Fossil SCM

Update the built-in SQLite to the latest trunk version from the 3.46.0 development cycle, for the purposing testing SQLite.

drh 2024-03-18 19:16 trunk
Commit 03e00a67d9f0aff6e03afd7efed9ee4370e6231e28fcc9957b41ab06d8705c00
Parent 6f532afa4710c5f…
3 files changed +45 -33 +3072 -2773 +1 -1
~ extsrc/shell.c ~ extsrc/sqlite3.c ~ extsrc/sqlite3.h
M extsrc/shell.c
+45 -33
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -26761,20 +26761,19 @@
2676126761
 }else
2676226762
2676326763
 #ifndef SQLITE_SHELL_FIDDLE
2676426764
 if( c=='i' && cli_strncmp(azArg[0], "import", n)==0 ){
2676526765
 char *zTable = 0; /* Insert data into this table */
26766
- char *zSchema = 0; /* within this schema (may default to "main") */
26766
+ char *zSchema = 0; /* Schema of zTable */
2676726767
 char *zFile = 0; /* Name of file to extra content from */
2676826768
 sqlite3_stmt *pStmt = NULL; /* A statement */
2676926769
 int nCol; /* Number of columns in the table */
26770
- int nByte; /* Number of bytes in an SQL string */
26770
+ i64 nByte; /* Number of bytes in an SQL string */
2677126771
 int i, j; /* Loop counters */
2677226772
 int needCommit; /* True to COMMIT or ROLLBACK at end */
2677326773
 int nSep; /* Number of bytes in p->colSeparator[] */
26774
- char *zSql; /* An SQL statement */
26775
- char *zFullTabName; /* Table name with schema if applicable */
26774
+ char *zSql = 0; /* An SQL statement */
2677626775
 ImportCtx sCtx; /* Reader context */
2677726776
 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
2677826777
 int eVerbose = 0; /* Larger for more console output */
2677926778
 int nSkip = 0; /* Initial lines to skip */
2678026779
 int useOutputMode = 1; /* Use output mode to determine separators */
@@ -26904,28 +26903,18 @@
2690426903
 }
2690526904
 /* Below, resources must be freed before exit. */
2690626905
 while( (nSkip--)>0 ){
2690726906
 while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){}
2690826907
 }
26909
- if( zSchema!=0 ){
26910
- zFullTabName = sqlite3_mprintf("\"%w\".\"%w\"", zSchema, zTable);
26911
- }else{
26912
- zFullTabName = sqlite3_mprintf("\"%w\"", zTable);
26913
- }
26914
- zSql = sqlite3_mprintf("SELECT * FROM %s", zFullTabName);
26915
- if( zSql==0 || zFullTabName==0 ){
26916
- import_cleanup(&sCtx);
26917
- shell_out_of_memory();
26918
- }
26919
- nByte = strlen30(zSql);
26920
- rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2692126908
 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
26922
- if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
26909
+ if( sqlite3_table_column_metadata(p->db, zSchema, zTable,0,0,0,0,0,0) ){
26910
+ /* Table does not exist. Create it. */
2692326911
 sqlite3 *dbCols = 0;
2692426912
 char *zRenames = 0;
2692526913
 char *zColDefs;
26926
- zCreate = sqlite3_mprintf("CREATE TABLE %s", zFullTabName);
26914
+ zCreate = sqlite3_mprintf("CREATE TABLE \"%w\".\"%w\"",
26915
+ zSchema ? zSchema : "main", zTable);
2692726916
 while( xRead(&sCtx) ){
2692826917
 zAutoColumn(sCtx.z, &dbCols, 0);
2692926918
 if( sCtx.cTerm!=sCtx.cColSep ) break;
2693026919
 }
2693126920
 zColDefs = zAutoColumn(0, &dbCols, &zRenames);
@@ -26936,47 +26925,68 @@
2693626925
 sqlite3_free(zRenames);
2693726926
 }
2693826927
 assert(dbCols==0);
2693926928
 if( zColDefs==0 ){
2694026929
 eputf("%s: empty file\n", sCtx.zFile);
26941
- import_fail:
26942
- sqlite3_free(zCreate);
26943
- sqlite3_free(zSql);
26944
- sqlite3_free(zFullTabName);
2694526930
 import_cleanup(&sCtx);
2694626931
 rc = 1;
2694726932
 goto meta_command_exit;
2694826933
 }
2694926934
 zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
26935
+ if( zCreate==0 ){
26936
+ import_cleanup(&sCtx);
26937
+ shell_out_of_memory();
26938
+ }
2695026939
 if( eVerbose>=1 ){
2695126940
 oputf("%s\n", zCreate);
2695226941
 }
2695326942
 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
26943
+ sqlite3_free(zCreate);
26944
+ zCreate = 0;
2695426945
 if( rc ){
2695526946
 eputf("%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
26956
- goto import_fail;
26947
+ import_cleanup(&sCtx);
26948
+ rc = 1;
26949
+ goto meta_command_exit;
2695726950
 }
26958
- sqlite3_free(zCreate);
26959
- zCreate = 0;
26960
- rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2696126951
 }
26952
+ zSql = sqlite3_mprintf("SELECT count(*) FROM pragma_table_info(%Q,%Q);",
26953
+ zTable, zSchema);
26954
+ if( zSql==0 ){
26955
+ import_cleanup(&sCtx);
26956
+ shell_out_of_memory();
26957
+ }
26958
+ nByte = strlen(zSql);
26959
+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26960
+ sqlite3_free(zSql);
26961
+ zSql = 0;
2696226962
 if( rc ){
2696326963
 if (pStmt) sqlite3_finalize(pStmt);
2696426964
 eputf("Error: %s\n", sqlite3_errmsg(p->db));
26965
- goto import_fail;
26965
+ import_cleanup(&sCtx);
26966
+ rc = 1;
26967
+ goto meta_command_exit;
2696626968
 }
26967
- sqlite3_free(zSql);
26968
- nCol = sqlite3_column_count(pStmt);
26969
+ if( sqlite3_step(pStmt)==SQLITE_ROW ){
26970
+ nCol = sqlite3_column_int(pStmt, 0);
26971
+ }else{
26972
+ nCol = 0;
26973
+ }
2696926974
 sqlite3_finalize(pStmt);
2697026975
 pStmt = 0;
2697126976
 if( nCol==0 ) return 0; /* no columns, no error */
2697226977
 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
2697326978
 if( zSql==0 ){
2697426979
 import_cleanup(&sCtx);
2697526980
 shell_out_of_memory();
2697626981
 }
26977
- sqlite3_snprintf(nByte+20, zSql, "INSERT INTO %s VALUES(?", zFullTabName);
26982
+ if( zSchema ){
26983
+ sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\".\"%w\" VALUES(?",
26984
+ zSchema, zTable);
26985
+ }else{
26986
+ sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
26987
+ }
2697826988
 j = strlen30(zSql);
2697926989
 for(i=1; i<nCol; i++){
2698026990
 zSql[j++] = ',';
2698126991
 zSql[j++] = '?';
2698226992
 }
@@ -26984,17 +26994,19 @@
2698426994
 zSql[j] = 0;
2698526995
 if( eVerbose>=2 ){
2698626996
 oputf("Insert using: %s\n", zSql);
2698726997
 }
2698826998
 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26999
+ sqlite3_free(zSql);
27000
+ zSql = 0;
2698927001
 if( rc ){
2699027002
 eputf("Error: %s\n", sqlite3_errmsg(p->db));
2699127003
 if (pStmt) sqlite3_finalize(pStmt);
26992
- goto import_fail;
27004
+ import_cleanup(&sCtx);
27005
+ rc = 1;
27006
+ goto meta_command_exit;
2699327007
 }
26994
- sqlite3_free(zSql);
26995
- sqlite3_free(zFullTabName);
2699627008
 needCommit = sqlite3_get_autocommit(p->db);
2699727009
 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
2699827010
 do{
2699927011
 int startLine = sCtx.nLine;
2700027012
 for(i=0; i<nCol; i++){
2700127013
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -26761,20 +26761,19 @@
26761 }else
26762
26763 #ifndef SQLITE_SHELL_FIDDLE
26764 if( c=='i' && cli_strncmp(azArg[0], "import", n)==0 ){
26765 char *zTable = 0; /* Insert data into this table */
26766 char *zSchema = 0; /* within this schema (may default to "main") */
26767 char *zFile = 0; /* Name of file to extra content from */
26768 sqlite3_stmt *pStmt = NULL; /* A statement */
26769 int nCol; /* Number of columns in the table */
26770 int nByte; /* Number of bytes in an SQL string */
26771 int i, j; /* Loop counters */
26772 int needCommit; /* True to COMMIT or ROLLBACK at end */
26773 int nSep; /* Number of bytes in p->colSeparator[] */
26774 char *zSql; /* An SQL statement */
26775 char *zFullTabName; /* Table name with schema if applicable */
26776 ImportCtx sCtx; /* Reader context */
26777 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
26778 int eVerbose = 0; /* Larger for more console output */
26779 int nSkip = 0; /* Initial lines to skip */
26780 int useOutputMode = 1; /* Use output mode to determine separators */
@@ -26904,28 +26903,18 @@
26904 }
26905 /* Below, resources must be freed before exit. */
26906 while( (nSkip--)>0 ){
26907 while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){}
26908 }
26909 if( zSchema!=0 ){
26910 zFullTabName = sqlite3_mprintf("\"%w\".\"%w\"", zSchema, zTable);
26911 }else{
26912 zFullTabName = sqlite3_mprintf("\"%w\"", zTable);
26913 }
26914 zSql = sqlite3_mprintf("SELECT * FROM %s", zFullTabName);
26915 if( zSql==0 || zFullTabName==0 ){
26916 import_cleanup(&sCtx);
26917 shell_out_of_memory();
26918 }
26919 nByte = strlen30(zSql);
26920 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26921 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
26922 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
 
26923 sqlite3 *dbCols = 0;
26924 char *zRenames = 0;
26925 char *zColDefs;
26926 zCreate = sqlite3_mprintf("CREATE TABLE %s", zFullTabName);
 
26927 while( xRead(&sCtx) ){
26928 zAutoColumn(sCtx.z, &dbCols, 0);
26929 if( sCtx.cTerm!=sCtx.cColSep ) break;
26930 }
26931 zColDefs = zAutoColumn(0, &dbCols, &zRenames);
@@ -26936,47 +26925,68 @@
26936 sqlite3_free(zRenames);
26937 }
26938 assert(dbCols==0);
26939 if( zColDefs==0 ){
26940 eputf("%s: empty file\n", sCtx.zFile);
26941 import_fail:
26942 sqlite3_free(zCreate);
26943 sqlite3_free(zSql);
26944 sqlite3_free(zFullTabName);
26945 import_cleanup(&sCtx);
26946 rc = 1;
26947 goto meta_command_exit;
26948 }
26949 zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
 
 
 
 
26950 if( eVerbose>=1 ){
26951 oputf("%s\n", zCreate);
26952 }
26953 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
 
 
26954 if( rc ){
26955 eputf("%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
26956 goto import_fail;
 
 
26957 }
26958 sqlite3_free(zCreate);
26959 zCreate = 0;
26960 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26961 }
 
 
 
 
 
 
 
 
 
 
26962 if( rc ){
26963 if (pStmt) sqlite3_finalize(pStmt);
26964 eputf("Error: %s\n", sqlite3_errmsg(p->db));
26965 goto import_fail;
 
 
26966 }
26967 sqlite3_free(zSql);
26968 nCol = sqlite3_column_count(pStmt);
 
 
 
26969 sqlite3_finalize(pStmt);
26970 pStmt = 0;
26971 if( nCol==0 ) return 0; /* no columns, no error */
26972 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
26973 if( zSql==0 ){
26974 import_cleanup(&sCtx);
26975 shell_out_of_memory();
26976 }
26977 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO %s VALUES(?", zFullTabName);
 
 
 
 
 
26978 j = strlen30(zSql);
26979 for(i=1; i<nCol; i++){
26980 zSql[j++] = ',';
26981 zSql[j++] = '?';
26982 }
@@ -26984,17 +26994,19 @@
26984 zSql[j] = 0;
26985 if( eVerbose>=2 ){
26986 oputf("Insert using: %s\n", zSql);
26987 }
26988 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
 
 
26989 if( rc ){
26990 eputf("Error: %s\n", sqlite3_errmsg(p->db));
26991 if (pStmt) sqlite3_finalize(pStmt);
26992 goto import_fail;
 
 
26993 }
26994 sqlite3_free(zSql);
26995 sqlite3_free(zFullTabName);
26996 needCommit = sqlite3_get_autocommit(p->db);
26997 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
26998 do{
26999 int startLine = sCtx.nLine;
27000 for(i=0; i<nCol; i++){
27001
--- extsrc/shell.c
+++ extsrc/shell.c
@@ -26761,20 +26761,19 @@
26761 }else
26762
26763 #ifndef SQLITE_SHELL_FIDDLE
26764 if( c=='i' && cli_strncmp(azArg[0], "import", n)==0 ){
26765 char *zTable = 0; /* Insert data into this table */
26766 char *zSchema = 0; /* Schema of zTable */
26767 char *zFile = 0; /* Name of file to extra content from */
26768 sqlite3_stmt *pStmt = NULL; /* A statement */
26769 int nCol; /* Number of columns in the table */
26770 i64 nByte; /* Number of bytes in an SQL string */
26771 int i, j; /* Loop counters */
26772 int needCommit; /* True to COMMIT or ROLLBACK at end */
26773 int nSep; /* Number of bytes in p->colSeparator[] */
26774 char *zSql = 0; /* An SQL statement */
 
26775 ImportCtx sCtx; /* Reader context */
26776 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
26777 int eVerbose = 0; /* Larger for more console output */
26778 int nSkip = 0; /* Initial lines to skip */
26779 int useOutputMode = 1; /* Use output mode to determine separators */
@@ -26904,28 +26903,18 @@
26903 }
26904 /* Below, resources must be freed before exit. */
26905 while( (nSkip--)>0 ){
26906 while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){}
26907 }
 
 
 
 
 
 
 
 
 
 
 
 
26908 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
26909 if( sqlite3_table_column_metadata(p->db, zSchema, zTable,0,0,0,0,0,0) ){
26910 /* Table does not exist. Create it. */
26911 sqlite3 *dbCols = 0;
26912 char *zRenames = 0;
26913 char *zColDefs;
26914 zCreate = sqlite3_mprintf("CREATE TABLE \"%w\".\"%w\"",
26915 zSchema ? zSchema : "main", zTable);
26916 while( xRead(&sCtx) ){
26917 zAutoColumn(sCtx.z, &dbCols, 0);
26918 if( sCtx.cTerm!=sCtx.cColSep ) break;
26919 }
26920 zColDefs = zAutoColumn(0, &dbCols, &zRenames);
@@ -26936,47 +26925,68 @@
26925 sqlite3_free(zRenames);
26926 }
26927 assert(dbCols==0);
26928 if( zColDefs==0 ){
26929 eputf("%s: empty file\n", sCtx.zFile);
 
 
 
 
26930 import_cleanup(&sCtx);
26931 rc = 1;
26932 goto meta_command_exit;
26933 }
26934 zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
26935 if( zCreate==0 ){
26936 import_cleanup(&sCtx);
26937 shell_out_of_memory();
26938 }
26939 if( eVerbose>=1 ){
26940 oputf("%s\n", zCreate);
26941 }
26942 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
26943 sqlite3_free(zCreate);
26944 zCreate = 0;
26945 if( rc ){
26946 eputf("%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
26947 import_cleanup(&sCtx);
26948 rc = 1;
26949 goto meta_command_exit;
26950 }
 
 
 
26951 }
26952 zSql = sqlite3_mprintf("SELECT count(*) FROM pragma_table_info(%Q,%Q);",
26953 zTable, zSchema);
26954 if( zSql==0 ){
26955 import_cleanup(&sCtx);
26956 shell_out_of_memory();
26957 }
26958 nByte = strlen(zSql);
26959 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26960 sqlite3_free(zSql);
26961 zSql = 0;
26962 if( rc ){
26963 if (pStmt) sqlite3_finalize(pStmt);
26964 eputf("Error: %s\n", sqlite3_errmsg(p->db));
26965 import_cleanup(&sCtx);
26966 rc = 1;
26967 goto meta_command_exit;
26968 }
26969 if( sqlite3_step(pStmt)==SQLITE_ROW ){
26970 nCol = sqlite3_column_int(pStmt, 0);
26971 }else{
26972 nCol = 0;
26973 }
26974 sqlite3_finalize(pStmt);
26975 pStmt = 0;
26976 if( nCol==0 ) return 0; /* no columns, no error */
26977 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
26978 if( zSql==0 ){
26979 import_cleanup(&sCtx);
26980 shell_out_of_memory();
26981 }
26982 if( zSchema ){
26983 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\".\"%w\" VALUES(?",
26984 zSchema, zTable);
26985 }else{
26986 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
26987 }
26988 j = strlen30(zSql);
26989 for(i=1; i<nCol; i++){
26990 zSql[j++] = ',';
26991 zSql[j++] = '?';
26992 }
@@ -26984,17 +26994,19 @@
26994 zSql[j] = 0;
26995 if( eVerbose>=2 ){
26996 oputf("Insert using: %s\n", zSql);
26997 }
26998 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26999 sqlite3_free(zSql);
27000 zSql = 0;
27001 if( rc ){
27002 eputf("Error: %s\n", sqlite3_errmsg(p->db));
27003 if (pStmt) sqlite3_finalize(pStmt);
27004 import_cleanup(&sCtx);
27005 rc = 1;
27006 goto meta_command_exit;
27007 }
 
 
27008 needCommit = sqlite3_get_autocommit(p->db);
27009 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
27010 do{
27011 int startLine = sCtx.nLine;
27012 for(i=0; i<nCol; i++){
27013
M extsrc/sqlite3.c
+3072 -2773
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
1616
 ** if you want a wrapper to interface SQLite with your choice of programming
1717
 ** language. The code for the "sqlite3" command-line shell is also in a
1818
 ** separate file. This file contains only code for the core SQLite library.
1919
 **
2020
 ** The content in this amalgamation comes from Fossil check-in
21
-** 7ead022edaf7a0cd6a8976a1261246084975.
21
+** 76fb3a908f45230b956cb659c754e47603e8.
2222
 */
2323
 #define SQLITE_CORE 1
2424
 #define SQLITE_AMALGAMATION 1
2525
 #ifndef SQLITE_PRIVATE
2626
 # define SQLITE_PRIVATE static
@@ -459,11 +459,11 @@
459459
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460460
 ** [sqlite_version()] and [sqlite_source_id()].
461461
 */
462462
 #define SQLITE_VERSION "3.46.0"
463463
 #define SQLITE_VERSION_NUMBER 3046000
464
-#define SQLITE_SOURCE_ID "2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f"
464
+#define SQLITE_SOURCE_ID "2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61"
465465
466466
 /*
467467
 ** CAPI3REF: Run-Time Library Version Numbers
468468
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
469469
 **
@@ -19173,14 +19173,16 @@
1917319173
 ** In the colUsed field, the high-order bit (bit 63) is set if the table
1917419174
 ** contains more than 63 columns and the 64-th or later column is used.
1917519175
 **
1917619176
 ** Union member validity:
1917719177
 **
19178
-** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc
19179
-** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy
19180
-** u2.pIBIndex fg.isIndexedBy && !fg.isCte
19181
-** u2.pCteUse fg.isCte && !fg.isIndexedBy
19178
+** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc
19179
+** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy
19180
+** u1.nRow !fg.isTabFunc && !fg.isIndexedBy
19181
+**
19182
+** u2.pIBIndex fg.isIndexedBy && !fg.isCte
19183
+** u2.pCteUse fg.isCte && !fg.isIndexedBy
1918219184
 */
1918319185
 struct SrcItem {
1918419186
 Schema *pSchema; /* Schema to which this item is fixed */
1918519187
 char *zDatabase; /* Name of database holding this table */
1918619188
 char *zName; /* Name of the table */
@@ -19214,10 +19216,11 @@
1921419216
 } u3;
1921519217
 Bitmask colUsed; /* Bit N set if column N used. Details above for N>62 */
1921619218
 union {
1921719219
 char *zIndexedBy; /* Identifier from "INDEXED BY <zIndex>" clause */
1921819220
 ExprList *pFuncArg; /* Arguments to table-valued-function */
19221
+ u32 nRow; /* Number of rows in a VALUES clause */
1921919222
 } u1;
1922019223
 union {
1922119224
 Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */
1922219225
 CteUse *pCteUse; /* CTE Usage info when fg.isCte is true */
1922319226
 } u2;
@@ -19715,10 +19718,11 @@
1971519718
 u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */
1971619719
 u8 okConstFactor; /* OK to factor out constants */
1971719720
 u8 disableLookaside; /* Number of times lookaside has been disabled */
1971819721
 u8 prepFlags; /* SQLITE_PREPARE_* flags */
1971919722
 u8 withinRJSubrtn; /* Nesting level for RIGHT JOIN body subroutines */
19723
+ u8 bHasWith; /* True if statement contains WITH */
1972019724
 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
1972119725
 u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */
1972219726
 #endif
1972319727
 #ifdef SQLITE_DEBUG
1972419728
 u8 ifNotExists; /* Might be true if IF NOT EXISTS. Assert()s only */
@@ -20389,10 +20393,13 @@
2038920393
 int regEndRowid;
2039020394
 u8 bExprArgs; /* Defer evaluation of window function arguments
2039120395
 ** due to the SQLITE_SUBTYPE flag */
2039220396
 };
2039320397
20398
+SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow);
20399
+SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
20400
+
2039420401
 #ifndef SQLITE_OMIT_WINDOWFUNC
2039520402
 SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*);
2039620403
 SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*);
2039720404
 SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p);
2039820405
 SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
@@ -20957,12 +20964,11 @@
2095720964
 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
2095820965
 SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
2095920966
 SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*);
2096020967
 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*);
2096120968
 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*);
20962
-SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
20963
-SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
20969
+SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse*,Expr*);
2096420970
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
2096520971
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
2096620972
 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int);
2096720973
 SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int);
2096820974
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -31896,10 +31902,14 @@
3189631902
 }else{
3189731903
 Select *pSel = pItem->pSelect;
3189831904
 assert( pSel!=0 );
3189931905
 if( pSel->selFlags & SF_NestedFrom ){
3190031906
 sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
31907
+ }else if( pSel->selFlags & SF_MultiValue ){
31908
+ assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy );
31909
+ sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE",
31910
+ pItem->u1.nRow);
3190131911
 }else{
3190231912
 sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId);
3190331913
 }
3190431914
 }
3190531915
 length = width = 0;
@@ -109036,13 +109046,14 @@
109036109046
 if( ExprHasProperty(pExpr, EP_Unlikely) ){
109037109047
 assert( ExprUseXList(pExpr) );
109038109048
 assert( pExpr->x.pList->nExpr>0 );
109039109049
 assert( pExpr->op==TK_FUNCTION );
109040109050
 pExpr = pExpr->x.pList->a[0].pExpr;
109041
- }else{
109042
- assert( pExpr->op==TK_COLLATE );
109051
+ }else if( pExpr->op==TK_COLLATE ){
109043109052
 pExpr = pExpr->pLeft;
109053
+ }else{
109054
+ break;
109044109055
 }
109045109056
 }
109046109057
 return pExpr;
109047109058
 }
109048109059
@@ -110687,10 +110698,11 @@
110687110698
 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
110688110699
 pNewItem->fg = pOldItem->fg;
110689110700
 pNewItem->iCursor = pOldItem->iCursor;
110690110701
 pNewItem->addrFillSub = pOldItem->addrFillSub;
110691110702
 pNewItem->regReturn = pOldItem->regReturn;
110703
+ pNewItem->regResult = pOldItem->regResult;
110692110704
 if( pNewItem->fg.isIndexedBy ){
110693110705
 pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
110694110706
 }
110695110707
 pNewItem->u2 = pOldItem->u2;
110696110708
 if( pNewItem->fg.isCte ){
@@ -111163,10 +111175,58 @@
111163111175
 }
111164111176
 }
111165111177
 return pExpr;
111166111178
 }
111167111179
111180
+/*
111181
+** pExpr is a TK_FUNCTION node. Try to determine whether or not the
111182
+** function is a constant function. A function is constant if all of
111183
+** the following are true:
111184
+**
111185
+** (1) It is a scalar function (not an aggregate or window function)
111186
+** (2) It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
111187
+** property.
111188
+** (3) All of its arguments are constants
111189
+**
111190
+** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
111191
+** It makes no changes to pWalker->eCode if pExpr is constant. In
111192
+** every case, it returns WRC_Abort.
111193
+**
111194
+** Called as a service subroutine from exprNodeIsConstant().
111195
+*/
111196
+static SQLITE_NOINLINE int exprNodeIsConstantFunction(
111197
+ Walker *pWalker,
111198
+ Expr *pExpr
111199
+){
111200
+ int n; /* Number of arguments */
111201
+ ExprList *pList; /* List of arguments */
111202
+ FuncDef *pDef; /* The function */
111203
+ sqlite3 *db; /* The database */
111204
+
111205
+ assert( pExpr->op==TK_FUNCTION );
111206
+ if( ExprHasProperty(pExpr, EP_TokenOnly)
111207
+ || (pList = pExpr->x.pList)==0
111208
+ ){;
111209
+ n = 0;
111210
+ }else{
111211
+ n = pList->nExpr;
111212
+ sqlite3WalkExprList(pWalker, pList);
111213
+ if( pWalker->eCode==0 ) return WRC_Abort;
111214
+ }
111215
+ db = pWalker->pParse->db;
111216
+ pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
111217
+ if( pDef==0
111218
+ || pDef->xFinalize!=0
111219
+ || (pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
111220
+ || ExprHasProperty(pExpr, EP_WinFunc)
111221
+ ){
111222
+ pWalker->eCode = 0;
111223
+ return WRC_Abort;
111224
+ }
111225
+ return WRC_Continue;
111226
+}
111227
+
111168111228
111169111229
 /*
111170111230
 ** These routines are Walker callbacks used to check expressions to
111171111231
 ** see if they are "constant" for some definition of constant. The
111172111232
 ** Walker.eCode value determines the type of "constant" we are looking
@@ -111191,10 +111251,11 @@
111191111251
 ** contain a bound parameter because they were generated by older versions
111192111252
 ** of SQLite to be parsed by newer versions of SQLite without raising a
111193111253
 ** malformed schema error.
111194111254
 */
111195111255
 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
111256
+ assert( pWalker->eCode>0 );
111196111257
111197111258
 /* If pWalker->eCode is 2 then any term of the expression that comes from
111198111259
 ** the ON or USING clauses of an outer join disqualifies the expression
111199111260
 ** from being considered constant. */
111200111261
 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
@@ -111210,10 +111271,12 @@
111210111271
 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
111211111272
 && !ExprHasProperty(pExpr, EP_WinFunc)
111212111273
 ){
111213111274
 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
111214111275
 return WRC_Continue;
111276
+ }else if( pWalker->pParse ){
111277
+ return exprNodeIsConstantFunction(pWalker, pExpr);
111215111278
 }else{
111216111279
 pWalker->eCode = 0;
111217111280
 return WRC_Abort;
111218111281
 }
111219111282
 case TK_ID:
@@ -111262,13 +111325,14 @@
111262111325
 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
111263111326
 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
111264111327
 return WRC_Continue;
111265111328
 }
111266111329
 }
111267
-static int exprIsConst(Expr *p, int initFlag, int iCur){
111330
+static int exprIsConst(Parse *pParse, Expr *p, int initFlag, int iCur){
111268111331
 Walker w;
111269111332
 w.eCode = initFlag;
111333
+ w.pParse = pParse;
111270111334
 w.xExprCallback = exprNodeIsConstant;
111271111335
 w.xSelectCallback = sqlite3SelectWalkFail;
111272111336
 #ifdef SQLITE_DEBUG
111273111337
 w.xSelectCallback2 = sqlite3SelectWalkAssert2;
111274111338
 #endif
@@ -111282,13 +111346,19 @@
111282111346
 ** and 0 if it involves variables or function calls.
111283111347
 **
111284111348
 ** For the purposes of this function, a double-quoted string (ex: "abc")
111285111349
 ** is considered a variable but a single-quoted string (ex: 'abc') is
111286111350
 ** a constant.
111351
+**
111352
+** The pParse parameter may be NULL. But if it is NULL, there is no way
111353
+** to determine if function calls are constant or not, and hence all
111354
+** function calls will be considered to be non-constant. If pParse is
111355
+** not NULL, then a function call might be constant, depending on the
111356
+** function and on its parameters.
111287111357
 */
111288
-SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
111289
- return exprIsConst(p, 1, 0);
111358
+SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse *pParse, Expr *p){
111359
+ return exprIsConst(pParse, p, 1, 0);
111290111360
 }
111291111361
111292111362
 /*
111293111363
 ** Walk an expression tree. Return non-zero if
111294111364
 **
@@ -111300,22 +111370,22 @@
111300111370
 **
111301111371
 ** When this routine returns true, it indicates that the expression
111302111372
 ** can be added to the pParse->pConstExpr list and evaluated once when
111303111373
 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
111304111374
 */
111305
-SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
111306
- return exprIsConst(p, 2, 0);
111375
+static int sqlite3ExprIsConstantNotJoin(Parse *pParse, Expr *p){
111376
+ return exprIsConst(pParse, p, 2, 0);
111307111377
 }
111308111378
111309111379
 /*
111310111380
 ** Walk an expression tree. Return non-zero if the expression is constant
111311111381
 ** for any single row of the table with cursor iCur. In other words, the
111312111382
 ** expression must not refer to any non-deterministic function nor any
111313111383
 ** table other than iCur.
111314111384
 */
111315111385
 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
111316
- return exprIsConst(p, 3, iCur);
111386
+ return exprIsConst(0, p, 3, iCur);
111317111387
 }
111318111388
111319111389
 /*
111320111390
 ** Check pExpr to see if it is an constraint on the single data source
111321111391
 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
@@ -111468,11 +111538,11 @@
111468111538
 ** is considered a variable but a single-quoted string (ex: 'abc') is
111469111539
 ** a constant.
111470111540
 */
111471111541
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){
111472111542
 assert( isInit==0 || isInit==1 );
111473
- return exprIsConst(p, 4+isInit, 0);
111543
+ return exprIsConst(0, p, 4+isInit, 0);
111474111544
 }
111475111545
111476111546
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
111477111547
 /*
111478111548
 ** Walk an expression tree. Return 1 if the expression contains a
@@ -111713,17 +111783,17 @@
111713111783
 #ifndef SQLITE_OMIT_SUBQUERY
111714111784
 /*
111715111785
 ** The argument is an IN operator with a list (not a subquery) on the
111716111786
 ** right-hand side. Return TRUE if that list is constant.
111717111787
 */
111718
-static int sqlite3InRhsIsConstant(Expr *pIn){
111788
+static int sqlite3InRhsIsConstant(Parse *pParse, Expr *pIn){
111719111789
 Expr *pLHS;
111720111790
 int res;
111721111791
 assert( !ExprHasProperty(pIn, EP_xIsSelect) );
111722111792
 pLHS = pIn->pLeft;
111723111793
 pIn->pLeft = 0;
111724
- res = sqlite3ExprIsConstant(pIn);
111794
+ res = sqlite3ExprIsConstant(pParse, pIn);
111725111795
 pIn->pLeft = pLHS;
111726111796
 return res;
111727111797
 }
111728111798
 #endif
111729111799
@@ -111988,11 +112058,11 @@
111988112058
 ** the IN operator so return IN_INDEX_NOOP.
111989112059
 */
111990112060
 if( eType==0
111991112061
 && (inFlags & IN_INDEX_NOOP_OK)
111992112062
 && ExprUseXList(pX)
111993
- && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
112063
+ && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
111994112064
 ){
111995112065
 pParse->nTab--; /* Back out the allocation of the unused cursor */
111996112066
 iTab = -1; /* Cursor is not allocated */
111997112067
 eType = IN_INDEX_NOOP;
111998112068
 }
@@ -112271,11 +112341,11 @@
112271112341
 /* If the expression is not constant then we will need to
112272112342
 ** disable the test that was generated above that makes sure
112273112343
 ** this code only executes once. Because for a non-constant
112274112344
 ** expression we need to rerun this code each time.
112275112345
 */
112276
- if( addrOnce && !sqlite3ExprIsConstant(pE2) ){
112346
+ if( addrOnce && !sqlite3ExprIsConstant(pParse, pE2) ){
112277112347
 sqlite3VdbeChangeToNoop(v, addrOnce-1);
112278112348
 sqlite3VdbeChangeToNoop(v, addrOnce);
112279112349
 ExprClearProperty(pExpr, EP_Subrtn);
112280112350
 addrOnce = 0;
112281112351
 }
@@ -113608,11 +113678,13 @@
113608113678
 if( ExprHasProperty(pExpr, EP_WinFunc) ){
113609113679
 return pExpr->y.pWin->regResult;
113610113680
 }
113611113681
 #endif
113612113682
113613
- if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
113683
+ if( ConstFactorOk(pParse)
113684
+ && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
113685
+ ){
113614113686
 /* SQL functions can be expensive. So try to avoid running them
113615113687
 ** multiple times if we know they always give the same result */
113616113688
 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113617113689
 }
113618113690
 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
@@ -113639,11 +113711,11 @@
113639113711
 }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){
113640113712
 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113641113713
 }
113642113714
113643113715
 for(i=0; i<nFarg; i++){
113644
- if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
113716
+ if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
113645113717
 testcase( i==31 );
113646113718
 constMask |= MASKBIT32(i);
113647113719
 }
113648113720
 if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
113649113721
 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
@@ -114106,11 +114178,11 @@
114106114178
 int r2;
114107114179
 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
114108114180
 if( ConstFactorOk(pParse)
114109114181
 && ALWAYS(pExpr!=0)
114110114182
 && pExpr->op!=TK_REGISTER
114111
- && sqlite3ExprIsConstantNotJoin(pExpr)
114183
+ && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
114112114184
 ){
114113114185
 *pReg = 0;
114114114186
 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114115114187
 }else{
114116114188
 int r1 = sqlite3GetTempReg(pParse);
@@ -114170,11 +114242,11 @@
114170114242
 ** results in register target. The results are guaranteed to appear
114171114243
 ** in register target. If the expression is constant, then this routine
114172114244
 ** might choose to code the expression at initialization time.
114173114245
 */
114174114246
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
114175
- if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
114247
+ if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
114176114248
 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
114177114249
 }else{
114178114250
 sqlite3ExprCodeCopy(pParse, pExpr, target);
114179114251
 }
114180114252
 }
@@ -114229,11 +114301,11 @@
114229114301
 n--;
114230114302
 }else{
114231114303
 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
114232114304
 }
114233114305
 }else if( (flags & SQLITE_ECEL_FACTOR)!=0
114234
- && sqlite3ExprIsConstantNotJoin(pExpr)
114306
+ && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
114235114307
 ){
114236114308
 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
114237114309
 }else{
114238114310
 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
114239114311
 if( inReg!=target+i ){
@@ -133152,10 +133224,197 @@
133152133224
 */
133153133225
 # define autoIncBegin(A,B,C) (0)
133154133226
 # define autoIncStep(A,B,C)
133155133227
 #endif /* SQLITE_OMIT_AUTOINCREMENT */
133156133228
133229
+/*
133230
+** If argument pVal is a Select object returned by an sqlite3MultiValues()
133231
+** that was able to use the co-routine optimization, finish coding the
133232
+** co-routine.
133233
+*/
133234
+SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
133235
+ if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
133236
+ SrcItem *pItem = &pVal->pSrc->a[0];
133237
+ sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->regReturn);
133238
+ sqlite3VdbeJumpHere(pParse->pVdbe, pItem->addrFillSub - 1);
133239
+ }
133240
+}
133241
+
133242
+/*
133243
+** Return true if all expressions in the expression-list passed as the
133244
+** only argument are constant.
133245
+*/
133246
+static int exprListIsConstant(Parse *pParse, ExprList *pRow){
133247
+ int ii;
133248
+ for(ii=0; ii<pRow->nExpr; ii++){
133249
+ if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
133250
+ }
133251
+ return 1;
133252
+}
133253
+
133254
+/*
133255
+** Return true if all expressions in the expression-list passed as the
133256
+** only argument are both constant and have no affinity.
133257
+*/
133258
+static int exprListIsNoAffinity(Parse *pParse, ExprList *pRow){
133259
+ int ii;
133260
+ if( exprListIsConstant(pParse,pRow)==0 ) return 0;
133261
+ for(ii=0; ii<pRow->nExpr; ii++){
133262
+ assert( pRow->a[ii].pExpr->affExpr==0 );
133263
+ if( 0!=sqlite3ExprAffinity(pRow->a[ii].pExpr) ) return 0;
133264
+ }
133265
+ return 1;
133266
+
133267
+}
133268
+
133269
+/*
133270
+** This function is called by the parser for the second and subsequent
133271
+** rows of a multi-row VALUES clause. Argument pLeft is the part of
133272
+** the VALUES clause already parsed, argument pRow is the vector of values
133273
+** for the new row. The Select object returned represents the complete
133274
+** VALUES clause, including the new row.
133275
+**
133276
+** There are two ways in which this may be achieved - by incremental
133277
+** coding of a co-routine (the "co-routine" method) or by returning a
133278
+** Select object equivalent to the following (the "UNION ALL" method):
133279
+**
133280
+** "pLeft UNION ALL SELECT pRow"
133281
+**
133282
+** If the VALUES clause contains a lot of rows, this compound Select
133283
+** object may consume a lot of memory.
133284
+**
133285
+** When the co-routine method is used, each row that will be returned
133286
+** by the VALUES clause is coded into part of a co-routine as it is
133287
+** passed to this function. The returned Select object is equivalent to:
133288
+**
133289
+** SELECT * FROM (
133290
+** Select object to read co-routine
133291
+** )
133292
+**
133293
+** The co-routine method is used in most cases. Exceptions are:
133294
+**
133295
+** a) If the current statement has a WITH clause. This is to avoid
133296
+** statements like:
133297
+**
133298
+** WITH cte AS ( VALUES('x'), ('y') ... )
133299
+** SELECT * FROM cte AS a, cte AS b;
133300
+**
133301
+** This will not work, as the co-routine uses a hard-coded register
133302
+** for its OP_Yield instructions, and so it is not possible for two
133303
+** cursors to iterate through it concurrently.
133304
+**
133305
+** b) The schema is currently being parsed (i.e. the VALUES clause is part
133306
+** of a schema item like a VIEW or TRIGGER). In this case there is no VM
133307
+** being generated when parsing is taking place, and so generating
133308
+** a co-routine is not possible.
133309
+**
133310
+** c) There are non-constant expressions in the VALUES clause (e.g.
133311
+** the VALUES clause is part of a correlated sub-query).
133312
+**
133313
+** d) One or more of the values in the first row of the VALUES clause
133314
+** has an affinity (i.e. is a CAST expression). This causes problems
133315
+** because the complex rules SQLite uses (see function
133316
+** sqlite3SubqueryColumnTypes() in select.c) to determine the effective
133317
+** affinity of such a column for all rows require access to all values in
133318
+** the column simultaneously.
133319
+*/
133320
+SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){
133321
+
133322
+ if( pParse->bHasWith /* condition (a) above */
133323
+ || pParse->db->init.busy /* condition (b) above */
133324
+ || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */
133325
+ || (pLeft->pSrc->nSrc==0 &&
133326
+ exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
133327
+ || IN_SPECIAL_PARSE
133328
+ ){
133329
+ /* The co-routine method cannot be used. Fall back to UNION ALL. */
133330
+ Select *pSelect = 0;
133331
+ int f = SF_Values | SF_MultiValue;
133332
+ if( pLeft->pSrc->nSrc ){
133333
+ sqlite3MultiValuesEnd(pParse, pLeft);
133334
+ f = SF_Values;
133335
+ }else if( pLeft->pPrior ){
133336
+ /* In this case set the SF_MultiValue flag only if it was set on pLeft */
133337
+ f = (f & pLeft->selFlags);
133338
+ }
133339
+ pSelect = sqlite3SelectNew(pParse, pRow, 0, 0, 0, 0, 0, f, 0);
133340
+ pLeft->selFlags &= ~SF_MultiValue;
133341
+ if( pSelect ){
133342
+ pSelect->op = TK_ALL;
133343
+ pSelect->pPrior = pLeft;
133344
+ pLeft = pSelect;
133345
+ }
133346
+ }else{
133347
+ SrcItem *p = 0; /* SrcItem that reads from co-routine */
133348
+
133349
+ if( pLeft->pSrc->nSrc==0 ){
133350
+ /* Co-routine has not yet been started and the special Select object
133351
+ ** that accesses the co-routine has not yet been created. This block
133352
+ ** does both those things. */
133353
+ Vdbe *v = sqlite3GetVdbe(pParse);
133354
+ Select *pRet = sqlite3SelectNew(pParse, 0, 0, 0, 0, 0, 0, 0, 0);
133355
+
133356
+ /* Ensure the database schema has been read. This is to ensure we have
133357
+ ** the correct text encoding. */
133358
+ if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
133359
+ sqlite3ReadSchema(pParse);
133360
+ }
133361
+
133362
+ if( pRet ){
133363
+ SelectDest dest;
133364
+ pRet->pSrc->nSrc = 1;
133365
+ pRet->pPrior = pLeft->pPrior;
133366
+ pRet->op = pLeft->op;
133367
+ pLeft->pPrior = 0;
133368
+ pLeft->op = TK_SELECT;
133369
+ assert( pLeft->pNext==0 );
133370
+ assert( pRet->pNext==0 );
133371
+ p = &pRet->pSrc->a[0];
133372
+ p->pSelect = pLeft;
133373
+ p->fg.viaCoroutine = 1;
133374
+ p->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
133375
+ p->regReturn = ++pParse->nMem;
133376
+ p->iCursor = -1;
133377
+ p->u1.nRow = 2;
133378
+ sqlite3VdbeAddOp3(v,OP_InitCoroutine,p->regReturn,0,p->addrFillSub);
133379
+ sqlite3SelectDestInit(&dest, SRT_Coroutine, p->regReturn);
133380
+
133381
+ /* Allocate registers for the output of the co-routine. Do so so
133382
+ ** that there are two unused registers immediately before those
133383
+ ** used by the co-routine. This allows the code in sqlite3Insert()
133384
+ ** to use these registers directly, instead of copying the output
133385
+ ** of the co-routine to a separate array for processing. */
133386
+ dest.iSdst = pParse->nMem + 3;
133387
+ dest.nSdst = pLeft->pEList->nExpr;
133388
+ pParse->nMem += 2 + dest.nSdst;
133389
+
133390
+ pLeft->selFlags |= SF_MultiValue;
133391
+ sqlite3Select(pParse, pLeft, &dest);
133392
+ p->regResult = dest.iSdst;
133393
+ assert( pParse->nErr || dest.iSdst>0 );
133394
+ pLeft = pRet;
133395
+ }
133396
+ }else{
133397
+ p = &pLeft->pSrc->a[0];
133398
+ assert( !p->fg.isTabFunc && !p->fg.isIndexedBy );
133399
+ p->u1.nRow++;
133400
+ }
133401
+
133402
+ if( pParse->nErr==0 ){
133403
+ assert( p!=0 );
133404
+ if( p->pSelect->pEList->nExpr!=pRow->nExpr ){
133405
+ sqlite3SelectWrongNumTermsError(pParse, p->pSelect);
133406
+ }else{
133407
+ sqlite3ExprCodeExprList(pParse, pRow, p->regResult, 0, 0);
133408
+ sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, p->regReturn);
133409
+ }
133410
+ }
133411
+ sqlite3ExprListDelete(pParse->db, pRow);
133412
+ }
133413
+
133414
+ return pLeft;
133415
+}
133157133416
133158133417
 /* Forward declaration */
133159133418
 static int xferOptimization(
133160133419
 Parse *pParse, /* Parser context */
133161133420
 Table *pDest, /* The table we are inserting into */
@@ -133488,29 +133747,44 @@
133488133747
 ** co-routine is the common header to the 3rd and 4th templates.
133489133748
 */
133490133749
 if( pSelect ){
133491133750
 /* Data is coming from a SELECT or from a multi-row VALUES clause.
133492133751
 ** Generate a co-routine to run the SELECT. */
133493
- int regYield; /* Register holding co-routine entry-point */
133494
- int addrTop; /* Top of the co-routine */
133495133752
 int rc; /* Result code */
133496133753
133497
- regYield = ++pParse->nMem;
133498
- addrTop = sqlite3VdbeCurrentAddr(v) + 1;
133499
- sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
133500
- sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
133501
- dest.iSdst = bIdListInOrder ? regData : 0;
133502
- dest.nSdst = pTab->nCol;
133503
- rc = sqlite3Select(pParse, pSelect, &dest);
133504
- regFromSelect = dest.iSdst;
133505
- assert( db->pParse==pParse );
133506
- if( rc || pParse->nErr ) goto insert_cleanup;
133507
- assert( db->mallocFailed==0 );
133508
- sqlite3VdbeEndCoroutine(v, regYield);
133509
- sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
133510
- assert( pSelect->pEList );
133511
- nColumn = pSelect->pEList->nExpr;
133754
+ if( pSelect->pSrc->nSrc==1
133755
+ && pSelect->pSrc->a[0].fg.viaCoroutine
133756
+ && pSelect->pPrior==0
133757
+ ){
133758
+ SrcItem *pItem = &pSelect->pSrc->a[0];
133759
+ dest.iSDParm = pItem->regReturn;
133760
+ regFromSelect = pItem->regResult;
133761
+ nColumn = pItem->pSelect->pEList->nExpr;
133762
+ ExplainQueryPlan((pParse, 0, "SCAN %S", pItem));
133763
+ if( bIdListInOrder && nColumn==pTab->nCol ){
133764
+ regData = regFromSelect;
133765
+ regRowid = regData - 1;
133766
+ regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
133767
+ }
133768
+ }else{
133769
+ int addrTop; /* Top of the co-routine */
133770
+ int regYield = ++pParse->nMem;
133771
+ addrTop = sqlite3VdbeCurrentAddr(v) + 1;
133772
+ sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
133773
+ sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
133774
+ dest.iSdst = bIdListInOrder ? regData : 0;
133775
+ dest.nSdst = pTab->nCol;
133776
+ rc = sqlite3Select(pParse, pSelect, &dest);
133777
+ regFromSelect = dest.iSdst;
133778
+ assert( db->pParse==pParse );
133779
+ if( rc || pParse->nErr ) goto insert_cleanup;
133780
+ assert( db->mallocFailed==0 );
133781
+ sqlite3VdbeEndCoroutine(v, regYield);
133782
+ sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
133783
+ assert( pSelect->pEList );
133784
+ nColumn = pSelect->pEList->nExpr;
133785
+ }
133512133786
133513133787
 /* Set useTempTable to TRUE if the result of the SELECT statement
133514133788
 ** should be written into a temporary table (template 4). Set to
133515133789
 ** FALSE if each output row of the SELECT can be written directly into
133516133790
 ** the destination table (template 3).
@@ -147133,11 +147407,11 @@
147133147407
 Expr *pValue, /* The VALUE part of the constraint */
147134147408
 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
147135147409
 ){
147136147410
 int i;
147137147411
 assert( pColumn->op==TK_COLUMN );
147138
- assert( sqlite3ExprIsConstant(pValue) );
147412
+ assert( sqlite3ExprIsConstant(pConst->pParse, pValue) );
147139147413
147140147414
 if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
147141147415
 if( sqlite3ExprAffinity(pValue)!=0 ) return;
147142147416
 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147143147417
 return;
@@ -147191,14 +147465,14 @@
147191147465
 if( pExpr->op!=TK_EQ ) return;
147192147466
 pRight = pExpr->pRight;
147193147467
 pLeft = pExpr->pLeft;
147194147468
 assert( pRight!=0 );
147195147469
 assert( pLeft!=0 );
147196
- if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
147470
+ if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pLeft) ){
147197147471
 constInsert(pConst,pRight,pLeft,pExpr);
147198147472
 }
147199
- if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
147473
+ if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pRight) ){
147200147474
 constInsert(pConst,pLeft,pRight,pExpr);
147201147475
 }
147202147476
 }
147203147477
147204147478
 /*
@@ -149993,11 +150267,11 @@
149993150267
149994150268
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
149995150269
 /* Generate code for all sub-queries in the FROM clause
149996150270
 */
149997150271
 pSub = pItem->pSelect;
149998
- if( pSub==0 ) continue;
150272
+ if( pSub==0 || pItem->addrFillSub!=0 ) continue;
149999150273
150000150274
 /* The code for a subquery should only be generated once. */
150001150275
 assert( pItem->addrFillSub==0 );
150002150276
150003150277
 /* Increment Parse.nHeight by the height of the largest expression
@@ -160532,11 +160806,11 @@
160532160806
 if( pIdx->aColExpr==0 ) continue;
160533160807
 for(i=0; i<pIdx->nKeyCol; i++){
160534160808
 if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
160535160809
 assert( pIdx->bHasExpr );
160536160810
 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
160537
- && !sqlite3ExprIsConstant(pIdx->aColExpr->a[i].pExpr)
160811
+ && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
160538160812
 ){
160539160813
 aiCurCol[0] = iCur;
160540160814
 aiCurCol[1] = XN_EXPR;
160541160815
 return 1;
160542160816
 }
@@ -162745,11 +163019,11 @@
162745163019
 for(i=0; i<n; i++){
162746163020
 Expr *pExpr = pOrderBy->a[i].pExpr;
162747163021
 Expr *pE2;
162748163022
162749163023
 /* Skip over constant terms in the ORDER BY clause */
162750
- if( sqlite3ExprIsConstant(pExpr) ){
163024
+ if( sqlite3ExprIsConstant(0, pExpr) ){
162751163025
 continue;
162752163026
 }
162753163027
162754163028
 /* Virtual tables are unable to deal with NULLS FIRST */
162755163029
 if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break;
@@ -162857,11 +163131,11 @@
162857163131
 }
162858163132
 assert( j==nTerm );
162859163133
 pIdxInfo->nConstraint = j;
162860163134
 for(i=j=0; i<nOrderBy; i++){
162861163135
 Expr *pExpr = pOrderBy->a[i].pExpr;
162862
- if( sqlite3ExprIsConstant(pExpr) ) continue;
163136
+ if( sqlite3ExprIsConstant(0, pExpr) ) continue;
162863163137
 assert( pExpr->op==TK_COLUMN
162864163138
 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
162865163139
 && pExpr->iColumn==pExpr->pLeft->iColumn) );
162866163140
 pIdxOrderBy[j].iColumn = pExpr->iColumn;
162867163141
 pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC;
@@ -165039,11 +165313,11 @@
165039165313
 Expr *pLeft = pPart->pLeft;
165040165314
 Expr *pRight = pPart->pRight;
165041165315
 u8 aff;
165042165316
165043165317
 if( pLeft->op!=TK_COLUMN ) return;
165044
- if( !sqlite3ExprIsConstant(pRight) ) return;
165318
+ if( !sqlite3ExprIsConstant(0, pRight) ) return;
165045165319
 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
165046165320
 if( pLeft->iColumn<0 ) return;
165047165321
 aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
165048165322
 if( aff>=SQLITE_AFF_TEXT ){
165049165323
 if( pItem ){
@@ -166413,11 +166687,11 @@
166413166687
 Expr *p;
166414166688
 Bitmask mTerm;
166415166689
 if( MASKBIT(i) & obSat ) continue;
166416166690
 p = pOrderBy->a[i].pExpr;
166417166691
 mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
166418
- if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
166692
+ if( mTerm==0 && !sqlite3ExprIsConstant(0,p) ) continue;
166419166693
 if( (mTerm&~orderDistinctMask)==0 ){
166420166694
 obSat |= MASKBIT(i);
166421166695
 }
166422166696
 }
166423166697
 }
@@ -167282,11 +167556,11 @@
167282167556
 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
167283167557
 bMaybeNullRow = 0;
167284167558
 }else{
167285167559
 continue;
167286167560
 }
167287
- if( sqlite3ExprIsConstant(pExpr) ) continue;
167561
+ if( sqlite3ExprIsConstant(0,pExpr) ) continue;
167288167562
 if( pExpr->op==TK_FUNCTION ){
167289167563
 /* Functions that might set a subtype should not be replaced by the
167290167564
 ** value taken from an expression index since the index omits the
167291167565
 ** subtype. https://sqlite.org/forum/forumpost/68d284c86b082c3e */
167292167566
 int n;
@@ -167560,11 +167834,15 @@
167560167834
 if( (wctrlFlags & WHERE_WANT_DISTINCT)!=0
167561167835
 && OptimizationEnabled(db, SQLITE_DistinctOpt)
167562167836
 ){
167563167837
 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
167564167838
 }
167565
- ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
167839
+ if( ALWAYS(pWInfo->pSelect)
167840
+ && (pWInfo->pSelect->selFlags & SF_MultiValue)==0
167841
+ ){
167842
+ ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
167843
+ }
167566167844
 }else{
167567167845
 /* Assign a bit from the bitmask to every term in the FROM clause.
167568167846
 **
167569167847
 ** The N-th term of the FROM clause is assigned a bitmask of 1<<N.
167570167848
 **
@@ -168312,10 +168590,11 @@
168312168590
 ** the co-routine into OP_Copy of result contained in a register.
168313168591
 ** OP_Rowid becomes OP_Null.
168314168592
 */
168315168593
 if( pTabItem->fg.viaCoroutine ){
168316168594
 testcase( pParse->db->mallocFailed );
168595
+ assert( pTabItem->regResult>=0 );
168317168596
 translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
168318168597
 pTabItem->regResult, 0);
168319168598
 continue;
168320168599
 }
168321168600
@@ -169616,11 +169895,11 @@
169616169895
 ** constant, change it to NULL. The fact that it is then a non-negative
169617169896
 ** integer will be caught later. But it is important not to leave
169618169897
 ** variable values in the expression tree.
169619169898
 */
169620169899
 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
169621
- if( 0==sqlite3ExprIsConstant(pExpr) ){
169900
+ if( 0==sqlite3ExprIsConstant(0,pExpr) ){
169622169901
 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
169623169902
 sqlite3ExprDelete(pParse->db, pExpr);
169624169903
 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
169625169904
 }
169626169905
 return pExpr;
@@ -172042,35 +172321,35 @@
172042172321
 #ifndef INTERFACE
172043172322
 # define INTERFACE 1
172044172323
 #endif
172045172324
 /************* Begin control #defines *****************************************/
172046172325
 #define YYCODETYPE unsigned short int
172047
-#define YYNOCODE 320
172326
+#define YYNOCODE 322
172048172327
 #define YYACTIONTYPE unsigned short int
172049172328
 #define YYWILDCARD 101
172050172329
 #define sqlite3ParserTOKENTYPE Token
172051172330
 typedef union {
172052172331
 int yyinit;
172053172332
 sqlite3ParserTOKENTYPE yy0;
172054
- Expr* yy2;
172055
- Window* yy3;
172056
- Cte* yy79;
172057
- int yy92;
172058
- With* yy131;
172059
- struct TrigEvent yy210;
172060
- Upsert* yy258;
172061
- Select* yy299;
172062
- OnOrUsing yy305;
172063
- struct FrameBound yy337;
172064
- TriggerStep* yy347;
172065
- struct {int value; int mask;} yy367;
172066
- SrcList* yy387;
172067
- IdList* yy400;
172068
- ExprList* yy402;
172069
- u8 yy498;
172070
- u32 yy527;
172071
- const char* yy616;
172333
+ ExprList* yy14;
172334
+ With* yy59;
172335
+ Cte* yy67;
172336
+ Upsert* yy122;
172337
+ IdList* yy132;
172338
+ int yy144;
172339
+ const char* yy168;
172340
+ SrcList* yy203;
172341
+ Window* yy211;
172342
+ OnOrUsing yy269;
172343
+ struct TrigEvent yy286;
172344
+ struct {int value; int mask;} yy383;
172345
+ u32 yy391;
172346
+ TriggerStep* yy427;
172347
+ Expr* yy454;
172348
+ u8 yy462;
172349
+ struct FrameBound yy509;
172350
+ Select* yy555;
172072172351
 } YYMINORTYPE;
172073172352
 #ifndef YYSTACKDEPTH
172074172353
 #define YYSTACKDEPTH 100
172075172354
 #endif
172076172355
 #define sqlite3ParserARG_SDECL
@@ -172085,24 +172364,24 @@
172085172364
 #define sqlite3ParserCTX_PDECL ,Parse *pParse
172086172365
 #define sqlite3ParserCTX_PARAM ,pParse
172087172366
 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
172088172367
 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
172089172368
 #define YYFALLBACK 1
172090
-#define YYNSTATE 579
172091
-#define YYNRULE 406
172092
-#define YYNRULE_WITH_ACTION 341
172369
+#define YYNSTATE 583
172370
+#define YYNRULE 409
172371
+#define YYNRULE_WITH_ACTION 344
172093172372
 #define YYNTOKEN 186
172094
-#define YY_MAX_SHIFT 578
172095
-#define YY_MIN_SHIFTREDUCE 839
172096
-#define YY_MAX_SHIFTREDUCE 1244
172097
-#define YY_ERROR_ACTION 1245
172098
-#define YY_ACCEPT_ACTION 1246
172099
-#define YY_NO_ACTION 1247
172100
-#define YY_MIN_REDUCE 1248
172101
-#define YY_MAX_REDUCE 1653
172373
+#define YY_MAX_SHIFT 582
172374
+#define YY_MIN_SHIFTREDUCE 845
172375
+#define YY_MAX_SHIFTREDUCE 1253
172376
+#define YY_ERROR_ACTION 1254
172377
+#define YY_ACCEPT_ACTION 1255
172378
+#define YY_NO_ACTION 1256
172379
+#define YY_MIN_REDUCE 1257
172380
+#define YY_MAX_REDUCE 1665
172102172381
 #define YY_MIN_DSTRCTR 205
172103
-#define YY_MAX_DSTRCTR 317
172382
+#define YY_MAX_DSTRCTR 319
172104172383
 /************* End control #defines *******************************************/
172105172384
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
172106172385
172107172386
 /* Define the yytestcase() macro to be a no-op if is not already defined
172108172387
 ** otherwise.
@@ -172181,626 +172460,634 @@
172181172460
 ** yy_reduce_ofst[] For each state, the offset into yy_action for
172182172461
 ** shifting non-terminals after a reduce.
172183172462
 ** yy_default[] Default action for each state.
172184172463
 **
172185172464
 *********** Begin parsing tables **********************************************/
172186
-#define YY_ACTTAB_COUNT (2114)
172465
+#define YY_ACTTAB_COUNT (2142)
172187172466
 static const YYACTIONTYPE yy_action[] = {
172188
- /* 0 */ 572, 210, 572, 119, 116, 231, 572, 119, 116, 231,
172189
- /* 10 */ 572, 1319, 379, 1298, 410, 566, 566, 566, 572, 411,
172190
- /* 20 */ 380, 1319, 1281, 42, 42, 42, 42, 210, 1531, 72,
172191
- /* 30 */ 72, 975, 421, 42, 42, 495, 305, 281, 305, 976,
172192
- /* 40 */ 399, 72, 72, 126, 127, 81, 1219, 1219, 1055, 1058,
172193
- /* 50 */ 1045, 1045, 124, 124, 125, 125, 125, 125, 480, 411,
172194
- /* 60 */ 1246, 1, 1, 578, 2, 1250, 554, 119, 116, 231,
172195
- /* 70 */ 319, 484, 147, 484, 528, 119, 116, 231, 533, 1332,
172196
- /* 80 */ 419, 527, 143, 126, 127, 81, 1219, 1219, 1055, 1058,
172197
- /* 90 */ 1045, 1045, 124, 124, 125, 125, 125, 125, 119, 116,
172198
- /* 100 */ 231, 329, 123, 123, 123, 123, 122, 122, 121, 121,
172199
- /* 110 */ 121, 120, 117, 448, 286, 286, 286, 286, 446, 446,
172200
- /* 120 */ 446, 1570, 378, 1572, 1195, 377, 1165, 569, 1165, 569,
172201
- /* 130 */ 411, 1570, 541, 261, 228, 448, 102, 146, 453, 318,
172202
- /* 140 */ 563, 242, 123, 123, 123, 123, 122, 122, 121, 121,
172203
- /* 150 */ 121, 120, 117, 448, 126, 127, 81, 1219, 1219, 1055,
172204
- /* 160 */ 1058, 1045, 1045, 124, 124, 125, 125, 125, 125, 143,
172205
- /* 170 */ 296, 1195, 341, 452, 121, 121, 121, 120, 117, 448,
172206
- /* 180 */ 128, 1195, 1196, 1195, 149, 445, 444, 572, 120, 117,
172207
- /* 190 */ 448, 125, 125, 125, 125, 118, 123, 123, 123, 123,
172208
- /* 200 */ 122, 122, 121, 121, 121, 120, 117, 448, 458, 1284,
172209
- /* 210 */ 13, 13, 130, 123, 123, 123, 123, 122, 122, 121,
172210
- /* 220 */ 121, 121, 120, 117, 448, 424, 318, 563, 1195, 1196,
172211
- /* 230 */ 1195, 162, 1227, 411, 1227, 125, 125, 125, 125, 123,
172212
- /* 240 */ 123, 123, 123, 122, 122, 121, 121, 121, 120, 117,
172213
- /* 250 */ 448, 469, 344, 1042, 1042, 1056, 1059, 126, 127, 81,
172214
- /* 260 */ 1219, 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125,
172215
- /* 270 */ 125, 125, 1102, 1102, 492, 1195, 572, 411, 226, 519,
172216
- /* 280 */ 177, 83, 84, 123, 123, 123, 123, 122, 122, 121,
172217
- /* 290 */ 121, 121, 120, 117, 448, 1011, 408, 407, 1195, 72,
172218
- /* 300 */ 72, 126, 127, 81, 1219, 1219, 1055, 1058, 1045, 1045,
172219
- /* 310 */ 124, 124, 125, 125, 125, 125, 123, 123, 123, 123,
172220
- /* 320 */ 122, 122, 121, 121, 121, 120, 117, 448, 1046, 1615,
172221
- /* 330 */ 1195, 905, 1195, 1196, 1195, 254, 314, 401, 508, 505,
172222
- /* 340 */ 504, 112, 564, 570, 4, 930, 930, 435, 503, 342,
172223
- /* 350 */ 464, 330, 362, 517, 327, 1195, 1196, 1195, 567, 572,
172224
- /* 360 */ 123, 123, 123, 123, 122, 122, 121, 121, 121, 120,
172225
- /* 370 */ 117, 448, 286, 286, 844, 845, 846, 445, 444, 1198,
172226
- /* 380 */ 411, 449, 72, 72, 12, 569, 1224, 1195, 1196, 1195,
172227
- /* 390 */ 86, 1226, 273, 561, 1440, 520, 520, 572, 375, 1225,
172228
- /* 400 */ 6, 1283, 476, 143, 126, 127, 81, 1219, 1219, 1055,
172229
- /* 410 */ 1058, 1045, 1045, 124, 124, 125, 125, 125, 125, 554,
172230
- /* 420 */ 13, 13, 1032, 511, 1227, 1195, 1227, 553, 110, 110,
172231
- /* 430 */ 224, 572, 371, 1583, 572, 429, 111, 1198, 449, 573,
172232
- /* 440 */ 449, 432, 375, 1020, 1495, 555, 155, 272, 289, 370,
172233
- /* 450 */ 514, 365, 513, 259, 72, 72, 547, 72, 72, 361,
172234
- /* 460 */ 318, 563, 485, 123, 123, 123, 123, 122, 122, 121,
172235
- /* 470 */ 121, 121, 120, 117, 448, 1020, 1020, 1022, 1023, 28,
172236
- /* 480 */ 286, 286, 1195, 1196, 1195, 1160, 1616, 210, 411, 1610,
172237
- /* 490 */ 158, 554, 358, 569, 554, 390, 537, 1291, 1160, 437,
172238
- /* 500 */ 404, 1160, 556, 1565, 572, 1179, 572, 6, 9, 1557,
172239
- /* 510 */ 264, 216, 126, 127, 81, 1219, 1219, 1055, 1058, 1045,
172240
- /* 520 */ 1045, 124, 124, 125, 125, 125, 125, 13, 13, 13,
172241
- /* 530 */ 13, 411, 577, 254, 1250, 509, 508, 505, 504, 319,
172242
- /* 540 */ 224, 147, 431, 1011, 304, 1215, 503, 219, 1332, 1324,
172243
- /* 550 */ 1324, 143, 375, 1557, 536, 126, 127, 81, 1219, 1219,
172244
- /* 560 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172245
- /* 570 */ 1559, 123, 123, 123, 123, 122, 122, 121, 121, 121,
172246
- /* 580 */ 120, 117, 448, 286, 286, 122, 122, 121, 121, 121,
172247
- /* 590 */ 120, 117, 448, 1586, 1195, 177, 569, 342, 1195, 386,
172248
- /* 600 */ 154, 382, 411, 1215, 571, 547, 880, 192, 318, 563,
172249
- /* 610 */ 242, 193, 1322, 1322, 123, 123, 123, 123, 122, 122,
172250
- /* 620 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172251
- /* 630 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172252
- /* 640 */ 125, 411, 452, 941, 1195, 873, 1272, 376, 1195, 1272,
172253
- /* 650 */ 856, 1195, 1196, 1195, 421, 1195, 1196, 1195, 1270, 574,
172254
- /* 660 */ 572, 574, 33, 1557, 99, 126, 127, 81, 1219, 1219,
172255
- /* 670 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172256
- /* 680 */ 1355, 415, 963, 13, 13, 123, 123, 123, 123, 122,
172257
- /* 690 */ 122, 121, 121, 121, 120, 117, 448, 526, 436, 1195,
172258
- /* 700 */ 421, 1195, 1196, 1195, 1195, 1195, 1196, 1195, 1195, 467,
172259
- /* 710 */ 545, 545, 411, 375, 373, 6, 1178, 5, 548, 548,
172260
- /* 720 */ 16, 16, 3, 208, 123, 123, 123, 123, 122, 122,
172261
- /* 730 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172262
- /* 740 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172263
- /* 750 */ 125, 411, 1077, 430, 1195, 1033, 1195, 1196, 1195, 1195,
172264
- /* 760 */ 532, 1195, 1196, 1195, 489, 1195, 1196, 1195, 486, 209,
172265
- /* 770 */ 572, 375, 229, 1647, 397, 126, 127, 81, 1219, 1219,
172266
- /* 780 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172267
- /* 790 */ 1487, 572, 962, 13, 13, 123, 123, 123, 123, 122,
172268
- /* 800 */ 122, 121, 121, 121, 120, 117, 448, 1424, 202, 572,
172269
- /* 810 */ 384, 1195, 1196, 1195, 13, 13, 1195, 1196, 1195, 156,
172270
- /* 820 */ 199, 459, 411, 283, 1558, 961, 1016, 1541, 292, 203,
172271
- /* 830 */ 301, 896, 72, 72, 123, 123, 123, 123, 122, 122,
172272
- /* 840 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172273
- /* 850 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172274
- /* 860 */ 125, 411, 512, 286, 286, 286, 286, 280, 280, 315,
172275
- /* 870 */ 897, 287, 287, 461, 101, 98, 569, 426, 569, 572,
172276
- /* 880 */ 569, 288, 1557, 409, 569, 126, 127, 81, 1219, 1219,
172277
- /* 890 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172278
- /* 900 */ 572, 12, 13, 13, 531, 123, 123, 123, 123, 122,
172279
- /* 910 */ 122, 121, 121, 121, 120, 117, 448, 549, 230, 1590,
172280
- /* 920 */ 578, 2, 1250, 71, 71, 1160, 433, 319, 356, 147,
172281
- /* 930 */ 495, 1563, 411, 318, 563, 6, 1332, 1543, 1160, 1357,
172282
- /* 940 */ 313, 1160, 1330, 961, 123, 123, 123, 123, 122, 122,
172283
- /* 950 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172284
- /* 960 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172285
- /* 970 */ 125, 286, 286, 572, 205, 1530, 411, 286, 286, 468,
172286
- /* 980 */ 257, 256, 255, 1097, 569, 385, 495, 876, 529, 351,
172287
- /* 990 */ 569, 354, 1141, 1645, 1302, 1645, 72, 72, 242, 1268,
172288
- /* 1000 */ 1604, 105, 81, 1219, 1219, 1055, 1058, 1045, 1045, 124,
172289
- /* 1010 */ 124, 125, 125, 125, 125, 123, 123, 123, 123, 122,
172290
- /* 1020 */ 122, 121, 121, 121, 120, 117, 448, 572, 1032, 572,
172291
- /* 1030 */ 452, 1494, 572, 443, 286, 286, 1141, 1646, 1424, 1646,
172292
- /* 1040 */ 521, 495, 523, 1118, 876, 1021, 334, 569, 495, 1020,
172293
- /* 1050 */ 72, 72, 52, 52, 101, 134, 134, 1439, 1119, 123,
172294
- /* 1060 */ 123, 123, 123, 122, 122, 121, 121, 121, 120, 117,
172295
- /* 1070 */ 448, 1139, 108, 1120, 936, 286, 286, 286, 286, 935,
172296
- /* 1080 */ 457, 1020, 1020, 1022, 98, 530, 1331, 447, 569, 522,
172297
- /* 1090 */ 569, 484, 411, 1327, 916, 371, 1583, 211, 457, 456,
172298
- /* 1100 */ 469, 344, 460, 109, 917, 107, 460, 331, 427, 333,
172299
- /* 1110 */ 572, 1179, 411, 531, 1438, 1139, 126, 127, 81, 1219,
172300
- /* 1120 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172301
- /* 1130 */ 125, 1564, 411, 136, 136, 6, 126, 127, 81, 1219,
172302
- /* 1140 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172303
- /* 1150 */ 125, 152, 371, 1583, 1500, 887, 126, 115, 81, 1219,
172304
- /* 1160 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172305
- /* 1170 */ 125, 457, 1500, 1502, 478, 123, 123, 123, 123, 122,
172306
- /* 1180 */ 122, 121, 121, 121, 120, 117, 448, 500, 868, 1214,
172307
- /* 1190 */ 303, 332, 454, 557, 1160, 123, 123, 123, 123, 122,
172308
- /* 1200 */ 122, 121, 121, 121, 120, 117, 448, 1160, 1562, 572,
172309
- /* 1210 */ 1160, 543, 6, 572, 258, 123, 123, 123, 123, 122,
172310
- /* 1220 */ 122, 121, 121, 121, 120, 117, 448, 1032, 286, 286,
172311
- /* 1230 */ 542, 572, 56, 56, 1561, 411, 57, 57, 6, 1171,
172312
- /* 1240 */ 474, 569, 478, 295, 1021, 1500, 868, 295, 1020, 294,
172313
- /* 1250 */ 495, 264, 1099, 572, 15, 15, 1099, 1195, 396, 1240,
172314
- /* 1260 */ 127, 81, 1219, 1219, 1055, 1058, 1045, 1045, 124, 124,
172315
- /* 1270 */ 125, 125, 125, 125, 1160, 218, 44, 44, 572, 1118,
172316
- /* 1280 */ 1020, 1020, 1022, 416, 572, 544, 1215, 1160, 490, 572,
172317
- /* 1290 */ 1160, 1171, 1424, 373, 1119, 349, 478, 1539, 529, 361,
172318
- /* 1300 */ 322, 58, 58, 235, 516, 478, 219, 45, 45, 1120,
172319
- /* 1310 */ 1179, 572, 59, 59, 1195, 1196, 1195, 297, 123, 123,
172320
- /* 1320 */ 123, 123, 122, 122, 121, 121, 121, 120, 117, 448,
172321
- /* 1330 */ 560, 936, 440, 572, 60, 60, 935, 1241, 112, 564,
172322
- /* 1340 */ 572, 4, 572, 535, 1215, 572, 1424, 1424, 1235, 572,
172323
- /* 1350 */ 961, 396, 1140, 572, 31, 567, 61, 61, 112, 564,
172324
- /* 1360 */ 572, 4, 428, 62, 62, 63, 63, 8, 46, 46,
172325
- /* 1370 */ 572, 300, 47, 47, 17, 567, 48, 48, 449, 572,
172326
- /* 1380 */ 302, 975, 572, 50, 50, 32, 1273, 417, 572, 976,
172327
- /* 1390 */ 561, 572, 258, 51, 51, 530, 883, 572, 449, 572,
172328
- /* 1400 */ 565, 417, 64, 64, 539, 65, 65, 323, 572, 538,
172329
- /* 1410 */ 561, 66, 66, 422, 14, 14, 491, 441, 572, 1032,
172330
- /* 1420 */ 67, 67, 132, 132, 539, 110, 110, 326, 550, 540,
172331
- /* 1430 */ 1241, 133, 133, 111, 462, 449, 573, 449, 482, 1032,
172332
- /* 1440 */ 1020, 68, 68, 230, 409, 110, 110, 150, 114, 112,
172333
- /* 1450 */ 564, 1336, 4, 111, 883, 449, 573, 449, 572, 239,
172334
- /* 1460 */ 1020, 416, 572, 569, 572, 1369, 567, 572, 961, 318,
172335
- /* 1470 */ 563, 525, 1020, 1020, 1022, 1023, 28, 1301, 418, 179,
172336
- /* 1480 */ 1368, 53, 53, 285, 228, 69, 69, 70, 70, 449,
172337
- /* 1490 */ 54, 54, 1020, 1020, 1022, 1023, 28, 87, 215, 290,
172338
- /* 1500 */ 471, 561, 1179, 475, 394, 394, 393, 275, 391, 572,
172339
- /* 1510 */ 409, 853, 153, 409, 39, 539, 572, 317, 470, 1136,
172340
- /* 1520 */ 538, 398, 1179, 291, 236, 1300, 325, 409, 463, 572,
172341
- /* 1530 */ 1032, 201, 165, 165, 324, 483, 110, 110, 572, 166,
172342
- /* 1540 */ 166, 339, 112, 564, 111, 4, 449, 573, 449, 1145,
172343
- /* 1550 */ 572, 1020, 77, 77, 572, 1546, 572, 321, 472, 567,
172344
- /* 1560 */ 335, 55, 55, 340, 238, 101, 1519, 1013, 550, 263,
172345
- /* 1570 */ 895, 894, 170, 73, 73, 142, 241, 135, 135, 74,
172346
- /* 1580 */ 74, 298, 449, 1020, 1020, 1022, 1023, 28, 1589, 1183,
172347
- /* 1590 */ 451, 1518, 237, 290, 561, 161, 1084, 101, 394, 394,
172348
- /* 1600 */ 393, 275, 391, 487, 477, 853, 263, 479, 345, 263,
172349
- /* 1610 */ 101, 346, 501, 1179, 260, 902, 903, 559, 236, 572,
172350
- /* 1620 */ 325, 112, 564, 1032, 4, 369, 572, 412, 324, 110,
172351
- /* 1630 */ 110, 940, 318, 563, 1024, 368, 572, 111, 567, 449,
172352
- /* 1640 */ 573, 449, 163, 163, 1020, 1365, 359, 572, 101, 137,
172353
- /* 1650 */ 137, 572, 350, 1080, 1084, 260, 455, 353, 238, 131,
172354
- /* 1660 */ 131, 449, 966, 933, 263, 114, 170, 572, 355, 142,
172355
- /* 1670 */ 164, 164, 1299, 561, 157, 157, 1020, 1020, 1022, 1023,
172356
- /* 1680 */ 28, 572, 978, 979, 1577, 866, 237, 151, 496, 572,
172357
- /* 1690 */ 141, 141, 1024, 80, 564, 1096, 4, 1096, 1095, 357,
172358
- /* 1700 */ 1095, 572, 1032, 1315, 140, 140, 1179, 364, 110, 110,
172359
- /* 1710 */ 567, 572, 138, 138, 374, 572, 111, 1348, 449, 573,
172360
- /* 1720 */ 449, 412, 1378, 1020, 139, 139, 318, 563, 572, 934,
172361
- /* 1730 */ 1423, 114, 1351, 449, 76, 76, 278, 572, 78, 78,
172362
- /* 1740 */ 572, 1363, 552, 558, 1428, 561, 1280, 1271, 1259, 1258,
172363
- /* 1750 */ 455, 75, 75, 1260, 1597, 1020, 1020, 1022, 1023, 28,
172364
- /* 1760 */ 43, 43, 213, 49, 49, 395, 310, 311, 312, 11,
172365
- /* 1770 */ 234, 221, 1410, 293, 1032, 337, 1405, 338, 1415, 299,
172366
- /* 1780 */ 110, 110, 1398, 481, 506, 1179, 367, 1414, 111, 1491,
172367
- /* 1790 */ 449, 573, 449, 1183, 451, 1020, 402, 290, 225, 1490,
172368
- /* 1800 */ 1298, 1360, 394, 394, 393, 275, 391, 343, 1361, 853,
172369
- /* 1810 */ 562, 1359, 206, 389, 551, 207, 1600, 1358, 1235, 267,
172370
- /* 1820 */ 220, 1538, 236, 1536, 325, 1232, 82, 1020, 1020, 1022,
172371
- /* 1830 */ 1023, 28, 324, 181, 420, 86, 217, 232, 190, 175,
172372
- /* 1840 */ 183, 465, 185, 466, 1411, 186, 244, 112, 564, 36,
172373
- /* 1850 */ 4, 187, 188, 85, 1496, 499, 99, 1179, 400, 1417,
172374
- /* 1860 */ 1416, 37, 238, 473, 567, 403, 1419, 194, 1485, 488,
172375
- /* 1870 */ 170, 248, 92, 142, 1507, 494, 279, 250, 198, 497,
172376
- /* 1880 */ 352, 348, 251, 405, 1261, 252, 515, 449, 1318, 1317,
172377
- /* 1890 */ 237, 1316, 1309, 434, 94, 887, 226, 438, 1614, 561,
172378
- /* 1900 */ 1288, 1613, 406, 524, 439, 1582, 265, 366, 1287, 1286,
172379
- /* 1910 */ 1612, 308, 309, 266, 372, 442, 1568, 1308, 1567, 1383,
172380
- /* 1920 */ 1382, 129, 550, 10, 383, 412, 1472, 316, 1032, 100,
172381
- /* 1930 */ 318, 563, 106, 35, 110, 110, 534, 575, 1189, 274,
172382
- /* 1940 */ 276, 388, 111, 381, 449, 573, 449, 1341, 1340, 1020,
172383
- /* 1950 */ 212, 387, 277, 576, 455, 1256, 1251, 167, 148, 413,
172384
- /* 1960 */ 414, 180, 1523, 168, 1524, 1522, 1521, 840, 222, 306,
172385
- /* 1970 */ 450, 223, 169, 79, 214, 320, 233, 1094, 145, 1092,
172386
- /* 1980 */ 328, 1020, 1020, 1022, 1023, 28, 182, 171, 184, 1214,
172387
- /* 1990 */ 240, 919, 243, 336, 1108, 189, 172, 173, 423, 174,
172388
- /* 2000 */ 191, 88, 425, 89, 90, 1111, 91, 245, 1107, 246,
172389
- /* 2010 */ 159, 1179, 18, 247, 263, 347, 1229, 1100, 249, 493,
172390
- /* 2020 */ 196, 38, 855, 195, 368, 498, 197, 253, 510, 885,
172391
- /* 2030 */ 93, 19, 176, 360, 20, 502, 507, 363, 95, 898,
172392
- /* 2040 */ 160, 307, 518, 96, 1176, 1061, 1147, 40, 21, 97,
172393
- /* 2050 */ 227, 282, 284, 262, 1146, 970, 200, 964, 114, 1166,
172394
- /* 2060 */ 22, 23, 1164, 1162, 24, 25, 1170, 1151, 34, 26,
172395
- /* 2070 */ 204, 546, 1169, 101, 27, 103, 7, 104, 1075, 1062,
172396
- /* 2080 */ 1060, 1064, 1117, 1065, 1116, 268, 269, 29, 41, 1185,
172397
- /* 2090 */ 1025, 867, 113, 30, 568, 929, 392, 144, 178, 270,
172398
- /* 2100 */ 271, 1184, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247,
172399
- /* 2110 */ 1247, 1247, 1247, 1605,
172467
+ /* 0 */ 576, 128, 125, 232, 1622, 549, 576, 1290, 1281, 576,
172468
+ /* 10 */ 328, 576, 1300, 212, 576, 128, 125, 232, 578, 412,
172469
+ /* 20 */ 578, 391, 1542, 51, 51, 523, 405, 1293, 529, 51,
172470
+ /* 30 */ 51, 983, 51, 51, 81, 81, 1107, 61, 61, 984,
172471
+ /* 40 */ 1107, 1292, 380, 135, 136, 90, 1228, 1228, 1063, 1066,
172472
+ /* 50 */ 1053, 1053, 133, 133, 134, 134, 134, 134, 1577, 412,
172473
+ /* 60 */ 287, 287, 7, 287, 287, 422, 1050, 1050, 1064, 1067,
172474
+ /* 70 */ 289, 556, 492, 573, 524, 561, 573, 497, 561, 482,
172475
+ /* 80 */ 530, 262, 229, 135, 136, 90, 1228, 1228, 1063, 1066,
172476
+ /* 90 */ 1053, 1053, 133, 133, 134, 134, 134, 134, 128, 125,
172477
+ /* 100 */ 232, 1506, 132, 132, 132, 132, 131, 131, 130, 130,
172478
+ /* 110 */ 130, 129, 126, 450, 1204, 1255, 1, 1, 582, 2,
172479
+ /* 120 */ 1259, 1571, 420, 1582, 379, 320, 1174, 153, 1174, 1584,
172480
+ /* 130 */ 412, 378, 1582, 543, 1341, 330, 111, 570, 570, 570,
172481
+ /* 140 */ 293, 1054, 132, 132, 132, 132, 131, 131, 130, 130,
172482
+ /* 150 */ 130, 129, 126, 450, 135, 136, 90, 1228, 1228, 1063,
172483
+ /* 160 */ 1066, 1053, 1053, 133, 133, 134, 134, 134, 134, 287,
172484
+ /* 170 */ 287, 1204, 1205, 1204, 255, 287, 287, 510, 507, 506,
172485
+ /* 180 */ 137, 455, 573, 212, 561, 447, 446, 505, 573, 1616,
172486
+ /* 190 */ 561, 134, 134, 134, 134, 127, 400, 243, 132, 132,
172487
+ /* 200 */ 132, 132, 131, 131, 130, 130, 130, 129, 126, 450,
172488
+ /* 210 */ 282, 471, 345, 132, 132, 132, 132, 131, 131, 130,
172489
+ /* 220 */ 130, 130, 129, 126, 450, 574, 155, 936, 936, 454,
172490
+ /* 230 */ 227, 521, 1236, 412, 1236, 134, 134, 134, 134, 132,
172491
+ /* 240 */ 132, 132, 132, 131, 131, 130, 130, 130, 129, 126,
172492
+ /* 250 */ 450, 130, 130, 130, 129, 126, 450, 135, 136, 90,
172493
+ /* 260 */ 1228, 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134,
172494
+ /* 270 */ 134, 134, 128, 125, 232, 450, 576, 412, 397, 1249,
172495
+ /* 280 */ 180, 92, 93, 132, 132, 132, 132, 131, 131, 130,
172496
+ /* 290 */ 130, 130, 129, 126, 450, 381, 387, 1204, 383, 81,
172497
+ /* 300 */ 81, 135, 136, 90, 1228, 1228, 1063, 1066, 1053, 1053,
172498
+ /* 310 */ 133, 133, 134, 134, 134, 134, 132, 132, 132, 132,
172499
+ /* 320 */ 131, 131, 130, 130, 130, 129, 126, 450, 131, 131,
172500
+ /* 330 */ 130, 130, 130, 129, 126, 450, 556, 1204, 302, 319,
172501
+ /* 340 */ 567, 121, 568, 480, 4, 555, 1149, 1657, 1628, 1657,
172502
+ /* 350 */ 45, 128, 125, 232, 1204, 1205, 1204, 1250, 571, 1169,
172503
+ /* 360 */ 132, 132, 132, 132, 131, 131, 130, 130, 130, 129,
172504
+ /* 370 */ 126, 450, 1169, 287, 287, 1169, 1019, 576, 422, 1019,
172505
+ /* 380 */ 412, 451, 1602, 582, 2, 1259, 573, 44, 561, 95,
172506
+ /* 390 */ 320, 110, 153, 565, 1204, 1205, 1204, 522, 522, 1341,
172507
+ /* 400 */ 81, 81, 7, 44, 135, 136, 90, 1228, 1228, 1063,
172508
+ /* 410 */ 1066, 1053, 1053, 133, 133, 134, 134, 134, 134, 295,
172509
+ /* 420 */ 1149, 1658, 1040, 1658, 1204, 1147, 319, 567, 119, 119,
172510
+ /* 430 */ 343, 466, 331, 343, 287, 287, 120, 556, 451, 577,
172511
+ /* 440 */ 451, 1169, 1169, 1028, 319, 567, 438, 573, 210, 561,
172512
+ /* 450 */ 1339, 1451, 546, 531, 1169, 1169, 1598, 1169, 1169, 416,
172513
+ /* 460 */ 319, 567, 243, 132, 132, 132, 132, 131, 131, 130,
172514
+ /* 470 */ 130, 130, 129, 126, 450, 1028, 1028, 1030, 1031, 35,
172515
+ /* 480 */ 44, 1204, 1205, 1204, 472, 287, 287, 1328, 412, 1307,
172516
+ /* 490 */ 372, 1595, 359, 225, 454, 1204, 195, 1328, 573, 1147,
172517
+ /* 500 */ 561, 1333, 1333, 274, 576, 1188, 576, 340, 46, 196,
172518
+ /* 510 */ 537, 217, 135, 136, 90, 1228, 1228, 1063, 1066, 1053,
172519
+ /* 520 */ 1053, 133, 133, 134, 134, 134, 134, 19, 19, 19,
172520
+ /* 530 */ 19, 412, 581, 1204, 1259, 511, 1204, 319, 567, 320,
172521
+ /* 540 */ 944, 153, 425, 491, 430, 943, 1204, 488, 1341, 1450,
172522
+ /* 550 */ 532, 1277, 1204, 1205, 1204, 135, 136, 90, 1228, 1228,
172523
+ /* 560 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172524
+ /* 570 */ 575, 132, 132, 132, 132, 131, 131, 130, 130, 130,
172525
+ /* 580 */ 129, 126, 450, 287, 287, 528, 287, 287, 372, 1595,
172526
+ /* 590 */ 1204, 1205, 1204, 1204, 1205, 1204, 573, 486, 561, 573,
172527
+ /* 600 */ 889, 561, 412, 1204, 1205, 1204, 886, 40, 22, 22,
172528
+ /* 610 */ 220, 243, 525, 1449, 132, 132, 132, 132, 131, 131,
172529
+ /* 620 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172530
+ /* 630 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172531
+ /* 640 */ 134, 412, 180, 454, 1204, 879, 255, 287, 287, 510,
172532
+ /* 650 */ 507, 506, 372, 1595, 1568, 1331, 1331, 576, 889, 505,
172533
+ /* 660 */ 573, 44, 561, 559, 1207, 135, 136, 90, 1228, 1228,
172534
+ /* 670 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172535
+ /* 680 */ 81, 81, 422, 576, 377, 132, 132, 132, 132, 131,
172536
+ /* 690 */ 131, 130, 130, 130, 129, 126, 450, 297, 287, 287,
172537
+ /* 700 */ 460, 1204, 1205, 1204, 1204, 534, 19, 19, 448, 448,
172538
+ /* 710 */ 448, 573, 412, 561, 230, 436, 1187, 535, 319, 567,
172539
+ /* 720 */ 363, 432, 1207, 1435, 132, 132, 132, 132, 131, 131,
172540
+ /* 730 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172541
+ /* 740 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172542
+ /* 750 */ 134, 412, 211, 949, 1169, 1041, 1110, 1110, 494, 547,
172543
+ /* 760 */ 547, 1204, 1205, 1204, 7, 539, 1570, 1169, 376, 576,
172544
+ /* 770 */ 1169, 5, 1204, 486, 3, 135, 136, 90, 1228, 1228,
172545
+ /* 780 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172546
+ /* 790 */ 576, 513, 19, 19, 427, 132, 132, 132, 132, 131,
172547
+ /* 800 */ 131, 130, 130, 130, 129, 126, 450, 305, 1204, 433,
172548
+ /* 810 */ 225, 1204, 385, 19, 19, 273, 290, 371, 516, 366,
172549
+ /* 820 */ 515, 260, 412, 538, 1568, 549, 1024, 362, 437, 1204,
172550
+ /* 830 */ 1205, 1204, 902, 1552, 132, 132, 132, 132, 131, 131,
172551
+ /* 840 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172552
+ /* 850 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172553
+ /* 860 */ 134, 412, 1435, 514, 1281, 1204, 1205, 1204, 1204, 1205,
172554
+ /* 870 */ 1204, 903, 48, 342, 1568, 1568, 1279, 1627, 1568, 911,
172555
+ /* 880 */ 576, 129, 126, 450, 110, 135, 136, 90, 1228, 1228,
172556
+ /* 890 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172557
+ /* 900 */ 265, 576, 459, 19, 19, 132, 132, 132, 132, 131,
172558
+ /* 910 */ 131, 130, 130, 130, 129, 126, 450, 1345, 204, 576,
172559
+ /* 920 */ 459, 458, 50, 47, 19, 19, 49, 434, 1105, 573,
172560
+ /* 930 */ 497, 561, 412, 428, 108, 1224, 1569, 1554, 376, 205,
172561
+ /* 940 */ 550, 550, 81, 81, 132, 132, 132, 132, 131, 131,
172562
+ /* 950 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172563
+ /* 960 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172564
+ /* 970 */ 134, 480, 576, 1204, 576, 1541, 412, 1435, 969, 315,
172565
+ /* 980 */ 1659, 398, 284, 497, 969, 893, 1569, 1569, 376, 376,
172566
+ /* 990 */ 1569, 461, 376, 1224, 459, 80, 80, 81, 81, 497,
172567
+ /* 1000 */ 374, 114, 90, 1228, 1228, 1063, 1066, 1053, 1053, 133,
172568
+ /* 1010 */ 133, 134, 134, 134, 134, 132, 132, 132, 132, 131,
172569
+ /* 1020 */ 131, 130, 130, 130, 129, 126, 450, 1204, 1505, 576,
172570
+ /* 1030 */ 1204, 1205, 1204, 1366, 316, 486, 281, 281, 497, 431,
172571
+ /* 1040 */ 557, 288, 288, 402, 1340, 471, 345, 298, 429, 573,
172572
+ /* 1050 */ 576, 561, 81, 81, 573, 374, 561, 971, 386, 132,
172573
+ /* 1060 */ 132, 132, 132, 131, 131, 130, 130, 130, 129, 126,
172574
+ /* 1070 */ 450, 231, 117, 81, 81, 287, 287, 231, 287, 287,
172575
+ /* 1080 */ 576, 1511, 576, 1336, 1204, 1205, 1204, 139, 573, 556,
172576
+ /* 1090 */ 561, 573, 412, 561, 441, 456, 969, 213, 558, 1511,
172577
+ /* 1100 */ 1513, 1550, 969, 143, 143, 145, 145, 1368, 314, 478,
172578
+ /* 1110 */ 444, 970, 412, 850, 851, 852, 135, 136, 90, 1228,
172579
+ /* 1120 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172580
+ /* 1130 */ 134, 357, 412, 397, 1148, 304, 135, 136, 90, 1228,
172581
+ /* 1140 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172582
+ /* 1150 */ 134, 1575, 323, 6, 862, 7, 135, 124, 90, 1228,
172583
+ /* 1160 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172584
+ /* 1170 */ 134, 409, 408, 1511, 212, 132, 132, 132, 132, 131,
172585
+ /* 1180 */ 131, 130, 130, 130, 129, 126, 450, 411, 118, 1204,
172586
+ /* 1190 */ 116, 10, 352, 265, 355, 132, 132, 132, 132, 131,
172587
+ /* 1200 */ 131, 130, 130, 130, 129, 126, 450, 576, 324, 306,
172588
+ /* 1210 */ 576, 306, 1250, 469, 158, 132, 132, 132, 132, 131,
172589
+ /* 1220 */ 131, 130, 130, 130, 129, 126, 450, 207, 1224, 1126,
172590
+ /* 1230 */ 65, 65, 470, 66, 66, 412, 447, 446, 882, 531,
172591
+ /* 1240 */ 335, 258, 257, 256, 1127, 1233, 1204, 1205, 1204, 327,
172592
+ /* 1250 */ 1235, 874, 159, 576, 16, 480, 1085, 1040, 1234, 1128,
172593
+ /* 1260 */ 136, 90, 1228, 1228, 1063, 1066, 1053, 1053, 133, 133,
172594
+ /* 1270 */ 134, 134, 134, 134, 1029, 576, 81, 81, 1028, 1040,
172595
+ /* 1280 */ 922, 576, 463, 1236, 576, 1236, 1224, 502, 107, 1435,
172596
+ /* 1290 */ 923, 6, 576, 410, 1498, 882, 1029, 480, 21, 21,
172597
+ /* 1300 */ 1028, 332, 1380, 334, 53, 53, 497, 81, 81, 874,
172598
+ /* 1310 */ 1028, 1028, 1030, 445, 259, 19, 19, 533, 132, 132,
172599
+ /* 1320 */ 132, 132, 131, 131, 130, 130, 130, 129, 126, 450,
172600
+ /* 1330 */ 551, 301, 1028, 1028, 1030, 107, 532, 545, 121, 568,
172601
+ /* 1340 */ 1188, 4, 1126, 1576, 449, 576, 462, 7, 1282, 418,
172602
+ /* 1350 */ 462, 350, 1435, 576, 518, 571, 544, 1127, 121, 568,
172603
+ /* 1360 */ 442, 4, 1188, 464, 533, 1180, 1223, 9, 67, 67,
172604
+ /* 1370 */ 487, 576, 1128, 303, 410, 571, 54, 54, 451, 576,
172605
+ /* 1380 */ 123, 944, 576, 417, 576, 333, 943, 1379, 576, 236,
172606
+ /* 1390 */ 565, 576, 1574, 564, 68, 68, 7, 576, 451, 362,
172607
+ /* 1400 */ 419, 182, 69, 69, 541, 70, 70, 71, 71, 540,
172608
+ /* 1410 */ 565, 72, 72, 484, 55, 55, 473, 1180, 296, 1040,
172609
+ /* 1420 */ 56, 56, 296, 493, 541, 119, 119, 410, 1573, 542,
172610
+ /* 1430 */ 569, 418, 7, 120, 1244, 451, 577, 451, 465, 1040,
172611
+ /* 1440 */ 1028, 576, 1557, 552, 476, 119, 119, 527, 259, 121,
172612
+ /* 1450 */ 568, 240, 4, 120, 576, 451, 577, 451, 576, 477,
172613
+ /* 1460 */ 1028, 576, 156, 576, 57, 57, 571, 576, 286, 229,
172614
+ /* 1470 */ 410, 336, 1028, 1028, 1030, 1031, 35, 59, 59, 219,
172615
+ /* 1480 */ 983, 60, 60, 220, 73, 73, 74, 74, 984, 451,
172616
+ /* 1490 */ 75, 75, 1028, 1028, 1030, 1031, 35, 96, 216, 291,
172617
+ /* 1500 */ 552, 565, 1188, 318, 395, 395, 394, 276, 392, 576,
172618
+ /* 1510 */ 485, 859, 474, 1311, 410, 541, 576, 417, 1530, 1144,
172619
+ /* 1520 */ 540, 399, 1188, 292, 237, 1153, 326, 38, 23, 576,
172620
+ /* 1530 */ 1040, 576, 20, 20, 325, 299, 119, 119, 164, 76,
172621
+ /* 1540 */ 76, 1529, 121, 568, 120, 4, 451, 577, 451, 203,
172622
+ /* 1550 */ 576, 1028, 141, 141, 142, 142, 576, 322, 39, 571,
172623
+ /* 1560 */ 341, 1021, 110, 264, 239, 901, 900, 423, 242, 908,
172624
+ /* 1570 */ 909, 370, 173, 77, 77, 43, 479, 1310, 264, 62,
172625
+ /* 1580 */ 62, 369, 451, 1028, 1028, 1030, 1031, 35, 1601, 1192,
172626
+ /* 1590 */ 453, 1092, 238, 291, 565, 163, 1309, 110, 395, 395,
172627
+ /* 1600 */ 394, 276, 392, 986, 987, 859, 481, 346, 264, 110,
172628
+ /* 1610 */ 1032, 489, 576, 1188, 503, 1088, 261, 261, 237, 576,
172629
+ /* 1620 */ 326, 121, 568, 1040, 4, 347, 1376, 413, 325, 119,
172630
+ /* 1630 */ 119, 948, 319, 567, 351, 78, 78, 120, 571, 451,
172631
+ /* 1640 */ 577, 451, 79, 79, 1028, 354, 356, 576, 360, 1092,
172632
+ /* 1650 */ 110, 576, 974, 942, 264, 123, 457, 358, 239, 576,
172633
+ /* 1660 */ 519, 451, 939, 1104, 123, 1104, 173, 576, 1032, 43,
172634
+ /* 1670 */ 63, 63, 1324, 565, 168, 168, 1028, 1028, 1030, 1031,
172635
+ /* 1680 */ 35, 576, 169, 169, 1308, 872, 238, 157, 1589, 576,
172636
+ /* 1690 */ 86, 86, 365, 89, 568, 375, 4, 1103, 941, 1103,
172637
+ /* 1700 */ 123, 576, 1040, 1389, 64, 64, 1188, 1434, 119, 119,
172638
+ /* 1710 */ 571, 576, 82, 82, 563, 576, 120, 165, 451, 577,
172639
+ /* 1720 */ 451, 413, 1362, 1028, 144, 144, 319, 567, 576, 1374,
172640
+ /* 1730 */ 562, 498, 279, 451, 83, 83, 1439, 576, 166, 166,
172641
+ /* 1740 */ 576, 1289, 554, 576, 1280, 565, 576, 12, 576, 1268,
172642
+ /* 1750 */ 457, 146, 146, 1267, 576, 1028, 1028, 1030, 1031, 35,
172643
+ /* 1760 */ 140, 140, 1269, 167, 167, 1609, 160, 160, 1359, 150,
172644
+ /* 1770 */ 150, 149, 149, 311, 1040, 576, 312, 147, 147, 313,
172645
+ /* 1780 */ 119, 119, 222, 235, 576, 1188, 396, 576, 120, 576,
172646
+ /* 1790 */ 451, 577, 451, 1192, 453, 1028, 508, 291, 148, 148,
172647
+ /* 1800 */ 1421, 1612, 395, 395, 394, 276, 392, 85, 85, 859,
172648
+ /* 1810 */ 87, 87, 84, 84, 553, 576, 294, 576, 1426, 338,
172649
+ /* 1820 */ 339, 1425, 237, 300, 326, 1416, 1409, 1028, 1028, 1030,
172650
+ /* 1830 */ 1031, 35, 325, 344, 403, 483, 226, 1307, 52, 52,
172651
+ /* 1840 */ 58, 58, 368, 1371, 1502, 566, 1501, 121, 568, 221,
172652
+ /* 1850 */ 4, 208, 268, 209, 390, 1244, 1549, 1188, 1372, 1370,
172653
+ /* 1860 */ 1369, 1547, 239, 184, 571, 233, 421, 1241, 95, 218,
172654
+ /* 1870 */ 173, 1507, 193, 43, 91, 94, 178, 186, 467, 188,
172655
+ /* 1880 */ 468, 1422, 13, 189, 190, 191, 501, 451, 245, 108,
172656
+ /* 1890 */ 238, 401, 1428, 1427, 1430, 475, 404, 1496, 197, 565,
172657
+ /* 1900 */ 14, 490, 249, 101, 1518, 496, 349, 280, 251, 201,
172658
+ /* 1910 */ 353, 499, 252, 406, 1270, 253, 517, 1327, 1326, 435,
172659
+ /* 1920 */ 1325, 1318, 103, 893, 1296, 413, 227, 407, 1040, 1626,
172660
+ /* 1930 */ 319, 567, 1625, 1297, 119, 119, 439, 367, 1317, 1295,
172661
+ /* 1940 */ 1624, 526, 120, 440, 451, 577, 451, 1594, 309, 1028,
172662
+ /* 1950 */ 310, 373, 266, 267, 457, 1580, 1579, 443, 138, 1394,
172663
+ /* 1960 */ 552, 1393, 11, 1483, 384, 115, 317, 1350, 109, 536,
172664
+ /* 1970 */ 42, 579, 382, 214, 1349, 388, 1198, 389, 275, 277,
172665
+ /* 1980 */ 278, 1028, 1028, 1030, 1031, 35, 580, 1265, 414, 1260,
172666
+ /* 1990 */ 170, 415, 183, 1534, 1535, 1533, 171, 154, 307, 1532,
172667
+ /* 2000 */ 846, 223, 224, 88, 452, 215, 172, 321, 234, 1102,
172668
+ /* 2010 */ 152, 1188, 1100, 329, 185, 174, 1223, 925, 187, 241,
172669
+ /* 2020 */ 337, 244, 1116, 192, 175, 176, 424, 426, 97, 194,
172670
+ /* 2030 */ 98, 99, 100, 177, 1119, 1115, 246, 247, 161, 24,
172671
+ /* 2040 */ 248, 348, 1238, 264, 1108, 250, 495, 199, 198, 15,
172672
+ /* 2050 */ 861, 500, 369, 254, 504, 509, 512, 200, 102, 25,
172673
+ /* 2060 */ 179, 361, 26, 364, 104, 891, 308, 162, 105, 904,
172674
+ /* 2070 */ 520, 106, 1185, 1069, 1155, 17, 228, 27, 1154, 283,
172675
+ /* 2080 */ 285, 263, 978, 202, 972, 123, 28, 1175, 29, 30,
172676
+ /* 2090 */ 1179, 1171, 31, 1173, 1160, 41, 32, 206, 548, 33,
172677
+ /* 2100 */ 110, 1178, 1083, 8, 112, 1070, 113, 1068, 1072, 34,
172678
+ /* 2110 */ 1073, 560, 1125, 269, 1124, 270, 36, 18, 1194, 1033,
172679
+ /* 2120 */ 873, 151, 122, 37, 393, 271, 272, 572, 181, 1193,
172680
+ /* 2130 */ 1256, 1256, 1256, 935, 1256, 1256, 1256, 1256, 1256, 1256,
172681
+ /* 2140 */ 1256, 1617,
172400172682
 };
172401172683
 static const YYCODETYPE yy_lookahead[] = {
172402
- /* 0 */ 194, 194, 194, 275, 276, 277, 194, 275, 276, 277,
172403
- /* 10 */ 194, 224, 220, 226, 207, 211, 212, 213, 194, 19,
172404
- /* 20 */ 220, 234, 217, 217, 218, 217, 218, 194, 296, 217,
172405
- /* 30 */ 218, 31, 194, 217, 218, 194, 229, 214, 231, 39,
172406
- /* 40 */ 207, 217, 218, 43, 44, 45, 46, 47, 48, 49,
172407
- /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 194, 19,
172408
- /* 60 */ 186, 187, 188, 189, 190, 191, 254, 275, 276, 277,
172409
- /* 70 */ 196, 194, 198, 194, 262, 275, 276, 277, 254, 205,
172410
- /* 80 */ 239, 205, 81, 43, 44, 45, 46, 47, 48, 49,
172411
- /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 275, 276,
172412
- /* 100 */ 277, 263, 102, 103, 104, 105, 106, 107, 108, 109,
172413
- /* 110 */ 110, 111, 112, 113, 240, 241, 240, 241, 211, 212,
172414
- /* 120 */ 213, 315, 316, 315, 59, 317, 86, 253, 88, 253,
172415
- /* 130 */ 19, 315, 316, 257, 258, 113, 25, 72, 297, 138,
172416
- /* 140 */ 139, 267, 102, 103, 104, 105, 106, 107, 108, 109,
172684
+ /* 0 */ 194, 276, 277, 278, 216, 194, 194, 217, 194, 194,
172685
+ /* 10 */ 194, 194, 224, 194, 194, 276, 277, 278, 204, 19,
172686
+ /* 20 */ 206, 202, 297, 217, 218, 205, 207, 217, 205, 217,
172687
+ /* 30 */ 218, 31, 217, 218, 217, 218, 29, 217, 218, 39,
172688
+ /* 40 */ 33, 217, 220, 43, 44, 45, 46, 47, 48, 49,
172689
+ /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 312, 19,
172690
+ /* 60 */ 240, 241, 316, 240, 241, 194, 46, 47, 48, 49,
172691
+ /* 70 */ 22, 254, 65, 253, 254, 255, 253, 194, 255, 194,
172692
+ /* 80 */ 263, 258, 259, 43, 44, 45, 46, 47, 48, 49,
172693
+ /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 276, 277,
172694
+ /* 100 */ 278, 285, 102, 103, 104, 105, 106, 107, 108, 109,
172695
+ /* 110 */ 110, 111, 112, 113, 59, 186, 187, 188, 189, 190,
172696
+ /* 120 */ 191, 310, 239, 317, 318, 196, 86, 198, 88, 317,
172697
+ /* 130 */ 19, 319, 317, 318, 205, 264, 25, 211, 212, 213,
172698
+ /* 140 */ 205, 121, 102, 103, 104, 105, 106, 107, 108, 109,
172417172699
 /* 150 */ 110, 111, 112, 113, 43, 44, 45, 46, 47, 48,
172418
- /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 81,
172419
- /* 170 */ 293, 59, 293, 299, 108, 109, 110, 111, 112, 113,
172420
- /* 180 */ 69, 116, 117, 118, 72, 106, 107, 194, 111, 112,
172421
- /* 190 */ 113, 54, 55, 56, 57, 58, 102, 103, 104, 105,
172422
- /* 200 */ 106, 107, 108, 109, 110, 111, 112, 113, 120, 217,
172423
- /* 210 */ 217, 218, 22, 102, 103, 104, 105, 106, 107, 108,
172424
- /* 220 */ 109, 110, 111, 112, 113, 232, 138, 139, 116, 117,
172425
- /* 230 */ 118, 23, 153, 19, 155, 54, 55, 56, 57, 102,
172700
+ /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 240,
172701
+ /* 170 */ 241, 116, 117, 118, 119, 240, 241, 122, 123, 124,
172702
+ /* 180 */ 69, 298, 253, 194, 255, 106, 107, 132, 253, 141,
172703
+ /* 190 */ 255, 54, 55, 56, 57, 58, 207, 268, 102, 103,
172704
+ /* 200 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
172705
+ /* 210 */ 214, 128, 129, 102, 103, 104, 105, 106, 107, 108,
172706
+ /* 220 */ 109, 110, 111, 112, 113, 134, 25, 136, 137, 300,
172707
+ /* 230 */ 165, 166, 153, 19, 155, 54, 55, 56, 57, 102,
172426172708
 /* 240 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172427
- /* 250 */ 113, 128, 129, 46, 47, 48, 49, 43, 44, 45,
172709
+ /* 250 */ 113, 108, 109, 110, 111, 112, 113, 43, 44, 45,
172428172710
 /* 260 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
172429
- /* 270 */ 56, 57, 127, 128, 129, 59, 194, 19, 165, 166,
172711
+ /* 270 */ 56, 57, 276, 277, 278, 113, 194, 19, 22, 23,
172430172712
 /* 280 */ 194, 67, 24, 102, 103, 104, 105, 106, 107, 108,
172431
- /* 290 */ 109, 110, 111, 112, 113, 73, 106, 107, 59, 217,
172713
+ /* 290 */ 109, 110, 111, 112, 113, 220, 250, 59, 252, 217,
172432172714
 /* 300 */ 218, 43, 44, 45, 46, 47, 48, 49, 50, 51,
172433172715
 /* 310 */ 52, 53, 54, 55, 56, 57, 102, 103, 104, 105,
172434
- /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 121, 23,
172435
- /* 330 */ 59, 25, 116, 117, 118, 119, 254, 205, 122, 123,
172436
- /* 340 */ 124, 19, 20, 134, 22, 136, 137, 19, 132, 127,
172437
- /* 350 */ 128, 129, 24, 145, 194, 116, 117, 118, 36, 194,
172716
+ /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 106, 107,
172717
+ /* 330 */ 108, 109, 110, 111, 112, 113, 254, 59, 205, 138,
172718
+ /* 340 */ 139, 19, 20, 194, 22, 263, 22, 23, 231, 25,
172719
+ /* 350 */ 72, 276, 277, 278, 116, 117, 118, 101, 36, 76,
172438172720
 /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
172439
- /* 370 */ 112, 113, 240, 241, 7, 8, 9, 106, 107, 59,
172440
- /* 380 */ 19, 59, 217, 218, 214, 253, 115, 116, 117, 118,
172441
- /* 390 */ 151, 120, 26, 71, 274, 309, 310, 194, 194, 128,
172442
- /* 400 */ 314, 217, 270, 81, 43, 44, 45, 46, 47, 48,
172443
- /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 254,
172444
- /* 420 */ 217, 218, 100, 95, 153, 59, 155, 262, 106, 107,
172445
- /* 430 */ 25, 194, 312, 313, 194, 232, 114, 117, 116, 117,
172446
- /* 440 */ 118, 113, 194, 121, 284, 205, 242, 119, 120, 121,
172447
- /* 450 */ 122, 123, 124, 125, 217, 218, 194, 217, 218, 131,
172448
- /* 460 */ 138, 139, 292, 102, 103, 104, 105, 106, 107, 108,
172721
+ /* 370 */ 112, 113, 89, 240, 241, 92, 73, 194, 194, 73,
172722
+ /* 380 */ 19, 59, 188, 189, 190, 191, 253, 81, 255, 151,
172723
+ /* 390 */ 196, 25, 198, 71, 116, 117, 118, 311, 312, 205,
172724
+ /* 400 */ 217, 218, 316, 81, 43, 44, 45, 46, 47, 48,
172725
+ /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 270,
172726
+ /* 420 */ 22, 23, 100, 25, 59, 101, 138, 139, 106, 107,
172727
+ /* 430 */ 127, 128, 129, 127, 240, 241, 114, 254, 116, 117,
172728
+ /* 440 */ 118, 76, 76, 121, 138, 139, 263, 253, 264, 255,
172729
+ /* 450 */ 205, 275, 87, 19, 89, 89, 194, 92, 92, 199,
172730
+ /* 460 */ 138, 139, 268, 102, 103, 104, 105, 106, 107, 108,
172449172731
 /* 470 */ 109, 110, 111, 112, 113, 153, 154, 155, 156, 157,
172450
- /* 480 */ 240, 241, 116, 117, 118, 76, 231, 194, 19, 216,
172451
- /* 490 */ 242, 254, 23, 253, 254, 202, 87, 224, 89, 262,
172452
- /* 500 */ 207, 92, 262, 310, 194, 183, 194, 314, 22, 305,
172453
- /* 510 */ 24, 150, 43, 44, 45, 46, 47, 48, 49, 50,
172732
+ /* 480 */ 81, 116, 117, 118, 129, 240, 241, 224, 19, 226,
172733
+ /* 490 */ 314, 315, 23, 25, 300, 59, 22, 234, 253, 101,
172734
+ /* 500 */ 255, 236, 237, 26, 194, 183, 194, 152, 72, 22,
172735
+ /* 510 */ 145, 150, 43, 44, 45, 46, 47, 48, 49, 50,
172454172736
 /* 520 */ 51, 52, 53, 54, 55, 56, 57, 217, 218, 217,
172455
- /* 530 */ 218, 19, 189, 119, 191, 23, 122, 123, 124, 196,
172456
- /* 540 */ 25, 198, 232, 73, 232, 59, 132, 142, 205, 236,
172457
- /* 550 */ 237, 81, 194, 305, 145, 43, 44, 45, 46, 47,
172737
+ /* 530 */ 218, 19, 189, 59, 191, 23, 59, 138, 139, 196,
172738
+ /* 540 */ 135, 198, 232, 283, 232, 140, 59, 287, 205, 275,
172739
+ /* 550 */ 116, 205, 116, 117, 118, 43, 44, 45, 46, 47,
172458172740
 /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172459
- /* 570 */ 308, 102, 103, 104, 105, 106, 107, 108, 109, 110,
172460
- /* 580 */ 111, 112, 113, 240, 241, 106, 107, 108, 109, 110,
172461
- /* 590 */ 111, 112, 113, 194, 59, 194, 253, 127, 59, 250,
172462
- /* 600 */ 242, 252, 19, 117, 194, 194, 23, 22, 138, 139,
172463
- /* 610 */ 267, 22, 236, 237, 102, 103, 104, 105, 106, 107,
172741
+ /* 570 */ 194, 102, 103, 104, 105, 106, 107, 108, 109, 110,
172742
+ /* 580 */ 111, 112, 113, 240, 241, 194, 240, 241, 314, 315,
172743
+ /* 590 */ 116, 117, 118, 116, 117, 118, 253, 194, 255, 253,
172744
+ /* 600 */ 59, 255, 19, 116, 117, 118, 23, 22, 217, 218,
172745
+ /* 610 */ 142, 268, 205, 275, 102, 103, 104, 105, 106, 107,
172464172746
 /* 620 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172465172747
 /* 630 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172466
- /* 640 */ 57, 19, 299, 108, 59, 23, 194, 194, 59, 194,
172467
- /* 650 */ 21, 116, 117, 118, 194, 116, 117, 118, 206, 204,
172468
- /* 660 */ 194, 206, 22, 305, 149, 43, 44, 45, 46, 47,
172748
+ /* 640 */ 57, 19, 194, 300, 59, 23, 119, 240, 241, 122,
172749
+ /* 650 */ 123, 124, 314, 315, 194, 236, 237, 194, 117, 132,
172750
+ /* 660 */ 253, 81, 255, 205, 59, 43, 44, 45, 46, 47,
172469172751
 /* 670 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172470
- /* 680 */ 259, 199, 143, 217, 218, 102, 103, 104, 105, 106,
172471
- /* 690 */ 107, 108, 109, 110, 111, 112, 113, 194, 232, 59,
172472
- /* 700 */ 194, 116, 117, 118, 59, 116, 117, 118, 59, 80,
172473
- /* 710 */ 309, 310, 19, 194, 194, 314, 23, 22, 307, 308,
172474
- /* 720 */ 217, 218, 22, 263, 102, 103, 104, 105, 106, 107,
172752
+ /* 680 */ 217, 218, 194, 194, 194, 102, 103, 104, 105, 106,
172753
+ /* 690 */ 107, 108, 109, 110, 111, 112, 113, 294, 240, 241,
172754
+ /* 700 */ 120, 116, 117, 118, 59, 194, 217, 218, 211, 212,
172755
+ /* 710 */ 213, 253, 19, 255, 194, 19, 23, 254, 138, 139,
172756
+ /* 720 */ 24, 232, 117, 194, 102, 103, 104, 105, 106, 107,
172475172757
 /* 730 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172476172758
 /* 740 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172477
- /* 750 */ 57, 19, 123, 233, 59, 23, 116, 117, 118, 59,
172478
- /* 760 */ 194, 116, 117, 118, 282, 116, 117, 118, 286, 263,
172479
- /* 770 */ 194, 194, 194, 302, 303, 43, 44, 45, 46, 47,
172759
+ /* 750 */ 57, 19, 264, 108, 76, 23, 127, 128, 129, 311,
172760
+ /* 760 */ 312, 116, 117, 118, 316, 87, 306, 89, 308, 194,
172761
+ /* 770 */ 92, 22, 59, 194, 22, 43, 44, 45, 46, 47,
172480172762
 /* 780 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172481
- /* 790 */ 161, 194, 143, 217, 218, 102, 103, 104, 105, 106,
172482
- /* 800 */ 107, 108, 109, 110, 111, 112, 113, 194, 232, 194,
172483
- /* 810 */ 194, 116, 117, 118, 217, 218, 116, 117, 118, 242,
172484
- /* 820 */ 25, 270, 19, 23, 305, 25, 23, 194, 205, 232,
172485
- /* 830 */ 205, 35, 217, 218, 102, 103, 104, 105, 106, 107,
172763
+ /* 790 */ 194, 95, 217, 218, 265, 102, 103, 104, 105, 106,
172764
+ /* 800 */ 107, 108, 109, 110, 111, 112, 113, 232, 59, 113,
172765
+ /* 810 */ 25, 59, 194, 217, 218, 119, 120, 121, 122, 123,
172766
+ /* 820 */ 124, 125, 19, 145, 194, 194, 23, 131, 232, 116,
172767
+ /* 830 */ 117, 118, 35, 194, 102, 103, 104, 105, 106, 107,
172486172768
 /* 840 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172487172769
 /* 850 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172488
- /* 860 */ 57, 19, 66, 240, 241, 240, 241, 240, 241, 254,
172489
- /* 870 */ 74, 240, 241, 245, 25, 115, 253, 264, 253, 194,
172490
- /* 880 */ 253, 22, 305, 255, 253, 43, 44, 45, 46, 47,
172770
+ /* 860 */ 57, 19, 194, 66, 194, 116, 117, 118, 116, 117,
172771
+ /* 870 */ 118, 74, 242, 294, 194, 194, 206, 23, 194, 25,
172772
+ /* 880 */ 194, 111, 112, 113, 25, 43, 44, 45, 46, 47,
172491172773
 /* 890 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172492
- /* 900 */ 194, 214, 217, 218, 144, 102, 103, 104, 105, 106,
172493
- /* 910 */ 107, 108, 109, 110, 111, 112, 113, 232, 118, 188,
172494
- /* 920 */ 189, 190, 191, 217, 218, 76, 130, 196, 16, 198,
172495
- /* 930 */ 194, 310, 19, 138, 139, 314, 205, 194, 89, 260,
172496
- /* 940 */ 261, 92, 205, 143, 102, 103, 104, 105, 106, 107,
172774
+ /* 900 */ 24, 194, 194, 217, 218, 102, 103, 104, 105, 106,
172775
+ /* 910 */ 107, 108, 109, 110, 111, 112, 113, 241, 232, 194,
172776
+ /* 920 */ 212, 213, 242, 242, 217, 218, 242, 130, 11, 253,
172777
+ /* 930 */ 194, 255, 19, 265, 149, 59, 306, 194, 308, 232,
172778
+ /* 940 */ 309, 310, 217, 218, 102, 103, 104, 105, 106, 107,
172497172779
 /* 950 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172498172780
 /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172499
- /* 970 */ 57, 240, 241, 194, 287, 239, 19, 240, 241, 292,
172500
- /* 980 */ 127, 128, 129, 11, 253, 279, 194, 59, 19, 77,
172501
- /* 990 */ 253, 79, 22, 23, 227, 25, 217, 218, 267, 205,
172502
- /* 1000 */ 141, 159, 45, 46, 47, 48, 49, 50, 51, 52,
172781
+ /* 970 */ 57, 194, 194, 59, 194, 239, 19, 194, 25, 254,
172782
+ /* 980 */ 303, 304, 23, 194, 25, 126, 306, 306, 308, 308,
172783
+ /* 990 */ 306, 271, 308, 117, 286, 217, 218, 217, 218, 194,
172784
+ /* 1000 */ 194, 159, 45, 46, 47, 48, 49, 50, 51, 52,
172503172785
 /* 1010 */ 53, 54, 55, 56, 57, 102, 103, 104, 105, 106,
172504
- /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 194, 100, 194,
172505
- /* 1030 */ 299, 239, 194, 254, 240, 241, 22, 23, 194, 25,
172506
- /* 1040 */ 205, 194, 205, 12, 116, 117, 16, 253, 194, 121,
172507
- /* 1050 */ 217, 218, 217, 218, 25, 217, 218, 274, 27, 102,
172786
+ /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 59, 239, 194,
172787
+ /* 1030 */ 116, 117, 118, 260, 254, 194, 240, 241, 194, 233,
172788
+ /* 1040 */ 205, 240, 241, 205, 239, 128, 129, 270, 265, 253,
172789
+ /* 1050 */ 194, 255, 217, 218, 253, 194, 255, 143, 280, 102,
172508172790
 /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172509
- /* 1070 */ 113, 101, 159, 42, 135, 240, 241, 240, 241, 140,
172510
- /* 1080 */ 194, 153, 154, 155, 115, 116, 239, 254, 253, 254,
172511
- /* 1090 */ 253, 194, 19, 239, 63, 312, 313, 24, 212, 213,
172512
- /* 1100 */ 128, 129, 261, 158, 73, 160, 265, 77, 264, 79,
172513
- /* 1110 */ 194, 183, 19, 144, 274, 101, 43, 44, 45, 46,
172791
+ /* 1070 */ 113, 118, 159, 217, 218, 240, 241, 118, 240, 241,
172792
+ /* 1080 */ 194, 194, 194, 239, 116, 117, 118, 22, 253, 254,
172793
+ /* 1090 */ 255, 253, 19, 255, 233, 194, 143, 24, 263, 212,
172794
+ /* 1100 */ 213, 194, 143, 217, 218, 217, 218, 261, 262, 271,
172795
+ /* 1110 */ 254, 143, 19, 7, 8, 9, 43, 44, 45, 46,
172514172796
 /* 1120 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172515
- /* 1130 */ 57, 310, 19, 217, 218, 314, 43, 44, 45, 46,
172797
+ /* 1130 */ 57, 16, 19, 22, 23, 294, 43, 44, 45, 46,
172516172798
 /* 1140 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172517
- /* 1150 */ 57, 22, 312, 313, 194, 126, 43, 44, 45, 46,
172799
+ /* 1150 */ 57, 312, 194, 214, 21, 316, 43, 44, 45, 46,
172518172800
 /* 1160 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172519
- /* 1170 */ 57, 285, 212, 213, 194, 102, 103, 104, 105, 106,
172520
- /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 19, 59, 25,
172521
- /* 1190 */ 293, 161, 194, 205, 76, 102, 103, 104, 105, 106,
172522
- /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 89, 310, 194,
172523
- /* 1210 */ 92, 66, 314, 194, 46, 102, 103, 104, 105, 106,
172524
- /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 100, 240, 241,
172525
- /* 1230 */ 85, 194, 217, 218, 310, 19, 217, 218, 314, 94,
172526
- /* 1240 */ 115, 253, 194, 261, 117, 285, 117, 265, 121, 269,
172527
- /* 1250 */ 194, 24, 29, 194, 217, 218, 33, 59, 22, 23,
172801
+ /* 1170 */ 57, 106, 107, 286, 194, 102, 103, 104, 105, 106,
172802
+ /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 207, 158, 59,
172803
+ /* 1190 */ 160, 22, 77, 24, 79, 102, 103, 104, 105, 106,
172804
+ /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 194, 194, 229,
172805
+ /* 1210 */ 194, 231, 101, 80, 22, 102, 103, 104, 105, 106,
172806
+ /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 288, 59, 12,
172807
+ /* 1230 */ 217, 218, 293, 217, 218, 19, 106, 107, 59, 19,
172808
+ /* 1240 */ 16, 127, 128, 129, 27, 115, 116, 117, 118, 194,
172809
+ /* 1250 */ 120, 59, 22, 194, 24, 194, 123, 100, 128, 42,
172528172810
 /* 1260 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
172529
- /* 1270 */ 54, 55, 56, 57, 76, 150, 217, 218, 194, 12,
172530
- /* 1280 */ 153, 154, 155, 115, 194, 87, 59, 89, 65, 194,
172531
- /* 1290 */ 92, 146, 194, 194, 27, 239, 194, 194, 19, 131,
172532
- /* 1300 */ 194, 217, 218, 15, 108, 194, 142, 217, 218, 42,
172533
- /* 1310 */ 183, 194, 217, 218, 116, 117, 118, 269, 102, 103,
172811
+ /* 1270 */ 54, 55, 56, 57, 117, 194, 217, 218, 121, 100,
172812
+ /* 1280 */ 63, 194, 245, 153, 194, 155, 117, 19, 115, 194,
172813
+ /* 1290 */ 73, 214, 194, 256, 161, 116, 117, 194, 217, 218,
172814
+ /* 1300 */ 121, 77, 194, 79, 217, 218, 194, 217, 218, 117,
172815
+ /* 1310 */ 153, 154, 155, 254, 46, 217, 218, 144, 102, 103,
172534172816
 /* 1320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
172535
- /* 1330 */ 63, 135, 233, 194, 217, 218, 140, 101, 19, 20,
172536
- /* 1340 */ 194, 22, 194, 145, 117, 194, 194, 194, 60, 194,
172537
- /* 1350 */ 25, 22, 23, 194, 22, 36, 217, 218, 19, 20,
172538
- /* 1360 */ 194, 22, 264, 217, 218, 217, 218, 48, 217, 218,
172539
- /* 1370 */ 194, 269, 217, 218, 22, 36, 217, 218, 59, 194,
172540
- /* 1380 */ 269, 31, 194, 217, 218, 53, 209, 210, 194, 39,
172541
- /* 1390 */ 71, 194, 46, 217, 218, 116, 59, 194, 59, 194,
172542
- /* 1400 */ 209, 210, 217, 218, 85, 217, 218, 194, 194, 90,
172543
- /* 1410 */ 71, 217, 218, 61, 217, 218, 264, 264, 194, 100,
172544
- /* 1420 */ 217, 218, 217, 218, 85, 106, 107, 194, 145, 90,
172545
- /* 1430 */ 101, 217, 218, 114, 245, 116, 117, 118, 19, 100,
172546
- /* 1440 */ 121, 217, 218, 118, 255, 106, 107, 164, 25, 19,
172547
- /* 1450 */ 20, 241, 22, 114, 117, 116, 117, 118, 194, 24,
172548
- /* 1460 */ 121, 115, 194, 253, 194, 194, 36, 194, 143, 138,
172549
- /* 1470 */ 139, 19, 153, 154, 155, 156, 157, 227, 300, 301,
172550
- /* 1480 */ 194, 217, 218, 257, 258, 217, 218, 217, 218, 59,
172817
+ /* 1330 */ 232, 270, 153, 154, 155, 115, 116, 66, 19, 20,
172818
+ /* 1340 */ 183, 22, 12, 312, 254, 194, 262, 316, 209, 210,
172819
+ /* 1350 */ 266, 239, 194, 194, 108, 36, 85, 27, 19, 20,
172820
+ /* 1360 */ 265, 22, 183, 245, 144, 94, 25, 48, 217, 218,
172821
+ /* 1370 */ 293, 194, 42, 270, 256, 36, 217, 218, 59, 194,
172822
+ /* 1380 */ 25, 135, 194, 115, 194, 161, 140, 194, 194, 15,
172823
+ /* 1390 */ 71, 194, 312, 63, 217, 218, 316, 194, 59, 131,
172824
+ /* 1400 */ 301, 302, 217, 218, 85, 217, 218, 217, 218, 90,
172825
+ /* 1410 */ 71, 217, 218, 19, 217, 218, 245, 146, 262, 100,
172826
+ /* 1420 */ 217, 218, 266, 265, 85, 106, 107, 256, 312, 90,
172827
+ /* 1430 */ 209, 210, 316, 114, 60, 116, 117, 118, 194, 100,
172828
+ /* 1440 */ 121, 194, 194, 145, 115, 106, 107, 19, 46, 19,
172829
+ /* 1450 */ 20, 24, 22, 114, 194, 116, 117, 118, 194, 245,
172830
+ /* 1460 */ 121, 194, 164, 194, 217, 218, 36, 194, 258, 259,
172831
+ /* 1470 */ 256, 194, 153, 154, 155, 156, 157, 217, 218, 150,
172832
+ /* 1480 */ 31, 217, 218, 142, 217, 218, 217, 218, 39, 59,
172551172833
 /* 1490 */ 217, 218, 153, 154, 155, 156, 157, 149, 150, 5,
172552
- /* 1500 */ 245, 71, 183, 245, 10, 11, 12, 13, 14, 194,
172553
- /* 1510 */ 255, 17, 22, 255, 24, 85, 194, 245, 129, 23,
172554
- /* 1520 */ 90, 25, 183, 99, 30, 227, 32, 255, 194, 194,
172555
- /* 1530 */ 100, 256, 217, 218, 40, 116, 106, 107, 194, 217,
172556
- /* 1540 */ 218, 152, 19, 20, 114, 22, 116, 117, 118, 97,
172557
- /* 1550 */ 194, 121, 217, 218, 194, 194, 194, 133, 129, 36,
172558
- /* 1560 */ 194, 217, 218, 23, 70, 25, 194, 23, 145, 25,
172559
- /* 1570 */ 120, 121, 78, 217, 218, 81, 141, 217, 218, 217,
172560
- /* 1580 */ 218, 152, 59, 153, 154, 155, 156, 157, 0, 1,
172561
- /* 1590 */ 2, 194, 98, 5, 71, 23, 59, 25, 10, 11,
172562
- /* 1600 */ 12, 13, 14, 194, 23, 17, 25, 23, 23, 25,
172563
- /* 1610 */ 25, 194, 23, 183, 25, 7, 8, 237, 30, 194,
172564
- /* 1620 */ 32, 19, 20, 100, 22, 121, 194, 133, 40, 106,
172565
- /* 1630 */ 107, 108, 138, 139, 59, 131, 194, 114, 36, 116,
172566
- /* 1640 */ 117, 118, 217, 218, 121, 194, 23, 194, 25, 217,
172567
- /* 1650 */ 218, 194, 194, 23, 117, 25, 162, 194, 70, 217,
172568
- /* 1660 */ 218, 59, 23, 23, 25, 25, 78, 194, 194, 81,
172834
+ /* 1500 */ 145, 71, 183, 245, 10, 11, 12, 13, 14, 194,
172835
+ /* 1510 */ 116, 17, 129, 227, 256, 85, 194, 115, 194, 23,
172836
+ /* 1520 */ 90, 25, 183, 99, 30, 97, 32, 22, 22, 194,
172837
+ /* 1530 */ 100, 194, 217, 218, 40, 152, 106, 107, 23, 217,
172838
+ /* 1540 */ 218, 194, 19, 20, 114, 22, 116, 117, 118, 257,
172839
+ /* 1550 */ 194, 121, 217, 218, 217, 218, 194, 133, 53, 36,
172840
+ /* 1560 */ 23, 23, 25, 25, 70, 120, 121, 61, 141, 7,
172841
+ /* 1570 */ 8, 121, 78, 217, 218, 81, 23, 227, 25, 217,
172842
+ /* 1580 */ 218, 131, 59, 153, 154, 155, 156, 157, 0, 1,
172843
+ /* 1590 */ 2, 59, 98, 5, 71, 23, 227, 25, 10, 11,
172844
+ /* 1600 */ 12, 13, 14, 83, 84, 17, 23, 23, 25, 25,
172845
+ /* 1610 */ 59, 194, 194, 183, 23, 23, 25, 25, 30, 194,
172846
+ /* 1620 */ 32, 19, 20, 100, 22, 194, 194, 133, 40, 106,
172847
+ /* 1630 */ 107, 108, 138, 139, 194, 217, 218, 114, 36, 116,
172848
+ /* 1640 */ 117, 118, 217, 218, 121, 194, 194, 194, 23, 117,
172849
+ /* 1650 */ 25, 194, 23, 23, 25, 25, 162, 194, 70, 194,
172850
+ /* 1660 */ 145, 59, 23, 153, 25, 155, 78, 194, 117, 81,
172569172851
 /* 1670 */ 217, 218, 194, 71, 217, 218, 153, 154, 155, 156,
172570
- /* 1680 */ 157, 194, 83, 84, 319, 23, 98, 25, 289, 194,
172571
- /* 1690 */ 217, 218, 117, 19, 20, 153, 22, 155, 153, 194,
172572
- /* 1700 */ 155, 194, 100, 194, 217, 218, 183, 194, 106, 107,
172573
- /* 1710 */ 36, 194, 217, 218, 194, 194, 114, 256, 116, 117,
172574
- /* 1720 */ 118, 133, 194, 121, 217, 218, 138, 139, 194, 23,
172575
- /* 1730 */ 194, 25, 194, 59, 217, 218, 288, 194, 217, 218,
172576
- /* 1740 */ 194, 194, 140, 194, 194, 71, 194, 194, 194, 194,
172852
+ /* 1680 */ 157, 194, 217, 218, 194, 23, 98, 25, 321, 194,
172853
+ /* 1690 */ 217, 218, 194, 19, 20, 194, 22, 153, 23, 155,
172854
+ /* 1700 */ 25, 194, 100, 194, 217, 218, 183, 194, 106, 107,
172855
+ /* 1710 */ 36, 194, 217, 218, 237, 194, 114, 243, 116, 117,
172856
+ /* 1720 */ 118, 133, 194, 121, 217, 218, 138, 139, 194, 194,
172857
+ /* 1730 */ 194, 290, 289, 59, 217, 218, 194, 194, 217, 218,
172858
+ /* 1740 */ 194, 194, 140, 194, 194, 71, 194, 244, 194, 194,
172577172859
 /* 1750 */ 162, 217, 218, 194, 194, 153, 154, 155, 156, 157,
172578
- /* 1760 */ 217, 218, 243, 217, 218, 192, 256, 256, 256, 244,
172579
- /* 1770 */ 298, 215, 272, 246, 100, 294, 268, 247, 272, 247,
172580
- /* 1780 */ 106, 107, 268, 294, 221, 183, 220, 272, 114, 220,
172581
- /* 1790 */ 116, 117, 118, 1, 2, 121, 272, 5, 230, 220,
172582
- /* 1800 */ 226, 260, 10, 11, 12, 13, 14, 246, 260, 17,
172583
- /* 1810 */ 281, 260, 250, 246, 140, 250, 197, 260, 60, 141,
172584
- /* 1820 */ 244, 201, 30, 201, 32, 38, 295, 153, 154, 155,
172585
- /* 1830 */ 156, 157, 40, 298, 201, 151, 150, 298, 22, 43,
172586
- /* 1840 */ 235, 18, 238, 201, 273, 238, 200, 19, 20, 271,
172587
- /* 1850 */ 22, 238, 238, 295, 284, 18, 149, 183, 247, 273,
172588
- /* 1860 */ 273, 271, 70, 247, 36, 247, 235, 235, 247, 201,
172589
- /* 1870 */ 78, 200, 158, 81, 291, 62, 201, 200, 22, 222,
172590
- /* 1880 */ 201, 290, 200, 222, 201, 200, 115, 59, 219, 219,
172591
- /* 1890 */ 98, 219, 228, 64, 22, 126, 165, 24, 225, 71,
172592
- /* 1900 */ 219, 225, 222, 306, 113, 313, 201, 219, 221, 219,
172593
- /* 1910 */ 219, 283, 283, 91, 222, 82, 318, 228, 318, 266,
172594
- /* 1920 */ 266, 148, 145, 22, 201, 133, 278, 280, 100, 147,
172595
- /* 1930 */ 138, 139, 158, 25, 106, 107, 146, 203, 13, 195,
172596
- /* 1940 */ 195, 247, 114, 250, 116, 117, 118, 251, 251, 121,
172597
- /* 1950 */ 249, 248, 6, 193, 162, 193, 193, 208, 223, 304,
172598
- /* 1960 */ 304, 301, 214, 208, 214, 214, 214, 4, 215, 223,
172599
- /* 1970 */ 3, 215, 208, 214, 22, 163, 15, 23, 16, 23,
172600
- /* 1980 */ 139, 153, 154, 155, 156, 157, 151, 130, 142, 25,
172601
- /* 1990 */ 24, 20, 144, 16, 1, 142, 130, 130, 61, 130,
172602
- /* 2000 */ 151, 53, 37, 53, 53, 116, 53, 34, 1, 141,
172603
- /* 2010 */ 5, 183, 22, 115, 25, 161, 75, 68, 141, 41,
172604
- /* 2020 */ 115, 24, 20, 68, 131, 19, 22, 125, 96, 59,
172605
- /* 2030 */ 22, 22, 37, 23, 22, 67, 67, 24, 22, 28,
172606
- /* 2040 */ 23, 67, 22, 149, 23, 23, 23, 22, 34, 25,
172607
- /* 2050 */ 141, 23, 23, 34, 97, 116, 22, 143, 25, 75,
172608
- /* 2060 */ 34, 34, 86, 88, 34, 34, 75, 23, 22, 34,
172609
- /* 2070 */ 25, 24, 93, 25, 34, 142, 44, 142, 23, 23,
172610
- /* 2080 */ 23, 23, 23, 11, 23, 25, 22, 22, 22, 1,
172611
- /* 2090 */ 23, 23, 22, 22, 25, 135, 15, 23, 25, 141,
172612
- /* 2100 */ 141, 1, 320, 320, 320, 320, 320, 320, 320, 320,
172613
- /* 2110 */ 320, 320, 320, 141, 320, 320, 320, 320, 320, 320,
172614
- /* 2120 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172615
- /* 2130 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172616
- /* 2140 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172617
- /* 2150 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172618
- /* 2160 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172619
- /* 2170 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172620
- /* 2180 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172621
- /* 2190 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172622
- /* 2200 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172623
- /* 2210 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172624
- /* 2220 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172625
- /* 2230 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172626
- /* 2240 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172627
- /* 2250 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172628
- /* 2260 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172629
- /* 2270 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172630
- /* 2280 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172631
- /* 2290 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172632
-};
172633
-#define YY_SHIFT_COUNT (578)
172860
+ /* 1760 */ 217, 218, 194, 217, 218, 194, 217, 218, 257, 217,
172861
+ /* 1770 */ 218, 217, 218, 257, 100, 194, 257, 217, 218, 257,
172862
+ /* 1780 */ 106, 107, 215, 299, 194, 183, 192, 194, 114, 194,
172863
+ /* 1790 */ 116, 117, 118, 1, 2, 121, 221, 5, 217, 218,
172864
+ /* 1800 */ 273, 197, 10, 11, 12, 13, 14, 217, 218, 17,
172865
+ /* 1810 */ 217, 218, 217, 218, 140, 194, 246, 194, 273, 295,
172866
+ /* 1820 */ 247, 273, 30, 247, 32, 269, 269, 153, 154, 155,
172867
+ /* 1830 */ 156, 157, 40, 246, 273, 295, 230, 226, 217, 218,
172868
+ /* 1840 */ 217, 218, 220, 261, 220, 282, 220, 19, 20, 244,
172869
+ /* 1850 */ 22, 250, 141, 250, 246, 60, 201, 183, 261, 261,
172870
+ /* 1860 */ 261, 201, 70, 299, 36, 299, 201, 38, 151, 150,
172871
+ /* 1870 */ 78, 285, 22, 81, 296, 296, 43, 235, 18, 238,
172872
+ /* 1880 */ 201, 274, 272, 238, 238, 238, 18, 59, 200, 149,
172873
+ /* 1890 */ 98, 247, 274, 274, 235, 247, 247, 247, 235, 71,
172874
+ /* 1900 */ 272, 201, 200, 158, 292, 62, 291, 201, 200, 22,
172875
+ /* 1910 */ 201, 222, 200, 222, 201, 200, 115, 219, 219, 64,
172876
+ /* 1920 */ 219, 228, 22, 126, 221, 133, 165, 222, 100, 225,
172877
+ /* 1930 */ 138, 139, 225, 219, 106, 107, 24, 219, 228, 219,
172878
+ /* 1940 */ 219, 307, 114, 113, 116, 117, 118, 315, 284, 121,
172879
+ /* 1950 */ 284, 222, 201, 91, 162, 320, 320, 82, 148, 267,
172880
+ /* 1960 */ 145, 267, 22, 279, 201, 158, 281, 251, 147, 146,
172881
+ /* 1970 */ 25, 203, 250, 249, 251, 248, 13, 247, 195, 195,
172882
+ /* 1980 */ 6, 153, 154, 155, 156, 157, 193, 193, 305, 193,
172883
+ /* 1990 */ 208, 305, 302, 214, 214, 214, 208, 223, 223, 214,
172884
+ /* 2000 */ 4, 215, 215, 214, 3, 22, 208, 163, 15, 23,
172885
+ /* 2010 */ 16, 183, 23, 139, 151, 130, 25, 20, 142, 24,
172886
+ /* 2020 */ 16, 144, 1, 142, 130, 130, 61, 37, 53, 151,
172887
+ /* 2030 */ 53, 53, 53, 130, 116, 1, 34, 141, 5, 22,
172888
+ /* 2040 */ 115, 161, 75, 25, 68, 141, 41, 115, 68, 24,
172889
+ /* 2050 */ 20, 19, 131, 125, 67, 67, 96, 22, 22, 22,
172890
+ /* 2060 */ 37, 23, 22, 24, 22, 59, 67, 23, 149, 28,
172891
+ /* 2070 */ 22, 25, 23, 23, 23, 22, 141, 34, 97, 23,
172892
+ /* 2080 */ 23, 34, 116, 22, 143, 25, 34, 75, 34, 34,
172893
+ /* 2090 */ 75, 88, 34, 86, 23, 22, 34, 25, 24, 34,
172894
+ /* 2100 */ 25, 93, 23, 44, 142, 23, 142, 23, 23, 22,
172895
+ /* 2110 */ 11, 25, 23, 25, 23, 22, 22, 22, 1, 23,
172896
+ /* 2120 */ 23, 23, 22, 22, 15, 141, 141, 25, 25, 1,
172897
+ /* 2130 */ 322, 322, 322, 135, 322, 322, 322, 322, 322, 322,
172898
+ /* 2140 */ 322, 141, 322, 322, 322, 322, 322, 322, 322, 322,
172899
+ /* 2150 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172900
+ /* 2160 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172901
+ /* 2170 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172902
+ /* 2180 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172903
+ /* 2190 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172904
+ /* 2200 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172905
+ /* 2210 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172906
+ /* 2220 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172907
+ /* 2230 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172908
+ /* 2240 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172909
+ /* 2250 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172910
+ /* 2260 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172911
+ /* 2270 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172912
+ /* 2280 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172913
+ /* 2290 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172914
+ /* 2300 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172915
+ /* 2310 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172916
+ /* 2320 */ 322, 322, 322, 322, 322, 322, 322, 322,
172917
+};
172918
+#define YY_SHIFT_COUNT (582)
172634172919
 #define YY_SHIFT_MIN (0)
172635
-#define YY_SHIFT_MAX (2100)
172920
+#define YY_SHIFT_MAX (2128)
172636172921
 static const unsigned short int yy_shift_ofst[] = {
172637
- /* 0 */ 1792, 1588, 1494, 322, 322, 1, 1319, 1339, 1430, 1828,
172638
- /* 10 */ 1828, 1828, 470, 0, 0, 214, 1093, 1828, 1828, 1828,
172639
- /* 20 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172640
- /* 30 */ 1828, 271, 271, 1198, 1198, 216, 88, 1, 1, 1,
172641
- /* 40 */ 1, 1, 40, 111, 258, 361, 469, 512, 583, 622,
172642
- /* 50 */ 693, 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093,
172643
- /* 60 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
172644
- /* 70 */ 1093, 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1523,
172645
- /* 80 */ 1602, 1674, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172646
- /* 90 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172922
+ /* 0 */ 1792, 1588, 1494, 322, 322, 399, 306, 1319, 1339, 1430,
172923
+ /* 10 */ 1828, 1828, 1828, 580, 399, 399, 399, 399, 399, 0,
172924
+ /* 20 */ 0, 214, 1093, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172925
+ /* 30 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1130, 1130,
172926
+ /* 40 */ 365, 365, 55, 278, 436, 713, 713, 201, 201, 201,
172927
+ /* 50 */ 201, 40, 111, 258, 361, 469, 512, 583, 622, 693,
172928
+ /* 60 */ 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093, 1093,
172929
+ /* 70 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
172930
+ /* 80 */ 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1523, 1602,
172931
+ /* 90 */ 1674, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172647172932
 /* 100 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172648172933
 /* 110 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172649172934
 /* 120 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172650
- /* 130 */ 1828, 137, 181, 181, 181, 181, 181, 181, 181, 94,
172651
- /* 140 */ 479, 66, 65, 112, 366, 645, 645, 629, 1168, 645,
172652
- /* 150 */ 645, 79, 79, 645, 795, 795, 795, 77, 795, 123,
172653
- /* 160 */ 113, 113, 113, 22, 22, 2114, 2114, 328, 328, 328,
172654
- /* 170 */ 239, 585, 585, 585, 585, 1031, 1031, 409, 366, 970,
172655
- /* 180 */ 1014, 645, 645, 645, 645, 645, 645, 645, 645, 645,
172656
- /* 190 */ 645, 645, 645, 645, 645, 645, 645, 645, 645, 645,
172657
- /* 200 */ 645, 969, 849, 849, 645, 972, 1118, 1118, 1279, 1279,
172658
- /* 210 */ 320, 320, 1283, 1331, 2114, 2114, 2114, 2114, 2114, 2114,
172659
- /* 220 */ 2114, 928, 1127, 1127, 589, 414, 640, 535, 695, 539,
172660
- /* 230 */ 649, 700, 645, 645, 645, 645, 645, 645, 645, 645,
172661
- /* 240 */ 645, 645, 222, 645, 645, 645, 645, 645, 645, 645,
172662
- /* 250 */ 645, 645, 645, 645, 645, 796, 796, 796, 645, 645,
172663
- /* 260 */ 645, 800, 645, 645, 645, 486, 1145, 645, 645, 1267,
172664
- /* 270 */ 645, 645, 645, 645, 645, 645, 645, 645, 145, 1223,
172665
- /* 280 */ 209, 1227, 1227, 1227, 1227, 1325, 209, 209, 1196, 190,
172666
- /* 290 */ 367, 1288, 1125, 1348, 405, 1348, 1419, 515, 1125, 1125,
172667
- /* 300 */ 515, 1125, 405, 1419, 1029, 306, 1346, 1350, 1350, 1350,
172668
- /* 310 */ 760, 760, 760, 760, 1423, 1423, 945, 1164, 939, 1490,
172669
- /* 320 */ 1758, 1758, 1678, 1678, 1787, 1787, 1678, 1684, 1686, 1816,
172670
- /* 330 */ 1796, 1823, 1823, 1823, 1823, 1678, 1837, 1707, 1686, 1686,
172671
- /* 340 */ 1707, 1816, 1796, 1707, 1796, 1707, 1678, 1837, 1714, 1813,
172672
- /* 350 */ 1678, 1837, 1856, 1678, 1837, 1678, 1837, 1856, 1771, 1771,
172673
- /* 360 */ 1771, 1829, 1872, 1872, 1856, 1771, 1769, 1771, 1829, 1771,
172674
- /* 370 */ 1771, 1731, 1873, 1791, 1791, 1856, 1678, 1822, 1822, 1833,
172675
- /* 380 */ 1833, 1773, 1777, 1901, 1678, 1774, 1773, 1782, 1790, 1707,
172676
- /* 390 */ 1908, 1925, 1925, 1946, 1946, 1946, 2114, 2114, 2114, 2114,
172677
- /* 400 */ 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114,
172678
- /* 410 */ 2114, 207, 1030, 1236, 1329, 912, 853, 1129, 1496, 1424,
172679
- /* 420 */ 1332, 1435, 1389, 1429, 1540, 1352, 1544, 1581, 1584, 1585,
172680
- /* 430 */ 1589, 1623, 1337, 1450, 1608, 1504, 1572, 208, 1452, 1537,
172681
- /* 440 */ 1630, 1639, 1599, 1640, 1542, 1545, 1662, 1706, 1575, 859,
172682
- /* 450 */ 1963, 1967, 1952, 1812, 1961, 1962, 1954, 1956, 1841, 1835,
172683
- /* 460 */ 1857, 1964, 1964, 1966, 1846, 1971, 1848, 1977, 1993, 1853,
172684
- /* 470 */ 1866, 1964, 1867, 1937, 1965, 1964, 1849, 1948, 1950, 1951,
172685
- /* 480 */ 1953, 1869, 1889, 1973, 1868, 2007, 2005, 1990, 1898, 1854,
172686
- /* 490 */ 1949, 1989, 1955, 1941, 1978, 1877, 1905, 1997, 2002, 2006,
172687
- /* 500 */ 1893, 1902, 2004, 1968, 2008, 2009, 2010, 2012, 1969, 1970,
172688
- /* 510 */ 2013, 1932, 2011, 2016, 1974, 1995, 2017, 2014, 1894, 2020,
172689
- /* 520 */ 2021, 2022, 2024, 2023, 2025, 1957, 1909, 2028, 2029, 1939,
172690
- /* 530 */ 2019, 2034, 1914, 2033, 2026, 2027, 2030, 2031, 1975, 1984,
172691
- /* 540 */ 1976, 2032, 1991, 1979, 2035, 2044, 2046, 2047, 2045, 2048,
172692
- /* 550 */ 2040, 1933, 1935, 2055, 2033, 2056, 2057, 2058, 2059, 2060,
172693
- /* 560 */ 2061, 2064, 2072, 2065, 2066, 2067, 2068, 2070, 2071, 2069,
172694
- /* 570 */ 1960, 1958, 1959, 1972, 2073, 2074, 2081, 2088, 2100,
172935
+ /* 130 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172936
+ /* 140 */ 137, 181, 181, 181, 181, 181, 181, 181, 96, 222,
172937
+ /* 150 */ 143, 477, 713, 1133, 1268, 713, 713, 79, 79, 713,
172938
+ /* 160 */ 770, 83, 65, 65, 65, 288, 162, 162, 2142, 2142,
172939
+ /* 170 */ 696, 696, 696, 238, 474, 474, 474, 474, 1217, 1217,
172940
+ /* 180 */ 678, 477, 324, 398, 713, 713, 713, 713, 713, 713,
172941
+ /* 190 */ 713, 713, 713, 713, 713, 713, 713, 713, 713, 713,
172942
+ /* 200 */ 713, 713, 713, 1220, 366, 366, 713, 917, 283, 283,
172943
+ /* 210 */ 434, 434, 605, 605, 1298, 2142, 2142, 2142, 2142, 2142,
172944
+ /* 220 */ 2142, 2142, 1179, 1157, 1157, 487, 527, 585, 645, 749,
172945
+ /* 230 */ 914, 968, 752, 713, 713, 713, 713, 713, 713, 713,
172946
+ /* 240 */ 713, 713, 713, 303, 713, 713, 713, 713, 713, 713,
172947
+ /* 250 */ 713, 713, 713, 713, 713, 713, 797, 797, 797, 713,
172948
+ /* 260 */ 713, 713, 959, 713, 713, 713, 1169, 1271, 713, 713,
172949
+ /* 270 */ 1330, 713, 713, 713, 713, 713, 713, 713, 713, 629,
172950
+ /* 280 */ 7, 91, 876, 876, 876, 876, 953, 91, 91, 1246,
172951
+ /* 290 */ 1065, 1106, 1374, 1329, 1348, 468, 1348, 1394, 785, 1329,
172952
+ /* 300 */ 1329, 785, 1329, 468, 1394, 859, 854, 1402, 1449, 1449,
172953
+ /* 310 */ 1449, 1173, 1173, 1173, 1173, 1355, 1355, 1030, 1341, 405,
172954
+ /* 320 */ 1230, 1795, 1795, 1711, 1711, 1829, 1829, 1711, 1717, 1719,
172955
+ /* 330 */ 1850, 1833, 1860, 1860, 1860, 1860, 1711, 1868, 1740, 1719,
172956
+ /* 340 */ 1719, 1740, 1850, 1833, 1740, 1833, 1740, 1711, 1868, 1745,
172957
+ /* 350 */ 1843, 1711, 1868, 1887, 1711, 1868, 1711, 1868, 1887, 1801,
172958
+ /* 360 */ 1801, 1801, 1855, 1900, 1900, 1887, 1801, 1797, 1801, 1855,
172959
+ /* 370 */ 1801, 1801, 1761, 1912, 1830, 1830, 1887, 1711, 1862, 1862,
172960
+ /* 380 */ 1875, 1875, 1810, 1815, 1940, 1711, 1807, 1810, 1821, 1823,
172961
+ /* 390 */ 1740, 1945, 1963, 1963, 1974, 1974, 1974, 2142, 2142, 2142,
172962
+ /* 400 */ 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142,
172963
+ /* 410 */ 2142, 2142, 20, 1224, 256, 1111, 1115, 1114, 1192, 1496,
172964
+ /* 420 */ 1424, 1505, 1427, 355, 1383, 1537, 1506, 1538, 1553, 1583,
172965
+ /* 430 */ 1584, 1591, 1625, 541, 1445, 1562, 1450, 1572, 1515, 1428,
172966
+ /* 440 */ 1532, 1592, 1629, 1520, 1630, 1639, 1510, 1544, 1662, 1675,
172967
+ /* 450 */ 1551, 48, 1996, 2001, 1983, 1844, 1993, 1994, 1986, 1989,
172968
+ /* 460 */ 1874, 1863, 1885, 1991, 1991, 1995, 1876, 1997, 1877, 2004,
172969
+ /* 470 */ 2021, 1881, 1894, 1991, 1895, 1965, 1990, 1991, 1878, 1975,
172970
+ /* 480 */ 1977, 1978, 1979, 1903, 1918, 2002, 1896, 2034, 2033, 2017,
172971
+ /* 490 */ 1925, 1880, 1976, 2018, 1980, 1967, 2005, 1904, 1932, 2025,
172972
+ /* 500 */ 2030, 2032, 1921, 1928, 2035, 1987, 2036, 2037, 2038, 2040,
172973
+ /* 510 */ 1988, 2006, 2039, 1960, 2041, 2042, 1999, 2023, 2044, 2043,
172974
+ /* 520 */ 1919, 2048, 2049, 2050, 2046, 2051, 2053, 1981, 1935, 2056,
172975
+ /* 530 */ 2057, 1966, 2047, 2061, 1941, 2060, 2052, 2054, 2055, 2058,
172976
+ /* 540 */ 2003, 2012, 2007, 2059, 2015, 2008, 2062, 2071, 2073, 2074,
172977
+ /* 550 */ 2072, 2075, 2065, 1962, 1964, 2079, 2060, 2082, 2084, 2085,
172978
+ /* 560 */ 2087, 2086, 2089, 2088, 2091, 2093, 2099, 2094, 2095, 2096,
172979
+ /* 570 */ 2097, 2100, 2101, 2102, 1998, 1984, 1985, 2000, 2103, 2098,
172980
+ /* 580 */ 2109, 2117, 2128,
172695172981
 };
172696
-#define YY_REDUCE_COUNT (410)
172697
-#define YY_REDUCE_MIN (-272)
172698
-#define YY_REDUCE_MAX (1764)
172982
+#define YY_REDUCE_COUNT (411)
172983
+#define YY_REDUCE_MIN (-275)
172984
+#define YY_REDUCE_MAX (1798)
172699172985
 static const short yy_reduce_ofst[] = {
172700
- /* 0 */ -126, 731, 343, 240, 835, -124, -194, -192, -184, -188,
172701
- /* 10 */ 165, 237, 132, -208, -200, -268, -177, -7, 203, 310,
172702
- /* 20 */ 312, 466, -176, 576, 597, 82, 615, 685, 706, 779,
172703
- /* 30 */ 833, 886, 960, 86, 401, -193, 623, 625, 737, 794,
172704
- /* 40 */ 837, 988, -272, -272, -272, -272, -272, -272, -272, -272,
172705
- /* 50 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172706
- /* 60 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172707
- /* 70 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, 503,
172708
- /* 80 */ 838, 916, 1015, 1019, 1037, 1059, 1084, 1090, 1095, 1117,
172709
- /* 90 */ 1139, 1146, 1148, 1151, 1155, 1159, 1166, 1176, 1185, 1188,
172710
- /* 100 */ 1194, 1197, 1203, 1205, 1214, 1224, 1264, 1268, 1270, 1273,
172711
- /* 110 */ 1315, 1322, 1335, 1344, 1356, 1360, 1362, 1425, 1432, 1442,
172712
- /* 120 */ 1453, 1457, 1473, 1487, 1495, 1507, 1517, 1521, 1534, 1543,
172713
- /* 130 */ 1546, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172714
- /* 140 */ -272, -272, 204, 248, 455, -159, 358, 482, -213, 577,
172715
- /* 150 */ 411, -196, -93, 293, 627, 631, 627, -272, 631, 687,
172716
- /* 160 */ 120, 783, 840, -272, -272, -272, -272, 273, 273, 273,
172717
- /* 170 */ 160, 980, 1048, 1102, 1111, 313, 376, 193, 452, 471,
172718
- /* 180 */ 471, -167, -162, 460, 506, 736, 792, 847, 854, -123,
172719
- /* 190 */ 613, -121, 844, 1098, 897, 1152, 1056, 520, 1099, 519,
172720
- /* 200 */ 1153, 679, 621, 821, 262, 170, 898, 924, 841, 982,
172721
- /* 210 */ 1177, 1191, 349, 1210, 1178, 628, 1189, 1255, 1258, 1226,
172722
- /* 220 */ 1272, -195, -8, 184, -136, 255, 399, 410, 453, 566,
172723
- /* 230 */ 578, 616, 633, 743, 998, 1103, 1106, 1213, 1233, 1271,
172724
- /* 240 */ 1286, 1334, 551, 1361, 1366, 1372, 1397, 1409, 1417, 1451,
172725
- /* 250 */ 1458, 1463, 1474, 1505, 1509, 767, 1250, 1298, 1478, 1513,
172726
- /* 260 */ 1520, 421, 1528, 1536, 1538, 1275, 1365, 1547, 1549, 1380,
172727
- /* 270 */ 1550, 410, 1552, 1553, 1554, 1555, 1559, 1560, 1399, 1448,
172728
- /* 280 */ 1519, 1461, 1510, 1511, 1512, 421, 1519, 1519, 1525, 1556,
172729
- /* 290 */ 1573, 1472, 1500, 1508, 1527, 1514, 1481, 1530, 1506, 1515,
172730
- /* 300 */ 1532, 1524, 1561, 1489, 1563, 1568, 1574, 1566, 1569, 1579,
172731
- /* 310 */ 1541, 1548, 1551, 1557, 1562, 1565, 1529, 1567, 1576, 1619,
172732
- /* 320 */ 1535, 1539, 1620, 1622, 1531, 1558, 1633, 1570, 1571, 1578,
172733
- /* 330 */ 1605, 1604, 1607, 1613, 1614, 1642, 1646, 1611, 1586, 1587,
172734
- /* 340 */ 1616, 1590, 1631, 1618, 1632, 1621, 1668, 1671, 1583, 1591,
172735
- /* 350 */ 1675, 1677, 1657, 1679, 1682, 1683, 1685, 1661, 1669, 1670,
172736
- /* 360 */ 1672, 1664, 1673, 1676, 1680, 1681, 1687, 1688, 1689, 1690,
172737
- /* 370 */ 1691, 1592, 1597, 1628, 1629, 1692, 1705, 1598, 1600, 1653,
172738
- /* 380 */ 1654, 1696, 1693, 1648, 1723, 1647, 1697, 1701, 1703, 1694,
172739
- /* 390 */ 1734, 1744, 1745, 1760, 1762, 1763, 1655, 1656, 1660, 1749,
172740
- /* 400 */ 1748, 1750, 1751, 1752, 1755, 1735, 1746, 1753, 1756, 1759,
172741
- /* 410 */ 1764,
172986
+ /* 0 */ -71, 194, 343, 835, -180, -177, 838, -194, -188, -185,
172987
+ /* 10 */ -183, 82, 183, -65, 133, 245, 346, 407, 458, -178,
172988
+ /* 20 */ 75, -275, -4, 310, 312, 489, 575, 596, 463, 686,
172989
+ /* 30 */ 707, 725, 780, 1098, 856, 778, 1059, 1090, 708, 887,
172990
+ /* 40 */ 86, 448, 980, 630, 680, 681, 684, 796, 801, 796,
172991
+ /* 50 */ 801, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172992
+ /* 60 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172993
+ /* 70 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172994
+ /* 80 */ -261, -261, -261, -261, -261, -261, -261, -261, 391, 886,
172995
+ /* 90 */ 888, 1013, 1016, 1081, 1087, 1151, 1159, 1177, 1185, 1188,
172996
+ /* 100 */ 1190, 1194, 1197, 1203, 1247, 1260, 1264, 1267, 1269, 1273,
172997
+ /* 110 */ 1315, 1322, 1335, 1337, 1356, 1362, 1418, 1425, 1453, 1457,
172998
+ /* 120 */ 1465, 1473, 1487, 1495, 1507, 1517, 1521, 1534, 1543, 1546,
172999
+ /* 130 */ 1549, 1552, 1554, 1560, 1581, 1590, 1593, 1595, 1621, 1623,
173000
+ /* 140 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
173001
+ /* 150 */ -261, -186, -117, 260, 263, 460, 631, -74, 497, -181,
173002
+ /* 160 */ -261, 939, 176, 274, 338, 676, -261, -261, -261, -261,
173003
+ /* 170 */ -212, -212, -212, -184, 149, 777, 1061, 1103, 265, 419,
173004
+ /* 180 */ -254, 670, 677, 677, -11, -129, 184, 488, 736, 789,
173005
+ /* 190 */ 805, 844, 403, 529, 579, 668, 783, 841, 1158, 1112,
173006
+ /* 200 */ 806, 861, 1095, 846, 839, 1031, -189, 1077, 1080, 1116,
173007
+ /* 210 */ 1084, 1156, 1139, 1221, 46, 1099, 1037, 1118, 1171, 1214,
173008
+ /* 220 */ 1210, 1258, -210, -190, -176, -115, 117, 262, 376, 490,
173009
+ /* 230 */ 511, 520, 618, 639, 743, 901, 907, 958, 1014, 1055,
173010
+ /* 240 */ 1108, 1193, 1244, 720, 1248, 1277, 1324, 1347, 1417, 1431,
173011
+ /* 250 */ 1432, 1440, 1451, 1452, 1463, 1478, 1286, 1350, 1369, 1490,
173012
+ /* 260 */ 1498, 1501, 773, 1509, 1513, 1528, 1292, 1367, 1535, 1536,
173013
+ /* 270 */ 1477, 1542, 376, 1547, 1550, 1555, 1559, 1568, 1571, 1441,
173014
+ /* 280 */ 1443, 1474, 1511, 1516, 1519, 1522, 773, 1474, 1474, 1503,
173015
+ /* 290 */ 1567, 1594, 1484, 1527, 1556, 1570, 1557, 1524, 1573, 1545,
173016
+ /* 300 */ 1548, 1576, 1561, 1587, 1540, 1575, 1606, 1611, 1622, 1624,
173017
+ /* 310 */ 1626, 1582, 1597, 1598, 1599, 1601, 1603, 1563, 1608, 1605,
173018
+ /* 320 */ 1604, 1564, 1566, 1655, 1660, 1578, 1579, 1665, 1586, 1607,
173019
+ /* 330 */ 1610, 1642, 1641, 1645, 1646, 1647, 1679, 1688, 1644, 1618,
173020
+ /* 340 */ 1619, 1648, 1628, 1659, 1649, 1663, 1650, 1700, 1702, 1612,
173021
+ /* 350 */ 1615, 1706, 1708, 1689, 1709, 1712, 1713, 1715, 1691, 1698,
173022
+ /* 360 */ 1699, 1701, 1693, 1704, 1707, 1705, 1714, 1703, 1718, 1710,
173023
+ /* 370 */ 1720, 1721, 1632, 1634, 1664, 1666, 1729, 1751, 1635, 1636,
173024
+ /* 380 */ 1692, 1694, 1716, 1722, 1684, 1763, 1685, 1723, 1724, 1727,
173025
+ /* 390 */ 1730, 1768, 1783, 1784, 1793, 1794, 1796, 1683, 1686, 1690,
173026
+ /* 400 */ 1782, 1779, 1780, 1781, 1785, 1788, 1774, 1775, 1786, 1787,
173027
+ /* 410 */ 1789, 1798,
172742173028
 };
172743173029
 static const YYACTIONTYPE yy_default[] = {
172744
- /* 0 */ 1651, 1651, 1651, 1480, 1245, 1356, 1245, 1245, 1245, 1480,
172745
- /* 10 */ 1480, 1480, 1245, 1386, 1386, 1533, 1278, 1245, 1245, 1245,
172746
- /* 20 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1479, 1245,
172747
- /* 30 */ 1245, 1245, 1245, 1566, 1566, 1245, 1245, 1245, 1245, 1245,
172748
- /* 40 */ 1245, 1245, 1245, 1395, 1245, 1402, 1245, 1245, 1245, 1245,
172749
- /* 50 */ 1245, 1481, 1482, 1245, 1245, 1245, 1532, 1534, 1497, 1409,
172750
- /* 60 */ 1408, 1407, 1406, 1515, 1374, 1400, 1393, 1397, 1476, 1477,
172751
- /* 70 */ 1475, 1629, 1482, 1481, 1245, 1396, 1444, 1460, 1443, 1245,
172752
- /* 80 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172753
- /* 90 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172754
- /* 100 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172755
- /* 110 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172756
- /* 120 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172757
- /* 130 */ 1245, 1452, 1459, 1458, 1457, 1466, 1456, 1453, 1446, 1445,
172758
- /* 140 */ 1447, 1448, 1245, 1245, 1269, 1245, 1245, 1266, 1320, 1245,
172759
- /* 150 */ 1245, 1245, 1245, 1245, 1552, 1551, 1245, 1449, 1245, 1278,
172760
- /* 160 */ 1437, 1436, 1435, 1463, 1450, 1462, 1461, 1540, 1603, 1602,
172761
- /* 170 */ 1498, 1245, 1245, 1245, 1245, 1245, 1245, 1566, 1245, 1245,
172762
- /* 180 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172763
- /* 190 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172764
- /* 200 */ 1245, 1376, 1566, 1566, 1245, 1278, 1566, 1566, 1377, 1377,
172765
- /* 210 */ 1274, 1274, 1380, 1245, 1547, 1347, 1347, 1347, 1347, 1356,
172766
- /* 220 */ 1347, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172767
- /* 230 */ 1245, 1245, 1245, 1245, 1245, 1245, 1537, 1535, 1245, 1245,
172768
- /* 240 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172769
- /* 250 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172770
- /* 260 */ 1245, 1245, 1245, 1245, 1245, 1352, 1245, 1245, 1245, 1245,
172771
- /* 270 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1596, 1245, 1510,
172772
- /* 280 */ 1334, 1352, 1352, 1352, 1352, 1354, 1335, 1333, 1346, 1279,
172773
- /* 290 */ 1252, 1643, 1412, 1401, 1353, 1401, 1640, 1399, 1412, 1412,
172774
- /* 300 */ 1399, 1412, 1353, 1640, 1295, 1618, 1290, 1386, 1386, 1386,
172775
- /* 310 */ 1376, 1376, 1376, 1376, 1380, 1380, 1478, 1353, 1346, 1245,
172776
- /* 320 */ 1643, 1643, 1362, 1362, 1642, 1642, 1362, 1498, 1626, 1421,
172777
- /* 330 */ 1323, 1329, 1329, 1329, 1329, 1362, 1263, 1399, 1626, 1626,
172778
- /* 340 */ 1399, 1421, 1323, 1399, 1323, 1399, 1362, 1263, 1514, 1637,
172779
- /* 350 */ 1362, 1263, 1488, 1362, 1263, 1362, 1263, 1488, 1321, 1321,
172780
- /* 360 */ 1321, 1310, 1245, 1245, 1488, 1321, 1295, 1321, 1310, 1321,
172781
- /* 370 */ 1321, 1584, 1245, 1492, 1492, 1488, 1362, 1576, 1576, 1389,
172782
- /* 380 */ 1389, 1394, 1380, 1483, 1362, 1245, 1394, 1392, 1390, 1399,
172783
- /* 390 */ 1313, 1599, 1599, 1595, 1595, 1595, 1648, 1648, 1547, 1611,
172784
- /* 400 */ 1278, 1278, 1278, 1278, 1611, 1297, 1297, 1279, 1279, 1278,
172785
- /* 410 */ 1611, 1245, 1245, 1245, 1245, 1245, 1245, 1606, 1245, 1542,
172786
- /* 420 */ 1499, 1366, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172787
- /* 430 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1553, 1245,
172788
- /* 440 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1426,
172789
- /* 450 */ 1245, 1248, 1544, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172790
- /* 460 */ 1245, 1403, 1404, 1367, 1245, 1245, 1245, 1245, 1245, 1245,
172791
- /* 470 */ 1245, 1418, 1245, 1245, 1245, 1413, 1245, 1245, 1245, 1245,
172792
- /* 480 */ 1245, 1245, 1245, 1245, 1639, 1245, 1245, 1245, 1245, 1245,
172793
- /* 490 */ 1245, 1513, 1512, 1245, 1245, 1364, 1245, 1245, 1245, 1245,
172794
- /* 500 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1293,
172795
- /* 510 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172796
- /* 520 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172797
- /* 530 */ 1245, 1245, 1245, 1391, 1245, 1245, 1245, 1245, 1245, 1245,
172798
- /* 540 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1581, 1381,
172799
- /* 550 */ 1245, 1245, 1245, 1245, 1630, 1245, 1245, 1245, 1245, 1245,
172800
- /* 560 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1622,
172801
- /* 570 */ 1337, 1427, 1245, 1430, 1267, 1245, 1257, 1245, 1245,
173030
+ /* 0 */ 1663, 1663, 1663, 1491, 1254, 1367, 1254, 1254, 1254, 1254,
173031
+ /* 10 */ 1491, 1491, 1491, 1254, 1254, 1254, 1254, 1254, 1254, 1397,
173032
+ /* 20 */ 1397, 1544, 1287, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173033
+ /* 30 */ 1254, 1254, 1254, 1254, 1254, 1490, 1254, 1254, 1254, 1254,
173034
+ /* 40 */ 1578, 1578, 1254, 1254, 1254, 1254, 1254, 1563, 1562, 1254,
173035
+ /* 50 */ 1254, 1254, 1406, 1254, 1413, 1254, 1254, 1254, 1254, 1254,
173036
+ /* 60 */ 1492, 1493, 1254, 1254, 1254, 1543, 1545, 1508, 1420, 1419,
173037
+ /* 70 */ 1418, 1417, 1526, 1385, 1411, 1404, 1408, 1487, 1488, 1486,
173038
+ /* 80 */ 1641, 1493, 1492, 1254, 1407, 1455, 1471, 1454, 1254, 1254,
173039
+ /* 90 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173040
+ /* 100 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173041
+ /* 110 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173042
+ /* 120 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173043
+ /* 130 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173044
+ /* 140 */ 1463, 1470, 1469, 1468, 1477, 1467, 1464, 1457, 1456, 1458,
173045
+ /* 150 */ 1459, 1278, 1254, 1275, 1329, 1254, 1254, 1254, 1254, 1254,
173046
+ /* 160 */ 1460, 1287, 1448, 1447, 1446, 1254, 1474, 1461, 1473, 1472,
173047
+ /* 170 */ 1551, 1615, 1614, 1509, 1254, 1254, 1254, 1254, 1254, 1254,
173048
+ /* 180 */ 1578, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173049
+ /* 190 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173050
+ /* 200 */ 1254, 1254, 1254, 1387, 1578, 1578, 1254, 1287, 1578, 1578,
173051
+ /* 210 */ 1388, 1388, 1283, 1283, 1391, 1558, 1358, 1358, 1358, 1358,
173052
+ /* 220 */ 1367, 1358, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173053
+ /* 230 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1548, 1546, 1254,
173054
+ /* 240 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173055
+ /* 250 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173056
+ /* 260 */ 1254, 1254, 1254, 1254, 1254, 1254, 1363, 1254, 1254, 1254,
173057
+ /* 270 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1608, 1254,
173058
+ /* 280 */ 1521, 1343, 1363, 1363, 1363, 1363, 1365, 1344, 1342, 1357,
173059
+ /* 290 */ 1288, 1261, 1655, 1423, 1412, 1364, 1412, 1652, 1410, 1423,
173060
+ /* 300 */ 1423, 1410, 1423, 1364, 1652, 1304, 1630, 1299, 1397, 1397,
173061
+ /* 310 */ 1397, 1387, 1387, 1387, 1387, 1391, 1391, 1489, 1364, 1357,
173062
+ /* 320 */ 1254, 1655, 1655, 1373, 1373, 1654, 1654, 1373, 1509, 1638,
173063
+ /* 330 */ 1432, 1332, 1338, 1338, 1338, 1338, 1373, 1272, 1410, 1638,
173064
+ /* 340 */ 1638, 1410, 1432, 1332, 1410, 1332, 1410, 1373, 1272, 1525,
173065
+ /* 350 */ 1649, 1373, 1272, 1499, 1373, 1272, 1373, 1272, 1499, 1330,
173066
+ /* 360 */ 1330, 1330, 1319, 1254, 1254, 1499, 1330, 1304, 1330, 1319,
173067
+ /* 370 */ 1330, 1330, 1596, 1254, 1503, 1503, 1499, 1373, 1588, 1588,
173068
+ /* 380 */ 1400, 1400, 1405, 1391, 1494, 1373, 1254, 1405, 1403, 1401,
173069
+ /* 390 */ 1410, 1322, 1611, 1611, 1607, 1607, 1607, 1660, 1660, 1558,
173070
+ /* 400 */ 1623, 1287, 1287, 1287, 1287, 1623, 1306, 1306, 1288, 1288,
173071
+ /* 410 */ 1287, 1623, 1254, 1254, 1254, 1254, 1254, 1254, 1618, 1254,
173072
+ /* 420 */ 1553, 1510, 1377, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173073
+ /* 430 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1564,
173074
+ /* 440 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173075
+ /* 450 */ 1254, 1437, 1254, 1257, 1555, 1254, 1254, 1254, 1254, 1254,
173076
+ /* 460 */ 1254, 1254, 1254, 1414, 1415, 1378, 1254, 1254, 1254, 1254,
173077
+ /* 470 */ 1254, 1254, 1254, 1429, 1254, 1254, 1254, 1424, 1254, 1254,
173078
+ /* 480 */ 1254, 1254, 1254, 1254, 1254, 1254, 1651, 1254, 1254, 1254,
173079
+ /* 490 */ 1254, 1254, 1254, 1524, 1523, 1254, 1254, 1375, 1254, 1254,
173080
+ /* 500 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173081
+ /* 510 */ 1254, 1302, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173082
+ /* 520 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173083
+ /* 530 */ 1254, 1254, 1254, 1254, 1254, 1402, 1254, 1254, 1254, 1254,
173084
+ /* 540 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173085
+ /* 550 */ 1593, 1392, 1254, 1254, 1254, 1254, 1642, 1254, 1254, 1254,
173086
+ /* 560 */ 1254, 1352, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173087
+ /* 570 */ 1254, 1254, 1254, 1634, 1346, 1438, 1254, 1441, 1276, 1254,
173088
+ /* 580 */ 1266, 1254, 1254,
172802173089
 };
172803173090
 /********** End of lemon-generated parsing tables *****************************/
172804173091
172805173092
 /* The next table maps tokens (terminal symbols) into fallback tokens.
172806173093
 ** If a construct like the following:
@@ -173340,75 +173627,77 @@
173340173627
 /* 250 */ "orderby_opt",
173341173628
 /* 251 */ "limit_opt",
173342173629
 /* 252 */ "window_clause",
173343173630
 /* 253 */ "values",
173344173631
 /* 254 */ "nexprlist",
173345
- /* 255 */ "sclp",
173346
- /* 256 */ "as",
173347
- /* 257 */ "seltablist",
173348
- /* 258 */ "stl_prefix",
173349
- /* 259 */ "joinop",
173350
- /* 260 */ "on_using",
173351
- /* 261 */ "indexed_by",
173352
- /* 262 */ "exprlist",
173353
- /* 263 */ "xfullname",
173354
- /* 264 */ "idlist",
173355
- /* 265 */ "indexed_opt",
173356
- /* 266 */ "nulls",
173357
- /* 267 */ "with",
173358
- /* 268 */ "where_opt_ret",
173359
- /* 269 */ "setlist",
173360
- /* 270 */ "insert_cmd",
173361
- /* 271 */ "idlist_opt",
173362
- /* 272 */ "upsert",
173363
- /* 273 */ "returning",
173364
- /* 274 */ "filter_over",
173365
- /* 275 */ "likeop",
173366
- /* 276 */ "between_op",
173367
- /* 277 */ "in_op",
173368
- /* 278 */ "paren_exprlist",
173369
- /* 279 */ "case_operand",
173370
- /* 280 */ "case_exprlist",
173371
- /* 281 */ "case_else",
173372
- /* 282 */ "uniqueflag",
173373
- /* 283 */ "collate",
173374
- /* 284 */ "vinto",
173375
- /* 285 */ "nmnum",
173376
- /* 286 */ "trigger_decl",
173377
- /* 287 */ "trigger_cmd_list",
173378
- /* 288 */ "trigger_time",
173379
- /* 289 */ "trigger_event",
173380
- /* 290 */ "foreach_clause",
173381
- /* 291 */ "when_clause",
173382
- /* 292 */ "trigger_cmd",
173383
- /* 293 */ "trnm",
173384
- /* 294 */ "tridxby",
173385
- /* 295 */ "database_kw_opt",
173386
- /* 296 */ "key_opt",
173387
- /* 297 */ "add_column_fullname",
173388
- /* 298 */ "kwcolumn_opt",
173389
- /* 299 */ "create_vtab",
173390
- /* 300 */ "vtabarglist",
173391
- /* 301 */ "vtabarg",
173392
- /* 302 */ "vtabargtoken",
173393
- /* 303 */ "lp",
173394
- /* 304 */ "anylist",
173395
- /* 305 */ "wqitem",
173396
- /* 306 */ "wqas",
173397
- /* 307 */ "windowdefn_list",
173398
- /* 308 */ "windowdefn",
173399
- /* 309 */ "window",
173400
- /* 310 */ "frame_opt",
173401
- /* 311 */ "part_opt",
173402
- /* 312 */ "filter_clause",
173403
- /* 313 */ "over_clause",
173404
- /* 314 */ "range_or_rows",
173405
- /* 315 */ "frame_bound",
173406
- /* 316 */ "frame_bound_s",
173407
- /* 317 */ "frame_bound_e",
173408
- /* 318 */ "frame_exclude_opt",
173409
- /* 319 */ "frame_exclude",
173632
+ /* 255 */ "mvalues",
173633
+ /* 256 */ "sclp",
173634
+ /* 257 */ "as",
173635
+ /* 258 */ "seltablist",
173636
+ /* 259 */ "stl_prefix",
173637
+ /* 260 */ "joinop",
173638
+ /* 261 */ "on_using",
173639
+ /* 262 */ "indexed_by",
173640
+ /* 263 */ "exprlist",
173641
+ /* 264 */ "xfullname",
173642
+ /* 265 */ "idlist",
173643
+ /* 266 */ "indexed_opt",
173644
+ /* 267 */ "nulls",
173645
+ /* 268 */ "with",
173646
+ /* 269 */ "where_opt_ret",
173647
+ /* 270 */ "setlist",
173648
+ /* 271 */ "insert_cmd",
173649
+ /* 272 */ "idlist_opt",
173650
+ /* 273 */ "upsert",
173651
+ /* 274 */ "returning",
173652
+ /* 275 */ "filter_over",
173653
+ /* 276 */ "likeop",
173654
+ /* 277 */ "between_op",
173655
+ /* 278 */ "in_op",
173656
+ /* 279 */ "paren_exprlist",
173657
+ /* 280 */ "case_operand",
173658
+ /* 281 */ "case_exprlist",
173659
+ /* 282 */ "case_else",
173660
+ /* 283 */ "uniqueflag",
173661
+ /* 284 */ "collate",
173662
+ /* 285 */ "vinto",
173663
+ /* 286 */ "nmnum",
173664
+ /* 287 */ "trigger_decl",
173665
+ /* 288 */ "trigger_cmd_list",
173666
+ /* 289 */ "trigger_time",
173667
+ /* 290 */ "trigger_event",
173668
+ /* 291 */ "foreach_clause",
173669
+ /* 292 */ "when_clause",
173670
+ /* 293 */ "trigger_cmd",
173671
+ /* 294 */ "trnm",
173672
+ /* 295 */ "tridxby",
173673
+ /* 296 */ "database_kw_opt",
173674
+ /* 297 */ "key_opt",
173675
+ /* 298 */ "add_column_fullname",
173676
+ /* 299 */ "kwcolumn_opt",
173677
+ /* 300 */ "create_vtab",
173678
+ /* 301 */ "vtabarglist",
173679
+ /* 302 */ "vtabarg",
173680
+ /* 303 */ "vtabargtoken",
173681
+ /* 304 */ "lp",
173682
+ /* 305 */ "anylist",
173683
+ /* 306 */ "wqitem",
173684
+ /* 307 */ "wqas",
173685
+ /* 308 */ "withnm",
173686
+ /* 309 */ "windowdefn_list",
173687
+ /* 310 */ "windowdefn",
173688
+ /* 311 */ "window",
173689
+ /* 312 */ "frame_opt",
173690
+ /* 313 */ "part_opt",
173691
+ /* 314 */ "filter_clause",
173692
+ /* 315 */ "over_clause",
173693
+ /* 316 */ "range_or_rows",
173694
+ /* 317 */ "frame_bound",
173695
+ /* 318 */ "frame_bound_s",
173696
+ /* 319 */ "frame_bound_e",
173697
+ /* 320 */ "frame_exclude_opt",
173698
+ /* 321 */ "frame_exclude",
173410173699
 };
173411173700
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
173412173701
173413173702
 #ifndef NDEBUG
173414173703
 /* For tracing reduce actions, the names of all rules are required.
@@ -173507,321 +173796,324 @@
173507173796
 /* 90 */ "multiselect_op ::= UNION ALL",
173508173797
 /* 91 */ "multiselect_op ::= EXCEPT|INTERSECT",
173509173798
 /* 92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
173510173799
 /* 93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
173511173800
 /* 94 */ "values ::= VALUES LP nexprlist RP",
173512
- /* 95 */ "values ::= values COMMA LP nexprlist RP",
173513
- /* 96 */ "distinct ::= DISTINCT",
173514
- /* 97 */ "distinct ::= ALL",
173515
- /* 98 */ "distinct ::=",
173516
- /* 99 */ "sclp ::=",
173517
- /* 100 */ "selcollist ::= sclp scanpt expr scanpt as",
173518
- /* 101 */ "selcollist ::= sclp scanpt STAR",
173519
- /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR",
173520
- /* 103 */ "as ::= AS nm",
173521
- /* 104 */ "as ::=",
173522
- /* 105 */ "from ::=",
173523
- /* 106 */ "from ::= FROM seltablist",
173524
- /* 107 */ "stl_prefix ::= seltablist joinop",
173525
- /* 108 */ "stl_prefix ::=",
173526
- /* 109 */ "seltablist ::= stl_prefix nm dbnm as on_using",
173527
- /* 110 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
173528
- /* 111 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
173529
- /* 112 */ "seltablist ::= stl_prefix LP select RP as on_using",
173530
- /* 113 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
173531
- /* 114 */ "dbnm ::=",
173532
- /* 115 */ "dbnm ::= DOT nm",
173533
- /* 116 */ "fullname ::= nm",
173534
- /* 117 */ "fullname ::= nm DOT nm",
173535
- /* 118 */ "xfullname ::= nm",
173536
- /* 119 */ "xfullname ::= nm DOT nm",
173537
- /* 120 */ "xfullname ::= nm DOT nm AS nm",
173538
- /* 121 */ "xfullname ::= nm AS nm",
173539
- /* 122 */ "joinop ::= COMMA|JOIN",
173540
- /* 123 */ "joinop ::= JOIN_KW JOIN",
173541
- /* 124 */ "joinop ::= JOIN_KW nm JOIN",
173542
- /* 125 */ "joinop ::= JOIN_KW nm nm JOIN",
173543
- /* 126 */ "on_using ::= ON expr",
173544
- /* 127 */ "on_using ::= USING LP idlist RP",
173545
- /* 128 */ "on_using ::=",
173546
- /* 129 */ "indexed_opt ::=",
173547
- /* 130 */ "indexed_by ::= INDEXED BY nm",
173548
- /* 131 */ "indexed_by ::= NOT INDEXED",
173549
- /* 132 */ "orderby_opt ::=",
173550
- /* 133 */ "orderby_opt ::= ORDER BY sortlist",
173551
- /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
173552
- /* 135 */ "sortlist ::= expr sortorder nulls",
173553
- /* 136 */ "sortorder ::= ASC",
173554
- /* 137 */ "sortorder ::= DESC",
173555
- /* 138 */ "sortorder ::=",
173556
- /* 139 */ "nulls ::= NULLS FIRST",
173557
- /* 140 */ "nulls ::= NULLS LAST",
173558
- /* 141 */ "nulls ::=",
173559
- /* 142 */ "groupby_opt ::=",
173560
- /* 143 */ "groupby_opt ::= GROUP BY nexprlist",
173561
- /* 144 */ "having_opt ::=",
173562
- /* 145 */ "having_opt ::= HAVING expr",
173563
- /* 146 */ "limit_opt ::=",
173564
- /* 147 */ "limit_opt ::= LIMIT expr",
173565
- /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr",
173566
- /* 149 */ "limit_opt ::= LIMIT expr COMMA expr",
173567
- /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
173568
- /* 151 */ "where_opt ::=",
173569
- /* 152 */ "where_opt ::= WHERE expr",
173570
- /* 153 */ "where_opt_ret ::=",
173571
- /* 154 */ "where_opt_ret ::= WHERE expr",
173572
- /* 155 */ "where_opt_ret ::= RETURNING selcollist",
173573
- /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
173574
- /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
173575
- /* 158 */ "setlist ::= setlist COMMA nm EQ expr",
173576
- /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
173577
- /* 160 */ "setlist ::= nm EQ expr",
173578
- /* 161 */ "setlist ::= LP idlist RP EQ expr",
173579
- /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
173580
- /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
173581
- /* 164 */ "upsert ::=",
173582
- /* 165 */ "upsert ::= RETURNING selcollist",
173583
- /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
173584
- /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
173585
- /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning",
173586
- /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
173587
- /* 170 */ "returning ::= RETURNING selcollist",
173588
- /* 171 */ "insert_cmd ::= INSERT orconf",
173589
- /* 172 */ "insert_cmd ::= REPLACE",
173590
- /* 173 */ "idlist_opt ::=",
173591
- /* 174 */ "idlist_opt ::= LP idlist RP",
173592
- /* 175 */ "idlist ::= idlist COMMA nm",
173593
- /* 176 */ "idlist ::= nm",
173594
- /* 177 */ "expr ::= LP expr RP",
173595
- /* 178 */ "expr ::= ID|INDEXED|JOIN_KW",
173596
- /* 179 */ "expr ::= nm DOT nm",
173597
- /* 180 */ "expr ::= nm DOT nm DOT nm",
173598
- /* 181 */ "term ::= NULL|FLOAT|BLOB",
173599
- /* 182 */ "term ::= STRING",
173600
- /* 183 */ "term ::= INTEGER",
173601
- /* 184 */ "expr ::= VARIABLE",
173602
- /* 185 */ "expr ::= expr COLLATE ID|STRING",
173603
- /* 186 */ "expr ::= CAST LP expr AS typetoken RP",
173604
- /* 187 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
173605
- /* 188 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
173606
- /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
173607
- /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
173608
- /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
173609
- /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
173610
- /* 193 */ "term ::= CTIME_KW",
173611
- /* 194 */ "expr ::= LP nexprlist COMMA expr RP",
173612
- /* 195 */ "expr ::= expr AND expr",
173613
- /* 196 */ "expr ::= expr OR expr",
173614
- /* 197 */ "expr ::= expr LT|GT|GE|LE expr",
173615
- /* 198 */ "expr ::= expr EQ|NE expr",
173616
- /* 199 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
173617
- /* 200 */ "expr ::= expr PLUS|MINUS expr",
173618
- /* 201 */ "expr ::= expr STAR|SLASH|REM expr",
173619
- /* 202 */ "expr ::= expr CONCAT expr",
173620
- /* 203 */ "likeop ::= NOT LIKE_KW|MATCH",
173621
- /* 204 */ "expr ::= expr likeop expr",
173622
- /* 205 */ "expr ::= expr likeop expr ESCAPE expr",
173623
- /* 206 */ "expr ::= expr ISNULL|NOTNULL",
173624
- /* 207 */ "expr ::= expr NOT NULL",
173625
- /* 208 */ "expr ::= expr IS expr",
173626
- /* 209 */ "expr ::= expr IS NOT expr",
173627
- /* 210 */ "expr ::= expr IS NOT DISTINCT FROM expr",
173628
- /* 211 */ "expr ::= expr IS DISTINCT FROM expr",
173629
- /* 212 */ "expr ::= NOT expr",
173630
- /* 213 */ "expr ::= BITNOT expr",
173631
- /* 214 */ "expr ::= PLUS|MINUS expr",
173632
- /* 215 */ "expr ::= expr PTR expr",
173633
- /* 216 */ "between_op ::= BETWEEN",
173634
- /* 217 */ "between_op ::= NOT BETWEEN",
173635
- /* 218 */ "expr ::= expr between_op expr AND expr",
173636
- /* 219 */ "in_op ::= IN",
173637
- /* 220 */ "in_op ::= NOT IN",
173638
- /* 221 */ "expr ::= expr in_op LP exprlist RP",
173639
- /* 222 */ "expr ::= LP select RP",
173640
- /* 223 */ "expr ::= expr in_op LP select RP",
173641
- /* 224 */ "expr ::= expr in_op nm dbnm paren_exprlist",
173642
- /* 225 */ "expr ::= EXISTS LP select RP",
173643
- /* 226 */ "expr ::= CASE case_operand case_exprlist case_else END",
173644
- /* 227 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
173645
- /* 228 */ "case_exprlist ::= WHEN expr THEN expr",
173646
- /* 229 */ "case_else ::= ELSE expr",
173647
- /* 230 */ "case_else ::=",
173648
- /* 231 */ "case_operand ::=",
173649
- /* 232 */ "exprlist ::=",
173650
- /* 233 */ "nexprlist ::= nexprlist COMMA expr",
173651
- /* 234 */ "nexprlist ::= expr",
173652
- /* 235 */ "paren_exprlist ::=",
173653
- /* 236 */ "paren_exprlist ::= LP exprlist RP",
173654
- /* 237 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
173655
- /* 238 */ "uniqueflag ::= UNIQUE",
173656
- /* 239 */ "uniqueflag ::=",
173657
- /* 240 */ "eidlist_opt ::=",
173658
- /* 241 */ "eidlist_opt ::= LP eidlist RP",
173659
- /* 242 */ "eidlist ::= eidlist COMMA nm collate sortorder",
173660
- /* 243 */ "eidlist ::= nm collate sortorder",
173661
- /* 244 */ "collate ::=",
173662
- /* 245 */ "collate ::= COLLATE ID|STRING",
173663
- /* 246 */ "cmd ::= DROP INDEX ifexists fullname",
173664
- /* 247 */ "cmd ::= VACUUM vinto",
173665
- /* 248 */ "cmd ::= VACUUM nm vinto",
173666
- /* 249 */ "vinto ::= INTO expr",
173667
- /* 250 */ "vinto ::=",
173668
- /* 251 */ "cmd ::= PRAGMA nm dbnm",
173669
- /* 252 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
173670
- /* 253 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
173671
- /* 254 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
173672
- /* 255 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
173673
- /* 256 */ "plus_num ::= PLUS INTEGER|FLOAT",
173674
- /* 257 */ "minus_num ::= MINUS INTEGER|FLOAT",
173675
- /* 258 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
173676
- /* 259 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
173677
- /* 260 */ "trigger_time ::= BEFORE|AFTER",
173678
- /* 261 */ "trigger_time ::= INSTEAD OF",
173679
- /* 262 */ "trigger_time ::=",
173680
- /* 263 */ "trigger_event ::= DELETE|INSERT",
173681
- /* 264 */ "trigger_event ::= UPDATE",
173682
- /* 265 */ "trigger_event ::= UPDATE OF idlist",
173683
- /* 266 */ "when_clause ::=",
173684
- /* 267 */ "when_clause ::= WHEN expr",
173685
- /* 268 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
173686
- /* 269 */ "trigger_cmd_list ::= trigger_cmd SEMI",
173687
- /* 270 */ "trnm ::= nm DOT nm",
173688
- /* 271 */ "tridxby ::= INDEXED BY nm",
173689
- /* 272 */ "tridxby ::= NOT INDEXED",
173690
- /* 273 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
173691
- /* 274 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
173692
- /* 275 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
173693
- /* 276 */ "trigger_cmd ::= scanpt select scanpt",
173694
- /* 277 */ "expr ::= RAISE LP IGNORE RP",
173695
- /* 278 */ "expr ::= RAISE LP raisetype COMMA nm RP",
173696
- /* 279 */ "raisetype ::= ROLLBACK",
173697
- /* 280 */ "raisetype ::= ABORT",
173698
- /* 281 */ "raisetype ::= FAIL",
173699
- /* 282 */ "cmd ::= DROP TRIGGER ifexists fullname",
173700
- /* 283 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
173701
- /* 284 */ "cmd ::= DETACH database_kw_opt expr",
173702
- /* 285 */ "key_opt ::=",
173703
- /* 286 */ "key_opt ::= KEY expr",
173704
- /* 287 */ "cmd ::= REINDEX",
173705
- /* 288 */ "cmd ::= REINDEX nm dbnm",
173706
- /* 289 */ "cmd ::= ANALYZE",
173707
- /* 290 */ "cmd ::= ANALYZE nm dbnm",
173708
- /* 291 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
173709
- /* 292 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
173710
- /* 293 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
173711
- /* 294 */ "add_column_fullname ::= fullname",
173712
- /* 295 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
173713
- /* 296 */ "cmd ::= create_vtab",
173714
- /* 297 */ "cmd ::= create_vtab LP vtabarglist RP",
173715
- /* 298 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
173716
- /* 299 */ "vtabarg ::=",
173717
- /* 300 */ "vtabargtoken ::= ANY",
173718
- /* 301 */ "vtabargtoken ::= lp anylist RP",
173719
- /* 302 */ "lp ::= LP",
173720
- /* 303 */ "with ::= WITH wqlist",
173721
- /* 304 */ "with ::= WITH RECURSIVE wqlist",
173722
- /* 305 */ "wqas ::= AS",
173723
- /* 306 */ "wqas ::= AS MATERIALIZED",
173724
- /* 307 */ "wqas ::= AS NOT MATERIALIZED",
173725
- /* 308 */ "wqitem ::= nm eidlist_opt wqas LP select RP",
173726
- /* 309 */ "wqlist ::= wqitem",
173727
- /* 310 */ "wqlist ::= wqlist COMMA wqitem",
173728
- /* 311 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
173729
- /* 312 */ "windowdefn ::= nm AS LP window RP",
173730
- /* 313 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
173731
- /* 314 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
173732
- /* 315 */ "window ::= ORDER BY sortlist frame_opt",
173733
- /* 316 */ "window ::= nm ORDER BY sortlist frame_opt",
173734
- /* 317 */ "window ::= nm frame_opt",
173735
- /* 318 */ "frame_opt ::=",
173736
- /* 319 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
173737
- /* 320 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
173738
- /* 321 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
173739
- /* 322 */ "frame_bound_s ::= frame_bound",
173740
- /* 323 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
173741
- /* 324 */ "frame_bound_e ::= frame_bound",
173742
- /* 325 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
173743
- /* 326 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
173744
- /* 327 */ "frame_bound ::= CURRENT ROW",
173745
- /* 328 */ "frame_exclude_opt ::=",
173746
- /* 329 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
173747
- /* 330 */ "frame_exclude ::= NO OTHERS",
173748
- /* 331 */ "frame_exclude ::= CURRENT ROW",
173749
- /* 332 */ "frame_exclude ::= GROUP|TIES",
173750
- /* 333 */ "window_clause ::= WINDOW windowdefn_list",
173751
- /* 334 */ "filter_over ::= filter_clause over_clause",
173752
- /* 335 */ "filter_over ::= over_clause",
173753
- /* 336 */ "filter_over ::= filter_clause",
173754
- /* 337 */ "over_clause ::= OVER LP window RP",
173755
- /* 338 */ "over_clause ::= OVER nm",
173756
- /* 339 */ "filter_clause ::= FILTER LP WHERE expr RP",
173757
- /* 340 */ "term ::= QNUMBER",
173758
- /* 341 */ "input ::= cmdlist",
173759
- /* 342 */ "cmdlist ::= cmdlist ecmd",
173760
- /* 343 */ "cmdlist ::= ecmd",
173761
- /* 344 */ "ecmd ::= SEMI",
173762
- /* 345 */ "ecmd ::= cmdx SEMI",
173763
- /* 346 */ "ecmd ::= explain cmdx SEMI",
173764
- /* 347 */ "trans_opt ::=",
173765
- /* 348 */ "trans_opt ::= TRANSACTION",
173766
- /* 349 */ "trans_opt ::= TRANSACTION nm",
173767
- /* 350 */ "savepoint_opt ::= SAVEPOINT",
173768
- /* 351 */ "savepoint_opt ::=",
173769
- /* 352 */ "cmd ::= create_table create_table_args",
173770
- /* 353 */ "table_option_set ::= table_option",
173771
- /* 354 */ "columnlist ::= columnlist COMMA columnname carglist",
173772
- /* 355 */ "columnlist ::= columnname carglist",
173773
- /* 356 */ "nm ::= ID|INDEXED|JOIN_KW",
173774
- /* 357 */ "nm ::= STRING",
173775
- /* 358 */ "typetoken ::= typename",
173776
- /* 359 */ "typename ::= ID|STRING",
173777
- /* 360 */ "signed ::= plus_num",
173778
- /* 361 */ "signed ::= minus_num",
173779
- /* 362 */ "carglist ::= carglist ccons",
173780
- /* 363 */ "carglist ::=",
173781
- /* 364 */ "ccons ::= NULL onconf",
173782
- /* 365 */ "ccons ::= GENERATED ALWAYS AS generated",
173783
- /* 366 */ "ccons ::= AS generated",
173784
- /* 367 */ "conslist_opt ::= COMMA conslist",
173785
- /* 368 */ "conslist ::= conslist tconscomma tcons",
173786
- /* 369 */ "conslist ::= tcons",
173787
- /* 370 */ "tconscomma ::=",
173788
- /* 371 */ "defer_subclause_opt ::= defer_subclause",
173789
- /* 372 */ "resolvetype ::= raisetype",
173790
- /* 373 */ "selectnowith ::= oneselect",
173791
- /* 374 */ "oneselect ::= values",
173792
- /* 375 */ "sclp ::= selcollist COMMA",
173793
- /* 376 */ "as ::= ID|STRING",
173794
- /* 377 */ "indexed_opt ::= indexed_by",
173795
- /* 378 */ "returning ::=",
173796
- /* 379 */ "expr ::= term",
173797
- /* 380 */ "likeop ::= LIKE_KW|MATCH",
173798
- /* 381 */ "case_operand ::= expr",
173799
- /* 382 */ "exprlist ::= nexprlist",
173800
- /* 383 */ "nmnum ::= plus_num",
173801
- /* 384 */ "nmnum ::= nm",
173802
- /* 385 */ "nmnum ::= ON",
173803
- /* 386 */ "nmnum ::= DELETE",
173804
- /* 387 */ "nmnum ::= DEFAULT",
173805
- /* 388 */ "plus_num ::= INTEGER|FLOAT",
173806
- /* 389 */ "foreach_clause ::=",
173807
- /* 390 */ "foreach_clause ::= FOR EACH ROW",
173808
- /* 391 */ "trnm ::= nm",
173809
- /* 392 */ "tridxby ::=",
173810
- /* 393 */ "database_kw_opt ::= DATABASE",
173811
- /* 394 */ "database_kw_opt ::=",
173812
- /* 395 */ "kwcolumn_opt ::=",
173813
- /* 396 */ "kwcolumn_opt ::= COLUMNKW",
173814
- /* 397 */ "vtabarglist ::= vtabarg",
173815
- /* 398 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
173816
- /* 399 */ "vtabarg ::= vtabarg vtabargtoken",
173817
- /* 400 */ "anylist ::=",
173818
- /* 401 */ "anylist ::= anylist LP anylist RP",
173819
- /* 402 */ "anylist ::= anylist ANY",
173820
- /* 403 */ "with ::=",
173821
- /* 404 */ "windowdefn_list ::= windowdefn",
173822
- /* 405 */ "window ::= frame_opt",
173801
+ /* 95 */ "oneselect ::= mvalues",
173802
+ /* 96 */ "mvalues ::= values COMMA LP nexprlist RP",
173803
+ /* 97 */ "mvalues ::= mvalues COMMA LP nexprlist RP",
173804
+ /* 98 */ "distinct ::= DISTINCT",
173805
+ /* 99 */ "distinct ::= ALL",
173806
+ /* 100 */ "distinct ::=",
173807
+ /* 101 */ "sclp ::=",
173808
+ /* 102 */ "selcollist ::= sclp scanpt expr scanpt as",
173809
+ /* 103 */ "selcollist ::= sclp scanpt STAR",
173810
+ /* 104 */ "selcollist ::= sclp scanpt nm DOT STAR",
173811
+ /* 105 */ "as ::= AS nm",
173812
+ /* 106 */ "as ::=",
173813
+ /* 107 */ "from ::=",
173814
+ /* 108 */ "from ::= FROM seltablist",
173815
+ /* 109 */ "stl_prefix ::= seltablist joinop",
173816
+ /* 110 */ "stl_prefix ::=",
173817
+ /* 111 */ "seltablist ::= stl_prefix nm dbnm as on_using",
173818
+ /* 112 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
173819
+ /* 113 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
173820
+ /* 114 */ "seltablist ::= stl_prefix LP select RP as on_using",
173821
+ /* 115 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
173822
+ /* 116 */ "dbnm ::=",
173823
+ /* 117 */ "dbnm ::= DOT nm",
173824
+ /* 118 */ "fullname ::= nm",
173825
+ /* 119 */ "fullname ::= nm DOT nm",
173826
+ /* 120 */ "xfullname ::= nm",
173827
+ /* 121 */ "xfullname ::= nm DOT nm",
173828
+ /* 122 */ "xfullname ::= nm DOT nm AS nm",
173829
+ /* 123 */ "xfullname ::= nm AS nm",
173830
+ /* 124 */ "joinop ::= COMMA|JOIN",
173831
+ /* 125 */ "joinop ::= JOIN_KW JOIN",
173832
+ /* 126 */ "joinop ::= JOIN_KW nm JOIN",
173833
+ /* 127 */ "joinop ::= JOIN_KW nm nm JOIN",
173834
+ /* 128 */ "on_using ::= ON expr",
173835
+ /* 129 */ "on_using ::= USING LP idlist RP",
173836
+ /* 130 */ "on_using ::=",
173837
+ /* 131 */ "indexed_opt ::=",
173838
+ /* 132 */ "indexed_by ::= INDEXED BY nm",
173839
+ /* 133 */ "indexed_by ::= NOT INDEXED",
173840
+ /* 134 */ "orderby_opt ::=",
173841
+ /* 135 */ "orderby_opt ::= ORDER BY sortlist",
173842
+ /* 136 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
173843
+ /* 137 */ "sortlist ::= expr sortorder nulls",
173844
+ /* 138 */ "sortorder ::= ASC",
173845
+ /* 139 */ "sortorder ::= DESC",
173846
+ /* 140 */ "sortorder ::=",
173847
+ /* 141 */ "nulls ::= NULLS FIRST",
173848
+ /* 142 */ "nulls ::= NULLS LAST",
173849
+ /* 143 */ "nulls ::=",
173850
+ /* 144 */ "groupby_opt ::=",
173851
+ /* 145 */ "groupby_opt ::= GROUP BY nexprlist",
173852
+ /* 146 */ "having_opt ::=",
173853
+ /* 147 */ "having_opt ::= HAVING expr",
173854
+ /* 148 */ "limit_opt ::=",
173855
+ /* 149 */ "limit_opt ::= LIMIT expr",
173856
+ /* 150 */ "limit_opt ::= LIMIT expr OFFSET expr",
173857
+ /* 151 */ "limit_opt ::= LIMIT expr COMMA expr",
173858
+ /* 152 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
173859
+ /* 153 */ "where_opt ::=",
173860
+ /* 154 */ "where_opt ::= WHERE expr",
173861
+ /* 155 */ "where_opt_ret ::=",
173862
+ /* 156 */ "where_opt_ret ::= WHERE expr",
173863
+ /* 157 */ "where_opt_ret ::= RETURNING selcollist",
173864
+ /* 158 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
173865
+ /* 159 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
173866
+ /* 160 */ "setlist ::= setlist COMMA nm EQ expr",
173867
+ /* 161 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
173868
+ /* 162 */ "setlist ::= nm EQ expr",
173869
+ /* 163 */ "setlist ::= LP idlist RP EQ expr",
173870
+ /* 164 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
173871
+ /* 165 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
173872
+ /* 166 */ "upsert ::=",
173873
+ /* 167 */ "upsert ::= RETURNING selcollist",
173874
+ /* 168 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
173875
+ /* 169 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
173876
+ /* 170 */ "upsert ::= ON CONFLICT DO NOTHING returning",
173877
+ /* 171 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
173878
+ /* 172 */ "returning ::= RETURNING selcollist",
173879
+ /* 173 */ "insert_cmd ::= INSERT orconf",
173880
+ /* 174 */ "insert_cmd ::= REPLACE",
173881
+ /* 175 */ "idlist_opt ::=",
173882
+ /* 176 */ "idlist_opt ::= LP idlist RP",
173883
+ /* 177 */ "idlist ::= idlist COMMA nm",
173884
+ /* 178 */ "idlist ::= nm",
173885
+ /* 179 */ "expr ::= LP expr RP",
173886
+ /* 180 */ "expr ::= ID|INDEXED|JOIN_KW",
173887
+ /* 181 */ "expr ::= nm DOT nm",
173888
+ /* 182 */ "expr ::= nm DOT nm DOT nm",
173889
+ /* 183 */ "term ::= NULL|FLOAT|BLOB",
173890
+ /* 184 */ "term ::= STRING",
173891
+ /* 185 */ "term ::= INTEGER",
173892
+ /* 186 */ "expr ::= VARIABLE",
173893
+ /* 187 */ "expr ::= expr COLLATE ID|STRING",
173894
+ /* 188 */ "expr ::= CAST LP expr AS typetoken RP",
173895
+ /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
173896
+ /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
173897
+ /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
173898
+ /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
173899
+ /* 193 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
173900
+ /* 194 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
173901
+ /* 195 */ "term ::= CTIME_KW",
173902
+ /* 196 */ "expr ::= LP nexprlist COMMA expr RP",
173903
+ /* 197 */ "expr ::= expr AND expr",
173904
+ /* 198 */ "expr ::= expr OR expr",
173905
+ /* 199 */ "expr ::= expr LT|GT|GE|LE expr",
173906
+ /* 200 */ "expr ::= expr EQ|NE expr",
173907
+ /* 201 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
173908
+ /* 202 */ "expr ::= expr PLUS|MINUS expr",
173909
+ /* 203 */ "expr ::= expr STAR|SLASH|REM expr",
173910
+ /* 204 */ "expr ::= expr CONCAT expr",
173911
+ /* 205 */ "likeop ::= NOT LIKE_KW|MATCH",
173912
+ /* 206 */ "expr ::= expr likeop expr",
173913
+ /* 207 */ "expr ::= expr likeop expr ESCAPE expr",
173914
+ /* 208 */ "expr ::= expr ISNULL|NOTNULL",
173915
+ /* 209 */ "expr ::= expr NOT NULL",
173916
+ /* 210 */ "expr ::= expr IS expr",
173917
+ /* 211 */ "expr ::= expr IS NOT expr",
173918
+ /* 212 */ "expr ::= expr IS NOT DISTINCT FROM expr",
173919
+ /* 213 */ "expr ::= expr IS DISTINCT FROM expr",
173920
+ /* 214 */ "expr ::= NOT expr",
173921
+ /* 215 */ "expr ::= BITNOT expr",
173922
+ /* 216 */ "expr ::= PLUS|MINUS expr",
173923
+ /* 217 */ "expr ::= expr PTR expr",
173924
+ /* 218 */ "between_op ::= BETWEEN",
173925
+ /* 219 */ "between_op ::= NOT BETWEEN",
173926
+ /* 220 */ "expr ::= expr between_op expr AND expr",
173927
+ /* 221 */ "in_op ::= IN",
173928
+ /* 222 */ "in_op ::= NOT IN",
173929
+ /* 223 */ "expr ::= expr in_op LP exprlist RP",
173930
+ /* 224 */ "expr ::= LP select RP",
173931
+ /* 225 */ "expr ::= expr in_op LP select RP",
173932
+ /* 226 */ "expr ::= expr in_op nm dbnm paren_exprlist",
173933
+ /* 227 */ "expr ::= EXISTS LP select RP",
173934
+ /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
173935
+ /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
173936
+ /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
173937
+ /* 231 */ "case_else ::= ELSE expr",
173938
+ /* 232 */ "case_else ::=",
173939
+ /* 233 */ "case_operand ::=",
173940
+ /* 234 */ "exprlist ::=",
173941
+ /* 235 */ "nexprlist ::= nexprlist COMMA expr",
173942
+ /* 236 */ "nexprlist ::= expr",
173943
+ /* 237 */ "paren_exprlist ::=",
173944
+ /* 238 */ "paren_exprlist ::= LP exprlist RP",
173945
+ /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
173946
+ /* 240 */ "uniqueflag ::= UNIQUE",
173947
+ /* 241 */ "uniqueflag ::=",
173948
+ /* 242 */ "eidlist_opt ::=",
173949
+ /* 243 */ "eidlist_opt ::= LP eidlist RP",
173950
+ /* 244 */ "eidlist ::= eidlist COMMA nm collate sortorder",
173951
+ /* 245 */ "eidlist ::= nm collate sortorder",
173952
+ /* 246 */ "collate ::=",
173953
+ /* 247 */ "collate ::= COLLATE ID|STRING",
173954
+ /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
173955
+ /* 249 */ "cmd ::= VACUUM vinto",
173956
+ /* 250 */ "cmd ::= VACUUM nm vinto",
173957
+ /* 251 */ "vinto ::= INTO expr",
173958
+ /* 252 */ "vinto ::=",
173959
+ /* 253 */ "cmd ::= PRAGMA nm dbnm",
173960
+ /* 254 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
173961
+ /* 255 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
173962
+ /* 256 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
173963
+ /* 257 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
173964
+ /* 258 */ "plus_num ::= PLUS INTEGER|FLOAT",
173965
+ /* 259 */ "minus_num ::= MINUS INTEGER|FLOAT",
173966
+ /* 260 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
173967
+ /* 261 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
173968
+ /* 262 */ "trigger_time ::= BEFORE|AFTER",
173969
+ /* 263 */ "trigger_time ::= INSTEAD OF",
173970
+ /* 264 */ "trigger_time ::=",
173971
+ /* 265 */ "trigger_event ::= DELETE|INSERT",
173972
+ /* 266 */ "trigger_event ::= UPDATE",
173973
+ /* 267 */ "trigger_event ::= UPDATE OF idlist",
173974
+ /* 268 */ "when_clause ::=",
173975
+ /* 269 */ "when_clause ::= WHEN expr",
173976
+ /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
173977
+ /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI",
173978
+ /* 272 */ "trnm ::= nm DOT nm",
173979
+ /* 273 */ "tridxby ::= INDEXED BY nm",
173980
+ /* 274 */ "tridxby ::= NOT INDEXED",
173981
+ /* 275 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
173982
+ /* 276 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
173983
+ /* 277 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
173984
+ /* 278 */ "trigger_cmd ::= scanpt select scanpt",
173985
+ /* 279 */ "expr ::= RAISE LP IGNORE RP",
173986
+ /* 280 */ "expr ::= RAISE LP raisetype COMMA nm RP",
173987
+ /* 281 */ "raisetype ::= ROLLBACK",
173988
+ /* 282 */ "raisetype ::= ABORT",
173989
+ /* 283 */ "raisetype ::= FAIL",
173990
+ /* 284 */ "cmd ::= DROP TRIGGER ifexists fullname",
173991
+ /* 285 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
173992
+ /* 286 */ "cmd ::= DETACH database_kw_opt expr",
173993
+ /* 287 */ "key_opt ::=",
173994
+ /* 288 */ "key_opt ::= KEY expr",
173995
+ /* 289 */ "cmd ::= REINDEX",
173996
+ /* 290 */ "cmd ::= REINDEX nm dbnm",
173997
+ /* 291 */ "cmd ::= ANALYZE",
173998
+ /* 292 */ "cmd ::= ANALYZE nm dbnm",
173999
+ /* 293 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
174000
+ /* 294 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
174001
+ /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
174002
+ /* 296 */ "add_column_fullname ::= fullname",
174003
+ /* 297 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
174004
+ /* 298 */ "cmd ::= create_vtab",
174005
+ /* 299 */ "cmd ::= create_vtab LP vtabarglist RP",
174006
+ /* 300 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
174007
+ /* 301 */ "vtabarg ::=",
174008
+ /* 302 */ "vtabargtoken ::= ANY",
174009
+ /* 303 */ "vtabargtoken ::= lp anylist RP",
174010
+ /* 304 */ "lp ::= LP",
174011
+ /* 305 */ "with ::= WITH wqlist",
174012
+ /* 306 */ "with ::= WITH RECURSIVE wqlist",
174013
+ /* 307 */ "wqas ::= AS",
174014
+ /* 308 */ "wqas ::= AS MATERIALIZED",
174015
+ /* 309 */ "wqas ::= AS NOT MATERIALIZED",
174016
+ /* 310 */ "wqitem ::= withnm eidlist_opt wqas LP select RP",
174017
+ /* 311 */ "withnm ::= nm",
174018
+ /* 312 */ "wqlist ::= wqitem",
174019
+ /* 313 */ "wqlist ::= wqlist COMMA wqitem",
174020
+ /* 314 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
174021
+ /* 315 */ "windowdefn ::= nm AS LP window RP",
174022
+ /* 316 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
174023
+ /* 317 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
174024
+ /* 318 */ "window ::= ORDER BY sortlist frame_opt",
174025
+ /* 319 */ "window ::= nm ORDER BY sortlist frame_opt",
174026
+ /* 320 */ "window ::= nm frame_opt",
174027
+ /* 321 */ "frame_opt ::=",
174028
+ /* 322 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
174029
+ /* 323 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
174030
+ /* 324 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
174031
+ /* 325 */ "frame_bound_s ::= frame_bound",
174032
+ /* 326 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
174033
+ /* 327 */ "frame_bound_e ::= frame_bound",
174034
+ /* 328 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
174035
+ /* 329 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
174036
+ /* 330 */ "frame_bound ::= CURRENT ROW",
174037
+ /* 331 */ "frame_exclude_opt ::=",
174038
+ /* 332 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
174039
+ /* 333 */ "frame_exclude ::= NO OTHERS",
174040
+ /* 334 */ "frame_exclude ::= CURRENT ROW",
174041
+ /* 335 */ "frame_exclude ::= GROUP|TIES",
174042
+ /* 336 */ "window_clause ::= WINDOW windowdefn_list",
174043
+ /* 337 */ "filter_over ::= filter_clause over_clause",
174044
+ /* 338 */ "filter_over ::= over_clause",
174045
+ /* 339 */ "filter_over ::= filter_clause",
174046
+ /* 340 */ "over_clause ::= OVER LP window RP",
174047
+ /* 341 */ "over_clause ::= OVER nm",
174048
+ /* 342 */ "filter_clause ::= FILTER LP WHERE expr RP",
174049
+ /* 343 */ "term ::= QNUMBER",
174050
+ /* 344 */ "input ::= cmdlist",
174051
+ /* 345 */ "cmdlist ::= cmdlist ecmd",
174052
+ /* 346 */ "cmdlist ::= ecmd",
174053
+ /* 347 */ "ecmd ::= SEMI",
174054
+ /* 348 */ "ecmd ::= cmdx SEMI",
174055
+ /* 349 */ "ecmd ::= explain cmdx SEMI",
174056
+ /* 350 */ "trans_opt ::=",
174057
+ /* 351 */ "trans_opt ::= TRANSACTION",
174058
+ /* 352 */ "trans_opt ::= TRANSACTION nm",
174059
+ /* 353 */ "savepoint_opt ::= SAVEPOINT",
174060
+ /* 354 */ "savepoint_opt ::=",
174061
+ /* 355 */ "cmd ::= create_table create_table_args",
174062
+ /* 356 */ "table_option_set ::= table_option",
174063
+ /* 357 */ "columnlist ::= columnlist COMMA columnname carglist",
174064
+ /* 358 */ "columnlist ::= columnname carglist",
174065
+ /* 359 */ "nm ::= ID|INDEXED|JOIN_KW",
174066
+ /* 360 */ "nm ::= STRING",
174067
+ /* 361 */ "typetoken ::= typename",
174068
+ /* 362 */ "typename ::= ID|STRING",
174069
+ /* 363 */ "signed ::= plus_num",
174070
+ /* 364 */ "signed ::= minus_num",
174071
+ /* 365 */ "carglist ::= carglist ccons",
174072
+ /* 366 */ "carglist ::=",
174073
+ /* 367 */ "ccons ::= NULL onconf",
174074
+ /* 368 */ "ccons ::= GENERATED ALWAYS AS generated",
174075
+ /* 369 */ "ccons ::= AS generated",
174076
+ /* 370 */ "conslist_opt ::= COMMA conslist",
174077
+ /* 371 */ "conslist ::= conslist tconscomma tcons",
174078
+ /* 372 */ "conslist ::= tcons",
174079
+ /* 373 */ "tconscomma ::=",
174080
+ /* 374 */ "defer_subclause_opt ::= defer_subclause",
174081
+ /* 375 */ "resolvetype ::= raisetype",
174082
+ /* 376 */ "selectnowith ::= oneselect",
174083
+ /* 377 */ "oneselect ::= values",
174084
+ /* 378 */ "sclp ::= selcollist COMMA",
174085
+ /* 379 */ "as ::= ID|STRING",
174086
+ /* 380 */ "indexed_opt ::= indexed_by",
174087
+ /* 381 */ "returning ::=",
174088
+ /* 382 */ "expr ::= term",
174089
+ /* 383 */ "likeop ::= LIKE_KW|MATCH",
174090
+ /* 384 */ "case_operand ::= expr",
174091
+ /* 385 */ "exprlist ::= nexprlist",
174092
+ /* 386 */ "nmnum ::= plus_num",
174093
+ /* 387 */ "nmnum ::= nm",
174094
+ /* 388 */ "nmnum ::= ON",
174095
+ /* 389 */ "nmnum ::= DELETE",
174096
+ /* 390 */ "nmnum ::= DEFAULT",
174097
+ /* 391 */ "plus_num ::= INTEGER|FLOAT",
174098
+ /* 392 */ "foreach_clause ::=",
174099
+ /* 393 */ "foreach_clause ::= FOR EACH ROW",
174100
+ /* 394 */ "trnm ::= nm",
174101
+ /* 395 */ "tridxby ::=",
174102
+ /* 396 */ "database_kw_opt ::= DATABASE",
174103
+ /* 397 */ "database_kw_opt ::=",
174104
+ /* 398 */ "kwcolumn_opt ::=",
174105
+ /* 399 */ "kwcolumn_opt ::= COLUMNKW",
174106
+ /* 400 */ "vtabarglist ::= vtabarg",
174107
+ /* 401 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
174108
+ /* 402 */ "vtabarg ::= vtabarg vtabargtoken",
174109
+ /* 403 */ "anylist ::=",
174110
+ /* 404 */ "anylist ::= anylist LP anylist RP",
174111
+ /* 405 */ "anylist ::= anylist ANY",
174112
+ /* 406 */ "with ::=",
174113
+ /* 407 */ "windowdefn_list ::= windowdefn",
174114
+ /* 408 */ "window ::= frame_opt",
173823174115
 };
173824174116
 #endif /* NDEBUG */
173825174117
173826174118
173827174119
 #if YYGROWABLESTACK
@@ -173945,97 +174237,98 @@
173945174237
 /********* Begin destructor definitions ***************************************/
173946174238
 case 205: /* select */
173947174239
 case 240: /* selectnowith */
173948174240
 case 241: /* oneselect */
173949174241
 case 253: /* values */
174242
+ case 255: /* mvalues */
173950174243
 {
173951
-sqlite3SelectDelete(pParse->db, (yypminor->yy299));
174244
+sqlite3SelectDelete(pParse->db, (yypminor->yy555));
173952174245
 }
173953174246
 break;
173954174247
 case 217: /* term */
173955174248
 case 218: /* expr */
173956174249
 case 247: /* where_opt */
173957174250
 case 249: /* having_opt */
173958
- case 268: /* where_opt_ret */
173959
- case 279: /* case_operand */
173960
- case 281: /* case_else */
173961
- case 284: /* vinto */
173962
- case 291: /* when_clause */
173963
- case 296: /* key_opt */
173964
- case 312: /* filter_clause */
173965
-{
173966
-sqlite3ExprDelete(pParse->db, (yypminor->yy2));
174251
+ case 269: /* where_opt_ret */
174252
+ case 280: /* case_operand */
174253
+ case 282: /* case_else */
174254
+ case 285: /* vinto */
174255
+ case 292: /* when_clause */
174256
+ case 297: /* key_opt */
174257
+ case 314: /* filter_clause */
174258
+{
174259
+sqlite3ExprDelete(pParse->db, (yypminor->yy454));
173967174260
 }
173968174261
 break;
173969174262
 case 222: /* eidlist_opt */
173970174263
 case 232: /* sortlist */
173971174264
 case 233: /* eidlist */
173972174265
 case 245: /* selcollist */
173973174266
 case 248: /* groupby_opt */
173974174267
 case 250: /* orderby_opt */
173975174268
 case 254: /* nexprlist */
173976
- case 255: /* sclp */
173977
- case 262: /* exprlist */
173978
- case 269: /* setlist */
173979
- case 278: /* paren_exprlist */
173980
- case 280: /* case_exprlist */
173981
- case 311: /* part_opt */
173982
-{
173983
-sqlite3ExprListDelete(pParse->db, (yypminor->yy402));
174269
+ case 256: /* sclp */
174270
+ case 263: /* exprlist */
174271
+ case 270: /* setlist */
174272
+ case 279: /* paren_exprlist */
174273
+ case 281: /* case_exprlist */
174274
+ case 313: /* part_opt */
174275
+{
174276
+sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
173984174277
 }
173985174278
 break;
173986174279
 case 239: /* fullname */
173987174280
 case 246: /* from */
173988
- case 257: /* seltablist */
173989
- case 258: /* stl_prefix */
173990
- case 263: /* xfullname */
174281
+ case 258: /* seltablist */
174282
+ case 259: /* stl_prefix */
174283
+ case 264: /* xfullname */
173991174284
 {
173992
-sqlite3SrcListDelete(pParse->db, (yypminor->yy387));
174285
+sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
173993174286
 }
173994174287
 break;
173995174288
 case 242: /* wqlist */
173996174289
 {
173997
-sqlite3WithDelete(pParse->db, (yypminor->yy131));
174290
+sqlite3WithDelete(pParse->db, (yypminor->yy59));
173998174291
 }
173999174292
 break;
174000174293
 case 252: /* window_clause */
174001
- case 307: /* windowdefn_list */
174002
-{
174003
-sqlite3WindowListDelete(pParse->db, (yypminor->yy3));
174004
-}
174005
- break;
174006
- case 264: /* idlist */
174007
- case 271: /* idlist_opt */
174008
-{
174009
-sqlite3IdListDelete(pParse->db, (yypminor->yy400));
174010
-}
174011
- break;
174012
- case 274: /* filter_over */
174013
- case 308: /* windowdefn */
174014
- case 309: /* window */
174015
- case 310: /* frame_opt */
174016
- case 313: /* over_clause */
174017
-{
174018
-sqlite3WindowDelete(pParse->db, (yypminor->yy3));
174019
-}
174020
- break;
174021
- case 287: /* trigger_cmd_list */
174022
- case 292: /* trigger_cmd */
174023
-{
174024
-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy347));
174025
-}
174026
- break;
174027
- case 289: /* trigger_event */
174028
-{
174029
-sqlite3IdListDelete(pParse->db, (yypminor->yy210).b);
174030
-}
174031
- break;
174032
- case 315: /* frame_bound */
174033
- case 316: /* frame_bound_s */
174034
- case 317: /* frame_bound_e */
174035
-{
174036
-sqlite3ExprDelete(pParse->db, (yypminor->yy337).pExpr);
174294
+ case 309: /* windowdefn_list */
174295
+{
174296
+sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
174297
+}
174298
+ break;
174299
+ case 265: /* idlist */
174300
+ case 272: /* idlist_opt */
174301
+{
174302
+sqlite3IdListDelete(pParse->db, (yypminor->yy132));
174303
+}
174304
+ break;
174305
+ case 275: /* filter_over */
174306
+ case 310: /* windowdefn */
174307
+ case 311: /* window */
174308
+ case 312: /* frame_opt */
174309
+ case 315: /* over_clause */
174310
+{
174311
+sqlite3WindowDelete(pParse->db, (yypminor->yy211));
174312
+}
174313
+ break;
174314
+ case 288: /* trigger_cmd_list */
174315
+ case 293: /* trigger_cmd */
174316
+{
174317
+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
174318
+}
174319
+ break;
174320
+ case 290: /* trigger_event */
174321
+{
174322
+sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
174323
+}
174324
+ break;
174325
+ case 317: /* frame_bound */
174326
+ case 318: /* frame_bound_s */
174327
+ case 319: /* frame_bound_e */
174328
+{
174329
+sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
174037174330
 }
174038174331
 break;
174039174332
 /********* End destructor definitions *****************************************/
174040174333
 default: break; /* If no destructor action specified: do nothing */
174041174334
 }
@@ -174428,321 +174721,324 @@
174428174721
 243, /* (90) multiselect_op ::= UNION ALL */
174429174722
 243, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
174430174723
 241, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
174431174724
 241, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
174432174725
 253, /* (94) values ::= VALUES LP nexprlist RP */
174433
- 253, /* (95) values ::= values COMMA LP nexprlist RP */
174434
- 244, /* (96) distinct ::= DISTINCT */
174435
- 244, /* (97) distinct ::= ALL */
174436
- 244, /* (98) distinct ::= */
174437
- 255, /* (99) sclp ::= */
174438
- 245, /* (100) selcollist ::= sclp scanpt expr scanpt as */
174439
- 245, /* (101) selcollist ::= sclp scanpt STAR */
174440
- 245, /* (102) selcollist ::= sclp scanpt nm DOT STAR */
174441
- 256, /* (103) as ::= AS nm */
174442
- 256, /* (104) as ::= */
174443
- 246, /* (105) from ::= */
174444
- 246, /* (106) from ::= FROM seltablist */
174445
- 258, /* (107) stl_prefix ::= seltablist joinop */
174446
- 258, /* (108) stl_prefix ::= */
174447
- 257, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
174448
- 257, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174449
- 257, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174450
- 257, /* (112) seltablist ::= stl_prefix LP select RP as on_using */
174451
- 257, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
174452
- 201, /* (114) dbnm ::= */
174453
- 201, /* (115) dbnm ::= DOT nm */
174454
- 239, /* (116) fullname ::= nm */
174455
- 239, /* (117) fullname ::= nm DOT nm */
174456
- 263, /* (118) xfullname ::= nm */
174457
- 263, /* (119) xfullname ::= nm DOT nm */
174458
- 263, /* (120) xfullname ::= nm DOT nm AS nm */
174459
- 263, /* (121) xfullname ::= nm AS nm */
174460
- 259, /* (122) joinop ::= COMMA|JOIN */
174461
- 259, /* (123) joinop ::= JOIN_KW JOIN */
174462
- 259, /* (124) joinop ::= JOIN_KW nm JOIN */
174463
- 259, /* (125) joinop ::= JOIN_KW nm nm JOIN */
174464
- 260, /* (126) on_using ::= ON expr */
174465
- 260, /* (127) on_using ::= USING LP idlist RP */
174466
- 260, /* (128) on_using ::= */
174467
- 265, /* (129) indexed_opt ::= */
174468
- 261, /* (130) indexed_by ::= INDEXED BY nm */
174469
- 261, /* (131) indexed_by ::= NOT INDEXED */
174470
- 250, /* (132) orderby_opt ::= */
174471
- 250, /* (133) orderby_opt ::= ORDER BY sortlist */
174472
- 232, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
174473
- 232, /* (135) sortlist ::= expr sortorder nulls */
174474
- 220, /* (136) sortorder ::= ASC */
174475
- 220, /* (137) sortorder ::= DESC */
174476
- 220, /* (138) sortorder ::= */
174477
- 266, /* (139) nulls ::= NULLS FIRST */
174478
- 266, /* (140) nulls ::= NULLS LAST */
174479
- 266, /* (141) nulls ::= */
174480
- 248, /* (142) groupby_opt ::= */
174481
- 248, /* (143) groupby_opt ::= GROUP BY nexprlist */
174482
- 249, /* (144) having_opt ::= */
174483
- 249, /* (145) having_opt ::= HAVING expr */
174484
- 251, /* (146) limit_opt ::= */
174485
- 251, /* (147) limit_opt ::= LIMIT expr */
174486
- 251, /* (148) limit_opt ::= LIMIT expr OFFSET expr */
174487
- 251, /* (149) limit_opt ::= LIMIT expr COMMA expr */
174488
- 191, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174489
- 247, /* (151) where_opt ::= */
174490
- 247, /* (152) where_opt ::= WHERE expr */
174491
- 268, /* (153) where_opt_ret ::= */
174492
- 268, /* (154) where_opt_ret ::= WHERE expr */
174493
- 268, /* (155) where_opt_ret ::= RETURNING selcollist */
174494
- 268, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
174495
- 191, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174496
- 269, /* (158) setlist ::= setlist COMMA nm EQ expr */
174497
- 269, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
174498
- 269, /* (160) setlist ::= nm EQ expr */
174499
- 269, /* (161) setlist ::= LP idlist RP EQ expr */
174500
- 191, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174501
- 191, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174502
- 272, /* (164) upsert ::= */
174503
- 272, /* (165) upsert ::= RETURNING selcollist */
174504
- 272, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174505
- 272, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174506
- 272, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
174507
- 272, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174508
- 273, /* (170) returning ::= RETURNING selcollist */
174509
- 270, /* (171) insert_cmd ::= INSERT orconf */
174510
- 270, /* (172) insert_cmd ::= REPLACE */
174511
- 271, /* (173) idlist_opt ::= */
174512
- 271, /* (174) idlist_opt ::= LP idlist RP */
174513
- 264, /* (175) idlist ::= idlist COMMA nm */
174514
- 264, /* (176) idlist ::= nm */
174515
- 218, /* (177) expr ::= LP expr RP */
174516
- 218, /* (178) expr ::= ID|INDEXED|JOIN_KW */
174517
- 218, /* (179) expr ::= nm DOT nm */
174518
- 218, /* (180) expr ::= nm DOT nm DOT nm */
174519
- 217, /* (181) term ::= NULL|FLOAT|BLOB */
174520
- 217, /* (182) term ::= STRING */
174521
- 217, /* (183) term ::= INTEGER */
174522
- 218, /* (184) expr ::= VARIABLE */
174523
- 218, /* (185) expr ::= expr COLLATE ID|STRING */
174524
- 218, /* (186) expr ::= CAST LP expr AS typetoken RP */
174525
- 218, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174526
- 218, /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174527
- 218, /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174528
- 218, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174529
- 218, /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174530
- 218, /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174531
- 217, /* (193) term ::= CTIME_KW */
174532
- 218, /* (194) expr ::= LP nexprlist COMMA expr RP */
174533
- 218, /* (195) expr ::= expr AND expr */
174534
- 218, /* (196) expr ::= expr OR expr */
174535
- 218, /* (197) expr ::= expr LT|GT|GE|LE expr */
174536
- 218, /* (198) expr ::= expr EQ|NE expr */
174537
- 218, /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174538
- 218, /* (200) expr ::= expr PLUS|MINUS expr */
174539
- 218, /* (201) expr ::= expr STAR|SLASH|REM expr */
174540
- 218, /* (202) expr ::= expr CONCAT expr */
174541
- 275, /* (203) likeop ::= NOT LIKE_KW|MATCH */
174542
- 218, /* (204) expr ::= expr likeop expr */
174543
- 218, /* (205) expr ::= expr likeop expr ESCAPE expr */
174544
- 218, /* (206) expr ::= expr ISNULL|NOTNULL */
174545
- 218, /* (207) expr ::= expr NOT NULL */
174546
- 218, /* (208) expr ::= expr IS expr */
174547
- 218, /* (209) expr ::= expr IS NOT expr */
174548
- 218, /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
174549
- 218, /* (211) expr ::= expr IS DISTINCT FROM expr */
174550
- 218, /* (212) expr ::= NOT expr */
174551
- 218, /* (213) expr ::= BITNOT expr */
174552
- 218, /* (214) expr ::= PLUS|MINUS expr */
174553
- 218, /* (215) expr ::= expr PTR expr */
174554
- 276, /* (216) between_op ::= BETWEEN */
174555
- 276, /* (217) between_op ::= NOT BETWEEN */
174556
- 218, /* (218) expr ::= expr between_op expr AND expr */
174557
- 277, /* (219) in_op ::= IN */
174558
- 277, /* (220) in_op ::= NOT IN */
174559
- 218, /* (221) expr ::= expr in_op LP exprlist RP */
174560
- 218, /* (222) expr ::= LP select RP */
174561
- 218, /* (223) expr ::= expr in_op LP select RP */
174562
- 218, /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
174563
- 218, /* (225) expr ::= EXISTS LP select RP */
174564
- 218, /* (226) expr ::= CASE case_operand case_exprlist case_else END */
174565
- 280, /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174566
- 280, /* (228) case_exprlist ::= WHEN expr THEN expr */
174567
- 281, /* (229) case_else ::= ELSE expr */
174568
- 281, /* (230) case_else ::= */
174569
- 279, /* (231) case_operand ::= */
174570
- 262, /* (232) exprlist ::= */
174571
- 254, /* (233) nexprlist ::= nexprlist COMMA expr */
174572
- 254, /* (234) nexprlist ::= expr */
174573
- 278, /* (235) paren_exprlist ::= */
174574
- 278, /* (236) paren_exprlist ::= LP exprlist RP */
174575
- 191, /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174576
- 282, /* (238) uniqueflag ::= UNIQUE */
174577
- 282, /* (239) uniqueflag ::= */
174578
- 222, /* (240) eidlist_opt ::= */
174579
- 222, /* (241) eidlist_opt ::= LP eidlist RP */
174580
- 233, /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
174581
- 233, /* (243) eidlist ::= nm collate sortorder */
174582
- 283, /* (244) collate ::= */
174583
- 283, /* (245) collate ::= COLLATE ID|STRING */
174584
- 191, /* (246) cmd ::= DROP INDEX ifexists fullname */
174585
- 191, /* (247) cmd ::= VACUUM vinto */
174586
- 191, /* (248) cmd ::= VACUUM nm vinto */
174587
- 284, /* (249) vinto ::= INTO expr */
174588
- 284, /* (250) vinto ::= */
174589
- 191, /* (251) cmd ::= PRAGMA nm dbnm */
174590
- 191, /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
174591
- 191, /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
174592
- 191, /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
174593
- 191, /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
174594
- 212, /* (256) plus_num ::= PLUS INTEGER|FLOAT */
174595
- 213, /* (257) minus_num ::= MINUS INTEGER|FLOAT */
174596
- 191, /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
174597
- 286, /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
174598
- 288, /* (260) trigger_time ::= BEFORE|AFTER */
174599
- 288, /* (261) trigger_time ::= INSTEAD OF */
174600
- 288, /* (262) trigger_time ::= */
174601
- 289, /* (263) trigger_event ::= DELETE|INSERT */
174602
- 289, /* (264) trigger_event ::= UPDATE */
174603
- 289, /* (265) trigger_event ::= UPDATE OF idlist */
174604
- 291, /* (266) when_clause ::= */
174605
- 291, /* (267) when_clause ::= WHEN expr */
174606
- 287, /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
174607
- 287, /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
174608
- 293, /* (270) trnm ::= nm DOT nm */
174609
- 294, /* (271) tridxby ::= INDEXED BY nm */
174610
- 294, /* (272) tridxby ::= NOT INDEXED */
174611
- 292, /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
174612
- 292, /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
174613
- 292, /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
174614
- 292, /* (276) trigger_cmd ::= scanpt select scanpt */
174615
- 218, /* (277) expr ::= RAISE LP IGNORE RP */
174616
- 218, /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
174617
- 237, /* (279) raisetype ::= ROLLBACK */
174618
- 237, /* (280) raisetype ::= ABORT */
174619
- 237, /* (281) raisetype ::= FAIL */
174620
- 191, /* (282) cmd ::= DROP TRIGGER ifexists fullname */
174621
- 191, /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
174622
- 191, /* (284) cmd ::= DETACH database_kw_opt expr */
174623
- 296, /* (285) key_opt ::= */
174624
- 296, /* (286) key_opt ::= KEY expr */
174625
- 191, /* (287) cmd ::= REINDEX */
174626
- 191, /* (288) cmd ::= REINDEX nm dbnm */
174627
- 191, /* (289) cmd ::= ANALYZE */
174628
- 191, /* (290) cmd ::= ANALYZE nm dbnm */
174629
- 191, /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
174630
- 191, /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
174631
- 191, /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
174632
- 297, /* (294) add_column_fullname ::= fullname */
174633
- 191, /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
174634
- 191, /* (296) cmd ::= create_vtab */
174635
- 191, /* (297) cmd ::= create_vtab LP vtabarglist RP */
174636
- 299, /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
174637
- 301, /* (299) vtabarg ::= */
174638
- 302, /* (300) vtabargtoken ::= ANY */
174639
- 302, /* (301) vtabargtoken ::= lp anylist RP */
174640
- 303, /* (302) lp ::= LP */
174641
- 267, /* (303) with ::= WITH wqlist */
174642
- 267, /* (304) with ::= WITH RECURSIVE wqlist */
174643
- 306, /* (305) wqas ::= AS */
174644
- 306, /* (306) wqas ::= AS MATERIALIZED */
174645
- 306, /* (307) wqas ::= AS NOT MATERIALIZED */
174646
- 305, /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
174647
- 242, /* (309) wqlist ::= wqitem */
174648
- 242, /* (310) wqlist ::= wqlist COMMA wqitem */
174649
- 307, /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
174650
- 308, /* (312) windowdefn ::= nm AS LP window RP */
174651
- 309, /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
174652
- 309, /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
174653
- 309, /* (315) window ::= ORDER BY sortlist frame_opt */
174654
- 309, /* (316) window ::= nm ORDER BY sortlist frame_opt */
174655
- 309, /* (317) window ::= nm frame_opt */
174656
- 310, /* (318) frame_opt ::= */
174657
- 310, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
174658
- 310, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
174659
- 314, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
174660
- 316, /* (322) frame_bound_s ::= frame_bound */
174661
- 316, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
174662
- 317, /* (324) frame_bound_e ::= frame_bound */
174663
- 317, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
174664
- 315, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
174665
- 315, /* (327) frame_bound ::= CURRENT ROW */
174666
- 318, /* (328) frame_exclude_opt ::= */
174667
- 318, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
174668
- 319, /* (330) frame_exclude ::= NO OTHERS */
174669
- 319, /* (331) frame_exclude ::= CURRENT ROW */
174670
- 319, /* (332) frame_exclude ::= GROUP|TIES */
174671
- 252, /* (333) window_clause ::= WINDOW windowdefn_list */
174672
- 274, /* (334) filter_over ::= filter_clause over_clause */
174673
- 274, /* (335) filter_over ::= over_clause */
174674
- 274, /* (336) filter_over ::= filter_clause */
174675
- 313, /* (337) over_clause ::= OVER LP window RP */
174676
- 313, /* (338) over_clause ::= OVER nm */
174677
- 312, /* (339) filter_clause ::= FILTER LP WHERE expr RP */
174678
- 217, /* (340) term ::= QNUMBER */
174679
- 186, /* (341) input ::= cmdlist */
174680
- 187, /* (342) cmdlist ::= cmdlist ecmd */
174681
- 187, /* (343) cmdlist ::= ecmd */
174682
- 188, /* (344) ecmd ::= SEMI */
174683
- 188, /* (345) ecmd ::= cmdx SEMI */
174684
- 188, /* (346) ecmd ::= explain cmdx SEMI */
174685
- 193, /* (347) trans_opt ::= */
174686
- 193, /* (348) trans_opt ::= TRANSACTION */
174687
- 193, /* (349) trans_opt ::= TRANSACTION nm */
174688
- 195, /* (350) savepoint_opt ::= SAVEPOINT */
174689
- 195, /* (351) savepoint_opt ::= */
174690
- 191, /* (352) cmd ::= create_table create_table_args */
174691
- 204, /* (353) table_option_set ::= table_option */
174692
- 202, /* (354) columnlist ::= columnlist COMMA columnname carglist */
174693
- 202, /* (355) columnlist ::= columnname carglist */
174694
- 194, /* (356) nm ::= ID|INDEXED|JOIN_KW */
174695
- 194, /* (357) nm ::= STRING */
174696
- 209, /* (358) typetoken ::= typename */
174697
- 210, /* (359) typename ::= ID|STRING */
174698
- 211, /* (360) signed ::= plus_num */
174699
- 211, /* (361) signed ::= minus_num */
174700
- 208, /* (362) carglist ::= carglist ccons */
174701
- 208, /* (363) carglist ::= */
174702
- 216, /* (364) ccons ::= NULL onconf */
174703
- 216, /* (365) ccons ::= GENERATED ALWAYS AS generated */
174704
- 216, /* (366) ccons ::= AS generated */
174705
- 203, /* (367) conslist_opt ::= COMMA conslist */
174706
- 229, /* (368) conslist ::= conslist tconscomma tcons */
174707
- 229, /* (369) conslist ::= tcons */
174708
- 230, /* (370) tconscomma ::= */
174709
- 234, /* (371) defer_subclause_opt ::= defer_subclause */
174710
- 236, /* (372) resolvetype ::= raisetype */
174711
- 240, /* (373) selectnowith ::= oneselect */
174712
- 241, /* (374) oneselect ::= values */
174713
- 255, /* (375) sclp ::= selcollist COMMA */
174714
- 256, /* (376) as ::= ID|STRING */
174715
- 265, /* (377) indexed_opt ::= indexed_by */
174716
- 273, /* (378) returning ::= */
174717
- 218, /* (379) expr ::= term */
174718
- 275, /* (380) likeop ::= LIKE_KW|MATCH */
174719
- 279, /* (381) case_operand ::= expr */
174720
- 262, /* (382) exprlist ::= nexprlist */
174721
- 285, /* (383) nmnum ::= plus_num */
174722
- 285, /* (384) nmnum ::= nm */
174723
- 285, /* (385) nmnum ::= ON */
174724
- 285, /* (386) nmnum ::= DELETE */
174725
- 285, /* (387) nmnum ::= DEFAULT */
174726
- 212, /* (388) plus_num ::= INTEGER|FLOAT */
174727
- 290, /* (389) foreach_clause ::= */
174728
- 290, /* (390) foreach_clause ::= FOR EACH ROW */
174729
- 293, /* (391) trnm ::= nm */
174730
- 294, /* (392) tridxby ::= */
174731
- 295, /* (393) database_kw_opt ::= DATABASE */
174732
- 295, /* (394) database_kw_opt ::= */
174733
- 298, /* (395) kwcolumn_opt ::= */
174734
- 298, /* (396) kwcolumn_opt ::= COLUMNKW */
174735
- 300, /* (397) vtabarglist ::= vtabarg */
174736
- 300, /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */
174737
- 301, /* (399) vtabarg ::= vtabarg vtabargtoken */
174738
- 304, /* (400) anylist ::= */
174739
- 304, /* (401) anylist ::= anylist LP anylist RP */
174740
- 304, /* (402) anylist ::= anylist ANY */
174741
- 267, /* (403) with ::= */
174742
- 307, /* (404) windowdefn_list ::= windowdefn */
174743
- 309, /* (405) window ::= frame_opt */
174726
+ 241, /* (95) oneselect ::= mvalues */
174727
+ 255, /* (96) mvalues ::= values COMMA LP nexprlist RP */
174728
+ 255, /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
174729
+ 244, /* (98) distinct ::= DISTINCT */
174730
+ 244, /* (99) distinct ::= ALL */
174731
+ 244, /* (100) distinct ::= */
174732
+ 256, /* (101) sclp ::= */
174733
+ 245, /* (102) selcollist ::= sclp scanpt expr scanpt as */
174734
+ 245, /* (103) selcollist ::= sclp scanpt STAR */
174735
+ 245, /* (104) selcollist ::= sclp scanpt nm DOT STAR */
174736
+ 257, /* (105) as ::= AS nm */
174737
+ 257, /* (106) as ::= */
174738
+ 246, /* (107) from ::= */
174739
+ 246, /* (108) from ::= FROM seltablist */
174740
+ 259, /* (109) stl_prefix ::= seltablist joinop */
174741
+ 259, /* (110) stl_prefix ::= */
174742
+ 258, /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
174743
+ 258, /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174744
+ 258, /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174745
+ 258, /* (114) seltablist ::= stl_prefix LP select RP as on_using */
174746
+ 258, /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
174747
+ 201, /* (116) dbnm ::= */
174748
+ 201, /* (117) dbnm ::= DOT nm */
174749
+ 239, /* (118) fullname ::= nm */
174750
+ 239, /* (119) fullname ::= nm DOT nm */
174751
+ 264, /* (120) xfullname ::= nm */
174752
+ 264, /* (121) xfullname ::= nm DOT nm */
174753
+ 264, /* (122) xfullname ::= nm DOT nm AS nm */
174754
+ 264, /* (123) xfullname ::= nm AS nm */
174755
+ 260, /* (124) joinop ::= COMMA|JOIN */
174756
+ 260, /* (125) joinop ::= JOIN_KW JOIN */
174757
+ 260, /* (126) joinop ::= JOIN_KW nm JOIN */
174758
+ 260, /* (127) joinop ::= JOIN_KW nm nm JOIN */
174759
+ 261, /* (128) on_using ::= ON expr */
174760
+ 261, /* (129) on_using ::= USING LP idlist RP */
174761
+ 261, /* (130) on_using ::= */
174762
+ 266, /* (131) indexed_opt ::= */
174763
+ 262, /* (132) indexed_by ::= INDEXED BY nm */
174764
+ 262, /* (133) indexed_by ::= NOT INDEXED */
174765
+ 250, /* (134) orderby_opt ::= */
174766
+ 250, /* (135) orderby_opt ::= ORDER BY sortlist */
174767
+ 232, /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
174768
+ 232, /* (137) sortlist ::= expr sortorder nulls */
174769
+ 220, /* (138) sortorder ::= ASC */
174770
+ 220, /* (139) sortorder ::= DESC */
174771
+ 220, /* (140) sortorder ::= */
174772
+ 267, /* (141) nulls ::= NULLS FIRST */
174773
+ 267, /* (142) nulls ::= NULLS LAST */
174774
+ 267, /* (143) nulls ::= */
174775
+ 248, /* (144) groupby_opt ::= */
174776
+ 248, /* (145) groupby_opt ::= GROUP BY nexprlist */
174777
+ 249, /* (146) having_opt ::= */
174778
+ 249, /* (147) having_opt ::= HAVING expr */
174779
+ 251, /* (148) limit_opt ::= */
174780
+ 251, /* (149) limit_opt ::= LIMIT expr */
174781
+ 251, /* (150) limit_opt ::= LIMIT expr OFFSET expr */
174782
+ 251, /* (151) limit_opt ::= LIMIT expr COMMA expr */
174783
+ 191, /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174784
+ 247, /* (153) where_opt ::= */
174785
+ 247, /* (154) where_opt ::= WHERE expr */
174786
+ 269, /* (155) where_opt_ret ::= */
174787
+ 269, /* (156) where_opt_ret ::= WHERE expr */
174788
+ 269, /* (157) where_opt_ret ::= RETURNING selcollist */
174789
+ 269, /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
174790
+ 191, /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174791
+ 270, /* (160) setlist ::= setlist COMMA nm EQ expr */
174792
+ 270, /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
174793
+ 270, /* (162) setlist ::= nm EQ expr */
174794
+ 270, /* (163) setlist ::= LP idlist RP EQ expr */
174795
+ 191, /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174796
+ 191, /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174797
+ 273, /* (166) upsert ::= */
174798
+ 273, /* (167) upsert ::= RETURNING selcollist */
174799
+ 273, /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174800
+ 273, /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174801
+ 273, /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
174802
+ 273, /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174803
+ 274, /* (172) returning ::= RETURNING selcollist */
174804
+ 271, /* (173) insert_cmd ::= INSERT orconf */
174805
+ 271, /* (174) insert_cmd ::= REPLACE */
174806
+ 272, /* (175) idlist_opt ::= */
174807
+ 272, /* (176) idlist_opt ::= LP idlist RP */
174808
+ 265, /* (177) idlist ::= idlist COMMA nm */
174809
+ 265, /* (178) idlist ::= nm */
174810
+ 218, /* (179) expr ::= LP expr RP */
174811
+ 218, /* (180) expr ::= ID|INDEXED|JOIN_KW */
174812
+ 218, /* (181) expr ::= nm DOT nm */
174813
+ 218, /* (182) expr ::= nm DOT nm DOT nm */
174814
+ 217, /* (183) term ::= NULL|FLOAT|BLOB */
174815
+ 217, /* (184) term ::= STRING */
174816
+ 217, /* (185) term ::= INTEGER */
174817
+ 218, /* (186) expr ::= VARIABLE */
174818
+ 218, /* (187) expr ::= expr COLLATE ID|STRING */
174819
+ 218, /* (188) expr ::= CAST LP expr AS typetoken RP */
174820
+ 218, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174821
+ 218, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174822
+ 218, /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174823
+ 218, /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174824
+ 218, /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174825
+ 218, /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174826
+ 217, /* (195) term ::= CTIME_KW */
174827
+ 218, /* (196) expr ::= LP nexprlist COMMA expr RP */
174828
+ 218, /* (197) expr ::= expr AND expr */
174829
+ 218, /* (198) expr ::= expr OR expr */
174830
+ 218, /* (199) expr ::= expr LT|GT|GE|LE expr */
174831
+ 218, /* (200) expr ::= expr EQ|NE expr */
174832
+ 218, /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174833
+ 218, /* (202) expr ::= expr PLUS|MINUS expr */
174834
+ 218, /* (203) expr ::= expr STAR|SLASH|REM expr */
174835
+ 218, /* (204) expr ::= expr CONCAT expr */
174836
+ 276, /* (205) likeop ::= NOT LIKE_KW|MATCH */
174837
+ 218, /* (206) expr ::= expr likeop expr */
174838
+ 218, /* (207) expr ::= expr likeop expr ESCAPE expr */
174839
+ 218, /* (208) expr ::= expr ISNULL|NOTNULL */
174840
+ 218, /* (209) expr ::= expr NOT NULL */
174841
+ 218, /* (210) expr ::= expr IS expr */
174842
+ 218, /* (211) expr ::= expr IS NOT expr */
174843
+ 218, /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
174844
+ 218, /* (213) expr ::= expr IS DISTINCT FROM expr */
174845
+ 218, /* (214) expr ::= NOT expr */
174846
+ 218, /* (215) expr ::= BITNOT expr */
174847
+ 218, /* (216) expr ::= PLUS|MINUS expr */
174848
+ 218, /* (217) expr ::= expr PTR expr */
174849
+ 277, /* (218) between_op ::= BETWEEN */
174850
+ 277, /* (219) between_op ::= NOT BETWEEN */
174851
+ 218, /* (220) expr ::= expr between_op expr AND expr */
174852
+ 278, /* (221) in_op ::= IN */
174853
+ 278, /* (222) in_op ::= NOT IN */
174854
+ 218, /* (223) expr ::= expr in_op LP exprlist RP */
174855
+ 218, /* (224) expr ::= LP select RP */
174856
+ 218, /* (225) expr ::= expr in_op LP select RP */
174857
+ 218, /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
174858
+ 218, /* (227) expr ::= EXISTS LP select RP */
174859
+ 218, /* (228) expr ::= CASE case_operand case_exprlist case_else END */
174860
+ 281, /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174861
+ 281, /* (230) case_exprlist ::= WHEN expr THEN expr */
174862
+ 282, /* (231) case_else ::= ELSE expr */
174863
+ 282, /* (232) case_else ::= */
174864
+ 280, /* (233) case_operand ::= */
174865
+ 263, /* (234) exprlist ::= */
174866
+ 254, /* (235) nexprlist ::= nexprlist COMMA expr */
174867
+ 254, /* (236) nexprlist ::= expr */
174868
+ 279, /* (237) paren_exprlist ::= */
174869
+ 279, /* (238) paren_exprlist ::= LP exprlist RP */
174870
+ 191, /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174871
+ 283, /* (240) uniqueflag ::= UNIQUE */
174872
+ 283, /* (241) uniqueflag ::= */
174873
+ 222, /* (242) eidlist_opt ::= */
174874
+ 222, /* (243) eidlist_opt ::= LP eidlist RP */
174875
+ 233, /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
174876
+ 233, /* (245) eidlist ::= nm collate sortorder */
174877
+ 284, /* (246) collate ::= */
174878
+ 284, /* (247) collate ::= COLLATE ID|STRING */
174879
+ 191, /* (248) cmd ::= DROP INDEX ifexists fullname */
174880
+ 191, /* (249) cmd ::= VACUUM vinto */
174881
+ 191, /* (250) cmd ::= VACUUM nm vinto */
174882
+ 285, /* (251) vinto ::= INTO expr */
174883
+ 285, /* (252) vinto ::= */
174884
+ 191, /* (253) cmd ::= PRAGMA nm dbnm */
174885
+ 191, /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
174886
+ 191, /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
174887
+ 191, /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
174888
+ 191, /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
174889
+ 212, /* (258) plus_num ::= PLUS INTEGER|FLOAT */
174890
+ 213, /* (259) minus_num ::= MINUS INTEGER|FLOAT */
174891
+ 191, /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
174892
+ 287, /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
174893
+ 289, /* (262) trigger_time ::= BEFORE|AFTER */
174894
+ 289, /* (263) trigger_time ::= INSTEAD OF */
174895
+ 289, /* (264) trigger_time ::= */
174896
+ 290, /* (265) trigger_event ::= DELETE|INSERT */
174897
+ 290, /* (266) trigger_event ::= UPDATE */
174898
+ 290, /* (267) trigger_event ::= UPDATE OF idlist */
174899
+ 292, /* (268) when_clause ::= */
174900
+ 292, /* (269) when_clause ::= WHEN expr */
174901
+ 288, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
174902
+ 288, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
174903
+ 294, /* (272) trnm ::= nm DOT nm */
174904
+ 295, /* (273) tridxby ::= INDEXED BY nm */
174905
+ 295, /* (274) tridxby ::= NOT INDEXED */
174906
+ 293, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
174907
+ 293, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
174908
+ 293, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
174909
+ 293, /* (278) trigger_cmd ::= scanpt select scanpt */
174910
+ 218, /* (279) expr ::= RAISE LP IGNORE RP */
174911
+ 218, /* (280) expr ::= RAISE LP raisetype COMMA nm RP */
174912
+ 237, /* (281) raisetype ::= ROLLBACK */
174913
+ 237, /* (282) raisetype ::= ABORT */
174914
+ 237, /* (283) raisetype ::= FAIL */
174915
+ 191, /* (284) cmd ::= DROP TRIGGER ifexists fullname */
174916
+ 191, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
174917
+ 191, /* (286) cmd ::= DETACH database_kw_opt expr */
174918
+ 297, /* (287) key_opt ::= */
174919
+ 297, /* (288) key_opt ::= KEY expr */
174920
+ 191, /* (289) cmd ::= REINDEX */
174921
+ 191, /* (290) cmd ::= REINDEX nm dbnm */
174922
+ 191, /* (291) cmd ::= ANALYZE */
174923
+ 191, /* (292) cmd ::= ANALYZE nm dbnm */
174924
+ 191, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
174925
+ 191, /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
174926
+ 191, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
174927
+ 298, /* (296) add_column_fullname ::= fullname */
174928
+ 191, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
174929
+ 191, /* (298) cmd ::= create_vtab */
174930
+ 191, /* (299) cmd ::= create_vtab LP vtabarglist RP */
174931
+ 300, /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
174932
+ 302, /* (301) vtabarg ::= */
174933
+ 303, /* (302) vtabargtoken ::= ANY */
174934
+ 303, /* (303) vtabargtoken ::= lp anylist RP */
174935
+ 304, /* (304) lp ::= LP */
174936
+ 268, /* (305) with ::= WITH wqlist */
174937
+ 268, /* (306) with ::= WITH RECURSIVE wqlist */
174938
+ 307, /* (307) wqas ::= AS */
174939
+ 307, /* (308) wqas ::= AS MATERIALIZED */
174940
+ 307, /* (309) wqas ::= AS NOT MATERIALIZED */
174941
+ 306, /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
174942
+ 308, /* (311) withnm ::= nm */
174943
+ 242, /* (312) wqlist ::= wqitem */
174944
+ 242, /* (313) wqlist ::= wqlist COMMA wqitem */
174945
+ 309, /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
174946
+ 310, /* (315) windowdefn ::= nm AS LP window RP */
174947
+ 311, /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
174948
+ 311, /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
174949
+ 311, /* (318) window ::= ORDER BY sortlist frame_opt */
174950
+ 311, /* (319) window ::= nm ORDER BY sortlist frame_opt */
174951
+ 311, /* (320) window ::= nm frame_opt */
174952
+ 312, /* (321) frame_opt ::= */
174953
+ 312, /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
174954
+ 312, /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
174955
+ 316, /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
174956
+ 318, /* (325) frame_bound_s ::= frame_bound */
174957
+ 318, /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
174958
+ 319, /* (327) frame_bound_e ::= frame_bound */
174959
+ 319, /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
174960
+ 317, /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
174961
+ 317, /* (330) frame_bound ::= CURRENT ROW */
174962
+ 320, /* (331) frame_exclude_opt ::= */
174963
+ 320, /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
174964
+ 321, /* (333) frame_exclude ::= NO OTHERS */
174965
+ 321, /* (334) frame_exclude ::= CURRENT ROW */
174966
+ 321, /* (335) frame_exclude ::= GROUP|TIES */
174967
+ 252, /* (336) window_clause ::= WINDOW windowdefn_list */
174968
+ 275, /* (337) filter_over ::= filter_clause over_clause */
174969
+ 275, /* (338) filter_over ::= over_clause */
174970
+ 275, /* (339) filter_over ::= filter_clause */
174971
+ 315, /* (340) over_clause ::= OVER LP window RP */
174972
+ 315, /* (341) over_clause ::= OVER nm */
174973
+ 314, /* (342) filter_clause ::= FILTER LP WHERE expr RP */
174974
+ 217, /* (343) term ::= QNUMBER */
174975
+ 186, /* (344) input ::= cmdlist */
174976
+ 187, /* (345) cmdlist ::= cmdlist ecmd */
174977
+ 187, /* (346) cmdlist ::= ecmd */
174978
+ 188, /* (347) ecmd ::= SEMI */
174979
+ 188, /* (348) ecmd ::= cmdx SEMI */
174980
+ 188, /* (349) ecmd ::= explain cmdx SEMI */
174981
+ 193, /* (350) trans_opt ::= */
174982
+ 193, /* (351) trans_opt ::= TRANSACTION */
174983
+ 193, /* (352) trans_opt ::= TRANSACTION nm */
174984
+ 195, /* (353) savepoint_opt ::= SAVEPOINT */
174985
+ 195, /* (354) savepoint_opt ::= */
174986
+ 191, /* (355) cmd ::= create_table create_table_args */
174987
+ 204, /* (356) table_option_set ::= table_option */
174988
+ 202, /* (357) columnlist ::= columnlist COMMA columnname carglist */
174989
+ 202, /* (358) columnlist ::= columnname carglist */
174990
+ 194, /* (359) nm ::= ID|INDEXED|JOIN_KW */
174991
+ 194, /* (360) nm ::= STRING */
174992
+ 209, /* (361) typetoken ::= typename */
174993
+ 210, /* (362) typename ::= ID|STRING */
174994
+ 211, /* (363) signed ::= plus_num */
174995
+ 211, /* (364) signed ::= minus_num */
174996
+ 208, /* (365) carglist ::= carglist ccons */
174997
+ 208, /* (366) carglist ::= */
174998
+ 216, /* (367) ccons ::= NULL onconf */
174999
+ 216, /* (368) ccons ::= GENERATED ALWAYS AS generated */
175000
+ 216, /* (369) ccons ::= AS generated */
175001
+ 203, /* (370) conslist_opt ::= COMMA conslist */
175002
+ 229, /* (371) conslist ::= conslist tconscomma tcons */
175003
+ 229, /* (372) conslist ::= tcons */
175004
+ 230, /* (373) tconscomma ::= */
175005
+ 234, /* (374) defer_subclause_opt ::= defer_subclause */
175006
+ 236, /* (375) resolvetype ::= raisetype */
175007
+ 240, /* (376) selectnowith ::= oneselect */
175008
+ 241, /* (377) oneselect ::= values */
175009
+ 256, /* (378) sclp ::= selcollist COMMA */
175010
+ 257, /* (379) as ::= ID|STRING */
175011
+ 266, /* (380) indexed_opt ::= indexed_by */
175012
+ 274, /* (381) returning ::= */
175013
+ 218, /* (382) expr ::= term */
175014
+ 276, /* (383) likeop ::= LIKE_KW|MATCH */
175015
+ 280, /* (384) case_operand ::= expr */
175016
+ 263, /* (385) exprlist ::= nexprlist */
175017
+ 286, /* (386) nmnum ::= plus_num */
175018
+ 286, /* (387) nmnum ::= nm */
175019
+ 286, /* (388) nmnum ::= ON */
175020
+ 286, /* (389) nmnum ::= DELETE */
175021
+ 286, /* (390) nmnum ::= DEFAULT */
175022
+ 212, /* (391) plus_num ::= INTEGER|FLOAT */
175023
+ 291, /* (392) foreach_clause ::= */
175024
+ 291, /* (393) foreach_clause ::= FOR EACH ROW */
175025
+ 294, /* (394) trnm ::= nm */
175026
+ 295, /* (395) tridxby ::= */
175027
+ 296, /* (396) database_kw_opt ::= DATABASE */
175028
+ 296, /* (397) database_kw_opt ::= */
175029
+ 299, /* (398) kwcolumn_opt ::= */
175030
+ 299, /* (399) kwcolumn_opt ::= COLUMNKW */
175031
+ 301, /* (400) vtabarglist ::= vtabarg */
175032
+ 301, /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
175033
+ 302, /* (402) vtabarg ::= vtabarg vtabargtoken */
175034
+ 305, /* (403) anylist ::= */
175035
+ 305, /* (404) anylist ::= anylist LP anylist RP */
175036
+ 305, /* (405) anylist ::= anylist ANY */
175037
+ 268, /* (406) with ::= */
175038
+ 309, /* (407) windowdefn_list ::= windowdefn */
175039
+ 311, /* (408) window ::= frame_opt */
174744175040
 };
174745175041
174746175042
 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
174747175043
 ** of symbols on the right-hand side of that rule. */
174748175044
 static const signed char yyRuleInfoNRhs[] = {
@@ -174839,321 +175135,324 @@
174839175135
 -2, /* (90) multiselect_op ::= UNION ALL */
174840175136
 -1, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
174841175137
 -9, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
174842175138
 -10, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
174843175139
 -4, /* (94) values ::= VALUES LP nexprlist RP */
174844
- -5, /* (95) values ::= values COMMA LP nexprlist RP */
174845
- -1, /* (96) distinct ::= DISTINCT */
174846
- -1, /* (97) distinct ::= ALL */
174847
- 0, /* (98) distinct ::= */
174848
- 0, /* (99) sclp ::= */
174849
- -5, /* (100) selcollist ::= sclp scanpt expr scanpt as */
174850
- -3, /* (101) selcollist ::= sclp scanpt STAR */
174851
- -5, /* (102) selcollist ::= sclp scanpt nm DOT STAR */
174852
- -2, /* (103) as ::= AS nm */
174853
- 0, /* (104) as ::= */
174854
- 0, /* (105) from ::= */
174855
- -2, /* (106) from ::= FROM seltablist */
174856
- -2, /* (107) stl_prefix ::= seltablist joinop */
174857
- 0, /* (108) stl_prefix ::= */
174858
- -5, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
174859
- -6, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174860
- -8, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174861
- -6, /* (112) seltablist ::= stl_prefix LP select RP as on_using */
174862
- -6, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
174863
- 0, /* (114) dbnm ::= */
174864
- -2, /* (115) dbnm ::= DOT nm */
174865
- -1, /* (116) fullname ::= nm */
174866
- -3, /* (117) fullname ::= nm DOT nm */
174867
- -1, /* (118) xfullname ::= nm */
174868
- -3, /* (119) xfullname ::= nm DOT nm */
174869
- -5, /* (120) xfullname ::= nm DOT nm AS nm */
174870
- -3, /* (121) xfullname ::= nm AS nm */
174871
- -1, /* (122) joinop ::= COMMA|JOIN */
174872
- -2, /* (123) joinop ::= JOIN_KW JOIN */
174873
- -3, /* (124) joinop ::= JOIN_KW nm JOIN */
174874
- -4, /* (125) joinop ::= JOIN_KW nm nm JOIN */
174875
- -2, /* (126) on_using ::= ON expr */
174876
- -4, /* (127) on_using ::= USING LP idlist RP */
174877
- 0, /* (128) on_using ::= */
174878
- 0, /* (129) indexed_opt ::= */
174879
- -3, /* (130) indexed_by ::= INDEXED BY nm */
174880
- -2, /* (131) indexed_by ::= NOT INDEXED */
174881
- 0, /* (132) orderby_opt ::= */
174882
- -3, /* (133) orderby_opt ::= ORDER BY sortlist */
174883
- -5, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
174884
- -3, /* (135) sortlist ::= expr sortorder nulls */
174885
- -1, /* (136) sortorder ::= ASC */
174886
- -1, /* (137) sortorder ::= DESC */
174887
- 0, /* (138) sortorder ::= */
174888
- -2, /* (139) nulls ::= NULLS FIRST */
174889
- -2, /* (140) nulls ::= NULLS LAST */
174890
- 0, /* (141) nulls ::= */
174891
- 0, /* (142) groupby_opt ::= */
174892
- -3, /* (143) groupby_opt ::= GROUP BY nexprlist */
174893
- 0, /* (144) having_opt ::= */
174894
- -2, /* (145) having_opt ::= HAVING expr */
174895
- 0, /* (146) limit_opt ::= */
174896
- -2, /* (147) limit_opt ::= LIMIT expr */
174897
- -4, /* (148) limit_opt ::= LIMIT expr OFFSET expr */
174898
- -4, /* (149) limit_opt ::= LIMIT expr COMMA expr */
174899
- -6, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174900
- 0, /* (151) where_opt ::= */
174901
- -2, /* (152) where_opt ::= WHERE expr */
174902
- 0, /* (153) where_opt_ret ::= */
174903
- -2, /* (154) where_opt_ret ::= WHERE expr */
174904
- -2, /* (155) where_opt_ret ::= RETURNING selcollist */
174905
- -4, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
174906
- -9, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174907
- -5, /* (158) setlist ::= setlist COMMA nm EQ expr */
174908
- -7, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
174909
- -3, /* (160) setlist ::= nm EQ expr */
174910
- -5, /* (161) setlist ::= LP idlist RP EQ expr */
174911
- -7, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174912
- -8, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174913
- 0, /* (164) upsert ::= */
174914
- -2, /* (165) upsert ::= RETURNING selcollist */
174915
- -12, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174916
- -9, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174917
- -5, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
174918
- -8, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174919
- -2, /* (170) returning ::= RETURNING selcollist */
174920
- -2, /* (171) insert_cmd ::= INSERT orconf */
174921
- -1, /* (172) insert_cmd ::= REPLACE */
174922
- 0, /* (173) idlist_opt ::= */
174923
- -3, /* (174) idlist_opt ::= LP idlist RP */
174924
- -3, /* (175) idlist ::= idlist COMMA nm */
174925
- -1, /* (176) idlist ::= nm */
174926
- -3, /* (177) expr ::= LP expr RP */
174927
- -1, /* (178) expr ::= ID|INDEXED|JOIN_KW */
174928
- -3, /* (179) expr ::= nm DOT nm */
174929
- -5, /* (180) expr ::= nm DOT nm DOT nm */
174930
- -1, /* (181) term ::= NULL|FLOAT|BLOB */
174931
- -1, /* (182) term ::= STRING */
174932
- -1, /* (183) term ::= INTEGER */
174933
- -1, /* (184) expr ::= VARIABLE */
174934
- -3, /* (185) expr ::= expr COLLATE ID|STRING */
174935
- -6, /* (186) expr ::= CAST LP expr AS typetoken RP */
174936
- -5, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174937
- -8, /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174938
- -4, /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174939
- -6, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174940
- -9, /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174941
- -5, /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174942
- -1, /* (193) term ::= CTIME_KW */
174943
- -5, /* (194) expr ::= LP nexprlist COMMA expr RP */
174944
- -3, /* (195) expr ::= expr AND expr */
174945
- -3, /* (196) expr ::= expr OR expr */
174946
- -3, /* (197) expr ::= expr LT|GT|GE|LE expr */
174947
- -3, /* (198) expr ::= expr EQ|NE expr */
174948
- -3, /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174949
- -3, /* (200) expr ::= expr PLUS|MINUS expr */
174950
- -3, /* (201) expr ::= expr STAR|SLASH|REM expr */
174951
- -3, /* (202) expr ::= expr CONCAT expr */
174952
- -2, /* (203) likeop ::= NOT LIKE_KW|MATCH */
174953
- -3, /* (204) expr ::= expr likeop expr */
174954
- -5, /* (205) expr ::= expr likeop expr ESCAPE expr */
174955
- -2, /* (206) expr ::= expr ISNULL|NOTNULL */
174956
- -3, /* (207) expr ::= expr NOT NULL */
174957
- -3, /* (208) expr ::= expr IS expr */
174958
- -4, /* (209) expr ::= expr IS NOT expr */
174959
- -6, /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
174960
- -5, /* (211) expr ::= expr IS DISTINCT FROM expr */
174961
- -2, /* (212) expr ::= NOT expr */
174962
- -2, /* (213) expr ::= BITNOT expr */
174963
- -2, /* (214) expr ::= PLUS|MINUS expr */
174964
- -3, /* (215) expr ::= expr PTR expr */
174965
- -1, /* (216) between_op ::= BETWEEN */
174966
- -2, /* (217) between_op ::= NOT BETWEEN */
174967
- -5, /* (218) expr ::= expr between_op expr AND expr */
174968
- -1, /* (219) in_op ::= IN */
174969
- -2, /* (220) in_op ::= NOT IN */
174970
- -5, /* (221) expr ::= expr in_op LP exprlist RP */
174971
- -3, /* (222) expr ::= LP select RP */
174972
- -5, /* (223) expr ::= expr in_op LP select RP */
174973
- -5, /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
174974
- -4, /* (225) expr ::= EXISTS LP select RP */
174975
- -5, /* (226) expr ::= CASE case_operand case_exprlist case_else END */
174976
- -5, /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174977
- -4, /* (228) case_exprlist ::= WHEN expr THEN expr */
174978
- -2, /* (229) case_else ::= ELSE expr */
174979
- 0, /* (230) case_else ::= */
174980
- 0, /* (231) case_operand ::= */
174981
- 0, /* (232) exprlist ::= */
174982
- -3, /* (233) nexprlist ::= nexprlist COMMA expr */
174983
- -1, /* (234) nexprlist ::= expr */
174984
- 0, /* (235) paren_exprlist ::= */
174985
- -3, /* (236) paren_exprlist ::= LP exprlist RP */
174986
- -12, /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174987
- -1, /* (238) uniqueflag ::= UNIQUE */
174988
- 0, /* (239) uniqueflag ::= */
174989
- 0, /* (240) eidlist_opt ::= */
174990
- -3, /* (241) eidlist_opt ::= LP eidlist RP */
174991
- -5, /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
174992
- -3, /* (243) eidlist ::= nm collate sortorder */
174993
- 0, /* (244) collate ::= */
174994
- -2, /* (245) collate ::= COLLATE ID|STRING */
174995
- -4, /* (246) cmd ::= DROP INDEX ifexists fullname */
174996
- -2, /* (247) cmd ::= VACUUM vinto */
174997
- -3, /* (248) cmd ::= VACUUM nm vinto */
174998
- -2, /* (249) vinto ::= INTO expr */
174999
- 0, /* (250) vinto ::= */
175000
- -3, /* (251) cmd ::= PRAGMA nm dbnm */
175001
- -5, /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
175002
- -6, /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
175003
- -5, /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
175004
- -6, /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
175005
- -2, /* (256) plus_num ::= PLUS INTEGER|FLOAT */
175006
- -2, /* (257) minus_num ::= MINUS INTEGER|FLOAT */
175007
- -5, /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
175008
- -11, /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
175009
- -1, /* (260) trigger_time ::= BEFORE|AFTER */
175010
- -2, /* (261) trigger_time ::= INSTEAD OF */
175011
- 0, /* (262) trigger_time ::= */
175012
- -1, /* (263) trigger_event ::= DELETE|INSERT */
175013
- -1, /* (264) trigger_event ::= UPDATE */
175014
- -3, /* (265) trigger_event ::= UPDATE OF idlist */
175015
- 0, /* (266) when_clause ::= */
175016
- -2, /* (267) when_clause ::= WHEN expr */
175017
- -3, /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
175018
- -2, /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
175019
- -3, /* (270) trnm ::= nm DOT nm */
175020
- -3, /* (271) tridxby ::= INDEXED BY nm */
175021
- -2, /* (272) tridxby ::= NOT INDEXED */
175022
- -9, /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
175023
- -8, /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
175024
- -6, /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
175025
- -3, /* (276) trigger_cmd ::= scanpt select scanpt */
175026
- -4, /* (277) expr ::= RAISE LP IGNORE RP */
175027
- -6, /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
175028
- -1, /* (279) raisetype ::= ROLLBACK */
175029
- -1, /* (280) raisetype ::= ABORT */
175030
- -1, /* (281) raisetype ::= FAIL */
175031
- -4, /* (282) cmd ::= DROP TRIGGER ifexists fullname */
175032
- -6, /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
175033
- -3, /* (284) cmd ::= DETACH database_kw_opt expr */
175034
- 0, /* (285) key_opt ::= */
175035
- -2, /* (286) key_opt ::= KEY expr */
175036
- -1, /* (287) cmd ::= REINDEX */
175037
- -3, /* (288) cmd ::= REINDEX nm dbnm */
175038
- -1, /* (289) cmd ::= ANALYZE */
175039
- -3, /* (290) cmd ::= ANALYZE nm dbnm */
175040
- -6, /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
175041
- -7, /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
175042
- -6, /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
175043
- -1, /* (294) add_column_fullname ::= fullname */
175044
- -8, /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
175045
- -1, /* (296) cmd ::= create_vtab */
175046
- -4, /* (297) cmd ::= create_vtab LP vtabarglist RP */
175047
- -8, /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
175048
- 0, /* (299) vtabarg ::= */
175049
- -1, /* (300) vtabargtoken ::= ANY */
175050
- -3, /* (301) vtabargtoken ::= lp anylist RP */
175051
- -1, /* (302) lp ::= LP */
175052
- -2, /* (303) with ::= WITH wqlist */
175053
- -3, /* (304) with ::= WITH RECURSIVE wqlist */
175054
- -1, /* (305) wqas ::= AS */
175055
- -2, /* (306) wqas ::= AS MATERIALIZED */
175056
- -3, /* (307) wqas ::= AS NOT MATERIALIZED */
175057
- -6, /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
175058
- -1, /* (309) wqlist ::= wqitem */
175059
- -3, /* (310) wqlist ::= wqlist COMMA wqitem */
175060
- -3, /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
175061
- -5, /* (312) windowdefn ::= nm AS LP window RP */
175062
- -5, /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
175063
- -6, /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
175064
- -4, /* (315) window ::= ORDER BY sortlist frame_opt */
175065
- -5, /* (316) window ::= nm ORDER BY sortlist frame_opt */
175066
- -2, /* (317) window ::= nm frame_opt */
175067
- 0, /* (318) frame_opt ::= */
175068
- -3, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
175069
- -6, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
175070
- -1, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
175071
- -1, /* (322) frame_bound_s ::= frame_bound */
175072
- -2, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
175073
- -1, /* (324) frame_bound_e ::= frame_bound */
175074
- -2, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
175075
- -2, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
175076
- -2, /* (327) frame_bound ::= CURRENT ROW */
175077
- 0, /* (328) frame_exclude_opt ::= */
175078
- -2, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
175079
- -2, /* (330) frame_exclude ::= NO OTHERS */
175080
- -2, /* (331) frame_exclude ::= CURRENT ROW */
175081
- -1, /* (332) frame_exclude ::= GROUP|TIES */
175082
- -2, /* (333) window_clause ::= WINDOW windowdefn_list */
175083
- -2, /* (334) filter_over ::= filter_clause over_clause */
175084
- -1, /* (335) filter_over ::= over_clause */
175085
- -1, /* (336) filter_over ::= filter_clause */
175086
- -4, /* (337) over_clause ::= OVER LP window RP */
175087
- -2, /* (338) over_clause ::= OVER nm */
175088
- -5, /* (339) filter_clause ::= FILTER LP WHERE expr RP */
175089
- -1, /* (340) term ::= QNUMBER */
175090
- -1, /* (341) input ::= cmdlist */
175091
- -2, /* (342) cmdlist ::= cmdlist ecmd */
175092
- -1, /* (343) cmdlist ::= ecmd */
175093
- -1, /* (344) ecmd ::= SEMI */
175094
- -2, /* (345) ecmd ::= cmdx SEMI */
175095
- -3, /* (346) ecmd ::= explain cmdx SEMI */
175096
- 0, /* (347) trans_opt ::= */
175097
- -1, /* (348) trans_opt ::= TRANSACTION */
175098
- -2, /* (349) trans_opt ::= TRANSACTION nm */
175099
- -1, /* (350) savepoint_opt ::= SAVEPOINT */
175100
- 0, /* (351) savepoint_opt ::= */
175101
- -2, /* (352) cmd ::= create_table create_table_args */
175102
- -1, /* (353) table_option_set ::= table_option */
175103
- -4, /* (354) columnlist ::= columnlist COMMA columnname carglist */
175104
- -2, /* (355) columnlist ::= columnname carglist */
175105
- -1, /* (356) nm ::= ID|INDEXED|JOIN_KW */
175106
- -1, /* (357) nm ::= STRING */
175107
- -1, /* (358) typetoken ::= typename */
175108
- -1, /* (359) typename ::= ID|STRING */
175109
- -1, /* (360) signed ::= plus_num */
175110
- -1, /* (361) signed ::= minus_num */
175111
- -2, /* (362) carglist ::= carglist ccons */
175112
- 0, /* (363) carglist ::= */
175113
- -2, /* (364) ccons ::= NULL onconf */
175114
- -4, /* (365) ccons ::= GENERATED ALWAYS AS generated */
175115
- -2, /* (366) ccons ::= AS generated */
175116
- -2, /* (367) conslist_opt ::= COMMA conslist */
175117
- -3, /* (368) conslist ::= conslist tconscomma tcons */
175118
- -1, /* (369) conslist ::= tcons */
175119
- 0, /* (370) tconscomma ::= */
175120
- -1, /* (371) defer_subclause_opt ::= defer_subclause */
175121
- -1, /* (372) resolvetype ::= raisetype */
175122
- -1, /* (373) selectnowith ::= oneselect */
175123
- -1, /* (374) oneselect ::= values */
175124
- -2, /* (375) sclp ::= selcollist COMMA */
175125
- -1, /* (376) as ::= ID|STRING */
175126
- -1, /* (377) indexed_opt ::= indexed_by */
175127
- 0, /* (378) returning ::= */
175128
- -1, /* (379) expr ::= term */
175129
- -1, /* (380) likeop ::= LIKE_KW|MATCH */
175130
- -1, /* (381) case_operand ::= expr */
175131
- -1, /* (382) exprlist ::= nexprlist */
175132
- -1, /* (383) nmnum ::= plus_num */
175133
- -1, /* (384) nmnum ::= nm */
175134
- -1, /* (385) nmnum ::= ON */
175135
- -1, /* (386) nmnum ::= DELETE */
175136
- -1, /* (387) nmnum ::= DEFAULT */
175137
- -1, /* (388) plus_num ::= INTEGER|FLOAT */
175138
- 0, /* (389) foreach_clause ::= */
175139
- -3, /* (390) foreach_clause ::= FOR EACH ROW */
175140
- -1, /* (391) trnm ::= nm */
175141
- 0, /* (392) tridxby ::= */
175142
- -1, /* (393) database_kw_opt ::= DATABASE */
175143
- 0, /* (394) database_kw_opt ::= */
175144
- 0, /* (395) kwcolumn_opt ::= */
175145
- -1, /* (396) kwcolumn_opt ::= COLUMNKW */
175146
- -1, /* (397) vtabarglist ::= vtabarg */
175147
- -3, /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */
175148
- -2, /* (399) vtabarg ::= vtabarg vtabargtoken */
175149
- 0, /* (400) anylist ::= */
175150
- -4, /* (401) anylist ::= anylist LP anylist RP */
175151
- -2, /* (402) anylist ::= anylist ANY */
175152
- 0, /* (403) with ::= */
175153
- -1, /* (404) windowdefn_list ::= windowdefn */
175154
- -1, /* (405) window ::= frame_opt */
175140
+ -1, /* (95) oneselect ::= mvalues */
175141
+ -5, /* (96) mvalues ::= values COMMA LP nexprlist RP */
175142
+ -5, /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
175143
+ -1, /* (98) distinct ::= DISTINCT */
175144
+ -1, /* (99) distinct ::= ALL */
175145
+ 0, /* (100) distinct ::= */
175146
+ 0, /* (101) sclp ::= */
175147
+ -5, /* (102) selcollist ::= sclp scanpt expr scanpt as */
175148
+ -3, /* (103) selcollist ::= sclp scanpt STAR */
175149
+ -5, /* (104) selcollist ::= sclp scanpt nm DOT STAR */
175150
+ -2, /* (105) as ::= AS nm */
175151
+ 0, /* (106) as ::= */
175152
+ 0, /* (107) from ::= */
175153
+ -2, /* (108) from ::= FROM seltablist */
175154
+ -2, /* (109) stl_prefix ::= seltablist joinop */
175155
+ 0, /* (110) stl_prefix ::= */
175156
+ -5, /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
175157
+ -6, /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175158
+ -8, /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175159
+ -6, /* (114) seltablist ::= stl_prefix LP select RP as on_using */
175160
+ -6, /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
175161
+ 0, /* (116) dbnm ::= */
175162
+ -2, /* (117) dbnm ::= DOT nm */
175163
+ -1, /* (118) fullname ::= nm */
175164
+ -3, /* (119) fullname ::= nm DOT nm */
175165
+ -1, /* (120) xfullname ::= nm */
175166
+ -3, /* (121) xfullname ::= nm DOT nm */
175167
+ -5, /* (122) xfullname ::= nm DOT nm AS nm */
175168
+ -3, /* (123) xfullname ::= nm AS nm */
175169
+ -1, /* (124) joinop ::= COMMA|JOIN */
175170
+ -2, /* (125) joinop ::= JOIN_KW JOIN */
175171
+ -3, /* (126) joinop ::= JOIN_KW nm JOIN */
175172
+ -4, /* (127) joinop ::= JOIN_KW nm nm JOIN */
175173
+ -2, /* (128) on_using ::= ON expr */
175174
+ -4, /* (129) on_using ::= USING LP idlist RP */
175175
+ 0, /* (130) on_using ::= */
175176
+ 0, /* (131) indexed_opt ::= */
175177
+ -3, /* (132) indexed_by ::= INDEXED BY nm */
175178
+ -2, /* (133) indexed_by ::= NOT INDEXED */
175179
+ 0, /* (134) orderby_opt ::= */
175180
+ -3, /* (135) orderby_opt ::= ORDER BY sortlist */
175181
+ -5, /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
175182
+ -3, /* (137) sortlist ::= expr sortorder nulls */
175183
+ -1, /* (138) sortorder ::= ASC */
175184
+ -1, /* (139) sortorder ::= DESC */
175185
+ 0, /* (140) sortorder ::= */
175186
+ -2, /* (141) nulls ::= NULLS FIRST */
175187
+ -2, /* (142) nulls ::= NULLS LAST */
175188
+ 0, /* (143) nulls ::= */
175189
+ 0, /* (144) groupby_opt ::= */
175190
+ -3, /* (145) groupby_opt ::= GROUP BY nexprlist */
175191
+ 0, /* (146) having_opt ::= */
175192
+ -2, /* (147) having_opt ::= HAVING expr */
175193
+ 0, /* (148) limit_opt ::= */
175194
+ -2, /* (149) limit_opt ::= LIMIT expr */
175195
+ -4, /* (150) limit_opt ::= LIMIT expr OFFSET expr */
175196
+ -4, /* (151) limit_opt ::= LIMIT expr COMMA expr */
175197
+ -6, /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
175198
+ 0, /* (153) where_opt ::= */
175199
+ -2, /* (154) where_opt ::= WHERE expr */
175200
+ 0, /* (155) where_opt_ret ::= */
175201
+ -2, /* (156) where_opt_ret ::= WHERE expr */
175202
+ -2, /* (157) where_opt_ret ::= RETURNING selcollist */
175203
+ -4, /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
175204
+ -9, /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
175205
+ -5, /* (160) setlist ::= setlist COMMA nm EQ expr */
175206
+ -7, /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
175207
+ -3, /* (162) setlist ::= nm EQ expr */
175208
+ -5, /* (163) setlist ::= LP idlist RP EQ expr */
175209
+ -7, /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
175210
+ -8, /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
175211
+ 0, /* (166) upsert ::= */
175212
+ -2, /* (167) upsert ::= RETURNING selcollist */
175213
+ -12, /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
175214
+ -9, /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
175215
+ -5, /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
175216
+ -8, /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
175217
+ -2, /* (172) returning ::= RETURNING selcollist */
175218
+ -2, /* (173) insert_cmd ::= INSERT orconf */
175219
+ -1, /* (174) insert_cmd ::= REPLACE */
175220
+ 0, /* (175) idlist_opt ::= */
175221
+ -3, /* (176) idlist_opt ::= LP idlist RP */
175222
+ -3, /* (177) idlist ::= idlist COMMA nm */
175223
+ -1, /* (178) idlist ::= nm */
175224
+ -3, /* (179) expr ::= LP expr RP */
175225
+ -1, /* (180) expr ::= ID|INDEXED|JOIN_KW */
175226
+ -3, /* (181) expr ::= nm DOT nm */
175227
+ -5, /* (182) expr ::= nm DOT nm DOT nm */
175228
+ -1, /* (183) term ::= NULL|FLOAT|BLOB */
175229
+ -1, /* (184) term ::= STRING */
175230
+ -1, /* (185) term ::= INTEGER */
175231
+ -1, /* (186) expr ::= VARIABLE */
175232
+ -3, /* (187) expr ::= expr COLLATE ID|STRING */
175233
+ -6, /* (188) expr ::= CAST LP expr AS typetoken RP */
175234
+ -5, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
175235
+ -8, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
175236
+ -4, /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
175237
+ -6, /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
175238
+ -9, /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
175239
+ -5, /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
175240
+ -1, /* (195) term ::= CTIME_KW */
175241
+ -5, /* (196) expr ::= LP nexprlist COMMA expr RP */
175242
+ -3, /* (197) expr ::= expr AND expr */
175243
+ -3, /* (198) expr ::= expr OR expr */
175244
+ -3, /* (199) expr ::= expr LT|GT|GE|LE expr */
175245
+ -3, /* (200) expr ::= expr EQ|NE expr */
175246
+ -3, /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
175247
+ -3, /* (202) expr ::= expr PLUS|MINUS expr */
175248
+ -3, /* (203) expr ::= expr STAR|SLASH|REM expr */
175249
+ -3, /* (204) expr ::= expr CONCAT expr */
175250
+ -2, /* (205) likeop ::= NOT LIKE_KW|MATCH */
175251
+ -3, /* (206) expr ::= expr likeop expr */
175252
+ -5, /* (207) expr ::= expr likeop expr ESCAPE expr */
175253
+ -2, /* (208) expr ::= expr ISNULL|NOTNULL */
175254
+ -3, /* (209) expr ::= expr NOT NULL */
175255
+ -3, /* (210) expr ::= expr IS expr */
175256
+ -4, /* (211) expr ::= expr IS NOT expr */
175257
+ -6, /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
175258
+ -5, /* (213) expr ::= expr IS DISTINCT FROM expr */
175259
+ -2, /* (214) expr ::= NOT expr */
175260
+ -2, /* (215) expr ::= BITNOT expr */
175261
+ -2, /* (216) expr ::= PLUS|MINUS expr */
175262
+ -3, /* (217) expr ::= expr PTR expr */
175263
+ -1, /* (218) between_op ::= BETWEEN */
175264
+ -2, /* (219) between_op ::= NOT BETWEEN */
175265
+ -5, /* (220) expr ::= expr between_op expr AND expr */
175266
+ -1, /* (221) in_op ::= IN */
175267
+ -2, /* (222) in_op ::= NOT IN */
175268
+ -5, /* (223) expr ::= expr in_op LP exprlist RP */
175269
+ -3, /* (224) expr ::= LP select RP */
175270
+ -5, /* (225) expr ::= expr in_op LP select RP */
175271
+ -5, /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
175272
+ -4, /* (227) expr ::= EXISTS LP select RP */
175273
+ -5, /* (228) expr ::= CASE case_operand case_exprlist case_else END */
175274
+ -5, /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
175275
+ -4, /* (230) case_exprlist ::= WHEN expr THEN expr */
175276
+ -2, /* (231) case_else ::= ELSE expr */
175277
+ 0, /* (232) case_else ::= */
175278
+ 0, /* (233) case_operand ::= */
175279
+ 0, /* (234) exprlist ::= */
175280
+ -3, /* (235) nexprlist ::= nexprlist COMMA expr */
175281
+ -1, /* (236) nexprlist ::= expr */
175282
+ 0, /* (237) paren_exprlist ::= */
175283
+ -3, /* (238) paren_exprlist ::= LP exprlist RP */
175284
+ -12, /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
175285
+ -1, /* (240) uniqueflag ::= UNIQUE */
175286
+ 0, /* (241) uniqueflag ::= */
175287
+ 0, /* (242) eidlist_opt ::= */
175288
+ -3, /* (243) eidlist_opt ::= LP eidlist RP */
175289
+ -5, /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
175290
+ -3, /* (245) eidlist ::= nm collate sortorder */
175291
+ 0, /* (246) collate ::= */
175292
+ -2, /* (247) collate ::= COLLATE ID|STRING */
175293
+ -4, /* (248) cmd ::= DROP INDEX ifexists fullname */
175294
+ -2, /* (249) cmd ::= VACUUM vinto */
175295
+ -3, /* (250) cmd ::= VACUUM nm vinto */
175296
+ -2, /* (251) vinto ::= INTO expr */
175297
+ 0, /* (252) vinto ::= */
175298
+ -3, /* (253) cmd ::= PRAGMA nm dbnm */
175299
+ -5, /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
175300
+ -6, /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
175301
+ -5, /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
175302
+ -6, /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
175303
+ -2, /* (258) plus_num ::= PLUS INTEGER|FLOAT */
175304
+ -2, /* (259) minus_num ::= MINUS INTEGER|FLOAT */
175305
+ -5, /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
175306
+ -11, /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
175307
+ -1, /* (262) trigger_time ::= BEFORE|AFTER */
175308
+ -2, /* (263) trigger_time ::= INSTEAD OF */
175309
+ 0, /* (264) trigger_time ::= */
175310
+ -1, /* (265) trigger_event ::= DELETE|INSERT */
175311
+ -1, /* (266) trigger_event ::= UPDATE */
175312
+ -3, /* (267) trigger_event ::= UPDATE OF idlist */
175313
+ 0, /* (268) when_clause ::= */
175314
+ -2, /* (269) when_clause ::= WHEN expr */
175315
+ -3, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
175316
+ -2, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
175317
+ -3, /* (272) trnm ::= nm DOT nm */
175318
+ -3, /* (273) tridxby ::= INDEXED BY nm */
175319
+ -2, /* (274) tridxby ::= NOT INDEXED */
175320
+ -9, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
175321
+ -8, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
175322
+ -6, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
175323
+ -3, /* (278) trigger_cmd ::= scanpt select scanpt */
175324
+ -4, /* (279) expr ::= RAISE LP IGNORE RP */
175325
+ -6, /* (280) expr ::= RAISE LP raisetype COMMA nm RP */
175326
+ -1, /* (281) raisetype ::= ROLLBACK */
175327
+ -1, /* (282) raisetype ::= ABORT */
175328
+ -1, /* (283) raisetype ::= FAIL */
175329
+ -4, /* (284) cmd ::= DROP TRIGGER ifexists fullname */
175330
+ -6, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
175331
+ -3, /* (286) cmd ::= DETACH database_kw_opt expr */
175332
+ 0, /* (287) key_opt ::= */
175333
+ -2, /* (288) key_opt ::= KEY expr */
175334
+ -1, /* (289) cmd ::= REINDEX */
175335
+ -3, /* (290) cmd ::= REINDEX nm dbnm */
175336
+ -1, /* (291) cmd ::= ANALYZE */
175337
+ -3, /* (292) cmd ::= ANALYZE nm dbnm */
175338
+ -6, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
175339
+ -7, /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
175340
+ -6, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
175341
+ -1, /* (296) add_column_fullname ::= fullname */
175342
+ -8, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
175343
+ -1, /* (298) cmd ::= create_vtab */
175344
+ -4, /* (299) cmd ::= create_vtab LP vtabarglist RP */
175345
+ -8, /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
175346
+ 0, /* (301) vtabarg ::= */
175347
+ -1, /* (302) vtabargtoken ::= ANY */
175348
+ -3, /* (303) vtabargtoken ::= lp anylist RP */
175349
+ -1, /* (304) lp ::= LP */
175350
+ -2, /* (305) with ::= WITH wqlist */
175351
+ -3, /* (306) with ::= WITH RECURSIVE wqlist */
175352
+ -1, /* (307) wqas ::= AS */
175353
+ -2, /* (308) wqas ::= AS MATERIALIZED */
175354
+ -3, /* (309) wqas ::= AS NOT MATERIALIZED */
175355
+ -6, /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
175356
+ -1, /* (311) withnm ::= nm */
175357
+ -1, /* (312) wqlist ::= wqitem */
175358
+ -3, /* (313) wqlist ::= wqlist COMMA wqitem */
175359
+ -3, /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
175360
+ -5, /* (315) windowdefn ::= nm AS LP window RP */
175361
+ -5, /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
175362
+ -6, /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
175363
+ -4, /* (318) window ::= ORDER BY sortlist frame_opt */
175364
+ -5, /* (319) window ::= nm ORDER BY sortlist frame_opt */
175365
+ -2, /* (320) window ::= nm frame_opt */
175366
+ 0, /* (321) frame_opt ::= */
175367
+ -3, /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
175368
+ -6, /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
175369
+ -1, /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
175370
+ -1, /* (325) frame_bound_s ::= frame_bound */
175371
+ -2, /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
175372
+ -1, /* (327) frame_bound_e ::= frame_bound */
175373
+ -2, /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
175374
+ -2, /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
175375
+ -2, /* (330) frame_bound ::= CURRENT ROW */
175376
+ 0, /* (331) frame_exclude_opt ::= */
175377
+ -2, /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
175378
+ -2, /* (333) frame_exclude ::= NO OTHERS */
175379
+ -2, /* (334) frame_exclude ::= CURRENT ROW */
175380
+ -1, /* (335) frame_exclude ::= GROUP|TIES */
175381
+ -2, /* (336) window_clause ::= WINDOW windowdefn_list */
175382
+ -2, /* (337) filter_over ::= filter_clause over_clause */
175383
+ -1, /* (338) filter_over ::= over_clause */
175384
+ -1, /* (339) filter_over ::= filter_clause */
175385
+ -4, /* (340) over_clause ::= OVER LP window RP */
175386
+ -2, /* (341) over_clause ::= OVER nm */
175387
+ -5, /* (342) filter_clause ::= FILTER LP WHERE expr RP */
175388
+ -1, /* (343) term ::= QNUMBER */
175389
+ -1, /* (344) input ::= cmdlist */
175390
+ -2, /* (345) cmdlist ::= cmdlist ecmd */
175391
+ -1, /* (346) cmdlist ::= ecmd */
175392
+ -1, /* (347) ecmd ::= SEMI */
175393
+ -2, /* (348) ecmd ::= cmdx SEMI */
175394
+ -3, /* (349) ecmd ::= explain cmdx SEMI */
175395
+ 0, /* (350) trans_opt ::= */
175396
+ -1, /* (351) trans_opt ::= TRANSACTION */
175397
+ -2, /* (352) trans_opt ::= TRANSACTION nm */
175398
+ -1, /* (353) savepoint_opt ::= SAVEPOINT */
175399
+ 0, /* (354) savepoint_opt ::= */
175400
+ -2, /* (355) cmd ::= create_table create_table_args */
175401
+ -1, /* (356) table_option_set ::= table_option */
175402
+ -4, /* (357) columnlist ::= columnlist COMMA columnname carglist */
175403
+ -2, /* (358) columnlist ::= columnname carglist */
175404
+ -1, /* (359) nm ::= ID|INDEXED|JOIN_KW */
175405
+ -1, /* (360) nm ::= STRING */
175406
+ -1, /* (361) typetoken ::= typename */
175407
+ -1, /* (362) typename ::= ID|STRING */
175408
+ -1, /* (363) signed ::= plus_num */
175409
+ -1, /* (364) signed ::= minus_num */
175410
+ -2, /* (365) carglist ::= carglist ccons */
175411
+ 0, /* (366) carglist ::= */
175412
+ -2, /* (367) ccons ::= NULL onconf */
175413
+ -4, /* (368) ccons ::= GENERATED ALWAYS AS generated */
175414
+ -2, /* (369) ccons ::= AS generated */
175415
+ -2, /* (370) conslist_opt ::= COMMA conslist */
175416
+ -3, /* (371) conslist ::= conslist tconscomma tcons */
175417
+ -1, /* (372) conslist ::= tcons */
175418
+ 0, /* (373) tconscomma ::= */
175419
+ -1, /* (374) defer_subclause_opt ::= defer_subclause */
175420
+ -1, /* (375) resolvetype ::= raisetype */
175421
+ -1, /* (376) selectnowith ::= oneselect */
175422
+ -1, /* (377) oneselect ::= values */
175423
+ -2, /* (378) sclp ::= selcollist COMMA */
175424
+ -1, /* (379) as ::= ID|STRING */
175425
+ -1, /* (380) indexed_opt ::= indexed_by */
175426
+ 0, /* (381) returning ::= */
175427
+ -1, /* (382) expr ::= term */
175428
+ -1, /* (383) likeop ::= LIKE_KW|MATCH */
175429
+ -1, /* (384) case_operand ::= expr */
175430
+ -1, /* (385) exprlist ::= nexprlist */
175431
+ -1, /* (386) nmnum ::= plus_num */
175432
+ -1, /* (387) nmnum ::= nm */
175433
+ -1, /* (388) nmnum ::= ON */
175434
+ -1, /* (389) nmnum ::= DELETE */
175435
+ -1, /* (390) nmnum ::= DEFAULT */
175436
+ -1, /* (391) plus_num ::= INTEGER|FLOAT */
175437
+ 0, /* (392) foreach_clause ::= */
175438
+ -3, /* (393) foreach_clause ::= FOR EACH ROW */
175439
+ -1, /* (394) trnm ::= nm */
175440
+ 0, /* (395) tridxby ::= */
175441
+ -1, /* (396) database_kw_opt ::= DATABASE */
175442
+ 0, /* (397) database_kw_opt ::= */
175443
+ 0, /* (398) kwcolumn_opt ::= */
175444
+ -1, /* (399) kwcolumn_opt ::= COLUMNKW */
175445
+ -1, /* (400) vtabarglist ::= vtabarg */
175446
+ -3, /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
175447
+ -2, /* (402) vtabarg ::= vtabarg vtabargtoken */
175448
+ 0, /* (403) anylist ::= */
175449
+ -4, /* (404) anylist ::= anylist LP anylist RP */
175450
+ -2, /* (405) anylist ::= anylist ANY */
175451
+ 0, /* (406) with ::= */
175452
+ -1, /* (407) windowdefn_list ::= windowdefn */
175453
+ -1, /* (408) window ::= frame_opt */
175155175454
 };
175156175455
175157175456
 static void yy_accept(yyParser*); /* Forward Declaration */
175158175457
175159175458
 /*
@@ -175201,20 +175500,20 @@
175201175500
 break;
175202175501
 case 2: /* cmdx ::= cmd */
175203175502
 { sqlite3FinishCoding(pParse); }
175204175503
 break;
175205175504
 case 3: /* cmd ::= BEGIN transtype trans_opt */
175206
-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy92);}
175505
+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
175207175506
 break;
175208175507
 case 4: /* transtype ::= */
175209
-{yymsp[1].minor.yy92 = TK_DEFERRED;}
175508
+{yymsp[1].minor.yy144 = TK_DEFERRED;}
175210175509
 break;
175211175510
 case 5: /* transtype ::= DEFERRED */
175212175511
 case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
175213175512
 case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
175214
- case 321: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==321);
175215
-{yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-X*/}
175513
+ case 324: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==324);
175514
+{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/}
175216175515
 break;
175217175516
 case 8: /* cmd ::= COMMIT|END trans_opt */
175218175517
 case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
175219175518
 {sqlite3EndTransaction(pParse,yymsp[-1].major);}
175220175519
 break;
@@ -175233,11 +175532,11 @@
175233175532
 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
175234175533
 }
175235175534
 break;
175236175535
 case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
175237175536
 {
175238
- sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy92,0,0,yymsp[-2].minor.yy92);
175537
+ sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144);
175239175538
 }
175240175539
 break;
175241175540
 case 14: /* createkw ::= CREATE */
175242175541
 {disableLookaside(pParse);}
175243175542
 break;
@@ -175245,65 +175544,65 @@
175245175544
 case 18: /* temp ::= */ yytestcase(yyruleno==18);
175246175545
 case 47: /* autoinc ::= */ yytestcase(yyruleno==47);
175247175546
 case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
175248175547
 case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
175249175548
 case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
175250
- case 98: /* distinct ::= */ yytestcase(yyruleno==98);
175251
- case 244: /* collate ::= */ yytestcase(yyruleno==244);
175252
-{yymsp[1].minor.yy92 = 0;}
175549
+ case 100: /* distinct ::= */ yytestcase(yyruleno==100);
175550
+ case 246: /* collate ::= */ yytestcase(yyruleno==246);
175551
+{yymsp[1].minor.yy144 = 0;}
175253175552
 break;
175254175553
 case 16: /* ifnotexists ::= IF NOT EXISTS */
175255
-{yymsp[-2].minor.yy92 = 1;}
175554
+{yymsp[-2].minor.yy144 = 1;}
175256175555
 break;
175257175556
 case 17: /* temp ::= TEMP */
175258
-{yymsp[0].minor.yy92 = pParse->db->init.busy==0;}
175557
+{yymsp[0].minor.yy144 = pParse->db->init.busy==0;}
175259175558
 break;
175260175559
 case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
175261175560
 {
175262
- sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy527,0);
175561
+ sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0);
175263175562
 }
175264175563
 break;
175265175564
 case 20: /* create_table_args ::= AS select */
175266175565
 {
175267
- sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy299);
175268
- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy299);
175566
+ sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
175567
+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
175269175568
 }
175270175569
 break;
175271175570
 case 21: /* table_option_set ::= */
175272
-{yymsp[1].minor.yy527 = 0;}
175571
+{yymsp[1].minor.yy391 = 0;}
175273175572
 break;
175274175573
 case 22: /* table_option_set ::= table_option_set COMMA table_option */
175275
-{yylhsminor.yy527 = yymsp[-2].minor.yy527|yymsp[0].minor.yy527;}
175276
- yymsp[-2].minor.yy527 = yylhsminor.yy527;
175574
+{yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;}
175575
+ yymsp[-2].minor.yy391 = yylhsminor.yy391;
175277175576
 break;
175278175577
 case 23: /* table_option ::= WITHOUT nm */
175279175578
 {
175280175579
 if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
175281
- yymsp[-1].minor.yy527 = TF_WithoutRowid | TF_NoVisibleRowid;
175580
+ yymsp[-1].minor.yy391 = TF_WithoutRowid | TF_NoVisibleRowid;
175282175581
 }else{
175283
- yymsp[-1].minor.yy527 = 0;
175582
+ yymsp[-1].minor.yy391 = 0;
175284175583
 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175285175584
 }
175286175585
 }
175287175586
 break;
175288175587
 case 24: /* table_option ::= nm */
175289175588
 {
175290175589
 if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
175291
- yylhsminor.yy527 = TF_Strict;
175590
+ yylhsminor.yy391 = TF_Strict;
175292175591
 }else{
175293
- yylhsminor.yy527 = 0;
175592
+ yylhsminor.yy391 = 0;
175294175593
 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175295175594
 }
175296175595
 }
175297
- yymsp[0].minor.yy527 = yylhsminor.yy527;
175596
+ yymsp[0].minor.yy391 = yylhsminor.yy391;
175298175597
 break;
175299175598
 case 25: /* columnname ::= nm typetoken */
175300175599
 {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
175301175600
 break;
175302175601
 case 26: /* typetoken ::= */
175303175602
 case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
175304
- case 104: /* as ::= */ yytestcase(yyruleno==104);
175603
+ case 106: /* as ::= */ yytestcase(yyruleno==106);
175305175604
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
175306175605
 break;
175307175606
 case 27: /* typetoken ::= typename LP signed RP */
175308175607
 {
175309175608
 yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
@@ -175318,11 +175617,11 @@
175318175617
 {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
175319175618
 break;
175320175619
 case 30: /* scanpt ::= */
175321175620
 {
175322175621
 assert( yyLookahead!=YYNOCODE );
175323
- yymsp[1].minor.yy616 = yyLookaheadToken.z;
175622
+ yymsp[1].minor.yy168 = yyLookaheadToken.z;
175324175623
 }
175325175624
 break;
175326175625
 case 31: /* scantok ::= */
175327175626
 {
175328175627
 assert( yyLookahead!=YYNOCODE );
@@ -175332,21 +175631,21 @@
175332175631
 case 32: /* ccons ::= CONSTRAINT nm */
175333175632
 case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
175334175633
 {pParse->constraintName = yymsp[0].minor.yy0;}
175335175634
 break;
175336175635
 case 33: /* ccons ::= DEFAULT scantok term */
175337
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy2,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175636
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175338175637
 break;
175339175638
 case 34: /* ccons ::= DEFAULT LP expr RP */
175340
-{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy2,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
175639
+{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
175341175640
 break;
175342175641
 case 35: /* ccons ::= DEFAULT PLUS scantok term */
175343
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy2,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175642
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175344175643
 break;
175345175644
 case 36: /* ccons ::= DEFAULT MINUS scantok term */
175346175645
 {
175347
- Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy2, 0);
175646
+ Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0);
175348175647
 sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
175349175648
 }
175350175649
 break;
175351175650
 case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
175352175651
 {
@@ -175357,315 +175656,312 @@
175357175656
 }
175358175657
 sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
175359175658
 }
175360175659
 break;
175361175660
 case 38: /* ccons ::= NOT NULL onconf */
175362
-{sqlite3AddNotNull(pParse, yymsp[0].minor.yy92);}
175661
+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);}
175363175662
 break;
175364175663
 case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
175365
-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy92,yymsp[0].minor.yy92,yymsp[-2].minor.yy92);}
175664
+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
175366175665
 break;
175367175666
 case 40: /* ccons ::= UNIQUE onconf */
175368
-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy92,0,0,0,0,
175667
+{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
175369175668
 SQLITE_IDXTYPE_UNIQUE);}
175370175669
 break;
175371175670
 case 41: /* ccons ::= CHECK LP expr RP */
175372
-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy2,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
175671
+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
175373175672
 break;
175374175673
 case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
175375
-{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy402,yymsp[0].minor.yy92);}
175674
+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);}
175376175675
 break;
175377175676
 case 43: /* ccons ::= defer_subclause */
175378
-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy92);}
175677
+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
175379175678
 break;
175380175679
 case 44: /* ccons ::= COLLATE ID|STRING */
175381175680
 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
175382175681
 break;
175383175682
 case 45: /* generated ::= LP expr RP */
175384
-{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy2,0);}
175683
+{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);}
175385175684
 break;
175386175685
 case 46: /* generated ::= LP expr RP ID */
175387
-{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy2,&yymsp[0].minor.yy0);}
175686
+{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
175388175687
 break;
175389175688
 case 48: /* autoinc ::= AUTOINCR */
175390
-{yymsp[0].minor.yy92 = 1;}
175689
+{yymsp[0].minor.yy144 = 1;}
175391175690
 break;
175392175691
 case 49: /* refargs ::= */
175393
-{ yymsp[1].minor.yy92 = OE_None*0x0101; /* EV: R-19803-45884 */}
175692
+{ yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */}
175394175693
 break;
175395175694
 case 50: /* refargs ::= refargs refarg */
175396
-{ yymsp[-1].minor.yy92 = (yymsp[-1].minor.yy92 & ~yymsp[0].minor.yy367.mask) | yymsp[0].minor.yy367.value; }
175695
+{ yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; }
175397175696
 break;
175398175697
 case 51: /* refarg ::= MATCH nm */
175399
-{ yymsp[-1].minor.yy367.value = 0; yymsp[-1].minor.yy367.mask = 0x000000; }
175698
+{ yymsp[-1].minor.yy383.value = 0; yymsp[-1].minor.yy383.mask = 0x000000; }
175400175699
 break;
175401175700
 case 52: /* refarg ::= ON INSERT refact */
175402
-{ yymsp[-2].minor.yy367.value = 0; yymsp[-2].minor.yy367.mask = 0x000000; }
175701
+{ yymsp[-2].minor.yy383.value = 0; yymsp[-2].minor.yy383.mask = 0x000000; }
175403175702
 break;
175404175703
 case 53: /* refarg ::= ON DELETE refact */
175405
-{ yymsp[-2].minor.yy367.value = yymsp[0].minor.yy92; yymsp[-2].minor.yy367.mask = 0x0000ff; }
175704
+{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144; yymsp[-2].minor.yy383.mask = 0x0000ff; }
175406175705
 break;
175407175706
 case 54: /* refarg ::= ON UPDATE refact */
175408
-{ yymsp[-2].minor.yy367.value = yymsp[0].minor.yy92<<8; yymsp[-2].minor.yy367.mask = 0x00ff00; }
175707
+{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8; yymsp[-2].minor.yy383.mask = 0x00ff00; }
175409175708
 break;
175410175709
 case 55: /* refact ::= SET NULL */
175411
-{ yymsp[-1].minor.yy92 = OE_SetNull; /* EV: R-33326-45252 */}
175710
+{ yymsp[-1].minor.yy144 = OE_SetNull; /* EV: R-33326-45252 */}
175412175711
 break;
175413175712
 case 56: /* refact ::= SET DEFAULT */
175414
-{ yymsp[-1].minor.yy92 = OE_SetDflt; /* EV: R-33326-45252 */}
175713
+{ yymsp[-1].minor.yy144 = OE_SetDflt; /* EV: R-33326-45252 */}
175415175714
 break;
175416175715
 case 57: /* refact ::= CASCADE */
175417
-{ yymsp[0].minor.yy92 = OE_Cascade; /* EV: R-33326-45252 */}
175716
+{ yymsp[0].minor.yy144 = OE_Cascade; /* EV: R-33326-45252 */}
175418175717
 break;
175419175718
 case 58: /* refact ::= RESTRICT */
175420
-{ yymsp[0].minor.yy92 = OE_Restrict; /* EV: R-33326-45252 */}
175719
+{ yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */}
175421175720
 break;
175422175721
 case 59: /* refact ::= NO ACTION */
175423
-{ yymsp[-1].minor.yy92 = OE_None; /* EV: R-33326-45252 */}
175722
+{ yymsp[-1].minor.yy144 = OE_None; /* EV: R-33326-45252 */}
175424175723
 break;
175425175724
 case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
175426
-{yymsp[-2].minor.yy92 = 0;}
175725
+{yymsp[-2].minor.yy144 = 0;}
175427175726
 break;
175428175727
 case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
175429175728
 case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
175430
- case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171);
175431
-{yymsp[-1].minor.yy92 = yymsp[0].minor.yy92;}
175729
+ case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173);
175730
+{yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;}
175432175731
 break;
175433175732
 case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
175434175733
 case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
175435
- case 217: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==217);
175436
- case 220: /* in_op ::= NOT IN */ yytestcase(yyruleno==220);
175437
- case 245: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==245);
175438
-{yymsp[-1].minor.yy92 = 1;}
175734
+ case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
175735
+ case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
175736
+ case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
175737
+{yymsp[-1].minor.yy144 = 1;}
175439175738
 break;
175440175739
 case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
175441
-{yymsp[-1].minor.yy92 = 0;}
175740
+{yymsp[-1].minor.yy144 = 0;}
175442175741
 break;
175443175742
 case 66: /* tconscomma ::= COMMA */
175444175743
 {pParse->constraintName.n = 0;}
175445175744
 break;
175446175745
 case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
175447
-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy402,yymsp[0].minor.yy92,yymsp[-2].minor.yy92,0);}
175746
+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
175448175747
 break;
175449175748
 case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
175450
-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy402,yymsp[0].minor.yy92,0,0,0,0,
175749
+{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
175451175750
 SQLITE_IDXTYPE_UNIQUE);}
175452175751
 break;
175453175752
 case 70: /* tcons ::= CHECK LP expr RP onconf */
175454
-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy2,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
175753
+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
175455175754
 break;
175456175755
 case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
175457175756
 {
175458
- sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy402, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[-1].minor.yy92);
175459
- sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy92);
175757
+ sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
175758
+ sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
175460175759
 }
175461175760
 break;
175462175761
 case 73: /* onconf ::= */
175463175762
 case 75: /* orconf ::= */ yytestcase(yyruleno==75);
175464
-{yymsp[1].minor.yy92 = OE_Default;}
175763
+{yymsp[1].minor.yy144 = OE_Default;}
175465175764
 break;
175466175765
 case 74: /* onconf ::= ON CONFLICT resolvetype */
175467
-{yymsp[-2].minor.yy92 = yymsp[0].minor.yy92;}
175766
+{yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;}
175468175767
 break;
175469175768
 case 77: /* resolvetype ::= IGNORE */
175470
-{yymsp[0].minor.yy92 = OE_Ignore;}
175769
+{yymsp[0].minor.yy144 = OE_Ignore;}
175471175770
 break;
175472175771
 case 78: /* resolvetype ::= REPLACE */
175473
- case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172);
175474
-{yymsp[0].minor.yy92 = OE_Replace;}
175772
+ case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174);
175773
+{yymsp[0].minor.yy144 = OE_Replace;}
175475175774
 break;
175476175775
 case 79: /* cmd ::= DROP TABLE ifexists fullname */
175477175776
 {
175478
- sqlite3DropTable(pParse, yymsp[0].minor.yy387, 0, yymsp[-1].minor.yy92);
175777
+ sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
175479175778
 }
175480175779
 break;
175481175780
 case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
175482175781
 {
175483
- sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[0].minor.yy299, yymsp[-7].minor.yy92, yymsp[-5].minor.yy92);
175782
+ sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
175484175783
 }
175485175784
 break;
175486175785
 case 83: /* cmd ::= DROP VIEW ifexists fullname */
175487175786
 {
175488
- sqlite3DropTable(pParse, yymsp[0].minor.yy387, 1, yymsp[-1].minor.yy92);
175787
+ sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
175489175788
 }
175490175789
 break;
175491175790
 case 84: /* cmd ::= select */
175492175791
 {
175493175792
 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
175494
- sqlite3Select(pParse, yymsp[0].minor.yy299, &dest);
175495
- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy299);
175793
+ sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
175794
+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
175496175795
 }
175497175796
 break;
175498175797
 case 85: /* select ::= WITH wqlist selectnowith */
175499
-{yymsp[-2].minor.yy299 = attachWithToSelect(pParse,yymsp[0].minor.yy299,yymsp[-1].minor.yy131);}
175798
+{yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
175500175799
 break;
175501175800
 case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
175502
-{yymsp[-3].minor.yy299 = attachWithToSelect(pParse,yymsp[0].minor.yy299,yymsp[-1].minor.yy131);}
175801
+{yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
175503175802
 break;
175504175803
 case 87: /* select ::= selectnowith */
175505175804
 {
175506
- Select *p = yymsp[0].minor.yy299;
175805
+ Select *p = yymsp[0].minor.yy555;
175507175806
 if( p ){
175508175807
 parserDoubleLinkSelect(pParse, p);
175509175808
 }
175510175809
 }
175511175810
 break;
175512175811
 case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
175513175812
 {
175514
- Select *pRhs = yymsp[0].minor.yy299;
175515
- Select *pLhs = yymsp[-2].minor.yy299;
175813
+ Select *pRhs = yymsp[0].minor.yy555;
175814
+ Select *pLhs = yymsp[-2].minor.yy555;
175516175815
 if( pRhs && pRhs->pPrior ){
175517175816
 SrcList *pFrom;
175518175817
 Token x;
175519175818
 x.n = 0;
175520175819
 parserDoubleLinkSelect(pParse, pRhs);
175521175820
 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
175522175821
 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
175523175822
 }
175524175823
 if( pRhs ){
175525
- pRhs->op = (u8)yymsp[-1].minor.yy92;
175824
+ pRhs->op = (u8)yymsp[-1].minor.yy144;
175526175825
 pRhs->pPrior = pLhs;
175527175826
 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
175528175827
 pRhs->selFlags &= ~SF_MultiValue;
175529
- if( yymsp[-1].minor.yy92!=TK_ALL ) pParse->hasCompound = 1;
175828
+ if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
175530175829
 }else{
175531175830
 sqlite3SelectDelete(pParse->db, pLhs);
175532175831
 }
175533
- yymsp[-2].minor.yy299 = pRhs;
175832
+ yymsp[-2].minor.yy555 = pRhs;
175534175833
 }
175535175834
 break;
175536175835
 case 89: /* multiselect_op ::= UNION */
175537175836
 case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
175538
-{yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-OP*/}
175837
+{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/}
175539175838
 break;
175540175839
 case 90: /* multiselect_op ::= UNION ALL */
175541
-{yymsp[-1].minor.yy92 = TK_ALL;}
175840
+{yymsp[-1].minor.yy144 = TK_ALL;}
175542175841
 break;
175543175842
 case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
175544175843
 {
175545
- yymsp[-8].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy402,yymsp[-5].minor.yy387,yymsp[-4].minor.yy2,yymsp[-3].minor.yy402,yymsp[-2].minor.yy2,yymsp[-1].minor.yy402,yymsp[-7].minor.yy92,yymsp[0].minor.yy2);
175844
+ yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
175546175845
 }
175547175846
 break;
175548175847
 case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
175549175848
 {
175550
- yymsp[-9].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy402,yymsp[-6].minor.yy387,yymsp[-5].minor.yy2,yymsp[-4].minor.yy402,yymsp[-3].minor.yy2,yymsp[-1].minor.yy402,yymsp[-8].minor.yy92,yymsp[0].minor.yy2);
175551
- if( yymsp[-9].minor.yy299 ){
175552
- yymsp[-9].minor.yy299->pWinDefn = yymsp[-2].minor.yy3;
175849
+ yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
175850
+ if( yymsp[-9].minor.yy555 ){
175851
+ yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211;
175553175852
 }else{
175554
- sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy3);
175853
+ sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
175555175854
 }
175556175855
 }
175557175856
 break;
175558175857
 case 94: /* values ::= VALUES LP nexprlist RP */
175559175858
 {
175560
- yymsp[-3].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy402,0,0,0,0,0,SF_Values,0);
175561
-}
175562
- break;
175563
- case 95: /* values ::= values COMMA LP nexprlist RP */
175564
-{
175565
- Select *pRight, *pLeft = yymsp[-4].minor.yy299;
175566
- pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy402,0,0,0,0,0,SF_Values|SF_MultiValue,0);
175567
- if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
175568
- if( pRight ){
175569
- pRight->op = TK_ALL;
175570
- pRight->pPrior = pLeft;
175571
- yymsp[-4].minor.yy299 = pRight;
175572
- }else{
175573
- yymsp[-4].minor.yy299 = pLeft;
175574
- }
175575
-}
175576
- break;
175577
- case 96: /* distinct ::= DISTINCT */
175578
-{yymsp[0].minor.yy92 = SF_Distinct;}
175579
- break;
175580
- case 97: /* distinct ::= ALL */
175581
-{yymsp[0].minor.yy92 = SF_All;}
175582
- break;
175583
- case 99: /* sclp ::= */
175584
- case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132);
175585
- case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142);
175586
- case 232: /* exprlist ::= */ yytestcase(yyruleno==232);
175587
- case 235: /* paren_exprlist ::= */ yytestcase(yyruleno==235);
175588
- case 240: /* eidlist_opt ::= */ yytestcase(yyruleno==240);
175589
-{yymsp[1].minor.yy402 = 0;}
175590
- break;
175591
- case 100: /* selcollist ::= sclp scanpt expr scanpt as */
175592
-{
175593
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[-2].minor.yy2);
175594
- if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[0].minor.yy0, 1);
175595
- sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy402,yymsp[-3].minor.yy616,yymsp[-1].minor.yy616);
175596
-}
175597
- break;
175598
- case 101: /* selcollist ::= sclp scanpt STAR */
175859
+ yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
175860
+}
175861
+ break;
175862
+ case 95: /* oneselect ::= mvalues */
175863
+{
175864
+ sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
175865
+}
175866
+ break;
175867
+ case 96: /* mvalues ::= values COMMA LP nexprlist RP */
175868
+ case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97);
175869
+{
175870
+ yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
175871
+}
175872
+ break;
175873
+ case 98: /* distinct ::= DISTINCT */
175874
+{yymsp[0].minor.yy144 = SF_Distinct;}
175875
+ break;
175876
+ case 99: /* distinct ::= ALL */
175877
+{yymsp[0].minor.yy144 = SF_All;}
175878
+ break;
175879
+ case 101: /* sclp ::= */
175880
+ case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134);
175881
+ case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144);
175882
+ case 234: /* exprlist ::= */ yytestcase(yyruleno==234);
175883
+ case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237);
175884
+ case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242);
175885
+{yymsp[1].minor.yy14 = 0;}
175886
+ break;
175887
+ case 102: /* selcollist ::= sclp scanpt expr scanpt as */
175888
+{
175889
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
175890
+ if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
175891
+ sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
175892
+}
175893
+ break;
175894
+ case 103: /* selcollist ::= sclp scanpt STAR */
175599175895
 {
175600175896
 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
175601175897
 sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175602
- yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy402, p);
175898
+ yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
175603175899
 }
175604175900
 break;
175605
- case 102: /* selcollist ::= sclp scanpt nm DOT STAR */
175901
+ case 104: /* selcollist ::= sclp scanpt nm DOT STAR */
175606175902
 {
175607175903
 Expr *pRight, *pLeft, *pDot;
175608175904
 pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
175609175905
 sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175610175906
 pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
175611175907
 pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
175612
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, pDot);
175908
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
175613175909
 }
175614175910
 break;
175615
- case 103: /* as ::= AS nm */
175616
- case 115: /* dbnm ::= DOT nm */ yytestcase(yyruleno==115);
175617
- case 256: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==256);
175618
- case 257: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==257);
175911
+ case 105: /* as ::= AS nm */
175912
+ case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117);
175913
+ case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258);
175914
+ case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259);
175619175915
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
175620175916
 break;
175621
- case 105: /* from ::= */
175622
- case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108);
175623
-{yymsp[1].minor.yy387 = 0;}
175624
- break;
175625
- case 106: /* from ::= FROM seltablist */
175626
-{
175627
- yymsp[-1].minor.yy387 = yymsp[0].minor.yy387;
175628
- sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy387);
175629
-}
175630
- break;
175631
- case 107: /* stl_prefix ::= seltablist joinop */
175632
-{
175633
- if( ALWAYS(yymsp[-1].minor.yy387 && yymsp[-1].minor.yy387->nSrc>0) ) yymsp[-1].minor.yy387->a[yymsp[-1].minor.yy387->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy92;
175634
-}
175635
- break;
175636
- case 109: /* seltablist ::= stl_prefix nm dbnm as on_using */
175637
-{
175638
- yymsp[-4].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy387,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175639
-}
175640
- break;
175641
- case 110: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175642
-{
175643
- yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy305);
175644
- sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy387, &yymsp[-1].minor.yy0);
175645
-}
175646
- break;
175647
- case 111: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175648
-{
175649
- yymsp[-7].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy387,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175650
- sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy387, yymsp[-3].minor.yy402);
175651
-}
175652
- break;
175653
- case 112: /* seltablist ::= stl_prefix LP select RP as on_using */
175654
-{
175655
- yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy299,&yymsp[0].minor.yy305);
175656
- }
175657
- break;
175658
- case 113: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
175659
-{
175660
- if( yymsp[-5].minor.yy387==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy305.pOn==0 && yymsp[0].minor.yy305.pUsing==0 ){
175661
- yymsp[-5].minor.yy387 = yymsp[-3].minor.yy387;
175662
- }else if( ALWAYS(yymsp[-3].minor.yy387!=0) && yymsp[-3].minor.yy387->nSrc==1 ){
175663
- yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175664
- if( yymsp[-5].minor.yy387 ){
175665
- SrcItem *pNew = &yymsp[-5].minor.yy387->a[yymsp[-5].minor.yy387->nSrc-1];
175666
- SrcItem *pOld = yymsp[-3].minor.yy387->a;
175917
+ case 107: /* from ::= */
175918
+ case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110);
175919
+{yymsp[1].minor.yy203 = 0;}
175920
+ break;
175921
+ case 108: /* from ::= FROM seltablist */
175922
+{
175923
+ yymsp[-1].minor.yy203 = yymsp[0].minor.yy203;
175924
+ sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
175925
+}
175926
+ break;
175927
+ case 109: /* stl_prefix ::= seltablist joinop */
175928
+{
175929
+ if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144;
175930
+}
175931
+ break;
175932
+ case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */
175933
+{
175934
+ yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175935
+}
175936
+ break;
175937
+ case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175938
+{
175939
+ yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
175940
+ sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
175941
+}
175942
+ break;
175943
+ case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175944
+{
175945
+ yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175946
+ sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
175947
+}
175948
+ break;
175949
+ case 114: /* seltablist ::= stl_prefix LP select RP as on_using */
175950
+{
175951
+ yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
175952
+ }
175953
+ break;
175954
+ case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
175955
+{
175956
+ if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){
175957
+ yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203;
175958
+ }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){
175959
+ yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175960
+ if( yymsp[-5].minor.yy203 ){
175961
+ SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
175962
+ SrcItem *pOld = yymsp[-3].minor.yy203->a;
175667175963
 pNew->zName = pOld->zName;
175668175964
 pNew->zDatabase = pOld->zDatabase;
175669175965
 pNew->pSelect = pOld->pSelect;
175670175966
 if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
175671175967
 pNew->fg.isNestedFrom = 1;
@@ -175677,1061 +175973,1064 @@
175677175973
 pNew->fg.isTabFunc = 1;
175678175974
 }
175679175975
 pOld->zName = pOld->zDatabase = 0;
175680175976
 pOld->pSelect = 0;
175681175977
 }
175682
- sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy387);
175978
+ sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
175683175979
 }else{
175684175980
 Select *pSubquery;
175685
- sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy387);
175686
- pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy387,0,0,0,0,SF_NestedFrom,0);
175687
- yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy305);
175981
+ sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
175982
+ pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
175983
+ yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
175688175984
 }
175689175985
 }
175690175986
 break;
175691
- case 114: /* dbnm ::= */
175692
- case 129: /* indexed_opt ::= */ yytestcase(yyruleno==129);
175987
+ case 116: /* dbnm ::= */
175988
+ case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131);
175693175989
 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
175694175990
 break;
175695
- case 116: /* fullname ::= nm */
175696
-{
175697
- yylhsminor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
175698
- if( IN_RENAME_OBJECT && yylhsminor.yy387 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy387->a[0].zName, &yymsp[0].minor.yy0);
175699
-}
175700
- yymsp[0].minor.yy387 = yylhsminor.yy387;
175701
- break;
175702
- case 117: /* fullname ::= nm DOT nm */
175703
-{
175704
- yylhsminor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
175705
- if( IN_RENAME_OBJECT && yylhsminor.yy387 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy387->a[0].zName, &yymsp[0].minor.yy0);
175706
-}
175707
- yymsp[-2].minor.yy387 = yylhsminor.yy387;
175708
- break;
175709
- case 118: /* xfullname ::= nm */
175710
-{yymsp[0].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
175711
- break;
175712
- case 119: /* xfullname ::= nm DOT nm */
175713
-{yymsp[-2].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
175714
- break;
175715
- case 120: /* xfullname ::= nm DOT nm AS nm */
175716
-{
175717
- yymsp[-4].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
175718
- if( yymsp[-4].minor.yy387 ) yymsp[-4].minor.yy387->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
175719
-}
175720
- break;
175721
- case 121: /* xfullname ::= nm AS nm */
175722
-{
175723
- yymsp[-2].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
175724
- if( yymsp[-2].minor.yy387 ) yymsp[-2].minor.yy387->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
175725
-}
175726
- break;
175727
- case 122: /* joinop ::= COMMA|JOIN */
175728
-{ yymsp[0].minor.yy92 = JT_INNER; }
175729
- break;
175730
- case 123: /* joinop ::= JOIN_KW JOIN */
175731
-{yymsp[-1].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
175732
- break;
175733
- case 124: /* joinop ::= JOIN_KW nm JOIN */
175734
-{yymsp[-2].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
175735
- break;
175736
- case 125: /* joinop ::= JOIN_KW nm nm JOIN */
175737
-{yymsp[-3].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
175738
- break;
175739
- case 126: /* on_using ::= ON expr */
175740
-{yymsp[-1].minor.yy305.pOn = yymsp[0].minor.yy2; yymsp[-1].minor.yy305.pUsing = 0;}
175741
- break;
175742
- case 127: /* on_using ::= USING LP idlist RP */
175743
-{yymsp[-3].minor.yy305.pOn = 0; yymsp[-3].minor.yy305.pUsing = yymsp[-1].minor.yy400;}
175744
- break;
175745
- case 128: /* on_using ::= */
175746
-{yymsp[1].minor.yy305.pOn = 0; yymsp[1].minor.yy305.pUsing = 0;}
175747
- break;
175748
- case 130: /* indexed_by ::= INDEXED BY nm */
175991
+ case 118: /* fullname ::= nm */
175992
+{
175993
+ yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
175994
+ if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
175995
+}
175996
+ yymsp[0].minor.yy203 = yylhsminor.yy203;
175997
+ break;
175998
+ case 119: /* fullname ::= nm DOT nm */
175999
+{
176000
+ yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
176001
+ if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
176002
+}
176003
+ yymsp[-2].minor.yy203 = yylhsminor.yy203;
176004
+ break;
176005
+ case 120: /* xfullname ::= nm */
176006
+{yymsp[0].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
176007
+ break;
176008
+ case 121: /* xfullname ::= nm DOT nm */
176009
+{yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
176010
+ break;
176011
+ case 122: /* xfullname ::= nm DOT nm AS nm */
176012
+{
176013
+ yymsp[-4].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
176014
+ if( yymsp[-4].minor.yy203 ) yymsp[-4].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176015
+}
176016
+ break;
176017
+ case 123: /* xfullname ::= nm AS nm */
176018
+{
176019
+ yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
176020
+ if( yymsp[-2].minor.yy203 ) yymsp[-2].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176021
+}
176022
+ break;
176023
+ case 124: /* joinop ::= COMMA|JOIN */
176024
+{ yymsp[0].minor.yy144 = JT_INNER; }
176025
+ break;
176026
+ case 125: /* joinop ::= JOIN_KW JOIN */
176027
+{yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
176028
+ break;
176029
+ case 126: /* joinop ::= JOIN_KW nm JOIN */
176030
+{yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
176031
+ break;
176032
+ case 127: /* joinop ::= JOIN_KW nm nm JOIN */
176033
+{yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
176034
+ break;
176035
+ case 128: /* on_using ::= ON expr */
176036
+{yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;}
176037
+ break;
176038
+ case 129: /* on_using ::= USING LP idlist RP */
176039
+{yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;}
176040
+ break;
176041
+ case 130: /* on_using ::= */
176042
+{yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;}
176043
+ break;
176044
+ case 132: /* indexed_by ::= INDEXED BY nm */
175749176045
 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
175750176046
 break;
175751
- case 131: /* indexed_by ::= NOT INDEXED */
176047
+ case 133: /* indexed_by ::= NOT INDEXED */
175752176048
 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
175753176049
 break;
175754
- case 133: /* orderby_opt ::= ORDER BY sortlist */
175755
- case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143);
175756
-{yymsp[-2].minor.yy402 = yymsp[0].minor.yy402;}
175757
- break;
175758
- case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */
175759
-{
175760
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402,yymsp[-2].minor.yy2);
175761
- sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy402,yymsp[-1].minor.yy92,yymsp[0].minor.yy92);
175762
-}
175763
- break;
175764
- case 135: /* sortlist ::= expr sortorder nulls */
175765
-{
175766
- yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy2); /*A-overwrites-Y*/
175767
- sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy402,yymsp[-1].minor.yy92,yymsp[0].minor.yy92);
175768
-}
175769
- break;
175770
- case 136: /* sortorder ::= ASC */
175771
-{yymsp[0].minor.yy92 = SQLITE_SO_ASC;}
175772
- break;
175773
- case 137: /* sortorder ::= DESC */
175774
-{yymsp[0].minor.yy92 = SQLITE_SO_DESC;}
175775
- break;
175776
- case 138: /* sortorder ::= */
175777
- case 141: /* nulls ::= */ yytestcase(yyruleno==141);
175778
-{yymsp[1].minor.yy92 = SQLITE_SO_UNDEFINED;}
175779
- break;
175780
- case 139: /* nulls ::= NULLS FIRST */
175781
-{yymsp[-1].minor.yy92 = SQLITE_SO_ASC;}
175782
- break;
175783
- case 140: /* nulls ::= NULLS LAST */
175784
-{yymsp[-1].minor.yy92 = SQLITE_SO_DESC;}
175785
- break;
175786
- case 144: /* having_opt ::= */
175787
- case 146: /* limit_opt ::= */ yytestcase(yyruleno==146);
175788
- case 151: /* where_opt ::= */ yytestcase(yyruleno==151);
175789
- case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153);
175790
- case 230: /* case_else ::= */ yytestcase(yyruleno==230);
175791
- case 231: /* case_operand ::= */ yytestcase(yyruleno==231);
175792
- case 250: /* vinto ::= */ yytestcase(yyruleno==250);
175793
-{yymsp[1].minor.yy2 = 0;}
175794
- break;
175795
- case 145: /* having_opt ::= HAVING expr */
175796
- case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152);
175797
- case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154);
175798
- case 229: /* case_else ::= ELSE expr */ yytestcase(yyruleno==229);
175799
- case 249: /* vinto ::= INTO expr */ yytestcase(yyruleno==249);
175800
-{yymsp[-1].minor.yy2 = yymsp[0].minor.yy2;}
175801
- break;
175802
- case 147: /* limit_opt ::= LIMIT expr */
175803
-{yymsp[-1].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy2,0);}
175804
- break;
175805
- case 148: /* limit_opt ::= LIMIT expr OFFSET expr */
175806
-{yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
175807
- break;
175808
- case 149: /* limit_opt ::= LIMIT expr COMMA expr */
175809
-{yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy2,yymsp[-2].minor.yy2);}
175810
- break;
175811
- case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
175812
-{
175813
- sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy387, &yymsp[-1].minor.yy0);
175814
- sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy387,yymsp[0].minor.yy2,0,0);
175815
-}
175816
- break;
175817
- case 155: /* where_opt_ret ::= RETURNING selcollist */
175818
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-1].minor.yy2 = 0;}
175819
- break;
175820
- case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
175821
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-3].minor.yy2 = yymsp[-2].minor.yy2;}
175822
- break;
175823
- case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
175824
-{
175825
- sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy387, &yymsp[-4].minor.yy0);
175826
- sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy402,"set list");
175827
- if( yymsp[-1].minor.yy387 ){
175828
- SrcList *pFromClause = yymsp[-1].minor.yy387;
176050
+ case 135: /* orderby_opt ::= ORDER BY sortlist */
176051
+ case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145);
176052
+{yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;}
176053
+ break;
176054
+ case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */
176055
+{
176056
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
176057
+ sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
176058
+}
176059
+ break;
176060
+ case 137: /* sortlist ::= expr sortorder nulls */
176061
+{
176062
+ yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
176063
+ sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
176064
+}
176065
+ break;
176066
+ case 138: /* sortorder ::= ASC */
176067
+{yymsp[0].minor.yy144 = SQLITE_SO_ASC;}
176068
+ break;
176069
+ case 139: /* sortorder ::= DESC */
176070
+{yymsp[0].minor.yy144 = SQLITE_SO_DESC;}
176071
+ break;
176072
+ case 140: /* sortorder ::= */
176073
+ case 143: /* nulls ::= */ yytestcase(yyruleno==143);
176074
+{yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;}
176075
+ break;
176076
+ case 141: /* nulls ::= NULLS FIRST */
176077
+{yymsp[-1].minor.yy144 = SQLITE_SO_ASC;}
176078
+ break;
176079
+ case 142: /* nulls ::= NULLS LAST */
176080
+{yymsp[-1].minor.yy144 = SQLITE_SO_DESC;}
176081
+ break;
176082
+ case 146: /* having_opt ::= */
176083
+ case 148: /* limit_opt ::= */ yytestcase(yyruleno==148);
176084
+ case 153: /* where_opt ::= */ yytestcase(yyruleno==153);
176085
+ case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155);
176086
+ case 232: /* case_else ::= */ yytestcase(yyruleno==232);
176087
+ case 233: /* case_operand ::= */ yytestcase(yyruleno==233);
176088
+ case 252: /* vinto ::= */ yytestcase(yyruleno==252);
176089
+{yymsp[1].minor.yy454 = 0;}
176090
+ break;
176091
+ case 147: /* having_opt ::= HAVING expr */
176092
+ case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154);
176093
+ case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156);
176094
+ case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
176095
+ case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251);
176096
+{yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;}
176097
+ break;
176098
+ case 149: /* limit_opt ::= LIMIT expr */
176099
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
176100
+ break;
176101
+ case 150: /* limit_opt ::= LIMIT expr OFFSET expr */
176102
+{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176103
+ break;
176104
+ case 151: /* limit_opt ::= LIMIT expr COMMA expr */
176105
+{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
176106
+ break;
176107
+ case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
176108
+{
176109
+ sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
176110
+ sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
176111
+}
176112
+ break;
176113
+ case 157: /* where_opt_ret ::= RETURNING selcollist */
176114
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
176115
+ break;
176116
+ case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
176117
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
176118
+ break;
176119
+ case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
176120
+{
176121
+ sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
176122
+ sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list");
176123
+ if( yymsp[-1].minor.yy203 ){
176124
+ SrcList *pFromClause = yymsp[-1].minor.yy203;
175829176125
 if( pFromClause->nSrc>1 ){
175830176126
 Select *pSubquery;
175831176127
 Token as;
175832176128
 pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0);
175833176129
 as.n = 0;
175834176130
 as.z = 0;
175835176131
 pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
175836176132
 }
175837
- yymsp[-5].minor.yy387 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy387, pFromClause);
175838
- }
175839
- sqlite3Update(pParse,yymsp[-5].minor.yy387,yymsp[-2].minor.yy402,yymsp[0].minor.yy2,yymsp[-6].minor.yy92,0,0,0);
175840
-}
175841
- break;
175842
- case 158: /* setlist ::= setlist COMMA nm EQ expr */
175843
-{
175844
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[0].minor.yy2);
175845
- sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, 1);
175846
-}
175847
- break;
175848
- case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
175849
-{
175850
- yymsp[-6].minor.yy402 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy402, yymsp[-3].minor.yy400, yymsp[0].minor.yy2);
175851
-}
175852
- break;
175853
- case 160: /* setlist ::= nm EQ expr */
175854
-{
175855
- yylhsminor.yy402 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy2);
175856
- sqlite3ExprListSetName(pParse, yylhsminor.yy402, &yymsp[-2].minor.yy0, 1);
175857
-}
175858
- yymsp[-2].minor.yy402 = yylhsminor.yy402;
175859
- break;
175860
- case 161: /* setlist ::= LP idlist RP EQ expr */
175861
-{
175862
- yymsp[-4].minor.yy402 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy400, yymsp[0].minor.yy2);
175863
-}
175864
- break;
175865
- case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
175866
-{
175867
- sqlite3Insert(pParse, yymsp[-3].minor.yy387, yymsp[-1].minor.yy299, yymsp[-2].minor.yy400, yymsp[-5].minor.yy92, yymsp[0].minor.yy258);
175868
-}
175869
- break;
175870
- case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
175871
-{
175872
- sqlite3Insert(pParse, yymsp[-4].minor.yy387, 0, yymsp[-3].minor.yy400, yymsp[-6].minor.yy92, 0);
175873
-}
175874
- break;
175875
- case 164: /* upsert ::= */
175876
-{ yymsp[1].minor.yy258 = 0; }
175877
- break;
175878
- case 165: /* upsert ::= RETURNING selcollist */
175879
-{ yymsp[-1].minor.yy258 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy402); }
175880
- break;
175881
- case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
175882
-{ yymsp[-11].minor.yy258 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy402,yymsp[-6].minor.yy2,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2,yymsp[0].minor.yy258);}
175883
- break;
175884
- case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
175885
-{ yymsp[-8].minor.yy258 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy402,yymsp[-3].minor.yy2,0,0,yymsp[0].minor.yy258); }
175886
- break;
175887
- case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */
175888
-{ yymsp[-4].minor.yy258 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
175889
- break;
175890
- case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
175891
-{ yymsp[-7].minor.yy258 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2,0);}
175892
- break;
175893
- case 170: /* returning ::= RETURNING selcollist */
175894
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy402);}
175895
- break;
175896
- case 173: /* idlist_opt ::= */
175897
-{yymsp[1].minor.yy400 = 0;}
175898
- break;
175899
- case 174: /* idlist_opt ::= LP idlist RP */
175900
-{yymsp[-2].minor.yy400 = yymsp[-1].minor.yy400;}
175901
- break;
175902
- case 175: /* idlist ::= idlist COMMA nm */
175903
-{yymsp[-2].minor.yy400 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy400,&yymsp[0].minor.yy0);}
175904
- break;
175905
- case 176: /* idlist ::= nm */
175906
-{yymsp[0].minor.yy400 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
175907
- break;
175908
- case 177: /* expr ::= LP expr RP */
175909
-{yymsp[-2].minor.yy2 = yymsp[-1].minor.yy2;}
175910
- break;
175911
- case 178: /* expr ::= ID|INDEXED|JOIN_KW */
175912
-{yymsp[0].minor.yy2=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
175913
- break;
175914
- case 179: /* expr ::= nm DOT nm */
176133
+ yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
176134
+ }
176135
+ sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
176136
+}
176137
+ break;
176138
+ case 160: /* setlist ::= setlist COMMA nm EQ expr */
176139
+{
176140
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
176141
+ sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
176142
+}
176143
+ break;
176144
+ case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
176145
+{
176146
+ yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176147
+}
176148
+ break;
176149
+ case 162: /* setlist ::= nm EQ expr */
176150
+{
176151
+ yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
176152
+ sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
176153
+}
176154
+ yymsp[-2].minor.yy14 = yylhsminor.yy14;
176155
+ break;
176156
+ case 163: /* setlist ::= LP idlist RP EQ expr */
176157
+{
176158
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176159
+}
176160
+ break;
176161
+ case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
176162
+{
176163
+ sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
176164
+}
176165
+ break;
176166
+ case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
176167
+{
176168
+ sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
176169
+}
176170
+ break;
176171
+ case 166: /* upsert ::= */
176172
+{ yymsp[1].minor.yy122 = 0; }
176173
+ break;
176174
+ case 167: /* upsert ::= RETURNING selcollist */
176175
+{ yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
176176
+ break;
176177
+ case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
176178
+{ yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
176179
+ break;
176180
+ case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
176181
+{ yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
176182
+ break;
176183
+ case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */
176184
+{ yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
176185
+ break;
176186
+ case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
176187
+{ yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
176188
+ break;
176189
+ case 172: /* returning ::= RETURNING selcollist */
176190
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
176191
+ break;
176192
+ case 175: /* idlist_opt ::= */
176193
+{yymsp[1].minor.yy132 = 0;}
176194
+ break;
176195
+ case 176: /* idlist_opt ::= LP idlist RP */
176196
+{yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;}
176197
+ break;
176198
+ case 177: /* idlist ::= idlist COMMA nm */
176199
+{yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
176200
+ break;
176201
+ case 178: /* idlist ::= nm */
176202
+{yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
176203
+ break;
176204
+ case 179: /* expr ::= LP expr RP */
176205
+{yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;}
176206
+ break;
176207
+ case 180: /* expr ::= ID|INDEXED|JOIN_KW */
176208
+{yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176209
+ break;
176210
+ case 181: /* expr ::= nm DOT nm */
175915176211
 {
175916176212
 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
175917176213
 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
175918
- yylhsminor.yy2 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
176214
+ yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
175919176215
 }
175920
- yymsp[-2].minor.yy2 = yylhsminor.yy2;
176216
+ yymsp[-2].minor.yy454 = yylhsminor.yy454;
175921176217
 break;
175922
- case 180: /* expr ::= nm DOT nm DOT nm */
176218
+ case 182: /* expr ::= nm DOT nm DOT nm */
175923176219
 {
175924176220
 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
175925176221
 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
175926176222
 Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
175927176223
 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
175928176224
 if( IN_RENAME_OBJECT ){
175929176225
 sqlite3RenameTokenRemap(pParse, 0, temp1);
175930176226
 }
175931
- yylhsminor.yy2 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
175932
-}
175933
- yymsp[-4].minor.yy2 = yylhsminor.yy2;
175934
- break;
175935
- case 181: /* term ::= NULL|FLOAT|BLOB */
175936
- case 182: /* term ::= STRING */ yytestcase(yyruleno==182);
175937
-{yymsp[0].minor.yy2=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
175938
- break;
175939
- case 183: /* term ::= INTEGER */
175940
-{
175941
- yylhsminor.yy2 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
175942
- if( yylhsminor.yy2 ) yylhsminor.yy2->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
175943
-}
175944
- yymsp[0].minor.yy2 = yylhsminor.yy2;
175945
- break;
175946
- case 184: /* expr ::= VARIABLE */
176227
+ yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
176228
+}
176229
+ yymsp[-4].minor.yy454 = yylhsminor.yy454;
176230
+ break;
176231
+ case 183: /* term ::= NULL|FLOAT|BLOB */
176232
+ case 184: /* term ::= STRING */ yytestcase(yyruleno==184);
176233
+{yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176234
+ break;
176235
+ case 185: /* term ::= INTEGER */
176236
+{
176237
+ yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
176238
+ if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
176239
+}
176240
+ yymsp[0].minor.yy454 = yylhsminor.yy454;
176241
+ break;
176242
+ case 186: /* expr ::= VARIABLE */
175947176243
 {
175948176244
 if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
175949176245
 u32 n = yymsp[0].minor.yy0.n;
175950
- yymsp[0].minor.yy2 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
175951
- sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy2, n);
176246
+ yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
176247
+ sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n);
175952176248
 }else{
175953176249
 /* When doing a nested parse, one can include terms in an expression
175954176250
 ** that look like this: #1 #2 ... These terms refer to registers
175955176251
 ** in the virtual machine. #N is the N-th register. */
175956176252
 Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
175957176253
 assert( t.n>=2 );
175958176254
 if( pParse->nested==0 ){
175959176255
 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
175960
- yymsp[0].minor.yy2 = 0;
175961
- }else{
175962
- yymsp[0].minor.yy2 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
175963
- if( yymsp[0].minor.yy2 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy2->iTable);
175964
- }
175965
- }
175966
-}
175967
- break;
175968
- case 185: /* expr ::= expr COLLATE ID|STRING */
175969
-{
175970
- yymsp[-2].minor.yy2 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy2, &yymsp[0].minor.yy0, 1);
175971
-}
175972
- break;
175973
- case 186: /* expr ::= CAST LP expr AS typetoken RP */
175974
-{
175975
- yymsp[-5].minor.yy2 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
175976
- sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy2, yymsp[-3].minor.yy2, 0);
175977
-}
175978
- break;
175979
- case 187: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
175980
-{
175981
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy92);
175982
-}
175983
- yymsp[-4].minor.yy2 = yylhsminor.yy2;
175984
- break;
175985
- case 188: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
175986
-{
175987
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy402, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy92);
175988
- sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy2, yymsp[-1].minor.yy402);
175989
-}
175990
- yymsp[-7].minor.yy2 = yylhsminor.yy2;
175991
- break;
175992
- case 189: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
175993
-{
175994
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
175995
-}
175996
- yymsp[-3].minor.yy2 = yylhsminor.yy2;
175997
- break;
175998
- case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
175999
-{
176000
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy402, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy92);
176001
- sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176002
-}
176003
- yymsp[-5].minor.yy2 = yylhsminor.yy2;
176004
- break;
176005
- case 191: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
176006
-{
176007
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy402, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy92);
176008
- sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176009
- sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy2, yymsp[-2].minor.yy402);
176010
-}
176011
- yymsp[-8].minor.yy2 = yylhsminor.yy2;
176012
- break;
176013
- case 192: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
176014
-{
176015
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
176016
- sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176017
-}
176018
- yymsp[-4].minor.yy2 = yylhsminor.yy2;
176019
- break;
176020
- case 193: /* term ::= CTIME_KW */
176021
-{
176022
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
176023
-}
176024
- yymsp[0].minor.yy2 = yylhsminor.yy2;
176025
- break;
176026
- case 194: /* expr ::= LP nexprlist COMMA expr RP */
176027
-{
176028
- ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy402, yymsp[-1].minor.yy2);
176029
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
176030
- if( yymsp[-4].minor.yy2 ){
176031
- yymsp[-4].minor.yy2->x.pList = pList;
176256
+ yymsp[0].minor.yy454 = 0;
176257
+ }else{
176258
+ yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
176259
+ if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable);
176260
+ }
176261
+ }
176262
+}
176263
+ break;
176264
+ case 187: /* expr ::= expr COLLATE ID|STRING */
176265
+{
176266
+ yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
176267
+}
176268
+ break;
176269
+ case 188: /* expr ::= CAST LP expr AS typetoken RP */
176270
+{
176271
+ yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
176272
+ sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
176273
+}
176274
+ break;
176275
+ case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
176276
+{
176277
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
176278
+}
176279
+ yymsp[-4].minor.yy454 = yylhsminor.yy454;
176280
+ break;
176281
+ case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
176282
+{
176283
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
176284
+ sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
176285
+}
176286
+ yymsp[-7].minor.yy454 = yylhsminor.yy454;
176287
+ break;
176288
+ case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
176289
+{
176290
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
176291
+}
176292
+ yymsp[-3].minor.yy454 = yylhsminor.yy454;
176293
+ break;
176294
+ case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
176295
+{
176296
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
176297
+ sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176298
+}
176299
+ yymsp[-5].minor.yy454 = yylhsminor.yy454;
176300
+ break;
176301
+ case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
176302
+{
176303
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
176304
+ sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176305
+ sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
176306
+}
176307
+ yymsp[-8].minor.yy454 = yylhsminor.yy454;
176308
+ break;
176309
+ case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
176310
+{
176311
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
176312
+ sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176313
+}
176314
+ yymsp[-4].minor.yy454 = yylhsminor.yy454;
176315
+ break;
176316
+ case 195: /* term ::= CTIME_KW */
176317
+{
176318
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
176319
+}
176320
+ yymsp[0].minor.yy454 = yylhsminor.yy454;
176321
+ break;
176322
+ case 196: /* expr ::= LP nexprlist COMMA expr RP */
176323
+{
176324
+ ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
176325
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
176326
+ if( yymsp[-4].minor.yy454 ){
176327
+ yymsp[-4].minor.yy454->x.pList = pList;
176032176328
 if( ALWAYS(pList->nExpr) ){
176033
- yymsp[-4].minor.yy2->flags |= pList->a[0].pExpr->flags & EP_Propagate;
176329
+ yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
176034176330
 }
176035176331
 }else{
176036176332
 sqlite3ExprListDelete(pParse->db, pList);
176037176333
 }
176038176334
 }
176039176335
 break;
176040
- case 195: /* expr ::= expr AND expr */
176041
-{yymsp[-2].minor.yy2=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
176042
- break;
176043
- case 196: /* expr ::= expr OR expr */
176044
- case 197: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==197);
176045
- case 198: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==198);
176046
- case 199: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==199);
176047
- case 200: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==200);
176048
- case 201: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==201);
176049
- case 202: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==202);
176050
-{yymsp[-2].minor.yy2=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
176051
- break;
176052
- case 203: /* likeop ::= NOT LIKE_KW|MATCH */
176336
+ case 197: /* expr ::= expr AND expr */
176337
+{yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176338
+ break;
176339
+ case 198: /* expr ::= expr OR expr */
176340
+ case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199);
176341
+ case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200);
176342
+ case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201);
176343
+ case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202);
176344
+ case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203);
176345
+ case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204);
176346
+{yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176347
+ break;
176348
+ case 205: /* likeop ::= NOT LIKE_KW|MATCH */
176053176349
 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
176054176350
 break;
176055
- case 204: /* expr ::= expr likeop expr */
176351
+ case 206: /* expr ::= expr likeop expr */
176056176352
 {
176057176353
 ExprList *pList;
176058176354
 int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
176059176355
 yymsp[-1].minor.yy0.n &= 0x7fffffff;
176060
- pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy2);
176061
- pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy2);
176062
- yymsp[-2].minor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176063
- if( bNot ) yymsp[-2].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy2, 0);
176064
- if( yymsp[-2].minor.yy2 ) yymsp[-2].minor.yy2->flags |= EP_InfixFunc;
176356
+ pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
176357
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
176358
+ yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176359
+ if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
176360
+ if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc;
176065176361
 }
176066176362
 break;
176067
- case 205: /* expr ::= expr likeop expr ESCAPE expr */
176363
+ case 207: /* expr ::= expr likeop expr ESCAPE expr */
176068176364
 {
176069176365
 ExprList *pList;
176070176366
 int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
176071176367
 yymsp[-3].minor.yy0.n &= 0x7fffffff;
176072
- pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176073
- pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy2);
176074
- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy2);
176075
- yymsp[-4].minor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
176076
- if( bNot ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176077
- if( yymsp[-4].minor.yy2 ) yymsp[-4].minor.yy2->flags |= EP_InfixFunc;
176078
-}
176079
- break;
176080
- case 206: /* expr ::= expr ISNULL|NOTNULL */
176081
-{yymsp[-1].minor.yy2 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy2,0);}
176082
- break;
176083
- case 207: /* expr ::= expr NOT NULL */
176084
-{yymsp[-2].minor.yy2 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy2,0);}
176085
- break;
176086
- case 208: /* expr ::= expr IS expr */
176087
-{
176088
- yymsp[-2].minor.yy2 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);
176089
- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-2].minor.yy2, TK_ISNULL);
176090
-}
176091
- break;
176092
- case 209: /* expr ::= expr IS NOT expr */
176093
-{
176094
- yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy2,yymsp[0].minor.yy2);
176095
- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-3].minor.yy2, TK_NOTNULL);
176096
-}
176097
- break;
176098
- case 210: /* expr ::= expr IS NOT DISTINCT FROM expr */
176099
-{
176100
- yymsp[-5].minor.yy2 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy2,yymsp[0].minor.yy2);
176101
- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-5].minor.yy2, TK_ISNULL);
176102
-}
176103
- break;
176104
- case 211: /* expr ::= expr IS DISTINCT FROM expr */
176105
-{
176106
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy2,yymsp[0].minor.yy2);
176107
- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-4].minor.yy2, TK_NOTNULL);
176108
-}
176109
- break;
176110
- case 212: /* expr ::= NOT expr */
176111
- case 213: /* expr ::= BITNOT expr */ yytestcase(yyruleno==213);
176112
-{yymsp[-1].minor.yy2 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy2, 0);/*A-overwrites-B*/}
176113
- break;
176114
- case 214: /* expr ::= PLUS|MINUS expr */
176115
-{
176116
- yymsp[-1].minor.yy2 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy2, 0);
176368
+ pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176369
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
176370
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176371
+ yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
176372
+ if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176373
+ if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc;
176374
+}
176375
+ break;
176376
+ case 208: /* expr ::= expr ISNULL|NOTNULL */
176377
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy454,0);}
176378
+ break;
176379
+ case 209: /* expr ::= expr NOT NULL */
176380
+{yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy454,0);}
176381
+ break;
176382
+ case 210: /* expr ::= expr IS expr */
176383
+{
176384
+ yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);
176385
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-2].minor.yy454, TK_ISNULL);
176386
+}
176387
+ break;
176388
+ case 211: /* expr ::= expr IS NOT expr */
176389
+{
176390
+ yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy454,yymsp[0].minor.yy454);
176391
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-3].minor.yy454, TK_NOTNULL);
176392
+}
176393
+ break;
176394
+ case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */
176395
+{
176396
+ yymsp[-5].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy454,yymsp[0].minor.yy454);
176397
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-5].minor.yy454, TK_ISNULL);
176398
+}
176399
+ break;
176400
+ case 213: /* expr ::= expr IS DISTINCT FROM expr */
176401
+{
176402
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy454,yymsp[0].minor.yy454);
176403
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-4].minor.yy454, TK_NOTNULL);
176404
+}
176405
+ break;
176406
+ case 214: /* expr ::= NOT expr */
176407
+ case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
176408
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
176409
+ break;
176410
+ case 216: /* expr ::= PLUS|MINUS expr */
176411
+{
176412
+ yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy454, 0);
176117176413
 /*A-overwrites-B*/
176118176414
 }
176119176415
 break;
176120
- case 215: /* expr ::= expr PTR expr */
176121
-{
176122
- ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy2);
176123
- pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy2);
176124
- yylhsminor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176125
-}
176126
- yymsp[-2].minor.yy2 = yylhsminor.yy2;
176127
- break;
176128
- case 216: /* between_op ::= BETWEEN */
176129
- case 219: /* in_op ::= IN */ yytestcase(yyruleno==219);
176130
-{yymsp[0].minor.yy92 = 0;}
176131
- break;
176132
- case 218: /* expr ::= expr between_op expr AND expr */
176133
-{
176134
- ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176135
- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy2);
176136
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy2, 0);
176137
- if( yymsp[-4].minor.yy2 ){
176138
- yymsp[-4].minor.yy2->x.pList = pList;
176416
+ case 217: /* expr ::= expr PTR expr */
176417
+{
176418
+ ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
176419
+ pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
176420
+ yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176421
+}
176422
+ yymsp[-2].minor.yy454 = yylhsminor.yy454;
176423
+ break;
176424
+ case 218: /* between_op ::= BETWEEN */
176425
+ case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
176426
+{yymsp[0].minor.yy144 = 0;}
176427
+ break;
176428
+ case 220: /* expr ::= expr between_op expr AND expr */
176429
+{
176430
+ ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176431
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176432
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
176433
+ if( yymsp[-4].minor.yy454 ){
176434
+ yymsp[-4].minor.yy454->x.pList = pList;
176139176435
 }else{
176140176436
 sqlite3ExprListDelete(pParse->db, pList);
176141176437
 }
176142
- if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176438
+ if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176143176439
 }
176144176440
 break;
176145
- case 221: /* expr ::= expr in_op LP exprlist RP */
176441
+ case 223: /* expr ::= expr in_op LP exprlist RP */
176146176442
 {
176147
- if( yymsp[-1].minor.yy402==0 ){
176443
+ if( yymsp[-1].minor.yy14==0 ){
176148176444
 /* Expressions of the form
176149176445
 **
176150176446
 ** expr1 IN ()
176151176447
 ** expr1 NOT IN ()
176152176448
 **
176153176449
 ** simplify to constants 0 (false) and 1 (true), respectively,
176154176450
 ** regardless of the value of expr1.
176155176451
 */
176156
- sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy2);
176157
- yymsp[-4].minor.yy2 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy92 ? "true" : "false");
176158
- if( yymsp[-4].minor.yy2 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy2);
176452
+ sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
176453
+ yymsp[-4].minor.yy454 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
176454
+ if( yymsp[-4].minor.yy454 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy454);
176159176455
 }else{
176160
- Expr *pRHS = yymsp[-1].minor.yy402->a[0].pExpr;
176161
- if( yymsp[-1].minor.yy402->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy2->op!=TK_VECTOR ){
176162
- yymsp[-1].minor.yy402->a[0].pExpr = 0;
176163
- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176456
+ Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
176457
+ if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){
176458
+ yymsp[-1].minor.yy14->a[0].pExpr = 0;
176459
+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176164176460
 pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
176165
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy2, pRHS);
176166
- }else if( yymsp[-1].minor.yy402->nExpr==1 && pRHS->op==TK_SELECT ){
176167
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176168
- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pRHS->x.pSelect);
176461
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
176462
+ }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){
176463
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176464
+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
176169176465
 pRHS->x.pSelect = 0;
176170
- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176466
+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176171176467
 }else{
176172
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176173
- if( yymsp[-4].minor.yy2==0 ){
176174
- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176175
- }else if( yymsp[-4].minor.yy2->pLeft->op==TK_VECTOR ){
176176
- int nExpr = yymsp[-4].minor.yy2->pLeft->x.pList->nExpr;
176177
- Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy402);
176468
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176469
+ if( yymsp[-4].minor.yy454==0 ){
176470
+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176471
+ }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){
176472
+ int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
176473
+ Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
176178176474
 if( pSelectRHS ){
176179176475
 parserDoubleLinkSelect(pParse, pSelectRHS);
176180
- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pSelectRHS);
176181
- }
176182
- }else{
176183
- yymsp[-4].minor.yy2->x.pList = yymsp[-1].minor.yy402;
176184
- sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy2);
176185
- }
176186
- }
176187
- if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176188
- }
176189
- }
176190
- break;
176191
- case 222: /* expr ::= LP select RP */
176192
-{
176193
- yymsp[-2].minor.yy2 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
176194
- sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy2, yymsp[-1].minor.yy299);
176195
- }
176196
- break;
176197
- case 223: /* expr ::= expr in_op LP select RP */
176198
-{
176199
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176200
- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, yymsp[-1].minor.yy299);
176201
- if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176202
- }
176203
- break;
176204
- case 224: /* expr ::= expr in_op nm dbnm paren_exprlist */
176476
+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
176477
+ }
176478
+ }else{
176479
+ yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
176480
+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
176481
+ }
176482
+ }
176483
+ if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176484
+ }
176485
+ }
176486
+ break;
176487
+ case 224: /* expr ::= LP select RP */
176488
+{
176489
+ yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
176490
+ sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
176491
+ }
176492
+ break;
176493
+ case 225: /* expr ::= expr in_op LP select RP */
176494
+{
176495
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176496
+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
176497
+ if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176498
+ }
176499
+ break;
176500
+ case 226: /* expr ::= expr in_op nm dbnm paren_exprlist */
176205176501
 {
176206176502
 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
176207176503
 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
176208
- if( yymsp[0].minor.yy402 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy402);
176209
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176210
- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pSelect);
176211
- if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176504
+ if( yymsp[0].minor.yy14 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
176505
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176506
+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
176507
+ if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176212176508
 }
176213176509
 break;
176214
- case 225: /* expr ::= EXISTS LP select RP */
176510
+ case 227: /* expr ::= EXISTS LP select RP */
176215176511
 {
176216176512
 Expr *p;
176217
- p = yymsp[-3].minor.yy2 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
176218
- sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy299);
176219
- }
176220
- break;
176221
- case 226: /* expr ::= CASE case_operand case_exprlist case_else END */
176222
-{
176223
- yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy2, 0);
176224
- if( yymsp[-4].minor.yy2 ){
176225
- yymsp[-4].minor.yy2->x.pList = yymsp[-1].minor.yy2 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2) : yymsp[-2].minor.yy402;
176226
- sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy2);
176227
- }else{
176228
- sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy402);
176229
- sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy2);
176230
- }
176231
-}
176232
- break;
176233
- case 227: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
176234
-{
176235
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[-2].minor.yy2);
176236
- yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[0].minor.yy2);
176237
-}
176238
- break;
176239
- case 228: /* case_exprlist ::= WHEN expr THEN expr */
176240
-{
176241
- yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176242
- yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy402, yymsp[0].minor.yy2);
176243
-}
176244
- break;
176245
- case 233: /* nexprlist ::= nexprlist COMMA expr */
176246
-{yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[0].minor.yy2);}
176247
- break;
176248
- case 234: /* nexprlist ::= expr */
176249
-{yymsp[0].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy2); /*A-overwrites-Y*/}
176250
- break;
176251
- case 236: /* paren_exprlist ::= LP exprlist RP */
176252
- case 241: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==241);
176253
-{yymsp[-2].minor.yy402 = yymsp[-1].minor.yy402;}
176254
- break;
176255
- case 237: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
176513
+ p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
176514
+ sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
176515
+ }
176516
+ break;
176517
+ case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
176518
+{
176519
+ yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
176520
+ if( yymsp[-4].minor.yy454 ){
176521
+ yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
176522
+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
176523
+ }else{
176524
+ sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
176525
+ sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
176526
+ }
176527
+}
176528
+ break;
176529
+ case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
176530
+{
176531
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
176532
+ yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
176533
+}
176534
+ break;
176535
+ case 230: /* case_exprlist ::= WHEN expr THEN expr */
176536
+{
176537
+ yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176538
+ yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
176539
+}
176540
+ break;
176541
+ case 235: /* nexprlist ::= nexprlist COMMA expr */
176542
+{yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
176543
+ break;
176544
+ case 236: /* nexprlist ::= expr */
176545
+{yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
176546
+ break;
176547
+ case 238: /* paren_exprlist ::= LP exprlist RP */
176548
+ case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243);
176549
+{yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;}
176550
+ break;
176551
+ case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
176256176552
 {
176257176553
 sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
176258
- sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy402, yymsp[-10].minor.yy92,
176259
- &yymsp[-11].minor.yy0, yymsp[0].minor.yy2, SQLITE_SO_ASC, yymsp[-8].minor.yy92, SQLITE_IDXTYPE_APPDEF);
176554
+ sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144,
176555
+ &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF);
176260176556
 if( IN_RENAME_OBJECT && pParse->pNewIndex ){
176261176557
 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
176262176558
 }
176263176559
 }
176264176560
 break;
176265
- case 238: /* uniqueflag ::= UNIQUE */
176266
- case 280: /* raisetype ::= ABORT */ yytestcase(yyruleno==280);
176267
-{yymsp[0].minor.yy92 = OE_Abort;}
176268
- break;
176269
- case 239: /* uniqueflag ::= */
176270
-{yymsp[1].minor.yy92 = OE_None;}
176271
- break;
176272
- case 242: /* eidlist ::= eidlist COMMA nm collate sortorder */
176273
-{
176274
- yymsp[-4].minor.yy402 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy92, yymsp[0].minor.yy92);
176275
-}
176276
- break;
176277
- case 243: /* eidlist ::= nm collate sortorder */
176278
-{
176279
- yymsp[-2].minor.yy402 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); /*A-overwrites-Y*/
176280
-}
176281
- break;
176282
- case 246: /* cmd ::= DROP INDEX ifexists fullname */
176283
-{sqlite3DropIndex(pParse, yymsp[0].minor.yy387, yymsp[-1].minor.yy92);}
176284
- break;
176285
- case 247: /* cmd ::= VACUUM vinto */
176286
-{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy2);}
176287
- break;
176288
- case 248: /* cmd ::= VACUUM nm vinto */
176289
-{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy2);}
176290
- break;
176291
- case 251: /* cmd ::= PRAGMA nm dbnm */
176561
+ case 240: /* uniqueflag ::= UNIQUE */
176562
+ case 282: /* raisetype ::= ABORT */ yytestcase(yyruleno==282);
176563
+{yymsp[0].minor.yy144 = OE_Abort;}
176564
+ break;
176565
+ case 241: /* uniqueflag ::= */
176566
+{yymsp[1].minor.yy144 = OE_None;}
176567
+ break;
176568
+ case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */
176569
+{
176570
+ yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
176571
+}
176572
+ break;
176573
+ case 245: /* eidlist ::= nm collate sortorder */
176574
+{
176575
+ yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
176576
+}
176577
+ break;
176578
+ case 248: /* cmd ::= DROP INDEX ifexists fullname */
176579
+{sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
176580
+ break;
176581
+ case 249: /* cmd ::= VACUUM vinto */
176582
+{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
176583
+ break;
176584
+ case 250: /* cmd ::= VACUUM nm vinto */
176585
+{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
176586
+ break;
176587
+ case 253: /* cmd ::= PRAGMA nm dbnm */
176292176588
 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
176293176589
 break;
176294
- case 252: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
176590
+ case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
176295176591
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
176296176592
 break;
176297
- case 253: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
176593
+ case 255: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
176298176594
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
176299176595
 break;
176300
- case 254: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
176596
+ case 256: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
176301176597
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
176302176598
 break;
176303
- case 255: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
176599
+ case 257: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
176304176600
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
176305176601
 break;
176306
- case 258: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
176602
+ case 260: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
176307176603
 {
176308176604
 Token all;
176309176605
 all.z = yymsp[-3].minor.yy0.z;
176310176606
 all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
176311
- sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy347, &all);
176607
+ sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
176312176608
 }
176313176609
 break;
176314
- case 259: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
176610
+ case 261: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
176315176611
 {
176316
- sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy92, yymsp[-4].minor.yy210.a, yymsp[-4].minor.yy210.b, yymsp[-2].minor.yy387, yymsp[0].minor.yy2, yymsp[-10].minor.yy92, yymsp[-8].minor.yy92);
176612
+ sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
176317176613
 yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
176318176614
 }
176319176615
 break;
176320
- case 260: /* trigger_time ::= BEFORE|AFTER */
176321
-{ yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-X*/ }
176322
- break;
176323
- case 261: /* trigger_time ::= INSTEAD OF */
176324
-{ yymsp[-1].minor.yy92 = TK_INSTEAD;}
176325
- break;
176326
- case 262: /* trigger_time ::= */
176327
-{ yymsp[1].minor.yy92 = TK_BEFORE; }
176328
- break;
176329
- case 263: /* trigger_event ::= DELETE|INSERT */
176330
- case 264: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==264);
176331
-{yymsp[0].minor.yy210.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy210.b = 0;}
176332
- break;
176333
- case 265: /* trigger_event ::= UPDATE OF idlist */
176334
-{yymsp[-2].minor.yy210.a = TK_UPDATE; yymsp[-2].minor.yy210.b = yymsp[0].minor.yy400;}
176335
- break;
176336
- case 266: /* when_clause ::= */
176337
- case 285: /* key_opt ::= */ yytestcase(yyruleno==285);
176338
-{ yymsp[1].minor.yy2 = 0; }
176339
- break;
176340
- case 267: /* when_clause ::= WHEN expr */
176341
- case 286: /* key_opt ::= KEY expr */ yytestcase(yyruleno==286);
176342
-{ yymsp[-1].minor.yy2 = yymsp[0].minor.yy2; }
176343
- break;
176344
- case 268: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
176345
-{
176346
- assert( yymsp[-2].minor.yy347!=0 );
176347
- yymsp[-2].minor.yy347->pLast->pNext = yymsp[-1].minor.yy347;
176348
- yymsp[-2].minor.yy347->pLast = yymsp[-1].minor.yy347;
176349
-}
176350
- break;
176351
- case 269: /* trigger_cmd_list ::= trigger_cmd SEMI */
176352
-{
176353
- assert( yymsp[-1].minor.yy347!=0 );
176354
- yymsp[-1].minor.yy347->pLast = yymsp[-1].minor.yy347;
176355
-}
176356
- break;
176357
- case 270: /* trnm ::= nm DOT nm */
176616
+ case 262: /* trigger_time ::= BEFORE|AFTER */
176617
+{ yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ }
176618
+ break;
176619
+ case 263: /* trigger_time ::= INSTEAD OF */
176620
+{ yymsp[-1].minor.yy144 = TK_INSTEAD;}
176621
+ break;
176622
+ case 264: /* trigger_time ::= */
176623
+{ yymsp[1].minor.yy144 = TK_BEFORE; }
176624
+ break;
176625
+ case 265: /* trigger_event ::= DELETE|INSERT */
176626
+ case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266);
176627
+{yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;}
176628
+ break;
176629
+ case 267: /* trigger_event ::= UPDATE OF idlist */
176630
+{yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;}
176631
+ break;
176632
+ case 268: /* when_clause ::= */
176633
+ case 287: /* key_opt ::= */ yytestcase(yyruleno==287);
176634
+{ yymsp[1].minor.yy454 = 0; }
176635
+ break;
176636
+ case 269: /* when_clause ::= WHEN expr */
176637
+ case 288: /* key_opt ::= KEY expr */ yytestcase(yyruleno==288);
176638
+{ yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; }
176639
+ break;
176640
+ case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
176641
+{
176642
+ assert( yymsp[-2].minor.yy427!=0 );
176643
+ yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
176644
+ yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
176645
+}
176646
+ break;
176647
+ case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */
176648
+{
176649
+ assert( yymsp[-1].minor.yy427!=0 );
176650
+ yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
176651
+}
176652
+ break;
176653
+ case 272: /* trnm ::= nm DOT nm */
176358176654
 {
176359176655
 yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
176360176656
 sqlite3ErrorMsg(pParse,
176361176657
 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
176362176658
 "statements within triggers");
176363176659
 }
176364176660
 break;
176365
- case 271: /* tridxby ::= INDEXED BY nm */
176661
+ case 273: /* tridxby ::= INDEXED BY nm */
176366176662
 {
176367176663
 sqlite3ErrorMsg(pParse,
176368176664
 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
176369176665
 "within triggers");
176370176666
 }
176371176667
 break;
176372
- case 272: /* tridxby ::= NOT INDEXED */
176668
+ case 274: /* tridxby ::= NOT INDEXED */
176373176669
 {
176374176670
 sqlite3ErrorMsg(pParse,
176375176671
 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
176376176672
 "within triggers");
176377176673
 }
176378176674
 break;
176379
- case 273: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
176380
-{yylhsminor.yy347 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy387, yymsp[-3].minor.yy402, yymsp[-1].minor.yy2, yymsp[-7].minor.yy92, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy616);}
176381
- yymsp[-8].minor.yy347 = yylhsminor.yy347;
176382
- break;
176383
- case 274: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
176384
-{
176385
- yylhsminor.yy347 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy400,yymsp[-2].minor.yy299,yymsp[-6].minor.yy92,yymsp[-1].minor.yy258,yymsp[-7].minor.yy616,yymsp[0].minor.yy616);/*yylhsminor.yy347-overwrites-yymsp[-6].minor.yy92*/
176386
-}
176387
- yymsp[-7].minor.yy347 = yylhsminor.yy347;
176388
- break;
176389
- case 275: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
176390
-{yylhsminor.yy347 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy2, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy616);}
176391
- yymsp[-5].minor.yy347 = yylhsminor.yy347;
176392
- break;
176393
- case 276: /* trigger_cmd ::= scanpt select scanpt */
176394
-{yylhsminor.yy347 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy299, yymsp[-2].minor.yy616, yymsp[0].minor.yy616); /*yylhsminor.yy347-overwrites-yymsp[-1].minor.yy299*/}
176395
- yymsp[-2].minor.yy347 = yylhsminor.yy347;
176396
- break;
176397
- case 277: /* expr ::= RAISE LP IGNORE RP */
176398
-{
176399
- yymsp[-3].minor.yy2 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
176400
- if( yymsp[-3].minor.yy2 ){
176401
- yymsp[-3].minor.yy2->affExpr = OE_Ignore;
176402
- }
176403
-}
176404
- break;
176405
- case 278: /* expr ::= RAISE LP raisetype COMMA nm RP */
176406
-{
176407
- yymsp[-5].minor.yy2 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
176408
- if( yymsp[-5].minor.yy2 ) {
176409
- yymsp[-5].minor.yy2->affExpr = (char)yymsp[-3].minor.yy92;
176410
- }
176411
-}
176412
- break;
176413
- case 279: /* raisetype ::= ROLLBACK */
176414
-{yymsp[0].minor.yy92 = OE_Rollback;}
176415
- break;
176416
- case 281: /* raisetype ::= FAIL */
176417
-{yymsp[0].minor.yy92 = OE_Fail;}
176418
- break;
176419
- case 282: /* cmd ::= DROP TRIGGER ifexists fullname */
176420
-{
176421
- sqlite3DropTrigger(pParse,yymsp[0].minor.yy387,yymsp[-1].minor.yy92);
176422
-}
176423
- break;
176424
- case 283: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
176425
-{
176426
- sqlite3Attach(pParse, yymsp[-3].minor.yy2, yymsp[-1].minor.yy2, yymsp[0].minor.yy2);
176427
-}
176428
- break;
176429
- case 284: /* cmd ::= DETACH database_kw_opt expr */
176430
-{
176431
- sqlite3Detach(pParse, yymsp[0].minor.yy2);
176432
-}
176433
- break;
176434
- case 287: /* cmd ::= REINDEX */
176675
+ case 275: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
176676
+{yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
176677
+ yymsp[-8].minor.yy427 = yylhsminor.yy427;
176678
+ break;
176679
+ case 276: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
176680
+{
176681
+ yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
176682
+}
176683
+ yymsp[-7].minor.yy427 = yylhsminor.yy427;
176684
+ break;
176685
+ case 277: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
176686
+{yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
176687
+ yymsp[-5].minor.yy427 = yylhsminor.yy427;
176688
+ break;
176689
+ case 278: /* trigger_cmd ::= scanpt select scanpt */
176690
+{yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
176691
+ yymsp[-2].minor.yy427 = yylhsminor.yy427;
176692
+ break;
176693
+ case 279: /* expr ::= RAISE LP IGNORE RP */
176694
+{
176695
+ yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
176696
+ if( yymsp[-3].minor.yy454 ){
176697
+ yymsp[-3].minor.yy454->affExpr = OE_Ignore;
176698
+ }
176699
+}
176700
+ break;
176701
+ case 280: /* expr ::= RAISE LP raisetype COMMA nm RP */
176702
+{
176703
+ yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
176704
+ if( yymsp[-5].minor.yy454 ) {
176705
+ yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144;
176706
+ }
176707
+}
176708
+ break;
176709
+ case 281: /* raisetype ::= ROLLBACK */
176710
+{yymsp[0].minor.yy144 = OE_Rollback;}
176711
+ break;
176712
+ case 283: /* raisetype ::= FAIL */
176713
+{yymsp[0].minor.yy144 = OE_Fail;}
176714
+ break;
176715
+ case 284: /* cmd ::= DROP TRIGGER ifexists fullname */
176716
+{
176717
+ sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
176718
+}
176719
+ break;
176720
+ case 285: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
176721
+{
176722
+ sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
176723
+}
176724
+ break;
176725
+ case 286: /* cmd ::= DETACH database_kw_opt expr */
176726
+{
176727
+ sqlite3Detach(pParse, yymsp[0].minor.yy454);
176728
+}
176729
+ break;
176730
+ case 289: /* cmd ::= REINDEX */
176435176731
 {sqlite3Reindex(pParse, 0, 0);}
176436176732
 break;
176437
- case 288: /* cmd ::= REINDEX nm dbnm */
176733
+ case 290: /* cmd ::= REINDEX nm dbnm */
176438176734
 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176439176735
 break;
176440
- case 289: /* cmd ::= ANALYZE */
176736
+ case 291: /* cmd ::= ANALYZE */
176441176737
 {sqlite3Analyze(pParse, 0, 0);}
176442176738
 break;
176443
- case 290: /* cmd ::= ANALYZE nm dbnm */
176739
+ case 292: /* cmd ::= ANALYZE nm dbnm */
176444176740
 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176445176741
 break;
176446
- case 291: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
176742
+ case 293: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
176447176743
 {
176448
- sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy387,&yymsp[0].minor.yy0);
176744
+ sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
176449176745
 }
176450176746
 break;
176451
- case 292: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
176747
+ case 294: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
176452176748
 {
176453176749
 yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
176454176750
 sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
176455176751
 }
176456176752
 break;
176457
- case 293: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
176753
+ case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
176458176754
 {
176459
- sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy387, &yymsp[0].minor.yy0);
176755
+ sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
176460176756
 }
176461176757
 break;
176462
- case 294: /* add_column_fullname ::= fullname */
176758
+ case 296: /* add_column_fullname ::= fullname */
176463176759
 {
176464176760
 disableLookaside(pParse);
176465
- sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy387);
176466
-}
176467
- break;
176468
- case 295: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
176469
-{
176470
- sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy387, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
176471
-}
176472
- break;
176473
- case 296: /* cmd ::= create_vtab */
176761
+ sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy203);
176762
+}
176763
+ break;
176764
+ case 297: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
176765
+{
176766
+ sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
176767
+}
176768
+ break;
176769
+ case 298: /* cmd ::= create_vtab */
176474176770
 {sqlite3VtabFinishParse(pParse,0);}
176475176771
 break;
176476
- case 297: /* cmd ::= create_vtab LP vtabarglist RP */
176772
+ case 299: /* cmd ::= create_vtab LP vtabarglist RP */
176477176773
 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
176478176774
 break;
176479
- case 298: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
176775
+ case 300: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
176480176776
 {
176481
- sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy92);
176777
+ sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144);
176482176778
 }
176483176779
 break;
176484
- case 299: /* vtabarg ::= */
176780
+ case 301: /* vtabarg ::= */
176485176781
 {sqlite3VtabArgInit(pParse);}
176486176782
 break;
176487
- case 300: /* vtabargtoken ::= ANY */
176488
- case 301: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==301);
176489
- case 302: /* lp ::= LP */ yytestcase(yyruleno==302);
176783
+ case 302: /* vtabargtoken ::= ANY */
176784
+ case 303: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==303);
176785
+ case 304: /* lp ::= LP */ yytestcase(yyruleno==304);
176490176786
 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
176491176787
 break;
176492
- case 303: /* with ::= WITH wqlist */
176493
- case 304: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==304);
176494
-{ sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); }
176495
- break;
176496
- case 305: /* wqas ::= AS */
176497
-{yymsp[0].minor.yy498 = M10d_Any;}
176498
- break;
176499
- case 306: /* wqas ::= AS MATERIALIZED */
176500
-{yymsp[-1].minor.yy498 = M10d_Yes;}
176501
- break;
176502
- case 307: /* wqas ::= AS NOT MATERIALIZED */
176503
-{yymsp[-2].minor.yy498 = M10d_No;}
176504
- break;
176505
- case 308: /* wqitem ::= nm eidlist_opt wqas LP select RP */
176506
-{
176507
- yymsp[-5].minor.yy79 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy402, yymsp[-1].minor.yy299, yymsp[-3].minor.yy498); /*A-overwrites-X*/
176508
-}
176509
- break;
176510
- case 309: /* wqlist ::= wqitem */
176511
-{
176512
- yymsp[0].minor.yy131 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy79); /*A-overwrites-X*/
176513
-}
176514
- break;
176515
- case 310: /* wqlist ::= wqlist COMMA wqitem */
176516
-{
176517
- yymsp[-2].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy131, yymsp[0].minor.yy79);
176518
-}
176519
- break;
176520
- case 311: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
176521
-{
176522
- assert( yymsp[0].minor.yy3!=0 );
176523
- sqlite3WindowChain(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy3);
176524
- yymsp[0].minor.yy3->pNextWin = yymsp[-2].minor.yy3;
176525
- yylhsminor.yy3 = yymsp[0].minor.yy3;
176526
-}
176527
- yymsp[-2].minor.yy3 = yylhsminor.yy3;
176528
- break;
176529
- case 312: /* windowdefn ::= nm AS LP window RP */
176530
-{
176531
- if( ALWAYS(yymsp[-1].minor.yy3) ){
176532
- yymsp[-1].minor.yy3->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
176533
- }
176534
- yylhsminor.yy3 = yymsp[-1].minor.yy3;
176535
-}
176536
- yymsp[-4].minor.yy3 = yylhsminor.yy3;
176537
- break;
176538
- case 313: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
176539
-{
176540
- yymsp[-4].minor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, 0);
176541
-}
176542
- break;
176543
- case 314: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
176544
-{
176545
- yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, &yymsp[-5].minor.yy0);
176546
-}
176547
- yymsp[-5].minor.yy3 = yylhsminor.yy3;
176548
- break;
176549
- case 315: /* window ::= ORDER BY sortlist frame_opt */
176550
-{
176551
- yymsp[-3].minor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, yymsp[-1].minor.yy402, 0);
176552
-}
176553
- break;
176554
- case 316: /* window ::= nm ORDER BY sortlist frame_opt */
176555
-{
176556
- yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0);
176557
-}
176558
- yymsp[-4].minor.yy3 = yylhsminor.yy3;
176559
- break;
176560
- case 317: /* window ::= nm frame_opt */
176561
-{
176562
- yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, 0, &yymsp[-1].minor.yy0);
176563
-}
176564
- yymsp[-1].minor.yy3 = yylhsminor.yy3;
176565
- break;
176566
- case 318: /* frame_opt ::= */
176567
-{
176568
- yymsp[1].minor.yy3 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
176569
-}
176570
- break;
176571
- case 319: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
176572
-{
176573
- yylhsminor.yy3 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy92, yymsp[-1].minor.yy337.eType, yymsp[-1].minor.yy337.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy498);
176574
-}
176575
- yymsp[-2].minor.yy3 = yylhsminor.yy3;
176576
- break;
176577
- case 320: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
176578
-{
176579
- yylhsminor.yy3 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy92, yymsp[-3].minor.yy337.eType, yymsp[-3].minor.yy337.pExpr, yymsp[-1].minor.yy337.eType, yymsp[-1].minor.yy337.pExpr, yymsp[0].minor.yy498);
176580
-}
176581
- yymsp[-5].minor.yy3 = yylhsminor.yy3;
176582
- break;
176583
- case 322: /* frame_bound_s ::= frame_bound */
176584
- case 324: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==324);
176585
-{yylhsminor.yy337 = yymsp[0].minor.yy337;}
176586
- yymsp[0].minor.yy337 = yylhsminor.yy337;
176587
- break;
176588
- case 323: /* frame_bound_s ::= UNBOUNDED PRECEDING */
176589
- case 325: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==325);
176590
- case 327: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==327);
176591
-{yylhsminor.yy337.eType = yymsp[-1].major; yylhsminor.yy337.pExpr = 0;}
176592
- yymsp[-1].minor.yy337 = yylhsminor.yy337;
176593
- break;
176594
- case 326: /* frame_bound ::= expr PRECEDING|FOLLOWING */
176595
-{yylhsminor.yy337.eType = yymsp[0].major; yylhsminor.yy337.pExpr = yymsp[-1].minor.yy2;}
176596
- yymsp[-1].minor.yy337 = yylhsminor.yy337;
176597
- break;
176598
- case 328: /* frame_exclude_opt ::= */
176599
-{yymsp[1].minor.yy498 = 0;}
176600
- break;
176601
- case 329: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
176602
-{yymsp[-1].minor.yy498 = yymsp[0].minor.yy498;}
176603
- break;
176604
- case 330: /* frame_exclude ::= NO OTHERS */
176605
- case 331: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==331);
176606
-{yymsp[-1].minor.yy498 = yymsp[-1].major; /*A-overwrites-X*/}
176607
- break;
176608
- case 332: /* frame_exclude ::= GROUP|TIES */
176609
-{yymsp[0].minor.yy498 = yymsp[0].major; /*A-overwrites-X*/}
176610
- break;
176611
- case 333: /* window_clause ::= WINDOW windowdefn_list */
176612
-{ yymsp[-1].minor.yy3 = yymsp[0].minor.yy3; }
176613
- break;
176614
- case 334: /* filter_over ::= filter_clause over_clause */
176615
-{
176616
- if( yymsp[0].minor.yy3 ){
176617
- yymsp[0].minor.yy3->pFilter = yymsp[-1].minor.yy2;
176618
- }else{
176619
- sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy2);
176620
- }
176621
- yylhsminor.yy3 = yymsp[0].minor.yy3;
176622
-}
176623
- yymsp[-1].minor.yy3 = yylhsminor.yy3;
176624
- break;
176625
- case 335: /* filter_over ::= over_clause */
176626
-{
176627
- yylhsminor.yy3 = yymsp[0].minor.yy3;
176628
-}
176629
- yymsp[0].minor.yy3 = yylhsminor.yy3;
176630
- break;
176631
- case 336: /* filter_over ::= filter_clause */
176632
-{
176633
- yylhsminor.yy3 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176634
- if( yylhsminor.yy3 ){
176635
- yylhsminor.yy3->eFrmType = TK_FILTER;
176636
- yylhsminor.yy3->pFilter = yymsp[0].minor.yy2;
176637
- }else{
176638
- sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy2);
176639
- }
176640
-}
176641
- yymsp[0].minor.yy3 = yylhsminor.yy3;
176642
- break;
176643
- case 337: /* over_clause ::= OVER LP window RP */
176644
-{
176645
- yymsp[-3].minor.yy3 = yymsp[-1].minor.yy3;
176646
- assert( yymsp[-3].minor.yy3!=0 );
176647
-}
176648
- break;
176649
- case 338: /* over_clause ::= OVER nm */
176650
-{
176651
- yymsp[-1].minor.yy3 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176652
- if( yymsp[-1].minor.yy3 ){
176653
- yymsp[-1].minor.yy3->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
176654
- }
176655
-}
176656
- break;
176657
- case 339: /* filter_clause ::= FILTER LP WHERE expr RP */
176658
-{ yymsp[-4].minor.yy2 = yymsp[-1].minor.yy2; }
176659
- break;
176660
- case 340: /* term ::= QNUMBER */
176661
-{
176662
- yylhsminor.yy2=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
176663
- sqlite3DequoteNumber(pParse, yylhsminor.yy2);
176664
-}
176665
- yymsp[0].minor.yy2 = yylhsminor.yy2;
176788
+ case 305: /* with ::= WITH wqlist */
176789
+ case 306: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==306);
176790
+{ sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
176791
+ break;
176792
+ case 307: /* wqas ::= AS */
176793
+{yymsp[0].minor.yy462 = M10d_Any;}
176794
+ break;
176795
+ case 308: /* wqas ::= AS MATERIALIZED */
176796
+{yymsp[-1].minor.yy462 = M10d_Yes;}
176797
+ break;
176798
+ case 309: /* wqas ::= AS NOT MATERIALIZED */
176799
+{yymsp[-2].minor.yy462 = M10d_No;}
176800
+ break;
176801
+ case 310: /* wqitem ::= withnm eidlist_opt wqas LP select RP */
176802
+{
176803
+ yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
176804
+}
176805
+ break;
176806
+ case 311: /* withnm ::= nm */
176807
+{pParse->bHasWith = 1;}
176808
+ break;
176809
+ case 312: /* wqlist ::= wqitem */
176810
+{
176811
+ yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
176812
+}
176813
+ break;
176814
+ case 313: /* wqlist ::= wqlist COMMA wqitem */
176815
+{
176816
+ yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
176817
+}
176818
+ break;
176819
+ case 314: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
176820
+{
176821
+ assert( yymsp[0].minor.yy211!=0 );
176822
+ sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
176823
+ yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211;
176824
+ yylhsminor.yy211 = yymsp[0].minor.yy211;
176825
+}
176826
+ yymsp[-2].minor.yy211 = yylhsminor.yy211;
176827
+ break;
176828
+ case 315: /* windowdefn ::= nm AS LP window RP */
176829
+{
176830
+ if( ALWAYS(yymsp[-1].minor.yy211) ){
176831
+ yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
176832
+ }
176833
+ yylhsminor.yy211 = yymsp[-1].minor.yy211;
176834
+}
176835
+ yymsp[-4].minor.yy211 = yylhsminor.yy211;
176836
+ break;
176837
+ case 316: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
176838
+{
176839
+ yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
176840
+}
176841
+ break;
176842
+ case 317: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
176843
+{
176844
+ yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
176845
+}
176846
+ yymsp[-5].minor.yy211 = yylhsminor.yy211;
176847
+ break;
176848
+ case 318: /* window ::= ORDER BY sortlist frame_opt */
176849
+{
176850
+ yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
176851
+}
176852
+ break;
176853
+ case 319: /* window ::= nm ORDER BY sortlist frame_opt */
176854
+{
176855
+ yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
176856
+}
176857
+ yymsp[-4].minor.yy211 = yylhsminor.yy211;
176858
+ break;
176859
+ case 320: /* window ::= nm frame_opt */
176860
+{
176861
+ yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
176862
+}
176863
+ yymsp[-1].minor.yy211 = yylhsminor.yy211;
176864
+ break;
176865
+ case 321: /* frame_opt ::= */
176866
+{
176867
+ yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
176868
+}
176869
+ break;
176870
+ case 322: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
176871
+{
176872
+ yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
176873
+}
176874
+ yymsp[-2].minor.yy211 = yylhsminor.yy211;
176875
+ break;
176876
+ case 323: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
176877
+{
176878
+ yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
176879
+}
176880
+ yymsp[-5].minor.yy211 = yylhsminor.yy211;
176881
+ break;
176882
+ case 325: /* frame_bound_s ::= frame_bound */
176883
+ case 327: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==327);
176884
+{yylhsminor.yy509 = yymsp[0].minor.yy509;}
176885
+ yymsp[0].minor.yy509 = yylhsminor.yy509;
176886
+ break;
176887
+ case 326: /* frame_bound_s ::= UNBOUNDED PRECEDING */
176888
+ case 328: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==328);
176889
+ case 330: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==330);
176890
+{yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
176891
+ yymsp[-1].minor.yy509 = yylhsminor.yy509;
176892
+ break;
176893
+ case 329: /* frame_bound ::= expr PRECEDING|FOLLOWING */
176894
+{yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
176895
+ yymsp[-1].minor.yy509 = yylhsminor.yy509;
176896
+ break;
176897
+ case 331: /* frame_exclude_opt ::= */
176898
+{yymsp[1].minor.yy462 = 0;}
176899
+ break;
176900
+ case 332: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
176901
+{yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;}
176902
+ break;
176903
+ case 333: /* frame_exclude ::= NO OTHERS */
176904
+ case 334: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==334);
176905
+{yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/}
176906
+ break;
176907
+ case 335: /* frame_exclude ::= GROUP|TIES */
176908
+{yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/}
176909
+ break;
176910
+ case 336: /* window_clause ::= WINDOW windowdefn_list */
176911
+{ yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; }
176912
+ break;
176913
+ case 337: /* filter_over ::= filter_clause over_clause */
176914
+{
176915
+ if( yymsp[0].minor.yy211 ){
176916
+ yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454;
176917
+ }else{
176918
+ sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
176919
+ }
176920
+ yylhsminor.yy211 = yymsp[0].minor.yy211;
176921
+}
176922
+ yymsp[-1].minor.yy211 = yylhsminor.yy211;
176923
+ break;
176924
+ case 338: /* filter_over ::= over_clause */
176925
+{
176926
+ yylhsminor.yy211 = yymsp[0].minor.yy211;
176927
+}
176928
+ yymsp[0].minor.yy211 = yylhsminor.yy211;
176929
+ break;
176930
+ case 339: /* filter_over ::= filter_clause */
176931
+{
176932
+ yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176933
+ if( yylhsminor.yy211 ){
176934
+ yylhsminor.yy211->eFrmType = TK_FILTER;
176935
+ yylhsminor.yy211->pFilter = yymsp[0].minor.yy454;
176936
+ }else{
176937
+ sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
176938
+ }
176939
+}
176940
+ yymsp[0].minor.yy211 = yylhsminor.yy211;
176941
+ break;
176942
+ case 340: /* over_clause ::= OVER LP window RP */
176943
+{
176944
+ yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211;
176945
+ assert( yymsp[-3].minor.yy211!=0 );
176946
+}
176947
+ break;
176948
+ case 341: /* over_clause ::= OVER nm */
176949
+{
176950
+ yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176951
+ if( yymsp[-1].minor.yy211 ){
176952
+ yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
176953
+ }
176954
+}
176955
+ break;
176956
+ case 342: /* filter_clause ::= FILTER LP WHERE expr RP */
176957
+{ yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; }
176958
+ break;
176959
+ case 343: /* term ::= QNUMBER */
176960
+{
176961
+ yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
176962
+ sqlite3DequoteNumber(pParse, yylhsminor.yy454);
176963
+}
176964
+ yymsp[0].minor.yy454 = yylhsminor.yy454;
176666176965
 break;
176667176966
 default:
176668
- /* (341) input ::= cmdlist */ yytestcase(yyruleno==341);
176669
- /* (342) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==342);
176670
- /* (343) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=343);
176671
- /* (344) ecmd ::= SEMI */ yytestcase(yyruleno==344);
176672
- /* (345) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==345);
176673
- /* (346) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=346);
176674
- /* (347) trans_opt ::= */ yytestcase(yyruleno==347);
176675
- /* (348) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==348);
176676
- /* (349) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==349);
176677
- /* (350) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==350);
176678
- /* (351) savepoint_opt ::= */ yytestcase(yyruleno==351);
176679
- /* (352) cmd ::= create_table create_table_args */ yytestcase(yyruleno==352);
176680
- /* (353) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=353);
176681
- /* (354) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==354);
176682
- /* (355) columnlist ::= columnname carglist */ yytestcase(yyruleno==355);
176683
- /* (356) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==356);
176684
- /* (357) nm ::= STRING */ yytestcase(yyruleno==357);
176685
- /* (358) typetoken ::= typename */ yytestcase(yyruleno==358);
176686
- /* (359) typename ::= ID|STRING */ yytestcase(yyruleno==359);
176687
- /* (360) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=360);
176688
- /* (361) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=361);
176689
- /* (362) carglist ::= carglist ccons */ yytestcase(yyruleno==362);
176690
- /* (363) carglist ::= */ yytestcase(yyruleno==363);
176691
- /* (364) ccons ::= NULL onconf */ yytestcase(yyruleno==364);
176692
- /* (365) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==365);
176693
- /* (366) ccons ::= AS generated */ yytestcase(yyruleno==366);
176694
- /* (367) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==367);
176695
- /* (368) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==368);
176696
- /* (369) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=369);
176697
- /* (370) tconscomma ::= */ yytestcase(yyruleno==370);
176698
- /* (371) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=371);
176699
- /* (372) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=372);
176700
- /* (373) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=373);
176701
- /* (374) oneselect ::= values */ yytestcase(yyruleno==374);
176702
- /* (375) sclp ::= selcollist COMMA */ yytestcase(yyruleno==375);
176703
- /* (376) as ::= ID|STRING */ yytestcase(yyruleno==376);
176704
- /* (377) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=377);
176705
- /* (378) returning ::= */ yytestcase(yyruleno==378);
176706
- /* (379) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=379);
176707
- /* (380) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==380);
176708
- /* (381) case_operand ::= expr */ yytestcase(yyruleno==381);
176709
- /* (382) exprlist ::= nexprlist */ yytestcase(yyruleno==382);
176710
- /* (383) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=383);
176711
- /* (384) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=384);
176712
- /* (385) nmnum ::= ON */ yytestcase(yyruleno==385);
176713
- /* (386) nmnum ::= DELETE */ yytestcase(yyruleno==386);
176714
- /* (387) nmnum ::= DEFAULT */ yytestcase(yyruleno==387);
176715
- /* (388) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==388);
176716
- /* (389) foreach_clause ::= */ yytestcase(yyruleno==389);
176717
- /* (390) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==390);
176718
- /* (391) trnm ::= nm */ yytestcase(yyruleno==391);
176719
- /* (392) tridxby ::= */ yytestcase(yyruleno==392);
176720
- /* (393) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==393);
176721
- /* (394) database_kw_opt ::= */ yytestcase(yyruleno==394);
176722
- /* (395) kwcolumn_opt ::= */ yytestcase(yyruleno==395);
176723
- /* (396) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==396);
176724
- /* (397) vtabarglist ::= vtabarg */ yytestcase(yyruleno==397);
176725
- /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==398);
176726
- /* (399) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==399);
176727
- /* (400) anylist ::= */ yytestcase(yyruleno==400);
176728
- /* (401) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==401);
176729
- /* (402) anylist ::= anylist ANY */ yytestcase(yyruleno==402);
176730
- /* (403) with ::= */ yytestcase(yyruleno==403);
176731
- /* (404) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=404);
176732
- /* (405) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=405);
176967
+ /* (344) input ::= cmdlist */ yytestcase(yyruleno==344);
176968
+ /* (345) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==345);
176969
+ /* (346) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=346);
176970
+ /* (347) ecmd ::= SEMI */ yytestcase(yyruleno==347);
176971
+ /* (348) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==348);
176972
+ /* (349) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=349);
176973
+ /* (350) trans_opt ::= */ yytestcase(yyruleno==350);
176974
+ /* (351) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==351);
176975
+ /* (352) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==352);
176976
+ /* (353) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==353);
176977
+ /* (354) savepoint_opt ::= */ yytestcase(yyruleno==354);
176978
+ /* (355) cmd ::= create_table create_table_args */ yytestcase(yyruleno==355);
176979
+ /* (356) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=356);
176980
+ /* (357) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==357);
176981
+ /* (358) columnlist ::= columnname carglist */ yytestcase(yyruleno==358);
176982
+ /* (359) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==359);
176983
+ /* (360) nm ::= STRING */ yytestcase(yyruleno==360);
176984
+ /* (361) typetoken ::= typename */ yytestcase(yyruleno==361);
176985
+ /* (362) typename ::= ID|STRING */ yytestcase(yyruleno==362);
176986
+ /* (363) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=363);
176987
+ /* (364) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=364);
176988
+ /* (365) carglist ::= carglist ccons */ yytestcase(yyruleno==365);
176989
+ /* (366) carglist ::= */ yytestcase(yyruleno==366);
176990
+ /* (367) ccons ::= NULL onconf */ yytestcase(yyruleno==367);
176991
+ /* (368) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==368);
176992
+ /* (369) ccons ::= AS generated */ yytestcase(yyruleno==369);
176993
+ /* (370) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==370);
176994
+ /* (371) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==371);
176995
+ /* (372) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=372);
176996
+ /* (373) tconscomma ::= */ yytestcase(yyruleno==373);
176997
+ /* (374) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=374);
176998
+ /* (375) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=375);
176999
+ /* (376) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=376);
177000
+ /* (377) oneselect ::= values */ yytestcase(yyruleno==377);
177001
+ /* (378) sclp ::= selcollist COMMA */ yytestcase(yyruleno==378);
177002
+ /* (379) as ::= ID|STRING */ yytestcase(yyruleno==379);
177003
+ /* (380) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=380);
177004
+ /* (381) returning ::= */ yytestcase(yyruleno==381);
177005
+ /* (382) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=382);
177006
+ /* (383) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==383);
177007
+ /* (384) case_operand ::= expr */ yytestcase(yyruleno==384);
177008
+ /* (385) exprlist ::= nexprlist */ yytestcase(yyruleno==385);
177009
+ /* (386) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=386);
177010
+ /* (387) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=387);
177011
+ /* (388) nmnum ::= ON */ yytestcase(yyruleno==388);
177012
+ /* (389) nmnum ::= DELETE */ yytestcase(yyruleno==389);
177013
+ /* (390) nmnum ::= DEFAULT */ yytestcase(yyruleno==390);
177014
+ /* (391) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==391);
177015
+ /* (392) foreach_clause ::= */ yytestcase(yyruleno==392);
177016
+ /* (393) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==393);
177017
+ /* (394) trnm ::= nm */ yytestcase(yyruleno==394);
177018
+ /* (395) tridxby ::= */ yytestcase(yyruleno==395);
177019
+ /* (396) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==396);
177020
+ /* (397) database_kw_opt ::= */ yytestcase(yyruleno==397);
177021
+ /* (398) kwcolumn_opt ::= */ yytestcase(yyruleno==398);
177022
+ /* (399) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==399);
177023
+ /* (400) vtabarglist ::= vtabarg */ yytestcase(yyruleno==400);
177024
+ /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==401);
177025
+ /* (402) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==402);
177026
+ /* (403) anylist ::= */ yytestcase(yyruleno==403);
177027
+ /* (404) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==404);
177028
+ /* (405) anylist ::= anylist ANY */ yytestcase(yyruleno==405);
177029
+ /* (406) with ::= */ yytestcase(yyruleno==406);
177030
+ /* (407) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=407);
177031
+ /* (408) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=408);
176733177032
 break;
176734177033
 /********** End reduce actions ************************************************/
176735177034
 };
176736177035
 assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
176737177036
 yygoto = yyRuleInfoLhs[yyruleno];
@@ -251503,11 +251802,11 @@
251503251802
 int nArg, /* Number of args */
251504251803
 sqlite3_value **apUnused /* Function arguments */
251505251804
 ){
251506251805
 assert( nArg==0 );
251507251806
 UNUSED_PARAM2(nArg, apUnused);
251508
- sqlite3_result_text(pCtx, "fts5: 2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f", -1, SQLITE_TRANSIENT);
251807
+ sqlite3_result_text(pCtx, "fts5: 2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61", -1, SQLITE_TRANSIENT);
251509251808
 }
251510251809
251511251810
 /*
251512251811
 ** Return true if zName is the extension on one of the shadow tables used
251513251812
 ** by this module.
251514251813
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
16 ** if you want a wrapper to interface SQLite with your choice of programming
17 ** language. The code for the "sqlite3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
19 **
20 ** The content in this amalgamation comes from Fossil check-in
21 ** 7ead022edaf7a0cd6a8976a1261246084975.
22 */
23 #define SQLITE_CORE 1
24 #define SQLITE_AMALGAMATION 1
25 #ifndef SQLITE_PRIVATE
26 # define SQLITE_PRIVATE static
@@ -459,11 +459,11 @@
459 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460 ** [sqlite_version()] and [sqlite_source_id()].
461 */
462 #define SQLITE_VERSION "3.46.0"
463 #define SQLITE_VERSION_NUMBER 3046000
464 #define SQLITE_SOURCE_ID "2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f"
465
466 /*
467 ** CAPI3REF: Run-Time Library Version Numbers
468 ** KEYWORDS: sqlite3_version sqlite3_sourceid
469 **
@@ -19173,14 +19173,16 @@
19173 ** In the colUsed field, the high-order bit (bit 63) is set if the table
19174 ** contains more than 63 columns and the 64-th or later column is used.
19175 **
19176 ** Union member validity:
19177 **
19178 ** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc
19179 ** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy
19180 ** u2.pIBIndex fg.isIndexedBy && !fg.isCte
19181 ** u2.pCteUse fg.isCte && !fg.isIndexedBy
 
 
19182 */
19183 struct SrcItem {
19184 Schema *pSchema; /* Schema to which this item is fixed */
19185 char *zDatabase; /* Name of database holding this table */
19186 char *zName; /* Name of the table */
@@ -19214,10 +19216,11 @@
19214 } u3;
19215 Bitmask colUsed; /* Bit N set if column N used. Details above for N>62 */
19216 union {
19217 char *zIndexedBy; /* Identifier from "INDEXED BY <zIndex>" clause */
19218 ExprList *pFuncArg; /* Arguments to table-valued-function */
 
19219 } u1;
19220 union {
19221 Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */
19222 CteUse *pCteUse; /* CTE Usage info when fg.isCte is true */
19223 } u2;
@@ -19715,10 +19718,11 @@
19715 u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */
19716 u8 okConstFactor; /* OK to factor out constants */
19717 u8 disableLookaside; /* Number of times lookaside has been disabled */
19718 u8 prepFlags; /* SQLITE_PREPARE_* flags */
19719 u8 withinRJSubrtn; /* Nesting level for RIGHT JOIN body subroutines */
 
19720 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
19721 u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */
19722 #endif
19723 #ifdef SQLITE_DEBUG
19724 u8 ifNotExists; /* Might be true if IF NOT EXISTS. Assert()s only */
@@ -20389,10 +20393,13 @@
20389 int regEndRowid;
20390 u8 bExprArgs; /* Defer evaluation of window function arguments
20391 ** due to the SQLITE_SUBTYPE flag */
20392 };
20393
 
 
 
20394 #ifndef SQLITE_OMIT_WINDOWFUNC
20395 SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*);
20396 SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*);
20397 SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p);
20398 SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
@@ -20957,12 +20964,11 @@
20957 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
20958 SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
20959 SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*);
20960 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*);
20961 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*);
20962 SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
20963 SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
20964 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
20965 SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
20966 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int);
20967 SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int);
20968 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -31896,10 +31902,14 @@
31896 }else{
31897 Select *pSel = pItem->pSelect;
31898 assert( pSel!=0 );
31899 if( pSel->selFlags & SF_NestedFrom ){
31900 sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
 
 
 
 
31901 }else{
31902 sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId);
31903 }
31904 }
31905 length = width = 0;
@@ -109036,13 +109046,14 @@
109036 if( ExprHasProperty(pExpr, EP_Unlikely) ){
109037 assert( ExprUseXList(pExpr) );
109038 assert( pExpr->x.pList->nExpr>0 );
109039 assert( pExpr->op==TK_FUNCTION );
109040 pExpr = pExpr->x.pList->a[0].pExpr;
109041 }else{
109042 assert( pExpr->op==TK_COLLATE );
109043 pExpr = pExpr->pLeft;
 
 
109044 }
109045 }
109046 return pExpr;
109047 }
109048
@@ -110687,10 +110698,11 @@
110687 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
110688 pNewItem->fg = pOldItem->fg;
110689 pNewItem->iCursor = pOldItem->iCursor;
110690 pNewItem->addrFillSub = pOldItem->addrFillSub;
110691 pNewItem->regReturn = pOldItem->regReturn;
 
110692 if( pNewItem->fg.isIndexedBy ){
110693 pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
110694 }
110695 pNewItem->u2 = pOldItem->u2;
110696 if( pNewItem->fg.isCte ){
@@ -111163,10 +111175,58 @@
111163 }
111164 }
111165 return pExpr;
111166 }
111167
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
111168
111169 /*
111170 ** These routines are Walker callbacks used to check expressions to
111171 ** see if they are "constant" for some definition of constant. The
111172 ** Walker.eCode value determines the type of "constant" we are looking
@@ -111191,10 +111251,11 @@
111191 ** contain a bound parameter because they were generated by older versions
111192 ** of SQLite to be parsed by newer versions of SQLite without raising a
111193 ** malformed schema error.
111194 */
111195 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
 
111196
111197 /* If pWalker->eCode is 2 then any term of the expression that comes from
111198 ** the ON or USING clauses of an outer join disqualifies the expression
111199 ** from being considered constant. */
111200 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
@@ -111210,10 +111271,12 @@
111210 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
111211 && !ExprHasProperty(pExpr, EP_WinFunc)
111212 ){
111213 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
111214 return WRC_Continue;
 
 
111215 }else{
111216 pWalker->eCode = 0;
111217 return WRC_Abort;
111218 }
111219 case TK_ID:
@@ -111262,13 +111325,14 @@
111262 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
111263 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
111264 return WRC_Continue;
111265 }
111266 }
111267 static int exprIsConst(Expr *p, int initFlag, int iCur){
111268 Walker w;
111269 w.eCode = initFlag;
 
111270 w.xExprCallback = exprNodeIsConstant;
111271 w.xSelectCallback = sqlite3SelectWalkFail;
111272 #ifdef SQLITE_DEBUG
111273 w.xSelectCallback2 = sqlite3SelectWalkAssert2;
111274 #endif
@@ -111282,13 +111346,19 @@
111282 ** and 0 if it involves variables or function calls.
111283 **
111284 ** For the purposes of this function, a double-quoted string (ex: "abc")
111285 ** is considered a variable but a single-quoted string (ex: 'abc') is
111286 ** a constant.
 
 
 
 
 
 
111287 */
111288 SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
111289 return exprIsConst(p, 1, 0);
111290 }
111291
111292 /*
111293 ** Walk an expression tree. Return non-zero if
111294 **
@@ -111300,22 +111370,22 @@
111300 **
111301 ** When this routine returns true, it indicates that the expression
111302 ** can be added to the pParse->pConstExpr list and evaluated once when
111303 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
111304 */
111305 SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
111306 return exprIsConst(p, 2, 0);
111307 }
111308
111309 /*
111310 ** Walk an expression tree. Return non-zero if the expression is constant
111311 ** for any single row of the table with cursor iCur. In other words, the
111312 ** expression must not refer to any non-deterministic function nor any
111313 ** table other than iCur.
111314 */
111315 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
111316 return exprIsConst(p, 3, iCur);
111317 }
111318
111319 /*
111320 ** Check pExpr to see if it is an constraint on the single data source
111321 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
@@ -111468,11 +111538,11 @@
111468 ** is considered a variable but a single-quoted string (ex: 'abc') is
111469 ** a constant.
111470 */
111471 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){
111472 assert( isInit==0 || isInit==1 );
111473 return exprIsConst(p, 4+isInit, 0);
111474 }
111475
111476 #ifdef SQLITE_ENABLE_CURSOR_HINTS
111477 /*
111478 ** Walk an expression tree. Return 1 if the expression contains a
@@ -111713,17 +111783,17 @@
111713 #ifndef SQLITE_OMIT_SUBQUERY
111714 /*
111715 ** The argument is an IN operator with a list (not a subquery) on the
111716 ** right-hand side. Return TRUE if that list is constant.
111717 */
111718 static int sqlite3InRhsIsConstant(Expr *pIn){
111719 Expr *pLHS;
111720 int res;
111721 assert( !ExprHasProperty(pIn, EP_xIsSelect) );
111722 pLHS = pIn->pLeft;
111723 pIn->pLeft = 0;
111724 res = sqlite3ExprIsConstant(pIn);
111725 pIn->pLeft = pLHS;
111726 return res;
111727 }
111728 #endif
111729
@@ -111988,11 +112058,11 @@
111988 ** the IN operator so return IN_INDEX_NOOP.
111989 */
111990 if( eType==0
111991 && (inFlags & IN_INDEX_NOOP_OK)
111992 && ExprUseXList(pX)
111993 && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
111994 ){
111995 pParse->nTab--; /* Back out the allocation of the unused cursor */
111996 iTab = -1; /* Cursor is not allocated */
111997 eType = IN_INDEX_NOOP;
111998 }
@@ -112271,11 +112341,11 @@
112271 /* If the expression is not constant then we will need to
112272 ** disable the test that was generated above that makes sure
112273 ** this code only executes once. Because for a non-constant
112274 ** expression we need to rerun this code each time.
112275 */
112276 if( addrOnce && !sqlite3ExprIsConstant(pE2) ){
112277 sqlite3VdbeChangeToNoop(v, addrOnce-1);
112278 sqlite3VdbeChangeToNoop(v, addrOnce);
112279 ExprClearProperty(pExpr, EP_Subrtn);
112280 addrOnce = 0;
112281 }
@@ -113608,11 +113678,13 @@
113608 if( ExprHasProperty(pExpr, EP_WinFunc) ){
113609 return pExpr->y.pWin->regResult;
113610 }
113611 #endif
113612
113613 if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
 
 
113614 /* SQL functions can be expensive. So try to avoid running them
113615 ** multiple times if we know they always give the same result */
113616 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113617 }
113618 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
@@ -113639,11 +113711,11 @@
113639 }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){
113640 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113641 }
113642
113643 for(i=0; i<nFarg; i++){
113644 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
113645 testcase( i==31 );
113646 constMask |= MASKBIT32(i);
113647 }
113648 if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
113649 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
@@ -114106,11 +114178,11 @@
114106 int r2;
114107 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
114108 if( ConstFactorOk(pParse)
114109 && ALWAYS(pExpr!=0)
114110 && pExpr->op!=TK_REGISTER
114111 && sqlite3ExprIsConstantNotJoin(pExpr)
114112 ){
114113 *pReg = 0;
114114 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114115 }else{
114116 int r1 = sqlite3GetTempReg(pParse);
@@ -114170,11 +114242,11 @@
114170 ** results in register target. The results are guaranteed to appear
114171 ** in register target. If the expression is constant, then this routine
114172 ** might choose to code the expression at initialization time.
114173 */
114174 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
114175 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
114176 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
114177 }else{
114178 sqlite3ExprCodeCopy(pParse, pExpr, target);
114179 }
114180 }
@@ -114229,11 +114301,11 @@
114229 n--;
114230 }else{
114231 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
114232 }
114233 }else if( (flags & SQLITE_ECEL_FACTOR)!=0
114234 && sqlite3ExprIsConstantNotJoin(pExpr)
114235 ){
114236 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
114237 }else{
114238 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
114239 if( inReg!=target+i ){
@@ -133152,10 +133224,197 @@
133152 */
133153 # define autoIncBegin(A,B,C) (0)
133154 # define autoIncStep(A,B,C)
133155 #endif /* SQLITE_OMIT_AUTOINCREMENT */
133156
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
133157
133158 /* Forward declaration */
133159 static int xferOptimization(
133160 Parse *pParse, /* Parser context */
133161 Table *pDest, /* The table we are inserting into */
@@ -133488,29 +133747,44 @@
133488 ** co-routine is the common header to the 3rd and 4th templates.
133489 */
133490 if( pSelect ){
133491 /* Data is coming from a SELECT or from a multi-row VALUES clause.
133492 ** Generate a co-routine to run the SELECT. */
133493 int regYield; /* Register holding co-routine entry-point */
133494 int addrTop; /* Top of the co-routine */
133495 int rc; /* Result code */
133496
133497 regYield = ++pParse->nMem;
133498 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
133499 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
133500 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
133501 dest.iSdst = bIdListInOrder ? regData : 0;
133502 dest.nSdst = pTab->nCol;
133503 rc = sqlite3Select(pParse, pSelect, &dest);
133504 regFromSelect = dest.iSdst;
133505 assert( db->pParse==pParse );
133506 if( rc || pParse->nErr ) goto insert_cleanup;
133507 assert( db->mallocFailed==0 );
133508 sqlite3VdbeEndCoroutine(v, regYield);
133509 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
133510 assert( pSelect->pEList );
133511 nColumn = pSelect->pEList->nExpr;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
133512
133513 /* Set useTempTable to TRUE if the result of the SELECT statement
133514 ** should be written into a temporary table (template 4). Set to
133515 ** FALSE if each output row of the SELECT can be written directly into
133516 ** the destination table (template 3).
@@ -147133,11 +147407,11 @@
147133 Expr *pValue, /* The VALUE part of the constraint */
147134 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
147135 ){
147136 int i;
147137 assert( pColumn->op==TK_COLUMN );
147138 assert( sqlite3ExprIsConstant(pValue) );
147139
147140 if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
147141 if( sqlite3ExprAffinity(pValue)!=0 ) return;
147142 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147143 return;
@@ -147191,14 +147465,14 @@
147191 if( pExpr->op!=TK_EQ ) return;
147192 pRight = pExpr->pRight;
147193 pLeft = pExpr->pLeft;
147194 assert( pRight!=0 );
147195 assert( pLeft!=0 );
147196 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
147197 constInsert(pConst,pRight,pLeft,pExpr);
147198 }
147199 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
147200 constInsert(pConst,pLeft,pRight,pExpr);
147201 }
147202 }
147203
147204 /*
@@ -149993,11 +150267,11 @@
149993
149994 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
149995 /* Generate code for all sub-queries in the FROM clause
149996 */
149997 pSub = pItem->pSelect;
149998 if( pSub==0 ) continue;
149999
150000 /* The code for a subquery should only be generated once. */
150001 assert( pItem->addrFillSub==0 );
150002
150003 /* Increment Parse.nHeight by the height of the largest expression
@@ -160532,11 +160806,11 @@
160532 if( pIdx->aColExpr==0 ) continue;
160533 for(i=0; i<pIdx->nKeyCol; i++){
160534 if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
160535 assert( pIdx->bHasExpr );
160536 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
160537 && !sqlite3ExprIsConstant(pIdx->aColExpr->a[i].pExpr)
160538 ){
160539 aiCurCol[0] = iCur;
160540 aiCurCol[1] = XN_EXPR;
160541 return 1;
160542 }
@@ -162745,11 +163019,11 @@
162745 for(i=0; i<n; i++){
162746 Expr *pExpr = pOrderBy->a[i].pExpr;
162747 Expr *pE2;
162748
162749 /* Skip over constant terms in the ORDER BY clause */
162750 if( sqlite3ExprIsConstant(pExpr) ){
162751 continue;
162752 }
162753
162754 /* Virtual tables are unable to deal with NULLS FIRST */
162755 if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break;
@@ -162857,11 +163131,11 @@
162857 }
162858 assert( j==nTerm );
162859 pIdxInfo->nConstraint = j;
162860 for(i=j=0; i<nOrderBy; i++){
162861 Expr *pExpr = pOrderBy->a[i].pExpr;
162862 if( sqlite3ExprIsConstant(pExpr) ) continue;
162863 assert( pExpr->op==TK_COLUMN
162864 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
162865 && pExpr->iColumn==pExpr->pLeft->iColumn) );
162866 pIdxOrderBy[j].iColumn = pExpr->iColumn;
162867 pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC;
@@ -165039,11 +165313,11 @@
165039 Expr *pLeft = pPart->pLeft;
165040 Expr *pRight = pPart->pRight;
165041 u8 aff;
165042
165043 if( pLeft->op!=TK_COLUMN ) return;
165044 if( !sqlite3ExprIsConstant(pRight) ) return;
165045 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
165046 if( pLeft->iColumn<0 ) return;
165047 aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
165048 if( aff>=SQLITE_AFF_TEXT ){
165049 if( pItem ){
@@ -166413,11 +166687,11 @@
166413 Expr *p;
166414 Bitmask mTerm;
166415 if( MASKBIT(i) & obSat ) continue;
166416 p = pOrderBy->a[i].pExpr;
166417 mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
166418 if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
166419 if( (mTerm&~orderDistinctMask)==0 ){
166420 obSat |= MASKBIT(i);
166421 }
166422 }
166423 }
@@ -167282,11 +167556,11 @@
167282 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
167283 bMaybeNullRow = 0;
167284 }else{
167285 continue;
167286 }
167287 if( sqlite3ExprIsConstant(pExpr) ) continue;
167288 if( pExpr->op==TK_FUNCTION ){
167289 /* Functions that might set a subtype should not be replaced by the
167290 ** value taken from an expression index since the index omits the
167291 ** subtype. https://sqlite.org/forum/forumpost/68d284c86b082c3e */
167292 int n;
@@ -167560,11 +167834,15 @@
167560 if( (wctrlFlags & WHERE_WANT_DISTINCT)!=0
167561 && OptimizationEnabled(db, SQLITE_DistinctOpt)
167562 ){
167563 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
167564 }
167565 ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
 
 
 
 
167566 }else{
167567 /* Assign a bit from the bitmask to every term in the FROM clause.
167568 **
167569 ** The N-th term of the FROM clause is assigned a bitmask of 1<<N.
167570 **
@@ -168312,10 +168590,11 @@
168312 ** the co-routine into OP_Copy of result contained in a register.
168313 ** OP_Rowid becomes OP_Null.
168314 */
168315 if( pTabItem->fg.viaCoroutine ){
168316 testcase( pParse->db->mallocFailed );
 
168317 translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
168318 pTabItem->regResult, 0);
168319 continue;
168320 }
168321
@@ -169616,11 +169895,11 @@
169616 ** constant, change it to NULL. The fact that it is then a non-negative
169617 ** integer will be caught later. But it is important not to leave
169618 ** variable values in the expression tree.
169619 */
169620 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
169621 if( 0==sqlite3ExprIsConstant(pExpr) ){
169622 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
169623 sqlite3ExprDelete(pParse->db, pExpr);
169624 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
169625 }
169626 return pExpr;
@@ -172042,35 +172321,35 @@
172042 #ifndef INTERFACE
172043 # define INTERFACE 1
172044 #endif
172045 /************* Begin control #defines *****************************************/
172046 #define YYCODETYPE unsigned short int
172047 #define YYNOCODE 320
172048 #define YYACTIONTYPE unsigned short int
172049 #define YYWILDCARD 101
172050 #define sqlite3ParserTOKENTYPE Token
172051 typedef union {
172052 int yyinit;
172053 sqlite3ParserTOKENTYPE yy0;
172054 Expr* yy2;
172055 Window* yy3;
172056 Cte* yy79;
172057 int yy92;
172058 With* yy131;
172059 struct TrigEvent yy210;
172060 Upsert* yy258;
172061 Select* yy299;
172062 OnOrUsing yy305;
172063 struct FrameBound yy337;
172064 TriggerStep* yy347;
172065 struct {int value; int mask;} yy367;
172066 SrcList* yy387;
172067 IdList* yy400;
172068 ExprList* yy402;
172069 u8 yy498;
172070 u32 yy527;
172071 const char* yy616;
172072 } YYMINORTYPE;
172073 #ifndef YYSTACKDEPTH
172074 #define YYSTACKDEPTH 100
172075 #endif
172076 #define sqlite3ParserARG_SDECL
@@ -172085,24 +172364,24 @@
172085 #define sqlite3ParserCTX_PDECL ,Parse *pParse
172086 #define sqlite3ParserCTX_PARAM ,pParse
172087 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
172088 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
172089 #define YYFALLBACK 1
172090 #define YYNSTATE 579
172091 #define YYNRULE 406
172092 #define YYNRULE_WITH_ACTION 341
172093 #define YYNTOKEN 186
172094 #define YY_MAX_SHIFT 578
172095 #define YY_MIN_SHIFTREDUCE 839
172096 #define YY_MAX_SHIFTREDUCE 1244
172097 #define YY_ERROR_ACTION 1245
172098 #define YY_ACCEPT_ACTION 1246
172099 #define YY_NO_ACTION 1247
172100 #define YY_MIN_REDUCE 1248
172101 #define YY_MAX_REDUCE 1653
172102 #define YY_MIN_DSTRCTR 205
172103 #define YY_MAX_DSTRCTR 317
172104 /************* End control #defines *******************************************/
172105 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
172106
172107 /* Define the yytestcase() macro to be a no-op if is not already defined
172108 ** otherwise.
@@ -172181,626 +172460,634 @@
172181 ** yy_reduce_ofst[] For each state, the offset into yy_action for
172182 ** shifting non-terminals after a reduce.
172183 ** yy_default[] Default action for each state.
172184 **
172185 *********** Begin parsing tables **********************************************/
172186 #define YY_ACTTAB_COUNT (2114)
172187 static const YYACTIONTYPE yy_action[] = {
172188 /* 0 */ 572, 210, 572, 119, 116, 231, 572, 119, 116, 231,
172189 /* 10 */ 572, 1319, 379, 1298, 410, 566, 566, 566, 572, 411,
172190 /* 20 */ 380, 1319, 1281, 42, 42, 42, 42, 210, 1531, 72,
172191 /* 30 */ 72, 975, 421, 42, 42, 495, 305, 281, 305, 976,
172192 /* 40 */ 399, 72, 72, 126, 127, 81, 1219, 1219, 1055, 1058,
172193 /* 50 */ 1045, 1045, 124, 124, 125, 125, 125, 125, 480, 411,
172194 /* 60 */ 1246, 1, 1, 578, 2, 1250, 554, 119, 116, 231,
172195 /* 70 */ 319, 484, 147, 484, 528, 119, 116, 231, 533, 1332,
172196 /* 80 */ 419, 527, 143, 126, 127, 81, 1219, 1219, 1055, 1058,
172197 /* 90 */ 1045, 1045, 124, 124, 125, 125, 125, 125, 119, 116,
172198 /* 100 */ 231, 329, 123, 123, 123, 123, 122, 122, 121, 121,
172199 /* 110 */ 121, 120, 117, 448, 286, 286, 286, 286, 446, 446,
172200 /* 120 */ 446, 1570, 378, 1572, 1195, 377, 1165, 569, 1165, 569,
172201 /* 130 */ 411, 1570, 541, 261, 228, 448, 102, 146, 453, 318,
172202 /* 140 */ 563, 242, 123, 123, 123, 123, 122, 122, 121, 121,
172203 /* 150 */ 121, 120, 117, 448, 126, 127, 81, 1219, 1219, 1055,
172204 /* 160 */ 1058, 1045, 1045, 124, 124, 125, 125, 125, 125, 143,
172205 /* 170 */ 296, 1195, 341, 452, 121, 121, 121, 120, 117, 448,
172206 /* 180 */ 128, 1195, 1196, 1195, 149, 445, 444, 572, 120, 117,
172207 /* 190 */ 448, 125, 125, 125, 125, 118, 123, 123, 123, 123,
172208 /* 200 */ 122, 122, 121, 121, 121, 120, 117, 448, 458, 1284,
172209 /* 210 */ 13, 13, 130, 123, 123, 123, 123, 122, 122, 121,
172210 /* 220 */ 121, 121, 120, 117, 448, 424, 318, 563, 1195, 1196,
172211 /* 230 */ 1195, 162, 1227, 411, 1227, 125, 125, 125, 125, 123,
172212 /* 240 */ 123, 123, 123, 122, 122, 121, 121, 121, 120, 117,
172213 /* 250 */ 448, 469, 344, 1042, 1042, 1056, 1059, 126, 127, 81,
172214 /* 260 */ 1219, 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125,
172215 /* 270 */ 125, 125, 1102, 1102, 492, 1195, 572, 411, 226, 519,
172216 /* 280 */ 177, 83, 84, 123, 123, 123, 123, 122, 122, 121,
172217 /* 290 */ 121, 121, 120, 117, 448, 1011, 408, 407, 1195, 72,
172218 /* 300 */ 72, 126, 127, 81, 1219, 1219, 1055, 1058, 1045, 1045,
172219 /* 310 */ 124, 124, 125, 125, 125, 125, 123, 123, 123, 123,
172220 /* 320 */ 122, 122, 121, 121, 121, 120, 117, 448, 1046, 1615,
172221 /* 330 */ 1195, 905, 1195, 1196, 1195, 254, 314, 401, 508, 505,
172222 /* 340 */ 504, 112, 564, 570, 4, 930, 930, 435, 503, 342,
172223 /* 350 */ 464, 330, 362, 517, 327, 1195, 1196, 1195, 567, 572,
172224 /* 360 */ 123, 123, 123, 123, 122, 122, 121, 121, 121, 120,
172225 /* 370 */ 117, 448, 286, 286, 844, 845, 846, 445, 444, 1198,
172226 /* 380 */ 411, 449, 72, 72, 12, 569, 1224, 1195, 1196, 1195,
172227 /* 390 */ 86, 1226, 273, 561, 1440, 520, 520, 572, 375, 1225,
172228 /* 400 */ 6, 1283, 476, 143, 126, 127, 81, 1219, 1219, 1055,
172229 /* 410 */ 1058, 1045, 1045, 124, 124, 125, 125, 125, 125, 554,
172230 /* 420 */ 13, 13, 1032, 511, 1227, 1195, 1227, 553, 110, 110,
172231 /* 430 */ 224, 572, 371, 1583, 572, 429, 111, 1198, 449, 573,
172232 /* 440 */ 449, 432, 375, 1020, 1495, 555, 155, 272, 289, 370,
172233 /* 450 */ 514, 365, 513, 259, 72, 72, 547, 72, 72, 361,
172234 /* 460 */ 318, 563, 485, 123, 123, 123, 123, 122, 122, 121,
172235 /* 470 */ 121, 121, 120, 117, 448, 1020, 1020, 1022, 1023, 28,
172236 /* 480 */ 286, 286, 1195, 1196, 1195, 1160, 1616, 210, 411, 1610,
172237 /* 490 */ 158, 554, 358, 569, 554, 390, 537, 1291, 1160, 437,
172238 /* 500 */ 404, 1160, 556, 1565, 572, 1179, 572, 6, 9, 1557,
172239 /* 510 */ 264, 216, 126, 127, 81, 1219, 1219, 1055, 1058, 1045,
172240 /* 520 */ 1045, 124, 124, 125, 125, 125, 125, 13, 13, 13,
172241 /* 530 */ 13, 411, 577, 254, 1250, 509, 508, 505, 504, 319,
172242 /* 540 */ 224, 147, 431, 1011, 304, 1215, 503, 219, 1332, 1324,
172243 /* 550 */ 1324, 143, 375, 1557, 536, 126, 127, 81, 1219, 1219,
172244 /* 560 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172245 /* 570 */ 1559, 123, 123, 123, 123, 122, 122, 121, 121, 121,
172246 /* 580 */ 120, 117, 448, 286, 286, 122, 122, 121, 121, 121,
172247 /* 590 */ 120, 117, 448, 1586, 1195, 177, 569, 342, 1195, 386,
172248 /* 600 */ 154, 382, 411, 1215, 571, 547, 880, 192, 318, 563,
172249 /* 610 */ 242, 193, 1322, 1322, 123, 123, 123, 123, 122, 122,
172250 /* 620 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172251 /* 630 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172252 /* 640 */ 125, 411, 452, 941, 1195, 873, 1272, 376, 1195, 1272,
172253 /* 650 */ 856, 1195, 1196, 1195, 421, 1195, 1196, 1195, 1270, 574,
172254 /* 660 */ 572, 574, 33, 1557, 99, 126, 127, 81, 1219, 1219,
172255 /* 670 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172256 /* 680 */ 1355, 415, 963, 13, 13, 123, 123, 123, 123, 122,
172257 /* 690 */ 122, 121, 121, 121, 120, 117, 448, 526, 436, 1195,
172258 /* 700 */ 421, 1195, 1196, 1195, 1195, 1195, 1196, 1195, 1195, 467,
172259 /* 710 */ 545, 545, 411, 375, 373, 6, 1178, 5, 548, 548,
172260 /* 720 */ 16, 16, 3, 208, 123, 123, 123, 123, 122, 122,
172261 /* 730 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172262 /* 740 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172263 /* 750 */ 125, 411, 1077, 430, 1195, 1033, 1195, 1196, 1195, 1195,
172264 /* 760 */ 532, 1195, 1196, 1195, 489, 1195, 1196, 1195, 486, 209,
172265 /* 770 */ 572, 375, 229, 1647, 397, 126, 127, 81, 1219, 1219,
172266 /* 780 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172267 /* 790 */ 1487, 572, 962, 13, 13, 123, 123, 123, 123, 122,
172268 /* 800 */ 122, 121, 121, 121, 120, 117, 448, 1424, 202, 572,
172269 /* 810 */ 384, 1195, 1196, 1195, 13, 13, 1195, 1196, 1195, 156,
172270 /* 820 */ 199, 459, 411, 283, 1558, 961, 1016, 1541, 292, 203,
172271 /* 830 */ 301, 896, 72, 72, 123, 123, 123, 123, 122, 122,
172272 /* 840 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172273 /* 850 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172274 /* 860 */ 125, 411, 512, 286, 286, 286, 286, 280, 280, 315,
172275 /* 870 */ 897, 287, 287, 461, 101, 98, 569, 426, 569, 572,
172276 /* 880 */ 569, 288, 1557, 409, 569, 126, 127, 81, 1219, 1219,
172277 /* 890 */ 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125, 125,
172278 /* 900 */ 572, 12, 13, 13, 531, 123, 123, 123, 123, 122,
172279 /* 910 */ 122, 121, 121, 121, 120, 117, 448, 549, 230, 1590,
172280 /* 920 */ 578, 2, 1250, 71, 71, 1160, 433, 319, 356, 147,
172281 /* 930 */ 495, 1563, 411, 318, 563, 6, 1332, 1543, 1160, 1357,
172282 /* 940 */ 313, 1160, 1330, 961, 123, 123, 123, 123, 122, 122,
172283 /* 950 */ 121, 121, 121, 120, 117, 448, 126, 127, 81, 1219,
172284 /* 960 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172285 /* 970 */ 125, 286, 286, 572, 205, 1530, 411, 286, 286, 468,
172286 /* 980 */ 257, 256, 255, 1097, 569, 385, 495, 876, 529, 351,
172287 /* 990 */ 569, 354, 1141, 1645, 1302, 1645, 72, 72, 242, 1268,
172288 /* 1000 */ 1604, 105, 81, 1219, 1219, 1055, 1058, 1045, 1045, 124,
172289 /* 1010 */ 124, 125, 125, 125, 125, 123, 123, 123, 123, 122,
172290 /* 1020 */ 122, 121, 121, 121, 120, 117, 448, 572, 1032, 572,
172291 /* 1030 */ 452, 1494, 572, 443, 286, 286, 1141, 1646, 1424, 1646,
172292 /* 1040 */ 521, 495, 523, 1118, 876, 1021, 334, 569, 495, 1020,
172293 /* 1050 */ 72, 72, 52, 52, 101, 134, 134, 1439, 1119, 123,
172294 /* 1060 */ 123, 123, 123, 122, 122, 121, 121, 121, 120, 117,
172295 /* 1070 */ 448, 1139, 108, 1120, 936, 286, 286, 286, 286, 935,
172296 /* 1080 */ 457, 1020, 1020, 1022, 98, 530, 1331, 447, 569, 522,
172297 /* 1090 */ 569, 484, 411, 1327, 916, 371, 1583, 211, 457, 456,
172298 /* 1100 */ 469, 344, 460, 109, 917, 107, 460, 331, 427, 333,
172299 /* 1110 */ 572, 1179, 411, 531, 1438, 1139, 126, 127, 81, 1219,
172300 /* 1120 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172301 /* 1130 */ 125, 1564, 411, 136, 136, 6, 126, 127, 81, 1219,
172302 /* 1140 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172303 /* 1150 */ 125, 152, 371, 1583, 1500, 887, 126, 115, 81, 1219,
172304 /* 1160 */ 1219, 1055, 1058, 1045, 1045, 124, 124, 125, 125, 125,
172305 /* 1170 */ 125, 457, 1500, 1502, 478, 123, 123, 123, 123, 122,
172306 /* 1180 */ 122, 121, 121, 121, 120, 117, 448, 500, 868, 1214,
172307 /* 1190 */ 303, 332, 454, 557, 1160, 123, 123, 123, 123, 122,
172308 /* 1200 */ 122, 121, 121, 121, 120, 117, 448, 1160, 1562, 572,
172309 /* 1210 */ 1160, 543, 6, 572, 258, 123, 123, 123, 123, 122,
172310 /* 1220 */ 122, 121, 121, 121, 120, 117, 448, 1032, 286, 286,
172311 /* 1230 */ 542, 572, 56, 56, 1561, 411, 57, 57, 6, 1171,
172312 /* 1240 */ 474, 569, 478, 295, 1021, 1500, 868, 295, 1020, 294,
172313 /* 1250 */ 495, 264, 1099, 572, 15, 15, 1099, 1195, 396, 1240,
172314 /* 1260 */ 127, 81, 1219, 1219, 1055, 1058, 1045, 1045, 124, 124,
172315 /* 1270 */ 125, 125, 125, 125, 1160, 218, 44, 44, 572, 1118,
172316 /* 1280 */ 1020, 1020, 1022, 416, 572, 544, 1215, 1160, 490, 572,
172317 /* 1290 */ 1160, 1171, 1424, 373, 1119, 349, 478, 1539, 529, 361,
172318 /* 1300 */ 322, 58, 58, 235, 516, 478, 219, 45, 45, 1120,
172319 /* 1310 */ 1179, 572, 59, 59, 1195, 1196, 1195, 297, 123, 123,
172320 /* 1320 */ 123, 123, 122, 122, 121, 121, 121, 120, 117, 448,
172321 /* 1330 */ 560, 936, 440, 572, 60, 60, 935, 1241, 112, 564,
172322 /* 1340 */ 572, 4, 572, 535, 1215, 572, 1424, 1424, 1235, 572,
172323 /* 1350 */ 961, 396, 1140, 572, 31, 567, 61, 61, 112, 564,
172324 /* 1360 */ 572, 4, 428, 62, 62, 63, 63, 8, 46, 46,
172325 /* 1370 */ 572, 300, 47, 47, 17, 567, 48, 48, 449, 572,
172326 /* 1380 */ 302, 975, 572, 50, 50, 32, 1273, 417, 572, 976,
172327 /* 1390 */ 561, 572, 258, 51, 51, 530, 883, 572, 449, 572,
172328 /* 1400 */ 565, 417, 64, 64, 539, 65, 65, 323, 572, 538,
172329 /* 1410 */ 561, 66, 66, 422, 14, 14, 491, 441, 572, 1032,
172330 /* 1420 */ 67, 67, 132, 132, 539, 110, 110, 326, 550, 540,
172331 /* 1430 */ 1241, 133, 133, 111, 462, 449, 573, 449, 482, 1032,
172332 /* 1440 */ 1020, 68, 68, 230, 409, 110, 110, 150, 114, 112,
172333 /* 1450 */ 564, 1336, 4, 111, 883, 449, 573, 449, 572, 239,
172334 /* 1460 */ 1020, 416, 572, 569, 572, 1369, 567, 572, 961, 318,
172335 /* 1470 */ 563, 525, 1020, 1020, 1022, 1023, 28, 1301, 418, 179,
172336 /* 1480 */ 1368, 53, 53, 285, 228, 69, 69, 70, 70, 449,
172337 /* 1490 */ 54, 54, 1020, 1020, 1022, 1023, 28, 87, 215, 290,
172338 /* 1500 */ 471, 561, 1179, 475, 394, 394, 393, 275, 391, 572,
172339 /* 1510 */ 409, 853, 153, 409, 39, 539, 572, 317, 470, 1136,
172340 /* 1520 */ 538, 398, 1179, 291, 236, 1300, 325, 409, 463, 572,
172341 /* 1530 */ 1032, 201, 165, 165, 324, 483, 110, 110, 572, 166,
172342 /* 1540 */ 166, 339, 112, 564, 111, 4, 449, 573, 449, 1145,
172343 /* 1550 */ 572, 1020, 77, 77, 572, 1546, 572, 321, 472, 567,
172344 /* 1560 */ 335, 55, 55, 340, 238, 101, 1519, 1013, 550, 263,
172345 /* 1570 */ 895, 894, 170, 73, 73, 142, 241, 135, 135, 74,
172346 /* 1580 */ 74, 298, 449, 1020, 1020, 1022, 1023, 28, 1589, 1183,
172347 /* 1590 */ 451, 1518, 237, 290, 561, 161, 1084, 101, 394, 394,
172348 /* 1600 */ 393, 275, 391, 487, 477, 853, 263, 479, 345, 263,
172349 /* 1610 */ 101, 346, 501, 1179, 260, 902, 903, 559, 236, 572,
172350 /* 1620 */ 325, 112, 564, 1032, 4, 369, 572, 412, 324, 110,
172351 /* 1630 */ 110, 940, 318, 563, 1024, 368, 572, 111, 567, 449,
172352 /* 1640 */ 573, 449, 163, 163, 1020, 1365, 359, 572, 101, 137,
172353 /* 1650 */ 137, 572, 350, 1080, 1084, 260, 455, 353, 238, 131,
172354 /* 1660 */ 131, 449, 966, 933, 263, 114, 170, 572, 355, 142,
172355 /* 1670 */ 164, 164, 1299, 561, 157, 157, 1020, 1020, 1022, 1023,
172356 /* 1680 */ 28, 572, 978, 979, 1577, 866, 237, 151, 496, 572,
172357 /* 1690 */ 141, 141, 1024, 80, 564, 1096, 4, 1096, 1095, 357,
172358 /* 1700 */ 1095, 572, 1032, 1315, 140, 140, 1179, 364, 110, 110,
172359 /* 1710 */ 567, 572, 138, 138, 374, 572, 111, 1348, 449, 573,
172360 /* 1720 */ 449, 412, 1378, 1020, 139, 139, 318, 563, 572, 934,
172361 /* 1730 */ 1423, 114, 1351, 449, 76, 76, 278, 572, 78, 78,
172362 /* 1740 */ 572, 1363, 552, 558, 1428, 561, 1280, 1271, 1259, 1258,
172363 /* 1750 */ 455, 75, 75, 1260, 1597, 1020, 1020, 1022, 1023, 28,
172364 /* 1760 */ 43, 43, 213, 49, 49, 395, 310, 311, 312, 11,
172365 /* 1770 */ 234, 221, 1410, 293, 1032, 337, 1405, 338, 1415, 299,
172366 /* 1780 */ 110, 110, 1398, 481, 506, 1179, 367, 1414, 111, 1491,
172367 /* 1790 */ 449, 573, 449, 1183, 451, 1020, 402, 290, 225, 1490,
172368 /* 1800 */ 1298, 1360, 394, 394, 393, 275, 391, 343, 1361, 853,
172369 /* 1810 */ 562, 1359, 206, 389, 551, 207, 1600, 1358, 1235, 267,
172370 /* 1820 */ 220, 1538, 236, 1536, 325, 1232, 82, 1020, 1020, 1022,
172371 /* 1830 */ 1023, 28, 324, 181, 420, 86, 217, 232, 190, 175,
172372 /* 1840 */ 183, 465, 185, 466, 1411, 186, 244, 112, 564, 36,
172373 /* 1850 */ 4, 187, 188, 85, 1496, 499, 99, 1179, 400, 1417,
172374 /* 1860 */ 1416, 37, 238, 473, 567, 403, 1419, 194, 1485, 488,
172375 /* 1870 */ 170, 248, 92, 142, 1507, 494, 279, 250, 198, 497,
172376 /* 1880 */ 352, 348, 251, 405, 1261, 252, 515, 449, 1318, 1317,
172377 /* 1890 */ 237, 1316, 1309, 434, 94, 887, 226, 438, 1614, 561,
172378 /* 1900 */ 1288, 1613, 406, 524, 439, 1582, 265, 366, 1287, 1286,
172379 /* 1910 */ 1612, 308, 309, 266, 372, 442, 1568, 1308, 1567, 1383,
172380 /* 1920 */ 1382, 129, 550, 10, 383, 412, 1472, 316, 1032, 100,
172381 /* 1930 */ 318, 563, 106, 35, 110, 110, 534, 575, 1189, 274,
172382 /* 1940 */ 276, 388, 111, 381, 449, 573, 449, 1341, 1340, 1020,
172383 /* 1950 */ 212, 387, 277, 576, 455, 1256, 1251, 167, 148, 413,
172384 /* 1960 */ 414, 180, 1523, 168, 1524, 1522, 1521, 840, 222, 306,
172385 /* 1970 */ 450, 223, 169, 79, 214, 320, 233, 1094, 145, 1092,
172386 /* 1980 */ 328, 1020, 1020, 1022, 1023, 28, 182, 171, 184, 1214,
172387 /* 1990 */ 240, 919, 243, 336, 1108, 189, 172, 173, 423, 174,
172388 /* 2000 */ 191, 88, 425, 89, 90, 1111, 91, 245, 1107, 246,
172389 /* 2010 */ 159, 1179, 18, 247, 263, 347, 1229, 1100, 249, 493,
172390 /* 2020 */ 196, 38, 855, 195, 368, 498, 197, 253, 510, 885,
172391 /* 2030 */ 93, 19, 176, 360, 20, 502, 507, 363, 95, 898,
172392 /* 2040 */ 160, 307, 518, 96, 1176, 1061, 1147, 40, 21, 97,
172393 /* 2050 */ 227, 282, 284, 262, 1146, 970, 200, 964, 114, 1166,
172394 /* 2060 */ 22, 23, 1164, 1162, 24, 25, 1170, 1151, 34, 26,
172395 /* 2070 */ 204, 546, 1169, 101, 27, 103, 7, 104, 1075, 1062,
172396 /* 2080 */ 1060, 1064, 1117, 1065, 1116, 268, 269, 29, 41, 1185,
172397 /* 2090 */ 1025, 867, 113, 30, 568, 929, 392, 144, 178, 270,
172398 /* 2100 */ 271, 1184, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247,
172399 /* 2110 */ 1247, 1247, 1247, 1605,
 
 
 
172400 };
172401 static const YYCODETYPE yy_lookahead[] = {
172402 /* 0 */ 194, 194, 194, 275, 276, 277, 194, 275, 276, 277,
172403 /* 10 */ 194, 224, 220, 226, 207, 211, 212, 213, 194, 19,
172404 /* 20 */ 220, 234, 217, 217, 218, 217, 218, 194, 296, 217,
172405 /* 30 */ 218, 31, 194, 217, 218, 194, 229, 214, 231, 39,
172406 /* 40 */ 207, 217, 218, 43, 44, 45, 46, 47, 48, 49,
172407 /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 194, 19,
172408 /* 60 */ 186, 187, 188, 189, 190, 191, 254, 275, 276, 277,
172409 /* 70 */ 196, 194, 198, 194, 262, 275, 276, 277, 254, 205,
172410 /* 80 */ 239, 205, 81, 43, 44, 45, 46, 47, 48, 49,
172411 /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 275, 276,
172412 /* 100 */ 277, 263, 102, 103, 104, 105, 106, 107, 108, 109,
172413 /* 110 */ 110, 111, 112, 113, 240, 241, 240, 241, 211, 212,
172414 /* 120 */ 213, 315, 316, 315, 59, 317, 86, 253, 88, 253,
172415 /* 130 */ 19, 315, 316, 257, 258, 113, 25, 72, 297, 138,
172416 /* 140 */ 139, 267, 102, 103, 104, 105, 106, 107, 108, 109,
172417 /* 150 */ 110, 111, 112, 113, 43, 44, 45, 46, 47, 48,
172418 /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 81,
172419 /* 170 */ 293, 59, 293, 299, 108, 109, 110, 111, 112, 113,
172420 /* 180 */ 69, 116, 117, 118, 72, 106, 107, 194, 111, 112,
172421 /* 190 */ 113, 54, 55, 56, 57, 58, 102, 103, 104, 105,
172422 /* 200 */ 106, 107, 108, 109, 110, 111, 112, 113, 120, 217,
172423 /* 210 */ 217, 218, 22, 102, 103, 104, 105, 106, 107, 108,
172424 /* 220 */ 109, 110, 111, 112, 113, 232, 138, 139, 116, 117,
172425 /* 230 */ 118, 23, 153, 19, 155, 54, 55, 56, 57, 102,
172426 /* 240 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172427 /* 250 */ 113, 128, 129, 46, 47, 48, 49, 43, 44, 45,
172428 /* 260 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
172429 /* 270 */ 56, 57, 127, 128, 129, 59, 194, 19, 165, 166,
172430 /* 280 */ 194, 67, 24, 102, 103, 104, 105, 106, 107, 108,
172431 /* 290 */ 109, 110, 111, 112, 113, 73, 106, 107, 59, 217,
172432 /* 300 */ 218, 43, 44, 45, 46, 47, 48, 49, 50, 51,
172433 /* 310 */ 52, 53, 54, 55, 56, 57, 102, 103, 104, 105,
172434 /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 121, 23,
172435 /* 330 */ 59, 25, 116, 117, 118, 119, 254, 205, 122, 123,
172436 /* 340 */ 124, 19, 20, 134, 22, 136, 137, 19, 132, 127,
172437 /* 350 */ 128, 129, 24, 145, 194, 116, 117, 118, 36, 194,
172438 /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
172439 /* 370 */ 112, 113, 240, 241, 7, 8, 9, 106, 107, 59,
172440 /* 380 */ 19, 59, 217, 218, 214, 253, 115, 116, 117, 118,
172441 /* 390 */ 151, 120, 26, 71, 274, 309, 310, 194, 194, 128,
172442 /* 400 */ 314, 217, 270, 81, 43, 44, 45, 46, 47, 48,
172443 /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 254,
172444 /* 420 */ 217, 218, 100, 95, 153, 59, 155, 262, 106, 107,
172445 /* 430 */ 25, 194, 312, 313, 194, 232, 114, 117, 116, 117,
172446 /* 440 */ 118, 113, 194, 121, 284, 205, 242, 119, 120, 121,
172447 /* 450 */ 122, 123, 124, 125, 217, 218, 194, 217, 218, 131,
172448 /* 460 */ 138, 139, 292, 102, 103, 104, 105, 106, 107, 108,
172449 /* 470 */ 109, 110, 111, 112, 113, 153, 154, 155, 156, 157,
172450 /* 480 */ 240, 241, 116, 117, 118, 76, 231, 194, 19, 216,
172451 /* 490 */ 242, 254, 23, 253, 254, 202, 87, 224, 89, 262,
172452 /* 500 */ 207, 92, 262, 310, 194, 183, 194, 314, 22, 305,
172453 /* 510 */ 24, 150, 43, 44, 45, 46, 47, 48, 49, 50,
172454 /* 520 */ 51, 52, 53, 54, 55, 56, 57, 217, 218, 217,
172455 /* 530 */ 218, 19, 189, 119, 191, 23, 122, 123, 124, 196,
172456 /* 540 */ 25, 198, 232, 73, 232, 59, 132, 142, 205, 236,
172457 /* 550 */ 237, 81, 194, 305, 145, 43, 44, 45, 46, 47,
172458 /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172459 /* 570 */ 308, 102, 103, 104, 105, 106, 107, 108, 109, 110,
172460 /* 580 */ 111, 112, 113, 240, 241, 106, 107, 108, 109, 110,
172461 /* 590 */ 111, 112, 113, 194, 59, 194, 253, 127, 59, 250,
172462 /* 600 */ 242, 252, 19, 117, 194, 194, 23, 22, 138, 139,
172463 /* 610 */ 267, 22, 236, 237, 102, 103, 104, 105, 106, 107,
172464 /* 620 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172465 /* 630 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172466 /* 640 */ 57, 19, 299, 108, 59, 23, 194, 194, 59, 194,
172467 /* 650 */ 21, 116, 117, 118, 194, 116, 117, 118, 206, 204,
172468 /* 660 */ 194, 206, 22, 305, 149, 43, 44, 45, 46, 47,
172469 /* 670 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172470 /* 680 */ 259, 199, 143, 217, 218, 102, 103, 104, 105, 106,
172471 /* 690 */ 107, 108, 109, 110, 111, 112, 113, 194, 232, 59,
172472 /* 700 */ 194, 116, 117, 118, 59, 116, 117, 118, 59, 80,
172473 /* 710 */ 309, 310, 19, 194, 194, 314, 23, 22, 307, 308,
172474 /* 720 */ 217, 218, 22, 263, 102, 103, 104, 105, 106, 107,
172475 /* 730 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172476 /* 740 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172477 /* 750 */ 57, 19, 123, 233, 59, 23, 116, 117, 118, 59,
172478 /* 760 */ 194, 116, 117, 118, 282, 116, 117, 118, 286, 263,
172479 /* 770 */ 194, 194, 194, 302, 303, 43, 44, 45, 46, 47,
172480 /* 780 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172481 /* 790 */ 161, 194, 143, 217, 218, 102, 103, 104, 105, 106,
172482 /* 800 */ 107, 108, 109, 110, 111, 112, 113, 194, 232, 194,
172483 /* 810 */ 194, 116, 117, 118, 217, 218, 116, 117, 118, 242,
172484 /* 820 */ 25, 270, 19, 23, 305, 25, 23, 194, 205, 232,
172485 /* 830 */ 205, 35, 217, 218, 102, 103, 104, 105, 106, 107,
172486 /* 840 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172487 /* 850 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172488 /* 860 */ 57, 19, 66, 240, 241, 240, 241, 240, 241, 254,
172489 /* 870 */ 74, 240, 241, 245, 25, 115, 253, 264, 253, 194,
172490 /* 880 */ 253, 22, 305, 255, 253, 43, 44, 45, 46, 47,
172491 /* 890 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172492 /* 900 */ 194, 214, 217, 218, 144, 102, 103, 104, 105, 106,
172493 /* 910 */ 107, 108, 109, 110, 111, 112, 113, 232, 118, 188,
172494 /* 920 */ 189, 190, 191, 217, 218, 76, 130, 196, 16, 198,
172495 /* 930 */ 194, 310, 19, 138, 139, 314, 205, 194, 89, 260,
172496 /* 940 */ 261, 92, 205, 143, 102, 103, 104, 105, 106, 107,
172497 /* 950 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172498 /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172499 /* 970 */ 57, 240, 241, 194, 287, 239, 19, 240, 241, 292,
172500 /* 980 */ 127, 128, 129, 11, 253, 279, 194, 59, 19, 77,
172501 /* 990 */ 253, 79, 22, 23, 227, 25, 217, 218, 267, 205,
172502 /* 1000 */ 141, 159, 45, 46, 47, 48, 49, 50, 51, 52,
172503 /* 1010 */ 53, 54, 55, 56, 57, 102, 103, 104, 105, 106,
172504 /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 194, 100, 194,
172505 /* 1030 */ 299, 239, 194, 254, 240, 241, 22, 23, 194, 25,
172506 /* 1040 */ 205, 194, 205, 12, 116, 117, 16, 253, 194, 121,
172507 /* 1050 */ 217, 218, 217, 218, 25, 217, 218, 274, 27, 102,
172508 /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172509 /* 1070 */ 113, 101, 159, 42, 135, 240, 241, 240, 241, 140,
172510 /* 1080 */ 194, 153, 154, 155, 115, 116, 239, 254, 253, 254,
172511 /* 1090 */ 253, 194, 19, 239, 63, 312, 313, 24, 212, 213,
172512 /* 1100 */ 128, 129, 261, 158, 73, 160, 265, 77, 264, 79,
172513 /* 1110 */ 194, 183, 19, 144, 274, 101, 43, 44, 45, 46,
172514 /* 1120 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172515 /* 1130 */ 57, 310, 19, 217, 218, 314, 43, 44, 45, 46,
172516 /* 1140 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172517 /* 1150 */ 57, 22, 312, 313, 194, 126, 43, 44, 45, 46,
172518 /* 1160 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172519 /* 1170 */ 57, 285, 212, 213, 194, 102, 103, 104, 105, 106,
172520 /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 19, 59, 25,
172521 /* 1190 */ 293, 161, 194, 205, 76, 102, 103, 104, 105, 106,
172522 /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 89, 310, 194,
172523 /* 1210 */ 92, 66, 314, 194, 46, 102, 103, 104, 105, 106,
172524 /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 100, 240, 241,
172525 /* 1230 */ 85, 194, 217, 218, 310, 19, 217, 218, 314, 94,
172526 /* 1240 */ 115, 253, 194, 261, 117, 285, 117, 265, 121, 269,
172527 /* 1250 */ 194, 24, 29, 194, 217, 218, 33, 59, 22, 23,
172528 /* 1260 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
172529 /* 1270 */ 54, 55, 56, 57, 76, 150, 217, 218, 194, 12,
172530 /* 1280 */ 153, 154, 155, 115, 194, 87, 59, 89, 65, 194,
172531 /* 1290 */ 92, 146, 194, 194, 27, 239, 194, 194, 19, 131,
172532 /* 1300 */ 194, 217, 218, 15, 108, 194, 142, 217, 218, 42,
172533 /* 1310 */ 183, 194, 217, 218, 116, 117, 118, 269, 102, 103,
172534 /* 1320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
172535 /* 1330 */ 63, 135, 233, 194, 217, 218, 140, 101, 19, 20,
172536 /* 1340 */ 194, 22, 194, 145, 117, 194, 194, 194, 60, 194,
172537 /* 1350 */ 25, 22, 23, 194, 22, 36, 217, 218, 19, 20,
172538 /* 1360 */ 194, 22, 264, 217, 218, 217, 218, 48, 217, 218,
172539 /* 1370 */ 194, 269, 217, 218, 22, 36, 217, 218, 59, 194,
172540 /* 1380 */ 269, 31, 194, 217, 218, 53, 209, 210, 194, 39,
172541 /* 1390 */ 71, 194, 46, 217, 218, 116, 59, 194, 59, 194,
172542 /* 1400 */ 209, 210, 217, 218, 85, 217, 218, 194, 194, 90,
172543 /* 1410 */ 71, 217, 218, 61, 217, 218, 264, 264, 194, 100,
172544 /* 1420 */ 217, 218, 217, 218, 85, 106, 107, 194, 145, 90,
172545 /* 1430 */ 101, 217, 218, 114, 245, 116, 117, 118, 19, 100,
172546 /* 1440 */ 121, 217, 218, 118, 255, 106, 107, 164, 25, 19,
172547 /* 1450 */ 20, 241, 22, 114, 117, 116, 117, 118, 194, 24,
172548 /* 1460 */ 121, 115, 194, 253, 194, 194, 36, 194, 143, 138,
172549 /* 1470 */ 139, 19, 153, 154, 155, 156, 157, 227, 300, 301,
172550 /* 1480 */ 194, 217, 218, 257, 258, 217, 218, 217, 218, 59,
172551 /* 1490 */ 217, 218, 153, 154, 155, 156, 157, 149, 150, 5,
172552 /* 1500 */ 245, 71, 183, 245, 10, 11, 12, 13, 14, 194,
172553 /* 1510 */ 255, 17, 22, 255, 24, 85, 194, 245, 129, 23,
172554 /* 1520 */ 90, 25, 183, 99, 30, 227, 32, 255, 194, 194,
172555 /* 1530 */ 100, 256, 217, 218, 40, 116, 106, 107, 194, 217,
172556 /* 1540 */ 218, 152, 19, 20, 114, 22, 116, 117, 118, 97,
172557 /* 1550 */ 194, 121, 217, 218, 194, 194, 194, 133, 129, 36,
172558 /* 1560 */ 194, 217, 218, 23, 70, 25, 194, 23, 145, 25,
172559 /* 1570 */ 120, 121, 78, 217, 218, 81, 141, 217, 218, 217,
172560 /* 1580 */ 218, 152, 59, 153, 154, 155, 156, 157, 0, 1,
172561 /* 1590 */ 2, 194, 98, 5, 71, 23, 59, 25, 10, 11,
172562 /* 1600 */ 12, 13, 14, 194, 23, 17, 25, 23, 23, 25,
172563 /* 1610 */ 25, 194, 23, 183, 25, 7, 8, 237, 30, 194,
172564 /* 1620 */ 32, 19, 20, 100, 22, 121, 194, 133, 40, 106,
172565 /* 1630 */ 107, 108, 138, 139, 59, 131, 194, 114, 36, 116,
172566 /* 1640 */ 117, 118, 217, 218, 121, 194, 23, 194, 25, 217,
172567 /* 1650 */ 218, 194, 194, 23, 117, 25, 162, 194, 70, 217,
172568 /* 1660 */ 218, 59, 23, 23, 25, 25, 78, 194, 194, 81,
172569 /* 1670 */ 217, 218, 194, 71, 217, 218, 153, 154, 155, 156,
172570 /* 1680 */ 157, 194, 83, 84, 319, 23, 98, 25, 289, 194,
172571 /* 1690 */ 217, 218, 117, 19, 20, 153, 22, 155, 153, 194,
172572 /* 1700 */ 155, 194, 100, 194, 217, 218, 183, 194, 106, 107,
172573 /* 1710 */ 36, 194, 217, 218, 194, 194, 114, 256, 116, 117,
172574 /* 1720 */ 118, 133, 194, 121, 217, 218, 138, 139, 194, 23,
172575 /* 1730 */ 194, 25, 194, 59, 217, 218, 288, 194, 217, 218,
172576 /* 1740 */ 194, 194, 140, 194, 194, 71, 194, 194, 194, 194,
172577 /* 1750 */ 162, 217, 218, 194, 194, 153, 154, 155, 156, 157,
172578 /* 1760 */ 217, 218, 243, 217, 218, 192, 256, 256, 256, 244,
172579 /* 1770 */ 298, 215, 272, 246, 100, 294, 268, 247, 272, 247,
172580 /* 1780 */ 106, 107, 268, 294, 221, 183, 220, 272, 114, 220,
172581 /* 1790 */ 116, 117, 118, 1, 2, 121, 272, 5, 230, 220,
172582 /* 1800 */ 226, 260, 10, 11, 12, 13, 14, 246, 260, 17,
172583 /* 1810 */ 281, 260, 250, 246, 140, 250, 197, 260, 60, 141,
172584 /* 1820 */ 244, 201, 30, 201, 32, 38, 295, 153, 154, 155,
172585 /* 1830 */ 156, 157, 40, 298, 201, 151, 150, 298, 22, 43,
172586 /* 1840 */ 235, 18, 238, 201, 273, 238, 200, 19, 20, 271,
172587 /* 1850 */ 22, 238, 238, 295, 284, 18, 149, 183, 247, 273,
172588 /* 1860 */ 273, 271, 70, 247, 36, 247, 235, 235, 247, 201,
172589 /* 1870 */ 78, 200, 158, 81, 291, 62, 201, 200, 22, 222,
172590 /* 1880 */ 201, 290, 200, 222, 201, 200, 115, 59, 219, 219,
172591 /* 1890 */ 98, 219, 228, 64, 22, 126, 165, 24, 225, 71,
172592 /* 1900 */ 219, 225, 222, 306, 113, 313, 201, 219, 221, 219,
172593 /* 1910 */ 219, 283, 283, 91, 222, 82, 318, 228, 318, 266,
172594 /* 1920 */ 266, 148, 145, 22, 201, 133, 278, 280, 100, 147,
172595 /* 1930 */ 138, 139, 158, 25, 106, 107, 146, 203, 13, 195,
172596 /* 1940 */ 195, 247, 114, 250, 116, 117, 118, 251, 251, 121,
172597 /* 1950 */ 249, 248, 6, 193, 162, 193, 193, 208, 223, 304,
172598 /* 1960 */ 304, 301, 214, 208, 214, 214, 214, 4, 215, 223,
172599 /* 1970 */ 3, 215, 208, 214, 22, 163, 15, 23, 16, 23,
172600 /* 1980 */ 139, 153, 154, 155, 156, 157, 151, 130, 142, 25,
172601 /* 1990 */ 24, 20, 144, 16, 1, 142, 130, 130, 61, 130,
172602 /* 2000 */ 151, 53, 37, 53, 53, 116, 53, 34, 1, 141,
172603 /* 2010 */ 5, 183, 22, 115, 25, 161, 75, 68, 141, 41,
172604 /* 2020 */ 115, 24, 20, 68, 131, 19, 22, 125, 96, 59,
172605 /* 2030 */ 22, 22, 37, 23, 22, 67, 67, 24, 22, 28,
172606 /* 2040 */ 23, 67, 22, 149, 23, 23, 23, 22, 34, 25,
172607 /* 2050 */ 141, 23, 23, 34, 97, 116, 22, 143, 25, 75,
172608 /* 2060 */ 34, 34, 86, 88, 34, 34, 75, 23, 22, 34,
172609 /* 2070 */ 25, 24, 93, 25, 34, 142, 44, 142, 23, 23,
172610 /* 2080 */ 23, 23, 23, 11, 23, 25, 22, 22, 22, 1,
172611 /* 2090 */ 23, 23, 22, 22, 25, 135, 15, 23, 25, 141,
172612 /* 2100 */ 141, 1, 320, 320, 320, 320, 320, 320, 320, 320,
172613 /* 2110 */ 320, 320, 320, 141, 320, 320, 320, 320, 320, 320,
172614 /* 2120 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172615 /* 2130 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172616 /* 2140 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172617 /* 2150 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172618 /* 2160 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172619 /* 2170 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172620 /* 2180 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172621 /* 2190 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172622 /* 2200 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172623 /* 2210 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172624 /* 2220 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172625 /* 2230 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172626 /* 2240 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172627 /* 2250 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172628 /* 2260 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172629 /* 2270 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172630 /* 2280 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172631 /* 2290 */ 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,
172632 };
172633 #define YY_SHIFT_COUNT (578)
 
 
 
172634 #define YY_SHIFT_MIN (0)
172635 #define YY_SHIFT_MAX (2100)
172636 static const unsigned short int yy_shift_ofst[] = {
172637 /* 0 */ 1792, 1588, 1494, 322, 322, 1, 1319, 1339, 1430, 1828,
172638 /* 10 */ 1828, 1828, 470, 0, 0, 214, 1093, 1828, 1828, 1828,
172639 /* 20 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172640 /* 30 */ 1828, 271, 271, 1198, 1198, 216, 88, 1, 1, 1,
172641 /* 40 */ 1, 1, 40, 111, 258, 361, 469, 512, 583, 622,
172642 /* 50 */ 693, 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093,
172643 /* 60 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
172644 /* 70 */ 1093, 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1523,
172645 /* 80 */ 1602, 1674, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172646 /* 90 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172647 /* 100 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172648 /* 110 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172649 /* 120 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172650 /* 130 */ 1828, 137, 181, 181, 181, 181, 181, 181, 181, 94,
172651 /* 140 */ 479, 66, 65, 112, 366, 645, 645, 629, 1168, 645,
172652 /* 150 */ 645, 79, 79, 645, 795, 795, 795, 77, 795, 123,
172653 /* 160 */ 113, 113, 113, 22, 22, 2114, 2114, 328, 328, 328,
172654 /* 170 */ 239, 585, 585, 585, 585, 1031, 1031, 409, 366, 970,
172655 /* 180 */ 1014, 645, 645, 645, 645, 645, 645, 645, 645, 645,
172656 /* 190 */ 645, 645, 645, 645, 645, 645, 645, 645, 645, 645,
172657 /* 200 */ 645, 969, 849, 849, 645, 972, 1118, 1118, 1279, 1279,
172658 /* 210 */ 320, 320, 1283, 1331, 2114, 2114, 2114, 2114, 2114, 2114,
172659 /* 220 */ 2114, 928, 1127, 1127, 589, 414, 640, 535, 695, 539,
172660 /* 230 */ 649, 700, 645, 645, 645, 645, 645, 645, 645, 645,
172661 /* 240 */ 645, 645, 222, 645, 645, 645, 645, 645, 645, 645,
172662 /* 250 */ 645, 645, 645, 645, 645, 796, 796, 796, 645, 645,
172663 /* 260 */ 645, 800, 645, 645, 645, 486, 1145, 645, 645, 1267,
172664 /* 270 */ 645, 645, 645, 645, 645, 645, 645, 645, 145, 1223,
172665 /* 280 */ 209, 1227, 1227, 1227, 1227, 1325, 209, 209, 1196, 190,
172666 /* 290 */ 367, 1288, 1125, 1348, 405, 1348, 1419, 515, 1125, 1125,
172667 /* 300 */ 515, 1125, 405, 1419, 1029, 306, 1346, 1350, 1350, 1350,
172668 /* 310 */ 760, 760, 760, 760, 1423, 1423, 945, 1164, 939, 1490,
172669 /* 320 */ 1758, 1758, 1678, 1678, 1787, 1787, 1678, 1684, 1686, 1816,
172670 /* 330 */ 1796, 1823, 1823, 1823, 1823, 1678, 1837, 1707, 1686, 1686,
172671 /* 340 */ 1707, 1816, 1796, 1707, 1796, 1707, 1678, 1837, 1714, 1813,
172672 /* 350 */ 1678, 1837, 1856, 1678, 1837, 1678, 1837, 1856, 1771, 1771,
172673 /* 360 */ 1771, 1829, 1872, 1872, 1856, 1771, 1769, 1771, 1829, 1771,
172674 /* 370 */ 1771, 1731, 1873, 1791, 1791, 1856, 1678, 1822, 1822, 1833,
172675 /* 380 */ 1833, 1773, 1777, 1901, 1678, 1774, 1773, 1782, 1790, 1707,
172676 /* 390 */ 1908, 1925, 1925, 1946, 1946, 1946, 2114, 2114, 2114, 2114,
172677 /* 400 */ 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114, 2114,
172678 /* 410 */ 2114, 207, 1030, 1236, 1329, 912, 853, 1129, 1496, 1424,
172679 /* 420 */ 1332, 1435, 1389, 1429, 1540, 1352, 1544, 1581, 1584, 1585,
172680 /* 430 */ 1589, 1623, 1337, 1450, 1608, 1504, 1572, 208, 1452, 1537,
172681 /* 440 */ 1630, 1639, 1599, 1640, 1542, 1545, 1662, 1706, 1575, 859,
172682 /* 450 */ 1963, 1967, 1952, 1812, 1961, 1962, 1954, 1956, 1841, 1835,
172683 /* 460 */ 1857, 1964, 1964, 1966, 1846, 1971, 1848, 1977, 1993, 1853,
172684 /* 470 */ 1866, 1964, 1867, 1937, 1965, 1964, 1849, 1948, 1950, 1951,
172685 /* 480 */ 1953, 1869, 1889, 1973, 1868, 2007, 2005, 1990, 1898, 1854,
172686 /* 490 */ 1949, 1989, 1955, 1941, 1978, 1877, 1905, 1997, 2002, 2006,
172687 /* 500 */ 1893, 1902, 2004, 1968, 2008, 2009, 2010, 2012, 1969, 1970,
172688 /* 510 */ 2013, 1932, 2011, 2016, 1974, 1995, 2017, 2014, 1894, 2020,
172689 /* 520 */ 2021, 2022, 2024, 2023, 2025, 1957, 1909, 2028, 2029, 1939,
172690 /* 530 */ 2019, 2034, 1914, 2033, 2026, 2027, 2030, 2031, 1975, 1984,
172691 /* 540 */ 1976, 2032, 1991, 1979, 2035, 2044, 2046, 2047, 2045, 2048,
172692 /* 550 */ 2040, 1933, 1935, 2055, 2033, 2056, 2057, 2058, 2059, 2060,
172693 /* 560 */ 2061, 2064, 2072, 2065, 2066, 2067, 2068, 2070, 2071, 2069,
172694 /* 570 */ 1960, 1958, 1959, 1972, 2073, 2074, 2081, 2088, 2100,
 
172695 };
172696 #define YY_REDUCE_COUNT (410)
172697 #define YY_REDUCE_MIN (-272)
172698 #define YY_REDUCE_MAX (1764)
172699 static const short yy_reduce_ofst[] = {
172700 /* 0 */ -126, 731, 343, 240, 835, -124, -194, -192, -184, -188,
172701 /* 10 */ 165, 237, 132, -208, -200, -268, -177, -7, 203, 310,
172702 /* 20 */ 312, 466, -176, 576, 597, 82, 615, 685, 706, 779,
172703 /* 30 */ 833, 886, 960, 86, 401, -193, 623, 625, 737, 794,
172704 /* 40 */ 837, 988, -272, -272, -272, -272, -272, -272, -272, -272,
172705 /* 50 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172706 /* 60 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172707 /* 70 */ -272, -272, -272, -272, -272, -272, -272, -272, -272, 503,
172708 /* 80 */ 838, 916, 1015, 1019, 1037, 1059, 1084, 1090, 1095, 1117,
172709 /* 90 */ 1139, 1146, 1148, 1151, 1155, 1159, 1166, 1176, 1185, 1188,
172710 /* 100 */ 1194, 1197, 1203, 1205, 1214, 1224, 1264, 1268, 1270, 1273,
172711 /* 110 */ 1315, 1322, 1335, 1344, 1356, 1360, 1362, 1425, 1432, 1442,
172712 /* 120 */ 1453, 1457, 1473, 1487, 1495, 1507, 1517, 1521, 1534, 1543,
172713 /* 130 */ 1546, -272, -272, -272, -272, -272, -272, -272, -272, -272,
172714 /* 140 */ -272, -272, 204, 248, 455, -159, 358, 482, -213, 577,
172715 /* 150 */ 411, -196, -93, 293, 627, 631, 627, -272, 631, 687,
172716 /* 160 */ 120, 783, 840, -272, -272, -272, -272, 273, 273, 273,
172717 /* 170 */ 160, 980, 1048, 1102, 1111, 313, 376, 193, 452, 471,
172718 /* 180 */ 471, -167, -162, 460, 506, 736, 792, 847, 854, -123,
172719 /* 190 */ 613, -121, 844, 1098, 897, 1152, 1056, 520, 1099, 519,
172720 /* 200 */ 1153, 679, 621, 821, 262, 170, 898, 924, 841, 982,
172721 /* 210 */ 1177, 1191, 349, 1210, 1178, 628, 1189, 1255, 1258, 1226,
172722 /* 220 */ 1272, -195, -8, 184, -136, 255, 399, 410, 453, 566,
172723 /* 230 */ 578, 616, 633, 743, 998, 1103, 1106, 1213, 1233, 1271,
172724 /* 240 */ 1286, 1334, 551, 1361, 1366, 1372, 1397, 1409, 1417, 1451,
172725 /* 250 */ 1458, 1463, 1474, 1505, 1509, 767, 1250, 1298, 1478, 1513,
172726 /* 260 */ 1520, 421, 1528, 1536, 1538, 1275, 1365, 1547, 1549, 1380,
172727 /* 270 */ 1550, 410, 1552, 1553, 1554, 1555, 1559, 1560, 1399, 1448,
172728 /* 280 */ 1519, 1461, 1510, 1511, 1512, 421, 1519, 1519, 1525, 1556,
172729 /* 290 */ 1573, 1472, 1500, 1508, 1527, 1514, 1481, 1530, 1506, 1515,
172730 /* 300 */ 1532, 1524, 1561, 1489, 1563, 1568, 1574, 1566, 1569, 1579,
172731 /* 310 */ 1541, 1548, 1551, 1557, 1562, 1565, 1529, 1567, 1576, 1619,
172732 /* 320 */ 1535, 1539, 1620, 1622, 1531, 1558, 1633, 1570, 1571, 1578,
172733 /* 330 */ 1605, 1604, 1607, 1613, 1614, 1642, 1646, 1611, 1586, 1587,
172734 /* 340 */ 1616, 1590, 1631, 1618, 1632, 1621, 1668, 1671, 1583, 1591,
172735 /* 350 */ 1675, 1677, 1657, 1679, 1682, 1683, 1685, 1661, 1669, 1670,
172736 /* 360 */ 1672, 1664, 1673, 1676, 1680, 1681, 1687, 1688, 1689, 1690,
172737 /* 370 */ 1691, 1592, 1597, 1628, 1629, 1692, 1705, 1598, 1600, 1653,
172738 /* 380 */ 1654, 1696, 1693, 1648, 1723, 1647, 1697, 1701, 1703, 1694,
172739 /* 390 */ 1734, 1744, 1745, 1760, 1762, 1763, 1655, 1656, 1660, 1749,
172740 /* 400 */ 1748, 1750, 1751, 1752, 1755, 1735, 1746, 1753, 1756, 1759,
172741 /* 410 */ 1764,
172742 };
172743 static const YYACTIONTYPE yy_default[] = {
172744 /* 0 */ 1651, 1651, 1651, 1480, 1245, 1356, 1245, 1245, 1245, 1480,
172745 /* 10 */ 1480, 1480, 1245, 1386, 1386, 1533, 1278, 1245, 1245, 1245,
172746 /* 20 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1479, 1245,
172747 /* 30 */ 1245, 1245, 1245, 1566, 1566, 1245, 1245, 1245, 1245, 1245,
172748 /* 40 */ 1245, 1245, 1245, 1395, 1245, 1402, 1245, 1245, 1245, 1245,
172749 /* 50 */ 1245, 1481, 1482, 1245, 1245, 1245, 1532, 1534, 1497, 1409,
172750 /* 60 */ 1408, 1407, 1406, 1515, 1374, 1400, 1393, 1397, 1476, 1477,
172751 /* 70 */ 1475, 1629, 1482, 1481, 1245, 1396, 1444, 1460, 1443, 1245,
172752 /* 80 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172753 /* 90 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172754 /* 100 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172755 /* 110 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172756 /* 120 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172757 /* 130 */ 1245, 1452, 1459, 1458, 1457, 1466, 1456, 1453, 1446, 1445,
172758 /* 140 */ 1447, 1448, 1245, 1245, 1269, 1245, 1245, 1266, 1320, 1245,
172759 /* 150 */ 1245, 1245, 1245, 1245, 1552, 1551, 1245, 1449, 1245, 1278,
172760 /* 160 */ 1437, 1436, 1435, 1463, 1450, 1462, 1461, 1540, 1603, 1602,
172761 /* 170 */ 1498, 1245, 1245, 1245, 1245, 1245, 1245, 1566, 1245, 1245,
172762 /* 180 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172763 /* 190 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172764 /* 200 */ 1245, 1376, 1566, 1566, 1245, 1278, 1566, 1566, 1377, 1377,
172765 /* 210 */ 1274, 1274, 1380, 1245, 1547, 1347, 1347, 1347, 1347, 1356,
172766 /* 220 */ 1347, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172767 /* 230 */ 1245, 1245, 1245, 1245, 1245, 1245, 1537, 1535, 1245, 1245,
172768 /* 240 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172769 /* 250 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172770 /* 260 */ 1245, 1245, 1245, 1245, 1245, 1352, 1245, 1245, 1245, 1245,
172771 /* 270 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1596, 1245, 1510,
172772 /* 280 */ 1334, 1352, 1352, 1352, 1352, 1354, 1335, 1333, 1346, 1279,
172773 /* 290 */ 1252, 1643, 1412, 1401, 1353, 1401, 1640, 1399, 1412, 1412,
172774 /* 300 */ 1399, 1412, 1353, 1640, 1295, 1618, 1290, 1386, 1386, 1386,
172775 /* 310 */ 1376, 1376, 1376, 1376, 1380, 1380, 1478, 1353, 1346, 1245,
172776 /* 320 */ 1643, 1643, 1362, 1362, 1642, 1642, 1362, 1498, 1626, 1421,
172777 /* 330 */ 1323, 1329, 1329, 1329, 1329, 1362, 1263, 1399, 1626, 1626,
172778 /* 340 */ 1399, 1421, 1323, 1399, 1323, 1399, 1362, 1263, 1514, 1637,
172779 /* 350 */ 1362, 1263, 1488, 1362, 1263, 1362, 1263, 1488, 1321, 1321,
172780 /* 360 */ 1321, 1310, 1245, 1245, 1488, 1321, 1295, 1321, 1310, 1321,
172781 /* 370 */ 1321, 1584, 1245, 1492, 1492, 1488, 1362, 1576, 1576, 1389,
172782 /* 380 */ 1389, 1394, 1380, 1483, 1362, 1245, 1394, 1392, 1390, 1399,
172783 /* 390 */ 1313, 1599, 1599, 1595, 1595, 1595, 1648, 1648, 1547, 1611,
172784 /* 400 */ 1278, 1278, 1278, 1278, 1611, 1297, 1297, 1279, 1279, 1278,
172785 /* 410 */ 1611, 1245, 1245, 1245, 1245, 1245, 1245, 1606, 1245, 1542,
172786 /* 420 */ 1499, 1366, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172787 /* 430 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1553, 1245,
172788 /* 440 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1426,
172789 /* 450 */ 1245, 1248, 1544, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172790 /* 460 */ 1245, 1403, 1404, 1367, 1245, 1245, 1245, 1245, 1245, 1245,
172791 /* 470 */ 1245, 1418, 1245, 1245, 1245, 1413, 1245, 1245, 1245, 1245,
172792 /* 480 */ 1245, 1245, 1245, 1245, 1639, 1245, 1245, 1245, 1245, 1245,
172793 /* 490 */ 1245, 1513, 1512, 1245, 1245, 1364, 1245, 1245, 1245, 1245,
172794 /* 500 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1293,
172795 /* 510 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172796 /* 520 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245,
172797 /* 530 */ 1245, 1245, 1245, 1391, 1245, 1245, 1245, 1245, 1245, 1245,
172798 /* 540 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1581, 1381,
172799 /* 550 */ 1245, 1245, 1245, 1245, 1630, 1245, 1245, 1245, 1245, 1245,
172800 /* 560 */ 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1622,
172801 /* 570 */ 1337, 1427, 1245, 1430, 1267, 1245, 1257, 1245, 1245,
 
172802 };
172803 /********** End of lemon-generated parsing tables *****************************/
172804
172805 /* The next table maps tokens (terminal symbols) into fallback tokens.
172806 ** If a construct like the following:
@@ -173340,75 +173627,77 @@
173340 /* 250 */ "orderby_opt",
173341 /* 251 */ "limit_opt",
173342 /* 252 */ "window_clause",
173343 /* 253 */ "values",
173344 /* 254 */ "nexprlist",
173345 /* 255 */ "sclp",
173346 /* 256 */ "as",
173347 /* 257 */ "seltablist",
173348 /* 258 */ "stl_prefix",
173349 /* 259 */ "joinop",
173350 /* 260 */ "on_using",
173351 /* 261 */ "indexed_by",
173352 /* 262 */ "exprlist",
173353 /* 263 */ "xfullname",
173354 /* 264 */ "idlist",
173355 /* 265 */ "indexed_opt",
173356 /* 266 */ "nulls",
173357 /* 267 */ "with",
173358 /* 268 */ "where_opt_ret",
173359 /* 269 */ "setlist",
173360 /* 270 */ "insert_cmd",
173361 /* 271 */ "idlist_opt",
173362 /* 272 */ "upsert",
173363 /* 273 */ "returning",
173364 /* 274 */ "filter_over",
173365 /* 275 */ "likeop",
173366 /* 276 */ "between_op",
173367 /* 277 */ "in_op",
173368 /* 278 */ "paren_exprlist",
173369 /* 279 */ "case_operand",
173370 /* 280 */ "case_exprlist",
173371 /* 281 */ "case_else",
173372 /* 282 */ "uniqueflag",
173373 /* 283 */ "collate",
173374 /* 284 */ "vinto",
173375 /* 285 */ "nmnum",
173376 /* 286 */ "trigger_decl",
173377 /* 287 */ "trigger_cmd_list",
173378 /* 288 */ "trigger_time",
173379 /* 289 */ "trigger_event",
173380 /* 290 */ "foreach_clause",
173381 /* 291 */ "when_clause",
173382 /* 292 */ "trigger_cmd",
173383 /* 293 */ "trnm",
173384 /* 294 */ "tridxby",
173385 /* 295 */ "database_kw_opt",
173386 /* 296 */ "key_opt",
173387 /* 297 */ "add_column_fullname",
173388 /* 298 */ "kwcolumn_opt",
173389 /* 299 */ "create_vtab",
173390 /* 300 */ "vtabarglist",
173391 /* 301 */ "vtabarg",
173392 /* 302 */ "vtabargtoken",
173393 /* 303 */ "lp",
173394 /* 304 */ "anylist",
173395 /* 305 */ "wqitem",
173396 /* 306 */ "wqas",
173397 /* 307 */ "windowdefn_list",
173398 /* 308 */ "windowdefn",
173399 /* 309 */ "window",
173400 /* 310 */ "frame_opt",
173401 /* 311 */ "part_opt",
173402 /* 312 */ "filter_clause",
173403 /* 313 */ "over_clause",
173404 /* 314 */ "range_or_rows",
173405 /* 315 */ "frame_bound",
173406 /* 316 */ "frame_bound_s",
173407 /* 317 */ "frame_bound_e",
173408 /* 318 */ "frame_exclude_opt",
173409 /* 319 */ "frame_exclude",
 
 
173410 };
173411 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
173412
173413 #ifndef NDEBUG
173414 /* For tracing reduce actions, the names of all rules are required.
@@ -173507,321 +173796,324 @@
173507 /* 90 */ "multiselect_op ::= UNION ALL",
173508 /* 91 */ "multiselect_op ::= EXCEPT|INTERSECT",
173509 /* 92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
173510 /* 93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
173511 /* 94 */ "values ::= VALUES LP nexprlist RP",
173512 /* 95 */ "values ::= values COMMA LP nexprlist RP",
173513 /* 96 */ "distinct ::= DISTINCT",
173514 /* 97 */ "distinct ::= ALL",
173515 /* 98 */ "distinct ::=",
173516 /* 99 */ "sclp ::=",
173517 /* 100 */ "selcollist ::= sclp scanpt expr scanpt as",
173518 /* 101 */ "selcollist ::= sclp scanpt STAR",
173519 /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR",
173520 /* 103 */ "as ::= AS nm",
173521 /* 104 */ "as ::=",
173522 /* 105 */ "from ::=",
173523 /* 106 */ "from ::= FROM seltablist",
173524 /* 107 */ "stl_prefix ::= seltablist joinop",
173525 /* 108 */ "stl_prefix ::=",
173526 /* 109 */ "seltablist ::= stl_prefix nm dbnm as on_using",
173527 /* 110 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
173528 /* 111 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
173529 /* 112 */ "seltablist ::= stl_prefix LP select RP as on_using",
173530 /* 113 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
173531 /* 114 */ "dbnm ::=",
173532 /* 115 */ "dbnm ::= DOT nm",
173533 /* 116 */ "fullname ::= nm",
173534 /* 117 */ "fullname ::= nm DOT nm",
173535 /* 118 */ "xfullname ::= nm",
173536 /* 119 */ "xfullname ::= nm DOT nm",
173537 /* 120 */ "xfullname ::= nm DOT nm AS nm",
173538 /* 121 */ "xfullname ::= nm AS nm",
173539 /* 122 */ "joinop ::= COMMA|JOIN",
173540 /* 123 */ "joinop ::= JOIN_KW JOIN",
173541 /* 124 */ "joinop ::= JOIN_KW nm JOIN",
173542 /* 125 */ "joinop ::= JOIN_KW nm nm JOIN",
173543 /* 126 */ "on_using ::= ON expr",
173544 /* 127 */ "on_using ::= USING LP idlist RP",
173545 /* 128 */ "on_using ::=",
173546 /* 129 */ "indexed_opt ::=",
173547 /* 130 */ "indexed_by ::= INDEXED BY nm",
173548 /* 131 */ "indexed_by ::= NOT INDEXED",
173549 /* 132 */ "orderby_opt ::=",
173550 /* 133 */ "orderby_opt ::= ORDER BY sortlist",
173551 /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
173552 /* 135 */ "sortlist ::= expr sortorder nulls",
173553 /* 136 */ "sortorder ::= ASC",
173554 /* 137 */ "sortorder ::= DESC",
173555 /* 138 */ "sortorder ::=",
173556 /* 139 */ "nulls ::= NULLS FIRST",
173557 /* 140 */ "nulls ::= NULLS LAST",
173558 /* 141 */ "nulls ::=",
173559 /* 142 */ "groupby_opt ::=",
173560 /* 143 */ "groupby_opt ::= GROUP BY nexprlist",
173561 /* 144 */ "having_opt ::=",
173562 /* 145 */ "having_opt ::= HAVING expr",
173563 /* 146 */ "limit_opt ::=",
173564 /* 147 */ "limit_opt ::= LIMIT expr",
173565 /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr",
173566 /* 149 */ "limit_opt ::= LIMIT expr COMMA expr",
173567 /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
173568 /* 151 */ "where_opt ::=",
173569 /* 152 */ "where_opt ::= WHERE expr",
173570 /* 153 */ "where_opt_ret ::=",
173571 /* 154 */ "where_opt_ret ::= WHERE expr",
173572 /* 155 */ "where_opt_ret ::= RETURNING selcollist",
173573 /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
173574 /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
173575 /* 158 */ "setlist ::= setlist COMMA nm EQ expr",
173576 /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
173577 /* 160 */ "setlist ::= nm EQ expr",
173578 /* 161 */ "setlist ::= LP idlist RP EQ expr",
173579 /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
173580 /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
173581 /* 164 */ "upsert ::=",
173582 /* 165 */ "upsert ::= RETURNING selcollist",
173583 /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
173584 /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
173585 /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning",
173586 /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
173587 /* 170 */ "returning ::= RETURNING selcollist",
173588 /* 171 */ "insert_cmd ::= INSERT orconf",
173589 /* 172 */ "insert_cmd ::= REPLACE",
173590 /* 173 */ "idlist_opt ::=",
173591 /* 174 */ "idlist_opt ::= LP idlist RP",
173592 /* 175 */ "idlist ::= idlist COMMA nm",
173593 /* 176 */ "idlist ::= nm",
173594 /* 177 */ "expr ::= LP expr RP",
173595 /* 178 */ "expr ::= ID|INDEXED|JOIN_KW",
173596 /* 179 */ "expr ::= nm DOT nm",
173597 /* 180 */ "expr ::= nm DOT nm DOT nm",
173598 /* 181 */ "term ::= NULL|FLOAT|BLOB",
173599 /* 182 */ "term ::= STRING",
173600 /* 183 */ "term ::= INTEGER",
173601 /* 184 */ "expr ::= VARIABLE",
173602 /* 185 */ "expr ::= expr COLLATE ID|STRING",
173603 /* 186 */ "expr ::= CAST LP expr AS typetoken RP",
173604 /* 187 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
173605 /* 188 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
173606 /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
173607 /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
173608 /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
173609 /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
173610 /* 193 */ "term ::= CTIME_KW",
173611 /* 194 */ "expr ::= LP nexprlist COMMA expr RP",
173612 /* 195 */ "expr ::= expr AND expr",
173613 /* 196 */ "expr ::= expr OR expr",
173614 /* 197 */ "expr ::= expr LT|GT|GE|LE expr",
173615 /* 198 */ "expr ::= expr EQ|NE expr",
173616 /* 199 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
173617 /* 200 */ "expr ::= expr PLUS|MINUS expr",
173618 /* 201 */ "expr ::= expr STAR|SLASH|REM expr",
173619 /* 202 */ "expr ::= expr CONCAT expr",
173620 /* 203 */ "likeop ::= NOT LIKE_KW|MATCH",
173621 /* 204 */ "expr ::= expr likeop expr",
173622 /* 205 */ "expr ::= expr likeop expr ESCAPE expr",
173623 /* 206 */ "expr ::= expr ISNULL|NOTNULL",
173624 /* 207 */ "expr ::= expr NOT NULL",
173625 /* 208 */ "expr ::= expr IS expr",
173626 /* 209 */ "expr ::= expr IS NOT expr",
173627 /* 210 */ "expr ::= expr IS NOT DISTINCT FROM expr",
173628 /* 211 */ "expr ::= expr IS DISTINCT FROM expr",
173629 /* 212 */ "expr ::= NOT expr",
173630 /* 213 */ "expr ::= BITNOT expr",
173631 /* 214 */ "expr ::= PLUS|MINUS expr",
173632 /* 215 */ "expr ::= expr PTR expr",
173633 /* 216 */ "between_op ::= BETWEEN",
173634 /* 217 */ "between_op ::= NOT BETWEEN",
173635 /* 218 */ "expr ::= expr between_op expr AND expr",
173636 /* 219 */ "in_op ::= IN",
173637 /* 220 */ "in_op ::= NOT IN",
173638 /* 221 */ "expr ::= expr in_op LP exprlist RP",
173639 /* 222 */ "expr ::= LP select RP",
173640 /* 223 */ "expr ::= expr in_op LP select RP",
173641 /* 224 */ "expr ::= expr in_op nm dbnm paren_exprlist",
173642 /* 225 */ "expr ::= EXISTS LP select RP",
173643 /* 226 */ "expr ::= CASE case_operand case_exprlist case_else END",
173644 /* 227 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
173645 /* 228 */ "case_exprlist ::= WHEN expr THEN expr",
173646 /* 229 */ "case_else ::= ELSE expr",
173647 /* 230 */ "case_else ::=",
173648 /* 231 */ "case_operand ::=",
173649 /* 232 */ "exprlist ::=",
173650 /* 233 */ "nexprlist ::= nexprlist COMMA expr",
173651 /* 234 */ "nexprlist ::= expr",
173652 /* 235 */ "paren_exprlist ::=",
173653 /* 236 */ "paren_exprlist ::= LP exprlist RP",
173654 /* 237 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
173655 /* 238 */ "uniqueflag ::= UNIQUE",
173656 /* 239 */ "uniqueflag ::=",
173657 /* 240 */ "eidlist_opt ::=",
173658 /* 241 */ "eidlist_opt ::= LP eidlist RP",
173659 /* 242 */ "eidlist ::= eidlist COMMA nm collate sortorder",
173660 /* 243 */ "eidlist ::= nm collate sortorder",
173661 /* 244 */ "collate ::=",
173662 /* 245 */ "collate ::= COLLATE ID|STRING",
173663 /* 246 */ "cmd ::= DROP INDEX ifexists fullname",
173664 /* 247 */ "cmd ::= VACUUM vinto",
173665 /* 248 */ "cmd ::= VACUUM nm vinto",
173666 /* 249 */ "vinto ::= INTO expr",
173667 /* 250 */ "vinto ::=",
173668 /* 251 */ "cmd ::= PRAGMA nm dbnm",
173669 /* 252 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
173670 /* 253 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
173671 /* 254 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
173672 /* 255 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
173673 /* 256 */ "plus_num ::= PLUS INTEGER|FLOAT",
173674 /* 257 */ "minus_num ::= MINUS INTEGER|FLOAT",
173675 /* 258 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
173676 /* 259 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
173677 /* 260 */ "trigger_time ::= BEFORE|AFTER",
173678 /* 261 */ "trigger_time ::= INSTEAD OF",
173679 /* 262 */ "trigger_time ::=",
173680 /* 263 */ "trigger_event ::= DELETE|INSERT",
173681 /* 264 */ "trigger_event ::= UPDATE",
173682 /* 265 */ "trigger_event ::= UPDATE OF idlist",
173683 /* 266 */ "when_clause ::=",
173684 /* 267 */ "when_clause ::= WHEN expr",
173685 /* 268 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
173686 /* 269 */ "trigger_cmd_list ::= trigger_cmd SEMI",
173687 /* 270 */ "trnm ::= nm DOT nm",
173688 /* 271 */ "tridxby ::= INDEXED BY nm",
173689 /* 272 */ "tridxby ::= NOT INDEXED",
173690 /* 273 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
173691 /* 274 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
173692 /* 275 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
173693 /* 276 */ "trigger_cmd ::= scanpt select scanpt",
173694 /* 277 */ "expr ::= RAISE LP IGNORE RP",
173695 /* 278 */ "expr ::= RAISE LP raisetype COMMA nm RP",
173696 /* 279 */ "raisetype ::= ROLLBACK",
173697 /* 280 */ "raisetype ::= ABORT",
173698 /* 281 */ "raisetype ::= FAIL",
173699 /* 282 */ "cmd ::= DROP TRIGGER ifexists fullname",
173700 /* 283 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
173701 /* 284 */ "cmd ::= DETACH database_kw_opt expr",
173702 /* 285 */ "key_opt ::=",
173703 /* 286 */ "key_opt ::= KEY expr",
173704 /* 287 */ "cmd ::= REINDEX",
173705 /* 288 */ "cmd ::= REINDEX nm dbnm",
173706 /* 289 */ "cmd ::= ANALYZE",
173707 /* 290 */ "cmd ::= ANALYZE nm dbnm",
173708 /* 291 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
173709 /* 292 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
173710 /* 293 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
173711 /* 294 */ "add_column_fullname ::= fullname",
173712 /* 295 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
173713 /* 296 */ "cmd ::= create_vtab",
173714 /* 297 */ "cmd ::= create_vtab LP vtabarglist RP",
173715 /* 298 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
173716 /* 299 */ "vtabarg ::=",
173717 /* 300 */ "vtabargtoken ::= ANY",
173718 /* 301 */ "vtabargtoken ::= lp anylist RP",
173719 /* 302 */ "lp ::= LP",
173720 /* 303 */ "with ::= WITH wqlist",
173721 /* 304 */ "with ::= WITH RECURSIVE wqlist",
173722 /* 305 */ "wqas ::= AS",
173723 /* 306 */ "wqas ::= AS MATERIALIZED",
173724 /* 307 */ "wqas ::= AS NOT MATERIALIZED",
173725 /* 308 */ "wqitem ::= nm eidlist_opt wqas LP select RP",
173726 /* 309 */ "wqlist ::= wqitem",
173727 /* 310 */ "wqlist ::= wqlist COMMA wqitem",
173728 /* 311 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
173729 /* 312 */ "windowdefn ::= nm AS LP window RP",
173730 /* 313 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
173731 /* 314 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
173732 /* 315 */ "window ::= ORDER BY sortlist frame_opt",
173733 /* 316 */ "window ::= nm ORDER BY sortlist frame_opt",
173734 /* 317 */ "window ::= nm frame_opt",
173735 /* 318 */ "frame_opt ::=",
173736 /* 319 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
173737 /* 320 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
173738 /* 321 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
173739 /* 322 */ "frame_bound_s ::= frame_bound",
173740 /* 323 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
173741 /* 324 */ "frame_bound_e ::= frame_bound",
173742 /* 325 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
173743 /* 326 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
173744 /* 327 */ "frame_bound ::= CURRENT ROW",
173745 /* 328 */ "frame_exclude_opt ::=",
173746 /* 329 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
173747 /* 330 */ "frame_exclude ::= NO OTHERS",
173748 /* 331 */ "frame_exclude ::= CURRENT ROW",
173749 /* 332 */ "frame_exclude ::= GROUP|TIES",
173750 /* 333 */ "window_clause ::= WINDOW windowdefn_list",
173751 /* 334 */ "filter_over ::= filter_clause over_clause",
173752 /* 335 */ "filter_over ::= over_clause",
173753 /* 336 */ "filter_over ::= filter_clause",
173754 /* 337 */ "over_clause ::= OVER LP window RP",
173755 /* 338 */ "over_clause ::= OVER nm",
173756 /* 339 */ "filter_clause ::= FILTER LP WHERE expr RP",
173757 /* 340 */ "term ::= QNUMBER",
173758 /* 341 */ "input ::= cmdlist",
173759 /* 342 */ "cmdlist ::= cmdlist ecmd",
173760 /* 343 */ "cmdlist ::= ecmd",
173761 /* 344 */ "ecmd ::= SEMI",
173762 /* 345 */ "ecmd ::= cmdx SEMI",
173763 /* 346 */ "ecmd ::= explain cmdx SEMI",
173764 /* 347 */ "trans_opt ::=",
173765 /* 348 */ "trans_opt ::= TRANSACTION",
173766 /* 349 */ "trans_opt ::= TRANSACTION nm",
173767 /* 350 */ "savepoint_opt ::= SAVEPOINT",
173768 /* 351 */ "savepoint_opt ::=",
173769 /* 352 */ "cmd ::= create_table create_table_args",
173770 /* 353 */ "table_option_set ::= table_option",
173771 /* 354 */ "columnlist ::= columnlist COMMA columnname carglist",
173772 /* 355 */ "columnlist ::= columnname carglist",
173773 /* 356 */ "nm ::= ID|INDEXED|JOIN_KW",
173774 /* 357 */ "nm ::= STRING",
173775 /* 358 */ "typetoken ::= typename",
173776 /* 359 */ "typename ::= ID|STRING",
173777 /* 360 */ "signed ::= plus_num",
173778 /* 361 */ "signed ::= minus_num",
173779 /* 362 */ "carglist ::= carglist ccons",
173780 /* 363 */ "carglist ::=",
173781 /* 364 */ "ccons ::= NULL onconf",
173782 /* 365 */ "ccons ::= GENERATED ALWAYS AS generated",
173783 /* 366 */ "ccons ::= AS generated",
173784 /* 367 */ "conslist_opt ::= COMMA conslist",
173785 /* 368 */ "conslist ::= conslist tconscomma tcons",
173786 /* 369 */ "conslist ::= tcons",
173787 /* 370 */ "tconscomma ::=",
173788 /* 371 */ "defer_subclause_opt ::= defer_subclause",
173789 /* 372 */ "resolvetype ::= raisetype",
173790 /* 373 */ "selectnowith ::= oneselect",
173791 /* 374 */ "oneselect ::= values",
173792 /* 375 */ "sclp ::= selcollist COMMA",
173793 /* 376 */ "as ::= ID|STRING",
173794 /* 377 */ "indexed_opt ::= indexed_by",
173795 /* 378 */ "returning ::=",
173796 /* 379 */ "expr ::= term",
173797 /* 380 */ "likeop ::= LIKE_KW|MATCH",
173798 /* 381 */ "case_operand ::= expr",
173799 /* 382 */ "exprlist ::= nexprlist",
173800 /* 383 */ "nmnum ::= plus_num",
173801 /* 384 */ "nmnum ::= nm",
173802 /* 385 */ "nmnum ::= ON",
173803 /* 386 */ "nmnum ::= DELETE",
173804 /* 387 */ "nmnum ::= DEFAULT",
173805 /* 388 */ "plus_num ::= INTEGER|FLOAT",
173806 /* 389 */ "foreach_clause ::=",
173807 /* 390 */ "foreach_clause ::= FOR EACH ROW",
173808 /* 391 */ "trnm ::= nm",
173809 /* 392 */ "tridxby ::=",
173810 /* 393 */ "database_kw_opt ::= DATABASE",
173811 /* 394 */ "database_kw_opt ::=",
173812 /* 395 */ "kwcolumn_opt ::=",
173813 /* 396 */ "kwcolumn_opt ::= COLUMNKW",
173814 /* 397 */ "vtabarglist ::= vtabarg",
173815 /* 398 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
173816 /* 399 */ "vtabarg ::= vtabarg vtabargtoken",
173817 /* 400 */ "anylist ::=",
173818 /* 401 */ "anylist ::= anylist LP anylist RP",
173819 /* 402 */ "anylist ::= anylist ANY",
173820 /* 403 */ "with ::=",
173821 /* 404 */ "windowdefn_list ::= windowdefn",
173822 /* 405 */ "window ::= frame_opt",
 
 
 
173823 };
173824 #endif /* NDEBUG */
173825
173826
173827 #if YYGROWABLESTACK
@@ -173945,97 +174237,98 @@
173945 /********* Begin destructor definitions ***************************************/
173946 case 205: /* select */
173947 case 240: /* selectnowith */
173948 case 241: /* oneselect */
173949 case 253: /* values */
 
173950 {
173951 sqlite3SelectDelete(pParse->db, (yypminor->yy299));
173952 }
173953 break;
173954 case 217: /* term */
173955 case 218: /* expr */
173956 case 247: /* where_opt */
173957 case 249: /* having_opt */
173958 case 268: /* where_opt_ret */
173959 case 279: /* case_operand */
173960 case 281: /* case_else */
173961 case 284: /* vinto */
173962 case 291: /* when_clause */
173963 case 296: /* key_opt */
173964 case 312: /* filter_clause */
173965 {
173966 sqlite3ExprDelete(pParse->db, (yypminor->yy2));
173967 }
173968 break;
173969 case 222: /* eidlist_opt */
173970 case 232: /* sortlist */
173971 case 233: /* eidlist */
173972 case 245: /* selcollist */
173973 case 248: /* groupby_opt */
173974 case 250: /* orderby_opt */
173975 case 254: /* nexprlist */
173976 case 255: /* sclp */
173977 case 262: /* exprlist */
173978 case 269: /* setlist */
173979 case 278: /* paren_exprlist */
173980 case 280: /* case_exprlist */
173981 case 311: /* part_opt */
173982 {
173983 sqlite3ExprListDelete(pParse->db, (yypminor->yy402));
173984 }
173985 break;
173986 case 239: /* fullname */
173987 case 246: /* from */
173988 case 257: /* seltablist */
173989 case 258: /* stl_prefix */
173990 case 263: /* xfullname */
173991 {
173992 sqlite3SrcListDelete(pParse->db, (yypminor->yy387));
173993 }
173994 break;
173995 case 242: /* wqlist */
173996 {
173997 sqlite3WithDelete(pParse->db, (yypminor->yy131));
173998 }
173999 break;
174000 case 252: /* window_clause */
174001 case 307: /* windowdefn_list */
174002 {
174003 sqlite3WindowListDelete(pParse->db, (yypminor->yy3));
174004 }
174005 break;
174006 case 264: /* idlist */
174007 case 271: /* idlist_opt */
174008 {
174009 sqlite3IdListDelete(pParse->db, (yypminor->yy400));
174010 }
174011 break;
174012 case 274: /* filter_over */
174013 case 308: /* windowdefn */
174014 case 309: /* window */
174015 case 310: /* frame_opt */
174016 case 313: /* over_clause */
174017 {
174018 sqlite3WindowDelete(pParse->db, (yypminor->yy3));
174019 }
174020 break;
174021 case 287: /* trigger_cmd_list */
174022 case 292: /* trigger_cmd */
174023 {
174024 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy347));
174025 }
174026 break;
174027 case 289: /* trigger_event */
174028 {
174029 sqlite3IdListDelete(pParse->db, (yypminor->yy210).b);
174030 }
174031 break;
174032 case 315: /* frame_bound */
174033 case 316: /* frame_bound_s */
174034 case 317: /* frame_bound_e */
174035 {
174036 sqlite3ExprDelete(pParse->db, (yypminor->yy337).pExpr);
174037 }
174038 break;
174039 /********* End destructor definitions *****************************************/
174040 default: break; /* If no destructor action specified: do nothing */
174041 }
@@ -174428,321 +174721,324 @@
174428 243, /* (90) multiselect_op ::= UNION ALL */
174429 243, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
174430 241, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
174431 241, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
174432 253, /* (94) values ::= VALUES LP nexprlist RP */
174433 253, /* (95) values ::= values COMMA LP nexprlist RP */
174434 244, /* (96) distinct ::= DISTINCT */
174435 244, /* (97) distinct ::= ALL */
174436 244, /* (98) distinct ::= */
174437 255, /* (99) sclp ::= */
174438 245, /* (100) selcollist ::= sclp scanpt expr scanpt as */
174439 245, /* (101) selcollist ::= sclp scanpt STAR */
174440 245, /* (102) selcollist ::= sclp scanpt nm DOT STAR */
174441 256, /* (103) as ::= AS nm */
174442 256, /* (104) as ::= */
174443 246, /* (105) from ::= */
174444 246, /* (106) from ::= FROM seltablist */
174445 258, /* (107) stl_prefix ::= seltablist joinop */
174446 258, /* (108) stl_prefix ::= */
174447 257, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
174448 257, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174449 257, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174450 257, /* (112) seltablist ::= stl_prefix LP select RP as on_using */
174451 257, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
174452 201, /* (114) dbnm ::= */
174453 201, /* (115) dbnm ::= DOT nm */
174454 239, /* (116) fullname ::= nm */
174455 239, /* (117) fullname ::= nm DOT nm */
174456 263, /* (118) xfullname ::= nm */
174457 263, /* (119) xfullname ::= nm DOT nm */
174458 263, /* (120) xfullname ::= nm DOT nm AS nm */
174459 263, /* (121) xfullname ::= nm AS nm */
174460 259, /* (122) joinop ::= COMMA|JOIN */
174461 259, /* (123) joinop ::= JOIN_KW JOIN */
174462 259, /* (124) joinop ::= JOIN_KW nm JOIN */
174463 259, /* (125) joinop ::= JOIN_KW nm nm JOIN */
174464 260, /* (126) on_using ::= ON expr */
174465 260, /* (127) on_using ::= USING LP idlist RP */
174466 260, /* (128) on_using ::= */
174467 265, /* (129) indexed_opt ::= */
174468 261, /* (130) indexed_by ::= INDEXED BY nm */
174469 261, /* (131) indexed_by ::= NOT INDEXED */
174470 250, /* (132) orderby_opt ::= */
174471 250, /* (133) orderby_opt ::= ORDER BY sortlist */
174472 232, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
174473 232, /* (135) sortlist ::= expr sortorder nulls */
174474 220, /* (136) sortorder ::= ASC */
174475 220, /* (137) sortorder ::= DESC */
174476 220, /* (138) sortorder ::= */
174477 266, /* (139) nulls ::= NULLS FIRST */
174478 266, /* (140) nulls ::= NULLS LAST */
174479 266, /* (141) nulls ::= */
174480 248, /* (142) groupby_opt ::= */
174481 248, /* (143) groupby_opt ::= GROUP BY nexprlist */
174482 249, /* (144) having_opt ::= */
174483 249, /* (145) having_opt ::= HAVING expr */
174484 251, /* (146) limit_opt ::= */
174485 251, /* (147) limit_opt ::= LIMIT expr */
174486 251, /* (148) limit_opt ::= LIMIT expr OFFSET expr */
174487 251, /* (149) limit_opt ::= LIMIT expr COMMA expr */
174488 191, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174489 247, /* (151) where_opt ::= */
174490 247, /* (152) where_opt ::= WHERE expr */
174491 268, /* (153) where_opt_ret ::= */
174492 268, /* (154) where_opt_ret ::= WHERE expr */
174493 268, /* (155) where_opt_ret ::= RETURNING selcollist */
174494 268, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
174495 191, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174496 269, /* (158) setlist ::= setlist COMMA nm EQ expr */
174497 269, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
174498 269, /* (160) setlist ::= nm EQ expr */
174499 269, /* (161) setlist ::= LP idlist RP EQ expr */
174500 191, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174501 191, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174502 272, /* (164) upsert ::= */
174503 272, /* (165) upsert ::= RETURNING selcollist */
174504 272, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174505 272, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174506 272, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
174507 272, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174508 273, /* (170) returning ::= RETURNING selcollist */
174509 270, /* (171) insert_cmd ::= INSERT orconf */
174510 270, /* (172) insert_cmd ::= REPLACE */
174511 271, /* (173) idlist_opt ::= */
174512 271, /* (174) idlist_opt ::= LP idlist RP */
174513 264, /* (175) idlist ::= idlist COMMA nm */
174514 264, /* (176) idlist ::= nm */
174515 218, /* (177) expr ::= LP expr RP */
174516 218, /* (178) expr ::= ID|INDEXED|JOIN_KW */
174517 218, /* (179) expr ::= nm DOT nm */
174518 218, /* (180) expr ::= nm DOT nm DOT nm */
174519 217, /* (181) term ::= NULL|FLOAT|BLOB */
174520 217, /* (182) term ::= STRING */
174521 217, /* (183) term ::= INTEGER */
174522 218, /* (184) expr ::= VARIABLE */
174523 218, /* (185) expr ::= expr COLLATE ID|STRING */
174524 218, /* (186) expr ::= CAST LP expr AS typetoken RP */
174525 218, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174526 218, /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174527 218, /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174528 218, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174529 218, /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174530 218, /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174531 217, /* (193) term ::= CTIME_KW */
174532 218, /* (194) expr ::= LP nexprlist COMMA expr RP */
174533 218, /* (195) expr ::= expr AND expr */
174534 218, /* (196) expr ::= expr OR expr */
174535 218, /* (197) expr ::= expr LT|GT|GE|LE expr */
174536 218, /* (198) expr ::= expr EQ|NE expr */
174537 218, /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174538 218, /* (200) expr ::= expr PLUS|MINUS expr */
174539 218, /* (201) expr ::= expr STAR|SLASH|REM expr */
174540 218, /* (202) expr ::= expr CONCAT expr */
174541 275, /* (203) likeop ::= NOT LIKE_KW|MATCH */
174542 218, /* (204) expr ::= expr likeop expr */
174543 218, /* (205) expr ::= expr likeop expr ESCAPE expr */
174544 218, /* (206) expr ::= expr ISNULL|NOTNULL */
174545 218, /* (207) expr ::= expr NOT NULL */
174546 218, /* (208) expr ::= expr IS expr */
174547 218, /* (209) expr ::= expr IS NOT expr */
174548 218, /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
174549 218, /* (211) expr ::= expr IS DISTINCT FROM expr */
174550 218, /* (212) expr ::= NOT expr */
174551 218, /* (213) expr ::= BITNOT expr */
174552 218, /* (214) expr ::= PLUS|MINUS expr */
174553 218, /* (215) expr ::= expr PTR expr */
174554 276, /* (216) between_op ::= BETWEEN */
174555 276, /* (217) between_op ::= NOT BETWEEN */
174556 218, /* (218) expr ::= expr between_op expr AND expr */
174557 277, /* (219) in_op ::= IN */
174558 277, /* (220) in_op ::= NOT IN */
174559 218, /* (221) expr ::= expr in_op LP exprlist RP */
174560 218, /* (222) expr ::= LP select RP */
174561 218, /* (223) expr ::= expr in_op LP select RP */
174562 218, /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
174563 218, /* (225) expr ::= EXISTS LP select RP */
174564 218, /* (226) expr ::= CASE case_operand case_exprlist case_else END */
174565 280, /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174566 280, /* (228) case_exprlist ::= WHEN expr THEN expr */
174567 281, /* (229) case_else ::= ELSE expr */
174568 281, /* (230) case_else ::= */
174569 279, /* (231) case_operand ::= */
174570 262, /* (232) exprlist ::= */
174571 254, /* (233) nexprlist ::= nexprlist COMMA expr */
174572 254, /* (234) nexprlist ::= expr */
174573 278, /* (235) paren_exprlist ::= */
174574 278, /* (236) paren_exprlist ::= LP exprlist RP */
174575 191, /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174576 282, /* (238) uniqueflag ::= UNIQUE */
174577 282, /* (239) uniqueflag ::= */
174578 222, /* (240) eidlist_opt ::= */
174579 222, /* (241) eidlist_opt ::= LP eidlist RP */
174580 233, /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
174581 233, /* (243) eidlist ::= nm collate sortorder */
174582 283, /* (244) collate ::= */
174583 283, /* (245) collate ::= COLLATE ID|STRING */
174584 191, /* (246) cmd ::= DROP INDEX ifexists fullname */
174585 191, /* (247) cmd ::= VACUUM vinto */
174586 191, /* (248) cmd ::= VACUUM nm vinto */
174587 284, /* (249) vinto ::= INTO expr */
174588 284, /* (250) vinto ::= */
174589 191, /* (251) cmd ::= PRAGMA nm dbnm */
174590 191, /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
174591 191, /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
174592 191, /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
174593 191, /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
174594 212, /* (256) plus_num ::= PLUS INTEGER|FLOAT */
174595 213, /* (257) minus_num ::= MINUS INTEGER|FLOAT */
174596 191, /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
174597 286, /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
174598 288, /* (260) trigger_time ::= BEFORE|AFTER */
174599 288, /* (261) trigger_time ::= INSTEAD OF */
174600 288, /* (262) trigger_time ::= */
174601 289, /* (263) trigger_event ::= DELETE|INSERT */
174602 289, /* (264) trigger_event ::= UPDATE */
174603 289, /* (265) trigger_event ::= UPDATE OF idlist */
174604 291, /* (266) when_clause ::= */
174605 291, /* (267) when_clause ::= WHEN expr */
174606 287, /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
174607 287, /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
174608 293, /* (270) trnm ::= nm DOT nm */
174609 294, /* (271) tridxby ::= INDEXED BY nm */
174610 294, /* (272) tridxby ::= NOT INDEXED */
174611 292, /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
174612 292, /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
174613 292, /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
174614 292, /* (276) trigger_cmd ::= scanpt select scanpt */
174615 218, /* (277) expr ::= RAISE LP IGNORE RP */
174616 218, /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
174617 237, /* (279) raisetype ::= ROLLBACK */
174618 237, /* (280) raisetype ::= ABORT */
174619 237, /* (281) raisetype ::= FAIL */
174620 191, /* (282) cmd ::= DROP TRIGGER ifexists fullname */
174621 191, /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
174622 191, /* (284) cmd ::= DETACH database_kw_opt expr */
174623 296, /* (285) key_opt ::= */
174624 296, /* (286) key_opt ::= KEY expr */
174625 191, /* (287) cmd ::= REINDEX */
174626 191, /* (288) cmd ::= REINDEX nm dbnm */
174627 191, /* (289) cmd ::= ANALYZE */
174628 191, /* (290) cmd ::= ANALYZE nm dbnm */
174629 191, /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
174630 191, /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
174631 191, /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
174632 297, /* (294) add_column_fullname ::= fullname */
174633 191, /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
174634 191, /* (296) cmd ::= create_vtab */
174635 191, /* (297) cmd ::= create_vtab LP vtabarglist RP */
174636 299, /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
174637 301, /* (299) vtabarg ::= */
174638 302, /* (300) vtabargtoken ::= ANY */
174639 302, /* (301) vtabargtoken ::= lp anylist RP */
174640 303, /* (302) lp ::= LP */
174641 267, /* (303) with ::= WITH wqlist */
174642 267, /* (304) with ::= WITH RECURSIVE wqlist */
174643 306, /* (305) wqas ::= AS */
174644 306, /* (306) wqas ::= AS MATERIALIZED */
174645 306, /* (307) wqas ::= AS NOT MATERIALIZED */
174646 305, /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
174647 242, /* (309) wqlist ::= wqitem */
174648 242, /* (310) wqlist ::= wqlist COMMA wqitem */
174649 307, /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
174650 308, /* (312) windowdefn ::= nm AS LP window RP */
174651 309, /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
174652 309, /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
174653 309, /* (315) window ::= ORDER BY sortlist frame_opt */
174654 309, /* (316) window ::= nm ORDER BY sortlist frame_opt */
174655 309, /* (317) window ::= nm frame_opt */
174656 310, /* (318) frame_opt ::= */
174657 310, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
174658 310, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
174659 314, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
174660 316, /* (322) frame_bound_s ::= frame_bound */
174661 316, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
174662 317, /* (324) frame_bound_e ::= frame_bound */
174663 317, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
174664 315, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
174665 315, /* (327) frame_bound ::= CURRENT ROW */
174666 318, /* (328) frame_exclude_opt ::= */
174667 318, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
174668 319, /* (330) frame_exclude ::= NO OTHERS */
174669 319, /* (331) frame_exclude ::= CURRENT ROW */
174670 319, /* (332) frame_exclude ::= GROUP|TIES */
174671 252, /* (333) window_clause ::= WINDOW windowdefn_list */
174672 274, /* (334) filter_over ::= filter_clause over_clause */
174673 274, /* (335) filter_over ::= over_clause */
174674 274, /* (336) filter_over ::= filter_clause */
174675 313, /* (337) over_clause ::= OVER LP window RP */
174676 313, /* (338) over_clause ::= OVER nm */
174677 312, /* (339) filter_clause ::= FILTER LP WHERE expr RP */
174678 217, /* (340) term ::= QNUMBER */
174679 186, /* (341) input ::= cmdlist */
174680 187, /* (342) cmdlist ::= cmdlist ecmd */
174681 187, /* (343) cmdlist ::= ecmd */
174682 188, /* (344) ecmd ::= SEMI */
174683 188, /* (345) ecmd ::= cmdx SEMI */
174684 188, /* (346) ecmd ::= explain cmdx SEMI */
174685 193, /* (347) trans_opt ::= */
174686 193, /* (348) trans_opt ::= TRANSACTION */
174687 193, /* (349) trans_opt ::= TRANSACTION nm */
174688 195, /* (350) savepoint_opt ::= SAVEPOINT */
174689 195, /* (351) savepoint_opt ::= */
174690 191, /* (352) cmd ::= create_table create_table_args */
174691 204, /* (353) table_option_set ::= table_option */
174692 202, /* (354) columnlist ::= columnlist COMMA columnname carglist */
174693 202, /* (355) columnlist ::= columnname carglist */
174694 194, /* (356) nm ::= ID|INDEXED|JOIN_KW */
174695 194, /* (357) nm ::= STRING */
174696 209, /* (358) typetoken ::= typename */
174697 210, /* (359) typename ::= ID|STRING */
174698 211, /* (360) signed ::= plus_num */
174699 211, /* (361) signed ::= minus_num */
174700 208, /* (362) carglist ::= carglist ccons */
174701 208, /* (363) carglist ::= */
174702 216, /* (364) ccons ::= NULL onconf */
174703 216, /* (365) ccons ::= GENERATED ALWAYS AS generated */
174704 216, /* (366) ccons ::= AS generated */
174705 203, /* (367) conslist_opt ::= COMMA conslist */
174706 229, /* (368) conslist ::= conslist tconscomma tcons */
174707 229, /* (369) conslist ::= tcons */
174708 230, /* (370) tconscomma ::= */
174709 234, /* (371) defer_subclause_opt ::= defer_subclause */
174710 236, /* (372) resolvetype ::= raisetype */
174711 240, /* (373) selectnowith ::= oneselect */
174712 241, /* (374) oneselect ::= values */
174713 255, /* (375) sclp ::= selcollist COMMA */
174714 256, /* (376) as ::= ID|STRING */
174715 265, /* (377) indexed_opt ::= indexed_by */
174716 273, /* (378) returning ::= */
174717 218, /* (379) expr ::= term */
174718 275, /* (380) likeop ::= LIKE_KW|MATCH */
174719 279, /* (381) case_operand ::= expr */
174720 262, /* (382) exprlist ::= nexprlist */
174721 285, /* (383) nmnum ::= plus_num */
174722 285, /* (384) nmnum ::= nm */
174723 285, /* (385) nmnum ::= ON */
174724 285, /* (386) nmnum ::= DELETE */
174725 285, /* (387) nmnum ::= DEFAULT */
174726 212, /* (388) plus_num ::= INTEGER|FLOAT */
174727 290, /* (389) foreach_clause ::= */
174728 290, /* (390) foreach_clause ::= FOR EACH ROW */
174729 293, /* (391) trnm ::= nm */
174730 294, /* (392) tridxby ::= */
174731 295, /* (393) database_kw_opt ::= DATABASE */
174732 295, /* (394) database_kw_opt ::= */
174733 298, /* (395) kwcolumn_opt ::= */
174734 298, /* (396) kwcolumn_opt ::= COLUMNKW */
174735 300, /* (397) vtabarglist ::= vtabarg */
174736 300, /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */
174737 301, /* (399) vtabarg ::= vtabarg vtabargtoken */
174738 304, /* (400) anylist ::= */
174739 304, /* (401) anylist ::= anylist LP anylist RP */
174740 304, /* (402) anylist ::= anylist ANY */
174741 267, /* (403) with ::= */
174742 307, /* (404) windowdefn_list ::= windowdefn */
174743 309, /* (405) window ::= frame_opt */
 
 
 
174744 };
174745
174746 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
174747 ** of symbols on the right-hand side of that rule. */
174748 static const signed char yyRuleInfoNRhs[] = {
@@ -174839,321 +175135,324 @@
174839 -2, /* (90) multiselect_op ::= UNION ALL */
174840 -1, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
174841 -9, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
174842 -10, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
174843 -4, /* (94) values ::= VALUES LP nexprlist RP */
174844 -5, /* (95) values ::= values COMMA LP nexprlist RP */
174845 -1, /* (96) distinct ::= DISTINCT */
174846 -1, /* (97) distinct ::= ALL */
174847 0, /* (98) distinct ::= */
174848 0, /* (99) sclp ::= */
174849 -5, /* (100) selcollist ::= sclp scanpt expr scanpt as */
174850 -3, /* (101) selcollist ::= sclp scanpt STAR */
174851 -5, /* (102) selcollist ::= sclp scanpt nm DOT STAR */
174852 -2, /* (103) as ::= AS nm */
174853 0, /* (104) as ::= */
174854 0, /* (105) from ::= */
174855 -2, /* (106) from ::= FROM seltablist */
174856 -2, /* (107) stl_prefix ::= seltablist joinop */
174857 0, /* (108) stl_prefix ::= */
174858 -5, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
174859 -6, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174860 -8, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174861 -6, /* (112) seltablist ::= stl_prefix LP select RP as on_using */
174862 -6, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
174863 0, /* (114) dbnm ::= */
174864 -2, /* (115) dbnm ::= DOT nm */
174865 -1, /* (116) fullname ::= nm */
174866 -3, /* (117) fullname ::= nm DOT nm */
174867 -1, /* (118) xfullname ::= nm */
174868 -3, /* (119) xfullname ::= nm DOT nm */
174869 -5, /* (120) xfullname ::= nm DOT nm AS nm */
174870 -3, /* (121) xfullname ::= nm AS nm */
174871 -1, /* (122) joinop ::= COMMA|JOIN */
174872 -2, /* (123) joinop ::= JOIN_KW JOIN */
174873 -3, /* (124) joinop ::= JOIN_KW nm JOIN */
174874 -4, /* (125) joinop ::= JOIN_KW nm nm JOIN */
174875 -2, /* (126) on_using ::= ON expr */
174876 -4, /* (127) on_using ::= USING LP idlist RP */
174877 0, /* (128) on_using ::= */
174878 0, /* (129) indexed_opt ::= */
174879 -3, /* (130) indexed_by ::= INDEXED BY nm */
174880 -2, /* (131) indexed_by ::= NOT INDEXED */
174881 0, /* (132) orderby_opt ::= */
174882 -3, /* (133) orderby_opt ::= ORDER BY sortlist */
174883 -5, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
174884 -3, /* (135) sortlist ::= expr sortorder nulls */
174885 -1, /* (136) sortorder ::= ASC */
174886 -1, /* (137) sortorder ::= DESC */
174887 0, /* (138) sortorder ::= */
174888 -2, /* (139) nulls ::= NULLS FIRST */
174889 -2, /* (140) nulls ::= NULLS LAST */
174890 0, /* (141) nulls ::= */
174891 0, /* (142) groupby_opt ::= */
174892 -3, /* (143) groupby_opt ::= GROUP BY nexprlist */
174893 0, /* (144) having_opt ::= */
174894 -2, /* (145) having_opt ::= HAVING expr */
174895 0, /* (146) limit_opt ::= */
174896 -2, /* (147) limit_opt ::= LIMIT expr */
174897 -4, /* (148) limit_opt ::= LIMIT expr OFFSET expr */
174898 -4, /* (149) limit_opt ::= LIMIT expr COMMA expr */
174899 -6, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174900 0, /* (151) where_opt ::= */
174901 -2, /* (152) where_opt ::= WHERE expr */
174902 0, /* (153) where_opt_ret ::= */
174903 -2, /* (154) where_opt_ret ::= WHERE expr */
174904 -2, /* (155) where_opt_ret ::= RETURNING selcollist */
174905 -4, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
174906 -9, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174907 -5, /* (158) setlist ::= setlist COMMA nm EQ expr */
174908 -7, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
174909 -3, /* (160) setlist ::= nm EQ expr */
174910 -5, /* (161) setlist ::= LP idlist RP EQ expr */
174911 -7, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174912 -8, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174913 0, /* (164) upsert ::= */
174914 -2, /* (165) upsert ::= RETURNING selcollist */
174915 -12, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174916 -9, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174917 -5, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
174918 -8, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174919 -2, /* (170) returning ::= RETURNING selcollist */
174920 -2, /* (171) insert_cmd ::= INSERT orconf */
174921 -1, /* (172) insert_cmd ::= REPLACE */
174922 0, /* (173) idlist_opt ::= */
174923 -3, /* (174) idlist_opt ::= LP idlist RP */
174924 -3, /* (175) idlist ::= idlist COMMA nm */
174925 -1, /* (176) idlist ::= nm */
174926 -3, /* (177) expr ::= LP expr RP */
174927 -1, /* (178) expr ::= ID|INDEXED|JOIN_KW */
174928 -3, /* (179) expr ::= nm DOT nm */
174929 -5, /* (180) expr ::= nm DOT nm DOT nm */
174930 -1, /* (181) term ::= NULL|FLOAT|BLOB */
174931 -1, /* (182) term ::= STRING */
174932 -1, /* (183) term ::= INTEGER */
174933 -1, /* (184) expr ::= VARIABLE */
174934 -3, /* (185) expr ::= expr COLLATE ID|STRING */
174935 -6, /* (186) expr ::= CAST LP expr AS typetoken RP */
174936 -5, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174937 -8, /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174938 -4, /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174939 -6, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174940 -9, /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174941 -5, /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174942 -1, /* (193) term ::= CTIME_KW */
174943 -5, /* (194) expr ::= LP nexprlist COMMA expr RP */
174944 -3, /* (195) expr ::= expr AND expr */
174945 -3, /* (196) expr ::= expr OR expr */
174946 -3, /* (197) expr ::= expr LT|GT|GE|LE expr */
174947 -3, /* (198) expr ::= expr EQ|NE expr */
174948 -3, /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174949 -3, /* (200) expr ::= expr PLUS|MINUS expr */
174950 -3, /* (201) expr ::= expr STAR|SLASH|REM expr */
174951 -3, /* (202) expr ::= expr CONCAT expr */
174952 -2, /* (203) likeop ::= NOT LIKE_KW|MATCH */
174953 -3, /* (204) expr ::= expr likeop expr */
174954 -5, /* (205) expr ::= expr likeop expr ESCAPE expr */
174955 -2, /* (206) expr ::= expr ISNULL|NOTNULL */
174956 -3, /* (207) expr ::= expr NOT NULL */
174957 -3, /* (208) expr ::= expr IS expr */
174958 -4, /* (209) expr ::= expr IS NOT expr */
174959 -6, /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
174960 -5, /* (211) expr ::= expr IS DISTINCT FROM expr */
174961 -2, /* (212) expr ::= NOT expr */
174962 -2, /* (213) expr ::= BITNOT expr */
174963 -2, /* (214) expr ::= PLUS|MINUS expr */
174964 -3, /* (215) expr ::= expr PTR expr */
174965 -1, /* (216) between_op ::= BETWEEN */
174966 -2, /* (217) between_op ::= NOT BETWEEN */
174967 -5, /* (218) expr ::= expr between_op expr AND expr */
174968 -1, /* (219) in_op ::= IN */
174969 -2, /* (220) in_op ::= NOT IN */
174970 -5, /* (221) expr ::= expr in_op LP exprlist RP */
174971 -3, /* (222) expr ::= LP select RP */
174972 -5, /* (223) expr ::= expr in_op LP select RP */
174973 -5, /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
174974 -4, /* (225) expr ::= EXISTS LP select RP */
174975 -5, /* (226) expr ::= CASE case_operand case_exprlist case_else END */
174976 -5, /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174977 -4, /* (228) case_exprlist ::= WHEN expr THEN expr */
174978 -2, /* (229) case_else ::= ELSE expr */
174979 0, /* (230) case_else ::= */
174980 0, /* (231) case_operand ::= */
174981 0, /* (232) exprlist ::= */
174982 -3, /* (233) nexprlist ::= nexprlist COMMA expr */
174983 -1, /* (234) nexprlist ::= expr */
174984 0, /* (235) paren_exprlist ::= */
174985 -3, /* (236) paren_exprlist ::= LP exprlist RP */
174986 -12, /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174987 -1, /* (238) uniqueflag ::= UNIQUE */
174988 0, /* (239) uniqueflag ::= */
174989 0, /* (240) eidlist_opt ::= */
174990 -3, /* (241) eidlist_opt ::= LP eidlist RP */
174991 -5, /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
174992 -3, /* (243) eidlist ::= nm collate sortorder */
174993 0, /* (244) collate ::= */
174994 -2, /* (245) collate ::= COLLATE ID|STRING */
174995 -4, /* (246) cmd ::= DROP INDEX ifexists fullname */
174996 -2, /* (247) cmd ::= VACUUM vinto */
174997 -3, /* (248) cmd ::= VACUUM nm vinto */
174998 -2, /* (249) vinto ::= INTO expr */
174999 0, /* (250) vinto ::= */
175000 -3, /* (251) cmd ::= PRAGMA nm dbnm */
175001 -5, /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
175002 -6, /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
175003 -5, /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
175004 -6, /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
175005 -2, /* (256) plus_num ::= PLUS INTEGER|FLOAT */
175006 -2, /* (257) minus_num ::= MINUS INTEGER|FLOAT */
175007 -5, /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
175008 -11, /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
175009 -1, /* (260) trigger_time ::= BEFORE|AFTER */
175010 -2, /* (261) trigger_time ::= INSTEAD OF */
175011 0, /* (262) trigger_time ::= */
175012 -1, /* (263) trigger_event ::= DELETE|INSERT */
175013 -1, /* (264) trigger_event ::= UPDATE */
175014 -3, /* (265) trigger_event ::= UPDATE OF idlist */
175015 0, /* (266) when_clause ::= */
175016 -2, /* (267) when_clause ::= WHEN expr */
175017 -3, /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
175018 -2, /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
175019 -3, /* (270) trnm ::= nm DOT nm */
175020 -3, /* (271) tridxby ::= INDEXED BY nm */
175021 -2, /* (272) tridxby ::= NOT INDEXED */
175022 -9, /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
175023 -8, /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
175024 -6, /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
175025 -3, /* (276) trigger_cmd ::= scanpt select scanpt */
175026 -4, /* (277) expr ::= RAISE LP IGNORE RP */
175027 -6, /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
175028 -1, /* (279) raisetype ::= ROLLBACK */
175029 -1, /* (280) raisetype ::= ABORT */
175030 -1, /* (281) raisetype ::= FAIL */
175031 -4, /* (282) cmd ::= DROP TRIGGER ifexists fullname */
175032 -6, /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
175033 -3, /* (284) cmd ::= DETACH database_kw_opt expr */
175034 0, /* (285) key_opt ::= */
175035 -2, /* (286) key_opt ::= KEY expr */
175036 -1, /* (287) cmd ::= REINDEX */
175037 -3, /* (288) cmd ::= REINDEX nm dbnm */
175038 -1, /* (289) cmd ::= ANALYZE */
175039 -3, /* (290) cmd ::= ANALYZE nm dbnm */
175040 -6, /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
175041 -7, /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
175042 -6, /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
175043 -1, /* (294) add_column_fullname ::= fullname */
175044 -8, /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
175045 -1, /* (296) cmd ::= create_vtab */
175046 -4, /* (297) cmd ::= create_vtab LP vtabarglist RP */
175047 -8, /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
175048 0, /* (299) vtabarg ::= */
175049 -1, /* (300) vtabargtoken ::= ANY */
175050 -3, /* (301) vtabargtoken ::= lp anylist RP */
175051 -1, /* (302) lp ::= LP */
175052 -2, /* (303) with ::= WITH wqlist */
175053 -3, /* (304) with ::= WITH RECURSIVE wqlist */
175054 -1, /* (305) wqas ::= AS */
175055 -2, /* (306) wqas ::= AS MATERIALIZED */
175056 -3, /* (307) wqas ::= AS NOT MATERIALIZED */
175057 -6, /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
175058 -1, /* (309) wqlist ::= wqitem */
175059 -3, /* (310) wqlist ::= wqlist COMMA wqitem */
175060 -3, /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
175061 -5, /* (312) windowdefn ::= nm AS LP window RP */
175062 -5, /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
175063 -6, /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
175064 -4, /* (315) window ::= ORDER BY sortlist frame_opt */
175065 -5, /* (316) window ::= nm ORDER BY sortlist frame_opt */
175066 -2, /* (317) window ::= nm frame_opt */
175067 0, /* (318) frame_opt ::= */
175068 -3, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
175069 -6, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
175070 -1, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
175071 -1, /* (322) frame_bound_s ::= frame_bound */
175072 -2, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
175073 -1, /* (324) frame_bound_e ::= frame_bound */
175074 -2, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
175075 -2, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
175076 -2, /* (327) frame_bound ::= CURRENT ROW */
175077 0, /* (328) frame_exclude_opt ::= */
175078 -2, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
175079 -2, /* (330) frame_exclude ::= NO OTHERS */
175080 -2, /* (331) frame_exclude ::= CURRENT ROW */
175081 -1, /* (332) frame_exclude ::= GROUP|TIES */
175082 -2, /* (333) window_clause ::= WINDOW windowdefn_list */
175083 -2, /* (334) filter_over ::= filter_clause over_clause */
175084 -1, /* (335) filter_over ::= over_clause */
175085 -1, /* (336) filter_over ::= filter_clause */
175086 -4, /* (337) over_clause ::= OVER LP window RP */
175087 -2, /* (338) over_clause ::= OVER nm */
175088 -5, /* (339) filter_clause ::= FILTER LP WHERE expr RP */
175089 -1, /* (340) term ::= QNUMBER */
175090 -1, /* (341) input ::= cmdlist */
175091 -2, /* (342) cmdlist ::= cmdlist ecmd */
175092 -1, /* (343) cmdlist ::= ecmd */
175093 -1, /* (344) ecmd ::= SEMI */
175094 -2, /* (345) ecmd ::= cmdx SEMI */
175095 -3, /* (346) ecmd ::= explain cmdx SEMI */
175096 0, /* (347) trans_opt ::= */
175097 -1, /* (348) trans_opt ::= TRANSACTION */
175098 -2, /* (349) trans_opt ::= TRANSACTION nm */
175099 -1, /* (350) savepoint_opt ::= SAVEPOINT */
175100 0, /* (351) savepoint_opt ::= */
175101 -2, /* (352) cmd ::= create_table create_table_args */
175102 -1, /* (353) table_option_set ::= table_option */
175103 -4, /* (354) columnlist ::= columnlist COMMA columnname carglist */
175104 -2, /* (355) columnlist ::= columnname carglist */
175105 -1, /* (356) nm ::= ID|INDEXED|JOIN_KW */
175106 -1, /* (357) nm ::= STRING */
175107 -1, /* (358) typetoken ::= typename */
175108 -1, /* (359) typename ::= ID|STRING */
175109 -1, /* (360) signed ::= plus_num */
175110 -1, /* (361) signed ::= minus_num */
175111 -2, /* (362) carglist ::= carglist ccons */
175112 0, /* (363) carglist ::= */
175113 -2, /* (364) ccons ::= NULL onconf */
175114 -4, /* (365) ccons ::= GENERATED ALWAYS AS generated */
175115 -2, /* (366) ccons ::= AS generated */
175116 -2, /* (367) conslist_opt ::= COMMA conslist */
175117 -3, /* (368) conslist ::= conslist tconscomma tcons */
175118 -1, /* (369) conslist ::= tcons */
175119 0, /* (370) tconscomma ::= */
175120 -1, /* (371) defer_subclause_opt ::= defer_subclause */
175121 -1, /* (372) resolvetype ::= raisetype */
175122 -1, /* (373) selectnowith ::= oneselect */
175123 -1, /* (374) oneselect ::= values */
175124 -2, /* (375) sclp ::= selcollist COMMA */
175125 -1, /* (376) as ::= ID|STRING */
175126 -1, /* (377) indexed_opt ::= indexed_by */
175127 0, /* (378) returning ::= */
175128 -1, /* (379) expr ::= term */
175129 -1, /* (380) likeop ::= LIKE_KW|MATCH */
175130 -1, /* (381) case_operand ::= expr */
175131 -1, /* (382) exprlist ::= nexprlist */
175132 -1, /* (383) nmnum ::= plus_num */
175133 -1, /* (384) nmnum ::= nm */
175134 -1, /* (385) nmnum ::= ON */
175135 -1, /* (386) nmnum ::= DELETE */
175136 -1, /* (387) nmnum ::= DEFAULT */
175137 -1, /* (388) plus_num ::= INTEGER|FLOAT */
175138 0, /* (389) foreach_clause ::= */
175139 -3, /* (390) foreach_clause ::= FOR EACH ROW */
175140 -1, /* (391) trnm ::= nm */
175141 0, /* (392) tridxby ::= */
175142 -1, /* (393) database_kw_opt ::= DATABASE */
175143 0, /* (394) database_kw_opt ::= */
175144 0, /* (395) kwcolumn_opt ::= */
175145 -1, /* (396) kwcolumn_opt ::= COLUMNKW */
175146 -1, /* (397) vtabarglist ::= vtabarg */
175147 -3, /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */
175148 -2, /* (399) vtabarg ::= vtabarg vtabargtoken */
175149 0, /* (400) anylist ::= */
175150 -4, /* (401) anylist ::= anylist LP anylist RP */
175151 -2, /* (402) anylist ::= anylist ANY */
175152 0, /* (403) with ::= */
175153 -1, /* (404) windowdefn_list ::= windowdefn */
175154 -1, /* (405) window ::= frame_opt */
 
 
 
175155 };
175156
175157 static void yy_accept(yyParser*); /* Forward Declaration */
175158
175159 /*
@@ -175201,20 +175500,20 @@
175201 break;
175202 case 2: /* cmdx ::= cmd */
175203 { sqlite3FinishCoding(pParse); }
175204 break;
175205 case 3: /* cmd ::= BEGIN transtype trans_opt */
175206 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy92);}
175207 break;
175208 case 4: /* transtype ::= */
175209 {yymsp[1].minor.yy92 = TK_DEFERRED;}
175210 break;
175211 case 5: /* transtype ::= DEFERRED */
175212 case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
175213 case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
175214 case 321: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==321);
175215 {yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-X*/}
175216 break;
175217 case 8: /* cmd ::= COMMIT|END trans_opt */
175218 case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
175219 {sqlite3EndTransaction(pParse,yymsp[-1].major);}
175220 break;
@@ -175233,11 +175532,11 @@
175233 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
175234 }
175235 break;
175236 case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
175237 {
175238 sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy92,0,0,yymsp[-2].minor.yy92);
175239 }
175240 break;
175241 case 14: /* createkw ::= CREATE */
175242 {disableLookaside(pParse);}
175243 break;
@@ -175245,65 +175544,65 @@
175245 case 18: /* temp ::= */ yytestcase(yyruleno==18);
175246 case 47: /* autoinc ::= */ yytestcase(yyruleno==47);
175247 case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
175248 case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
175249 case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
175250 case 98: /* distinct ::= */ yytestcase(yyruleno==98);
175251 case 244: /* collate ::= */ yytestcase(yyruleno==244);
175252 {yymsp[1].minor.yy92 = 0;}
175253 break;
175254 case 16: /* ifnotexists ::= IF NOT EXISTS */
175255 {yymsp[-2].minor.yy92 = 1;}
175256 break;
175257 case 17: /* temp ::= TEMP */
175258 {yymsp[0].minor.yy92 = pParse->db->init.busy==0;}
175259 break;
175260 case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
175261 {
175262 sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy527,0);
175263 }
175264 break;
175265 case 20: /* create_table_args ::= AS select */
175266 {
175267 sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy299);
175268 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy299);
175269 }
175270 break;
175271 case 21: /* table_option_set ::= */
175272 {yymsp[1].minor.yy527 = 0;}
175273 break;
175274 case 22: /* table_option_set ::= table_option_set COMMA table_option */
175275 {yylhsminor.yy527 = yymsp[-2].minor.yy527|yymsp[0].minor.yy527;}
175276 yymsp[-2].minor.yy527 = yylhsminor.yy527;
175277 break;
175278 case 23: /* table_option ::= WITHOUT nm */
175279 {
175280 if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
175281 yymsp[-1].minor.yy527 = TF_WithoutRowid | TF_NoVisibleRowid;
175282 }else{
175283 yymsp[-1].minor.yy527 = 0;
175284 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175285 }
175286 }
175287 break;
175288 case 24: /* table_option ::= nm */
175289 {
175290 if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
175291 yylhsminor.yy527 = TF_Strict;
175292 }else{
175293 yylhsminor.yy527 = 0;
175294 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175295 }
175296 }
175297 yymsp[0].minor.yy527 = yylhsminor.yy527;
175298 break;
175299 case 25: /* columnname ::= nm typetoken */
175300 {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
175301 break;
175302 case 26: /* typetoken ::= */
175303 case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
175304 case 104: /* as ::= */ yytestcase(yyruleno==104);
175305 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
175306 break;
175307 case 27: /* typetoken ::= typename LP signed RP */
175308 {
175309 yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
@@ -175318,11 +175617,11 @@
175318 {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
175319 break;
175320 case 30: /* scanpt ::= */
175321 {
175322 assert( yyLookahead!=YYNOCODE );
175323 yymsp[1].minor.yy616 = yyLookaheadToken.z;
175324 }
175325 break;
175326 case 31: /* scantok ::= */
175327 {
175328 assert( yyLookahead!=YYNOCODE );
@@ -175332,21 +175631,21 @@
175332 case 32: /* ccons ::= CONSTRAINT nm */
175333 case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
175334 {pParse->constraintName = yymsp[0].minor.yy0;}
175335 break;
175336 case 33: /* ccons ::= DEFAULT scantok term */
175337 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy2,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175338 break;
175339 case 34: /* ccons ::= DEFAULT LP expr RP */
175340 {sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy2,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
175341 break;
175342 case 35: /* ccons ::= DEFAULT PLUS scantok term */
175343 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy2,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175344 break;
175345 case 36: /* ccons ::= DEFAULT MINUS scantok term */
175346 {
175347 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy2, 0);
175348 sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
175349 }
175350 break;
175351 case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
175352 {
@@ -175357,315 +175656,312 @@
175357 }
175358 sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
175359 }
175360 break;
175361 case 38: /* ccons ::= NOT NULL onconf */
175362 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy92);}
175363 break;
175364 case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
175365 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy92,yymsp[0].minor.yy92,yymsp[-2].minor.yy92);}
175366 break;
175367 case 40: /* ccons ::= UNIQUE onconf */
175368 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy92,0,0,0,0,
175369 SQLITE_IDXTYPE_UNIQUE);}
175370 break;
175371 case 41: /* ccons ::= CHECK LP expr RP */
175372 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy2,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
175373 break;
175374 case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
175375 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy402,yymsp[0].minor.yy92);}
175376 break;
175377 case 43: /* ccons ::= defer_subclause */
175378 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy92);}
175379 break;
175380 case 44: /* ccons ::= COLLATE ID|STRING */
175381 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
175382 break;
175383 case 45: /* generated ::= LP expr RP */
175384 {sqlite3AddGenerated(pParse,yymsp[-1].minor.yy2,0);}
175385 break;
175386 case 46: /* generated ::= LP expr RP ID */
175387 {sqlite3AddGenerated(pParse,yymsp[-2].minor.yy2,&yymsp[0].minor.yy0);}
175388 break;
175389 case 48: /* autoinc ::= AUTOINCR */
175390 {yymsp[0].minor.yy92 = 1;}
175391 break;
175392 case 49: /* refargs ::= */
175393 { yymsp[1].minor.yy92 = OE_None*0x0101; /* EV: R-19803-45884 */}
175394 break;
175395 case 50: /* refargs ::= refargs refarg */
175396 { yymsp[-1].minor.yy92 = (yymsp[-1].minor.yy92 & ~yymsp[0].minor.yy367.mask) | yymsp[0].minor.yy367.value; }
175397 break;
175398 case 51: /* refarg ::= MATCH nm */
175399 { yymsp[-1].minor.yy367.value = 0; yymsp[-1].minor.yy367.mask = 0x000000; }
175400 break;
175401 case 52: /* refarg ::= ON INSERT refact */
175402 { yymsp[-2].minor.yy367.value = 0; yymsp[-2].minor.yy367.mask = 0x000000; }
175403 break;
175404 case 53: /* refarg ::= ON DELETE refact */
175405 { yymsp[-2].minor.yy367.value = yymsp[0].minor.yy92; yymsp[-2].minor.yy367.mask = 0x0000ff; }
175406 break;
175407 case 54: /* refarg ::= ON UPDATE refact */
175408 { yymsp[-2].minor.yy367.value = yymsp[0].minor.yy92<<8; yymsp[-2].minor.yy367.mask = 0x00ff00; }
175409 break;
175410 case 55: /* refact ::= SET NULL */
175411 { yymsp[-1].minor.yy92 = OE_SetNull; /* EV: R-33326-45252 */}
175412 break;
175413 case 56: /* refact ::= SET DEFAULT */
175414 { yymsp[-1].minor.yy92 = OE_SetDflt; /* EV: R-33326-45252 */}
175415 break;
175416 case 57: /* refact ::= CASCADE */
175417 { yymsp[0].minor.yy92 = OE_Cascade; /* EV: R-33326-45252 */}
175418 break;
175419 case 58: /* refact ::= RESTRICT */
175420 { yymsp[0].minor.yy92 = OE_Restrict; /* EV: R-33326-45252 */}
175421 break;
175422 case 59: /* refact ::= NO ACTION */
175423 { yymsp[-1].minor.yy92 = OE_None; /* EV: R-33326-45252 */}
175424 break;
175425 case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
175426 {yymsp[-2].minor.yy92 = 0;}
175427 break;
175428 case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
175429 case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
175430 case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171);
175431 {yymsp[-1].minor.yy92 = yymsp[0].minor.yy92;}
175432 break;
175433 case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
175434 case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
175435 case 217: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==217);
175436 case 220: /* in_op ::= NOT IN */ yytestcase(yyruleno==220);
175437 case 245: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==245);
175438 {yymsp[-1].minor.yy92 = 1;}
175439 break;
175440 case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
175441 {yymsp[-1].minor.yy92 = 0;}
175442 break;
175443 case 66: /* tconscomma ::= COMMA */
175444 {pParse->constraintName.n = 0;}
175445 break;
175446 case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
175447 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy402,yymsp[0].minor.yy92,yymsp[-2].minor.yy92,0);}
175448 break;
175449 case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
175450 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy402,yymsp[0].minor.yy92,0,0,0,0,
175451 SQLITE_IDXTYPE_UNIQUE);}
175452 break;
175453 case 70: /* tcons ::= CHECK LP expr RP onconf */
175454 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy2,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
175455 break;
175456 case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
175457 {
175458 sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy402, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[-1].minor.yy92);
175459 sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy92);
175460 }
175461 break;
175462 case 73: /* onconf ::= */
175463 case 75: /* orconf ::= */ yytestcase(yyruleno==75);
175464 {yymsp[1].minor.yy92 = OE_Default;}
175465 break;
175466 case 74: /* onconf ::= ON CONFLICT resolvetype */
175467 {yymsp[-2].minor.yy92 = yymsp[0].minor.yy92;}
175468 break;
175469 case 77: /* resolvetype ::= IGNORE */
175470 {yymsp[0].minor.yy92 = OE_Ignore;}
175471 break;
175472 case 78: /* resolvetype ::= REPLACE */
175473 case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172);
175474 {yymsp[0].minor.yy92 = OE_Replace;}
175475 break;
175476 case 79: /* cmd ::= DROP TABLE ifexists fullname */
175477 {
175478 sqlite3DropTable(pParse, yymsp[0].minor.yy387, 0, yymsp[-1].minor.yy92);
175479 }
175480 break;
175481 case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
175482 {
175483 sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy402, yymsp[0].minor.yy299, yymsp[-7].minor.yy92, yymsp[-5].minor.yy92);
175484 }
175485 break;
175486 case 83: /* cmd ::= DROP VIEW ifexists fullname */
175487 {
175488 sqlite3DropTable(pParse, yymsp[0].minor.yy387, 1, yymsp[-1].minor.yy92);
175489 }
175490 break;
175491 case 84: /* cmd ::= select */
175492 {
175493 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
175494 sqlite3Select(pParse, yymsp[0].minor.yy299, &dest);
175495 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy299);
175496 }
175497 break;
175498 case 85: /* select ::= WITH wqlist selectnowith */
175499 {yymsp[-2].minor.yy299 = attachWithToSelect(pParse,yymsp[0].minor.yy299,yymsp[-1].minor.yy131);}
175500 break;
175501 case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
175502 {yymsp[-3].minor.yy299 = attachWithToSelect(pParse,yymsp[0].minor.yy299,yymsp[-1].minor.yy131);}
175503 break;
175504 case 87: /* select ::= selectnowith */
175505 {
175506 Select *p = yymsp[0].minor.yy299;
175507 if( p ){
175508 parserDoubleLinkSelect(pParse, p);
175509 }
175510 }
175511 break;
175512 case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
175513 {
175514 Select *pRhs = yymsp[0].minor.yy299;
175515 Select *pLhs = yymsp[-2].minor.yy299;
175516 if( pRhs && pRhs->pPrior ){
175517 SrcList *pFrom;
175518 Token x;
175519 x.n = 0;
175520 parserDoubleLinkSelect(pParse, pRhs);
175521 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
175522 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
175523 }
175524 if( pRhs ){
175525 pRhs->op = (u8)yymsp[-1].minor.yy92;
175526 pRhs->pPrior = pLhs;
175527 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
175528 pRhs->selFlags &= ~SF_MultiValue;
175529 if( yymsp[-1].minor.yy92!=TK_ALL ) pParse->hasCompound = 1;
175530 }else{
175531 sqlite3SelectDelete(pParse->db, pLhs);
175532 }
175533 yymsp[-2].minor.yy299 = pRhs;
175534 }
175535 break;
175536 case 89: /* multiselect_op ::= UNION */
175537 case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
175538 {yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-OP*/}
175539 break;
175540 case 90: /* multiselect_op ::= UNION ALL */
175541 {yymsp[-1].minor.yy92 = TK_ALL;}
175542 break;
175543 case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
175544 {
175545 yymsp[-8].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy402,yymsp[-5].minor.yy387,yymsp[-4].minor.yy2,yymsp[-3].minor.yy402,yymsp[-2].minor.yy2,yymsp[-1].minor.yy402,yymsp[-7].minor.yy92,yymsp[0].minor.yy2);
175546 }
175547 break;
175548 case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
175549 {
175550 yymsp[-9].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy402,yymsp[-6].minor.yy387,yymsp[-5].minor.yy2,yymsp[-4].minor.yy402,yymsp[-3].minor.yy2,yymsp[-1].minor.yy402,yymsp[-8].minor.yy92,yymsp[0].minor.yy2);
175551 if( yymsp[-9].minor.yy299 ){
175552 yymsp[-9].minor.yy299->pWinDefn = yymsp[-2].minor.yy3;
175553 }else{
175554 sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy3);
175555 }
175556 }
175557 break;
175558 case 94: /* values ::= VALUES LP nexprlist RP */
175559 {
175560 yymsp[-3].minor.yy299 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy402,0,0,0,0,0,SF_Values,0);
175561 }
175562 break;
175563 case 95: /* values ::= values COMMA LP nexprlist RP */
175564 {
175565 Select *pRight, *pLeft = yymsp[-4].minor.yy299;
175566 pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy402,0,0,0,0,0,SF_Values|SF_MultiValue,0);
175567 if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
175568 if( pRight ){
175569 pRight->op = TK_ALL;
175570 pRight->pPrior = pLeft;
175571 yymsp[-4].minor.yy299 = pRight;
175572 }else{
175573 yymsp[-4].minor.yy299 = pLeft;
175574 }
175575 }
175576 break;
175577 case 96: /* distinct ::= DISTINCT */
175578 {yymsp[0].minor.yy92 = SF_Distinct;}
175579 break;
175580 case 97: /* distinct ::= ALL */
175581 {yymsp[0].minor.yy92 = SF_All;}
175582 break;
175583 case 99: /* sclp ::= */
175584 case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132);
175585 case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142);
175586 case 232: /* exprlist ::= */ yytestcase(yyruleno==232);
175587 case 235: /* paren_exprlist ::= */ yytestcase(yyruleno==235);
175588 case 240: /* eidlist_opt ::= */ yytestcase(yyruleno==240);
175589 {yymsp[1].minor.yy402 = 0;}
175590 break;
175591 case 100: /* selcollist ::= sclp scanpt expr scanpt as */
175592 {
175593 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[-2].minor.yy2);
175594 if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[0].minor.yy0, 1);
175595 sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy402,yymsp[-3].minor.yy616,yymsp[-1].minor.yy616);
175596 }
175597 break;
175598 case 101: /* selcollist ::= sclp scanpt STAR */
175599 {
175600 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
175601 sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175602 yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy402, p);
175603 }
175604 break;
175605 case 102: /* selcollist ::= sclp scanpt nm DOT STAR */
175606 {
175607 Expr *pRight, *pLeft, *pDot;
175608 pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
175609 sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175610 pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
175611 pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
175612 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, pDot);
175613 }
175614 break;
175615 case 103: /* as ::= AS nm */
175616 case 115: /* dbnm ::= DOT nm */ yytestcase(yyruleno==115);
175617 case 256: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==256);
175618 case 257: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==257);
175619 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
175620 break;
175621 case 105: /* from ::= */
175622 case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108);
175623 {yymsp[1].minor.yy387 = 0;}
175624 break;
175625 case 106: /* from ::= FROM seltablist */
175626 {
175627 yymsp[-1].minor.yy387 = yymsp[0].minor.yy387;
175628 sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy387);
175629 }
175630 break;
175631 case 107: /* stl_prefix ::= seltablist joinop */
175632 {
175633 if( ALWAYS(yymsp[-1].minor.yy387 && yymsp[-1].minor.yy387->nSrc>0) ) yymsp[-1].minor.yy387->a[yymsp[-1].minor.yy387->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy92;
175634 }
175635 break;
175636 case 109: /* seltablist ::= stl_prefix nm dbnm as on_using */
175637 {
175638 yymsp[-4].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy387,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175639 }
175640 break;
175641 case 110: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175642 {
175643 yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy305);
175644 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy387, &yymsp[-1].minor.yy0);
175645 }
175646 break;
175647 case 111: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175648 {
175649 yymsp[-7].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy387,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175650 sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy387, yymsp[-3].minor.yy402);
175651 }
175652 break;
175653 case 112: /* seltablist ::= stl_prefix LP select RP as on_using */
175654 {
175655 yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy299,&yymsp[0].minor.yy305);
175656 }
175657 break;
175658 case 113: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
175659 {
175660 if( yymsp[-5].minor.yy387==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy305.pOn==0 && yymsp[0].minor.yy305.pUsing==0 ){
175661 yymsp[-5].minor.yy387 = yymsp[-3].minor.yy387;
175662 }else if( ALWAYS(yymsp[-3].minor.yy387!=0) && yymsp[-3].minor.yy387->nSrc==1 ){
175663 yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy305);
175664 if( yymsp[-5].minor.yy387 ){
175665 SrcItem *pNew = &yymsp[-5].minor.yy387->a[yymsp[-5].minor.yy387->nSrc-1];
175666 SrcItem *pOld = yymsp[-3].minor.yy387->a;
175667 pNew->zName = pOld->zName;
175668 pNew->zDatabase = pOld->zDatabase;
175669 pNew->pSelect = pOld->pSelect;
175670 if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
175671 pNew->fg.isNestedFrom = 1;
@@ -175677,1061 +175973,1064 @@
175677 pNew->fg.isTabFunc = 1;
175678 }
175679 pOld->zName = pOld->zDatabase = 0;
175680 pOld->pSelect = 0;
175681 }
175682 sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy387);
175683 }else{
175684 Select *pSubquery;
175685 sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy387);
175686 pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy387,0,0,0,0,SF_NestedFrom,0);
175687 yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy305);
175688 }
175689 }
175690 break;
175691 case 114: /* dbnm ::= */
175692 case 129: /* indexed_opt ::= */ yytestcase(yyruleno==129);
175693 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
175694 break;
175695 case 116: /* fullname ::= nm */
175696 {
175697 yylhsminor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
175698 if( IN_RENAME_OBJECT && yylhsminor.yy387 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy387->a[0].zName, &yymsp[0].minor.yy0);
175699 }
175700 yymsp[0].minor.yy387 = yylhsminor.yy387;
175701 break;
175702 case 117: /* fullname ::= nm DOT nm */
175703 {
175704 yylhsminor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
175705 if( IN_RENAME_OBJECT && yylhsminor.yy387 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy387->a[0].zName, &yymsp[0].minor.yy0);
175706 }
175707 yymsp[-2].minor.yy387 = yylhsminor.yy387;
175708 break;
175709 case 118: /* xfullname ::= nm */
175710 {yymsp[0].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
175711 break;
175712 case 119: /* xfullname ::= nm DOT nm */
175713 {yymsp[-2].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
175714 break;
175715 case 120: /* xfullname ::= nm DOT nm AS nm */
175716 {
175717 yymsp[-4].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
175718 if( yymsp[-4].minor.yy387 ) yymsp[-4].minor.yy387->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
175719 }
175720 break;
175721 case 121: /* xfullname ::= nm AS nm */
175722 {
175723 yymsp[-2].minor.yy387 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
175724 if( yymsp[-2].minor.yy387 ) yymsp[-2].minor.yy387->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
175725 }
175726 break;
175727 case 122: /* joinop ::= COMMA|JOIN */
175728 { yymsp[0].minor.yy92 = JT_INNER; }
175729 break;
175730 case 123: /* joinop ::= JOIN_KW JOIN */
175731 {yymsp[-1].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
175732 break;
175733 case 124: /* joinop ::= JOIN_KW nm JOIN */
175734 {yymsp[-2].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
175735 break;
175736 case 125: /* joinop ::= JOIN_KW nm nm JOIN */
175737 {yymsp[-3].minor.yy92 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
175738 break;
175739 case 126: /* on_using ::= ON expr */
175740 {yymsp[-1].minor.yy305.pOn = yymsp[0].minor.yy2; yymsp[-1].minor.yy305.pUsing = 0;}
175741 break;
175742 case 127: /* on_using ::= USING LP idlist RP */
175743 {yymsp[-3].minor.yy305.pOn = 0; yymsp[-3].minor.yy305.pUsing = yymsp[-1].minor.yy400;}
175744 break;
175745 case 128: /* on_using ::= */
175746 {yymsp[1].minor.yy305.pOn = 0; yymsp[1].minor.yy305.pUsing = 0;}
175747 break;
175748 case 130: /* indexed_by ::= INDEXED BY nm */
175749 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
175750 break;
175751 case 131: /* indexed_by ::= NOT INDEXED */
175752 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
175753 break;
175754 case 133: /* orderby_opt ::= ORDER BY sortlist */
175755 case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143);
175756 {yymsp[-2].minor.yy402 = yymsp[0].minor.yy402;}
175757 break;
175758 case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */
175759 {
175760 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402,yymsp[-2].minor.yy2);
175761 sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy402,yymsp[-1].minor.yy92,yymsp[0].minor.yy92);
175762 }
175763 break;
175764 case 135: /* sortlist ::= expr sortorder nulls */
175765 {
175766 yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy2); /*A-overwrites-Y*/
175767 sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy402,yymsp[-1].minor.yy92,yymsp[0].minor.yy92);
175768 }
175769 break;
175770 case 136: /* sortorder ::= ASC */
175771 {yymsp[0].minor.yy92 = SQLITE_SO_ASC;}
175772 break;
175773 case 137: /* sortorder ::= DESC */
175774 {yymsp[0].minor.yy92 = SQLITE_SO_DESC;}
175775 break;
175776 case 138: /* sortorder ::= */
175777 case 141: /* nulls ::= */ yytestcase(yyruleno==141);
175778 {yymsp[1].minor.yy92 = SQLITE_SO_UNDEFINED;}
175779 break;
175780 case 139: /* nulls ::= NULLS FIRST */
175781 {yymsp[-1].minor.yy92 = SQLITE_SO_ASC;}
175782 break;
175783 case 140: /* nulls ::= NULLS LAST */
175784 {yymsp[-1].minor.yy92 = SQLITE_SO_DESC;}
175785 break;
175786 case 144: /* having_opt ::= */
175787 case 146: /* limit_opt ::= */ yytestcase(yyruleno==146);
175788 case 151: /* where_opt ::= */ yytestcase(yyruleno==151);
175789 case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153);
175790 case 230: /* case_else ::= */ yytestcase(yyruleno==230);
175791 case 231: /* case_operand ::= */ yytestcase(yyruleno==231);
175792 case 250: /* vinto ::= */ yytestcase(yyruleno==250);
175793 {yymsp[1].minor.yy2 = 0;}
175794 break;
175795 case 145: /* having_opt ::= HAVING expr */
175796 case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152);
175797 case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154);
175798 case 229: /* case_else ::= ELSE expr */ yytestcase(yyruleno==229);
175799 case 249: /* vinto ::= INTO expr */ yytestcase(yyruleno==249);
175800 {yymsp[-1].minor.yy2 = yymsp[0].minor.yy2;}
175801 break;
175802 case 147: /* limit_opt ::= LIMIT expr */
175803 {yymsp[-1].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy2,0);}
175804 break;
175805 case 148: /* limit_opt ::= LIMIT expr OFFSET expr */
175806 {yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
175807 break;
175808 case 149: /* limit_opt ::= LIMIT expr COMMA expr */
175809 {yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy2,yymsp[-2].minor.yy2);}
175810 break;
175811 case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
175812 {
175813 sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy387, &yymsp[-1].minor.yy0);
175814 sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy387,yymsp[0].minor.yy2,0,0);
175815 }
175816 break;
175817 case 155: /* where_opt_ret ::= RETURNING selcollist */
175818 {sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-1].minor.yy2 = 0;}
175819 break;
175820 case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
175821 {sqlite3AddReturning(pParse,yymsp[0].minor.yy402); yymsp[-3].minor.yy2 = yymsp[-2].minor.yy2;}
175822 break;
175823 case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
175824 {
175825 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy387, &yymsp[-4].minor.yy0);
175826 sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy402,"set list");
175827 if( yymsp[-1].minor.yy387 ){
175828 SrcList *pFromClause = yymsp[-1].minor.yy387;
175829 if( pFromClause->nSrc>1 ){
175830 Select *pSubquery;
175831 Token as;
175832 pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0);
175833 as.n = 0;
175834 as.z = 0;
175835 pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
175836 }
175837 yymsp[-5].minor.yy387 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy387, pFromClause);
175838 }
175839 sqlite3Update(pParse,yymsp[-5].minor.yy387,yymsp[-2].minor.yy402,yymsp[0].minor.yy2,yymsp[-6].minor.yy92,0,0,0);
175840 }
175841 break;
175842 case 158: /* setlist ::= setlist COMMA nm EQ expr */
175843 {
175844 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy402, yymsp[0].minor.yy2);
175845 sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, 1);
175846 }
175847 break;
175848 case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
175849 {
175850 yymsp[-6].minor.yy402 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy402, yymsp[-3].minor.yy400, yymsp[0].minor.yy2);
175851 }
175852 break;
175853 case 160: /* setlist ::= nm EQ expr */
175854 {
175855 yylhsminor.yy402 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy2);
175856 sqlite3ExprListSetName(pParse, yylhsminor.yy402, &yymsp[-2].minor.yy0, 1);
175857 }
175858 yymsp[-2].minor.yy402 = yylhsminor.yy402;
175859 break;
175860 case 161: /* setlist ::= LP idlist RP EQ expr */
175861 {
175862 yymsp[-4].minor.yy402 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy400, yymsp[0].minor.yy2);
175863 }
175864 break;
175865 case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
175866 {
175867 sqlite3Insert(pParse, yymsp[-3].minor.yy387, yymsp[-1].minor.yy299, yymsp[-2].minor.yy400, yymsp[-5].minor.yy92, yymsp[0].minor.yy258);
175868 }
175869 break;
175870 case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
175871 {
175872 sqlite3Insert(pParse, yymsp[-4].minor.yy387, 0, yymsp[-3].minor.yy400, yymsp[-6].minor.yy92, 0);
175873 }
175874 break;
175875 case 164: /* upsert ::= */
175876 { yymsp[1].minor.yy258 = 0; }
175877 break;
175878 case 165: /* upsert ::= RETURNING selcollist */
175879 { yymsp[-1].minor.yy258 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy402); }
175880 break;
175881 case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
175882 { yymsp[-11].minor.yy258 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy402,yymsp[-6].minor.yy2,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2,yymsp[0].minor.yy258);}
175883 break;
175884 case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
175885 { yymsp[-8].minor.yy258 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy402,yymsp[-3].minor.yy2,0,0,yymsp[0].minor.yy258); }
175886 break;
175887 case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */
175888 { yymsp[-4].minor.yy258 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
175889 break;
175890 case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
175891 { yymsp[-7].minor.yy258 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2,0);}
175892 break;
175893 case 170: /* returning ::= RETURNING selcollist */
175894 {sqlite3AddReturning(pParse,yymsp[0].minor.yy402);}
175895 break;
175896 case 173: /* idlist_opt ::= */
175897 {yymsp[1].minor.yy400 = 0;}
175898 break;
175899 case 174: /* idlist_opt ::= LP idlist RP */
175900 {yymsp[-2].minor.yy400 = yymsp[-1].minor.yy400;}
175901 break;
175902 case 175: /* idlist ::= idlist COMMA nm */
175903 {yymsp[-2].minor.yy400 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy400,&yymsp[0].minor.yy0);}
175904 break;
175905 case 176: /* idlist ::= nm */
175906 {yymsp[0].minor.yy400 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
175907 break;
175908 case 177: /* expr ::= LP expr RP */
175909 {yymsp[-2].minor.yy2 = yymsp[-1].minor.yy2;}
175910 break;
175911 case 178: /* expr ::= ID|INDEXED|JOIN_KW */
175912 {yymsp[0].minor.yy2=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
175913 break;
175914 case 179: /* expr ::= nm DOT nm */
175915 {
175916 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
175917 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
175918 yylhsminor.yy2 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
175919 }
175920 yymsp[-2].minor.yy2 = yylhsminor.yy2;
175921 break;
175922 case 180: /* expr ::= nm DOT nm DOT nm */
175923 {
175924 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
175925 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
175926 Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
175927 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
175928 if( IN_RENAME_OBJECT ){
175929 sqlite3RenameTokenRemap(pParse, 0, temp1);
175930 }
175931 yylhsminor.yy2 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
175932 }
175933 yymsp[-4].minor.yy2 = yylhsminor.yy2;
175934 break;
175935 case 181: /* term ::= NULL|FLOAT|BLOB */
175936 case 182: /* term ::= STRING */ yytestcase(yyruleno==182);
175937 {yymsp[0].minor.yy2=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
175938 break;
175939 case 183: /* term ::= INTEGER */
175940 {
175941 yylhsminor.yy2 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
175942 if( yylhsminor.yy2 ) yylhsminor.yy2->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
175943 }
175944 yymsp[0].minor.yy2 = yylhsminor.yy2;
175945 break;
175946 case 184: /* expr ::= VARIABLE */
175947 {
175948 if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
175949 u32 n = yymsp[0].minor.yy0.n;
175950 yymsp[0].minor.yy2 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
175951 sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy2, n);
175952 }else{
175953 /* When doing a nested parse, one can include terms in an expression
175954 ** that look like this: #1 #2 ... These terms refer to registers
175955 ** in the virtual machine. #N is the N-th register. */
175956 Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
175957 assert( t.n>=2 );
175958 if( pParse->nested==0 ){
175959 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
175960 yymsp[0].minor.yy2 = 0;
175961 }else{
175962 yymsp[0].minor.yy2 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
175963 if( yymsp[0].minor.yy2 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy2->iTable);
175964 }
175965 }
175966 }
175967 break;
175968 case 185: /* expr ::= expr COLLATE ID|STRING */
175969 {
175970 yymsp[-2].minor.yy2 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy2, &yymsp[0].minor.yy0, 1);
175971 }
175972 break;
175973 case 186: /* expr ::= CAST LP expr AS typetoken RP */
175974 {
175975 yymsp[-5].minor.yy2 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
175976 sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy2, yymsp[-3].minor.yy2, 0);
175977 }
175978 break;
175979 case 187: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
175980 {
175981 yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy92);
175982 }
175983 yymsp[-4].minor.yy2 = yylhsminor.yy2;
175984 break;
175985 case 188: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
175986 {
175987 yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy402, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy92);
175988 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy2, yymsp[-1].minor.yy402);
175989 }
175990 yymsp[-7].minor.yy2 = yylhsminor.yy2;
175991 break;
175992 case 189: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
175993 {
175994 yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
175995 }
175996 yymsp[-3].minor.yy2 = yylhsminor.yy2;
175997 break;
175998 case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
175999 {
176000 yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy402, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy92);
176001 sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176002 }
176003 yymsp[-5].minor.yy2 = yylhsminor.yy2;
176004 break;
176005 case 191: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
176006 {
176007 yylhsminor.yy2 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy402, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy92);
176008 sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176009 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy2, yymsp[-2].minor.yy402);
176010 }
176011 yymsp[-8].minor.yy2 = yylhsminor.yy2;
176012 break;
176013 case 192: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
176014 {
176015 yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
176016 sqlite3WindowAttach(pParse, yylhsminor.yy2, yymsp[0].minor.yy3);
176017 }
176018 yymsp[-4].minor.yy2 = yylhsminor.yy2;
176019 break;
176020 case 193: /* term ::= CTIME_KW */
176021 {
176022 yylhsminor.yy2 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
176023 }
176024 yymsp[0].minor.yy2 = yylhsminor.yy2;
176025 break;
176026 case 194: /* expr ::= LP nexprlist COMMA expr RP */
176027 {
176028 ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy402, yymsp[-1].minor.yy2);
176029 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
176030 if( yymsp[-4].minor.yy2 ){
176031 yymsp[-4].minor.yy2->x.pList = pList;
176032 if( ALWAYS(pList->nExpr) ){
176033 yymsp[-4].minor.yy2->flags |= pList->a[0].pExpr->flags & EP_Propagate;
176034 }
176035 }else{
176036 sqlite3ExprListDelete(pParse->db, pList);
176037 }
176038 }
176039 break;
176040 case 195: /* expr ::= expr AND expr */
176041 {yymsp[-2].minor.yy2=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
176042 break;
176043 case 196: /* expr ::= expr OR expr */
176044 case 197: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==197);
176045 case 198: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==198);
176046 case 199: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==199);
176047 case 200: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==200);
176048 case 201: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==201);
176049 case 202: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==202);
176050 {yymsp[-2].minor.yy2=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);}
176051 break;
176052 case 203: /* likeop ::= NOT LIKE_KW|MATCH */
176053 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
176054 break;
176055 case 204: /* expr ::= expr likeop expr */
176056 {
176057 ExprList *pList;
176058 int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
176059 yymsp[-1].minor.yy0.n &= 0x7fffffff;
176060 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy2);
176061 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy2);
176062 yymsp[-2].minor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176063 if( bNot ) yymsp[-2].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy2, 0);
176064 if( yymsp[-2].minor.yy2 ) yymsp[-2].minor.yy2->flags |= EP_InfixFunc;
176065 }
176066 break;
176067 case 205: /* expr ::= expr likeop expr ESCAPE expr */
176068 {
176069 ExprList *pList;
176070 int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
176071 yymsp[-3].minor.yy0.n &= 0x7fffffff;
176072 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176073 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy2);
176074 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy2);
176075 yymsp[-4].minor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
176076 if( bNot ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176077 if( yymsp[-4].minor.yy2 ) yymsp[-4].minor.yy2->flags |= EP_InfixFunc;
176078 }
176079 break;
176080 case 206: /* expr ::= expr ISNULL|NOTNULL */
176081 {yymsp[-1].minor.yy2 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy2,0);}
176082 break;
176083 case 207: /* expr ::= expr NOT NULL */
176084 {yymsp[-2].minor.yy2 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy2,0);}
176085 break;
176086 case 208: /* expr ::= expr IS expr */
176087 {
176088 yymsp[-2].minor.yy2 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy2,yymsp[0].minor.yy2);
176089 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-2].minor.yy2, TK_ISNULL);
176090 }
176091 break;
176092 case 209: /* expr ::= expr IS NOT expr */
176093 {
176094 yymsp[-3].minor.yy2 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy2,yymsp[0].minor.yy2);
176095 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-3].minor.yy2, TK_NOTNULL);
176096 }
176097 break;
176098 case 210: /* expr ::= expr IS NOT DISTINCT FROM expr */
176099 {
176100 yymsp[-5].minor.yy2 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy2,yymsp[0].minor.yy2);
176101 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-5].minor.yy2, TK_ISNULL);
176102 }
176103 break;
176104 case 211: /* expr ::= expr IS DISTINCT FROM expr */
176105 {
176106 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy2,yymsp[0].minor.yy2);
176107 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy2, yymsp[-4].minor.yy2, TK_NOTNULL);
176108 }
176109 break;
176110 case 212: /* expr ::= NOT expr */
176111 case 213: /* expr ::= BITNOT expr */ yytestcase(yyruleno==213);
176112 {yymsp[-1].minor.yy2 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy2, 0);/*A-overwrites-B*/}
176113 break;
176114 case 214: /* expr ::= PLUS|MINUS expr */
176115 {
176116 yymsp[-1].minor.yy2 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy2, 0);
176117 /*A-overwrites-B*/
176118 }
176119 break;
176120 case 215: /* expr ::= expr PTR expr */
176121 {
176122 ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy2);
176123 pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy2);
176124 yylhsminor.yy2 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176125 }
176126 yymsp[-2].minor.yy2 = yylhsminor.yy2;
176127 break;
176128 case 216: /* between_op ::= BETWEEN */
176129 case 219: /* in_op ::= IN */ yytestcase(yyruleno==219);
176130 {yymsp[0].minor.yy92 = 0;}
176131 break;
176132 case 218: /* expr ::= expr between_op expr AND expr */
176133 {
176134 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176135 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy2);
176136 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy2, 0);
176137 if( yymsp[-4].minor.yy2 ){
176138 yymsp[-4].minor.yy2->x.pList = pList;
176139 }else{
176140 sqlite3ExprListDelete(pParse->db, pList);
176141 }
176142 if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176143 }
176144 break;
176145 case 221: /* expr ::= expr in_op LP exprlist RP */
176146 {
176147 if( yymsp[-1].minor.yy402==0 ){
176148 /* Expressions of the form
176149 **
176150 ** expr1 IN ()
176151 ** expr1 NOT IN ()
176152 **
176153 ** simplify to constants 0 (false) and 1 (true), respectively,
176154 ** regardless of the value of expr1.
176155 */
176156 sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy2);
176157 yymsp[-4].minor.yy2 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy92 ? "true" : "false");
176158 if( yymsp[-4].minor.yy2 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy2);
176159 }else{
176160 Expr *pRHS = yymsp[-1].minor.yy402->a[0].pExpr;
176161 if( yymsp[-1].minor.yy402->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy2->op!=TK_VECTOR ){
176162 yymsp[-1].minor.yy402->a[0].pExpr = 0;
176163 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176164 pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
176165 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy2, pRHS);
176166 }else if( yymsp[-1].minor.yy402->nExpr==1 && pRHS->op==TK_SELECT ){
176167 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176168 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pRHS->x.pSelect);
176169 pRHS->x.pSelect = 0;
176170 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176171 }else{
176172 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176173 if( yymsp[-4].minor.yy2==0 ){
176174 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy402);
176175 }else if( yymsp[-4].minor.yy2->pLeft->op==TK_VECTOR ){
176176 int nExpr = yymsp[-4].minor.yy2->pLeft->x.pList->nExpr;
176177 Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy402);
176178 if( pSelectRHS ){
176179 parserDoubleLinkSelect(pParse, pSelectRHS);
176180 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pSelectRHS);
176181 }
176182 }else{
176183 yymsp[-4].minor.yy2->x.pList = yymsp[-1].minor.yy402;
176184 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy2);
176185 }
176186 }
176187 if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176188 }
176189 }
176190 break;
176191 case 222: /* expr ::= LP select RP */
176192 {
176193 yymsp[-2].minor.yy2 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
176194 sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy2, yymsp[-1].minor.yy299);
176195 }
176196 break;
176197 case 223: /* expr ::= expr in_op LP select RP */
176198 {
176199 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176200 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, yymsp[-1].minor.yy299);
176201 if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176202 }
176203 break;
176204 case 224: /* expr ::= expr in_op nm dbnm paren_exprlist */
176205 {
176206 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
176207 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
176208 if( yymsp[0].minor.yy402 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy402);
176209 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy2, 0);
176210 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy2, pSelect);
176211 if( yymsp[-3].minor.yy92 ) yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy2, 0);
176212 }
176213 break;
176214 case 225: /* expr ::= EXISTS LP select RP */
176215 {
176216 Expr *p;
176217 p = yymsp[-3].minor.yy2 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
176218 sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy299);
176219 }
176220 break;
176221 case 226: /* expr ::= CASE case_operand case_exprlist case_else END */
176222 {
176223 yymsp[-4].minor.yy2 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy2, 0);
176224 if( yymsp[-4].minor.yy2 ){
176225 yymsp[-4].minor.yy2->x.pList = yymsp[-1].minor.yy2 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[-1].minor.yy2) : yymsp[-2].minor.yy402;
176226 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy2);
176227 }else{
176228 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy402);
176229 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy2);
176230 }
176231 }
176232 break;
176233 case 227: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
176234 {
176235 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[-2].minor.yy2);
176236 yymsp[-4].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy402, yymsp[0].minor.yy2);
176237 }
176238 break;
176239 case 228: /* case_exprlist ::= WHEN expr THEN expr */
176240 {
176241 yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy2);
176242 yymsp[-3].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy402, yymsp[0].minor.yy2);
176243 }
176244 break;
176245 case 233: /* nexprlist ::= nexprlist COMMA expr */
176246 {yymsp[-2].minor.yy402 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy402,yymsp[0].minor.yy2);}
176247 break;
176248 case 234: /* nexprlist ::= expr */
176249 {yymsp[0].minor.yy402 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy2); /*A-overwrites-Y*/}
176250 break;
176251 case 236: /* paren_exprlist ::= LP exprlist RP */
176252 case 241: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==241);
176253 {yymsp[-2].minor.yy402 = yymsp[-1].minor.yy402;}
176254 break;
176255 case 237: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
176256 {
176257 sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
176258 sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy402, yymsp[-10].minor.yy92,
176259 &yymsp[-11].minor.yy0, yymsp[0].minor.yy2, SQLITE_SO_ASC, yymsp[-8].minor.yy92, SQLITE_IDXTYPE_APPDEF);
176260 if( IN_RENAME_OBJECT && pParse->pNewIndex ){
176261 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
176262 }
176263 }
176264 break;
176265 case 238: /* uniqueflag ::= UNIQUE */
176266 case 280: /* raisetype ::= ABORT */ yytestcase(yyruleno==280);
176267 {yymsp[0].minor.yy92 = OE_Abort;}
176268 break;
176269 case 239: /* uniqueflag ::= */
176270 {yymsp[1].minor.yy92 = OE_None;}
176271 break;
176272 case 242: /* eidlist ::= eidlist COMMA nm collate sortorder */
176273 {
176274 yymsp[-4].minor.yy402 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy402, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy92, yymsp[0].minor.yy92);
176275 }
176276 break;
176277 case 243: /* eidlist ::= nm collate sortorder */
176278 {
176279 yymsp[-2].minor.yy402 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); /*A-overwrites-Y*/
176280 }
176281 break;
176282 case 246: /* cmd ::= DROP INDEX ifexists fullname */
176283 {sqlite3DropIndex(pParse, yymsp[0].minor.yy387, yymsp[-1].minor.yy92);}
176284 break;
176285 case 247: /* cmd ::= VACUUM vinto */
176286 {sqlite3Vacuum(pParse,0,yymsp[0].minor.yy2);}
176287 break;
176288 case 248: /* cmd ::= VACUUM nm vinto */
176289 {sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy2);}
176290 break;
176291 case 251: /* cmd ::= PRAGMA nm dbnm */
176292 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
176293 break;
176294 case 252: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
176295 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
176296 break;
176297 case 253: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
176298 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
176299 break;
176300 case 254: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
176301 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
176302 break;
176303 case 255: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
176304 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
176305 break;
176306 case 258: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
176307 {
176308 Token all;
176309 all.z = yymsp[-3].minor.yy0.z;
176310 all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
176311 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy347, &all);
176312 }
176313 break;
176314 case 259: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
176315 {
176316 sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy92, yymsp[-4].minor.yy210.a, yymsp[-4].minor.yy210.b, yymsp[-2].minor.yy387, yymsp[0].minor.yy2, yymsp[-10].minor.yy92, yymsp[-8].minor.yy92);
176317 yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
176318 }
176319 break;
176320 case 260: /* trigger_time ::= BEFORE|AFTER */
176321 { yymsp[0].minor.yy92 = yymsp[0].major; /*A-overwrites-X*/ }
176322 break;
176323 case 261: /* trigger_time ::= INSTEAD OF */
176324 { yymsp[-1].minor.yy92 = TK_INSTEAD;}
176325 break;
176326 case 262: /* trigger_time ::= */
176327 { yymsp[1].minor.yy92 = TK_BEFORE; }
176328 break;
176329 case 263: /* trigger_event ::= DELETE|INSERT */
176330 case 264: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==264);
176331 {yymsp[0].minor.yy210.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy210.b = 0;}
176332 break;
176333 case 265: /* trigger_event ::= UPDATE OF idlist */
176334 {yymsp[-2].minor.yy210.a = TK_UPDATE; yymsp[-2].minor.yy210.b = yymsp[0].minor.yy400;}
176335 break;
176336 case 266: /* when_clause ::= */
176337 case 285: /* key_opt ::= */ yytestcase(yyruleno==285);
176338 { yymsp[1].minor.yy2 = 0; }
176339 break;
176340 case 267: /* when_clause ::= WHEN expr */
176341 case 286: /* key_opt ::= KEY expr */ yytestcase(yyruleno==286);
176342 { yymsp[-1].minor.yy2 = yymsp[0].minor.yy2; }
176343 break;
176344 case 268: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
176345 {
176346 assert( yymsp[-2].minor.yy347!=0 );
176347 yymsp[-2].minor.yy347->pLast->pNext = yymsp[-1].minor.yy347;
176348 yymsp[-2].minor.yy347->pLast = yymsp[-1].minor.yy347;
176349 }
176350 break;
176351 case 269: /* trigger_cmd_list ::= trigger_cmd SEMI */
176352 {
176353 assert( yymsp[-1].minor.yy347!=0 );
176354 yymsp[-1].minor.yy347->pLast = yymsp[-1].minor.yy347;
176355 }
176356 break;
176357 case 270: /* trnm ::= nm DOT nm */
176358 {
176359 yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
176360 sqlite3ErrorMsg(pParse,
176361 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
176362 "statements within triggers");
176363 }
176364 break;
176365 case 271: /* tridxby ::= INDEXED BY nm */
176366 {
176367 sqlite3ErrorMsg(pParse,
176368 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
176369 "within triggers");
176370 }
176371 break;
176372 case 272: /* tridxby ::= NOT INDEXED */
176373 {
176374 sqlite3ErrorMsg(pParse,
176375 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
176376 "within triggers");
176377 }
176378 break;
176379 case 273: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
176380 {yylhsminor.yy347 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy387, yymsp[-3].minor.yy402, yymsp[-1].minor.yy2, yymsp[-7].minor.yy92, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy616);}
176381 yymsp[-8].minor.yy347 = yylhsminor.yy347;
176382 break;
176383 case 274: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
176384 {
176385 yylhsminor.yy347 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy400,yymsp[-2].minor.yy299,yymsp[-6].minor.yy92,yymsp[-1].minor.yy258,yymsp[-7].minor.yy616,yymsp[0].minor.yy616);/*yylhsminor.yy347-overwrites-yymsp[-6].minor.yy92*/
176386 }
176387 yymsp[-7].minor.yy347 = yylhsminor.yy347;
176388 break;
176389 case 275: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
176390 {yylhsminor.yy347 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy2, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy616);}
176391 yymsp[-5].minor.yy347 = yylhsminor.yy347;
176392 break;
176393 case 276: /* trigger_cmd ::= scanpt select scanpt */
176394 {yylhsminor.yy347 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy299, yymsp[-2].minor.yy616, yymsp[0].minor.yy616); /*yylhsminor.yy347-overwrites-yymsp[-1].minor.yy299*/}
176395 yymsp[-2].minor.yy347 = yylhsminor.yy347;
176396 break;
176397 case 277: /* expr ::= RAISE LP IGNORE RP */
176398 {
176399 yymsp[-3].minor.yy2 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
176400 if( yymsp[-3].minor.yy2 ){
176401 yymsp[-3].minor.yy2->affExpr = OE_Ignore;
176402 }
176403 }
176404 break;
176405 case 278: /* expr ::= RAISE LP raisetype COMMA nm RP */
176406 {
176407 yymsp[-5].minor.yy2 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
176408 if( yymsp[-5].minor.yy2 ) {
176409 yymsp[-5].minor.yy2->affExpr = (char)yymsp[-3].minor.yy92;
176410 }
176411 }
176412 break;
176413 case 279: /* raisetype ::= ROLLBACK */
176414 {yymsp[0].minor.yy92 = OE_Rollback;}
176415 break;
176416 case 281: /* raisetype ::= FAIL */
176417 {yymsp[0].minor.yy92 = OE_Fail;}
176418 break;
176419 case 282: /* cmd ::= DROP TRIGGER ifexists fullname */
176420 {
176421 sqlite3DropTrigger(pParse,yymsp[0].minor.yy387,yymsp[-1].minor.yy92);
176422 }
176423 break;
176424 case 283: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
176425 {
176426 sqlite3Attach(pParse, yymsp[-3].minor.yy2, yymsp[-1].minor.yy2, yymsp[0].minor.yy2);
176427 }
176428 break;
176429 case 284: /* cmd ::= DETACH database_kw_opt expr */
176430 {
176431 sqlite3Detach(pParse, yymsp[0].minor.yy2);
176432 }
176433 break;
176434 case 287: /* cmd ::= REINDEX */
176435 {sqlite3Reindex(pParse, 0, 0);}
176436 break;
176437 case 288: /* cmd ::= REINDEX nm dbnm */
176438 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176439 break;
176440 case 289: /* cmd ::= ANALYZE */
176441 {sqlite3Analyze(pParse, 0, 0);}
176442 break;
176443 case 290: /* cmd ::= ANALYZE nm dbnm */
176444 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176445 break;
176446 case 291: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
176447 {
176448 sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy387,&yymsp[0].minor.yy0);
176449 }
176450 break;
176451 case 292: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
176452 {
176453 yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
176454 sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
176455 }
176456 break;
176457 case 293: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
176458 {
176459 sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy387, &yymsp[0].minor.yy0);
176460 }
176461 break;
176462 case 294: /* add_column_fullname ::= fullname */
176463 {
176464 disableLookaside(pParse);
176465 sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy387);
176466 }
176467 break;
176468 case 295: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
176469 {
176470 sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy387, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
176471 }
176472 break;
176473 case 296: /* cmd ::= create_vtab */
176474 {sqlite3VtabFinishParse(pParse,0);}
176475 break;
176476 case 297: /* cmd ::= create_vtab LP vtabarglist RP */
176477 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
176478 break;
176479 case 298: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
176480 {
176481 sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy92);
176482 }
176483 break;
176484 case 299: /* vtabarg ::= */
176485 {sqlite3VtabArgInit(pParse);}
176486 break;
176487 case 300: /* vtabargtoken ::= ANY */
176488 case 301: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==301);
176489 case 302: /* lp ::= LP */ yytestcase(yyruleno==302);
176490 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
176491 break;
176492 case 303: /* with ::= WITH wqlist */
176493 case 304: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==304);
176494 { sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); }
176495 break;
176496 case 305: /* wqas ::= AS */
176497 {yymsp[0].minor.yy498 = M10d_Any;}
176498 break;
176499 case 306: /* wqas ::= AS MATERIALIZED */
176500 {yymsp[-1].minor.yy498 = M10d_Yes;}
176501 break;
176502 case 307: /* wqas ::= AS NOT MATERIALIZED */
176503 {yymsp[-2].minor.yy498 = M10d_No;}
176504 break;
176505 case 308: /* wqitem ::= nm eidlist_opt wqas LP select RP */
176506 {
176507 yymsp[-5].minor.yy79 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy402, yymsp[-1].minor.yy299, yymsp[-3].minor.yy498); /*A-overwrites-X*/
176508 }
176509 break;
176510 case 309: /* wqlist ::= wqitem */
176511 {
176512 yymsp[0].minor.yy131 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy79); /*A-overwrites-X*/
176513 }
176514 break;
176515 case 310: /* wqlist ::= wqlist COMMA wqitem */
176516 {
176517 yymsp[-2].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy131, yymsp[0].minor.yy79);
176518 }
176519 break;
176520 case 311: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
176521 {
176522 assert( yymsp[0].minor.yy3!=0 );
176523 sqlite3WindowChain(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy3);
176524 yymsp[0].minor.yy3->pNextWin = yymsp[-2].minor.yy3;
176525 yylhsminor.yy3 = yymsp[0].minor.yy3;
176526 }
176527 yymsp[-2].minor.yy3 = yylhsminor.yy3;
176528 break;
176529 case 312: /* windowdefn ::= nm AS LP window RP */
176530 {
176531 if( ALWAYS(yymsp[-1].minor.yy3) ){
176532 yymsp[-1].minor.yy3->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
176533 }
176534 yylhsminor.yy3 = yymsp[-1].minor.yy3;
176535 }
176536 yymsp[-4].minor.yy3 = yylhsminor.yy3;
176537 break;
176538 case 313: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
176539 {
176540 yymsp[-4].minor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, 0);
176541 }
176542 break;
176543 case 314: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
176544 {
176545 yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, yymsp[-2].minor.yy402, yymsp[-1].minor.yy402, &yymsp[-5].minor.yy0);
176546 }
176547 yymsp[-5].minor.yy3 = yylhsminor.yy3;
176548 break;
176549 case 315: /* window ::= ORDER BY sortlist frame_opt */
176550 {
176551 yymsp[-3].minor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, yymsp[-1].minor.yy402, 0);
176552 }
176553 break;
176554 case 316: /* window ::= nm ORDER BY sortlist frame_opt */
176555 {
176556 yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, yymsp[-1].minor.yy402, &yymsp[-4].minor.yy0);
176557 }
176558 yymsp[-4].minor.yy3 = yylhsminor.yy3;
176559 break;
176560 case 317: /* window ::= nm frame_opt */
176561 {
176562 yylhsminor.yy3 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy3, 0, 0, &yymsp[-1].minor.yy0);
176563 }
176564 yymsp[-1].minor.yy3 = yylhsminor.yy3;
176565 break;
176566 case 318: /* frame_opt ::= */
176567 {
176568 yymsp[1].minor.yy3 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
176569 }
176570 break;
176571 case 319: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
176572 {
176573 yylhsminor.yy3 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy92, yymsp[-1].minor.yy337.eType, yymsp[-1].minor.yy337.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy498);
176574 }
176575 yymsp[-2].minor.yy3 = yylhsminor.yy3;
176576 break;
176577 case 320: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
176578 {
176579 yylhsminor.yy3 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy92, yymsp[-3].minor.yy337.eType, yymsp[-3].minor.yy337.pExpr, yymsp[-1].minor.yy337.eType, yymsp[-1].minor.yy337.pExpr, yymsp[0].minor.yy498);
176580 }
176581 yymsp[-5].minor.yy3 = yylhsminor.yy3;
176582 break;
176583 case 322: /* frame_bound_s ::= frame_bound */
176584 case 324: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==324);
176585 {yylhsminor.yy337 = yymsp[0].minor.yy337;}
176586 yymsp[0].minor.yy337 = yylhsminor.yy337;
176587 break;
176588 case 323: /* frame_bound_s ::= UNBOUNDED PRECEDING */
176589 case 325: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==325);
176590 case 327: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==327);
176591 {yylhsminor.yy337.eType = yymsp[-1].major; yylhsminor.yy337.pExpr = 0;}
176592 yymsp[-1].minor.yy337 = yylhsminor.yy337;
176593 break;
176594 case 326: /* frame_bound ::= expr PRECEDING|FOLLOWING */
176595 {yylhsminor.yy337.eType = yymsp[0].major; yylhsminor.yy337.pExpr = yymsp[-1].minor.yy2;}
176596 yymsp[-1].minor.yy337 = yylhsminor.yy337;
176597 break;
176598 case 328: /* frame_exclude_opt ::= */
176599 {yymsp[1].minor.yy498 = 0;}
176600 break;
176601 case 329: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
176602 {yymsp[-1].minor.yy498 = yymsp[0].minor.yy498;}
176603 break;
176604 case 330: /* frame_exclude ::= NO OTHERS */
176605 case 331: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==331);
176606 {yymsp[-1].minor.yy498 = yymsp[-1].major; /*A-overwrites-X*/}
176607 break;
176608 case 332: /* frame_exclude ::= GROUP|TIES */
176609 {yymsp[0].minor.yy498 = yymsp[0].major; /*A-overwrites-X*/}
176610 break;
176611 case 333: /* window_clause ::= WINDOW windowdefn_list */
176612 { yymsp[-1].minor.yy3 = yymsp[0].minor.yy3; }
176613 break;
176614 case 334: /* filter_over ::= filter_clause over_clause */
176615 {
176616 if( yymsp[0].minor.yy3 ){
176617 yymsp[0].minor.yy3->pFilter = yymsp[-1].minor.yy2;
176618 }else{
176619 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy2);
176620 }
176621 yylhsminor.yy3 = yymsp[0].minor.yy3;
176622 }
176623 yymsp[-1].minor.yy3 = yylhsminor.yy3;
176624 break;
176625 case 335: /* filter_over ::= over_clause */
176626 {
176627 yylhsminor.yy3 = yymsp[0].minor.yy3;
176628 }
176629 yymsp[0].minor.yy3 = yylhsminor.yy3;
176630 break;
176631 case 336: /* filter_over ::= filter_clause */
176632 {
176633 yylhsminor.yy3 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176634 if( yylhsminor.yy3 ){
176635 yylhsminor.yy3->eFrmType = TK_FILTER;
176636 yylhsminor.yy3->pFilter = yymsp[0].minor.yy2;
176637 }else{
176638 sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy2);
176639 }
176640 }
176641 yymsp[0].minor.yy3 = yylhsminor.yy3;
176642 break;
176643 case 337: /* over_clause ::= OVER LP window RP */
176644 {
176645 yymsp[-3].minor.yy3 = yymsp[-1].minor.yy3;
176646 assert( yymsp[-3].minor.yy3!=0 );
176647 }
176648 break;
176649 case 338: /* over_clause ::= OVER nm */
176650 {
176651 yymsp[-1].minor.yy3 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176652 if( yymsp[-1].minor.yy3 ){
176653 yymsp[-1].minor.yy3->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
176654 }
176655 }
176656 break;
176657 case 339: /* filter_clause ::= FILTER LP WHERE expr RP */
176658 { yymsp[-4].minor.yy2 = yymsp[-1].minor.yy2; }
176659 break;
176660 case 340: /* term ::= QNUMBER */
176661 {
176662 yylhsminor.yy2=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
176663 sqlite3DequoteNumber(pParse, yylhsminor.yy2);
176664 }
176665 yymsp[0].minor.yy2 = yylhsminor.yy2;
 
 
 
176666 break;
176667 default:
176668 /* (341) input ::= cmdlist */ yytestcase(yyruleno==341);
176669 /* (342) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==342);
176670 /* (343) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=343);
176671 /* (344) ecmd ::= SEMI */ yytestcase(yyruleno==344);
176672 /* (345) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==345);
176673 /* (346) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=346);
176674 /* (347) trans_opt ::= */ yytestcase(yyruleno==347);
176675 /* (348) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==348);
176676 /* (349) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==349);
176677 /* (350) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==350);
176678 /* (351) savepoint_opt ::= */ yytestcase(yyruleno==351);
176679 /* (352) cmd ::= create_table create_table_args */ yytestcase(yyruleno==352);
176680 /* (353) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=353);
176681 /* (354) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==354);
176682 /* (355) columnlist ::= columnname carglist */ yytestcase(yyruleno==355);
176683 /* (356) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==356);
176684 /* (357) nm ::= STRING */ yytestcase(yyruleno==357);
176685 /* (358) typetoken ::= typename */ yytestcase(yyruleno==358);
176686 /* (359) typename ::= ID|STRING */ yytestcase(yyruleno==359);
176687 /* (360) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=360);
176688 /* (361) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=361);
176689 /* (362) carglist ::= carglist ccons */ yytestcase(yyruleno==362);
176690 /* (363) carglist ::= */ yytestcase(yyruleno==363);
176691 /* (364) ccons ::= NULL onconf */ yytestcase(yyruleno==364);
176692 /* (365) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==365);
176693 /* (366) ccons ::= AS generated */ yytestcase(yyruleno==366);
176694 /* (367) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==367);
176695 /* (368) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==368);
176696 /* (369) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=369);
176697 /* (370) tconscomma ::= */ yytestcase(yyruleno==370);
176698 /* (371) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=371);
176699 /* (372) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=372);
176700 /* (373) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=373);
176701 /* (374) oneselect ::= values */ yytestcase(yyruleno==374);
176702 /* (375) sclp ::= selcollist COMMA */ yytestcase(yyruleno==375);
176703 /* (376) as ::= ID|STRING */ yytestcase(yyruleno==376);
176704 /* (377) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=377);
176705 /* (378) returning ::= */ yytestcase(yyruleno==378);
176706 /* (379) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=379);
176707 /* (380) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==380);
176708 /* (381) case_operand ::= expr */ yytestcase(yyruleno==381);
176709 /* (382) exprlist ::= nexprlist */ yytestcase(yyruleno==382);
176710 /* (383) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=383);
176711 /* (384) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=384);
176712 /* (385) nmnum ::= ON */ yytestcase(yyruleno==385);
176713 /* (386) nmnum ::= DELETE */ yytestcase(yyruleno==386);
176714 /* (387) nmnum ::= DEFAULT */ yytestcase(yyruleno==387);
176715 /* (388) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==388);
176716 /* (389) foreach_clause ::= */ yytestcase(yyruleno==389);
176717 /* (390) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==390);
176718 /* (391) trnm ::= nm */ yytestcase(yyruleno==391);
176719 /* (392) tridxby ::= */ yytestcase(yyruleno==392);
176720 /* (393) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==393);
176721 /* (394) database_kw_opt ::= */ yytestcase(yyruleno==394);
176722 /* (395) kwcolumn_opt ::= */ yytestcase(yyruleno==395);
176723 /* (396) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==396);
176724 /* (397) vtabarglist ::= vtabarg */ yytestcase(yyruleno==397);
176725 /* (398) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==398);
176726 /* (399) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==399);
176727 /* (400) anylist ::= */ yytestcase(yyruleno==400);
176728 /* (401) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==401);
176729 /* (402) anylist ::= anylist ANY */ yytestcase(yyruleno==402);
176730 /* (403) with ::= */ yytestcase(yyruleno==403);
176731 /* (404) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=404);
176732 /* (405) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=405);
176733 break;
176734 /********** End reduce actions ************************************************/
176735 };
176736 assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
176737 yygoto = yyRuleInfoLhs[yyruleno];
@@ -251503,11 +251802,11 @@
251503 int nArg, /* Number of args */
251504 sqlite3_value **apUnused /* Function arguments */
251505 ){
251506 assert( nArg==0 );
251507 UNUSED_PARAM2(nArg, apUnused);
251508 sqlite3_result_text(pCtx, "fts5: 2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f", -1, SQLITE_TRANSIENT);
251509 }
251510
251511 /*
251512 ** Return true if zName is the extension on one of the shadow tables used
251513 ** by this module.
251514
--- extsrc/sqlite3.c
+++ extsrc/sqlite3.c
@@ -16,11 +16,11 @@
16 ** if you want a wrapper to interface SQLite with your choice of programming
17 ** language. The code for the "sqlite3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
19 **
20 ** The content in this amalgamation comes from Fossil check-in
21 ** 76fb3a908f45230b956cb659c754e47603e8.
22 */
23 #define SQLITE_CORE 1
24 #define SQLITE_AMALGAMATION 1
25 #ifndef SQLITE_PRIVATE
26 # define SQLITE_PRIVATE static
@@ -459,11 +459,11 @@
459 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460 ** [sqlite_version()] and [sqlite_source_id()].
461 */
462 #define SQLITE_VERSION "3.46.0"
463 #define SQLITE_VERSION_NUMBER 3046000
464 #define SQLITE_SOURCE_ID "2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61"
465
466 /*
467 ** CAPI3REF: Run-Time Library Version Numbers
468 ** KEYWORDS: sqlite3_version sqlite3_sourceid
469 **
@@ -19173,14 +19173,16 @@
19173 ** In the colUsed field, the high-order bit (bit 63) is set if the table
19174 ** contains more than 63 columns and the 64-th or later column is used.
19175 **
19176 ** Union member validity:
19177 **
19178 ** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc
19179 ** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy
19180 ** u1.nRow !fg.isTabFunc && !fg.isIndexedBy
19181 **
19182 ** u2.pIBIndex fg.isIndexedBy && !fg.isCte
19183 ** u2.pCteUse fg.isCte && !fg.isIndexedBy
19184 */
19185 struct SrcItem {
19186 Schema *pSchema; /* Schema to which this item is fixed */
19187 char *zDatabase; /* Name of database holding this table */
19188 char *zName; /* Name of the table */
@@ -19214,10 +19216,11 @@
19216 } u3;
19217 Bitmask colUsed; /* Bit N set if column N used. Details above for N>62 */
19218 union {
19219 char *zIndexedBy; /* Identifier from "INDEXED BY <zIndex>" clause */
19220 ExprList *pFuncArg; /* Arguments to table-valued-function */
19221 u32 nRow; /* Number of rows in a VALUES clause */
19222 } u1;
19223 union {
19224 Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */
19225 CteUse *pCteUse; /* CTE Usage info when fg.isCte is true */
19226 } u2;
@@ -19715,10 +19718,11 @@
19718 u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */
19719 u8 okConstFactor; /* OK to factor out constants */
19720 u8 disableLookaside; /* Number of times lookaside has been disabled */
19721 u8 prepFlags; /* SQLITE_PREPARE_* flags */
19722 u8 withinRJSubrtn; /* Nesting level for RIGHT JOIN body subroutines */
19723 u8 bHasWith; /* True if statement contains WITH */
19724 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
19725 u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */
19726 #endif
19727 #ifdef SQLITE_DEBUG
19728 u8 ifNotExists; /* Might be true if IF NOT EXISTS. Assert()s only */
@@ -20389,10 +20393,13 @@
20393 int regEndRowid;
20394 u8 bExprArgs; /* Defer evaluation of window function arguments
20395 ** due to the SQLITE_SUBTYPE flag */
20396 };
20397
20398 SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow);
20399 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
20400
20401 #ifndef SQLITE_OMIT_WINDOWFUNC
20402 SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*);
20403 SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*);
20404 SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p);
20405 SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
@@ -20957,12 +20964,11 @@
20964 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
20965 SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
20966 SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*);
20967 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*);
20968 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*);
20969 SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse*,Expr*);
 
20970 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
20971 SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
20972 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int);
20973 SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int);
20974 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -31896,10 +31902,14 @@
31902 }else{
31903 Select *pSel = pItem->pSelect;
31904 assert( pSel!=0 );
31905 if( pSel->selFlags & SF_NestedFrom ){
31906 sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
31907 }else if( pSel->selFlags & SF_MultiValue ){
31908 assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy );
31909 sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE",
31910 pItem->u1.nRow);
31911 }else{
31912 sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId);
31913 }
31914 }
31915 length = width = 0;
@@ -109036,13 +109046,14 @@
109046 if( ExprHasProperty(pExpr, EP_Unlikely) ){
109047 assert( ExprUseXList(pExpr) );
109048 assert( pExpr->x.pList->nExpr>0 );
109049 assert( pExpr->op==TK_FUNCTION );
109050 pExpr = pExpr->x.pList->a[0].pExpr;
109051 }else if( pExpr->op==TK_COLLATE ){
 
109052 pExpr = pExpr->pLeft;
109053 }else{
109054 break;
109055 }
109056 }
109057 return pExpr;
109058 }
109059
@@ -110687,10 +110698,11 @@
110698 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
110699 pNewItem->fg = pOldItem->fg;
110700 pNewItem->iCursor = pOldItem->iCursor;
110701 pNewItem->addrFillSub = pOldItem->addrFillSub;
110702 pNewItem->regReturn = pOldItem->regReturn;
110703 pNewItem->regResult = pOldItem->regResult;
110704 if( pNewItem->fg.isIndexedBy ){
110705 pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
110706 }
110707 pNewItem->u2 = pOldItem->u2;
110708 if( pNewItem->fg.isCte ){
@@ -111163,10 +111175,58 @@
111175 }
111176 }
111177 return pExpr;
111178 }
111179
111180 /*
111181 ** pExpr is a TK_FUNCTION node. Try to determine whether or not the
111182 ** function is a constant function. A function is constant if all of
111183 ** the following are true:
111184 **
111185 ** (1) It is a scalar function (not an aggregate or window function)
111186 ** (2) It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
111187 ** property.
111188 ** (3) All of its arguments are constants
111189 **
111190 ** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
111191 ** It makes no changes to pWalker->eCode if pExpr is constant. In
111192 ** every case, it returns WRC_Abort.
111193 **
111194 ** Called as a service subroutine from exprNodeIsConstant().
111195 */
111196 static SQLITE_NOINLINE int exprNodeIsConstantFunction(
111197 Walker *pWalker,
111198 Expr *pExpr
111199 ){
111200 int n; /* Number of arguments */
111201 ExprList *pList; /* List of arguments */
111202 FuncDef *pDef; /* The function */
111203 sqlite3 *db; /* The database */
111204
111205 assert( pExpr->op==TK_FUNCTION );
111206 if( ExprHasProperty(pExpr, EP_TokenOnly)
111207 || (pList = pExpr->x.pList)==0
111208 ){;
111209 n = 0;
111210 }else{
111211 n = pList->nExpr;
111212 sqlite3WalkExprList(pWalker, pList);
111213 if( pWalker->eCode==0 ) return WRC_Abort;
111214 }
111215 db = pWalker->pParse->db;
111216 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
111217 if( pDef==0
111218 || pDef->xFinalize!=0
111219 || (pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
111220 || ExprHasProperty(pExpr, EP_WinFunc)
111221 ){
111222 pWalker->eCode = 0;
111223 return WRC_Abort;
111224 }
111225 return WRC_Continue;
111226 }
111227
111228
111229 /*
111230 ** These routines are Walker callbacks used to check expressions to
111231 ** see if they are "constant" for some definition of constant. The
111232 ** Walker.eCode value determines the type of "constant" we are looking
@@ -111191,10 +111251,11 @@
111251 ** contain a bound parameter because they were generated by older versions
111252 ** of SQLite to be parsed by newer versions of SQLite without raising a
111253 ** malformed schema error.
111254 */
111255 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
111256 assert( pWalker->eCode>0 );
111257
111258 /* If pWalker->eCode is 2 then any term of the expression that comes from
111259 ** the ON or USING clauses of an outer join disqualifies the expression
111260 ** from being considered constant. */
111261 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
@@ -111210,10 +111271,12 @@
111271 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
111272 && !ExprHasProperty(pExpr, EP_WinFunc)
111273 ){
111274 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
111275 return WRC_Continue;
111276 }else if( pWalker->pParse ){
111277 return exprNodeIsConstantFunction(pWalker, pExpr);
111278 }else{
111279 pWalker->eCode = 0;
111280 return WRC_Abort;
111281 }
111282 case TK_ID:
@@ -111262,13 +111325,14 @@
111325 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
111326 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
111327 return WRC_Continue;
111328 }
111329 }
111330 static int exprIsConst(Parse *pParse, Expr *p, int initFlag, int iCur){
111331 Walker w;
111332 w.eCode = initFlag;
111333 w.pParse = pParse;
111334 w.xExprCallback = exprNodeIsConstant;
111335 w.xSelectCallback = sqlite3SelectWalkFail;
111336 #ifdef SQLITE_DEBUG
111337 w.xSelectCallback2 = sqlite3SelectWalkAssert2;
111338 #endif
@@ -111282,13 +111346,19 @@
111346 ** and 0 if it involves variables or function calls.
111347 **
111348 ** For the purposes of this function, a double-quoted string (ex: "abc")
111349 ** is considered a variable but a single-quoted string (ex: 'abc') is
111350 ** a constant.
111351 **
111352 ** The pParse parameter may be NULL. But if it is NULL, there is no way
111353 ** to determine if function calls are constant or not, and hence all
111354 ** function calls will be considered to be non-constant. If pParse is
111355 ** not NULL, then a function call might be constant, depending on the
111356 ** function and on its parameters.
111357 */
111358 SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse *pParse, Expr *p){
111359 return exprIsConst(pParse, p, 1, 0);
111360 }
111361
111362 /*
111363 ** Walk an expression tree. Return non-zero if
111364 **
@@ -111300,22 +111370,22 @@
111370 **
111371 ** When this routine returns true, it indicates that the expression
111372 ** can be added to the pParse->pConstExpr list and evaluated once when
111373 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
111374 */
111375 static int sqlite3ExprIsConstantNotJoin(Parse *pParse, Expr *p){
111376 return exprIsConst(pParse, p, 2, 0);
111377 }
111378
111379 /*
111380 ** Walk an expression tree. Return non-zero if the expression is constant
111381 ** for any single row of the table with cursor iCur. In other words, the
111382 ** expression must not refer to any non-deterministic function nor any
111383 ** table other than iCur.
111384 */
111385 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
111386 return exprIsConst(0, p, 3, iCur);
111387 }
111388
111389 /*
111390 ** Check pExpr to see if it is an constraint on the single data source
111391 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
@@ -111468,11 +111538,11 @@
111538 ** is considered a variable but a single-quoted string (ex: 'abc') is
111539 ** a constant.
111540 */
111541 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){
111542 assert( isInit==0 || isInit==1 );
111543 return exprIsConst(0, p, 4+isInit, 0);
111544 }
111545
111546 #ifdef SQLITE_ENABLE_CURSOR_HINTS
111547 /*
111548 ** Walk an expression tree. Return 1 if the expression contains a
@@ -111713,17 +111783,17 @@
111783 #ifndef SQLITE_OMIT_SUBQUERY
111784 /*
111785 ** The argument is an IN operator with a list (not a subquery) on the
111786 ** right-hand side. Return TRUE if that list is constant.
111787 */
111788 static int sqlite3InRhsIsConstant(Parse *pParse, Expr *pIn){
111789 Expr *pLHS;
111790 int res;
111791 assert( !ExprHasProperty(pIn, EP_xIsSelect) );
111792 pLHS = pIn->pLeft;
111793 pIn->pLeft = 0;
111794 res = sqlite3ExprIsConstant(pParse, pIn);
111795 pIn->pLeft = pLHS;
111796 return res;
111797 }
111798 #endif
111799
@@ -111988,11 +112058,11 @@
112058 ** the IN operator so return IN_INDEX_NOOP.
112059 */
112060 if( eType==0
112061 && (inFlags & IN_INDEX_NOOP_OK)
112062 && ExprUseXList(pX)
112063 && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
112064 ){
112065 pParse->nTab--; /* Back out the allocation of the unused cursor */
112066 iTab = -1; /* Cursor is not allocated */
112067 eType = IN_INDEX_NOOP;
112068 }
@@ -112271,11 +112341,11 @@
112341 /* If the expression is not constant then we will need to
112342 ** disable the test that was generated above that makes sure
112343 ** this code only executes once. Because for a non-constant
112344 ** expression we need to rerun this code each time.
112345 */
112346 if( addrOnce && !sqlite3ExprIsConstant(pParse, pE2) ){
112347 sqlite3VdbeChangeToNoop(v, addrOnce-1);
112348 sqlite3VdbeChangeToNoop(v, addrOnce);
112349 ExprClearProperty(pExpr, EP_Subrtn);
112350 addrOnce = 0;
112351 }
@@ -113608,11 +113678,13 @@
113678 if( ExprHasProperty(pExpr, EP_WinFunc) ){
113679 return pExpr->y.pWin->regResult;
113680 }
113681 #endif
113682
113683 if( ConstFactorOk(pParse)
113684 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
113685 ){
113686 /* SQL functions can be expensive. So try to avoid running them
113687 ** multiple times if we know they always give the same result */
113688 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113689 }
113690 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
@@ -113639,11 +113711,11 @@
113711 }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){
113712 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113713 }
113714
113715 for(i=0; i<nFarg; i++){
113716 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
113717 testcase( i==31 );
113718 constMask |= MASKBIT32(i);
113719 }
113720 if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
113721 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
@@ -114106,11 +114178,11 @@
114178 int r2;
114179 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
114180 if( ConstFactorOk(pParse)
114181 && ALWAYS(pExpr!=0)
114182 && pExpr->op!=TK_REGISTER
114183 && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
114184 ){
114185 *pReg = 0;
114186 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114187 }else{
114188 int r1 = sqlite3GetTempReg(pParse);
@@ -114170,11 +114242,11 @@
114242 ** results in register target. The results are guaranteed to appear
114243 ** in register target. If the expression is constant, then this routine
114244 ** might choose to code the expression at initialization time.
114245 */
114246 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
114247 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
114248 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
114249 }else{
114250 sqlite3ExprCodeCopy(pParse, pExpr, target);
114251 }
114252 }
@@ -114229,11 +114301,11 @@
114301 n--;
114302 }else{
114303 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
114304 }
114305 }else if( (flags & SQLITE_ECEL_FACTOR)!=0
114306 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
114307 ){
114308 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
114309 }else{
114310 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
114311 if( inReg!=target+i ){
@@ -133152,10 +133224,197 @@
133224 */
133225 # define autoIncBegin(A,B,C) (0)
133226 # define autoIncStep(A,B,C)
133227 #endif /* SQLITE_OMIT_AUTOINCREMENT */
133228
133229 /*
133230 ** If argument pVal is a Select object returned by an sqlite3MultiValues()
133231 ** that was able to use the co-routine optimization, finish coding the
133232 ** co-routine.
133233 */
133234 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
133235 if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
133236 SrcItem *pItem = &pVal->pSrc->a[0];
133237 sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->regReturn);
133238 sqlite3VdbeJumpHere(pParse->pVdbe, pItem->addrFillSub - 1);
133239 }
133240 }
133241
133242 /*
133243 ** Return true if all expressions in the expression-list passed as the
133244 ** only argument are constant.
133245 */
133246 static int exprListIsConstant(Parse *pParse, ExprList *pRow){
133247 int ii;
133248 for(ii=0; ii<pRow->nExpr; ii++){
133249 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
133250 }
133251 return 1;
133252 }
133253
133254 /*
133255 ** Return true if all expressions in the expression-list passed as the
133256 ** only argument are both constant and have no affinity.
133257 */
133258 static int exprListIsNoAffinity(Parse *pParse, ExprList *pRow){
133259 int ii;
133260 if( exprListIsConstant(pParse,pRow)==0 ) return 0;
133261 for(ii=0; ii<pRow->nExpr; ii++){
133262 assert( pRow->a[ii].pExpr->affExpr==0 );
133263 if( 0!=sqlite3ExprAffinity(pRow->a[ii].pExpr) ) return 0;
133264 }
133265 return 1;
133266
133267 }
133268
133269 /*
133270 ** This function is called by the parser for the second and subsequent
133271 ** rows of a multi-row VALUES clause. Argument pLeft is the part of
133272 ** the VALUES clause already parsed, argument pRow is the vector of values
133273 ** for the new row. The Select object returned represents the complete
133274 ** VALUES clause, including the new row.
133275 **
133276 ** There are two ways in which this may be achieved - by incremental
133277 ** coding of a co-routine (the "co-routine" method) or by returning a
133278 ** Select object equivalent to the following (the "UNION ALL" method):
133279 **
133280 ** "pLeft UNION ALL SELECT pRow"
133281 **
133282 ** If the VALUES clause contains a lot of rows, this compound Select
133283 ** object may consume a lot of memory.
133284 **
133285 ** When the co-routine method is used, each row that will be returned
133286 ** by the VALUES clause is coded into part of a co-routine as it is
133287 ** passed to this function. The returned Select object is equivalent to:
133288 **
133289 ** SELECT * FROM (
133290 ** Select object to read co-routine
133291 ** )
133292 **
133293 ** The co-routine method is used in most cases. Exceptions are:
133294 **
133295 ** a) If the current statement has a WITH clause. This is to avoid
133296 ** statements like:
133297 **
133298 ** WITH cte AS ( VALUES('x'), ('y') ... )
133299 ** SELECT * FROM cte AS a, cte AS b;
133300 **
133301 ** This will not work, as the co-routine uses a hard-coded register
133302 ** for its OP_Yield instructions, and so it is not possible for two
133303 ** cursors to iterate through it concurrently.
133304 **
133305 ** b) The schema is currently being parsed (i.e. the VALUES clause is part
133306 ** of a schema item like a VIEW or TRIGGER). In this case there is no VM
133307 ** being generated when parsing is taking place, and so generating
133308 ** a co-routine is not possible.
133309 **
133310 ** c) There are non-constant expressions in the VALUES clause (e.g.
133311 ** the VALUES clause is part of a correlated sub-query).
133312 **
133313 ** d) One or more of the values in the first row of the VALUES clause
133314 ** has an affinity (i.e. is a CAST expression). This causes problems
133315 ** because the complex rules SQLite uses (see function
133316 ** sqlite3SubqueryColumnTypes() in select.c) to determine the effective
133317 ** affinity of such a column for all rows require access to all values in
133318 ** the column simultaneously.
133319 */
133320 SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){
133321
133322 if( pParse->bHasWith /* condition (a) above */
133323 || pParse->db->init.busy /* condition (b) above */
133324 || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */
133325 || (pLeft->pSrc->nSrc==0 &&
133326 exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
133327 || IN_SPECIAL_PARSE
133328 ){
133329 /* The co-routine method cannot be used. Fall back to UNION ALL. */
133330 Select *pSelect = 0;
133331 int f = SF_Values | SF_MultiValue;
133332 if( pLeft->pSrc->nSrc ){
133333 sqlite3MultiValuesEnd(pParse, pLeft);
133334 f = SF_Values;
133335 }else if( pLeft->pPrior ){
133336 /* In this case set the SF_MultiValue flag only if it was set on pLeft */
133337 f = (f & pLeft->selFlags);
133338 }
133339 pSelect = sqlite3SelectNew(pParse, pRow, 0, 0, 0, 0, 0, f, 0);
133340 pLeft->selFlags &= ~SF_MultiValue;
133341 if( pSelect ){
133342 pSelect->op = TK_ALL;
133343 pSelect->pPrior = pLeft;
133344 pLeft = pSelect;
133345 }
133346 }else{
133347 SrcItem *p = 0; /* SrcItem that reads from co-routine */
133348
133349 if( pLeft->pSrc->nSrc==0 ){
133350 /* Co-routine has not yet been started and the special Select object
133351 ** that accesses the co-routine has not yet been created. This block
133352 ** does both those things. */
133353 Vdbe *v = sqlite3GetVdbe(pParse);
133354 Select *pRet = sqlite3SelectNew(pParse, 0, 0, 0, 0, 0, 0, 0, 0);
133355
133356 /* Ensure the database schema has been read. This is to ensure we have
133357 ** the correct text encoding. */
133358 if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
133359 sqlite3ReadSchema(pParse);
133360 }
133361
133362 if( pRet ){
133363 SelectDest dest;
133364 pRet->pSrc->nSrc = 1;
133365 pRet->pPrior = pLeft->pPrior;
133366 pRet->op = pLeft->op;
133367 pLeft->pPrior = 0;
133368 pLeft->op = TK_SELECT;
133369 assert( pLeft->pNext==0 );
133370 assert( pRet->pNext==0 );
133371 p = &pRet->pSrc->a[0];
133372 p->pSelect = pLeft;
133373 p->fg.viaCoroutine = 1;
133374 p->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
133375 p->regReturn = ++pParse->nMem;
133376 p->iCursor = -1;
133377 p->u1.nRow = 2;
133378 sqlite3VdbeAddOp3(v,OP_InitCoroutine,p->regReturn,0,p->addrFillSub);
133379 sqlite3SelectDestInit(&dest, SRT_Coroutine, p->regReturn);
133380
133381 /* Allocate registers for the output of the co-routine. Do so so
133382 ** that there are two unused registers immediately before those
133383 ** used by the co-routine. This allows the code in sqlite3Insert()
133384 ** to use these registers directly, instead of copying the output
133385 ** of the co-routine to a separate array for processing. */
133386 dest.iSdst = pParse->nMem + 3;
133387 dest.nSdst = pLeft->pEList->nExpr;
133388 pParse->nMem += 2 + dest.nSdst;
133389
133390 pLeft->selFlags |= SF_MultiValue;
133391 sqlite3Select(pParse, pLeft, &dest);
133392 p->regResult = dest.iSdst;
133393 assert( pParse->nErr || dest.iSdst>0 );
133394 pLeft = pRet;
133395 }
133396 }else{
133397 p = &pLeft->pSrc->a[0];
133398 assert( !p->fg.isTabFunc && !p->fg.isIndexedBy );
133399 p->u1.nRow++;
133400 }
133401
133402 if( pParse->nErr==0 ){
133403 assert( p!=0 );
133404 if( p->pSelect->pEList->nExpr!=pRow->nExpr ){
133405 sqlite3SelectWrongNumTermsError(pParse, p->pSelect);
133406 }else{
133407 sqlite3ExprCodeExprList(pParse, pRow, p->regResult, 0, 0);
133408 sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, p->regReturn);
133409 }
133410 }
133411 sqlite3ExprListDelete(pParse->db, pRow);
133412 }
133413
133414 return pLeft;
133415 }
133416
133417 /* Forward declaration */
133418 static int xferOptimization(
133419 Parse *pParse, /* Parser context */
133420 Table *pDest, /* The table we are inserting into */
@@ -133488,29 +133747,44 @@
133747 ** co-routine is the common header to the 3rd and 4th templates.
133748 */
133749 if( pSelect ){
133750 /* Data is coming from a SELECT or from a multi-row VALUES clause.
133751 ** Generate a co-routine to run the SELECT. */
 
 
133752 int rc; /* Result code */
133753
133754 if( pSelect->pSrc->nSrc==1
133755 && pSelect->pSrc->a[0].fg.viaCoroutine
133756 && pSelect->pPrior==0
133757 ){
133758 SrcItem *pItem = &pSelect->pSrc->a[0];
133759 dest.iSDParm = pItem->regReturn;
133760 regFromSelect = pItem->regResult;
133761 nColumn = pItem->pSelect->pEList->nExpr;
133762 ExplainQueryPlan((pParse, 0, "SCAN %S", pItem));
133763 if( bIdListInOrder && nColumn==pTab->nCol ){
133764 regData = regFromSelect;
133765 regRowid = regData - 1;
133766 regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
133767 }
133768 }else{
133769 int addrTop; /* Top of the co-routine */
133770 int regYield = ++pParse->nMem;
133771 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
133772 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
133773 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
133774 dest.iSdst = bIdListInOrder ? regData : 0;
133775 dest.nSdst = pTab->nCol;
133776 rc = sqlite3Select(pParse, pSelect, &dest);
133777 regFromSelect = dest.iSdst;
133778 assert( db->pParse==pParse );
133779 if( rc || pParse->nErr ) goto insert_cleanup;
133780 assert( db->mallocFailed==0 );
133781 sqlite3VdbeEndCoroutine(v, regYield);
133782 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
133783 assert( pSelect->pEList );
133784 nColumn = pSelect->pEList->nExpr;
133785 }
133786
133787 /* Set useTempTable to TRUE if the result of the SELECT statement
133788 ** should be written into a temporary table (template 4). Set to
133789 ** FALSE if each output row of the SELECT can be written directly into
133790 ** the destination table (template 3).
@@ -147133,11 +147407,11 @@
147407 Expr *pValue, /* The VALUE part of the constraint */
147408 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
147409 ){
147410 int i;
147411 assert( pColumn->op==TK_COLUMN );
147412 assert( sqlite3ExprIsConstant(pConst->pParse, pValue) );
147413
147414 if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
147415 if( sqlite3ExprAffinity(pValue)!=0 ) return;
147416 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147417 return;
@@ -147191,14 +147465,14 @@
147465 if( pExpr->op!=TK_EQ ) return;
147466 pRight = pExpr->pRight;
147467 pLeft = pExpr->pLeft;
147468 assert( pRight!=0 );
147469 assert( pLeft!=0 );
147470 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pLeft) ){
147471 constInsert(pConst,pRight,pLeft,pExpr);
147472 }
147473 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pRight) ){
147474 constInsert(pConst,pLeft,pRight,pExpr);
147475 }
147476 }
147477
147478 /*
@@ -149993,11 +150267,11 @@
150267
150268 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
150269 /* Generate code for all sub-queries in the FROM clause
150270 */
150271 pSub = pItem->pSelect;
150272 if( pSub==0 || pItem->addrFillSub!=0 ) continue;
150273
150274 /* The code for a subquery should only be generated once. */
150275 assert( pItem->addrFillSub==0 );
150276
150277 /* Increment Parse.nHeight by the height of the largest expression
@@ -160532,11 +160806,11 @@
160806 if( pIdx->aColExpr==0 ) continue;
160807 for(i=0; i<pIdx->nKeyCol; i++){
160808 if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
160809 assert( pIdx->bHasExpr );
160810 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
160811 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
160812 ){
160813 aiCurCol[0] = iCur;
160814 aiCurCol[1] = XN_EXPR;
160815 return 1;
160816 }
@@ -162745,11 +163019,11 @@
163019 for(i=0; i<n; i++){
163020 Expr *pExpr = pOrderBy->a[i].pExpr;
163021 Expr *pE2;
163022
163023 /* Skip over constant terms in the ORDER BY clause */
163024 if( sqlite3ExprIsConstant(0, pExpr) ){
163025 continue;
163026 }
163027
163028 /* Virtual tables are unable to deal with NULLS FIRST */
163029 if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break;
@@ -162857,11 +163131,11 @@
163131 }
163132 assert( j==nTerm );
163133 pIdxInfo->nConstraint = j;
163134 for(i=j=0; i<nOrderBy; i++){
163135 Expr *pExpr = pOrderBy->a[i].pExpr;
163136 if( sqlite3ExprIsConstant(0, pExpr) ) continue;
163137 assert( pExpr->op==TK_COLUMN
163138 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
163139 && pExpr->iColumn==pExpr->pLeft->iColumn) );
163140 pIdxOrderBy[j].iColumn = pExpr->iColumn;
163141 pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC;
@@ -165039,11 +165313,11 @@
165313 Expr *pLeft = pPart->pLeft;
165314 Expr *pRight = pPart->pRight;
165315 u8 aff;
165316
165317 if( pLeft->op!=TK_COLUMN ) return;
165318 if( !sqlite3ExprIsConstant(0, pRight) ) return;
165319 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
165320 if( pLeft->iColumn<0 ) return;
165321 aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
165322 if( aff>=SQLITE_AFF_TEXT ){
165323 if( pItem ){
@@ -166413,11 +166687,11 @@
166687 Expr *p;
166688 Bitmask mTerm;
166689 if( MASKBIT(i) & obSat ) continue;
166690 p = pOrderBy->a[i].pExpr;
166691 mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
166692 if( mTerm==0 && !sqlite3ExprIsConstant(0,p) ) continue;
166693 if( (mTerm&~orderDistinctMask)==0 ){
166694 obSat |= MASKBIT(i);
166695 }
166696 }
166697 }
@@ -167282,11 +167556,11 @@
167556 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
167557 bMaybeNullRow = 0;
167558 }else{
167559 continue;
167560 }
167561 if( sqlite3ExprIsConstant(0,pExpr) ) continue;
167562 if( pExpr->op==TK_FUNCTION ){
167563 /* Functions that might set a subtype should not be replaced by the
167564 ** value taken from an expression index since the index omits the
167565 ** subtype. https://sqlite.org/forum/forumpost/68d284c86b082c3e */
167566 int n;
@@ -167560,11 +167834,15 @@
167834 if( (wctrlFlags & WHERE_WANT_DISTINCT)!=0
167835 && OptimizationEnabled(db, SQLITE_DistinctOpt)
167836 ){
167837 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
167838 }
167839 if( ALWAYS(pWInfo->pSelect)
167840 && (pWInfo->pSelect->selFlags & SF_MultiValue)==0
167841 ){
167842 ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
167843 }
167844 }else{
167845 /* Assign a bit from the bitmask to every term in the FROM clause.
167846 **
167847 ** The N-th term of the FROM clause is assigned a bitmask of 1<<N.
167848 **
@@ -168312,10 +168590,11 @@
168590 ** the co-routine into OP_Copy of result contained in a register.
168591 ** OP_Rowid becomes OP_Null.
168592 */
168593 if( pTabItem->fg.viaCoroutine ){
168594 testcase( pParse->db->mallocFailed );
168595 assert( pTabItem->regResult>=0 );
168596 translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
168597 pTabItem->regResult, 0);
168598 continue;
168599 }
168600
@@ -169616,11 +169895,11 @@
169895 ** constant, change it to NULL. The fact that it is then a non-negative
169896 ** integer will be caught later. But it is important not to leave
169897 ** variable values in the expression tree.
169898 */
169899 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
169900 if( 0==sqlite3ExprIsConstant(0,pExpr) ){
169901 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
169902 sqlite3ExprDelete(pParse->db, pExpr);
169903 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
169904 }
169905 return pExpr;
@@ -172042,35 +172321,35 @@
172321 #ifndef INTERFACE
172322 # define INTERFACE 1
172323 #endif
172324 /************* Begin control #defines *****************************************/
172325 #define YYCODETYPE unsigned short int
172326 #define YYNOCODE 322
172327 #define YYACTIONTYPE unsigned short int
172328 #define YYWILDCARD 101
172329 #define sqlite3ParserTOKENTYPE Token
172330 typedef union {
172331 int yyinit;
172332 sqlite3ParserTOKENTYPE yy0;
172333 ExprList* yy14;
172334 With* yy59;
172335 Cte* yy67;
172336 Upsert* yy122;
172337 IdList* yy132;
172338 int yy144;
172339 const char* yy168;
172340 SrcList* yy203;
172341 Window* yy211;
172342 OnOrUsing yy269;
172343 struct TrigEvent yy286;
172344 struct {int value; int mask;} yy383;
172345 u32 yy391;
172346 TriggerStep* yy427;
172347 Expr* yy454;
172348 u8 yy462;
172349 struct FrameBound yy509;
172350 Select* yy555;
172351 } YYMINORTYPE;
172352 #ifndef YYSTACKDEPTH
172353 #define YYSTACKDEPTH 100
172354 #endif
172355 #define sqlite3ParserARG_SDECL
@@ -172085,24 +172364,24 @@
172364 #define sqlite3ParserCTX_PDECL ,Parse *pParse
172365 #define sqlite3ParserCTX_PARAM ,pParse
172366 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
172367 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
172368 #define YYFALLBACK 1
172369 #define YYNSTATE 583
172370 #define YYNRULE 409
172371 #define YYNRULE_WITH_ACTION 344
172372 #define YYNTOKEN 186
172373 #define YY_MAX_SHIFT 582
172374 #define YY_MIN_SHIFTREDUCE 845
172375 #define YY_MAX_SHIFTREDUCE 1253
172376 #define YY_ERROR_ACTION 1254
172377 #define YY_ACCEPT_ACTION 1255
172378 #define YY_NO_ACTION 1256
172379 #define YY_MIN_REDUCE 1257
172380 #define YY_MAX_REDUCE 1665
172381 #define YY_MIN_DSTRCTR 205
172382 #define YY_MAX_DSTRCTR 319
172383 /************* End control #defines *******************************************/
172384 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
172385
172386 /* Define the yytestcase() macro to be a no-op if is not already defined
172387 ** otherwise.
@@ -172181,626 +172460,634 @@
172460 ** yy_reduce_ofst[] For each state, the offset into yy_action for
172461 ** shifting non-terminals after a reduce.
172462 ** yy_default[] Default action for each state.
172463 **
172464 *********** Begin parsing tables **********************************************/
172465 #define YY_ACTTAB_COUNT (2142)
172466 static const YYACTIONTYPE yy_action[] = {
172467 /* 0 */ 576, 128, 125, 232, 1622, 549, 576, 1290, 1281, 576,
172468 /* 10 */ 328, 576, 1300, 212, 576, 128, 125, 232, 578, 412,
172469 /* 20 */ 578, 391, 1542, 51, 51, 523, 405, 1293, 529, 51,
172470 /* 30 */ 51, 983, 51, 51, 81, 81, 1107, 61, 61, 984,
172471 /* 40 */ 1107, 1292, 380, 135, 136, 90, 1228, 1228, 1063, 1066,
172472 /* 50 */ 1053, 1053, 133, 133, 134, 134, 134, 134, 1577, 412,
172473 /* 60 */ 287, 287, 7, 287, 287, 422, 1050, 1050, 1064, 1067,
172474 /* 70 */ 289, 556, 492, 573, 524, 561, 573, 497, 561, 482,
172475 /* 80 */ 530, 262, 229, 135, 136, 90, 1228, 1228, 1063, 1066,
172476 /* 90 */ 1053, 1053, 133, 133, 134, 134, 134, 134, 128, 125,
172477 /* 100 */ 232, 1506, 132, 132, 132, 132, 131, 131, 130, 130,
172478 /* 110 */ 130, 129, 126, 450, 1204, 1255, 1, 1, 582, 2,
172479 /* 120 */ 1259, 1571, 420, 1582, 379, 320, 1174, 153, 1174, 1584,
172480 /* 130 */ 412, 378, 1582, 543, 1341, 330, 111, 570, 570, 570,
172481 /* 140 */ 293, 1054, 132, 132, 132, 132, 131, 131, 130, 130,
172482 /* 150 */ 130, 129, 126, 450, 135, 136, 90, 1228, 1228, 1063,
172483 /* 160 */ 1066, 1053, 1053, 133, 133, 134, 134, 134, 134, 287,
172484 /* 170 */ 287, 1204, 1205, 1204, 255, 287, 287, 510, 507, 506,
172485 /* 180 */ 137, 455, 573, 212, 561, 447, 446, 505, 573, 1616,
172486 /* 190 */ 561, 134, 134, 134, 134, 127, 400, 243, 132, 132,
172487 /* 200 */ 132, 132, 131, 131, 130, 130, 130, 129, 126, 450,
172488 /* 210 */ 282, 471, 345, 132, 132, 132, 132, 131, 131, 130,
172489 /* 220 */ 130, 130, 129, 126, 450, 574, 155, 936, 936, 454,
172490 /* 230 */ 227, 521, 1236, 412, 1236, 134, 134, 134, 134, 132,
172491 /* 240 */ 132, 132, 132, 131, 131, 130, 130, 130, 129, 126,
172492 /* 250 */ 450, 130, 130, 130, 129, 126, 450, 135, 136, 90,
172493 /* 260 */ 1228, 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134,
172494 /* 270 */ 134, 134, 128, 125, 232, 450, 576, 412, 397, 1249,
172495 /* 280 */ 180, 92, 93, 132, 132, 132, 132, 131, 131, 130,
172496 /* 290 */ 130, 130, 129, 126, 450, 381, 387, 1204, 383, 81,
172497 /* 300 */ 81, 135, 136, 90, 1228, 1228, 1063, 1066, 1053, 1053,
172498 /* 310 */ 133, 133, 134, 134, 134, 134, 132, 132, 132, 132,
172499 /* 320 */ 131, 131, 130, 130, 130, 129, 126, 450, 131, 131,
172500 /* 330 */ 130, 130, 130, 129, 126, 450, 556, 1204, 302, 319,
172501 /* 340 */ 567, 121, 568, 480, 4, 555, 1149, 1657, 1628, 1657,
172502 /* 350 */ 45, 128, 125, 232, 1204, 1205, 1204, 1250, 571, 1169,
172503 /* 360 */ 132, 132, 132, 132, 131, 131, 130, 130, 130, 129,
172504 /* 370 */ 126, 450, 1169, 287, 287, 1169, 1019, 576, 422, 1019,
172505 /* 380 */ 412, 451, 1602, 582, 2, 1259, 573, 44, 561, 95,
172506 /* 390 */ 320, 110, 153, 565, 1204, 1205, 1204, 522, 522, 1341,
172507 /* 400 */ 81, 81, 7, 44, 135, 136, 90, 1228, 1228, 1063,
172508 /* 410 */ 1066, 1053, 1053, 133, 133, 134, 134, 134, 134, 295,
172509 /* 420 */ 1149, 1658, 1040, 1658, 1204, 1147, 319, 567, 119, 119,
172510 /* 430 */ 343, 466, 331, 343, 287, 287, 120, 556, 451, 577,
172511 /* 440 */ 451, 1169, 1169, 1028, 319, 567, 438, 573, 210, 561,
172512 /* 450 */ 1339, 1451, 546, 531, 1169, 1169, 1598, 1169, 1169, 416,
172513 /* 460 */ 319, 567, 243, 132, 132, 132, 132, 131, 131, 130,
172514 /* 470 */ 130, 130, 129, 126, 450, 1028, 1028, 1030, 1031, 35,
172515 /* 480 */ 44, 1204, 1205, 1204, 472, 287, 287, 1328, 412, 1307,
172516 /* 490 */ 372, 1595, 359, 225, 454, 1204, 195, 1328, 573, 1147,
172517 /* 500 */ 561, 1333, 1333, 274, 576, 1188, 576, 340, 46, 196,
172518 /* 510 */ 537, 217, 135, 136, 90, 1228, 1228, 1063, 1066, 1053,
172519 /* 520 */ 1053, 133, 133, 134, 134, 134, 134, 19, 19, 19,
172520 /* 530 */ 19, 412, 581, 1204, 1259, 511, 1204, 319, 567, 320,
172521 /* 540 */ 944, 153, 425, 491, 430, 943, 1204, 488, 1341, 1450,
172522 /* 550 */ 532, 1277, 1204, 1205, 1204, 135, 136, 90, 1228, 1228,
172523 /* 560 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172524 /* 570 */ 575, 132, 132, 132, 132, 131, 131, 130, 130, 130,
172525 /* 580 */ 129, 126, 450, 287, 287, 528, 287, 287, 372, 1595,
172526 /* 590 */ 1204, 1205, 1204, 1204, 1205, 1204, 573, 486, 561, 573,
172527 /* 600 */ 889, 561, 412, 1204, 1205, 1204, 886, 40, 22, 22,
172528 /* 610 */ 220, 243, 525, 1449, 132, 132, 132, 132, 131, 131,
172529 /* 620 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172530 /* 630 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172531 /* 640 */ 134, 412, 180, 454, 1204, 879, 255, 287, 287, 510,
172532 /* 650 */ 507, 506, 372, 1595, 1568, 1331, 1331, 576, 889, 505,
172533 /* 660 */ 573, 44, 561, 559, 1207, 135, 136, 90, 1228, 1228,
172534 /* 670 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172535 /* 680 */ 81, 81, 422, 576, 377, 132, 132, 132, 132, 131,
172536 /* 690 */ 131, 130, 130, 130, 129, 126, 450, 297, 287, 287,
172537 /* 700 */ 460, 1204, 1205, 1204, 1204, 534, 19, 19, 448, 448,
172538 /* 710 */ 448, 573, 412, 561, 230, 436, 1187, 535, 319, 567,
172539 /* 720 */ 363, 432, 1207, 1435, 132, 132, 132, 132, 131, 131,
172540 /* 730 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172541 /* 740 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172542 /* 750 */ 134, 412, 211, 949, 1169, 1041, 1110, 1110, 494, 547,
172543 /* 760 */ 547, 1204, 1205, 1204, 7, 539, 1570, 1169, 376, 576,
172544 /* 770 */ 1169, 5, 1204, 486, 3, 135, 136, 90, 1228, 1228,
172545 /* 780 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172546 /* 790 */ 576, 513, 19, 19, 427, 132, 132, 132, 132, 131,
172547 /* 800 */ 131, 130, 130, 130, 129, 126, 450, 305, 1204, 433,
172548 /* 810 */ 225, 1204, 385, 19, 19, 273, 290, 371, 516, 366,
172549 /* 820 */ 515, 260, 412, 538, 1568, 549, 1024, 362, 437, 1204,
172550 /* 830 */ 1205, 1204, 902, 1552, 132, 132, 132, 132, 131, 131,
172551 /* 840 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172552 /* 850 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172553 /* 860 */ 134, 412, 1435, 514, 1281, 1204, 1205, 1204, 1204, 1205,
172554 /* 870 */ 1204, 903, 48, 342, 1568, 1568, 1279, 1627, 1568, 911,
172555 /* 880 */ 576, 129, 126, 450, 110, 135, 136, 90, 1228, 1228,
172556 /* 890 */ 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134, 134,
172557 /* 900 */ 265, 576, 459, 19, 19, 132, 132, 132, 132, 131,
172558 /* 910 */ 131, 130, 130, 130, 129, 126, 450, 1345, 204, 576,
172559 /* 920 */ 459, 458, 50, 47, 19, 19, 49, 434, 1105, 573,
172560 /* 930 */ 497, 561, 412, 428, 108, 1224, 1569, 1554, 376, 205,
172561 /* 940 */ 550, 550, 81, 81, 132, 132, 132, 132, 131, 131,
172562 /* 950 */ 130, 130, 130, 129, 126, 450, 135, 136, 90, 1228,
172563 /* 960 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172564 /* 970 */ 134, 480, 576, 1204, 576, 1541, 412, 1435, 969, 315,
172565 /* 980 */ 1659, 398, 284, 497, 969, 893, 1569, 1569, 376, 376,
172566 /* 990 */ 1569, 461, 376, 1224, 459, 80, 80, 81, 81, 497,
172567 /* 1000 */ 374, 114, 90, 1228, 1228, 1063, 1066, 1053, 1053, 133,
172568 /* 1010 */ 133, 134, 134, 134, 134, 132, 132, 132, 132, 131,
172569 /* 1020 */ 131, 130, 130, 130, 129, 126, 450, 1204, 1505, 576,
172570 /* 1030 */ 1204, 1205, 1204, 1366, 316, 486, 281, 281, 497, 431,
172571 /* 1040 */ 557, 288, 288, 402, 1340, 471, 345, 298, 429, 573,
172572 /* 1050 */ 576, 561, 81, 81, 573, 374, 561, 971, 386, 132,
172573 /* 1060 */ 132, 132, 132, 131, 131, 130, 130, 130, 129, 126,
172574 /* 1070 */ 450, 231, 117, 81, 81, 287, 287, 231, 287, 287,
172575 /* 1080 */ 576, 1511, 576, 1336, 1204, 1205, 1204, 139, 573, 556,
172576 /* 1090 */ 561, 573, 412, 561, 441, 456, 969, 213, 558, 1511,
172577 /* 1100 */ 1513, 1550, 969, 143, 143, 145, 145, 1368, 314, 478,
172578 /* 1110 */ 444, 970, 412, 850, 851, 852, 135, 136, 90, 1228,
172579 /* 1120 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172580 /* 1130 */ 134, 357, 412, 397, 1148, 304, 135, 136, 90, 1228,
172581 /* 1140 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172582 /* 1150 */ 134, 1575, 323, 6, 862, 7, 135, 124, 90, 1228,
172583 /* 1160 */ 1228, 1063, 1066, 1053, 1053, 133, 133, 134, 134, 134,
172584 /* 1170 */ 134, 409, 408, 1511, 212, 132, 132, 132, 132, 131,
172585 /* 1180 */ 131, 130, 130, 130, 129, 126, 450, 411, 118, 1204,
172586 /* 1190 */ 116, 10, 352, 265, 355, 132, 132, 132, 132, 131,
172587 /* 1200 */ 131, 130, 130, 130, 129, 126, 450, 576, 324, 306,
172588 /* 1210 */ 576, 306, 1250, 469, 158, 132, 132, 132, 132, 131,
172589 /* 1220 */ 131, 130, 130, 130, 129, 126, 450, 207, 1224, 1126,
172590 /* 1230 */ 65, 65, 470, 66, 66, 412, 447, 446, 882, 531,
172591 /* 1240 */ 335, 258, 257, 256, 1127, 1233, 1204, 1205, 1204, 327,
172592 /* 1250 */ 1235, 874, 159, 576, 16, 480, 1085, 1040, 1234, 1128,
172593 /* 1260 */ 136, 90, 1228, 1228, 1063, 1066, 1053, 1053, 133, 133,
172594 /* 1270 */ 134, 134, 134, 134, 1029, 576, 81, 81, 1028, 1040,
172595 /* 1280 */ 922, 576, 463, 1236, 576, 1236, 1224, 502, 107, 1435,
172596 /* 1290 */ 923, 6, 576, 410, 1498, 882, 1029, 480, 21, 21,
172597 /* 1300 */ 1028, 332, 1380, 334, 53, 53, 497, 81, 81, 874,
172598 /* 1310 */ 1028, 1028, 1030, 445, 259, 19, 19, 533, 132, 132,
172599 /* 1320 */ 132, 132, 131, 131, 130, 130, 130, 129, 126, 450,
172600 /* 1330 */ 551, 301, 1028, 1028, 1030, 107, 532, 545, 121, 568,
172601 /* 1340 */ 1188, 4, 1126, 1576, 449, 576, 462, 7, 1282, 418,
172602 /* 1350 */ 462, 350, 1435, 576, 518, 571, 544, 1127, 121, 568,
172603 /* 1360 */ 442, 4, 1188, 464, 533, 1180, 1223, 9, 67, 67,
172604 /* 1370 */ 487, 576, 1128, 303, 410, 571, 54, 54, 451, 576,
172605 /* 1380 */ 123, 944, 576, 417, 576, 333, 943, 1379, 576, 236,
172606 /* 1390 */ 565, 576, 1574, 564, 68, 68, 7, 576, 451, 362,
172607 /* 1400 */ 419, 182, 69, 69, 541, 70, 70, 71, 71, 540,
172608 /* 1410 */ 565, 72, 72, 484, 55, 55, 473, 1180, 296, 1040,
172609 /* 1420 */ 56, 56, 296, 493, 541, 119, 119, 410, 1573, 542,
172610 /* 1430 */ 569, 418, 7, 120, 1244, 451, 577, 451, 465, 1040,
172611 /* 1440 */ 1028, 576, 1557, 552, 476, 119, 119, 527, 259, 121,
172612 /* 1450 */ 568, 240, 4, 120, 576, 451, 577, 451, 576, 477,
172613 /* 1460 */ 1028, 576, 156, 576, 57, 57, 571, 576, 286, 229,
172614 /* 1470 */ 410, 336, 1028, 1028, 1030, 1031, 35, 59, 59, 219,
172615 /* 1480 */ 983, 60, 60, 220, 73, 73, 74, 74, 984, 451,
172616 /* 1490 */ 75, 75, 1028, 1028, 1030, 1031, 35, 96, 216, 291,
172617 /* 1500 */ 552, 565, 1188, 318, 395, 395, 394, 276, 392, 576,
172618 /* 1510 */ 485, 859, 474, 1311, 410, 541, 576, 417, 1530, 1144,
172619 /* 1520 */ 540, 399, 1188, 292, 237, 1153, 326, 38, 23, 576,
172620 /* 1530 */ 1040, 576, 20, 20, 325, 299, 119, 119, 164, 76,
172621 /* 1540 */ 76, 1529, 121, 568, 120, 4, 451, 577, 451, 203,
172622 /* 1550 */ 576, 1028, 141, 141, 142, 142, 576, 322, 39, 571,
172623 /* 1560 */ 341, 1021, 110, 264, 239, 901, 900, 423, 242, 908,
172624 /* 1570 */ 909, 370, 173, 77, 77, 43, 479, 1310, 264, 62,
172625 /* 1580 */ 62, 369, 451, 1028, 1028, 1030, 1031, 35, 1601, 1192,
172626 /* 1590 */ 453, 1092, 238, 291, 565, 163, 1309, 110, 395, 395,
172627 /* 1600 */ 394, 276, 392, 986, 987, 859, 481, 346, 264, 110,
172628 /* 1610 */ 1032, 489, 576, 1188, 503, 1088, 261, 261, 237, 576,
172629 /* 1620 */ 326, 121, 568, 1040, 4, 347, 1376, 413, 325, 119,
172630 /* 1630 */ 119, 948, 319, 567, 351, 78, 78, 120, 571, 451,
172631 /* 1640 */ 577, 451, 79, 79, 1028, 354, 356, 576, 360, 1092,
172632 /* 1650 */ 110, 576, 974, 942, 264, 123, 457, 358, 239, 576,
172633 /* 1660 */ 519, 451, 939, 1104, 123, 1104, 173, 576, 1032, 43,
172634 /* 1670 */ 63, 63, 1324, 565, 168, 168, 1028, 1028, 1030, 1031,
172635 /* 1680 */ 35, 576, 169, 169, 1308, 872, 238, 157, 1589, 576,
172636 /* 1690 */ 86, 86, 365, 89, 568, 375, 4, 1103, 941, 1103,
172637 /* 1700 */ 123, 576, 1040, 1389, 64, 64, 1188, 1434, 119, 119,
172638 /* 1710 */ 571, 576, 82, 82, 563, 576, 120, 165, 451, 577,
172639 /* 1720 */ 451, 413, 1362, 1028, 144, 144, 319, 567, 576, 1374,
172640 /* 1730 */ 562, 498, 279, 451, 83, 83, 1439, 576, 166, 166,
172641 /* 1740 */ 576, 1289, 554, 576, 1280, 565, 576, 12, 576, 1268,
172642 /* 1750 */ 457, 146, 146, 1267, 576, 1028, 1028, 1030, 1031, 35,
172643 /* 1760 */ 140, 140, 1269, 167, 167, 1609, 160, 160, 1359, 150,
172644 /* 1770 */ 150, 149, 149, 311, 1040, 576, 312, 147, 147, 313,
172645 /* 1780 */ 119, 119, 222, 235, 576, 1188, 396, 576, 120, 576,
172646 /* 1790 */ 451, 577, 451, 1192, 453, 1028, 508, 291, 148, 148,
172647 /* 1800 */ 1421, 1612, 395, 395, 394, 276, 392, 85, 85, 859,
172648 /* 1810 */ 87, 87, 84, 84, 553, 576, 294, 576, 1426, 338,
172649 /* 1820 */ 339, 1425, 237, 300, 326, 1416, 1409, 1028, 1028, 1030,
172650 /* 1830 */ 1031, 35, 325, 344, 403, 483, 226, 1307, 52, 52,
172651 /* 1840 */ 58, 58, 368, 1371, 1502, 566, 1501, 121, 568, 221,
172652 /* 1850 */ 4, 208, 268, 209, 390, 1244, 1549, 1188, 1372, 1370,
172653 /* 1860 */ 1369, 1547, 239, 184, 571, 233, 421, 1241, 95, 218,
172654 /* 1870 */ 173, 1507, 193, 43, 91, 94, 178, 186, 467, 188,
172655 /* 1880 */ 468, 1422, 13, 189, 190, 191, 501, 451, 245, 108,
172656 /* 1890 */ 238, 401, 1428, 1427, 1430, 475, 404, 1496, 197, 565,
172657 /* 1900 */ 14, 490, 249, 101, 1518, 496, 349, 280, 251, 201,
172658 /* 1910 */ 353, 499, 252, 406, 1270, 253, 517, 1327, 1326, 435,
172659 /* 1920 */ 1325, 1318, 103, 893, 1296, 413, 227, 407, 1040, 1626,
172660 /* 1930 */ 319, 567, 1625, 1297, 119, 119, 439, 367, 1317, 1295,
172661 /* 1940 */ 1624, 526, 120, 440, 451, 577, 451, 1594, 309, 1028,
172662 /* 1950 */ 310, 373, 266, 267, 457, 1580, 1579, 443, 138, 1394,
172663 /* 1960 */ 552, 1393, 11, 1483, 384, 115, 317, 1350, 109, 536,
172664 /* 1970 */ 42, 579, 382, 214, 1349, 388, 1198, 389, 275, 277,
172665 /* 1980 */ 278, 1028, 1028, 1030, 1031, 35, 580, 1265, 414, 1260,
172666 /* 1990 */ 170, 415, 183, 1534, 1535, 1533, 171, 154, 307, 1532,
172667 /* 2000 */ 846, 223, 224, 88, 452, 215, 172, 321, 234, 1102,
172668 /* 2010 */ 152, 1188, 1100, 329, 185, 174, 1223, 925, 187, 241,
172669 /* 2020 */ 337, 244, 1116, 192, 175, 176, 424, 426, 97, 194,
172670 /* 2030 */ 98, 99, 100, 177, 1119, 1115, 246, 247, 161, 24,
172671 /* 2040 */ 248, 348, 1238, 264, 1108, 250, 495, 199, 198, 15,
172672 /* 2050 */ 861, 500, 369, 254, 504, 509, 512, 200, 102, 25,
172673 /* 2060 */ 179, 361, 26, 364, 104, 891, 308, 162, 105, 904,
172674 /* 2070 */ 520, 106, 1185, 1069, 1155, 17, 228, 27, 1154, 283,
172675 /* 2080 */ 285, 263, 978, 202, 972, 123, 28, 1175, 29, 30,
172676 /* 2090 */ 1179, 1171, 31, 1173, 1160, 41, 32, 206, 548, 33,
172677 /* 2100 */ 110, 1178, 1083, 8, 112, 1070, 113, 1068, 1072, 34,
172678 /* 2110 */ 1073, 560, 1125, 269, 1124, 270, 36, 18, 1194, 1033,
172679 /* 2120 */ 873, 151, 122, 37, 393, 271, 272, 572, 181, 1193,
172680 /* 2130 */ 1256, 1256, 1256, 935, 1256, 1256, 1256, 1256, 1256, 1256,
172681 /* 2140 */ 1256, 1617,
172682 };
172683 static const YYCODETYPE yy_lookahead[] = {
172684 /* 0 */ 194, 276, 277, 278, 216, 194, 194, 217, 194, 194,
172685 /* 10 */ 194, 194, 224, 194, 194, 276, 277, 278, 204, 19,
172686 /* 20 */ 206, 202, 297, 217, 218, 205, 207, 217, 205, 217,
172687 /* 30 */ 218, 31, 217, 218, 217, 218, 29, 217, 218, 39,
172688 /* 40 */ 33, 217, 220, 43, 44, 45, 46, 47, 48, 49,
172689 /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 312, 19,
172690 /* 60 */ 240, 241, 316, 240, 241, 194, 46, 47, 48, 49,
172691 /* 70 */ 22, 254, 65, 253, 254, 255, 253, 194, 255, 194,
172692 /* 80 */ 263, 258, 259, 43, 44, 45, 46, 47, 48, 49,
172693 /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 276, 277,
172694 /* 100 */ 278, 285, 102, 103, 104, 105, 106, 107, 108, 109,
172695 /* 110 */ 110, 111, 112, 113, 59, 186, 187, 188, 189, 190,
172696 /* 120 */ 191, 310, 239, 317, 318, 196, 86, 198, 88, 317,
172697 /* 130 */ 19, 319, 317, 318, 205, 264, 25, 211, 212, 213,
172698 /* 140 */ 205, 121, 102, 103, 104, 105, 106, 107, 108, 109,
172699 /* 150 */ 110, 111, 112, 113, 43, 44, 45, 46, 47, 48,
172700 /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 240,
172701 /* 170 */ 241, 116, 117, 118, 119, 240, 241, 122, 123, 124,
172702 /* 180 */ 69, 298, 253, 194, 255, 106, 107, 132, 253, 141,
172703 /* 190 */ 255, 54, 55, 56, 57, 58, 207, 268, 102, 103,
172704 /* 200 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
172705 /* 210 */ 214, 128, 129, 102, 103, 104, 105, 106, 107, 108,
172706 /* 220 */ 109, 110, 111, 112, 113, 134, 25, 136, 137, 300,
172707 /* 230 */ 165, 166, 153, 19, 155, 54, 55, 56, 57, 102,
172708 /* 240 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172709 /* 250 */ 113, 108, 109, 110, 111, 112, 113, 43, 44, 45,
172710 /* 260 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
172711 /* 270 */ 56, 57, 276, 277, 278, 113, 194, 19, 22, 23,
172712 /* 280 */ 194, 67, 24, 102, 103, 104, 105, 106, 107, 108,
172713 /* 290 */ 109, 110, 111, 112, 113, 220, 250, 59, 252, 217,
172714 /* 300 */ 218, 43, 44, 45, 46, 47, 48, 49, 50, 51,
172715 /* 310 */ 52, 53, 54, 55, 56, 57, 102, 103, 104, 105,
172716 /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 106, 107,
172717 /* 330 */ 108, 109, 110, 111, 112, 113, 254, 59, 205, 138,
172718 /* 340 */ 139, 19, 20, 194, 22, 263, 22, 23, 231, 25,
172719 /* 350 */ 72, 276, 277, 278, 116, 117, 118, 101, 36, 76,
172720 /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
172721 /* 370 */ 112, 113, 89, 240, 241, 92, 73, 194, 194, 73,
172722 /* 380 */ 19, 59, 188, 189, 190, 191, 253, 81, 255, 151,
172723 /* 390 */ 196, 25, 198, 71, 116, 117, 118, 311, 312, 205,
172724 /* 400 */ 217, 218, 316, 81, 43, 44, 45, 46, 47, 48,
172725 /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 270,
172726 /* 420 */ 22, 23, 100, 25, 59, 101, 138, 139, 106, 107,
172727 /* 430 */ 127, 128, 129, 127, 240, 241, 114, 254, 116, 117,
172728 /* 440 */ 118, 76, 76, 121, 138, 139, 263, 253, 264, 255,
172729 /* 450 */ 205, 275, 87, 19, 89, 89, 194, 92, 92, 199,
172730 /* 460 */ 138, 139, 268, 102, 103, 104, 105, 106, 107, 108,
172731 /* 470 */ 109, 110, 111, 112, 113, 153, 154, 155, 156, 157,
172732 /* 480 */ 81, 116, 117, 118, 129, 240, 241, 224, 19, 226,
172733 /* 490 */ 314, 315, 23, 25, 300, 59, 22, 234, 253, 101,
172734 /* 500 */ 255, 236, 237, 26, 194, 183, 194, 152, 72, 22,
172735 /* 510 */ 145, 150, 43, 44, 45, 46, 47, 48, 49, 50,
172736 /* 520 */ 51, 52, 53, 54, 55, 56, 57, 217, 218, 217,
172737 /* 530 */ 218, 19, 189, 59, 191, 23, 59, 138, 139, 196,
172738 /* 540 */ 135, 198, 232, 283, 232, 140, 59, 287, 205, 275,
172739 /* 550 */ 116, 205, 116, 117, 118, 43, 44, 45, 46, 47,
172740 /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172741 /* 570 */ 194, 102, 103, 104, 105, 106, 107, 108, 109, 110,
172742 /* 580 */ 111, 112, 113, 240, 241, 194, 240, 241, 314, 315,
172743 /* 590 */ 116, 117, 118, 116, 117, 118, 253, 194, 255, 253,
172744 /* 600 */ 59, 255, 19, 116, 117, 118, 23, 22, 217, 218,
172745 /* 610 */ 142, 268, 205, 275, 102, 103, 104, 105, 106, 107,
172746 /* 620 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172747 /* 630 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172748 /* 640 */ 57, 19, 194, 300, 59, 23, 119, 240, 241, 122,
172749 /* 650 */ 123, 124, 314, 315, 194, 236, 237, 194, 117, 132,
172750 /* 660 */ 253, 81, 255, 205, 59, 43, 44, 45, 46, 47,
172751 /* 670 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172752 /* 680 */ 217, 218, 194, 194, 194, 102, 103, 104, 105, 106,
172753 /* 690 */ 107, 108, 109, 110, 111, 112, 113, 294, 240, 241,
172754 /* 700 */ 120, 116, 117, 118, 59, 194, 217, 218, 211, 212,
172755 /* 710 */ 213, 253, 19, 255, 194, 19, 23, 254, 138, 139,
172756 /* 720 */ 24, 232, 117, 194, 102, 103, 104, 105, 106, 107,
172757 /* 730 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172758 /* 740 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172759 /* 750 */ 57, 19, 264, 108, 76, 23, 127, 128, 129, 311,
172760 /* 760 */ 312, 116, 117, 118, 316, 87, 306, 89, 308, 194,
172761 /* 770 */ 92, 22, 59, 194, 22, 43, 44, 45, 46, 47,
172762 /* 780 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172763 /* 790 */ 194, 95, 217, 218, 265, 102, 103, 104, 105, 106,
172764 /* 800 */ 107, 108, 109, 110, 111, 112, 113, 232, 59, 113,
172765 /* 810 */ 25, 59, 194, 217, 218, 119, 120, 121, 122, 123,
172766 /* 820 */ 124, 125, 19, 145, 194, 194, 23, 131, 232, 116,
172767 /* 830 */ 117, 118, 35, 194, 102, 103, 104, 105, 106, 107,
172768 /* 840 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172769 /* 850 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172770 /* 860 */ 57, 19, 194, 66, 194, 116, 117, 118, 116, 117,
172771 /* 870 */ 118, 74, 242, 294, 194, 194, 206, 23, 194, 25,
172772 /* 880 */ 194, 111, 112, 113, 25, 43, 44, 45, 46, 47,
172773 /* 890 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
172774 /* 900 */ 24, 194, 194, 217, 218, 102, 103, 104, 105, 106,
172775 /* 910 */ 107, 108, 109, 110, 111, 112, 113, 241, 232, 194,
172776 /* 920 */ 212, 213, 242, 242, 217, 218, 242, 130, 11, 253,
172777 /* 930 */ 194, 255, 19, 265, 149, 59, 306, 194, 308, 232,
172778 /* 940 */ 309, 310, 217, 218, 102, 103, 104, 105, 106, 107,
172779 /* 950 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46,
172780 /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172781 /* 970 */ 57, 194, 194, 59, 194, 239, 19, 194, 25, 254,
172782 /* 980 */ 303, 304, 23, 194, 25, 126, 306, 306, 308, 308,
172783 /* 990 */ 306, 271, 308, 117, 286, 217, 218, 217, 218, 194,
172784 /* 1000 */ 194, 159, 45, 46, 47, 48, 49, 50, 51, 52,
172785 /* 1010 */ 53, 54, 55, 56, 57, 102, 103, 104, 105, 106,
172786 /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 59, 239, 194,
172787 /* 1030 */ 116, 117, 118, 260, 254, 194, 240, 241, 194, 233,
172788 /* 1040 */ 205, 240, 241, 205, 239, 128, 129, 270, 265, 253,
172789 /* 1050 */ 194, 255, 217, 218, 253, 194, 255, 143, 280, 102,
172790 /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
172791 /* 1070 */ 113, 118, 159, 217, 218, 240, 241, 118, 240, 241,
172792 /* 1080 */ 194, 194, 194, 239, 116, 117, 118, 22, 253, 254,
172793 /* 1090 */ 255, 253, 19, 255, 233, 194, 143, 24, 263, 212,
172794 /* 1100 */ 213, 194, 143, 217, 218, 217, 218, 261, 262, 271,
172795 /* 1110 */ 254, 143, 19, 7, 8, 9, 43, 44, 45, 46,
172796 /* 1120 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172797 /* 1130 */ 57, 16, 19, 22, 23, 294, 43, 44, 45, 46,
172798 /* 1140 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172799 /* 1150 */ 57, 312, 194, 214, 21, 316, 43, 44, 45, 46,
172800 /* 1160 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
172801 /* 1170 */ 57, 106, 107, 286, 194, 102, 103, 104, 105, 106,
172802 /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 207, 158, 59,
172803 /* 1190 */ 160, 22, 77, 24, 79, 102, 103, 104, 105, 106,
172804 /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 194, 194, 229,
172805 /* 1210 */ 194, 231, 101, 80, 22, 102, 103, 104, 105, 106,
172806 /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 288, 59, 12,
172807 /* 1230 */ 217, 218, 293, 217, 218, 19, 106, 107, 59, 19,
172808 /* 1240 */ 16, 127, 128, 129, 27, 115, 116, 117, 118, 194,
172809 /* 1250 */ 120, 59, 22, 194, 24, 194, 123, 100, 128, 42,
172810 /* 1260 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
172811 /* 1270 */ 54, 55, 56, 57, 117, 194, 217, 218, 121, 100,
172812 /* 1280 */ 63, 194, 245, 153, 194, 155, 117, 19, 115, 194,
172813 /* 1290 */ 73, 214, 194, 256, 161, 116, 117, 194, 217, 218,
172814 /* 1300 */ 121, 77, 194, 79, 217, 218, 194, 217, 218, 117,
172815 /* 1310 */ 153, 154, 155, 254, 46, 217, 218, 144, 102, 103,
172816 /* 1320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
172817 /* 1330 */ 232, 270, 153, 154, 155, 115, 116, 66, 19, 20,
172818 /* 1340 */ 183, 22, 12, 312, 254, 194, 262, 316, 209, 210,
172819 /* 1350 */ 266, 239, 194, 194, 108, 36, 85, 27, 19, 20,
172820 /* 1360 */ 265, 22, 183, 245, 144, 94, 25, 48, 217, 218,
172821 /* 1370 */ 293, 194, 42, 270, 256, 36, 217, 218, 59, 194,
172822 /* 1380 */ 25, 135, 194, 115, 194, 161, 140, 194, 194, 15,
172823 /* 1390 */ 71, 194, 312, 63, 217, 218, 316, 194, 59, 131,
172824 /* 1400 */ 301, 302, 217, 218, 85, 217, 218, 217, 218, 90,
172825 /* 1410 */ 71, 217, 218, 19, 217, 218, 245, 146, 262, 100,
172826 /* 1420 */ 217, 218, 266, 265, 85, 106, 107, 256, 312, 90,
172827 /* 1430 */ 209, 210, 316, 114, 60, 116, 117, 118, 194, 100,
172828 /* 1440 */ 121, 194, 194, 145, 115, 106, 107, 19, 46, 19,
172829 /* 1450 */ 20, 24, 22, 114, 194, 116, 117, 118, 194, 245,
172830 /* 1460 */ 121, 194, 164, 194, 217, 218, 36, 194, 258, 259,
172831 /* 1470 */ 256, 194, 153, 154, 155, 156, 157, 217, 218, 150,
172832 /* 1480 */ 31, 217, 218, 142, 217, 218, 217, 218, 39, 59,
172833 /* 1490 */ 217, 218, 153, 154, 155, 156, 157, 149, 150, 5,
172834 /* 1500 */ 145, 71, 183, 245, 10, 11, 12, 13, 14, 194,
172835 /* 1510 */ 116, 17, 129, 227, 256, 85, 194, 115, 194, 23,
172836 /* 1520 */ 90, 25, 183, 99, 30, 97, 32, 22, 22, 194,
172837 /* 1530 */ 100, 194, 217, 218, 40, 152, 106, 107, 23, 217,
172838 /* 1540 */ 218, 194, 19, 20, 114, 22, 116, 117, 118, 257,
172839 /* 1550 */ 194, 121, 217, 218, 217, 218, 194, 133, 53, 36,
172840 /* 1560 */ 23, 23, 25, 25, 70, 120, 121, 61, 141, 7,
172841 /* 1570 */ 8, 121, 78, 217, 218, 81, 23, 227, 25, 217,
172842 /* 1580 */ 218, 131, 59, 153, 154, 155, 156, 157, 0, 1,
172843 /* 1590 */ 2, 59, 98, 5, 71, 23, 227, 25, 10, 11,
172844 /* 1600 */ 12, 13, 14, 83, 84, 17, 23, 23, 25, 25,
172845 /* 1610 */ 59, 194, 194, 183, 23, 23, 25, 25, 30, 194,
172846 /* 1620 */ 32, 19, 20, 100, 22, 194, 194, 133, 40, 106,
172847 /* 1630 */ 107, 108, 138, 139, 194, 217, 218, 114, 36, 116,
172848 /* 1640 */ 117, 118, 217, 218, 121, 194, 194, 194, 23, 117,
172849 /* 1650 */ 25, 194, 23, 23, 25, 25, 162, 194, 70, 194,
172850 /* 1660 */ 145, 59, 23, 153, 25, 155, 78, 194, 117, 81,
172851 /* 1670 */ 217, 218, 194, 71, 217, 218, 153, 154, 155, 156,
172852 /* 1680 */ 157, 194, 217, 218, 194, 23, 98, 25, 321, 194,
172853 /* 1690 */ 217, 218, 194, 19, 20, 194, 22, 153, 23, 155,
172854 /* 1700 */ 25, 194, 100, 194, 217, 218, 183, 194, 106, 107,
172855 /* 1710 */ 36, 194, 217, 218, 237, 194, 114, 243, 116, 117,
172856 /* 1720 */ 118, 133, 194, 121, 217, 218, 138, 139, 194, 194,
172857 /* 1730 */ 194, 290, 289, 59, 217, 218, 194, 194, 217, 218,
172858 /* 1740 */ 194, 194, 140, 194, 194, 71, 194, 244, 194, 194,
172859 /* 1750 */ 162, 217, 218, 194, 194, 153, 154, 155, 156, 157,
172860 /* 1760 */ 217, 218, 194, 217, 218, 194, 217, 218, 257, 217,
172861 /* 1770 */ 218, 217, 218, 257, 100, 194, 257, 217, 218, 257,
172862 /* 1780 */ 106, 107, 215, 299, 194, 183, 192, 194, 114, 194,
172863 /* 1790 */ 116, 117, 118, 1, 2, 121, 221, 5, 217, 218,
172864 /* 1800 */ 273, 197, 10, 11, 12, 13, 14, 217, 218, 17,
172865 /* 1810 */ 217, 218, 217, 218, 140, 194, 246, 194, 273, 295,
172866 /* 1820 */ 247, 273, 30, 247, 32, 269, 269, 153, 154, 155,
172867 /* 1830 */ 156, 157, 40, 246, 273, 295, 230, 226, 217, 218,
172868 /* 1840 */ 217, 218, 220, 261, 220, 282, 220, 19, 20, 244,
172869 /* 1850 */ 22, 250, 141, 250, 246, 60, 201, 183, 261, 261,
172870 /* 1860 */ 261, 201, 70, 299, 36, 299, 201, 38, 151, 150,
172871 /* 1870 */ 78, 285, 22, 81, 296, 296, 43, 235, 18, 238,
172872 /* 1880 */ 201, 274, 272, 238, 238, 238, 18, 59, 200, 149,
172873 /* 1890 */ 98, 247, 274, 274, 235, 247, 247, 247, 235, 71,
172874 /* 1900 */ 272, 201, 200, 158, 292, 62, 291, 201, 200, 22,
172875 /* 1910 */ 201, 222, 200, 222, 201, 200, 115, 219, 219, 64,
172876 /* 1920 */ 219, 228, 22, 126, 221, 133, 165, 222, 100, 225,
172877 /* 1930 */ 138, 139, 225, 219, 106, 107, 24, 219, 228, 219,
172878 /* 1940 */ 219, 307, 114, 113, 116, 117, 118, 315, 284, 121,
172879 /* 1950 */ 284, 222, 201, 91, 162, 320, 320, 82, 148, 267,
172880 /* 1960 */ 145, 267, 22, 279, 201, 158, 281, 251, 147, 146,
172881 /* 1970 */ 25, 203, 250, 249, 251, 248, 13, 247, 195, 195,
172882 /* 1980 */ 6, 153, 154, 155, 156, 157, 193, 193, 305, 193,
172883 /* 1990 */ 208, 305, 302, 214, 214, 214, 208, 223, 223, 214,
172884 /* 2000 */ 4, 215, 215, 214, 3, 22, 208, 163, 15, 23,
172885 /* 2010 */ 16, 183, 23, 139, 151, 130, 25, 20, 142, 24,
172886 /* 2020 */ 16, 144, 1, 142, 130, 130, 61, 37, 53, 151,
172887 /* 2030 */ 53, 53, 53, 130, 116, 1, 34, 141, 5, 22,
172888 /* 2040 */ 115, 161, 75, 25, 68, 141, 41, 115, 68, 24,
172889 /* 2050 */ 20, 19, 131, 125, 67, 67, 96, 22, 22, 22,
172890 /* 2060 */ 37, 23, 22, 24, 22, 59, 67, 23, 149, 28,
172891 /* 2070 */ 22, 25, 23, 23, 23, 22, 141, 34, 97, 23,
172892 /* 2080 */ 23, 34, 116, 22, 143, 25, 34, 75, 34, 34,
172893 /* 2090 */ 75, 88, 34, 86, 23, 22, 34, 25, 24, 34,
172894 /* 2100 */ 25, 93, 23, 44, 142, 23, 142, 23, 23, 22,
172895 /* 2110 */ 11, 25, 23, 25, 23, 22, 22, 22, 1, 23,
172896 /* 2120 */ 23, 23, 22, 22, 15, 141, 141, 25, 25, 1,
172897 /* 2130 */ 322, 322, 322, 135, 322, 322, 322, 322, 322, 322,
172898 /* 2140 */ 322, 141, 322, 322, 322, 322, 322, 322, 322, 322,
172899 /* 2150 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172900 /* 2160 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172901 /* 2170 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172902 /* 2180 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172903 /* 2190 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172904 /* 2200 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172905 /* 2210 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172906 /* 2220 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172907 /* 2230 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172908 /* 2240 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172909 /* 2250 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172910 /* 2260 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172911 /* 2270 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172912 /* 2280 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172913 /* 2290 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172914 /* 2300 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172915 /* 2310 */ 322, 322, 322, 322, 322, 322, 322, 322, 322, 322,
172916 /* 2320 */ 322, 322, 322, 322, 322, 322, 322, 322,
172917 };
172918 #define YY_SHIFT_COUNT (582)
172919 #define YY_SHIFT_MIN (0)
172920 #define YY_SHIFT_MAX (2128)
172921 static const unsigned short int yy_shift_ofst[] = {
172922 /* 0 */ 1792, 1588, 1494, 322, 322, 399, 306, 1319, 1339, 1430,
172923 /* 10 */ 1828, 1828, 1828, 580, 399, 399, 399, 399, 399, 0,
172924 /* 20 */ 0, 214, 1093, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172925 /* 30 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1130, 1130,
172926 /* 40 */ 365, 365, 55, 278, 436, 713, 713, 201, 201, 201,
172927 /* 50 */ 201, 40, 111, 258, 361, 469, 512, 583, 622, 693,
172928 /* 60 */ 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093, 1093,
172929 /* 70 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
172930 /* 80 */ 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1523, 1602,
172931 /* 90 */ 1674, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172932 /* 100 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172933 /* 110 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172934 /* 120 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172935 /* 130 */ 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
172936 /* 140 */ 137, 181, 181, 181, 181, 181, 181, 181, 96, 222,
172937 /* 150 */ 143, 477, 713, 1133, 1268, 713, 713, 79, 79, 713,
172938 /* 160 */ 770, 83, 65, 65, 65, 288, 162, 162, 2142, 2142,
172939 /* 170 */ 696, 696, 696, 238, 474, 474, 474, 474, 1217, 1217,
172940 /* 180 */ 678, 477, 324, 398, 713, 713, 713, 713, 713, 713,
172941 /* 190 */ 713, 713, 713, 713, 713, 713, 713, 713, 713, 713,
172942 /* 200 */ 713, 713, 713, 1220, 366, 366, 713, 917, 283, 283,
172943 /* 210 */ 434, 434, 605, 605, 1298, 2142, 2142, 2142, 2142, 2142,
172944 /* 220 */ 2142, 2142, 1179, 1157, 1157, 487, 527, 585, 645, 749,
172945 /* 230 */ 914, 968, 752, 713, 713, 713, 713, 713, 713, 713,
172946 /* 240 */ 713, 713, 713, 303, 713, 713, 713, 713, 713, 713,
172947 /* 250 */ 713, 713, 713, 713, 713, 713, 797, 797, 797, 713,
172948 /* 260 */ 713, 713, 959, 713, 713, 713, 1169, 1271, 713, 713,
172949 /* 270 */ 1330, 713, 713, 713, 713, 713, 713, 713, 713, 629,
172950 /* 280 */ 7, 91, 876, 876, 876, 876, 953, 91, 91, 1246,
172951 /* 290 */ 1065, 1106, 1374, 1329, 1348, 468, 1348, 1394, 785, 1329,
172952 /* 300 */ 1329, 785, 1329, 468, 1394, 859, 854, 1402, 1449, 1449,
172953 /* 310 */ 1449, 1173, 1173, 1173, 1173, 1355, 1355, 1030, 1341, 405,
172954 /* 320 */ 1230, 1795, 1795, 1711, 1711, 1829, 1829, 1711, 1717, 1719,
172955 /* 330 */ 1850, 1833, 1860, 1860, 1860, 1860, 1711, 1868, 1740, 1719,
172956 /* 340 */ 1719, 1740, 1850, 1833, 1740, 1833, 1740, 1711, 1868, 1745,
172957 /* 350 */ 1843, 1711, 1868, 1887, 1711, 1868, 1711, 1868, 1887, 1801,
172958 /* 360 */ 1801, 1801, 1855, 1900, 1900, 1887, 1801, 1797, 1801, 1855,
172959 /* 370 */ 1801, 1801, 1761, 1912, 1830, 1830, 1887, 1711, 1862, 1862,
172960 /* 380 */ 1875, 1875, 1810, 1815, 1940, 1711, 1807, 1810, 1821, 1823,
172961 /* 390 */ 1740, 1945, 1963, 1963, 1974, 1974, 1974, 2142, 2142, 2142,
172962 /* 400 */ 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142, 2142,
172963 /* 410 */ 2142, 2142, 20, 1224, 256, 1111, 1115, 1114, 1192, 1496,
172964 /* 420 */ 1424, 1505, 1427, 355, 1383, 1537, 1506, 1538, 1553, 1583,
172965 /* 430 */ 1584, 1591, 1625, 541, 1445, 1562, 1450, 1572, 1515, 1428,
172966 /* 440 */ 1532, 1592, 1629, 1520, 1630, 1639, 1510, 1544, 1662, 1675,
172967 /* 450 */ 1551, 48, 1996, 2001, 1983, 1844, 1993, 1994, 1986, 1989,
172968 /* 460 */ 1874, 1863, 1885, 1991, 1991, 1995, 1876, 1997, 1877, 2004,
172969 /* 470 */ 2021, 1881, 1894, 1991, 1895, 1965, 1990, 1991, 1878, 1975,
172970 /* 480 */ 1977, 1978, 1979, 1903, 1918, 2002, 1896, 2034, 2033, 2017,
172971 /* 490 */ 1925, 1880, 1976, 2018, 1980, 1967, 2005, 1904, 1932, 2025,
172972 /* 500 */ 2030, 2032, 1921, 1928, 2035, 1987, 2036, 2037, 2038, 2040,
172973 /* 510 */ 1988, 2006, 2039, 1960, 2041, 2042, 1999, 2023, 2044, 2043,
172974 /* 520 */ 1919, 2048, 2049, 2050, 2046, 2051, 2053, 1981, 1935, 2056,
172975 /* 530 */ 2057, 1966, 2047, 2061, 1941, 2060, 2052, 2054, 2055, 2058,
172976 /* 540 */ 2003, 2012, 2007, 2059, 2015, 2008, 2062, 2071, 2073, 2074,
172977 /* 550 */ 2072, 2075, 2065, 1962, 1964, 2079, 2060, 2082, 2084, 2085,
172978 /* 560 */ 2087, 2086, 2089, 2088, 2091, 2093, 2099, 2094, 2095, 2096,
172979 /* 570 */ 2097, 2100, 2101, 2102, 1998, 1984, 1985, 2000, 2103, 2098,
172980 /* 580 */ 2109, 2117, 2128,
172981 };
172982 #define YY_REDUCE_COUNT (411)
172983 #define YY_REDUCE_MIN (-275)
172984 #define YY_REDUCE_MAX (1798)
172985 static const short yy_reduce_ofst[] = {
172986 /* 0 */ -71, 194, 343, 835, -180, -177, 838, -194, -188, -185,
172987 /* 10 */ -183, 82, 183, -65, 133, 245, 346, 407, 458, -178,
172988 /* 20 */ 75, -275, -4, 310, 312, 489, 575, 596, 463, 686,
172989 /* 30 */ 707, 725, 780, 1098, 856, 778, 1059, 1090, 708, 887,
172990 /* 40 */ 86, 448, 980, 630, 680, 681, 684, 796, 801, 796,
172991 /* 50 */ 801, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172992 /* 60 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172993 /* 70 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
172994 /* 80 */ -261, -261, -261, -261, -261, -261, -261, -261, 391, 886,
172995 /* 90 */ 888, 1013, 1016, 1081, 1087, 1151, 1159, 1177, 1185, 1188,
172996 /* 100 */ 1190, 1194, 1197, 1203, 1247, 1260, 1264, 1267, 1269, 1273,
172997 /* 110 */ 1315, 1322, 1335, 1337, 1356, 1362, 1418, 1425, 1453, 1457,
172998 /* 120 */ 1465, 1473, 1487, 1495, 1507, 1517, 1521, 1534, 1543, 1546,
172999 /* 130 */ 1549, 1552, 1554, 1560, 1581, 1590, 1593, 1595, 1621, 1623,
173000 /* 140 */ -261, -261, -261, -261, -261, -261, -261, -261, -261, -261,
173001 /* 150 */ -261, -186, -117, 260, 263, 460, 631, -74, 497, -181,
173002 /* 160 */ -261, 939, 176, 274, 338, 676, -261, -261, -261, -261,
173003 /* 170 */ -212, -212, -212, -184, 149, 777, 1061, 1103, 265, 419,
173004 /* 180 */ -254, 670, 677, 677, -11, -129, 184, 488, 736, 789,
173005 /* 190 */ 805, 844, 403, 529, 579, 668, 783, 841, 1158, 1112,
173006 /* 200 */ 806, 861, 1095, 846, 839, 1031, -189, 1077, 1080, 1116,
173007 /* 210 */ 1084, 1156, 1139, 1221, 46, 1099, 1037, 1118, 1171, 1214,
173008 /* 220 */ 1210, 1258, -210, -190, -176, -115, 117, 262, 376, 490,
173009 /* 230 */ 511, 520, 618, 639, 743, 901, 907, 958, 1014, 1055,
173010 /* 240 */ 1108, 1193, 1244, 720, 1248, 1277, 1324, 1347, 1417, 1431,
173011 /* 250 */ 1432, 1440, 1451, 1452, 1463, 1478, 1286, 1350, 1369, 1490,
173012 /* 260 */ 1498, 1501, 773, 1509, 1513, 1528, 1292, 1367, 1535, 1536,
173013 /* 270 */ 1477, 1542, 376, 1547, 1550, 1555, 1559, 1568, 1571, 1441,
173014 /* 280 */ 1443, 1474, 1511, 1516, 1519, 1522, 773, 1474, 1474, 1503,
173015 /* 290 */ 1567, 1594, 1484, 1527, 1556, 1570, 1557, 1524, 1573, 1545,
173016 /* 300 */ 1548, 1576, 1561, 1587, 1540, 1575, 1606, 1611, 1622, 1624,
173017 /* 310 */ 1626, 1582, 1597, 1598, 1599, 1601, 1603, 1563, 1608, 1605,
173018 /* 320 */ 1604, 1564, 1566, 1655, 1660, 1578, 1579, 1665, 1586, 1607,
173019 /* 330 */ 1610, 1642, 1641, 1645, 1646, 1647, 1679, 1688, 1644, 1618,
173020 /* 340 */ 1619, 1648, 1628, 1659, 1649, 1663, 1650, 1700, 1702, 1612,
173021 /* 350 */ 1615, 1706, 1708, 1689, 1709, 1712, 1713, 1715, 1691, 1698,
173022 /* 360 */ 1699, 1701, 1693, 1704, 1707, 1705, 1714, 1703, 1718, 1710,
173023 /* 370 */ 1720, 1721, 1632, 1634, 1664, 1666, 1729, 1751, 1635, 1636,
173024 /* 380 */ 1692, 1694, 1716, 1722, 1684, 1763, 1685, 1723, 1724, 1727,
173025 /* 390 */ 1730, 1768, 1783, 1784, 1793, 1794, 1796, 1683, 1686, 1690,
173026 /* 400 */ 1782, 1779, 1780, 1781, 1785, 1788, 1774, 1775, 1786, 1787,
173027 /* 410 */ 1789, 1798,
173028 };
173029 static const YYACTIONTYPE yy_default[] = {
173030 /* 0 */ 1663, 1663, 1663, 1491, 1254, 1367, 1254, 1254, 1254, 1254,
173031 /* 10 */ 1491, 1491, 1491, 1254, 1254, 1254, 1254, 1254, 1254, 1397,
173032 /* 20 */ 1397, 1544, 1287, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173033 /* 30 */ 1254, 1254, 1254, 1254, 1254, 1490, 1254, 1254, 1254, 1254,
173034 /* 40 */ 1578, 1578, 1254, 1254, 1254, 1254, 1254, 1563, 1562, 1254,
173035 /* 50 */ 1254, 1254, 1406, 1254, 1413, 1254, 1254, 1254, 1254, 1254,
173036 /* 60 */ 1492, 1493, 1254, 1254, 1254, 1543, 1545, 1508, 1420, 1419,
173037 /* 70 */ 1418, 1417, 1526, 1385, 1411, 1404, 1408, 1487, 1488, 1486,
173038 /* 80 */ 1641, 1493, 1492, 1254, 1407, 1455, 1471, 1454, 1254, 1254,
173039 /* 90 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173040 /* 100 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173041 /* 110 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173042 /* 120 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173043 /* 130 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173044 /* 140 */ 1463, 1470, 1469, 1468, 1477, 1467, 1464, 1457, 1456, 1458,
173045 /* 150 */ 1459, 1278, 1254, 1275, 1329, 1254, 1254, 1254, 1254, 1254,
173046 /* 160 */ 1460, 1287, 1448, 1447, 1446, 1254, 1474, 1461, 1473, 1472,
173047 /* 170 */ 1551, 1615, 1614, 1509, 1254, 1254, 1254, 1254, 1254, 1254,
173048 /* 180 */ 1578, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173049 /* 190 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173050 /* 200 */ 1254, 1254, 1254, 1387, 1578, 1578, 1254, 1287, 1578, 1578,
173051 /* 210 */ 1388, 1388, 1283, 1283, 1391, 1558, 1358, 1358, 1358, 1358,
173052 /* 220 */ 1367, 1358, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173053 /* 230 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1548, 1546, 1254,
173054 /* 240 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173055 /* 250 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173056 /* 260 */ 1254, 1254, 1254, 1254, 1254, 1254, 1363, 1254, 1254, 1254,
173057 /* 270 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1608, 1254,
173058 /* 280 */ 1521, 1343, 1363, 1363, 1363, 1363, 1365, 1344, 1342, 1357,
173059 /* 290 */ 1288, 1261, 1655, 1423, 1412, 1364, 1412, 1652, 1410, 1423,
173060 /* 300 */ 1423, 1410, 1423, 1364, 1652, 1304, 1630, 1299, 1397, 1397,
173061 /* 310 */ 1397, 1387, 1387, 1387, 1387, 1391, 1391, 1489, 1364, 1357,
173062 /* 320 */ 1254, 1655, 1655, 1373, 1373, 1654, 1654, 1373, 1509, 1638,
173063 /* 330 */ 1432, 1332, 1338, 1338, 1338, 1338, 1373, 1272, 1410, 1638,
173064 /* 340 */ 1638, 1410, 1432, 1332, 1410, 1332, 1410, 1373, 1272, 1525,
173065 /* 350 */ 1649, 1373, 1272, 1499, 1373, 1272, 1373, 1272, 1499, 1330,
173066 /* 360 */ 1330, 1330, 1319, 1254, 1254, 1499, 1330, 1304, 1330, 1319,
173067 /* 370 */ 1330, 1330, 1596, 1254, 1503, 1503, 1499, 1373, 1588, 1588,
173068 /* 380 */ 1400, 1400, 1405, 1391, 1494, 1373, 1254, 1405, 1403, 1401,
173069 /* 390 */ 1410, 1322, 1611, 1611, 1607, 1607, 1607, 1660, 1660, 1558,
173070 /* 400 */ 1623, 1287, 1287, 1287, 1287, 1623, 1306, 1306, 1288, 1288,
173071 /* 410 */ 1287, 1623, 1254, 1254, 1254, 1254, 1254, 1254, 1618, 1254,
173072 /* 420 */ 1553, 1510, 1377, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173073 /* 430 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1564,
173074 /* 440 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173075 /* 450 */ 1254, 1437, 1254, 1257, 1555, 1254, 1254, 1254, 1254, 1254,
173076 /* 460 */ 1254, 1254, 1254, 1414, 1415, 1378, 1254, 1254, 1254, 1254,
173077 /* 470 */ 1254, 1254, 1254, 1429, 1254, 1254, 1254, 1424, 1254, 1254,
173078 /* 480 */ 1254, 1254, 1254, 1254, 1254, 1254, 1651, 1254, 1254, 1254,
173079 /* 490 */ 1254, 1254, 1254, 1524, 1523, 1254, 1254, 1375, 1254, 1254,
173080 /* 500 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173081 /* 510 */ 1254, 1302, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173082 /* 520 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173083 /* 530 */ 1254, 1254, 1254, 1254, 1254, 1402, 1254, 1254, 1254, 1254,
173084 /* 540 */ 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173085 /* 550 */ 1593, 1392, 1254, 1254, 1254, 1254, 1642, 1254, 1254, 1254,
173086 /* 560 */ 1254, 1352, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
173087 /* 570 */ 1254, 1254, 1254, 1634, 1346, 1438, 1254, 1441, 1276, 1254,
173088 /* 580 */ 1266, 1254, 1254,
173089 };
173090 /********** End of lemon-generated parsing tables *****************************/
173091
173092 /* The next table maps tokens (terminal symbols) into fallback tokens.
173093 ** If a construct like the following:
@@ -173340,75 +173627,77 @@
173627 /* 250 */ "orderby_opt",
173628 /* 251 */ "limit_opt",
173629 /* 252 */ "window_clause",
173630 /* 253 */ "values",
173631 /* 254 */ "nexprlist",
173632 /* 255 */ "mvalues",
173633 /* 256 */ "sclp",
173634 /* 257 */ "as",
173635 /* 258 */ "seltablist",
173636 /* 259 */ "stl_prefix",
173637 /* 260 */ "joinop",
173638 /* 261 */ "on_using",
173639 /* 262 */ "indexed_by",
173640 /* 263 */ "exprlist",
173641 /* 264 */ "xfullname",
173642 /* 265 */ "idlist",
173643 /* 266 */ "indexed_opt",
173644 /* 267 */ "nulls",
173645 /* 268 */ "with",
173646 /* 269 */ "where_opt_ret",
173647 /* 270 */ "setlist",
173648 /* 271 */ "insert_cmd",
173649 /* 272 */ "idlist_opt",
173650 /* 273 */ "upsert",
173651 /* 274 */ "returning",
173652 /* 275 */ "filter_over",
173653 /* 276 */ "likeop",
173654 /* 277 */ "between_op",
173655 /* 278 */ "in_op",
173656 /* 279 */ "paren_exprlist",
173657 /* 280 */ "case_operand",
173658 /* 281 */ "case_exprlist",
173659 /* 282 */ "case_else",
173660 /* 283 */ "uniqueflag",
173661 /* 284 */ "collate",
173662 /* 285 */ "vinto",
173663 /* 286 */ "nmnum",
173664 /* 287 */ "trigger_decl",
173665 /* 288 */ "trigger_cmd_list",
173666 /* 289 */ "trigger_time",
173667 /* 290 */ "trigger_event",
173668 /* 291 */ "foreach_clause",
173669 /* 292 */ "when_clause",
173670 /* 293 */ "trigger_cmd",
173671 /* 294 */ "trnm",
173672 /* 295 */ "tridxby",
173673 /* 296 */ "database_kw_opt",
173674 /* 297 */ "key_opt",
173675 /* 298 */ "add_column_fullname",
173676 /* 299 */ "kwcolumn_opt",
173677 /* 300 */ "create_vtab",
173678 /* 301 */ "vtabarglist",
173679 /* 302 */ "vtabarg",
173680 /* 303 */ "vtabargtoken",
173681 /* 304 */ "lp",
173682 /* 305 */ "anylist",
173683 /* 306 */ "wqitem",
173684 /* 307 */ "wqas",
173685 /* 308 */ "withnm",
173686 /* 309 */ "windowdefn_list",
173687 /* 310 */ "windowdefn",
173688 /* 311 */ "window",
173689 /* 312 */ "frame_opt",
173690 /* 313 */ "part_opt",
173691 /* 314 */ "filter_clause",
173692 /* 315 */ "over_clause",
173693 /* 316 */ "range_or_rows",
173694 /* 317 */ "frame_bound",
173695 /* 318 */ "frame_bound_s",
173696 /* 319 */ "frame_bound_e",
173697 /* 320 */ "frame_exclude_opt",
173698 /* 321 */ "frame_exclude",
173699 };
173700 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
173701
173702 #ifndef NDEBUG
173703 /* For tracing reduce actions, the names of all rules are required.
@@ -173507,321 +173796,324 @@
173796 /* 90 */ "multiselect_op ::= UNION ALL",
173797 /* 91 */ "multiselect_op ::= EXCEPT|INTERSECT",
173798 /* 92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
173799 /* 93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
173800 /* 94 */ "values ::= VALUES LP nexprlist RP",
173801 /* 95 */ "oneselect ::= mvalues",
173802 /* 96 */ "mvalues ::= values COMMA LP nexprlist RP",
173803 /* 97 */ "mvalues ::= mvalues COMMA LP nexprlist RP",
173804 /* 98 */ "distinct ::= DISTINCT",
173805 /* 99 */ "distinct ::= ALL",
173806 /* 100 */ "distinct ::=",
173807 /* 101 */ "sclp ::=",
173808 /* 102 */ "selcollist ::= sclp scanpt expr scanpt as",
173809 /* 103 */ "selcollist ::= sclp scanpt STAR",
173810 /* 104 */ "selcollist ::= sclp scanpt nm DOT STAR",
173811 /* 105 */ "as ::= AS nm",
173812 /* 106 */ "as ::=",
173813 /* 107 */ "from ::=",
173814 /* 108 */ "from ::= FROM seltablist",
173815 /* 109 */ "stl_prefix ::= seltablist joinop",
173816 /* 110 */ "stl_prefix ::=",
173817 /* 111 */ "seltablist ::= stl_prefix nm dbnm as on_using",
173818 /* 112 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
173819 /* 113 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
173820 /* 114 */ "seltablist ::= stl_prefix LP select RP as on_using",
173821 /* 115 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
173822 /* 116 */ "dbnm ::=",
173823 /* 117 */ "dbnm ::= DOT nm",
173824 /* 118 */ "fullname ::= nm",
173825 /* 119 */ "fullname ::= nm DOT nm",
173826 /* 120 */ "xfullname ::= nm",
173827 /* 121 */ "xfullname ::= nm DOT nm",
173828 /* 122 */ "xfullname ::= nm DOT nm AS nm",
173829 /* 123 */ "xfullname ::= nm AS nm",
173830 /* 124 */ "joinop ::= COMMA|JOIN",
173831 /* 125 */ "joinop ::= JOIN_KW JOIN",
173832 /* 126 */ "joinop ::= JOIN_KW nm JOIN",
173833 /* 127 */ "joinop ::= JOIN_KW nm nm JOIN",
173834 /* 128 */ "on_using ::= ON expr",
173835 /* 129 */ "on_using ::= USING LP idlist RP",
173836 /* 130 */ "on_using ::=",
173837 /* 131 */ "indexed_opt ::=",
173838 /* 132 */ "indexed_by ::= INDEXED BY nm",
173839 /* 133 */ "indexed_by ::= NOT INDEXED",
173840 /* 134 */ "orderby_opt ::=",
173841 /* 135 */ "orderby_opt ::= ORDER BY sortlist",
173842 /* 136 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
173843 /* 137 */ "sortlist ::= expr sortorder nulls",
173844 /* 138 */ "sortorder ::= ASC",
173845 /* 139 */ "sortorder ::= DESC",
173846 /* 140 */ "sortorder ::=",
173847 /* 141 */ "nulls ::= NULLS FIRST",
173848 /* 142 */ "nulls ::= NULLS LAST",
173849 /* 143 */ "nulls ::=",
173850 /* 144 */ "groupby_opt ::=",
173851 /* 145 */ "groupby_opt ::= GROUP BY nexprlist",
173852 /* 146 */ "having_opt ::=",
173853 /* 147 */ "having_opt ::= HAVING expr",
173854 /* 148 */ "limit_opt ::=",
173855 /* 149 */ "limit_opt ::= LIMIT expr",
173856 /* 150 */ "limit_opt ::= LIMIT expr OFFSET expr",
173857 /* 151 */ "limit_opt ::= LIMIT expr COMMA expr",
173858 /* 152 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
173859 /* 153 */ "where_opt ::=",
173860 /* 154 */ "where_opt ::= WHERE expr",
173861 /* 155 */ "where_opt_ret ::=",
173862 /* 156 */ "where_opt_ret ::= WHERE expr",
173863 /* 157 */ "where_opt_ret ::= RETURNING selcollist",
173864 /* 158 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
173865 /* 159 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
173866 /* 160 */ "setlist ::= setlist COMMA nm EQ expr",
173867 /* 161 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
173868 /* 162 */ "setlist ::= nm EQ expr",
173869 /* 163 */ "setlist ::= LP idlist RP EQ expr",
173870 /* 164 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
173871 /* 165 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
173872 /* 166 */ "upsert ::=",
173873 /* 167 */ "upsert ::= RETURNING selcollist",
173874 /* 168 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
173875 /* 169 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
173876 /* 170 */ "upsert ::= ON CONFLICT DO NOTHING returning",
173877 /* 171 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
173878 /* 172 */ "returning ::= RETURNING selcollist",
173879 /* 173 */ "insert_cmd ::= INSERT orconf",
173880 /* 174 */ "insert_cmd ::= REPLACE",
173881 /* 175 */ "idlist_opt ::=",
173882 /* 176 */ "idlist_opt ::= LP idlist RP",
173883 /* 177 */ "idlist ::= idlist COMMA nm",
173884 /* 178 */ "idlist ::= nm",
173885 /* 179 */ "expr ::= LP expr RP",
173886 /* 180 */ "expr ::= ID|INDEXED|JOIN_KW",
173887 /* 181 */ "expr ::= nm DOT nm",
173888 /* 182 */ "expr ::= nm DOT nm DOT nm",
173889 /* 183 */ "term ::= NULL|FLOAT|BLOB",
173890 /* 184 */ "term ::= STRING",
173891 /* 185 */ "term ::= INTEGER",
173892 /* 186 */ "expr ::= VARIABLE",
173893 /* 187 */ "expr ::= expr COLLATE ID|STRING",
173894 /* 188 */ "expr ::= CAST LP expr AS typetoken RP",
173895 /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
173896 /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
173897 /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
173898 /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
173899 /* 193 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
173900 /* 194 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
173901 /* 195 */ "term ::= CTIME_KW",
173902 /* 196 */ "expr ::= LP nexprlist COMMA expr RP",
173903 /* 197 */ "expr ::= expr AND expr",
173904 /* 198 */ "expr ::= expr OR expr",
173905 /* 199 */ "expr ::= expr LT|GT|GE|LE expr",
173906 /* 200 */ "expr ::= expr EQ|NE expr",
173907 /* 201 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
173908 /* 202 */ "expr ::= expr PLUS|MINUS expr",
173909 /* 203 */ "expr ::= expr STAR|SLASH|REM expr",
173910 /* 204 */ "expr ::= expr CONCAT expr",
173911 /* 205 */ "likeop ::= NOT LIKE_KW|MATCH",
173912 /* 206 */ "expr ::= expr likeop expr",
173913 /* 207 */ "expr ::= expr likeop expr ESCAPE expr",
173914 /* 208 */ "expr ::= expr ISNULL|NOTNULL",
173915 /* 209 */ "expr ::= expr NOT NULL",
173916 /* 210 */ "expr ::= expr IS expr",
173917 /* 211 */ "expr ::= expr IS NOT expr",
173918 /* 212 */ "expr ::= expr IS NOT DISTINCT FROM expr",
173919 /* 213 */ "expr ::= expr IS DISTINCT FROM expr",
173920 /* 214 */ "expr ::= NOT expr",
173921 /* 215 */ "expr ::= BITNOT expr",
173922 /* 216 */ "expr ::= PLUS|MINUS expr",
173923 /* 217 */ "expr ::= expr PTR expr",
173924 /* 218 */ "between_op ::= BETWEEN",
173925 /* 219 */ "between_op ::= NOT BETWEEN",
173926 /* 220 */ "expr ::= expr between_op expr AND expr",
173927 /* 221 */ "in_op ::= IN",
173928 /* 222 */ "in_op ::= NOT IN",
173929 /* 223 */ "expr ::= expr in_op LP exprlist RP",
173930 /* 224 */ "expr ::= LP select RP",
173931 /* 225 */ "expr ::= expr in_op LP select RP",
173932 /* 226 */ "expr ::= expr in_op nm dbnm paren_exprlist",
173933 /* 227 */ "expr ::= EXISTS LP select RP",
173934 /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
173935 /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
173936 /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
173937 /* 231 */ "case_else ::= ELSE expr",
173938 /* 232 */ "case_else ::=",
173939 /* 233 */ "case_operand ::=",
173940 /* 234 */ "exprlist ::=",
173941 /* 235 */ "nexprlist ::= nexprlist COMMA expr",
173942 /* 236 */ "nexprlist ::= expr",
173943 /* 237 */ "paren_exprlist ::=",
173944 /* 238 */ "paren_exprlist ::= LP exprlist RP",
173945 /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
173946 /* 240 */ "uniqueflag ::= UNIQUE",
173947 /* 241 */ "uniqueflag ::=",
173948 /* 242 */ "eidlist_opt ::=",
173949 /* 243 */ "eidlist_opt ::= LP eidlist RP",
173950 /* 244 */ "eidlist ::= eidlist COMMA nm collate sortorder",
173951 /* 245 */ "eidlist ::= nm collate sortorder",
173952 /* 246 */ "collate ::=",
173953 /* 247 */ "collate ::= COLLATE ID|STRING",
173954 /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
173955 /* 249 */ "cmd ::= VACUUM vinto",
173956 /* 250 */ "cmd ::= VACUUM nm vinto",
173957 /* 251 */ "vinto ::= INTO expr",
173958 /* 252 */ "vinto ::=",
173959 /* 253 */ "cmd ::= PRAGMA nm dbnm",
173960 /* 254 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
173961 /* 255 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
173962 /* 256 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
173963 /* 257 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
173964 /* 258 */ "plus_num ::= PLUS INTEGER|FLOAT",
173965 /* 259 */ "minus_num ::= MINUS INTEGER|FLOAT",
173966 /* 260 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
173967 /* 261 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
173968 /* 262 */ "trigger_time ::= BEFORE|AFTER",
173969 /* 263 */ "trigger_time ::= INSTEAD OF",
173970 /* 264 */ "trigger_time ::=",
173971 /* 265 */ "trigger_event ::= DELETE|INSERT",
173972 /* 266 */ "trigger_event ::= UPDATE",
173973 /* 267 */ "trigger_event ::= UPDATE OF idlist",
173974 /* 268 */ "when_clause ::=",
173975 /* 269 */ "when_clause ::= WHEN expr",
173976 /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
173977 /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI",
173978 /* 272 */ "trnm ::= nm DOT nm",
173979 /* 273 */ "tridxby ::= INDEXED BY nm",
173980 /* 274 */ "tridxby ::= NOT INDEXED",
173981 /* 275 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
173982 /* 276 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
173983 /* 277 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
173984 /* 278 */ "trigger_cmd ::= scanpt select scanpt",
173985 /* 279 */ "expr ::= RAISE LP IGNORE RP",
173986 /* 280 */ "expr ::= RAISE LP raisetype COMMA nm RP",
173987 /* 281 */ "raisetype ::= ROLLBACK",
173988 /* 282 */ "raisetype ::= ABORT",
173989 /* 283 */ "raisetype ::= FAIL",
173990 /* 284 */ "cmd ::= DROP TRIGGER ifexists fullname",
173991 /* 285 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
173992 /* 286 */ "cmd ::= DETACH database_kw_opt expr",
173993 /* 287 */ "key_opt ::=",
173994 /* 288 */ "key_opt ::= KEY expr",
173995 /* 289 */ "cmd ::= REINDEX",
173996 /* 290 */ "cmd ::= REINDEX nm dbnm",
173997 /* 291 */ "cmd ::= ANALYZE",
173998 /* 292 */ "cmd ::= ANALYZE nm dbnm",
173999 /* 293 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
174000 /* 294 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
174001 /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
174002 /* 296 */ "add_column_fullname ::= fullname",
174003 /* 297 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
174004 /* 298 */ "cmd ::= create_vtab",
174005 /* 299 */ "cmd ::= create_vtab LP vtabarglist RP",
174006 /* 300 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
174007 /* 301 */ "vtabarg ::=",
174008 /* 302 */ "vtabargtoken ::= ANY",
174009 /* 303 */ "vtabargtoken ::= lp anylist RP",
174010 /* 304 */ "lp ::= LP",
174011 /* 305 */ "with ::= WITH wqlist",
174012 /* 306 */ "with ::= WITH RECURSIVE wqlist",
174013 /* 307 */ "wqas ::= AS",
174014 /* 308 */ "wqas ::= AS MATERIALIZED",
174015 /* 309 */ "wqas ::= AS NOT MATERIALIZED",
174016 /* 310 */ "wqitem ::= withnm eidlist_opt wqas LP select RP",
174017 /* 311 */ "withnm ::= nm",
174018 /* 312 */ "wqlist ::= wqitem",
174019 /* 313 */ "wqlist ::= wqlist COMMA wqitem",
174020 /* 314 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
174021 /* 315 */ "windowdefn ::= nm AS LP window RP",
174022 /* 316 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
174023 /* 317 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
174024 /* 318 */ "window ::= ORDER BY sortlist frame_opt",
174025 /* 319 */ "window ::= nm ORDER BY sortlist frame_opt",
174026 /* 320 */ "window ::= nm frame_opt",
174027 /* 321 */ "frame_opt ::=",
174028 /* 322 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
174029 /* 323 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
174030 /* 324 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
174031 /* 325 */ "frame_bound_s ::= frame_bound",
174032 /* 326 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
174033 /* 327 */ "frame_bound_e ::= frame_bound",
174034 /* 328 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
174035 /* 329 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
174036 /* 330 */ "frame_bound ::= CURRENT ROW",
174037 /* 331 */ "frame_exclude_opt ::=",
174038 /* 332 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
174039 /* 333 */ "frame_exclude ::= NO OTHERS",
174040 /* 334 */ "frame_exclude ::= CURRENT ROW",
174041 /* 335 */ "frame_exclude ::= GROUP|TIES",
174042 /* 336 */ "window_clause ::= WINDOW windowdefn_list",
174043 /* 337 */ "filter_over ::= filter_clause over_clause",
174044 /* 338 */ "filter_over ::= over_clause",
174045 /* 339 */ "filter_over ::= filter_clause",
174046 /* 340 */ "over_clause ::= OVER LP window RP",
174047 /* 341 */ "over_clause ::= OVER nm",
174048 /* 342 */ "filter_clause ::= FILTER LP WHERE expr RP",
174049 /* 343 */ "term ::= QNUMBER",
174050 /* 344 */ "input ::= cmdlist",
174051 /* 345 */ "cmdlist ::= cmdlist ecmd",
174052 /* 346 */ "cmdlist ::= ecmd",
174053 /* 347 */ "ecmd ::= SEMI",
174054 /* 348 */ "ecmd ::= cmdx SEMI",
174055 /* 349 */ "ecmd ::= explain cmdx SEMI",
174056 /* 350 */ "trans_opt ::=",
174057 /* 351 */ "trans_opt ::= TRANSACTION",
174058 /* 352 */ "trans_opt ::= TRANSACTION nm",
174059 /* 353 */ "savepoint_opt ::= SAVEPOINT",
174060 /* 354 */ "savepoint_opt ::=",
174061 /* 355 */ "cmd ::= create_table create_table_args",
174062 /* 356 */ "table_option_set ::= table_option",
174063 /* 357 */ "columnlist ::= columnlist COMMA columnname carglist",
174064 /* 358 */ "columnlist ::= columnname carglist",
174065 /* 359 */ "nm ::= ID|INDEXED|JOIN_KW",
174066 /* 360 */ "nm ::= STRING",
174067 /* 361 */ "typetoken ::= typename",
174068 /* 362 */ "typename ::= ID|STRING",
174069 /* 363 */ "signed ::= plus_num",
174070 /* 364 */ "signed ::= minus_num",
174071 /* 365 */ "carglist ::= carglist ccons",
174072 /* 366 */ "carglist ::=",
174073 /* 367 */ "ccons ::= NULL onconf",
174074 /* 368 */ "ccons ::= GENERATED ALWAYS AS generated",
174075 /* 369 */ "ccons ::= AS generated",
174076 /* 370 */ "conslist_opt ::= COMMA conslist",
174077 /* 371 */ "conslist ::= conslist tconscomma tcons",
174078 /* 372 */ "conslist ::= tcons",
174079 /* 373 */ "tconscomma ::=",
174080 /* 374 */ "defer_subclause_opt ::= defer_subclause",
174081 /* 375 */ "resolvetype ::= raisetype",
174082 /* 376 */ "selectnowith ::= oneselect",
174083 /* 377 */ "oneselect ::= values",
174084 /* 378 */ "sclp ::= selcollist COMMA",
174085 /* 379 */ "as ::= ID|STRING",
174086 /* 380 */ "indexed_opt ::= indexed_by",
174087 /* 381 */ "returning ::=",
174088 /* 382 */ "expr ::= term",
174089 /* 383 */ "likeop ::= LIKE_KW|MATCH",
174090 /* 384 */ "case_operand ::= expr",
174091 /* 385 */ "exprlist ::= nexprlist",
174092 /* 386 */ "nmnum ::= plus_num",
174093 /* 387 */ "nmnum ::= nm",
174094 /* 388 */ "nmnum ::= ON",
174095 /* 389 */ "nmnum ::= DELETE",
174096 /* 390 */ "nmnum ::= DEFAULT",
174097 /* 391 */ "plus_num ::= INTEGER|FLOAT",
174098 /* 392 */ "foreach_clause ::=",
174099 /* 393 */ "foreach_clause ::= FOR EACH ROW",
174100 /* 394 */ "trnm ::= nm",
174101 /* 395 */ "tridxby ::=",
174102 /* 396 */ "database_kw_opt ::= DATABASE",
174103 /* 397 */ "database_kw_opt ::=",
174104 /* 398 */ "kwcolumn_opt ::=",
174105 /* 399 */ "kwcolumn_opt ::= COLUMNKW",
174106 /* 400 */ "vtabarglist ::= vtabarg",
174107 /* 401 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
174108 /* 402 */ "vtabarg ::= vtabarg vtabargtoken",
174109 /* 403 */ "anylist ::=",
174110 /* 404 */ "anylist ::= anylist LP anylist RP",
174111 /* 405 */ "anylist ::= anylist ANY",
174112 /* 406 */ "with ::=",
174113 /* 407 */ "windowdefn_list ::= windowdefn",
174114 /* 408 */ "window ::= frame_opt",
174115 };
174116 #endif /* NDEBUG */
174117
174118
174119 #if YYGROWABLESTACK
@@ -173945,97 +174237,98 @@
174237 /********* Begin destructor definitions ***************************************/
174238 case 205: /* select */
174239 case 240: /* selectnowith */
174240 case 241: /* oneselect */
174241 case 253: /* values */
174242 case 255: /* mvalues */
174243 {
174244 sqlite3SelectDelete(pParse->db, (yypminor->yy555));
174245 }
174246 break;
174247 case 217: /* term */
174248 case 218: /* expr */
174249 case 247: /* where_opt */
174250 case 249: /* having_opt */
174251 case 269: /* where_opt_ret */
174252 case 280: /* case_operand */
174253 case 282: /* case_else */
174254 case 285: /* vinto */
174255 case 292: /* when_clause */
174256 case 297: /* key_opt */
174257 case 314: /* filter_clause */
174258 {
174259 sqlite3ExprDelete(pParse->db, (yypminor->yy454));
174260 }
174261 break;
174262 case 222: /* eidlist_opt */
174263 case 232: /* sortlist */
174264 case 233: /* eidlist */
174265 case 245: /* selcollist */
174266 case 248: /* groupby_opt */
174267 case 250: /* orderby_opt */
174268 case 254: /* nexprlist */
174269 case 256: /* sclp */
174270 case 263: /* exprlist */
174271 case 270: /* setlist */
174272 case 279: /* paren_exprlist */
174273 case 281: /* case_exprlist */
174274 case 313: /* part_opt */
174275 {
174276 sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
174277 }
174278 break;
174279 case 239: /* fullname */
174280 case 246: /* from */
174281 case 258: /* seltablist */
174282 case 259: /* stl_prefix */
174283 case 264: /* xfullname */
174284 {
174285 sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
174286 }
174287 break;
174288 case 242: /* wqlist */
174289 {
174290 sqlite3WithDelete(pParse->db, (yypminor->yy59));
174291 }
174292 break;
174293 case 252: /* window_clause */
174294 case 309: /* windowdefn_list */
174295 {
174296 sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
174297 }
174298 break;
174299 case 265: /* idlist */
174300 case 272: /* idlist_opt */
174301 {
174302 sqlite3IdListDelete(pParse->db, (yypminor->yy132));
174303 }
174304 break;
174305 case 275: /* filter_over */
174306 case 310: /* windowdefn */
174307 case 311: /* window */
174308 case 312: /* frame_opt */
174309 case 315: /* over_clause */
174310 {
174311 sqlite3WindowDelete(pParse->db, (yypminor->yy211));
174312 }
174313 break;
174314 case 288: /* trigger_cmd_list */
174315 case 293: /* trigger_cmd */
174316 {
174317 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
174318 }
174319 break;
174320 case 290: /* trigger_event */
174321 {
174322 sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
174323 }
174324 break;
174325 case 317: /* frame_bound */
174326 case 318: /* frame_bound_s */
174327 case 319: /* frame_bound_e */
174328 {
174329 sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
174330 }
174331 break;
174332 /********* End destructor definitions *****************************************/
174333 default: break; /* If no destructor action specified: do nothing */
174334 }
@@ -174428,321 +174721,324 @@
174721 243, /* (90) multiselect_op ::= UNION ALL */
174722 243, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
174723 241, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
174724 241, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
174725 253, /* (94) values ::= VALUES LP nexprlist RP */
174726 241, /* (95) oneselect ::= mvalues */
174727 255, /* (96) mvalues ::= values COMMA LP nexprlist RP */
174728 255, /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
174729 244, /* (98) distinct ::= DISTINCT */
174730 244, /* (99) distinct ::= ALL */
174731 244, /* (100) distinct ::= */
174732 256, /* (101) sclp ::= */
174733 245, /* (102) selcollist ::= sclp scanpt expr scanpt as */
174734 245, /* (103) selcollist ::= sclp scanpt STAR */
174735 245, /* (104) selcollist ::= sclp scanpt nm DOT STAR */
174736 257, /* (105) as ::= AS nm */
174737 257, /* (106) as ::= */
174738 246, /* (107) from ::= */
174739 246, /* (108) from ::= FROM seltablist */
174740 259, /* (109) stl_prefix ::= seltablist joinop */
174741 259, /* (110) stl_prefix ::= */
174742 258, /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
174743 258, /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
174744 258, /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
174745 258, /* (114) seltablist ::= stl_prefix LP select RP as on_using */
174746 258, /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
174747 201, /* (116) dbnm ::= */
174748 201, /* (117) dbnm ::= DOT nm */
174749 239, /* (118) fullname ::= nm */
174750 239, /* (119) fullname ::= nm DOT nm */
174751 264, /* (120) xfullname ::= nm */
174752 264, /* (121) xfullname ::= nm DOT nm */
174753 264, /* (122) xfullname ::= nm DOT nm AS nm */
174754 264, /* (123) xfullname ::= nm AS nm */
174755 260, /* (124) joinop ::= COMMA|JOIN */
174756 260, /* (125) joinop ::= JOIN_KW JOIN */
174757 260, /* (126) joinop ::= JOIN_KW nm JOIN */
174758 260, /* (127) joinop ::= JOIN_KW nm nm JOIN */
174759 261, /* (128) on_using ::= ON expr */
174760 261, /* (129) on_using ::= USING LP idlist RP */
174761 261, /* (130) on_using ::= */
174762 266, /* (131) indexed_opt ::= */
174763 262, /* (132) indexed_by ::= INDEXED BY nm */
174764 262, /* (133) indexed_by ::= NOT INDEXED */
174765 250, /* (134) orderby_opt ::= */
174766 250, /* (135) orderby_opt ::= ORDER BY sortlist */
174767 232, /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
174768 232, /* (137) sortlist ::= expr sortorder nulls */
174769 220, /* (138) sortorder ::= ASC */
174770 220, /* (139) sortorder ::= DESC */
174771 220, /* (140) sortorder ::= */
174772 267, /* (141) nulls ::= NULLS FIRST */
174773 267, /* (142) nulls ::= NULLS LAST */
174774 267, /* (143) nulls ::= */
174775 248, /* (144) groupby_opt ::= */
174776 248, /* (145) groupby_opt ::= GROUP BY nexprlist */
174777 249, /* (146) having_opt ::= */
174778 249, /* (147) having_opt ::= HAVING expr */
174779 251, /* (148) limit_opt ::= */
174780 251, /* (149) limit_opt ::= LIMIT expr */
174781 251, /* (150) limit_opt ::= LIMIT expr OFFSET expr */
174782 251, /* (151) limit_opt ::= LIMIT expr COMMA expr */
174783 191, /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
174784 247, /* (153) where_opt ::= */
174785 247, /* (154) where_opt ::= WHERE expr */
174786 269, /* (155) where_opt_ret ::= */
174787 269, /* (156) where_opt_ret ::= WHERE expr */
174788 269, /* (157) where_opt_ret ::= RETURNING selcollist */
174789 269, /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
174790 191, /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
174791 270, /* (160) setlist ::= setlist COMMA nm EQ expr */
174792 270, /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
174793 270, /* (162) setlist ::= nm EQ expr */
174794 270, /* (163) setlist ::= LP idlist RP EQ expr */
174795 191, /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
174796 191, /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
174797 273, /* (166) upsert ::= */
174798 273, /* (167) upsert ::= RETURNING selcollist */
174799 273, /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
174800 273, /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
174801 273, /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
174802 273, /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
174803 274, /* (172) returning ::= RETURNING selcollist */
174804 271, /* (173) insert_cmd ::= INSERT orconf */
174805 271, /* (174) insert_cmd ::= REPLACE */
174806 272, /* (175) idlist_opt ::= */
174807 272, /* (176) idlist_opt ::= LP idlist RP */
174808 265, /* (177) idlist ::= idlist COMMA nm */
174809 265, /* (178) idlist ::= nm */
174810 218, /* (179) expr ::= LP expr RP */
174811 218, /* (180) expr ::= ID|INDEXED|JOIN_KW */
174812 218, /* (181) expr ::= nm DOT nm */
174813 218, /* (182) expr ::= nm DOT nm DOT nm */
174814 217, /* (183) term ::= NULL|FLOAT|BLOB */
174815 217, /* (184) term ::= STRING */
174816 217, /* (185) term ::= INTEGER */
174817 218, /* (186) expr ::= VARIABLE */
174818 218, /* (187) expr ::= expr COLLATE ID|STRING */
174819 218, /* (188) expr ::= CAST LP expr AS typetoken RP */
174820 218, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
174821 218, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
174822 218, /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
174823 218, /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
174824 218, /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
174825 218, /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
174826 217, /* (195) term ::= CTIME_KW */
174827 218, /* (196) expr ::= LP nexprlist COMMA expr RP */
174828 218, /* (197) expr ::= expr AND expr */
174829 218, /* (198) expr ::= expr OR expr */
174830 218, /* (199) expr ::= expr LT|GT|GE|LE expr */
174831 218, /* (200) expr ::= expr EQ|NE expr */
174832 218, /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
174833 218, /* (202) expr ::= expr PLUS|MINUS expr */
174834 218, /* (203) expr ::= expr STAR|SLASH|REM expr */
174835 218, /* (204) expr ::= expr CONCAT expr */
174836 276, /* (205) likeop ::= NOT LIKE_KW|MATCH */
174837 218, /* (206) expr ::= expr likeop expr */
174838 218, /* (207) expr ::= expr likeop expr ESCAPE expr */
174839 218, /* (208) expr ::= expr ISNULL|NOTNULL */
174840 218, /* (209) expr ::= expr NOT NULL */
174841 218, /* (210) expr ::= expr IS expr */
174842 218, /* (211) expr ::= expr IS NOT expr */
174843 218, /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
174844 218, /* (213) expr ::= expr IS DISTINCT FROM expr */
174845 218, /* (214) expr ::= NOT expr */
174846 218, /* (215) expr ::= BITNOT expr */
174847 218, /* (216) expr ::= PLUS|MINUS expr */
174848 218, /* (217) expr ::= expr PTR expr */
174849 277, /* (218) between_op ::= BETWEEN */
174850 277, /* (219) between_op ::= NOT BETWEEN */
174851 218, /* (220) expr ::= expr between_op expr AND expr */
174852 278, /* (221) in_op ::= IN */
174853 278, /* (222) in_op ::= NOT IN */
174854 218, /* (223) expr ::= expr in_op LP exprlist RP */
174855 218, /* (224) expr ::= LP select RP */
174856 218, /* (225) expr ::= expr in_op LP select RP */
174857 218, /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
174858 218, /* (227) expr ::= EXISTS LP select RP */
174859 218, /* (228) expr ::= CASE case_operand case_exprlist case_else END */
174860 281, /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
174861 281, /* (230) case_exprlist ::= WHEN expr THEN expr */
174862 282, /* (231) case_else ::= ELSE expr */
174863 282, /* (232) case_else ::= */
174864 280, /* (233) case_operand ::= */
174865 263, /* (234) exprlist ::= */
174866 254, /* (235) nexprlist ::= nexprlist COMMA expr */
174867 254, /* (236) nexprlist ::= expr */
174868 279, /* (237) paren_exprlist ::= */
174869 279, /* (238) paren_exprlist ::= LP exprlist RP */
174870 191, /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
174871 283, /* (240) uniqueflag ::= UNIQUE */
174872 283, /* (241) uniqueflag ::= */
174873 222, /* (242) eidlist_opt ::= */
174874 222, /* (243) eidlist_opt ::= LP eidlist RP */
174875 233, /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
174876 233, /* (245) eidlist ::= nm collate sortorder */
174877 284, /* (246) collate ::= */
174878 284, /* (247) collate ::= COLLATE ID|STRING */
174879 191, /* (248) cmd ::= DROP INDEX ifexists fullname */
174880 191, /* (249) cmd ::= VACUUM vinto */
174881 191, /* (250) cmd ::= VACUUM nm vinto */
174882 285, /* (251) vinto ::= INTO expr */
174883 285, /* (252) vinto ::= */
174884 191, /* (253) cmd ::= PRAGMA nm dbnm */
174885 191, /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
174886 191, /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
174887 191, /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
174888 191, /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
174889 212, /* (258) plus_num ::= PLUS INTEGER|FLOAT */
174890 213, /* (259) minus_num ::= MINUS INTEGER|FLOAT */
174891 191, /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
174892 287, /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
174893 289, /* (262) trigger_time ::= BEFORE|AFTER */
174894 289, /* (263) trigger_time ::= INSTEAD OF */
174895 289, /* (264) trigger_time ::= */
174896 290, /* (265) trigger_event ::= DELETE|INSERT */
174897 290, /* (266) trigger_event ::= UPDATE */
174898 290, /* (267) trigger_event ::= UPDATE OF idlist */
174899 292, /* (268) when_clause ::= */
174900 292, /* (269) when_clause ::= WHEN expr */
174901 288, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
174902 288, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
174903 294, /* (272) trnm ::= nm DOT nm */
174904 295, /* (273) tridxby ::= INDEXED BY nm */
174905 295, /* (274) tridxby ::= NOT INDEXED */
174906 293, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
174907 293, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
174908 293, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
174909 293, /* (278) trigger_cmd ::= scanpt select scanpt */
174910 218, /* (279) expr ::= RAISE LP IGNORE RP */
174911 218, /* (280) expr ::= RAISE LP raisetype COMMA nm RP */
174912 237, /* (281) raisetype ::= ROLLBACK */
174913 237, /* (282) raisetype ::= ABORT */
174914 237, /* (283) raisetype ::= FAIL */
174915 191, /* (284) cmd ::= DROP TRIGGER ifexists fullname */
174916 191, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
174917 191, /* (286) cmd ::= DETACH database_kw_opt expr */
174918 297, /* (287) key_opt ::= */
174919 297, /* (288) key_opt ::= KEY expr */
174920 191, /* (289) cmd ::= REINDEX */
174921 191, /* (290) cmd ::= REINDEX nm dbnm */
174922 191, /* (291) cmd ::= ANALYZE */
174923 191, /* (292) cmd ::= ANALYZE nm dbnm */
174924 191, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
174925 191, /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
174926 191, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
174927 298, /* (296) add_column_fullname ::= fullname */
174928 191, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
174929 191, /* (298) cmd ::= create_vtab */
174930 191, /* (299) cmd ::= create_vtab LP vtabarglist RP */
174931 300, /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
174932 302, /* (301) vtabarg ::= */
174933 303, /* (302) vtabargtoken ::= ANY */
174934 303, /* (303) vtabargtoken ::= lp anylist RP */
174935 304, /* (304) lp ::= LP */
174936 268, /* (305) with ::= WITH wqlist */
174937 268, /* (306) with ::= WITH RECURSIVE wqlist */
174938 307, /* (307) wqas ::= AS */
174939 307, /* (308) wqas ::= AS MATERIALIZED */
174940 307, /* (309) wqas ::= AS NOT MATERIALIZED */
174941 306, /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
174942 308, /* (311) withnm ::= nm */
174943 242, /* (312) wqlist ::= wqitem */
174944 242, /* (313) wqlist ::= wqlist COMMA wqitem */
174945 309, /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
174946 310, /* (315) windowdefn ::= nm AS LP window RP */
174947 311, /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
174948 311, /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
174949 311, /* (318) window ::= ORDER BY sortlist frame_opt */
174950 311, /* (319) window ::= nm ORDER BY sortlist frame_opt */
174951 311, /* (320) window ::= nm frame_opt */
174952 312, /* (321) frame_opt ::= */
174953 312, /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
174954 312, /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
174955 316, /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
174956 318, /* (325) frame_bound_s ::= frame_bound */
174957 318, /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
174958 319, /* (327) frame_bound_e ::= frame_bound */
174959 319, /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
174960 317, /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
174961 317, /* (330) frame_bound ::= CURRENT ROW */
174962 320, /* (331) frame_exclude_opt ::= */
174963 320, /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
174964 321, /* (333) frame_exclude ::= NO OTHERS */
174965 321, /* (334) frame_exclude ::= CURRENT ROW */
174966 321, /* (335) frame_exclude ::= GROUP|TIES */
174967 252, /* (336) window_clause ::= WINDOW windowdefn_list */
174968 275, /* (337) filter_over ::= filter_clause over_clause */
174969 275, /* (338) filter_over ::= over_clause */
174970 275, /* (339) filter_over ::= filter_clause */
174971 315, /* (340) over_clause ::= OVER LP window RP */
174972 315, /* (341) over_clause ::= OVER nm */
174973 314, /* (342) filter_clause ::= FILTER LP WHERE expr RP */
174974 217, /* (343) term ::= QNUMBER */
174975 186, /* (344) input ::= cmdlist */
174976 187, /* (345) cmdlist ::= cmdlist ecmd */
174977 187, /* (346) cmdlist ::= ecmd */
174978 188, /* (347) ecmd ::= SEMI */
174979 188, /* (348) ecmd ::= cmdx SEMI */
174980 188, /* (349) ecmd ::= explain cmdx SEMI */
174981 193, /* (350) trans_opt ::= */
174982 193, /* (351) trans_opt ::= TRANSACTION */
174983 193, /* (352) trans_opt ::= TRANSACTION nm */
174984 195, /* (353) savepoint_opt ::= SAVEPOINT */
174985 195, /* (354) savepoint_opt ::= */
174986 191, /* (355) cmd ::= create_table create_table_args */
174987 204, /* (356) table_option_set ::= table_option */
174988 202, /* (357) columnlist ::= columnlist COMMA columnname carglist */
174989 202, /* (358) columnlist ::= columnname carglist */
174990 194, /* (359) nm ::= ID|INDEXED|JOIN_KW */
174991 194, /* (360) nm ::= STRING */
174992 209, /* (361) typetoken ::= typename */
174993 210, /* (362) typename ::= ID|STRING */
174994 211, /* (363) signed ::= plus_num */
174995 211, /* (364) signed ::= minus_num */
174996 208, /* (365) carglist ::= carglist ccons */
174997 208, /* (366) carglist ::= */
174998 216, /* (367) ccons ::= NULL onconf */
174999 216, /* (368) ccons ::= GENERATED ALWAYS AS generated */
175000 216, /* (369) ccons ::= AS generated */
175001 203, /* (370) conslist_opt ::= COMMA conslist */
175002 229, /* (371) conslist ::= conslist tconscomma tcons */
175003 229, /* (372) conslist ::= tcons */
175004 230, /* (373) tconscomma ::= */
175005 234, /* (374) defer_subclause_opt ::= defer_subclause */
175006 236, /* (375) resolvetype ::= raisetype */
175007 240, /* (376) selectnowith ::= oneselect */
175008 241, /* (377) oneselect ::= values */
175009 256, /* (378) sclp ::= selcollist COMMA */
175010 257, /* (379) as ::= ID|STRING */
175011 266, /* (380) indexed_opt ::= indexed_by */
175012 274, /* (381) returning ::= */
175013 218, /* (382) expr ::= term */
175014 276, /* (383) likeop ::= LIKE_KW|MATCH */
175015 280, /* (384) case_operand ::= expr */
175016 263, /* (385) exprlist ::= nexprlist */
175017 286, /* (386) nmnum ::= plus_num */
175018 286, /* (387) nmnum ::= nm */
175019 286, /* (388) nmnum ::= ON */
175020 286, /* (389) nmnum ::= DELETE */
175021 286, /* (390) nmnum ::= DEFAULT */
175022 212, /* (391) plus_num ::= INTEGER|FLOAT */
175023 291, /* (392) foreach_clause ::= */
175024 291, /* (393) foreach_clause ::= FOR EACH ROW */
175025 294, /* (394) trnm ::= nm */
175026 295, /* (395) tridxby ::= */
175027 296, /* (396) database_kw_opt ::= DATABASE */
175028 296, /* (397) database_kw_opt ::= */
175029 299, /* (398) kwcolumn_opt ::= */
175030 299, /* (399) kwcolumn_opt ::= COLUMNKW */
175031 301, /* (400) vtabarglist ::= vtabarg */
175032 301, /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
175033 302, /* (402) vtabarg ::= vtabarg vtabargtoken */
175034 305, /* (403) anylist ::= */
175035 305, /* (404) anylist ::= anylist LP anylist RP */
175036 305, /* (405) anylist ::= anylist ANY */
175037 268, /* (406) with ::= */
175038 309, /* (407) windowdefn_list ::= windowdefn */
175039 311, /* (408) window ::= frame_opt */
175040 };
175041
175042 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
175043 ** of symbols on the right-hand side of that rule. */
175044 static const signed char yyRuleInfoNRhs[] = {
@@ -174839,321 +175135,324 @@
175135 -2, /* (90) multiselect_op ::= UNION ALL */
175136 -1, /* (91) multiselect_op ::= EXCEPT|INTERSECT */
175137 -9, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
175138 -10, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
175139 -4, /* (94) values ::= VALUES LP nexprlist RP */
175140 -1, /* (95) oneselect ::= mvalues */
175141 -5, /* (96) mvalues ::= values COMMA LP nexprlist RP */
175142 -5, /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
175143 -1, /* (98) distinct ::= DISTINCT */
175144 -1, /* (99) distinct ::= ALL */
175145 0, /* (100) distinct ::= */
175146 0, /* (101) sclp ::= */
175147 -5, /* (102) selcollist ::= sclp scanpt expr scanpt as */
175148 -3, /* (103) selcollist ::= sclp scanpt STAR */
175149 -5, /* (104) selcollist ::= sclp scanpt nm DOT STAR */
175150 -2, /* (105) as ::= AS nm */
175151 0, /* (106) as ::= */
175152 0, /* (107) from ::= */
175153 -2, /* (108) from ::= FROM seltablist */
175154 -2, /* (109) stl_prefix ::= seltablist joinop */
175155 0, /* (110) stl_prefix ::= */
175156 -5, /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
175157 -6, /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175158 -8, /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175159 -6, /* (114) seltablist ::= stl_prefix LP select RP as on_using */
175160 -6, /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
175161 0, /* (116) dbnm ::= */
175162 -2, /* (117) dbnm ::= DOT nm */
175163 -1, /* (118) fullname ::= nm */
175164 -3, /* (119) fullname ::= nm DOT nm */
175165 -1, /* (120) xfullname ::= nm */
175166 -3, /* (121) xfullname ::= nm DOT nm */
175167 -5, /* (122) xfullname ::= nm DOT nm AS nm */
175168 -3, /* (123) xfullname ::= nm AS nm */
175169 -1, /* (124) joinop ::= COMMA|JOIN */
175170 -2, /* (125) joinop ::= JOIN_KW JOIN */
175171 -3, /* (126) joinop ::= JOIN_KW nm JOIN */
175172 -4, /* (127) joinop ::= JOIN_KW nm nm JOIN */
175173 -2, /* (128) on_using ::= ON expr */
175174 -4, /* (129) on_using ::= USING LP idlist RP */
175175 0, /* (130) on_using ::= */
175176 0, /* (131) indexed_opt ::= */
175177 -3, /* (132) indexed_by ::= INDEXED BY nm */
175178 -2, /* (133) indexed_by ::= NOT INDEXED */
175179 0, /* (134) orderby_opt ::= */
175180 -3, /* (135) orderby_opt ::= ORDER BY sortlist */
175181 -5, /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
175182 -3, /* (137) sortlist ::= expr sortorder nulls */
175183 -1, /* (138) sortorder ::= ASC */
175184 -1, /* (139) sortorder ::= DESC */
175185 0, /* (140) sortorder ::= */
175186 -2, /* (141) nulls ::= NULLS FIRST */
175187 -2, /* (142) nulls ::= NULLS LAST */
175188 0, /* (143) nulls ::= */
175189 0, /* (144) groupby_opt ::= */
175190 -3, /* (145) groupby_opt ::= GROUP BY nexprlist */
175191 0, /* (146) having_opt ::= */
175192 -2, /* (147) having_opt ::= HAVING expr */
175193 0, /* (148) limit_opt ::= */
175194 -2, /* (149) limit_opt ::= LIMIT expr */
175195 -4, /* (150) limit_opt ::= LIMIT expr OFFSET expr */
175196 -4, /* (151) limit_opt ::= LIMIT expr COMMA expr */
175197 -6, /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
175198 0, /* (153) where_opt ::= */
175199 -2, /* (154) where_opt ::= WHERE expr */
175200 0, /* (155) where_opt_ret ::= */
175201 -2, /* (156) where_opt_ret ::= WHERE expr */
175202 -2, /* (157) where_opt_ret ::= RETURNING selcollist */
175203 -4, /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
175204 -9, /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
175205 -5, /* (160) setlist ::= setlist COMMA nm EQ expr */
175206 -7, /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
175207 -3, /* (162) setlist ::= nm EQ expr */
175208 -5, /* (163) setlist ::= LP idlist RP EQ expr */
175209 -7, /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
175210 -8, /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
175211 0, /* (166) upsert ::= */
175212 -2, /* (167) upsert ::= RETURNING selcollist */
175213 -12, /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
175214 -9, /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
175215 -5, /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
175216 -8, /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
175217 -2, /* (172) returning ::= RETURNING selcollist */
175218 -2, /* (173) insert_cmd ::= INSERT orconf */
175219 -1, /* (174) insert_cmd ::= REPLACE */
175220 0, /* (175) idlist_opt ::= */
175221 -3, /* (176) idlist_opt ::= LP idlist RP */
175222 -3, /* (177) idlist ::= idlist COMMA nm */
175223 -1, /* (178) idlist ::= nm */
175224 -3, /* (179) expr ::= LP expr RP */
175225 -1, /* (180) expr ::= ID|INDEXED|JOIN_KW */
175226 -3, /* (181) expr ::= nm DOT nm */
175227 -5, /* (182) expr ::= nm DOT nm DOT nm */
175228 -1, /* (183) term ::= NULL|FLOAT|BLOB */
175229 -1, /* (184) term ::= STRING */
175230 -1, /* (185) term ::= INTEGER */
175231 -1, /* (186) expr ::= VARIABLE */
175232 -3, /* (187) expr ::= expr COLLATE ID|STRING */
175233 -6, /* (188) expr ::= CAST LP expr AS typetoken RP */
175234 -5, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
175235 -8, /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
175236 -4, /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
175237 -6, /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
175238 -9, /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
175239 -5, /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
175240 -1, /* (195) term ::= CTIME_KW */
175241 -5, /* (196) expr ::= LP nexprlist COMMA expr RP */
175242 -3, /* (197) expr ::= expr AND expr */
175243 -3, /* (198) expr ::= expr OR expr */
175244 -3, /* (199) expr ::= expr LT|GT|GE|LE expr */
175245 -3, /* (200) expr ::= expr EQ|NE expr */
175246 -3, /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
175247 -3, /* (202) expr ::= expr PLUS|MINUS expr */
175248 -3, /* (203) expr ::= expr STAR|SLASH|REM expr */
175249 -3, /* (204) expr ::= expr CONCAT expr */
175250 -2, /* (205) likeop ::= NOT LIKE_KW|MATCH */
175251 -3, /* (206) expr ::= expr likeop expr */
175252 -5, /* (207) expr ::= expr likeop expr ESCAPE expr */
175253 -2, /* (208) expr ::= expr ISNULL|NOTNULL */
175254 -3, /* (209) expr ::= expr NOT NULL */
175255 -3, /* (210) expr ::= expr IS expr */
175256 -4, /* (211) expr ::= expr IS NOT expr */
175257 -6, /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
175258 -5, /* (213) expr ::= expr IS DISTINCT FROM expr */
175259 -2, /* (214) expr ::= NOT expr */
175260 -2, /* (215) expr ::= BITNOT expr */
175261 -2, /* (216) expr ::= PLUS|MINUS expr */
175262 -3, /* (217) expr ::= expr PTR expr */
175263 -1, /* (218) between_op ::= BETWEEN */
175264 -2, /* (219) between_op ::= NOT BETWEEN */
175265 -5, /* (220) expr ::= expr between_op expr AND expr */
175266 -1, /* (221) in_op ::= IN */
175267 -2, /* (222) in_op ::= NOT IN */
175268 -5, /* (223) expr ::= expr in_op LP exprlist RP */
175269 -3, /* (224) expr ::= LP select RP */
175270 -5, /* (225) expr ::= expr in_op LP select RP */
175271 -5, /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
175272 -4, /* (227) expr ::= EXISTS LP select RP */
175273 -5, /* (228) expr ::= CASE case_operand case_exprlist case_else END */
175274 -5, /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
175275 -4, /* (230) case_exprlist ::= WHEN expr THEN expr */
175276 -2, /* (231) case_else ::= ELSE expr */
175277 0, /* (232) case_else ::= */
175278 0, /* (233) case_operand ::= */
175279 0, /* (234) exprlist ::= */
175280 -3, /* (235) nexprlist ::= nexprlist COMMA expr */
175281 -1, /* (236) nexprlist ::= expr */
175282 0, /* (237) paren_exprlist ::= */
175283 -3, /* (238) paren_exprlist ::= LP exprlist RP */
175284 -12, /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
175285 -1, /* (240) uniqueflag ::= UNIQUE */
175286 0, /* (241) uniqueflag ::= */
175287 0, /* (242) eidlist_opt ::= */
175288 -3, /* (243) eidlist_opt ::= LP eidlist RP */
175289 -5, /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
175290 -3, /* (245) eidlist ::= nm collate sortorder */
175291 0, /* (246) collate ::= */
175292 -2, /* (247) collate ::= COLLATE ID|STRING */
175293 -4, /* (248) cmd ::= DROP INDEX ifexists fullname */
175294 -2, /* (249) cmd ::= VACUUM vinto */
175295 -3, /* (250) cmd ::= VACUUM nm vinto */
175296 -2, /* (251) vinto ::= INTO expr */
175297 0, /* (252) vinto ::= */
175298 -3, /* (253) cmd ::= PRAGMA nm dbnm */
175299 -5, /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
175300 -6, /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
175301 -5, /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
175302 -6, /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
175303 -2, /* (258) plus_num ::= PLUS INTEGER|FLOAT */
175304 -2, /* (259) minus_num ::= MINUS INTEGER|FLOAT */
175305 -5, /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
175306 -11, /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
175307 -1, /* (262) trigger_time ::= BEFORE|AFTER */
175308 -2, /* (263) trigger_time ::= INSTEAD OF */
175309 0, /* (264) trigger_time ::= */
175310 -1, /* (265) trigger_event ::= DELETE|INSERT */
175311 -1, /* (266) trigger_event ::= UPDATE */
175312 -3, /* (267) trigger_event ::= UPDATE OF idlist */
175313 0, /* (268) when_clause ::= */
175314 -2, /* (269) when_clause ::= WHEN expr */
175315 -3, /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
175316 -2, /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
175317 -3, /* (272) trnm ::= nm DOT nm */
175318 -3, /* (273) tridxby ::= INDEXED BY nm */
175319 -2, /* (274) tridxby ::= NOT INDEXED */
175320 -9, /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
175321 -8, /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
175322 -6, /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
175323 -3, /* (278) trigger_cmd ::= scanpt select scanpt */
175324 -4, /* (279) expr ::= RAISE LP IGNORE RP */
175325 -6, /* (280) expr ::= RAISE LP raisetype COMMA nm RP */
175326 -1, /* (281) raisetype ::= ROLLBACK */
175327 -1, /* (282) raisetype ::= ABORT */
175328 -1, /* (283) raisetype ::= FAIL */
175329 -4, /* (284) cmd ::= DROP TRIGGER ifexists fullname */
175330 -6, /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
175331 -3, /* (286) cmd ::= DETACH database_kw_opt expr */
175332 0, /* (287) key_opt ::= */
175333 -2, /* (288) key_opt ::= KEY expr */
175334 -1, /* (289) cmd ::= REINDEX */
175335 -3, /* (290) cmd ::= REINDEX nm dbnm */
175336 -1, /* (291) cmd ::= ANALYZE */
175337 -3, /* (292) cmd ::= ANALYZE nm dbnm */
175338 -6, /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
175339 -7, /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
175340 -6, /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
175341 -1, /* (296) add_column_fullname ::= fullname */
175342 -8, /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
175343 -1, /* (298) cmd ::= create_vtab */
175344 -4, /* (299) cmd ::= create_vtab LP vtabarglist RP */
175345 -8, /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
175346 0, /* (301) vtabarg ::= */
175347 -1, /* (302) vtabargtoken ::= ANY */
175348 -3, /* (303) vtabargtoken ::= lp anylist RP */
175349 -1, /* (304) lp ::= LP */
175350 -2, /* (305) with ::= WITH wqlist */
175351 -3, /* (306) with ::= WITH RECURSIVE wqlist */
175352 -1, /* (307) wqas ::= AS */
175353 -2, /* (308) wqas ::= AS MATERIALIZED */
175354 -3, /* (309) wqas ::= AS NOT MATERIALIZED */
175355 -6, /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
175356 -1, /* (311) withnm ::= nm */
175357 -1, /* (312) wqlist ::= wqitem */
175358 -3, /* (313) wqlist ::= wqlist COMMA wqitem */
175359 -3, /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
175360 -5, /* (315) windowdefn ::= nm AS LP window RP */
175361 -5, /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
175362 -6, /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
175363 -4, /* (318) window ::= ORDER BY sortlist frame_opt */
175364 -5, /* (319) window ::= nm ORDER BY sortlist frame_opt */
175365 -2, /* (320) window ::= nm frame_opt */
175366 0, /* (321) frame_opt ::= */
175367 -3, /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
175368 -6, /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
175369 -1, /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
175370 -1, /* (325) frame_bound_s ::= frame_bound */
175371 -2, /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
175372 -1, /* (327) frame_bound_e ::= frame_bound */
175373 -2, /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
175374 -2, /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
175375 -2, /* (330) frame_bound ::= CURRENT ROW */
175376 0, /* (331) frame_exclude_opt ::= */
175377 -2, /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
175378 -2, /* (333) frame_exclude ::= NO OTHERS */
175379 -2, /* (334) frame_exclude ::= CURRENT ROW */
175380 -1, /* (335) frame_exclude ::= GROUP|TIES */
175381 -2, /* (336) window_clause ::= WINDOW windowdefn_list */
175382 -2, /* (337) filter_over ::= filter_clause over_clause */
175383 -1, /* (338) filter_over ::= over_clause */
175384 -1, /* (339) filter_over ::= filter_clause */
175385 -4, /* (340) over_clause ::= OVER LP window RP */
175386 -2, /* (341) over_clause ::= OVER nm */
175387 -5, /* (342) filter_clause ::= FILTER LP WHERE expr RP */
175388 -1, /* (343) term ::= QNUMBER */
175389 -1, /* (344) input ::= cmdlist */
175390 -2, /* (345) cmdlist ::= cmdlist ecmd */
175391 -1, /* (346) cmdlist ::= ecmd */
175392 -1, /* (347) ecmd ::= SEMI */
175393 -2, /* (348) ecmd ::= cmdx SEMI */
175394 -3, /* (349) ecmd ::= explain cmdx SEMI */
175395 0, /* (350) trans_opt ::= */
175396 -1, /* (351) trans_opt ::= TRANSACTION */
175397 -2, /* (352) trans_opt ::= TRANSACTION nm */
175398 -1, /* (353) savepoint_opt ::= SAVEPOINT */
175399 0, /* (354) savepoint_opt ::= */
175400 -2, /* (355) cmd ::= create_table create_table_args */
175401 -1, /* (356) table_option_set ::= table_option */
175402 -4, /* (357) columnlist ::= columnlist COMMA columnname carglist */
175403 -2, /* (358) columnlist ::= columnname carglist */
175404 -1, /* (359) nm ::= ID|INDEXED|JOIN_KW */
175405 -1, /* (360) nm ::= STRING */
175406 -1, /* (361) typetoken ::= typename */
175407 -1, /* (362) typename ::= ID|STRING */
175408 -1, /* (363) signed ::= plus_num */
175409 -1, /* (364) signed ::= minus_num */
175410 -2, /* (365) carglist ::= carglist ccons */
175411 0, /* (366) carglist ::= */
175412 -2, /* (367) ccons ::= NULL onconf */
175413 -4, /* (368) ccons ::= GENERATED ALWAYS AS generated */
175414 -2, /* (369) ccons ::= AS generated */
175415 -2, /* (370) conslist_opt ::= COMMA conslist */
175416 -3, /* (371) conslist ::= conslist tconscomma tcons */
175417 -1, /* (372) conslist ::= tcons */
175418 0, /* (373) tconscomma ::= */
175419 -1, /* (374) defer_subclause_opt ::= defer_subclause */
175420 -1, /* (375) resolvetype ::= raisetype */
175421 -1, /* (376) selectnowith ::= oneselect */
175422 -1, /* (377) oneselect ::= values */
175423 -2, /* (378) sclp ::= selcollist COMMA */
175424 -1, /* (379) as ::= ID|STRING */
175425 -1, /* (380) indexed_opt ::= indexed_by */
175426 0, /* (381) returning ::= */
175427 -1, /* (382) expr ::= term */
175428 -1, /* (383) likeop ::= LIKE_KW|MATCH */
175429 -1, /* (384) case_operand ::= expr */
175430 -1, /* (385) exprlist ::= nexprlist */
175431 -1, /* (386) nmnum ::= plus_num */
175432 -1, /* (387) nmnum ::= nm */
175433 -1, /* (388) nmnum ::= ON */
175434 -1, /* (389) nmnum ::= DELETE */
175435 -1, /* (390) nmnum ::= DEFAULT */
175436 -1, /* (391) plus_num ::= INTEGER|FLOAT */
175437 0, /* (392) foreach_clause ::= */
175438 -3, /* (393) foreach_clause ::= FOR EACH ROW */
175439 -1, /* (394) trnm ::= nm */
175440 0, /* (395) tridxby ::= */
175441 -1, /* (396) database_kw_opt ::= DATABASE */
175442 0, /* (397) database_kw_opt ::= */
175443 0, /* (398) kwcolumn_opt ::= */
175444 -1, /* (399) kwcolumn_opt ::= COLUMNKW */
175445 -1, /* (400) vtabarglist ::= vtabarg */
175446 -3, /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
175447 -2, /* (402) vtabarg ::= vtabarg vtabargtoken */
175448 0, /* (403) anylist ::= */
175449 -4, /* (404) anylist ::= anylist LP anylist RP */
175450 -2, /* (405) anylist ::= anylist ANY */
175451 0, /* (406) with ::= */
175452 -1, /* (407) windowdefn_list ::= windowdefn */
175453 -1, /* (408) window ::= frame_opt */
175454 };
175455
175456 static void yy_accept(yyParser*); /* Forward Declaration */
175457
175458 /*
@@ -175201,20 +175500,20 @@
175500 break;
175501 case 2: /* cmdx ::= cmd */
175502 { sqlite3FinishCoding(pParse); }
175503 break;
175504 case 3: /* cmd ::= BEGIN transtype trans_opt */
175505 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
175506 break;
175507 case 4: /* transtype ::= */
175508 {yymsp[1].minor.yy144 = TK_DEFERRED;}
175509 break;
175510 case 5: /* transtype ::= DEFERRED */
175511 case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
175512 case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
175513 case 324: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==324);
175514 {yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/}
175515 break;
175516 case 8: /* cmd ::= COMMIT|END trans_opt */
175517 case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
175518 {sqlite3EndTransaction(pParse,yymsp[-1].major);}
175519 break;
@@ -175233,11 +175532,11 @@
175532 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
175533 }
175534 break;
175535 case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
175536 {
175537 sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144);
175538 }
175539 break;
175540 case 14: /* createkw ::= CREATE */
175541 {disableLookaside(pParse);}
175542 break;
@@ -175245,65 +175544,65 @@
175544 case 18: /* temp ::= */ yytestcase(yyruleno==18);
175545 case 47: /* autoinc ::= */ yytestcase(yyruleno==47);
175546 case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
175547 case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
175548 case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
175549 case 100: /* distinct ::= */ yytestcase(yyruleno==100);
175550 case 246: /* collate ::= */ yytestcase(yyruleno==246);
175551 {yymsp[1].minor.yy144 = 0;}
175552 break;
175553 case 16: /* ifnotexists ::= IF NOT EXISTS */
175554 {yymsp[-2].minor.yy144 = 1;}
175555 break;
175556 case 17: /* temp ::= TEMP */
175557 {yymsp[0].minor.yy144 = pParse->db->init.busy==0;}
175558 break;
175559 case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
175560 {
175561 sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0);
175562 }
175563 break;
175564 case 20: /* create_table_args ::= AS select */
175565 {
175566 sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
175567 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
175568 }
175569 break;
175570 case 21: /* table_option_set ::= */
175571 {yymsp[1].minor.yy391 = 0;}
175572 break;
175573 case 22: /* table_option_set ::= table_option_set COMMA table_option */
175574 {yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;}
175575 yymsp[-2].minor.yy391 = yylhsminor.yy391;
175576 break;
175577 case 23: /* table_option ::= WITHOUT nm */
175578 {
175579 if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
175580 yymsp[-1].minor.yy391 = TF_WithoutRowid | TF_NoVisibleRowid;
175581 }else{
175582 yymsp[-1].minor.yy391 = 0;
175583 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175584 }
175585 }
175586 break;
175587 case 24: /* table_option ::= nm */
175588 {
175589 if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
175590 yylhsminor.yy391 = TF_Strict;
175591 }else{
175592 yylhsminor.yy391 = 0;
175593 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
175594 }
175595 }
175596 yymsp[0].minor.yy391 = yylhsminor.yy391;
175597 break;
175598 case 25: /* columnname ::= nm typetoken */
175599 {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
175600 break;
175601 case 26: /* typetoken ::= */
175602 case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
175603 case 106: /* as ::= */ yytestcase(yyruleno==106);
175604 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
175605 break;
175606 case 27: /* typetoken ::= typename LP signed RP */
175607 {
175608 yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
@@ -175318,11 +175617,11 @@
175617 {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
175618 break;
175619 case 30: /* scanpt ::= */
175620 {
175621 assert( yyLookahead!=YYNOCODE );
175622 yymsp[1].minor.yy168 = yyLookaheadToken.z;
175623 }
175624 break;
175625 case 31: /* scantok ::= */
175626 {
175627 assert( yyLookahead!=YYNOCODE );
@@ -175332,21 +175631,21 @@
175631 case 32: /* ccons ::= CONSTRAINT nm */
175632 case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
175633 {pParse->constraintName = yymsp[0].minor.yy0;}
175634 break;
175635 case 33: /* ccons ::= DEFAULT scantok term */
175636 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175637 break;
175638 case 34: /* ccons ::= DEFAULT LP expr RP */
175639 {sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
175640 break;
175641 case 35: /* ccons ::= DEFAULT PLUS scantok term */
175642 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
175643 break;
175644 case 36: /* ccons ::= DEFAULT MINUS scantok term */
175645 {
175646 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0);
175647 sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
175648 }
175649 break;
175650 case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
175651 {
@@ -175357,315 +175656,312 @@
175656 }
175657 sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
175658 }
175659 break;
175660 case 38: /* ccons ::= NOT NULL onconf */
175661 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);}
175662 break;
175663 case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
175664 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
175665 break;
175666 case 40: /* ccons ::= UNIQUE onconf */
175667 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
175668 SQLITE_IDXTYPE_UNIQUE);}
175669 break;
175670 case 41: /* ccons ::= CHECK LP expr RP */
175671 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
175672 break;
175673 case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
175674 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);}
175675 break;
175676 case 43: /* ccons ::= defer_subclause */
175677 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
175678 break;
175679 case 44: /* ccons ::= COLLATE ID|STRING */
175680 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
175681 break;
175682 case 45: /* generated ::= LP expr RP */
175683 {sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);}
175684 break;
175685 case 46: /* generated ::= LP expr RP ID */
175686 {sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
175687 break;
175688 case 48: /* autoinc ::= AUTOINCR */
175689 {yymsp[0].minor.yy144 = 1;}
175690 break;
175691 case 49: /* refargs ::= */
175692 { yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */}
175693 break;
175694 case 50: /* refargs ::= refargs refarg */
175695 { yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; }
175696 break;
175697 case 51: /* refarg ::= MATCH nm */
175698 { yymsp[-1].minor.yy383.value = 0; yymsp[-1].minor.yy383.mask = 0x000000; }
175699 break;
175700 case 52: /* refarg ::= ON INSERT refact */
175701 { yymsp[-2].minor.yy383.value = 0; yymsp[-2].minor.yy383.mask = 0x000000; }
175702 break;
175703 case 53: /* refarg ::= ON DELETE refact */
175704 { yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144; yymsp[-2].minor.yy383.mask = 0x0000ff; }
175705 break;
175706 case 54: /* refarg ::= ON UPDATE refact */
175707 { yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8; yymsp[-2].minor.yy383.mask = 0x00ff00; }
175708 break;
175709 case 55: /* refact ::= SET NULL */
175710 { yymsp[-1].minor.yy144 = OE_SetNull; /* EV: R-33326-45252 */}
175711 break;
175712 case 56: /* refact ::= SET DEFAULT */
175713 { yymsp[-1].minor.yy144 = OE_SetDflt; /* EV: R-33326-45252 */}
175714 break;
175715 case 57: /* refact ::= CASCADE */
175716 { yymsp[0].minor.yy144 = OE_Cascade; /* EV: R-33326-45252 */}
175717 break;
175718 case 58: /* refact ::= RESTRICT */
175719 { yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */}
175720 break;
175721 case 59: /* refact ::= NO ACTION */
175722 { yymsp[-1].minor.yy144 = OE_None; /* EV: R-33326-45252 */}
175723 break;
175724 case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
175725 {yymsp[-2].minor.yy144 = 0;}
175726 break;
175727 case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
175728 case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
175729 case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173);
175730 {yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;}
175731 break;
175732 case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
175733 case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
175734 case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
175735 case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
175736 case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
175737 {yymsp[-1].minor.yy144 = 1;}
175738 break;
175739 case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
175740 {yymsp[-1].minor.yy144 = 0;}
175741 break;
175742 case 66: /* tconscomma ::= COMMA */
175743 {pParse->constraintName.n = 0;}
175744 break;
175745 case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
175746 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
175747 break;
175748 case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
175749 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
175750 SQLITE_IDXTYPE_UNIQUE);}
175751 break;
175752 case 70: /* tcons ::= CHECK LP expr RP onconf */
175753 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
175754 break;
175755 case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
175756 {
175757 sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
175758 sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
175759 }
175760 break;
175761 case 73: /* onconf ::= */
175762 case 75: /* orconf ::= */ yytestcase(yyruleno==75);
175763 {yymsp[1].minor.yy144 = OE_Default;}
175764 break;
175765 case 74: /* onconf ::= ON CONFLICT resolvetype */
175766 {yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;}
175767 break;
175768 case 77: /* resolvetype ::= IGNORE */
175769 {yymsp[0].minor.yy144 = OE_Ignore;}
175770 break;
175771 case 78: /* resolvetype ::= REPLACE */
175772 case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174);
175773 {yymsp[0].minor.yy144 = OE_Replace;}
175774 break;
175775 case 79: /* cmd ::= DROP TABLE ifexists fullname */
175776 {
175777 sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
175778 }
175779 break;
175780 case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
175781 {
175782 sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
175783 }
175784 break;
175785 case 83: /* cmd ::= DROP VIEW ifexists fullname */
175786 {
175787 sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
175788 }
175789 break;
175790 case 84: /* cmd ::= select */
175791 {
175792 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
175793 sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
175794 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
175795 }
175796 break;
175797 case 85: /* select ::= WITH wqlist selectnowith */
175798 {yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
175799 break;
175800 case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
175801 {yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
175802 break;
175803 case 87: /* select ::= selectnowith */
175804 {
175805 Select *p = yymsp[0].minor.yy555;
175806 if( p ){
175807 parserDoubleLinkSelect(pParse, p);
175808 }
175809 }
175810 break;
175811 case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
175812 {
175813 Select *pRhs = yymsp[0].minor.yy555;
175814 Select *pLhs = yymsp[-2].minor.yy555;
175815 if( pRhs && pRhs->pPrior ){
175816 SrcList *pFrom;
175817 Token x;
175818 x.n = 0;
175819 parserDoubleLinkSelect(pParse, pRhs);
175820 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
175821 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
175822 }
175823 if( pRhs ){
175824 pRhs->op = (u8)yymsp[-1].minor.yy144;
175825 pRhs->pPrior = pLhs;
175826 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
175827 pRhs->selFlags &= ~SF_MultiValue;
175828 if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
175829 }else{
175830 sqlite3SelectDelete(pParse->db, pLhs);
175831 }
175832 yymsp[-2].minor.yy555 = pRhs;
175833 }
175834 break;
175835 case 89: /* multiselect_op ::= UNION */
175836 case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
175837 {yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/}
175838 break;
175839 case 90: /* multiselect_op ::= UNION ALL */
175840 {yymsp[-1].minor.yy144 = TK_ALL;}
175841 break;
175842 case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
175843 {
175844 yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
175845 }
175846 break;
175847 case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
175848 {
175849 yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
175850 if( yymsp[-9].minor.yy555 ){
175851 yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211;
175852 }else{
175853 sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
175854 }
175855 }
175856 break;
175857 case 94: /* values ::= VALUES LP nexprlist RP */
175858 {
175859 yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
175860 }
175861 break;
175862 case 95: /* oneselect ::= mvalues */
175863 {
175864 sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
175865 }
175866 break;
175867 case 96: /* mvalues ::= values COMMA LP nexprlist RP */
175868 case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97);
175869 {
175870 yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
175871 }
175872 break;
175873 case 98: /* distinct ::= DISTINCT */
175874 {yymsp[0].minor.yy144 = SF_Distinct;}
175875 break;
175876 case 99: /* distinct ::= ALL */
175877 {yymsp[0].minor.yy144 = SF_All;}
175878 break;
175879 case 101: /* sclp ::= */
175880 case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134);
175881 case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144);
175882 case 234: /* exprlist ::= */ yytestcase(yyruleno==234);
175883 case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237);
175884 case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242);
175885 {yymsp[1].minor.yy14 = 0;}
175886 break;
175887 case 102: /* selcollist ::= sclp scanpt expr scanpt as */
175888 {
175889 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
175890 if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
175891 sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
175892 }
175893 break;
175894 case 103: /* selcollist ::= sclp scanpt STAR */
 
 
 
175895 {
175896 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
175897 sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175898 yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
175899 }
175900 break;
175901 case 104: /* selcollist ::= sclp scanpt nm DOT STAR */
175902 {
175903 Expr *pRight, *pLeft, *pDot;
175904 pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
175905 sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
175906 pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
175907 pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
175908 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
175909 }
175910 break;
175911 case 105: /* as ::= AS nm */
175912 case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117);
175913 case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258);
175914 case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259);
175915 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
175916 break;
175917 case 107: /* from ::= */
175918 case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110);
175919 {yymsp[1].minor.yy203 = 0;}
175920 break;
175921 case 108: /* from ::= FROM seltablist */
175922 {
175923 yymsp[-1].minor.yy203 = yymsp[0].minor.yy203;
175924 sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
175925 }
175926 break;
175927 case 109: /* stl_prefix ::= seltablist joinop */
175928 {
175929 if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144;
175930 }
175931 break;
175932 case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */
175933 {
175934 yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175935 }
175936 break;
175937 case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
175938 {
175939 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
175940 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
175941 }
175942 break;
175943 case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
175944 {
175945 yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175946 sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
175947 }
175948 break;
175949 case 114: /* seltablist ::= stl_prefix LP select RP as on_using */
175950 {
175951 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
175952 }
175953 break;
175954 case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
175955 {
175956 if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){
175957 yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203;
175958 }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){
175959 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
175960 if( yymsp[-5].minor.yy203 ){
175961 SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
175962 SrcItem *pOld = yymsp[-3].minor.yy203->a;
175963 pNew->zName = pOld->zName;
175964 pNew->zDatabase = pOld->zDatabase;
175965 pNew->pSelect = pOld->pSelect;
175966 if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
175967 pNew->fg.isNestedFrom = 1;
@@ -175677,1061 +175973,1064 @@
175973 pNew->fg.isTabFunc = 1;
175974 }
175975 pOld->zName = pOld->zDatabase = 0;
175976 pOld->pSelect = 0;
175977 }
175978 sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
175979 }else{
175980 Select *pSubquery;
175981 sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
175982 pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
175983 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
175984 }
175985 }
175986 break;
175987 case 116: /* dbnm ::= */
175988 case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131);
175989 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
175990 break;
175991 case 118: /* fullname ::= nm */
175992 {
175993 yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
175994 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
175995 }
175996 yymsp[0].minor.yy203 = yylhsminor.yy203;
175997 break;
175998 case 119: /* fullname ::= nm DOT nm */
175999 {
176000 yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
176001 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
176002 }
176003 yymsp[-2].minor.yy203 = yylhsminor.yy203;
176004 break;
176005 case 120: /* xfullname ::= nm */
176006 {yymsp[0].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
176007 break;
176008 case 121: /* xfullname ::= nm DOT nm */
176009 {yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
176010 break;
176011 case 122: /* xfullname ::= nm DOT nm AS nm */
176012 {
176013 yymsp[-4].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
176014 if( yymsp[-4].minor.yy203 ) yymsp[-4].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176015 }
176016 break;
176017 case 123: /* xfullname ::= nm AS nm */
176018 {
176019 yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
176020 if( yymsp[-2].minor.yy203 ) yymsp[-2].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176021 }
176022 break;
176023 case 124: /* joinop ::= COMMA|JOIN */
176024 { yymsp[0].minor.yy144 = JT_INNER; }
176025 break;
176026 case 125: /* joinop ::= JOIN_KW JOIN */
176027 {yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
176028 break;
176029 case 126: /* joinop ::= JOIN_KW nm JOIN */
176030 {yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
176031 break;
176032 case 127: /* joinop ::= JOIN_KW nm nm JOIN */
176033 {yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
176034 break;
176035 case 128: /* on_using ::= ON expr */
176036 {yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;}
176037 break;
176038 case 129: /* on_using ::= USING LP idlist RP */
176039 {yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;}
176040 break;
176041 case 130: /* on_using ::= */
176042 {yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;}
176043 break;
176044 case 132: /* indexed_by ::= INDEXED BY nm */
176045 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
176046 break;
176047 case 133: /* indexed_by ::= NOT INDEXED */
176048 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
176049 break;
176050 case 135: /* orderby_opt ::= ORDER BY sortlist */
176051 case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145);
176052 {yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;}
176053 break;
176054 case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */
176055 {
176056 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
176057 sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
176058 }
176059 break;
176060 case 137: /* sortlist ::= expr sortorder nulls */
176061 {
176062 yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
176063 sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
176064 }
176065 break;
176066 case 138: /* sortorder ::= ASC */
176067 {yymsp[0].minor.yy144 = SQLITE_SO_ASC;}
176068 break;
176069 case 139: /* sortorder ::= DESC */
176070 {yymsp[0].minor.yy144 = SQLITE_SO_DESC;}
176071 break;
176072 case 140: /* sortorder ::= */
176073 case 143: /* nulls ::= */ yytestcase(yyruleno==143);
176074 {yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;}
176075 break;
176076 case 141: /* nulls ::= NULLS FIRST */
176077 {yymsp[-1].minor.yy144 = SQLITE_SO_ASC;}
176078 break;
176079 case 142: /* nulls ::= NULLS LAST */
176080 {yymsp[-1].minor.yy144 = SQLITE_SO_DESC;}
176081 break;
176082 case 146: /* having_opt ::= */
176083 case 148: /* limit_opt ::= */ yytestcase(yyruleno==148);
176084 case 153: /* where_opt ::= */ yytestcase(yyruleno==153);
176085 case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155);
176086 case 232: /* case_else ::= */ yytestcase(yyruleno==232);
176087 case 233: /* case_operand ::= */ yytestcase(yyruleno==233);
176088 case 252: /* vinto ::= */ yytestcase(yyruleno==252);
176089 {yymsp[1].minor.yy454 = 0;}
176090 break;
176091 case 147: /* having_opt ::= HAVING expr */
176092 case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154);
176093 case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156);
176094 case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
176095 case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251);
176096 {yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;}
176097 break;
176098 case 149: /* limit_opt ::= LIMIT expr */
176099 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
176100 break;
176101 case 150: /* limit_opt ::= LIMIT expr OFFSET expr */
176102 {yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176103 break;
176104 case 151: /* limit_opt ::= LIMIT expr COMMA expr */
176105 {yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
176106 break;
176107 case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
176108 {
176109 sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
176110 sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
176111 }
176112 break;
176113 case 157: /* where_opt_ret ::= RETURNING selcollist */
176114 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
176115 break;
176116 case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
176117 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
176118 break;
176119 case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
176120 {
176121 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
176122 sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list");
176123 if( yymsp[-1].minor.yy203 ){
176124 SrcList *pFromClause = yymsp[-1].minor.yy203;
176125 if( pFromClause->nSrc>1 ){
176126 Select *pSubquery;
176127 Token as;
176128 pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0);
176129 as.n = 0;
176130 as.z = 0;
176131 pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
176132 }
176133 yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
176134 }
176135 sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
176136 }
176137 break;
176138 case 160: /* setlist ::= setlist COMMA nm EQ expr */
176139 {
176140 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
176141 sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
176142 }
176143 break;
176144 case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
176145 {
176146 yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176147 }
176148 break;
176149 case 162: /* setlist ::= nm EQ expr */
176150 {
176151 yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
176152 sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
176153 }
176154 yymsp[-2].minor.yy14 = yylhsminor.yy14;
176155 break;
176156 case 163: /* setlist ::= LP idlist RP EQ expr */
176157 {
176158 yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176159 }
176160 break;
176161 case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
176162 {
176163 sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
176164 }
176165 break;
176166 case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
176167 {
176168 sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
176169 }
176170 break;
176171 case 166: /* upsert ::= */
176172 { yymsp[1].minor.yy122 = 0; }
176173 break;
176174 case 167: /* upsert ::= RETURNING selcollist */
176175 { yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
176176 break;
176177 case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
176178 { yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
176179 break;
176180 case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
176181 { yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
176182 break;
176183 case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */
176184 { yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
176185 break;
176186 case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
176187 { yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
176188 break;
176189 case 172: /* returning ::= RETURNING selcollist */
176190 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
176191 break;
176192 case 175: /* idlist_opt ::= */
176193 {yymsp[1].minor.yy132 = 0;}
176194 break;
176195 case 176: /* idlist_opt ::= LP idlist RP */
176196 {yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;}
176197 break;
176198 case 177: /* idlist ::= idlist COMMA nm */
176199 {yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
176200 break;
176201 case 178: /* idlist ::= nm */
176202 {yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
176203 break;
176204 case 179: /* expr ::= LP expr RP */
176205 {yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;}
176206 break;
176207 case 180: /* expr ::= ID|INDEXED|JOIN_KW */
176208 {yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176209 break;
176210 case 181: /* expr ::= nm DOT nm */
176211 {
176212 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
176213 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
176214 yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
176215 }
176216 yymsp[-2].minor.yy454 = yylhsminor.yy454;
176217 break;
176218 case 182: /* expr ::= nm DOT nm DOT nm */
176219 {
176220 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
176221 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
176222 Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
176223 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
176224 if( IN_RENAME_OBJECT ){
176225 sqlite3RenameTokenRemap(pParse, 0, temp1);
176226 }
176227 yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
176228 }
176229 yymsp[-4].minor.yy454 = yylhsminor.yy454;
176230 break;
176231 case 183: /* term ::= NULL|FLOAT|BLOB */
176232 case 184: /* term ::= STRING */ yytestcase(yyruleno==184);
176233 {yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176234 break;
176235 case 185: /* term ::= INTEGER */
176236 {
176237 yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
176238 if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
176239 }
176240 yymsp[0].minor.yy454 = yylhsminor.yy454;
176241 break;
176242 case 186: /* expr ::= VARIABLE */
176243 {
176244 if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
176245 u32 n = yymsp[0].minor.yy0.n;
176246 yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
176247 sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n);
176248 }else{
176249 /* When doing a nested parse, one can include terms in an expression
176250 ** that look like this: #1 #2 ... These terms refer to registers
176251 ** in the virtual machine. #N is the N-th register. */
176252 Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
176253 assert( t.n>=2 );
176254 if( pParse->nested==0 ){
176255 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
176256 yymsp[0].minor.yy454 = 0;
176257 }else{
176258 yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
176259 if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable);
176260 }
176261 }
176262 }
176263 break;
176264 case 187: /* expr ::= expr COLLATE ID|STRING */
176265 {
176266 yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
176267 }
176268 break;
176269 case 188: /* expr ::= CAST LP expr AS typetoken RP */
176270 {
176271 yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
176272 sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
176273 }
176274 break;
176275 case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
176276 {
176277 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
176278 }
176279 yymsp[-4].minor.yy454 = yylhsminor.yy454;
176280 break;
176281 case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
176282 {
176283 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
176284 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
176285 }
176286 yymsp[-7].minor.yy454 = yylhsminor.yy454;
176287 break;
176288 case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
176289 {
176290 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
176291 }
176292 yymsp[-3].minor.yy454 = yylhsminor.yy454;
176293 break;
176294 case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
176295 {
176296 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
176297 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176298 }
176299 yymsp[-5].minor.yy454 = yylhsminor.yy454;
176300 break;
176301 case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
176302 {
176303 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
176304 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176305 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
176306 }
176307 yymsp[-8].minor.yy454 = yylhsminor.yy454;
176308 break;
176309 case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
176310 {
176311 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
176312 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176313 }
176314 yymsp[-4].minor.yy454 = yylhsminor.yy454;
176315 break;
176316 case 195: /* term ::= CTIME_KW */
176317 {
176318 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
176319 }
176320 yymsp[0].minor.yy454 = yylhsminor.yy454;
176321 break;
176322 case 196: /* expr ::= LP nexprlist COMMA expr RP */
176323 {
176324 ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
176325 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
176326 if( yymsp[-4].minor.yy454 ){
176327 yymsp[-4].minor.yy454->x.pList = pList;
176328 if( ALWAYS(pList->nExpr) ){
176329 yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
176330 }
176331 }else{
176332 sqlite3ExprListDelete(pParse->db, pList);
176333 }
176334 }
176335 break;
176336 case 197: /* expr ::= expr AND expr */
176337 {yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176338 break;
176339 case 198: /* expr ::= expr OR expr */
176340 case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199);
176341 case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200);
176342 case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201);
176343 case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202);
176344 case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203);
176345 case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204);
176346 {yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176347 break;
176348 case 205: /* likeop ::= NOT LIKE_KW|MATCH */
176349 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
176350 break;
176351 case 206: /* expr ::= expr likeop expr */
176352 {
176353 ExprList *pList;
176354 int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
176355 yymsp[-1].minor.yy0.n &= 0x7fffffff;
176356 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
176357 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
176358 yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176359 if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
176360 if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc;
176361 }
176362 break;
176363 case 207: /* expr ::= expr likeop expr ESCAPE expr */
176364 {
176365 ExprList *pList;
176366 int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
176367 yymsp[-3].minor.yy0.n &= 0x7fffffff;
176368 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176369 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
176370 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176371 yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
176372 if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176373 if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc;
176374 }
176375 break;
176376 case 208: /* expr ::= expr ISNULL|NOTNULL */
176377 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy454,0);}
176378 break;
176379 case 209: /* expr ::= expr NOT NULL */
176380 {yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy454,0);}
176381 break;
176382 case 210: /* expr ::= expr IS expr */
176383 {
176384 yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);
176385 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-2].minor.yy454, TK_ISNULL);
176386 }
176387 break;
176388 case 211: /* expr ::= expr IS NOT expr */
176389 {
176390 yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy454,yymsp[0].minor.yy454);
176391 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-3].minor.yy454, TK_NOTNULL);
176392 }
176393 break;
176394 case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */
176395 {
176396 yymsp[-5].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy454,yymsp[0].minor.yy454);
176397 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-5].minor.yy454, TK_ISNULL);
176398 }
176399 break;
176400 case 213: /* expr ::= expr IS DISTINCT FROM expr */
176401 {
176402 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy454,yymsp[0].minor.yy454);
176403 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-4].minor.yy454, TK_NOTNULL);
176404 }
176405 break;
176406 case 214: /* expr ::= NOT expr */
176407 case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
176408 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
176409 break;
176410 case 216: /* expr ::= PLUS|MINUS expr */
176411 {
176412 yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy454, 0);
176413 /*A-overwrites-B*/
176414 }
176415 break;
176416 case 217: /* expr ::= expr PTR expr */
176417 {
176418 ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
176419 pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
176420 yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176421 }
176422 yymsp[-2].minor.yy454 = yylhsminor.yy454;
176423 break;
176424 case 218: /* between_op ::= BETWEEN */
176425 case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
176426 {yymsp[0].minor.yy144 = 0;}
176427 break;
176428 case 220: /* expr ::= expr between_op expr AND expr */
176429 {
176430 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176431 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176432 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
176433 if( yymsp[-4].minor.yy454 ){
176434 yymsp[-4].minor.yy454->x.pList = pList;
176435 }else{
176436 sqlite3ExprListDelete(pParse->db, pList);
176437 }
176438 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176439 }
176440 break;
176441 case 223: /* expr ::= expr in_op LP exprlist RP */
176442 {
176443 if( yymsp[-1].minor.yy14==0 ){
176444 /* Expressions of the form
176445 **
176446 ** expr1 IN ()
176447 ** expr1 NOT IN ()
176448 **
176449 ** simplify to constants 0 (false) and 1 (true), respectively,
176450 ** regardless of the value of expr1.
176451 */
176452 sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
176453 yymsp[-4].minor.yy454 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
176454 if( yymsp[-4].minor.yy454 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy454);
176455 }else{
176456 Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
176457 if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){
176458 yymsp[-1].minor.yy14->a[0].pExpr = 0;
176459 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176460 pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
176461 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
176462 }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){
176463 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176464 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
176465 pRHS->x.pSelect = 0;
176466 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176467 }else{
176468 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176469 if( yymsp[-4].minor.yy454==0 ){
176470 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
176471 }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){
176472 int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
176473 Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
176474 if( pSelectRHS ){
176475 parserDoubleLinkSelect(pParse, pSelectRHS);
176476 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
176477 }
176478 }else{
176479 yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
176480 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
176481 }
176482 }
176483 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176484 }
176485 }
176486 break;
176487 case 224: /* expr ::= LP select RP */
176488 {
176489 yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
176490 sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
176491 }
176492 break;
176493 case 225: /* expr ::= expr in_op LP select RP */
176494 {
176495 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176496 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
176497 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176498 }
176499 break;
176500 case 226: /* expr ::= expr in_op nm dbnm paren_exprlist */
176501 {
176502 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
176503 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
176504 if( yymsp[0].minor.yy14 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
176505 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
176506 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
176507 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176508 }
176509 break;
176510 case 227: /* expr ::= EXISTS LP select RP */
176511 {
176512 Expr *p;
176513 p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
176514 sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
176515 }
176516 break;
176517 case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
176518 {
176519 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
176520 if( yymsp[-4].minor.yy454 ){
176521 yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
176522 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
176523 }else{
176524 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
176525 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
176526 }
176527 }
176528 break;
176529 case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
176530 {
176531 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
176532 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
176533 }
176534 break;
176535 case 230: /* case_exprlist ::= WHEN expr THEN expr */
176536 {
176537 yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176538 yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
176539 }
176540 break;
176541 case 235: /* nexprlist ::= nexprlist COMMA expr */
176542 {yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
176543 break;
176544 case 236: /* nexprlist ::= expr */
176545 {yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
176546 break;
176547 case 238: /* paren_exprlist ::= LP exprlist RP */
176548 case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243);
176549 {yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;}
176550 break;
176551 case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
176552 {
176553 sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
176554 sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144,
176555 &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF);
176556 if( IN_RENAME_OBJECT && pParse->pNewIndex ){
176557 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
176558 }
176559 }
176560 break;
176561 case 240: /* uniqueflag ::= UNIQUE */
176562 case 282: /* raisetype ::= ABORT */ yytestcase(yyruleno==282);
176563 {yymsp[0].minor.yy144 = OE_Abort;}
176564 break;
176565 case 241: /* uniqueflag ::= */
176566 {yymsp[1].minor.yy144 = OE_None;}
176567 break;
176568 case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */
176569 {
176570 yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
176571 }
176572 break;
176573 case 245: /* eidlist ::= nm collate sortorder */
176574 {
176575 yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
176576 }
176577 break;
176578 case 248: /* cmd ::= DROP INDEX ifexists fullname */
176579 {sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
176580 break;
176581 case 249: /* cmd ::= VACUUM vinto */
176582 {sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
176583 break;
176584 case 250: /* cmd ::= VACUUM nm vinto */
176585 {sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
176586 break;
176587 case 253: /* cmd ::= PRAGMA nm dbnm */
176588 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
176589 break;
176590 case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
176591 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
176592 break;
176593 case 255: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
176594 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
176595 break;
176596 case 256: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
176597 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
176598 break;
176599 case 257: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
176600 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
176601 break;
176602 case 260: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
176603 {
176604 Token all;
176605 all.z = yymsp[-3].minor.yy0.z;
176606 all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
176607 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
176608 }
176609 break;
176610 case 261: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
176611 {
176612 sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
176613 yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
176614 }
176615 break;
176616 case 262: /* trigger_time ::= BEFORE|AFTER */
176617 { yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ }
176618 break;
176619 case 263: /* trigger_time ::= INSTEAD OF */
176620 { yymsp[-1].minor.yy144 = TK_INSTEAD;}
176621 break;
176622 case 264: /* trigger_time ::= */
176623 { yymsp[1].minor.yy144 = TK_BEFORE; }
176624 break;
176625 case 265: /* trigger_event ::= DELETE|INSERT */
176626 case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266);
176627 {yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;}
176628 break;
176629 case 267: /* trigger_event ::= UPDATE OF idlist */
176630 {yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;}
176631 break;
176632 case 268: /* when_clause ::= */
176633 case 287: /* key_opt ::= */ yytestcase(yyruleno==287);
176634 { yymsp[1].minor.yy454 = 0; }
176635 break;
176636 case 269: /* when_clause ::= WHEN expr */
176637 case 288: /* key_opt ::= KEY expr */ yytestcase(yyruleno==288);
176638 { yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; }
176639 break;
176640 case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
176641 {
176642 assert( yymsp[-2].minor.yy427!=0 );
176643 yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
176644 yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
176645 }
176646 break;
176647 case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */
176648 {
176649 assert( yymsp[-1].minor.yy427!=0 );
176650 yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
176651 }
176652 break;
176653 case 272: /* trnm ::= nm DOT nm */
176654 {
176655 yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
176656 sqlite3ErrorMsg(pParse,
176657 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
176658 "statements within triggers");
176659 }
176660 break;
176661 case 273: /* tridxby ::= INDEXED BY nm */
176662 {
176663 sqlite3ErrorMsg(pParse,
176664 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
176665 "within triggers");
176666 }
176667 break;
176668 case 274: /* tridxby ::= NOT INDEXED */
176669 {
176670 sqlite3ErrorMsg(pParse,
176671 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
176672 "within triggers");
176673 }
176674 break;
176675 case 275: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
176676 {yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
176677 yymsp[-8].minor.yy427 = yylhsminor.yy427;
176678 break;
176679 case 276: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
176680 {
176681 yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
176682 }
176683 yymsp[-7].minor.yy427 = yylhsminor.yy427;
176684 break;
176685 case 277: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
176686 {yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
176687 yymsp[-5].minor.yy427 = yylhsminor.yy427;
176688 break;
176689 case 278: /* trigger_cmd ::= scanpt select scanpt */
176690 {yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
176691 yymsp[-2].minor.yy427 = yylhsminor.yy427;
176692 break;
176693 case 279: /* expr ::= RAISE LP IGNORE RP */
176694 {
176695 yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
176696 if( yymsp[-3].minor.yy454 ){
176697 yymsp[-3].minor.yy454->affExpr = OE_Ignore;
176698 }
176699 }
176700 break;
176701 case 280: /* expr ::= RAISE LP raisetype COMMA nm RP */
176702 {
176703 yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
176704 if( yymsp[-5].minor.yy454 ) {
176705 yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144;
176706 }
176707 }
176708 break;
176709 case 281: /* raisetype ::= ROLLBACK */
176710 {yymsp[0].minor.yy144 = OE_Rollback;}
176711 break;
176712 case 283: /* raisetype ::= FAIL */
176713 {yymsp[0].minor.yy144 = OE_Fail;}
176714 break;
176715 case 284: /* cmd ::= DROP TRIGGER ifexists fullname */
176716 {
176717 sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
176718 }
176719 break;
176720 case 285: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
176721 {
176722 sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
176723 }
176724 break;
176725 case 286: /* cmd ::= DETACH database_kw_opt expr */
176726 {
176727 sqlite3Detach(pParse, yymsp[0].minor.yy454);
176728 }
176729 break;
176730 case 289: /* cmd ::= REINDEX */
176731 {sqlite3Reindex(pParse, 0, 0);}
176732 break;
176733 case 290: /* cmd ::= REINDEX nm dbnm */
176734 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176735 break;
176736 case 291: /* cmd ::= ANALYZE */
176737 {sqlite3Analyze(pParse, 0, 0);}
176738 break;
176739 case 292: /* cmd ::= ANALYZE nm dbnm */
176740 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
176741 break;
176742 case 293: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
176743 {
176744 sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
176745 }
176746 break;
176747 case 294: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
176748 {
176749 yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
176750 sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
176751 }
176752 break;
176753 case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
176754 {
176755 sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
176756 }
176757 break;
176758 case 296: /* add_column_fullname ::= fullname */
176759 {
176760 disableLookaside(pParse);
176761 sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy203);
176762 }
176763 break;
176764 case 297: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
176765 {
176766 sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
176767 }
176768 break;
176769 case 298: /* cmd ::= create_vtab */
176770 {sqlite3VtabFinishParse(pParse,0);}
176771 break;
176772 case 299: /* cmd ::= create_vtab LP vtabarglist RP */
176773 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
176774 break;
176775 case 300: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
176776 {
176777 sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144);
176778 }
176779 break;
176780 case 301: /* vtabarg ::= */
176781 {sqlite3VtabArgInit(pParse);}
176782 break;
176783 case 302: /* vtabargtoken ::= ANY */
176784 case 303: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==303);
176785 case 304: /* lp ::= LP */ yytestcase(yyruleno==304);
176786 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
176787 break;
176788 case 305: /* with ::= WITH wqlist */
176789 case 306: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==306);
176790 { sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
176791 break;
176792 case 307: /* wqas ::= AS */
176793 {yymsp[0].minor.yy462 = M10d_Any;}
176794 break;
176795 case 308: /* wqas ::= AS MATERIALIZED */
176796 {yymsp[-1].minor.yy462 = M10d_Yes;}
176797 break;
176798 case 309: /* wqas ::= AS NOT MATERIALIZED */
176799 {yymsp[-2].minor.yy462 = M10d_No;}
176800 break;
176801 case 310: /* wqitem ::= withnm eidlist_opt wqas LP select RP */
176802 {
176803 yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
176804 }
176805 break;
176806 case 311: /* withnm ::= nm */
176807 {pParse->bHasWith = 1;}
176808 break;
176809 case 312: /* wqlist ::= wqitem */
176810 {
176811 yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
176812 }
176813 break;
176814 case 313: /* wqlist ::= wqlist COMMA wqitem */
176815 {
176816 yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
176817 }
176818 break;
176819 case 314: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
176820 {
176821 assert( yymsp[0].minor.yy211!=0 );
176822 sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
176823 yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211;
176824 yylhsminor.yy211 = yymsp[0].minor.yy211;
176825 }
176826 yymsp[-2].minor.yy211 = yylhsminor.yy211;
176827 break;
176828 case 315: /* windowdefn ::= nm AS LP window RP */
176829 {
176830 if( ALWAYS(yymsp[-1].minor.yy211) ){
176831 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
176832 }
176833 yylhsminor.yy211 = yymsp[-1].minor.yy211;
176834 }
176835 yymsp[-4].minor.yy211 = yylhsminor.yy211;
176836 break;
176837 case 316: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
176838 {
176839 yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
176840 }
176841 break;
176842 case 317: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
176843 {
176844 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
176845 }
176846 yymsp[-5].minor.yy211 = yylhsminor.yy211;
176847 break;
176848 case 318: /* window ::= ORDER BY sortlist frame_opt */
176849 {
176850 yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
176851 }
176852 break;
176853 case 319: /* window ::= nm ORDER BY sortlist frame_opt */
176854 {
176855 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
176856 }
176857 yymsp[-4].minor.yy211 = yylhsminor.yy211;
176858 break;
176859 case 320: /* window ::= nm frame_opt */
176860 {
176861 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
176862 }
176863 yymsp[-1].minor.yy211 = yylhsminor.yy211;
176864 break;
176865 case 321: /* frame_opt ::= */
176866 {
176867 yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
176868 }
176869 break;
176870 case 322: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
176871 {
176872 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
176873 }
176874 yymsp[-2].minor.yy211 = yylhsminor.yy211;
176875 break;
176876 case 323: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
176877 {
176878 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
176879 }
176880 yymsp[-5].minor.yy211 = yylhsminor.yy211;
176881 break;
176882 case 325: /* frame_bound_s ::= frame_bound */
176883 case 327: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==327);
176884 {yylhsminor.yy509 = yymsp[0].minor.yy509;}
176885 yymsp[0].minor.yy509 = yylhsminor.yy509;
176886 break;
176887 case 326: /* frame_bound_s ::= UNBOUNDED PRECEDING */
176888 case 328: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==328);
176889 case 330: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==330);
176890 {yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
176891 yymsp[-1].minor.yy509 = yylhsminor.yy509;
176892 break;
176893 case 329: /* frame_bound ::= expr PRECEDING|FOLLOWING */
176894 {yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
176895 yymsp[-1].minor.yy509 = yylhsminor.yy509;
176896 break;
176897 case 331: /* frame_exclude_opt ::= */
176898 {yymsp[1].minor.yy462 = 0;}
176899 break;
176900 case 332: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
176901 {yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;}
176902 break;
176903 case 333: /* frame_exclude ::= NO OTHERS */
176904 case 334: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==334);
176905 {yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/}
176906 break;
176907 case 335: /* frame_exclude ::= GROUP|TIES */
176908 {yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/}
176909 break;
176910 case 336: /* window_clause ::= WINDOW windowdefn_list */
176911 { yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; }
176912 break;
176913 case 337: /* filter_over ::= filter_clause over_clause */
176914 {
176915 if( yymsp[0].minor.yy211 ){
176916 yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454;
176917 }else{
176918 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
176919 }
176920 yylhsminor.yy211 = yymsp[0].minor.yy211;
176921 }
176922 yymsp[-1].minor.yy211 = yylhsminor.yy211;
176923 break;
176924 case 338: /* filter_over ::= over_clause */
176925 {
176926 yylhsminor.yy211 = yymsp[0].minor.yy211;
176927 }
176928 yymsp[0].minor.yy211 = yylhsminor.yy211;
176929 break;
176930 case 339: /* filter_over ::= filter_clause */
176931 {
176932 yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176933 if( yylhsminor.yy211 ){
176934 yylhsminor.yy211->eFrmType = TK_FILTER;
176935 yylhsminor.yy211->pFilter = yymsp[0].minor.yy454;
176936 }else{
176937 sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
176938 }
176939 }
176940 yymsp[0].minor.yy211 = yylhsminor.yy211;
176941 break;
176942 case 340: /* over_clause ::= OVER LP window RP */
176943 {
176944 yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211;
176945 assert( yymsp[-3].minor.yy211!=0 );
176946 }
176947 break;
176948 case 341: /* over_clause ::= OVER nm */
176949 {
176950 yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
176951 if( yymsp[-1].minor.yy211 ){
176952 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
176953 }
176954 }
176955 break;
176956 case 342: /* filter_clause ::= FILTER LP WHERE expr RP */
176957 { yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; }
176958 break;
176959 case 343: /* term ::= QNUMBER */
176960 {
176961 yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
176962 sqlite3DequoteNumber(pParse, yylhsminor.yy454);
176963 }
176964 yymsp[0].minor.yy454 = yylhsminor.yy454;
176965 break;
176966 default:
176967 /* (344) input ::= cmdlist */ yytestcase(yyruleno==344);
176968 /* (345) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==345);
176969 /* (346) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=346);
176970 /* (347) ecmd ::= SEMI */ yytestcase(yyruleno==347);
176971 /* (348) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==348);
176972 /* (349) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=349);
176973 /* (350) trans_opt ::= */ yytestcase(yyruleno==350);
176974 /* (351) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==351);
176975 /* (352) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==352);
176976 /* (353) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==353);
176977 /* (354) savepoint_opt ::= */ yytestcase(yyruleno==354);
176978 /* (355) cmd ::= create_table create_table_args */ yytestcase(yyruleno==355);
176979 /* (356) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=356);
176980 /* (357) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==357);
176981 /* (358) columnlist ::= columnname carglist */ yytestcase(yyruleno==358);
176982 /* (359) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==359);
176983 /* (360) nm ::= STRING */ yytestcase(yyruleno==360);
176984 /* (361) typetoken ::= typename */ yytestcase(yyruleno==361);
176985 /* (362) typename ::= ID|STRING */ yytestcase(yyruleno==362);
176986 /* (363) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=363);
176987 /* (364) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=364);
176988 /* (365) carglist ::= carglist ccons */ yytestcase(yyruleno==365);
176989 /* (366) carglist ::= */ yytestcase(yyruleno==366);
176990 /* (367) ccons ::= NULL onconf */ yytestcase(yyruleno==367);
176991 /* (368) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==368);
176992 /* (369) ccons ::= AS generated */ yytestcase(yyruleno==369);
176993 /* (370) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==370);
176994 /* (371) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==371);
176995 /* (372) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=372);
176996 /* (373) tconscomma ::= */ yytestcase(yyruleno==373);
176997 /* (374) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=374);
176998 /* (375) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=375);
176999 /* (376) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=376);
177000 /* (377) oneselect ::= values */ yytestcase(yyruleno==377);
177001 /* (378) sclp ::= selcollist COMMA */ yytestcase(yyruleno==378);
177002 /* (379) as ::= ID|STRING */ yytestcase(yyruleno==379);
177003 /* (380) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=380);
177004 /* (381) returning ::= */ yytestcase(yyruleno==381);
177005 /* (382) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=382);
177006 /* (383) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==383);
177007 /* (384) case_operand ::= expr */ yytestcase(yyruleno==384);
177008 /* (385) exprlist ::= nexprlist */ yytestcase(yyruleno==385);
177009 /* (386) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=386);
177010 /* (387) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=387);
177011 /* (388) nmnum ::= ON */ yytestcase(yyruleno==388);
177012 /* (389) nmnum ::= DELETE */ yytestcase(yyruleno==389);
177013 /* (390) nmnum ::= DEFAULT */ yytestcase(yyruleno==390);
177014 /* (391) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==391);
177015 /* (392) foreach_clause ::= */ yytestcase(yyruleno==392);
177016 /* (393) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==393);
177017 /* (394) trnm ::= nm */ yytestcase(yyruleno==394);
177018 /* (395) tridxby ::= */ yytestcase(yyruleno==395);
177019 /* (396) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==396);
177020 /* (397) database_kw_opt ::= */ yytestcase(yyruleno==397);
177021 /* (398) kwcolumn_opt ::= */ yytestcase(yyruleno==398);
177022 /* (399) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==399);
177023 /* (400) vtabarglist ::= vtabarg */ yytestcase(yyruleno==400);
177024 /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==401);
177025 /* (402) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==402);
177026 /* (403) anylist ::= */ yytestcase(yyruleno==403);
177027 /* (404) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==404);
177028 /* (405) anylist ::= anylist ANY */ yytestcase(yyruleno==405);
177029 /* (406) with ::= */ yytestcase(yyruleno==406);
177030 /* (407) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=407);
177031 /* (408) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=408);
177032 break;
177033 /********** End reduce actions ************************************************/
177034 };
177035 assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
177036 yygoto = yyRuleInfoLhs[yyruleno];
@@ -251503,11 +251802,11 @@
251802 int nArg, /* Number of args */
251803 sqlite3_value **apUnused /* Function arguments */
251804 ){
251805 assert( nArg==0 );
251806 UNUSED_PARAM2(nArg, apUnused);
251807 sqlite3_result_text(pCtx, "fts5: 2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61", -1, SQLITE_TRANSIENT);
251808 }
251809
251810 /*
251811 ** Return true if zName is the extension on one of the shadow tables used
251812 ** by this module.
251813
M extsrc/sqlite3.h
+1 -1
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,11 +146,11 @@
146146
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147147
 ** [sqlite_version()] and [sqlite_source_id()].
148148
 */
149149
 #define SQLITE_VERSION "3.46.0"
150150
 #define SQLITE_VERSION_NUMBER 3046000
151
-#define SQLITE_SOURCE_ID "2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f"
151
+#define SQLITE_SOURCE_ID "2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61"
152152
153153
 /*
154154
 ** CAPI3REF: Run-Time Library Version Numbers
155155
 ** KEYWORDS: sqlite3_version sqlite3_sourceid
156156
 **
157157
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,11 +146,11 @@
146 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147 ** [sqlite_version()] and [sqlite_source_id()].
148 */
149 #define SQLITE_VERSION "3.46.0"
150 #define SQLITE_VERSION_NUMBER 3046000
151 #define SQLITE_SOURCE_ID "2024-03-09 18:41:40 7ead022edaf7a0cd6a8976a1261246084975c9a5be5c893f6c751bb5f963ac0f"
152
153 /*
154 ** CAPI3REF: Run-Time Library Version Numbers
155 ** KEYWORDS: sqlite3_version sqlite3_sourceid
156 **
157
--- extsrc/sqlite3.h
+++ extsrc/sqlite3.h
@@ -146,11 +146,11 @@
146 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147 ** [sqlite_version()] and [sqlite_source_id()].
148 */
149 #define SQLITE_VERSION "3.46.0"
150 #define SQLITE_VERSION_NUMBER 3046000
151 #define SQLITE_SOURCE_ID "2024-03-18 18:03:17 76fb3a908f45230b956cb659c754e47603e80aa72a2aad50d479437a9c013f61"
152
153 /*
154 ** CAPI3REF: Run-Time Library Version Numbers
155 ** KEYWORDS: sqlite3_version sqlite3_sourceid
156 **
157

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button