| | @@ -452,11 +452,11 @@ |
| 452 | 452 | ** [sqlite3_libversion_number()], [sqlite3_sourceid()], |
| 453 | 453 | ** [sqlite_version()] and [sqlite_source_id()]. |
| 454 | 454 | */ |
| 455 | 455 | #define SQLITE_VERSION "3.38.0" |
| 456 | 456 | #define SQLITE_VERSION_NUMBER 3038000 |
| 457 | | -#define SQLITE_SOURCE_ID "2021-12-09 20:06:18 633bfeeea2bccdd44126acf3f61ecca163c9d933bdc787a2c18a697dc9406882" |
| 457 | +#define SQLITE_SOURCE_ID "2022-01-12 00:28:12 adebb9d7478d092f16fb0ef7d5246ce152b166479d6f949110b5878b89ea2cec" |
| 458 | 458 | |
| 459 | 459 | /* |
| 460 | 460 | ** CAPI3REF: Run-Time Library Version Numbers |
| 461 | 461 | ** KEYWORDS: sqlite3_version sqlite3_sourceid |
| 462 | 462 | ** |
| | @@ -4128,17 +4128,18 @@ |
| 4128 | 4128 | ** |
| 4129 | 4129 | ** The values returned by sqlite3_errcode() and/or |
| 4130 | 4130 | ** sqlite3_extended_errcode() might change with each API call. |
| 4131 | 4131 | ** Except, there are some interfaces that are guaranteed to never |
| 4132 | 4132 | ** change the value of the error code. The error-code preserving |
| 4133 | | -** interfaces are: |
| 4133 | +** interfaces include the following: |
| 4134 | 4134 | ** |
| 4135 | 4135 | ** <ul> |
| 4136 | 4136 | ** <li> sqlite3_errcode() |
| 4137 | 4137 | ** <li> sqlite3_extended_errcode() |
| 4138 | 4138 | ** <li> sqlite3_errmsg() |
| 4139 | 4139 | ** <li> sqlite3_errmsg16() |
| 4140 | +** <li> sqlite3_error_offset() |
| 4140 | 4141 | ** </ul> |
| 4141 | 4142 | ** |
| 4142 | 4143 | ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language |
| 4143 | 4144 | ** text that describes the error, as either UTF-8 or UTF-16 respectively. |
| 4144 | 4145 | ** ^(Memory to hold the error message string is managed internally. |
| | @@ -4148,10 +4149,17 @@ |
| 4148 | 4149 | ** |
| 4149 | 4150 | ** ^The sqlite3_errstr() interface returns the English-language text |
| 4150 | 4151 | ** that describes the [result code], as UTF-8. |
| 4151 | 4152 | ** ^(Memory to hold the error message string is managed internally |
| 4152 | 4153 | ** and must not be freed by the application)^. |
| 4154 | +** |
| 4155 | +** ^If the most recent error references a specific token in the input |
| 4156 | +** SQL, the sqlite3_error_offset() interface returns the byte offset |
| 4157 | +** of the start of that token. ^The byte offset returned by |
| 4158 | +** sqlite3_error_offset() assumes that the input SQL is UTF8. |
| 4159 | +** ^If the most error does not reference a specific token in the input |
| 4160 | +** SQL, then the sqlite3_error_offset() function returns -1. |
| 4153 | 4161 | ** |
| 4154 | 4162 | ** When the serialized [threading mode] is in use, it might be the |
| 4155 | 4163 | ** case that a second error occurs on a separate thread in between |
| 4156 | 4164 | ** the time of the first error and the call to these interfaces. |
| 4157 | 4165 | ** When that happens, the second error will be reported since these |
| | @@ -4168,10 +4176,11 @@ |
| 4168 | 4176 | SQLITE_API int sqlite3_errcode(sqlite3 *db); |
| 4169 | 4177 | SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); |
| 4170 | 4178 | SQLITE_API const char *sqlite3_errmsg(sqlite3*); |
| 4171 | 4179 | SQLITE_API const void *sqlite3_errmsg16(sqlite3*); |
| 4172 | 4180 | SQLITE_API const char *sqlite3_errstr(int); |
| 4181 | +SQLITE_API int sqlite3_error_offset(sqlite3 *db); |
| 4173 | 4182 | |
| 4174 | 4183 | /* |
| 4175 | 4184 | ** CAPI3REF: Prepared Statement Object |
| 4176 | 4185 | ** KEYWORDS: {prepared statement} {prepared statements} |
| 4177 | 4186 | ** |
| | @@ -9768,18 +9777,37 @@ |
| 9768 | 9777 | |
| 9769 | 9778 | /* |
| 9770 | 9779 | ** CAPI3REF: Determine The Collation For a Virtual Table Constraint |
| 9771 | 9780 | ** |
| 9772 | 9781 | ** This function may only be called from within a call to the [xBestIndex] |
| 9773 | | -** method of a [virtual table]. |
| 9782 | +** method of a [virtual table]. This function returns a pointer to a string |
| 9783 | +** that is the name of the appropriate collation sequence to use for text |
| 9784 | +** comparisons on the constraint identified by its arguments. |
| 9774 | 9785 | ** |
| 9775 | | -** The first argument must be the sqlite3_index_info object that is the |
| 9776 | | -** first parameter to the xBestIndex() method. The second argument must be |
| 9777 | | -** an index into the aConstraint[] array belonging to the sqlite3_index_info |
| 9778 | | -** structure passed to xBestIndex. This function returns a pointer to a buffer |
| 9779 | | -** containing the name of the collation sequence for the corresponding |
| 9780 | | -** constraint. |
| 9786 | +** The first argument must be the pointer to the sqlite3_index_info object |
| 9787 | +** that is the first parameter to the xBestIndex() method. The second argument |
| 9788 | +** must be an index into the aConstraint[] array belonging to the |
| 9789 | +** sqlite3_index_info structure passed to xBestIndex. |
| 9790 | +** |
| 9791 | +** Important: |
| 9792 | +** The first parameter must be the same pointer that is passed into the |
| 9793 | +** xBestMethod() method. The first parameter may not be a pointer to a |
| 9794 | +** different sqlite3_index_info object, even an exact copy. |
| 9795 | +** |
| 9796 | +** The return value is computed as follows: |
| 9797 | +** |
| 9798 | +** <ol> |
| 9799 | +** <li><p> If the constraint comes from a WHERE clause expression that contains |
| 9800 | +** a [COLLATE operator], then the name of the collation specified by |
| 9801 | +** that COLLATE operator is returned. |
| 9802 | +** <li><p> If there is no COLLATE operator, but the column that is the subject |
| 9803 | +** of the constraint specifies an alternative collating sequence via |
| 9804 | +** a [COLLATE clause] on the column definition within the CREATE TABLE |
| 9805 | +** statement that was passed into [sqlite3_declare_vtab()], then the |
| 9806 | +** name of that alternative collating sequence is returned. |
| 9807 | +** <li><p> Otherwise, "BINARY" is returned. |
| 9808 | +** </ol> |
| 9781 | 9809 | */ |
| 9782 | 9810 | SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int); |
| 9783 | 9811 | |
| 9784 | 9812 | /* |
| 9785 | 9813 | ** CAPI3REF: Conflict resolution modes |
| | @@ -13565,14 +13593,14 @@ |
| 13565 | 13593 | #define TK_DETACH 40 |
| 13566 | 13594 | #define TK_EACH 41 |
| 13567 | 13595 | #define TK_FAIL 42 |
| 13568 | 13596 | #define TK_OR 43 |
| 13569 | 13597 | #define TK_AND 44 |
| 13570 | | -#define TK_MATCH 45 |
| 13571 | | -#define TK_LIKE_KW 46 |
| 13572 | | -#define TK_BETWEEN 47 |
| 13573 | | -#define TK_IS 48 |
| 13598 | +#define TK_IS 45 |
| 13599 | +#define TK_MATCH 46 |
| 13600 | +#define TK_LIKE_KW 47 |
| 13601 | +#define TK_BETWEEN 48 |
| 13574 | 13602 | #define TK_IN 49 |
| 13575 | 13603 | #define TK_ISNULL 50 |
| 13576 | 13604 | #define TK_NOTNULL 51 |
| 13577 | 13605 | #define TK_NE 52 |
| 13578 | 13606 | #define TK_EQ 53 |
| | @@ -13632,82 +13660,83 @@ |
| 13632 | 13660 | #define TK_MINUS 107 |
| 13633 | 13661 | #define TK_STAR 108 |
| 13634 | 13662 | #define TK_SLASH 109 |
| 13635 | 13663 | #define TK_REM 110 |
| 13636 | 13664 | #define TK_CONCAT 111 |
| 13637 | | -#define TK_COLLATE 112 |
| 13638 | | -#define TK_BITNOT 113 |
| 13639 | | -#define TK_ON 114 |
| 13640 | | -#define TK_INDEXED 115 |
| 13641 | | -#define TK_STRING 116 |
| 13642 | | -#define TK_JOIN_KW 117 |
| 13643 | | -#define TK_CONSTRAINT 118 |
| 13644 | | -#define TK_DEFAULT 119 |
| 13645 | | -#define TK_NULL 120 |
| 13646 | | -#define TK_PRIMARY 121 |
| 13647 | | -#define TK_UNIQUE 122 |
| 13648 | | -#define TK_CHECK 123 |
| 13649 | | -#define TK_REFERENCES 124 |
| 13650 | | -#define TK_AUTOINCR 125 |
| 13651 | | -#define TK_INSERT 126 |
| 13652 | | -#define TK_DELETE 127 |
| 13653 | | -#define TK_UPDATE 128 |
| 13654 | | -#define TK_SET 129 |
| 13655 | | -#define TK_DEFERRABLE 130 |
| 13656 | | -#define TK_FOREIGN 131 |
| 13657 | | -#define TK_DROP 132 |
| 13658 | | -#define TK_UNION 133 |
| 13659 | | -#define TK_ALL 134 |
| 13660 | | -#define TK_EXCEPT 135 |
| 13661 | | -#define TK_INTERSECT 136 |
| 13662 | | -#define TK_SELECT 137 |
| 13663 | | -#define TK_VALUES 138 |
| 13664 | | -#define TK_DISTINCT 139 |
| 13665 | | -#define TK_DOT 140 |
| 13666 | | -#define TK_FROM 141 |
| 13667 | | -#define TK_JOIN 142 |
| 13668 | | -#define TK_USING 143 |
| 13669 | | -#define TK_ORDER 144 |
| 13670 | | -#define TK_GROUP 145 |
| 13671 | | -#define TK_HAVING 146 |
| 13672 | | -#define TK_LIMIT 147 |
| 13673 | | -#define TK_WHERE 148 |
| 13674 | | -#define TK_RETURNING 149 |
| 13675 | | -#define TK_INTO 150 |
| 13676 | | -#define TK_NOTHING 151 |
| 13677 | | -#define TK_FLOAT 152 |
| 13678 | | -#define TK_BLOB 153 |
| 13679 | | -#define TK_INTEGER 154 |
| 13680 | | -#define TK_VARIABLE 155 |
| 13681 | | -#define TK_CASE 156 |
| 13682 | | -#define TK_WHEN 157 |
| 13683 | | -#define TK_THEN 158 |
| 13684 | | -#define TK_ELSE 159 |
| 13685 | | -#define TK_INDEX 160 |
| 13686 | | -#define TK_ALTER 161 |
| 13687 | | -#define TK_ADD 162 |
| 13688 | | -#define TK_WINDOW 163 |
| 13689 | | -#define TK_OVER 164 |
| 13690 | | -#define TK_FILTER 165 |
| 13691 | | -#define TK_COLUMN 166 |
| 13692 | | -#define TK_AGG_FUNCTION 167 |
| 13693 | | -#define TK_AGG_COLUMN 168 |
| 13694 | | -#define TK_TRUEFALSE 169 |
| 13695 | | -#define TK_ISNOT 170 |
| 13696 | | -#define TK_FUNCTION 171 |
| 13697 | | -#define TK_UMINUS 172 |
| 13698 | | -#define TK_UPLUS 173 |
| 13699 | | -#define TK_TRUTH 174 |
| 13700 | | -#define TK_REGISTER 175 |
| 13701 | | -#define TK_VECTOR 176 |
| 13702 | | -#define TK_SELECT_COLUMN 177 |
| 13703 | | -#define TK_IF_NULL_ROW 178 |
| 13704 | | -#define TK_ASTERISK 179 |
| 13705 | | -#define TK_SPAN 180 |
| 13706 | | -#define TK_ERROR 181 |
| 13707 | | -#define TK_SPACE 182 |
| 13708 | | -#define TK_ILLEGAL 183 |
| 13665 | +#define TK_PTR 112 |
| 13666 | +#define TK_COLLATE 113 |
| 13667 | +#define TK_BITNOT 114 |
| 13668 | +#define TK_ON 115 |
| 13669 | +#define TK_INDEXED 116 |
| 13670 | +#define TK_STRING 117 |
| 13671 | +#define TK_JOIN_KW 118 |
| 13672 | +#define TK_CONSTRAINT 119 |
| 13673 | +#define TK_DEFAULT 120 |
| 13674 | +#define TK_NULL 121 |
| 13675 | +#define TK_PRIMARY 122 |
| 13676 | +#define TK_UNIQUE 123 |
| 13677 | +#define TK_CHECK 124 |
| 13678 | +#define TK_REFERENCES 125 |
| 13679 | +#define TK_AUTOINCR 126 |
| 13680 | +#define TK_INSERT 127 |
| 13681 | +#define TK_DELETE 128 |
| 13682 | +#define TK_UPDATE 129 |
| 13683 | +#define TK_SET 130 |
| 13684 | +#define TK_DEFERRABLE 131 |
| 13685 | +#define TK_FOREIGN 132 |
| 13686 | +#define TK_DROP 133 |
| 13687 | +#define TK_UNION 134 |
| 13688 | +#define TK_ALL 135 |
| 13689 | +#define TK_EXCEPT 136 |
| 13690 | +#define TK_INTERSECT 137 |
| 13691 | +#define TK_SELECT 138 |
| 13692 | +#define TK_VALUES 139 |
| 13693 | +#define TK_DISTINCT 140 |
| 13694 | +#define TK_DOT 141 |
| 13695 | +#define TK_FROM 142 |
| 13696 | +#define TK_JOIN 143 |
| 13697 | +#define TK_USING 144 |
| 13698 | +#define TK_ORDER 145 |
| 13699 | +#define TK_GROUP 146 |
| 13700 | +#define TK_HAVING 147 |
| 13701 | +#define TK_LIMIT 148 |
| 13702 | +#define TK_WHERE 149 |
| 13703 | +#define TK_RETURNING 150 |
| 13704 | +#define TK_INTO 151 |
| 13705 | +#define TK_NOTHING 152 |
| 13706 | +#define TK_FLOAT 153 |
| 13707 | +#define TK_BLOB 154 |
| 13708 | +#define TK_INTEGER 155 |
| 13709 | +#define TK_VARIABLE 156 |
| 13710 | +#define TK_CASE 157 |
| 13711 | +#define TK_WHEN 158 |
| 13712 | +#define TK_THEN 159 |
| 13713 | +#define TK_ELSE 160 |
| 13714 | +#define TK_INDEX 161 |
| 13715 | +#define TK_ALTER 162 |
| 13716 | +#define TK_ADD 163 |
| 13717 | +#define TK_WINDOW 164 |
| 13718 | +#define TK_OVER 165 |
| 13719 | +#define TK_FILTER 166 |
| 13720 | +#define TK_COLUMN 167 |
| 13721 | +#define TK_AGG_FUNCTION 168 |
| 13722 | +#define TK_AGG_COLUMN 169 |
| 13723 | +#define TK_TRUEFALSE 170 |
| 13724 | +#define TK_ISNOT 171 |
| 13725 | +#define TK_FUNCTION 172 |
| 13726 | +#define TK_UMINUS 173 |
| 13727 | +#define TK_UPLUS 174 |
| 13728 | +#define TK_TRUTH 175 |
| 13729 | +#define TK_REGISTER 176 |
| 13730 | +#define TK_VECTOR 177 |
| 13731 | +#define TK_SELECT_COLUMN 178 |
| 13732 | +#define TK_IF_NULL_ROW 179 |
| 13733 | +#define TK_ASTERISK 180 |
| 13734 | +#define TK_SPAN 181 |
| 13735 | +#define TK_ERROR 182 |
| 13736 | +#define TK_SPACE 183 |
| 13737 | +#define TK_ILLEGAL 184 |
| 13709 | 13738 | |
| 13710 | 13739 | /************** End of parse.h ***********************************************/ |
| 13711 | 13740 | /************** Continuing where we left off in sqliteInt.h ******************/ |
| 13712 | 13741 | #include <stdio.h> |
| 13713 | 13742 | #include <stdlib.h> |
| | @@ -15314,15 +15343,15 @@ |
| 15314 | 15343 | #define OP_Multiply 108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ |
| 15315 | 15344 | #define OP_Divide 109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ |
| 15316 | 15345 | #define OP_Remainder 110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ |
| 15317 | 15346 | #define OP_Concat 111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ |
| 15318 | 15347 | #define OP_OpenWrite 112 /* synopsis: root=P2 iDb=P3 */ |
| 15319 | | -#define OP_BitNot 113 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ |
| 15320 | | -#define OP_OpenDup 114 |
| 15348 | +#define OP_OpenDup 113 |
| 15349 | +#define OP_BitNot 114 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ |
| 15321 | 15350 | #define OP_OpenAutoindex 115 /* synopsis: nColumn=P2 */ |
| 15322 | | -#define OP_String8 116 /* same as TK_STRING, synopsis: r[P2]='P4' */ |
| 15323 | | -#define OP_OpenEphemeral 117 /* synopsis: nColumn=P2 */ |
| 15351 | +#define OP_OpenEphemeral 116 /* synopsis: nColumn=P2 */ |
| 15352 | +#define OP_String8 117 /* same as TK_STRING, synopsis: r[P2]='P4' */ |
| 15324 | 15353 | #define OP_SorterOpen 118 |
| 15325 | 15354 | #define OP_SequenceTest 119 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ |
| 15326 | 15355 | #define OP_OpenPseudo 120 /* synopsis: P3 columns in r[P2] */ |
| 15327 | 15356 | #define OP_Close 121 |
| 15328 | 15357 | #define OP_ColumnsUsed 122 |
| | @@ -15353,12 +15382,12 @@ |
| 15353 | 15382 | #define OP_SqlExec 147 |
| 15354 | 15383 | #define OP_ParseSchema 148 |
| 15355 | 15384 | #define OP_LoadAnalysis 149 |
| 15356 | 15385 | #define OP_DropTable 150 |
| 15357 | 15386 | #define OP_DropIndex 151 |
| 15358 | | -#define OP_Real 152 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ |
| 15359 | | -#define OP_DropTrigger 153 |
| 15387 | +#define OP_DropTrigger 152 |
| 15388 | +#define OP_Real 153 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ |
| 15360 | 15389 | #define OP_IntegrityCk 154 |
| 15361 | 15390 | #define OP_RowSetAdd 155 /* synopsis: rowset(P1)=r[P2] */ |
| 15362 | 15391 | #define OP_Param 156 |
| 15363 | 15392 | #define OP_FkCounter 157 /* synopsis: fkctr[P1]+=P2 */ |
| 15364 | 15393 | #define OP_MemMax 158 /* synopsis: r[P1]=max(r[P1],r[P2]) */ |
| | @@ -15411,16 +15440,16 @@ |
| 15411 | 15440 | /* 72 */ 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00,\ |
| 15412 | 15441 | /* 80 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02,\ |
| 15413 | 15442 | /* 88 */ 0x00, 0x00, 0x12, 0x1e, 0x20, 0x00, 0x00, 0x00,\ |
| 15414 | 15443 | /* 96 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x26, 0x26,\ |
| 15415 | 15444 | /* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\ |
| 15416 | | -/* 112 */ 0x00, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\ |
| 15445 | +/* 112 */ 0x00, 0x00, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00,\ |
| 15417 | 15446 | /* 120 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\ |
| 15418 | 15447 | /* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,\ |
| 15419 | 15448 | /* 136 */ 0x00, 0x04, 0x04, 0x00, 0x00, 0x10, 0x00, 0x10,\ |
| 15420 | 15449 | /* 144 */ 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\ |
| 15421 | | -/* 152 */ 0x10, 0x00, 0x00, 0x06, 0x10, 0x00, 0x04, 0x1a,\ |
| 15450 | +/* 152 */ 0x00, 0x10, 0x00, 0x06, 0x10, 0x00, 0x04, 0x1a,\ |
| 15422 | 15451 | /* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ |
| 15423 | 15452 | /* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\ |
| 15424 | 15453 | /* 176 */ 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ |
| 15425 | 15454 | } |
| 15426 | 15455 | |
| | @@ -16489,10 +16518,11 @@ |
| 16489 | 16518 | i64 lastRowid; /* ROWID of most recent insert (see above) */ |
| 16490 | 16519 | i64 szMmap; /* Default mmap_size setting */ |
| 16491 | 16520 | u32 nSchemaLock; /* Do not reset the schema when non-zero */ |
| 16492 | 16521 | unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ |
| 16493 | 16522 | int errCode; /* Most recent error code (SQLITE_*) */ |
| 16523 | + int errByteOffset; /* Byte offset of error in SQL statement */ |
| 16494 | 16524 | int errMask; /* & result codes with this before returning */ |
| 16495 | 16525 | int iSysErrno; /* Errno value from last system error */ |
| 16496 | 16526 | u32 dbOptFlags; /* Flags to enable/disable optimizations */ |
| 16497 | 16527 | u8 enc; /* Text encoding */ |
| 16498 | 16528 | u8 autoCommit; /* The auto-commit flag. */ |
| | @@ -16725,10 +16755,11 @@ |
| 16725 | 16755 | #define SQLITE_SeekScan 0x00020000 /* The OP_SeekScan optimization */ |
| 16726 | 16756 | #define SQLITE_OmitOrderBy 0x00040000 /* Omit pointless ORDER BY */ |
| 16727 | 16757 | /* TH3 expects this value ^^^^^^^^^^ to be 0x40000. Coordinate any change */ |
| 16728 | 16758 | #define SQLITE_BloomFilter 0x00080000 /* Use a Bloom filter on searches */ |
| 16729 | 16759 | #define SQLITE_BloomPulldown 0x00100000 /* Run Bloom filters early */ |
| 16760 | +#define SQLITE_BalancedMerge 0x00200000 /* Balance multi-way merges */ |
| 16730 | 16761 | #define SQLITE_AllOpts 0xffffffff /* All optimizations */ |
| 16731 | 16762 | |
| 16732 | 16763 | /* |
| 16733 | 16764 | ** Macros for testing whether or not optimizations are enabled or disabled. |
| 16734 | 16765 | */ |
| | @@ -16898,11 +16929,11 @@ |
| 16898 | 16929 | ** Used to create an aggregate function definition implemented by |
| 16899 | 16930 | ** the C functions xStep and xFinal. The first four parameters |
| 16900 | 16931 | ** are interpreted in the same way as the first 4 parameters to |
| 16901 | 16932 | ** FUNCTION(). |
| 16902 | 16933 | ** |
| 16903 | | -** WFUNCTION(zName, nArg, iArg, xStep, xFinal, xValue, xInverse) |
| 16934 | +** WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse) |
| 16904 | 16935 | ** Used to create an aggregate function definition implemented by |
| 16905 | 16936 | ** the C functions xStep and xFinal. The first four parameters |
| 16906 | 16937 | ** are interpreted in the same way as the first 4 parameters to |
| 16907 | 16938 | ** FUNCTION(). |
| 16908 | 16939 | ** |
| | @@ -16925,10 +16956,14 @@ |
| 16925 | 16956 | {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \ |
| 16926 | 16957 | SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } |
| 16927 | 16958 | #define MFUNCTION(zName, nArg, xPtr, xFunc) \ |
| 16928 | 16959 | {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \ |
| 16929 | 16960 | xPtr, 0, xFunc, 0, 0, 0, #zName, {0} } |
| 16961 | +#define JFUNCTION(zName, nArg, iArg, xFunc) \ |
| 16962 | + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|\ |
| 16963 | + SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \ |
| 16964 | + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } |
| 16930 | 16965 | #define INLINE_FUNC(zName, nArg, iArg, mFlags) \ |
| 16931 | 16966 | {nArg, SQLITE_FUNC_BUILTIN|\ |
| 16932 | 16967 | SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ |
| 16933 | 16968 | SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } |
| 16934 | 16969 | #define TEST_FUNC(zName, nArg, iArg, mFlags) \ |
| | @@ -18519,10 +18554,12 @@ |
| 18519 | 18554 | TableLock *aTableLock; /* Required table locks for shared-cache mode */ |
| 18520 | 18555 | #endif |
| 18521 | 18556 | AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ |
| 18522 | 18557 | Parse *pToplevel; /* Parse structure for main program (or NULL) */ |
| 18523 | 18558 | Table *pTriggerTab; /* Table triggers are being coded for */ |
| 18559 | + TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ |
| 18560 | + ParseCleanup *pCleanup; /* List of cleanup operations to run after parse */ |
| 18524 | 18561 | union { |
| 18525 | 18562 | int addrCrTab; /* Address of OP_CreateBtree on CREATE TABLE */ |
| 18526 | 18563 | Returning *pReturning; /* The RETURNING clause */ |
| 18527 | 18564 | } u1; |
| 18528 | 18565 | u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ |
| | @@ -18573,13 +18610,11 @@ |
| 18573 | 18610 | const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ |
| 18574 | 18611 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 18575 | 18612 | Token sArg; /* Complete text of a module argument */ |
| 18576 | 18613 | Table **apVtabLock; /* Pointer to virtual tables needing locking */ |
| 18577 | 18614 | #endif |
| 18578 | | - TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ |
| 18579 | 18615 | With *pWith; /* Current WITH clause, or NULL */ |
| 18580 | | - ParseCleanup *pCleanup; /* List of cleanup operations to run after parse */ |
| 18581 | 18616 | #ifndef SQLITE_OMIT_ALTERTABLE |
| 18582 | 18617 | RenameToken *pRename; /* Tokens subject to renaming by ALTER TABLE */ |
| 18583 | 18618 | #endif |
| 18584 | 18619 | }; |
| 18585 | 18620 | |
| | @@ -19366,11 +19401,11 @@ |
| 19366 | 19401 | SQLITE_PRIVATE void sqlite3Dequote(char*); |
| 19367 | 19402 | SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*); |
| 19368 | 19403 | SQLITE_PRIVATE void sqlite3DequoteToken(Token*); |
| 19369 | 19404 | SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*); |
| 19370 | 19405 | SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int); |
| 19371 | | -SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **); |
| 19406 | +SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*); |
| 19372 | 19407 | SQLITE_PRIVATE void sqlite3FinishCoding(Parse*); |
| 19373 | 19408 | SQLITE_PRIVATE int sqlite3GetTempReg(Parse*); |
| 19374 | 19409 | SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int); |
| 19375 | 19410 | SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int); |
| 19376 | 19411 | SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int); |
| | @@ -19646,13 +19681,18 @@ |
| 19646 | 19681 | SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,const IdList*); |
| 19647 | 19682 | SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,const Select*,int); |
| 19648 | 19683 | SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*); |
| 19649 | 19684 | SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int); |
| 19650 | 19685 | SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8); |
| 19686 | +SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum*,sqlite3_value*); |
| 19651 | 19687 | SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void); |
| 19652 | 19688 | SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void); |
| 19689 | +SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void); |
| 19653 | 19690 | SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*); |
| 19691 | +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) |
| 19692 | +SQLITE_PRIVATE int sqlite3JsonTableFunctions(sqlite3*); |
| 19693 | +#endif |
| 19654 | 19694 | SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*); |
| 19655 | 19695 | SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*); |
| 19656 | 19696 | SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int); |
| 19657 | 19697 | SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p); |
| 19658 | 19698 | |
| | @@ -19932,15 +19972,17 @@ |
| 19932 | 19972 | SQLITE_PRIVATE void sqlite3OomClear(sqlite3*); |
| 19933 | 19973 | SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int); |
| 19934 | 19974 | SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *); |
| 19935 | 19975 | |
| 19936 | 19976 | SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int); |
| 19977 | +SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum*, int); |
| 19937 | 19978 | SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*); |
| 19938 | 19979 | SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum*, u8); |
| 19939 | 19980 | SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*); |
| 19940 | 19981 | SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int); |
| 19941 | 19982 | SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); |
| 19983 | +SQLITE_PRIVATE void sqlite3RecordErrorByteOffset(sqlite3*,const char*); |
| 19942 | 19984 | |
| 19943 | 19985 | SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *); |
| 19944 | 19986 | SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); |
| 19945 | 19987 | |
| 19946 | 19988 | #ifndef SQLITE_OMIT_SUBQUERY |
| | @@ -20104,17 +20146,19 @@ |
| 20104 | 20146 | SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*); |
| 20105 | 20147 | SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int); |
| 20106 | 20148 | SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int); |
| 20107 | 20149 | SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*); |
| 20108 | 20150 | SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *); |
| 20151 | +SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3*,int); |
| 20109 | 20152 | #else |
| 20110 | 20153 | #define sqlite3FkActions(a,b,c,d,e,f) |
| 20111 | 20154 | #define sqlite3FkCheck(a,b,c,d,e,f) |
| 20112 | 20155 | #define sqlite3FkDropTable(a,b,c) |
| 20113 | 20156 | #define sqlite3FkOldmask(a,b) 0 |
| 20114 | 20157 | #define sqlite3FkRequired(a,b,c,d) 0 |
| 20115 | 20158 | #define sqlite3FkReferences(a) 0 |
| 20159 | + #define sqlite3FkClearTriggerCache(a,b) |
| 20116 | 20160 | #endif |
| 20117 | 20161 | #ifndef SQLITE_OMIT_FOREIGN_KEY |
| 20118 | 20162 | SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*); |
| 20119 | 20163 | SQLITE_PRIVATE int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**); |
| 20120 | 20164 | #else |
| | @@ -20656,10 +20700,13 @@ |
| 20656 | 20700 | #ifdef SQLITE_DISABLE_FTS4_DEFERRED |
| 20657 | 20701 | "DISABLE_FTS4_DEFERRED", |
| 20658 | 20702 | #endif |
| 20659 | 20703 | #ifdef SQLITE_DISABLE_INTRINSIC |
| 20660 | 20704 | "DISABLE_INTRINSIC", |
| 20705 | +#endif |
| 20706 | +#ifdef SQLITE_DISABLE_JSON |
| 20707 | + "DISABLE_JSON", |
| 20661 | 20708 | #endif |
| 20662 | 20709 | #ifdef SQLITE_DISABLE_LFS |
| 20663 | 20710 | "DISABLE_LFS", |
| 20664 | 20711 | #endif |
| 20665 | 20712 | #ifdef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS |
| | @@ -20735,13 +20782,10 @@ |
| 20735 | 20782 | "ENABLE_ICU", |
| 20736 | 20783 | #endif |
| 20737 | 20784 | #ifdef SQLITE_ENABLE_IOTRACE |
| 20738 | 20785 | "ENABLE_IOTRACE", |
| 20739 | 20786 | #endif |
| 20740 | | -#ifdef SQLITE_ENABLE_JSON1 |
| 20741 | | - "ENABLE_JSON1", |
| 20742 | | -#endif |
| 20743 | 20787 | #ifdef SQLITE_ENABLE_LOAD_EXTENSION |
| 20744 | 20788 | "ENABLE_LOAD_EXTENSION", |
| 20745 | 20789 | #endif |
| 20746 | 20790 | #ifdef SQLITE_ENABLE_LOCKING_STYLE |
| 20747 | 20791 | "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), |
| | @@ -21764,11 +21808,11 @@ |
| 21764 | 21808 | ** * A one-row "pseudotable" stored in a single register |
| 21765 | 21809 | */ |
| 21766 | 21810 | typedef struct VdbeCursor VdbeCursor; |
| 21767 | 21811 | struct VdbeCursor { |
| 21768 | 21812 | u8 eCurType; /* One of the CURTYPE_* values above */ |
| 21769 | | - i8 iDb; /* Index of cursor database in db->aDb[] (or -1) */ |
| 21813 | + i8 iDb; /* Index of cursor database in db->aDb[] */ |
| 21770 | 21814 | u8 nullRow; /* True if pointing to a row with no data */ |
| 21771 | 21815 | u8 deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */ |
| 21772 | 21816 | u8 isTable; /* True for rowid tables. False for indexes */ |
| 21773 | 21817 | #ifdef SQLITE_DEBUG |
| 21774 | 21818 | u8 seekOp; /* Most recent seek operation on this cursor */ |
| | @@ -21777,13 +21821,15 @@ |
| 21777 | 21821 | Bool isEphemeral:1; /* True for an ephemeral table */ |
| 21778 | 21822 | Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */ |
| 21779 | 21823 | Bool isOrdered:1; /* True if the table is not BTREE_UNORDERED */ |
| 21780 | 21824 | Bool hasBeenDuped:1; /* This cursor was source or target of OP_OpenDup */ |
| 21781 | 21825 | u16 seekHit; /* See the OP_SeekHit and OP_IfNoHope opcodes */ |
| 21782 | | - Btree *pBtx; /* Separate file holding temporary table */ |
| 21826 | + union { /* pBtx for isEphermeral. pAltMap otherwise */ |
| 21827 | + Btree *pBtx; /* Separate file holding temporary table */ |
| 21828 | + u32 *aAltMap; /* Mapping from table to index column numbers */ |
| 21829 | + } ub; |
| 21783 | 21830 | i64 seqCount; /* Sequence counter */ |
| 21784 | | - u32 *aAltMap; /* Mapping from table to index column numbers */ |
| 21785 | 21831 | |
| 21786 | 21832 | /* Cached OP_Column parse information is only valid if cacheStatus matches |
| 21787 | 21833 | ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of |
| 21788 | 21834 | ** CACHE_STALE (0) and so setting cacheStatus=CACHE_STALE guarantees that |
| 21789 | 21835 | ** the cache is out of date. */ |
| | @@ -22181,11 +22227,11 @@ |
| 22181 | 22227 | SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor**, u32*); |
| 22182 | 22228 | SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor*); |
| 22183 | 22229 | SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32); |
| 22184 | 22230 | SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8); |
| 22185 | 22231 | SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32); |
| 22186 | | -SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); |
| 22232 | +SQLITE_PRIVATE void sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); |
| 22187 | 22233 | SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int); |
| 22188 | 22234 | |
| 22189 | 22235 | int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); |
| 22190 | 22236 | SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*); |
| 22191 | 22237 | SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*); |
| | @@ -23319,22 +23365,21 @@ |
| 23319 | 23365 | ** |
| 23320 | 23366 | ** Where NNN is an arbitrary floating-point number and "days" can be one |
| 23321 | 23367 | ** of several units of time. |
| 23322 | 23368 | */ |
| 23323 | 23369 | static const struct { |
| 23324 | | - u8 eType; /* Transformation type code */ |
| 23325 | | - u8 nName; /* Length of th name */ |
| 23326 | | - char *zName; /* Name of the transformation */ |
| 23327 | | - double rLimit; /* Maximum NNN value for this transform */ |
| 23328 | | - double rXform; /* Constant used for this transform */ |
| 23370 | + u8 nName; /* Length of the name */ |
| 23371 | + char zName[7]; /* Name of the transformation */ |
| 23372 | + float rLimit; /* Maximum NNN value for this transform */ |
| 23373 | + float rXform; /* Constant used for this transform */ |
| 23329 | 23374 | } aXformType[] = { |
| 23330 | | - { 0, 6, "second", 464269060800.0, 1000.0 }, |
| 23331 | | - { 0, 6, "minute", 7737817680.0, 60000.0 }, |
| 23332 | | - { 0, 4, "hour", 128963628.0, 3600000.0 }, |
| 23333 | | - { 0, 3, "day", 5373485.0, 86400000.0 }, |
| 23334 | | - { 1, 5, "month", 176546.0, 2592000000.0 }, |
| 23335 | | - { 2, 4, "year", 14713.0, 31536000000.0 }, |
| 23375 | + { 6, "second", 4.6427e+14, 1.0 }, |
| 23376 | + { 6, "minute", 7.7379e+12, 60.0 }, |
| 23377 | + { 4, "hour", 1.2897e+11, 3600.0 }, |
| 23378 | + { 3, "day", 5373485.0, 86400.0 }, |
| 23379 | + { 5, "month", 176546.0, 2592000.0 }, |
| 23380 | + { 4, "year", 14713.0, 31536000.0 }, |
| 23336 | 23381 | }; |
| 23337 | 23382 | |
| 23338 | 23383 | /* |
| 23339 | 23384 | ** Process a modifier to a date-time stamp. The modifiers are |
| 23340 | 23385 | ** as follows: |
| | @@ -23567,33 +23612,35 @@ |
| 23567 | 23612 | for(i=0; i<ArraySize(aXformType); i++){ |
| 23568 | 23613 | if( aXformType[i].nName==n |
| 23569 | 23614 | && sqlite3_strnicmp(aXformType[i].zName, z, n)==0 |
| 23570 | 23615 | && r>-aXformType[i].rLimit && r<aXformType[i].rLimit |
| 23571 | 23616 | ){ |
| 23572 | | - switch( aXformType[i].eType ){ |
| 23573 | | - case 1: { /* Special processing to add months */ |
| 23617 | + switch( i ){ |
| 23618 | + case 4: { /* Special processing to add months */ |
| 23574 | 23619 | int x; |
| 23620 | + assert( strcmp(aXformType[i].zName,"month")==0 ); |
| 23575 | 23621 | computeYMD_HMS(p); |
| 23576 | 23622 | p->M += (int)r; |
| 23577 | 23623 | x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; |
| 23578 | 23624 | p->Y += x; |
| 23579 | 23625 | p->M -= x*12; |
| 23580 | 23626 | p->validJD = 0; |
| 23581 | 23627 | r -= (int)r; |
| 23582 | 23628 | break; |
| 23583 | 23629 | } |
| 23584 | | - case 2: { /* Special processing to add years */ |
| 23630 | + case 5: { /* Special processing to add years */ |
| 23585 | 23631 | int y = (int)r; |
| 23632 | + assert( strcmp(aXformType[i].zName,"year")==0 ); |
| 23586 | 23633 | computeYMD_HMS(p); |
| 23587 | 23634 | p->Y += y; |
| 23588 | 23635 | p->validJD = 0; |
| 23589 | 23636 | r -= (int)r; |
| 23590 | 23637 | break; |
| 23591 | 23638 | } |
| 23592 | 23639 | } |
| 23593 | 23640 | computeJD(p); |
| 23594 | | - p->iJD += (sqlite3_int64)(r*aXformType[i].rXform + rRounder); |
| 23641 | + p->iJD += (sqlite3_int64)(r*1000.0*aXformType[i].rXform + rRounder); |
| 23595 | 23642 | rc = 0; |
| 23596 | 23643 | break; |
| 23597 | 23644 | } |
| 23598 | 23645 | } |
| 23599 | 23646 | clearYMD_HMS_TZ(p); |
| | @@ -29835,10 +29882,11 @@ |
| 29835 | 29882 | if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; |
| 29836 | 29883 | pToken = va_arg(ap, Token*); |
| 29837 | 29884 | assert( bArgList==0 ); |
| 29838 | 29885 | if( pToken && pToken->n ){ |
| 29839 | 29886 | sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); |
| 29887 | + sqlite3RecordErrorByteOffset(pAccum->db, pToken->z); |
| 29840 | 29888 | } |
| 29841 | 29889 | length = width = 0; |
| 29842 | 29890 | break; |
| 29843 | 29891 | } |
| 29844 | 29892 | case etSRCITEM: { |
| | @@ -29889,18 +29937,42 @@ |
| 29889 | 29937 | zExtra = 0; |
| 29890 | 29938 | } |
| 29891 | 29939 | }/* End for loop over the format string */ |
| 29892 | 29940 | } /* End of function */ |
| 29893 | 29941 | |
| 29942 | + |
| 29943 | +/* |
| 29944 | +** The z string points to the first character of a token that is |
| 29945 | +** associated with an error. If db does not already have an error |
| 29946 | +** byte offset recorded, try to compute the error byte offset for |
| 29947 | +** z and set the error byte offset in db. |
| 29948 | +*/ |
| 29949 | +SQLITE_PRIVATE void sqlite3RecordErrorByteOffset(sqlite3 *db, const char *z){ |
| 29950 | + const Parse *pParse; |
| 29951 | + const char *zText; |
| 29952 | + const char *zEnd; |
| 29953 | + assert( z!=0 ); |
| 29954 | + if( NEVER(db==0) ) return; |
| 29955 | + if( db->errByteOffset!=(-2) ) return; |
| 29956 | + pParse = db->pParse; |
| 29957 | + if( NEVER(pParse==0) ) return; |
| 29958 | + zText =pParse->zTail; |
| 29959 | + if( NEVER(zText==0) ) return; |
| 29960 | + zEnd = &zText[strlen(zText)]; |
| 29961 | + if( SQLITE_WITHIN(z,zText,zEnd) ){ |
| 29962 | + db->errByteOffset = (int)(z-zText); |
| 29963 | + } |
| 29964 | +} |
| 29965 | + |
| 29894 | 29966 | /* |
| 29895 | 29967 | ** Enlarge the memory allocation on a StrAccum object so that it is |
| 29896 | 29968 | ** able to accept at least N more bytes of text. |
| 29897 | 29969 | ** |
| 29898 | 29970 | ** Return the number of bytes of text that StrAccum is able to accept |
| 29899 | 29971 | ** after the attempted enlargement. The value returned might be zero. |
| 29900 | 29972 | */ |
| 29901 | | -static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ |
| 29973 | +SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, int N){ |
| 29902 | 29974 | char *zNew; |
| 29903 | 29975 | assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */ |
| 29904 | 29976 | if( p->accError ){ |
| 29905 | 29977 | testcase(p->accError==SQLITE_TOOBIG); |
| 29906 | 29978 | testcase(p->accError==SQLITE_NOMEM); |
| | @@ -32212,20 +32284,25 @@ |
| 32212 | 32284 | ** that would be appropriate. |
| 32213 | 32285 | */ |
| 32214 | 32286 | SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){ |
| 32215 | 32287 | assert( db!=0 ); |
| 32216 | 32288 | db->errCode = err_code; |
| 32217 | | - if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code); |
| 32289 | + if( err_code || db->pErr ){ |
| 32290 | + sqlite3ErrorFinish(db, err_code); |
| 32291 | + }else{ |
| 32292 | + db->errByteOffset = -1; |
| 32293 | + } |
| 32218 | 32294 | } |
| 32219 | 32295 | |
| 32220 | 32296 | /* |
| 32221 | 32297 | ** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state |
| 32222 | 32298 | ** and error message. |
| 32223 | 32299 | */ |
| 32224 | 32300 | SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3 *db){ |
| 32225 | 32301 | assert( db!=0 ); |
| 32226 | 32302 | db->errCode = SQLITE_OK; |
| 32303 | + db->errByteOffset = -1; |
| 32227 | 32304 | if( db->pErr ) sqlite3ValueSetNull(db->pErr); |
| 32228 | 32305 | } |
| 32229 | 32306 | |
| 32230 | 32307 | /* |
| 32231 | 32308 | ** Load the sqlite3.iSysErrno field if that is an appropriate thing |
| | @@ -32242,21 +32319,12 @@ |
| 32242 | 32319 | /* |
| 32243 | 32320 | ** Set the most recent error code and error string for the sqlite |
| 32244 | 32321 | ** handle "db". The error code is set to "err_code". |
| 32245 | 32322 | ** |
| 32246 | 32323 | ** If it is not NULL, string zFormat specifies the format of the |
| 32247 | | -** error string in the style of the printf functions: The following |
| 32248 | | -** format characters are allowed: |
| 32249 | | -** |
| 32250 | | -** %s Insert a string |
| 32251 | | -** %z A string that should be freed after use |
| 32252 | | -** %d Insert an integer |
| 32253 | | -** %T Insert a token |
| 32254 | | -** %S Insert the first element of a SrcList |
| 32255 | | -** |
| 32256 | | -** zFormat and any string tokens that follow it are assumed to be |
| 32257 | | -** encoded in UTF-8. |
| 32324 | +** error string. zFormat and any string tokens that follow it are |
| 32325 | +** assumed to be encoded in UTF-8. |
| 32258 | 32326 | ** |
| 32259 | 32327 | ** To clear the most recent error for sqlite handle "db", sqlite3Error |
| 32260 | 32328 | ** should be called with err_code set to SQLITE_OK and zFormat set |
| 32261 | 32329 | ** to NULL. |
| 32262 | 32330 | */ |
| | @@ -32276,17 +32344,10 @@ |
| 32276 | 32344 | } |
| 32277 | 32345 | } |
| 32278 | 32346 | |
| 32279 | 32347 | /* |
| 32280 | 32348 | ** Add an error message to pParse->zErrMsg and increment pParse->nErr. |
| 32281 | | -** The following formatting characters are allowed: |
| 32282 | | -** |
| 32283 | | -** %s Insert a string |
| 32284 | | -** %z A string that should be freed after use |
| 32285 | | -** %d Insert an integer |
| 32286 | | -** %T Insert a token |
| 32287 | | -** %S Insert the first element of a SrcList |
| 32288 | 32349 | ** |
| 32289 | 32350 | ** This function should be used to report any error that occurs while |
| 32290 | 32351 | ** compiling an SQL statement (i.e. within sqlite3_prepare()). The |
| 32291 | 32352 | ** last thing the sqlite3_prepare() function does is copy the error |
| 32292 | 32353 | ** stored by this function into the database handle using sqlite3Error(). |
| | @@ -32295,13 +32356,15 @@ |
| 32295 | 32356 | */ |
| 32296 | 32357 | SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ |
| 32297 | 32358 | char *zMsg; |
| 32298 | 32359 | va_list ap; |
| 32299 | 32360 | sqlite3 *db = pParse->db; |
| 32361 | + db->errByteOffset = -2; |
| 32300 | 32362 | va_start(ap, zFormat); |
| 32301 | 32363 | zMsg = sqlite3VMPrintf(db, zFormat, ap); |
| 32302 | 32364 | va_end(ap); |
| 32365 | + if( db->errByteOffset<-1 ) db->errByteOffset = -1; |
| 32303 | 32366 | if( db->suppressErr ){ |
| 32304 | 32367 | sqlite3DbFree(db, zMsg); |
| 32305 | 32368 | }else{ |
| 32306 | 32369 | pParse->nErr++; |
| 32307 | 32370 | sqlite3DbFree(db, pParse->zErrMsg); |
| | @@ -34211,15 +34274,15 @@ |
| 34211 | 34274 | /* 108 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), |
| 34212 | 34275 | /* 109 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), |
| 34213 | 34276 | /* 110 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), |
| 34214 | 34277 | /* 111 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), |
| 34215 | 34278 | /* 112 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), |
| 34216 | | - /* 113 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), |
| 34217 | | - /* 114 */ "OpenDup" OpHelp(""), |
| 34279 | + /* 113 */ "OpenDup" OpHelp(""), |
| 34280 | + /* 114 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), |
| 34218 | 34281 | /* 115 */ "OpenAutoindex" OpHelp("nColumn=P2"), |
| 34219 | | - /* 116 */ "String8" OpHelp("r[P2]='P4'"), |
| 34220 | | - /* 117 */ "OpenEphemeral" OpHelp("nColumn=P2"), |
| 34282 | + /* 116 */ "OpenEphemeral" OpHelp("nColumn=P2"), |
| 34283 | + /* 117 */ "String8" OpHelp("r[P2]='P4'"), |
| 34221 | 34284 | /* 118 */ "SorterOpen" OpHelp(""), |
| 34222 | 34285 | /* 119 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), |
| 34223 | 34286 | /* 120 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), |
| 34224 | 34287 | /* 121 */ "Close" OpHelp(""), |
| 34225 | 34288 | /* 122 */ "ColumnsUsed" OpHelp(""), |
| | @@ -34250,12 +34313,12 @@ |
| 34250 | 34313 | /* 147 */ "SqlExec" OpHelp(""), |
| 34251 | 34314 | /* 148 */ "ParseSchema" OpHelp(""), |
| 34252 | 34315 | /* 149 */ "LoadAnalysis" OpHelp(""), |
| 34253 | 34316 | /* 150 */ "DropTable" OpHelp(""), |
| 34254 | 34317 | /* 151 */ "DropIndex" OpHelp(""), |
| 34255 | | - /* 152 */ "Real" OpHelp("r[P2]=P4"), |
| 34256 | | - /* 153 */ "DropTrigger" OpHelp(""), |
| 34318 | + /* 152 */ "DropTrigger" OpHelp(""), |
| 34319 | + /* 153 */ "Real" OpHelp("r[P2]=P4"), |
| 34257 | 34320 | /* 154 */ "IntegrityCk" OpHelp(""), |
| 34258 | 34321 | /* 155 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), |
| 34259 | 34322 | /* 156 */ "Param" OpHelp(""), |
| 34260 | 34323 | /* 157 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), |
| 34261 | 34324 | /* 158 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), |
| | @@ -56614,12 +56677,11 @@ |
| 56614 | 56677 | ** |
| 56615 | 56678 | ** a) The page number is less than or equal to the size of the |
| 56616 | 56679 | ** current database image, in pages, OR |
| 56617 | 56680 | ** |
| 56618 | 56681 | ** b) if the page content were written at this time, it would not |
| 56619 | | -** be necessary to write the current content out to the sub-journal |
| 56620 | | -** (as determined by function subjRequiresPage()). |
| 56682 | +** be necessary to write the current content out to the sub-journal. |
| 56621 | 56683 | ** |
| 56622 | 56684 | ** If the condition asserted by this function were not true, and the |
| 56623 | 56685 | ** dirty page were to be discarded from the cache via the pagerStress() |
| 56624 | 56686 | ** routine, pagerStress() would not write the current page content to |
| 56625 | 56687 | ** the database file. If a savepoint transaction were rolled back after |
| | @@ -56630,12 +56692,20 @@ |
| 56630 | 56692 | ** database image would become corrupt. It is therefore fortunate that |
| 56631 | 56693 | ** this circumstance cannot arise. |
| 56632 | 56694 | */ |
| 56633 | 56695 | #if defined(SQLITE_DEBUG) |
| 56634 | 56696 | static void assertTruncateConstraintCb(PgHdr *pPg){ |
| 56697 | + Pager *pPager = pPg->pPager; |
| 56635 | 56698 | assert( pPg->flags&PGHDR_DIRTY ); |
| 56636 | | - assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize ); |
| 56699 | + if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */ |
| 56700 | + Pgno pgno = pPg->pgno; |
| 56701 | + int i; |
| 56702 | + for(i=0; i<pPg->pPager->nSavepoint; i++){ |
| 56703 | + PagerSavepoint *p = &pPager->aSavepoint[i]; |
| 56704 | + assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,pgno) ); |
| 56705 | + } |
| 56706 | + } |
| 56637 | 56707 | } |
| 56638 | 56708 | static void assertTruncateConstraint(Pager *pPager){ |
| 56639 | 56709 | sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb); |
| 56640 | 56710 | } |
| 56641 | 56711 | #else |
| | @@ -57972,11 +58042,11 @@ |
| 57972 | 58042 | ** other connection managed to get in and roll it back before |
| 57973 | 58043 | ** this connection obtained the exclusive lock above. Or, it |
| 57974 | 58044 | ** may mean that the pager was in the error-state when this |
| 57975 | 58045 | ** function was called and the journal file does not exist. |
| 57976 | 58046 | */ |
| 57977 | | - if( !isOpen(pPager->jfd) ){ |
| 58047 | + if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ |
| 57978 | 58048 | sqlite3_vfs * const pVfs = pPager->pVfs; |
| 57979 | 58049 | int bExists; /* True if journal file exists */ |
| 57980 | 58050 | rc = sqlite3OsAccess( |
| 57981 | 58051 | pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists); |
| 57982 | 58052 | if( rc==SQLITE_OK && bExists ){ |
| | @@ -58374,10 +58444,11 @@ |
| 58374 | 58444 | Pager *pPager, /* The pager open on the database file */ |
| 58375 | 58445 | Pgno pgno, /* Page number to fetch */ |
| 58376 | 58446 | DbPage **ppPage, /* Write a pointer to the page here */ |
| 58377 | 58447 | int flags /* PAGER_GET_XXX flags */ |
| 58378 | 58448 | ){ |
| 58449 | + /* printf("PAGE %u\n", pgno); fflush(stdout); */ |
| 58379 | 58450 | return pPager->xGet(pPager, pgno, ppPage, flags); |
| 58380 | 58451 | } |
| 58381 | 58452 | |
| 58382 | 58453 | /* |
| 58383 | 58454 | ** Acquire a page if it is already in the in-memory cache. Do |
| | @@ -59979,16 +60050,16 @@ |
| 59979 | 60050 | */ |
| 59980 | 60051 | SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){ |
| 59981 | 60052 | u8 eOld = pPager->journalMode; /* Prior journalmode */ |
| 59982 | 60053 | |
| 59983 | 60054 | /* The eMode parameter is always valid */ |
| 59984 | | - assert( eMode==PAGER_JOURNALMODE_DELETE |
| 59985 | | - || eMode==PAGER_JOURNALMODE_TRUNCATE |
| 59986 | | - || eMode==PAGER_JOURNALMODE_PERSIST |
| 59987 | | - || eMode==PAGER_JOURNALMODE_OFF |
| 59988 | | - || eMode==PAGER_JOURNALMODE_WAL |
| 59989 | | - || eMode==PAGER_JOURNALMODE_MEMORY ); |
| 60055 | + assert( eMode==PAGER_JOURNALMODE_DELETE /* 0 */ |
| 60056 | + || eMode==PAGER_JOURNALMODE_PERSIST /* 1 */ |
| 60057 | + || eMode==PAGER_JOURNALMODE_OFF /* 2 */ |
| 60058 | + || eMode==PAGER_JOURNALMODE_TRUNCATE /* 3 */ |
| 60059 | + || eMode==PAGER_JOURNALMODE_MEMORY /* 4 */ |
| 60060 | + || eMode==PAGER_JOURNALMODE_WAL /* 5 */ ); |
| 59990 | 60061 | |
| 59991 | 60062 | /* This routine is only called from the OP_JournalMode opcode, and |
| 59992 | 60063 | ** the logic there will never allow a temporary file to be changed |
| 59993 | 60064 | ** to WAL mode. |
| 59994 | 60065 | */ |
| | @@ -60021,11 +60092,10 @@ |
| 60021 | 60092 | assert( (PAGER_JOURNALMODE_OFF & 5)==0 ); |
| 60022 | 60093 | assert( (PAGER_JOURNALMODE_WAL & 5)==5 ); |
| 60023 | 60094 | |
| 60024 | 60095 | assert( isOpen(pPager->fd) || pPager->exclusiveMode ); |
| 60025 | 60096 | if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){ |
| 60026 | | - |
| 60027 | 60097 | /* In this case we would like to delete the journal file. If it is |
| 60028 | 60098 | ** not possible, then that is not a problem. Deleting the journal file |
| 60029 | 60099 | ** here is an optimization only. |
| 60030 | 60100 | ** |
| 60031 | 60101 | ** Before deleting the journal file, obtain a RESERVED lock on the |
| | @@ -66854,32 +66924,46 @@ |
| 66854 | 66924 | |
| 66855 | 66925 | /* The next block of code is equivalent to: |
| 66856 | 66926 | ** |
| 66857 | 66927 | ** pIter += getVarint(pIter, (u64*)&pInfo->nKey); |
| 66858 | 66928 | ** |
| 66859 | | - ** The code is inlined to avoid a function call. |
| 66929 | + ** The code is inlined and the loop is unrolled for performance. |
| 66930 | + ** This routine is a high-runner. |
| 66860 | 66931 | */ |
| 66861 | 66932 | iKey = *pIter; |
| 66862 | 66933 | if( iKey>=0x80 ){ |
| 66863 | | - u8 *pEnd = &pIter[7]; |
| 66864 | | - iKey &= 0x7f; |
| 66865 | | - while(1){ |
| 66866 | | - iKey = (iKey<<7) | (*++pIter & 0x7f); |
| 66867 | | - if( (*pIter)<0x80 ) break; |
| 66868 | | - if( pIter>=pEnd ){ |
| 66869 | | - iKey = (iKey<<8) | *++pIter; |
| 66870 | | - break; |
| 66934 | + u8 x; |
| 66935 | + iKey = ((iKey&0x7f)<<7) | ((x = *++pIter) & 0x7f); |
| 66936 | + if( x>=0x80 ){ |
| 66937 | + iKey = (iKey<<7) | ((x =*++pIter) & 0x7f); |
| 66938 | + if( x>=0x80 ){ |
| 66939 | + iKey = (iKey<<7) | ((x = *++pIter) & 0x7f); |
| 66940 | + if( x>=0x80 ){ |
| 66941 | + iKey = (iKey<<7) | ((x = *++pIter) & 0x7f); |
| 66942 | + if( x>=0x80 ){ |
| 66943 | + iKey = (iKey<<7) | ((x = *++pIter) & 0x7f); |
| 66944 | + if( x>=0x80 ){ |
| 66945 | + iKey = (iKey<<7) | ((x = *++pIter) & 0x7f); |
| 66946 | + if( x>=0x80 ){ |
| 66947 | + iKey = (iKey<<7) | ((x = *++pIter) & 0x7f); |
| 66948 | + if( x>=0x80 ){ |
| 66949 | + iKey = (iKey<<8) | (*++pIter); |
| 66950 | + } |
| 66951 | + } |
| 66952 | + } |
| 66953 | + } |
| 66954 | + } |
| 66871 | 66955 | } |
| 66872 | 66956 | } |
| 66873 | 66957 | } |
| 66874 | 66958 | pIter++; |
| 66875 | 66959 | |
| 66876 | 66960 | pInfo->nKey = *(i64*)&iKey; |
| 66877 | 66961 | pInfo->nPayload = nPayload; |
| 66878 | 66962 | pInfo->pPayload = pIter; |
| 66879 | 66963 | testcase( nPayload==pPage->maxLocal ); |
| 66880 | | - testcase( nPayload==pPage->maxLocal+1 ); |
| 66964 | + testcase( nPayload==(u32)pPage->maxLocal+1 ); |
| 66881 | 66965 | if( nPayload<=pPage->maxLocal ){ |
| 66882 | 66966 | /* This is the (easy) common case where the entire payload fits |
| 66883 | 66967 | ** on the local page. No overflow is required. |
| 66884 | 66968 | */ |
| 66885 | 66969 | pInfo->nSize = nPayload + (u16)(pIter - pCell); |
| | @@ -66912,11 +66996,11 @@ |
| 66912 | 66996 | pIter++; |
| 66913 | 66997 | pInfo->nKey = nPayload; |
| 66914 | 66998 | pInfo->nPayload = nPayload; |
| 66915 | 66999 | pInfo->pPayload = pIter; |
| 66916 | 67000 | testcase( nPayload==pPage->maxLocal ); |
| 66917 | | - testcase( nPayload==pPage->maxLocal+1 ); |
| 67001 | + testcase( nPayload==(u32)pPage->maxLocal+1 ); |
| 66918 | 67002 | if( nPayload<=pPage->maxLocal ){ |
| 66919 | 67003 | /* This is the (easy) common case where the entire payload fits |
| 66920 | 67004 | ** on the local page. No overflow is required. |
| 66921 | 67005 | */ |
| 66922 | 67006 | pInfo->nSize = nPayload + (u16)(pIter - pCell); |
| | @@ -66975,19 +67059,19 @@ |
| 66975 | 67059 | ** past the end of the key value. */ |
| 66976 | 67060 | pEnd = &pIter[9]; |
| 66977 | 67061 | while( (*pIter++)&0x80 && pIter<pEnd ); |
| 66978 | 67062 | } |
| 66979 | 67063 | testcase( nSize==pPage->maxLocal ); |
| 66980 | | - testcase( nSize==pPage->maxLocal+1 ); |
| 67064 | + testcase( nSize==(u32)pPage->maxLocal+1 ); |
| 66981 | 67065 | if( nSize<=pPage->maxLocal ){ |
| 66982 | 67066 | nSize += (u32)(pIter - pCell); |
| 66983 | 67067 | if( nSize<4 ) nSize = 4; |
| 66984 | 67068 | }else{ |
| 66985 | 67069 | int minLocal = pPage->minLocal; |
| 66986 | 67070 | nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); |
| 66987 | 67071 | testcase( nSize==pPage->maxLocal ); |
| 66988 | | - testcase( nSize==pPage->maxLocal+1 ); |
| 67072 | + testcase( nSize==(u32)pPage->maxLocal+1 ); |
| 66989 | 67073 | if( nSize>pPage->maxLocal ){ |
| 66990 | 67074 | nSize = minLocal; |
| 66991 | 67075 | } |
| 66992 | 67076 | nSize += 4 + (u16)(pIter - pCell); |
| 66993 | 67077 | } |
| | @@ -69882,11 +69966,11 @@ |
| 69882 | 69966 | */ |
| 69883 | 69967 | static void btreeSetNPage(BtShared *pBt, MemPage *pPage1){ |
| 69884 | 69968 | int nPage = get4byte(&pPage1->aData[28]); |
| 69885 | 69969 | testcase( nPage==0 ); |
| 69886 | 69970 | if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); |
| 69887 | | - testcase( pBt->nPage!=nPage ); |
| 69971 | + testcase( pBt->nPage!=(u32)nPage ); |
| 69888 | 69972 | pBt->nPage = nPage; |
| 69889 | 69973 | } |
| 69890 | 69974 | |
| 69891 | 69975 | /* |
| 69892 | 69976 | ** Rollback the transaction in progress. |
| | @@ -70903,11 +70987,11 @@ |
| 70903 | 70987 | if( pCur->iPage ){ |
| 70904 | 70988 | releasePageNotNull(pCur->pPage); |
| 70905 | 70989 | while( --pCur->iPage ){ |
| 70906 | 70990 | releasePageNotNull(pCur->apPage[pCur->iPage]); |
| 70907 | 70991 | } |
| 70908 | | - pCur->pPage = pCur->apPage[0]; |
| 70992 | + pRoot = pCur->pPage = pCur->apPage[0]; |
| 70909 | 70993 | goto skip_init; |
| 70910 | 70994 | } |
| 70911 | 70995 | }else if( pCur->pgnoRoot==0 ){ |
| 70912 | 70996 | pCur->eState = CURSOR_INVALID; |
| 70913 | 70997 | return SQLITE_EMPTY; |
| | @@ -70950,11 +71034,10 @@ |
| 70950 | 71034 | skip_init: |
| 70951 | 71035 | pCur->ix = 0; |
| 70952 | 71036 | pCur->info.nSize = 0; |
| 70953 | 71037 | pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl); |
| 70954 | 71038 | |
| 70955 | | - pRoot = pCur->pPage; |
| 70956 | 71039 | if( pRoot->nCell>0 ){ |
| 70957 | 71040 | pCur->eState = CURSOR_VALID; |
| 70958 | 71041 | }else if( !pRoot->leaf ){ |
| 70959 | 71042 | Pgno subpage; |
| 70960 | 71043 | if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT; |
| | @@ -71191,11 +71274,10 @@ |
| 71191 | 71274 | assert( pPage->intKey ); |
| 71192 | 71275 | lwr = 0; |
| 71193 | 71276 | upr = pPage->nCell-1; |
| 71194 | 71277 | assert( biasRight==0 || biasRight==1 ); |
| 71195 | 71278 | idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ |
| 71196 | | - pCur->ix = (u16)idx; |
| 71197 | 71279 | for(;;){ |
| 71198 | 71280 | i64 nCellKey; |
| 71199 | 71281 | pCell = findCellPastPtr(pPage, idx); |
| 71200 | 71282 | if( pPage->intKeyLeaf ){ |
| 71201 | 71283 | while( 0x80 <= *(pCell++) ){ |
| | @@ -71333,11 +71415,10 @@ |
| 71333 | 71415 | assert( pPage->nCell>0 ); |
| 71334 | 71416 | assert( pPage->intKey==(pIdxKey==0) ); |
| 71335 | 71417 | lwr = 0; |
| 71336 | 71418 | upr = pPage->nCell-1; |
| 71337 | 71419 | idx = upr>>1; /* idx = (lwr+upr)/2; */ |
| 71338 | | - pCur->ix = (u16)idx; |
| 71339 | 71420 | for(;;){ |
| 71340 | 71421 | int nCell; /* Size of the pCell cell in bytes */ |
| 71341 | 71422 | pCell = findCellPastPtr(pPage, idx); |
| 71342 | 71423 | |
| 71343 | 71424 | /* The maximum supported page-size is 65536 bytes. This means that |
| | @@ -72449,20 +72530,22 @@ |
| 72449 | 72530 | u8 *ptr; /* Used to move bytes around within data[] */ |
| 72450 | 72531 | int rc; /* The return code */ |
| 72451 | 72532 | int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */ |
| 72452 | 72533 | |
| 72453 | 72534 | if( *pRC ) return; |
| 72454 | | - assert( idx>=0 && idx<pPage->nCell ); |
| 72535 | + assert( idx>=0 ); |
| 72536 | + assert( idx<pPage->nCell ); |
| 72455 | 72537 | assert( CORRUPT_DB || sz==cellSize(pPage, idx) ); |
| 72456 | 72538 | assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| 72457 | 72539 | assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| 72458 | 72540 | assert( pPage->nFree>=0 ); |
| 72459 | 72541 | data = pPage->aData; |
| 72460 | 72542 | ptr = &pPage->aCellIdx[2*idx]; |
| 72543 | + assert( pPage->pBt->usableSize > (u32)(ptr-data) ); |
| 72461 | 72544 | pc = get2byte(ptr); |
| 72462 | 72545 | hdr = pPage->hdrOffset; |
| 72463 | | - testcase( pc==get2byte(&data[hdr+5]) ); |
| 72546 | + testcase( pc==(u32)get2byte(&data[hdr+5]) ); |
| 72464 | 72547 | testcase( pc+sz==pPage->pBt->usableSize ); |
| 72465 | 72548 | if( pc+sz > pPage->pBt->usableSize ){ |
| 72466 | 72549 | *pRC = SQLITE_CORRUPT_BKPT; |
| 72467 | 72550 | return; |
| 72468 | 72551 | } |
| | @@ -72750,11 +72833,11 @@ |
| 72750 | 72833 | int k; /* Current slot in pCArray->apEnd[] */ |
| 72751 | 72834 | u8 *pSrcEnd; /* Current pCArray->apEnd[k] value */ |
| 72752 | 72835 | |
| 72753 | 72836 | assert( i<iEnd ); |
| 72754 | 72837 | j = get2byte(&aData[hdr+5]); |
| 72755 | | - if( NEVER(j>(u32)usableSize) ){ j = 0; } |
| 72838 | + if( j>(u32)usableSize ){ j = 0; } |
| 72756 | 72839 | memcpy(&pTmp[j], &aData[j], usableSize - j); |
| 72757 | 72840 | |
| 72758 | 72841 | for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){} |
| 72759 | 72842 | pSrcEnd = pCArray->apEnd[k]; |
| 72760 | 72843 | |
| | @@ -72981,11 +73064,11 @@ |
| 72981 | 73064 | nCell -= nTail; |
| 72982 | 73065 | } |
| 72983 | 73066 | |
| 72984 | 73067 | pData = &aData[get2byteNotZero(&aData[hdr+5])]; |
| 72985 | 73068 | if( pData<pBegin ) goto editpage_fail; |
| 72986 | | - if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail; |
| 73069 | + if( pData>pPg->aDataEnd ) goto editpage_fail; |
| 72987 | 73070 | |
| 72988 | 73071 | /* Add cells to the start of the page */ |
| 72989 | 73072 | if( iNew<iOld ){ |
| 72990 | 73073 | int nAdd = MIN(nNew,iOld-iNew); |
| 72991 | 73074 | assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB ); |
| | @@ -74857,18 +74940,17 @@ |
| 74857 | 74940 | ** but which might be used by alternative storage engines. |
| 74858 | 74941 | */ |
| 74859 | 74942 | SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ |
| 74860 | 74943 | Btree *p = pCur->pBtree; |
| 74861 | 74944 | BtShared *pBt = p->pBt; |
| 74862 | | - int rc; /* Return code */ |
| 74863 | | - MemPage *pPage; /* Page to delete cell from */ |
| 74864 | | - unsigned char *pCell; /* Pointer to cell to delete */ |
| 74865 | | - int iCellIdx; /* Index of cell to delete */ |
| 74866 | | - int iCellDepth; /* Depth of node containing pCell */ |
| 74867 | | - CellInfo info; /* Size of the cell being deleted */ |
| 74868 | | - int bSkipnext = 0; /* Leaf cursor in SKIPNEXT state */ |
| 74869 | | - u8 bPreserve = flags & BTREE_SAVEPOSITION; /* Keep cursor valid */ |
| 74945 | + int rc; /* Return code */ |
| 74946 | + MemPage *pPage; /* Page to delete cell from */ |
| 74947 | + unsigned char *pCell; /* Pointer to cell to delete */ |
| 74948 | + int iCellIdx; /* Index of cell to delete */ |
| 74949 | + int iCellDepth; /* Depth of node containing pCell */ |
| 74950 | + CellInfo info; /* Size of the cell being deleted */ |
| 74951 | + u8 bPreserve; /* Keep cursor valid. 2 for CURSOR_SKIPNEXT */ |
| 74870 | 74952 | |
| 74871 | 74953 | assert( cursorOwnsBtShared(pCur) ); |
| 74872 | 74954 | assert( pBt->inTransaction==TRANS_WRITE ); |
| 74873 | 74955 | assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); |
| 74874 | 74956 | assert( pCur->curFlags & BTCF_WriteFlag ); |
| | @@ -74883,22 +74965,35 @@ |
| 74883 | 74965 | assert( CORRUPT_DB || pCur->eState==CURSOR_VALID ); |
| 74884 | 74966 | |
| 74885 | 74967 | iCellDepth = pCur->iPage; |
| 74886 | 74968 | iCellIdx = pCur->ix; |
| 74887 | 74969 | pPage = pCur->pPage; |
| 74970 | + if( pPage->nCell<=iCellIdx ){ |
| 74971 | + return SQLITE_CORRUPT_BKPT; |
| 74972 | + } |
| 74888 | 74973 | pCell = findCell(pPage, iCellIdx); |
| 74889 | | - if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ) return SQLITE_CORRUPT; |
| 74974 | + if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){ |
| 74975 | + return SQLITE_CORRUPT_BKPT; |
| 74976 | + } |
| 74890 | 74977 | |
| 74891 | | - /* If the bPreserve flag is set to true, then the cursor position must |
| 74978 | + /* If the BTREE_SAVEPOSITION bit is on, then the cursor position must |
| 74892 | 74979 | ** be preserved following this delete operation. If the current delete |
| 74893 | 74980 | ** will cause a b-tree rebalance, then this is done by saving the cursor |
| 74894 | 74981 | ** key and leaving the cursor in CURSOR_REQUIRESEEK state before |
| 74895 | 74982 | ** returning. |
| 74896 | 74983 | ** |
| 74897 | | - ** Or, if the current delete will not cause a rebalance, then the cursor |
| 74984 | + ** If the current delete will not cause a rebalance, then the cursor |
| 74898 | 74985 | ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately |
| 74899 | | - ** before or after the deleted entry. In this case set bSkipnext to true. */ |
| 74986 | + ** before or after the deleted entry. |
| 74987 | + ** |
| 74988 | + ** The bPreserve value records which path is required: |
| 74989 | + ** |
| 74990 | + ** bPreserve==0 Not necessary to save the cursor position |
| 74991 | + ** bPreserve==1 Use CURSOR_REQUIRESEEK to save the cursor position |
| 74992 | + ** bPreserve==2 Cursor won't move. Set CURSOR_SKIPNEXT. |
| 74993 | + */ |
| 74994 | + bPreserve = (flags & BTREE_SAVEPOSITION)!=0; |
| 74900 | 74995 | if( bPreserve ){ |
| 74901 | 74996 | if( !pPage->leaf |
| 74902 | 74997 | || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3) |
| 74903 | 74998 | || pPage->nCell==1 /* See dbfuzz001.test for a test case */ |
| 74904 | 74999 | ){ |
| | @@ -74905,11 +75000,11 @@ |
| 74905 | 75000 | /* A b-tree rebalance will be required after deleting this entry. |
| 74906 | 75001 | ** Save the cursor key. */ |
| 74907 | 75002 | rc = saveCursorKey(pCur); |
| 74908 | 75003 | if( rc ) return rc; |
| 74909 | 75004 | }else{ |
| 74910 | | - bSkipnext = 1; |
| 75005 | + bPreserve = 2; |
| 74911 | 75006 | } |
| 74912 | 75007 | } |
| 74913 | 75008 | |
| 74914 | 75009 | /* If the page containing the entry to delete is not a leaf page, move |
| 74915 | 75010 | ** the cursor to the largest entry in the tree that is smaller than |
| | @@ -75005,12 +75100,12 @@ |
| 75005 | 75100 | pCur->pPage = pCur->apPage[pCur->iPage]; |
| 75006 | 75101 | rc = balance(pCur); |
| 75007 | 75102 | } |
| 75008 | 75103 | |
| 75009 | 75104 | if( rc==SQLITE_OK ){ |
| 75010 | | - if( bSkipnext ){ |
| 75011 | | - assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) ); |
| 75105 | + if( bPreserve>1 ){ |
| 75106 | + assert( (pCur->iPage==iCellDepth || CORRUPT_DB) ); |
| 75012 | 75107 | assert( pPage==pCur->pPage || CORRUPT_DB ); |
| 75013 | 75108 | assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell ); |
| 75014 | 75109 | pCur->eState = CURSOR_SKIPNEXT; |
| 75015 | 75110 | if( iCellIdx>=pPage->nCell ){ |
| 75016 | 75111 | pCur->skipNext = -1; |
| | @@ -81704,12 +81799,10 @@ |
| 81704 | 81799 | */ |
| 81705 | 81800 | SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ |
| 81706 | 81801 | if( pCx==0 ){ |
| 81707 | 81802 | return; |
| 81708 | 81803 | } |
| 81709 | | - assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE ); |
| 81710 | | - assert( pCx->pBtx==0 || pCx->isEphemeral ); |
| 81711 | 81804 | switch( pCx->eCurType ){ |
| 81712 | 81805 | case CURTYPE_SORTER: { |
| 81713 | 81806 | sqlite3VdbeSorterClose(p->db, pCx); |
| 81714 | 81807 | break; |
| 81715 | 81808 | } |
| | @@ -82807,11 +82900,11 @@ |
| 82807 | 82900 | VdbeCursor *p = *pp; |
| 82808 | 82901 | assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO ); |
| 82809 | 82902 | if( p->deferredMoveto ){ |
| 82810 | 82903 | u32 iMap; |
| 82811 | 82904 | assert( !p->isEphemeral ); |
| 82812 | | - if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 && !p->nullRow ){ |
| 82905 | + if( p->ub.aAltMap && (iMap = p->ub.aAltMap[1+*piCol])>0 && !p->nullRow ){ |
| 82813 | 82906 | *pp = p->pAltCursor; |
| 82814 | 82907 | *piCol = iMap - 1; |
| 82815 | 82908 | return SQLITE_OK; |
| 82816 | 82909 | } |
| 82817 | 82910 | return sqlite3VdbeFinishMoveto(p); |
| | @@ -83085,18 +83178,18 @@ |
| 83085 | 83178 | #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) |
| 83086 | 83179 | #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) |
| 83087 | 83180 | |
| 83088 | 83181 | /* |
| 83089 | 83182 | ** Deserialize the data blob pointed to by buf as serial type serial_type |
| 83090 | | -** and store the result in pMem. Return the number of bytes read. |
| 83183 | +** and store the result in pMem. |
| 83091 | 83184 | ** |
| 83092 | 83185 | ** This function is implemented as two separate routines for performance. |
| 83093 | 83186 | ** The few cases that require local variables are broken out into a separate |
| 83094 | 83187 | ** routine so that in most cases the overhead of moving the stack pointer |
| 83095 | 83188 | ** is avoided. |
| 83096 | 83189 | */ |
| 83097 | | -static u32 serialGet( |
| 83190 | +static void serialGet( |
| 83098 | 83191 | const unsigned char *buf, /* Buffer to deserialize from */ |
| 83099 | 83192 | u32 serial_type, /* Serial type to deserialize */ |
| 83100 | 83193 | Mem *pMem /* Memory cell to write value into */ |
| 83101 | 83194 | ){ |
| 83102 | 83195 | u64 x = FOUR_BYTE_UINT(buf); |
| | @@ -83126,13 +83219,12 @@ |
| 83126 | 83219 | assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 ); |
| 83127 | 83220 | swapMixedEndianFloat(x); |
| 83128 | 83221 | memcpy(&pMem->u.r, &x, sizeof(x)); |
| 83129 | 83222 | pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real; |
| 83130 | 83223 | } |
| 83131 | | - return 8; |
| 83132 | 83224 | } |
| 83133 | | -SQLITE_PRIVATE u32 sqlite3VdbeSerialGet( |
| 83225 | +SQLITE_PRIVATE void sqlite3VdbeSerialGet( |
| 83134 | 83226 | const unsigned char *buf, /* Buffer to deserialize from */ |
| 83135 | 83227 | u32 serial_type, /* Serial type to deserialize */ |
| 83136 | 83228 | Mem *pMem /* Memory cell to write value into */ |
| 83137 | 83229 | ){ |
| 83138 | 83230 | switch( serial_type ){ |
| | @@ -83139,41 +83231,41 @@ |
| 83139 | 83231 | case 10: { /* Internal use only: NULL with virtual table |
| 83140 | 83232 | ** UPDATE no-change flag set */ |
| 83141 | 83233 | pMem->flags = MEM_Null|MEM_Zero; |
| 83142 | 83234 | pMem->n = 0; |
| 83143 | 83235 | pMem->u.nZero = 0; |
| 83144 | | - break; |
| 83236 | + return; |
| 83145 | 83237 | } |
| 83146 | 83238 | case 11: /* Reserved for future use */ |
| 83147 | 83239 | case 0: { /* Null */ |
| 83148 | 83240 | /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */ |
| 83149 | 83241 | pMem->flags = MEM_Null; |
| 83150 | | - break; |
| 83242 | + return; |
| 83151 | 83243 | } |
| 83152 | 83244 | case 1: { |
| 83153 | 83245 | /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement |
| 83154 | 83246 | ** integer. */ |
| 83155 | 83247 | pMem->u.i = ONE_BYTE_INT(buf); |
| 83156 | 83248 | pMem->flags = MEM_Int; |
| 83157 | 83249 | testcase( pMem->u.i<0 ); |
| 83158 | | - return 1; |
| 83250 | + return; |
| 83159 | 83251 | } |
| 83160 | 83252 | case 2: { /* 2-byte signed integer */ |
| 83161 | 83253 | /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit |
| 83162 | 83254 | ** twos-complement integer. */ |
| 83163 | 83255 | pMem->u.i = TWO_BYTE_INT(buf); |
| 83164 | 83256 | pMem->flags = MEM_Int; |
| 83165 | 83257 | testcase( pMem->u.i<0 ); |
| 83166 | | - return 2; |
| 83258 | + return; |
| 83167 | 83259 | } |
| 83168 | 83260 | case 3: { /* 3-byte signed integer */ |
| 83169 | 83261 | /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit |
| 83170 | 83262 | ** twos-complement integer. */ |
| 83171 | 83263 | pMem->u.i = THREE_BYTE_INT(buf); |
| 83172 | 83264 | pMem->flags = MEM_Int; |
| 83173 | 83265 | testcase( pMem->u.i<0 ); |
| 83174 | | - return 3; |
| 83266 | + return; |
| 83175 | 83267 | } |
| 83176 | 83268 | case 4: { /* 4-byte signed integer */ |
| 83177 | 83269 | /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit |
| 83178 | 83270 | ** twos-complement integer. */ |
| 83179 | 83271 | pMem->u.i = FOUR_BYTE_INT(buf); |
| | @@ -83181,33 +83273,34 @@ |
| 83181 | 83273 | /* Work around a sign-extension bug in the HP compiler for HP/UX */ |
| 83182 | 83274 | if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL; |
| 83183 | 83275 | #endif |
| 83184 | 83276 | pMem->flags = MEM_Int; |
| 83185 | 83277 | testcase( pMem->u.i<0 ); |
| 83186 | | - return 4; |
| 83278 | + return; |
| 83187 | 83279 | } |
| 83188 | 83280 | case 5: { /* 6-byte signed integer */ |
| 83189 | 83281 | /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit |
| 83190 | 83282 | ** twos-complement integer. */ |
| 83191 | 83283 | pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf); |
| 83192 | 83284 | pMem->flags = MEM_Int; |
| 83193 | 83285 | testcase( pMem->u.i<0 ); |
| 83194 | | - return 6; |
| 83286 | + return; |
| 83195 | 83287 | } |
| 83196 | 83288 | case 6: /* 8-byte signed integer */ |
| 83197 | 83289 | case 7: { /* IEEE floating point */ |
| 83198 | 83290 | /* These use local variables, so do them in a separate routine |
| 83199 | 83291 | ** to avoid having to move the frame pointer in the common case */ |
| 83200 | | - return serialGet(buf,serial_type,pMem); |
| 83292 | + serialGet(buf,serial_type,pMem); |
| 83293 | + return; |
| 83201 | 83294 | } |
| 83202 | 83295 | case 8: /* Integer 0 */ |
| 83203 | 83296 | case 9: { /* Integer 1 */ |
| 83204 | 83297 | /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */ |
| 83205 | 83298 | /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */ |
| 83206 | 83299 | pMem->u.i = serial_type-8; |
| 83207 | 83300 | pMem->flags = MEM_Int; |
| 83208 | | - return 0; |
| 83301 | + return; |
| 83209 | 83302 | } |
| 83210 | 83303 | default: { |
| 83211 | 83304 | /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in |
| 83212 | 83305 | ** length. |
| 83213 | 83306 | ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and |
| | @@ -83214,14 +83307,14 @@ |
| 83214 | 83307 | ** (N-13)/2 bytes in length. */ |
| 83215 | 83308 | static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem }; |
| 83216 | 83309 | pMem->z = (char *)buf; |
| 83217 | 83310 | pMem->n = (serial_type-12)/2; |
| 83218 | 83311 | pMem->flags = aFlag[serial_type&1]; |
| 83219 | | - return pMem->n; |
| 83312 | + return; |
| 83220 | 83313 | } |
| 83221 | 83314 | } |
| 83222 | | - return 0; |
| 83315 | + return; |
| 83223 | 83316 | } |
| 83224 | 83317 | /* |
| 83225 | 83318 | ** This routine is used to allocate sufficient space for an UnpackedRecord |
| 83226 | 83319 | ** structure large enough to be used with sqlite3VdbeRecordUnpack() if |
| 83227 | 83320 | ** the first argument is a pointer to KeyInfo structure pKeyInfo. |
| | @@ -83280,11 +83373,12 @@ |
| 83280 | 83373 | pMem->enc = pKeyInfo->enc; |
| 83281 | 83374 | pMem->db = pKeyInfo->db; |
| 83282 | 83375 | /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */ |
| 83283 | 83376 | pMem->szMalloc = 0; |
| 83284 | 83377 | pMem->z = 0; |
| 83285 | | - d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); |
| 83378 | + sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); |
| 83379 | + d += sqlite3VdbeSerialTypeLen(serial_type); |
| 83286 | 83380 | pMem++; |
| 83287 | 83381 | if( (++u)>=p->nField ) break; |
| 83288 | 83382 | } |
| 83289 | 83383 | if( d>(u32)nKey && u ){ |
| 83290 | 83384 | assert( CORRUPT_DB ); |
| | @@ -83364,11 +83458,12 @@ |
| 83364 | 83458 | break; |
| 83365 | 83459 | } |
| 83366 | 83460 | |
| 83367 | 83461 | /* Extract the values to be compared. |
| 83368 | 83462 | */ |
| 83369 | | - d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); |
| 83463 | + sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); |
| 83464 | + d1 += sqlite3VdbeSerialTypeLen(serial_type1); |
| 83370 | 83465 | |
| 83371 | 83466 | /* Do the comparison |
| 83372 | 83467 | */ |
| 83373 | 83468 | rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], |
| 83374 | 83469 | pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0); |
| | @@ -84168,11 +84263,11 @@ |
| 84168 | 84263 | } |
| 84169 | 84264 | |
| 84170 | 84265 | /* The index entry must begin with a header size */ |
| 84171 | 84266 | getVarint32NR((u8*)m.z, szHdr); |
| 84172 | 84267 | testcase( szHdr==3 ); |
| 84173 | | - testcase( szHdr==m.n ); |
| 84268 | + testcase( szHdr==(u32)m.n ); |
| 84174 | 84269 | testcase( szHdr>0x7fffffff ); |
| 84175 | 84270 | assert( m.n>=0 ); |
| 84176 | 84271 | if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){ |
| 84177 | 84272 | goto idx_rowid_corruption; |
| 84178 | 84273 | } |
| | @@ -87006,11 +87101,10 @@ |
| 87006 | 87101 | */ |
| 87007 | 87102 | static VdbeCursor *allocateCursor( |
| 87008 | 87103 | Vdbe *p, /* The virtual machine */ |
| 87009 | 87104 | int iCur, /* Index of the new VdbeCursor */ |
| 87010 | 87105 | int nField, /* Number of fields in the table or index */ |
| 87011 | | - int iDb, /* Database the cursor belongs to, or -1 */ |
| 87012 | 87106 | u8 eCurType /* Type of the new cursor */ |
| 87013 | 87107 | ){ |
| 87014 | 87108 | /* Find the memory cell that will be used to store the blob of memory |
| 87015 | 87109 | ** required for this VdbeCursor structure. It is convenient to use a |
| 87016 | 87110 | ** vdbe memory cell to manage the memory allocation required for a |
| | @@ -87063,11 +87157,10 @@ |
| 87063 | 87157 | } |
| 87064 | 87158 | |
| 87065 | 87159 | p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc; |
| 87066 | 87160 | memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); |
| 87067 | 87161 | pCx->eCurType = eCurType; |
| 87068 | | - pCx->iDb = iDb; |
| 87069 | 87162 | pCx->nField = nField; |
| 87070 | 87163 | pCx->aOffset = &pCx->aType[nField]; |
| 87071 | 87164 | if( eCurType==CURTYPE_BTREE ){ |
| 87072 | 87165 | pCx->uc.pCursor = (BtCursor*) |
| 87073 | 87166 | &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; |
| | @@ -87446,11 +87539,10 @@ |
| 87446 | 87539 | int i, mx; |
| 87447 | 87540 | u64 h = 0; |
| 87448 | 87541 | |
| 87449 | 87542 | i = pOp->p3; |
| 87450 | 87543 | assert( pOp->p4type==P4_INT32 ); |
| 87451 | | - mx = i + pOp->p4.i; |
| 87452 | 87544 | for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){ |
| 87453 | 87545 | const Mem *p = &aMem[i]; |
| 87454 | 87546 | if( p->flags & (MEM_Int|MEM_IntReal) ){ |
| 87455 | 87547 | h += p->u.i; |
| 87456 | 87548 | }else if( p->flags & MEM_Real ){ |
| | @@ -89458,10 +89550,11 @@ |
| 89458 | 89550 | pDest = &aMem[pOp->p3]; |
| 89459 | 89551 | memAboutToChange(p, pDest); |
| 89460 | 89552 | assert( pC!=0 ); |
| 89461 | 89553 | assert( p2<(u32)pC->nField ); |
| 89462 | 89554 | aOffset = pC->aOffset; |
| 89555 | + assert( aOffset==pC->aType+pC->nField ); |
| 89463 | 89556 | assert( pC->eCurType!=CURTYPE_VTAB ); |
| 89464 | 89557 | assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); |
| 89465 | 89558 | assert( pC->eCurType!=CURTYPE_SORTER ); |
| 89466 | 89559 | |
| 89467 | 89560 | if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/ |
| | @@ -90607,10 +90700,11 @@ |
| 90607 | 90700 | rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3); |
| 90608 | 90701 | if( pOp->p2==BTREE_SCHEMA_VERSION ){ |
| 90609 | 90702 | /* When the schema cookie changes, record the new cookie internally */ |
| 90610 | 90703 | pDb->pSchema->schema_cookie = pOp->p3 - pOp->p5; |
| 90611 | 90704 | db->mDbFlags |= DBFLAG_SchemaChange; |
| 90705 | + sqlite3FkClearTriggerCache(db, pOp->p1); |
| 90612 | 90706 | }else if( pOp->p2==BTREE_FILE_FORMAT ){ |
| 90613 | 90707 | /* Record changes in the file format */ |
| 90614 | 90708 | pDb->pSchema->file_format = pOp->p3; |
| 90615 | 90709 | } |
| 90616 | 90710 | if( pOp->p1==1 ){ |
| | @@ -90784,12 +90878,13 @@ |
| 90784 | 90878 | nField = pOp->p4.i; |
| 90785 | 90879 | } |
| 90786 | 90880 | assert( pOp->p1>=0 ); |
| 90787 | 90881 | assert( nField>=0 ); |
| 90788 | 90882 | testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ |
| 90789 | | - pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE); |
| 90883 | + pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE); |
| 90790 | 90884 | if( pCur==0 ) goto no_mem; |
| 90885 | + pCur->iDb = iDb; |
| 90791 | 90886 | pCur->nullRow = 1; |
| 90792 | 90887 | pCur->isOrdered = 1; |
| 90793 | 90888 | pCur->pgnoRoot = p2; |
| 90794 | 90889 | #ifdef SQLITE_DEBUG |
| 90795 | 90890 | pCur->wrFlag = wrFlag; |
| | @@ -90827,22 +90922,22 @@ |
| 90827 | 90922 | |
| 90828 | 90923 | pOrig = p->apCsr[pOp->p2]; |
| 90829 | 90924 | assert( pOrig ); |
| 90830 | 90925 | assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */ |
| 90831 | 90926 | |
| 90832 | | - pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE); |
| 90927 | + pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE); |
| 90833 | 90928 | if( pCx==0 ) goto no_mem; |
| 90834 | 90929 | pCx->nullRow = 1; |
| 90835 | 90930 | pCx->isEphemeral = 1; |
| 90836 | 90931 | pCx->pKeyInfo = pOrig->pKeyInfo; |
| 90837 | 90932 | pCx->isTable = pOrig->isTable; |
| 90838 | 90933 | pCx->pgnoRoot = pOrig->pgnoRoot; |
| 90839 | 90934 | pCx->isOrdered = pOrig->isOrdered; |
| 90840 | | - pCx->pBtx = pOrig->pBtx; |
| 90935 | + pCx->ub.pBtx = pOrig->ub.pBtx; |
| 90841 | 90936 | pCx->hasBeenDuped = 1; |
| 90842 | 90937 | pOrig->hasBeenDuped = 1; |
| 90843 | | - rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| 90938 | + rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| 90844 | 90939 | pCx->pKeyInfo, pCx->uc.pCursor); |
| 90845 | 90940 | /* The sqlite3BtreeCursor() routine can only fail for the first cursor |
| 90846 | 90941 | ** opened for a database. Since there is already an open cursor when this |
| 90847 | 90942 | ** opcode is run, the sqlite3BtreeCursor() cannot fail */ |
| 90848 | 90943 | assert( rc==SQLITE_OK ); |
| | @@ -90911,48 +91006,48 @@ |
| 90911 | 91006 | ** OP_OpenDup, then erase all existing content so that the table is |
| 90912 | 91007 | ** empty again, rather than creating a new table. */ |
| 90913 | 91008 | assert( pCx->isEphemeral ); |
| 90914 | 91009 | pCx->seqCount = 0; |
| 90915 | 91010 | pCx->cacheStatus = CACHE_STALE; |
| 90916 | | - rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0); |
| 91011 | + rc = sqlite3BtreeClearTable(pCx->ub.pBtx, pCx->pgnoRoot, 0); |
| 90917 | 91012 | }else{ |
| 90918 | | - pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE); |
| 91013 | + pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE); |
| 90919 | 91014 | if( pCx==0 ) goto no_mem; |
| 90920 | 91015 | pCx->isEphemeral = 1; |
| 90921 | | - rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx, |
| 91016 | + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx, |
| 90922 | 91017 | BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, |
| 90923 | 91018 | vfsFlags); |
| 90924 | 91019 | if( rc==SQLITE_OK ){ |
| 90925 | | - rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0); |
| 91020 | + rc = sqlite3BtreeBeginTrans(pCx->ub.pBtx, 1, 0); |
| 90926 | 91021 | if( rc==SQLITE_OK ){ |
| 90927 | 91022 | /* If a transient index is required, create it by calling |
| 90928 | 91023 | ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before |
| 90929 | 91024 | ** opening it. If a transient table is required, just use the |
| 90930 | 91025 | ** automatically created table with root-page 1 (an BLOB_INTKEY table). |
| 90931 | 91026 | */ |
| 90932 | 91027 | if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ |
| 90933 | 91028 | assert( pOp->p4type==P4_KEYINFO ); |
| 90934 | | - rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot, |
| 91029 | + rc = sqlite3BtreeCreateTable(pCx->ub.pBtx, &pCx->pgnoRoot, |
| 90935 | 91030 | BTREE_BLOBKEY | pOp->p5); |
| 90936 | 91031 | if( rc==SQLITE_OK ){ |
| 90937 | 91032 | assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); |
| 90938 | 91033 | assert( pKeyInfo->db==db ); |
| 90939 | 91034 | assert( pKeyInfo->enc==ENC(db) ); |
| 90940 | | - rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| 91035 | + rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| 90941 | 91036 | pKeyInfo, pCx->uc.pCursor); |
| 90942 | 91037 | } |
| 90943 | 91038 | pCx->isTable = 0; |
| 90944 | 91039 | }else{ |
| 90945 | 91040 | pCx->pgnoRoot = SCHEMA_ROOT; |
| 90946 | | - rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR, |
| 91041 | + rc = sqlite3BtreeCursor(pCx->ub.pBtx, SCHEMA_ROOT, BTREE_WRCSR, |
| 90947 | 91042 | 0, pCx->uc.pCursor); |
| 90948 | 91043 | pCx->isTable = 1; |
| 90949 | 91044 | } |
| 90950 | 91045 | } |
| 90951 | 91046 | pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); |
| 90952 | 91047 | if( rc ){ |
| 90953 | | - sqlite3BtreeClose(pCx->pBtx); |
| 91048 | + sqlite3BtreeClose(pCx->ub.pBtx); |
| 90954 | 91049 | } |
| 90955 | 91050 | } |
| 90956 | 91051 | } |
| 90957 | 91052 | if( rc ) goto abort_due_to_error; |
| 90958 | 91053 | pCx->nullRow = 1; |
| | @@ -90972,11 +91067,11 @@ |
| 90972 | 91067 | case OP_SorterOpen: { |
| 90973 | 91068 | VdbeCursor *pCx; |
| 90974 | 91069 | |
| 90975 | 91070 | assert( pOp->p1>=0 ); |
| 90976 | 91071 | assert( pOp->p2>=0 ); |
| 90977 | | - pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER); |
| 91072 | + pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER); |
| 90978 | 91073 | if( pCx==0 ) goto no_mem; |
| 90979 | 91074 | pCx->pKeyInfo = pOp->p4.pKeyInfo; |
| 90980 | 91075 | assert( pCx->pKeyInfo->db==db ); |
| 90981 | 91076 | assert( pCx->pKeyInfo->enc==ENC(db) ); |
| 90982 | 91077 | rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); |
| | @@ -91021,11 +91116,11 @@ |
| 91021 | 91116 | case OP_OpenPseudo: { |
| 91022 | 91117 | VdbeCursor *pCx; |
| 91023 | 91118 | |
| 91024 | 91119 | assert( pOp->p1>=0 ); |
| 91025 | 91120 | assert( pOp->p3>=0 ); |
| 91026 | | - pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO); |
| 91121 | + pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO); |
| 91027 | 91122 | if( pCx==0 ) goto no_mem; |
| 91028 | 91123 | pCx->nullRow = 1; |
| 91029 | 91124 | pCx->seekResult = pOp->p2; |
| 91030 | 91125 | pCx->isTable = 1; |
| 91031 | 91126 | /* Give this pseudo-cursor a fake BtCursor pointer so that pCx |
| | @@ -92961,13 +93056,13 @@ |
| 92961 | 93056 | assert( pTabCur->isTable ); |
| 92962 | 93057 | pTabCur->nullRow = 0; |
| 92963 | 93058 | pTabCur->movetoTarget = rowid; |
| 92964 | 93059 | pTabCur->deferredMoveto = 1; |
| 92965 | 93060 | assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); |
| 92966 | | - pTabCur->aAltMap = pOp->p4.ai; |
| 92967 | | - assert( !pC->isEphemeral ); |
| 92968 | 93061 | assert( !pTabCur->isEphemeral ); |
| 93062 | + pTabCur->ub.aAltMap = pOp->p4.ai; |
| 93063 | + assert( !pC->isEphemeral ); |
| 92969 | 93064 | pTabCur->pAltCursor = pC; |
| 92970 | 93065 | }else{ |
| 92971 | 93066 | pOut = out2Prerelease(p, pOp); |
| 92972 | 93067 | pOut->u.i = rowid; |
| 92973 | 93068 | } |
| | @@ -94485,11 +94580,11 @@ |
| 94485 | 94580 | |
| 94486 | 94581 | /* Initialize sqlite3_vtab_cursor base class */ |
| 94487 | 94582 | pVCur->pVtab = pVtab; |
| 94488 | 94583 | |
| 94489 | 94584 | /* Initialize vdbe cursor object */ |
| 94490 | | - pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB); |
| 94585 | + pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB); |
| 94491 | 94586 | if( pCur ){ |
| 94492 | 94587 | pCur->uc.pVCur = pVCur; |
| 94493 | 94588 | pVtab->nRef++; |
| 94494 | 94589 | }else{ |
| 94495 | 94590 | assert( db->mallocFailed ); |
| | @@ -96810,11 +96905,12 @@ |
| 96810 | 96905 | if( nWorker>=SORTER_MAX_MERGE_COUNT ){ |
| 96811 | 96906 | nWorker = SORTER_MAX_MERGE_COUNT-1; |
| 96812 | 96907 | } |
| 96813 | 96908 | #endif |
| 96814 | 96909 | |
| 96815 | | - assert( pCsr->pKeyInfo && pCsr->pBtx==0 ); |
| 96910 | + assert( pCsr->pKeyInfo ); |
| 96911 | + assert( !pCsr->isEphemeral ); |
| 96816 | 96912 | assert( pCsr->eCurType==CURTYPE_SORTER ); |
| 96817 | 96913 | szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*); |
| 96818 | 96914 | sz = sizeof(VdbeSorter) + nWorker * sizeof(SortSubtask); |
| 96819 | 96915 | |
| 96820 | 96916 | pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo); |
| | @@ -99310,11 +99406,11 @@ |
| 99310 | 99406 | if( size==0 ){ |
| 99311 | 99407 | memjrnlFreeChunks(p->pFirst); |
| 99312 | 99408 | p->pFirst = 0; |
| 99313 | 99409 | }else{ |
| 99314 | 99410 | i64 iOff = p->nChunkSize; |
| 99315 | | - for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){ |
| 99411 | + for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){ |
| 99316 | 99412 | iOff += p->nChunkSize; |
| 99317 | 99413 | } |
| 99318 | 99414 | if( ALWAYS(pIter) ){ |
| 99319 | 99415 | memjrnlFreeChunks(pIter->pNext); |
| 99320 | 99416 | pIter->pNext = 0; |
| | @@ -100064,12 +100160,13 @@ |
| 100064 | 100160 | hit = 1; |
| 100065 | 100161 | } |
| 100066 | 100162 | } |
| 100067 | 100163 | if( hit || zTab==0 ) continue; |
| 100068 | 100164 | } |
| 100069 | | - if( zDb && pTab->pSchema!=pSchema ){ |
| 100070 | | - continue; |
| 100165 | + if( zDb ){ |
| 100166 | + if( pTab->pSchema!=pSchema ) continue; |
| 100167 | + if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue; |
| 100071 | 100168 | } |
| 100072 | 100169 | if( zTab ){ |
| 100073 | 100170 | const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName; |
| 100074 | 100171 | assert( zTabName!=0 ); |
| 100075 | 100172 | if( sqlite3StrICmp(zTabName, zTab)!=0 ){ |
| | @@ -100196,10 +100293,11 @@ |
| 100196 | 100293 | { |
| 100197 | 100294 | assert( ExprUseYTab(pExpr) ); |
| 100198 | 100295 | pExpr->y.pTab = pTab; |
| 100199 | 100296 | if( pParse->bReturning ){ |
| 100200 | 100297 | eNewExprOp = TK_REGISTER; |
| 100298 | + pExpr->op2 = TK_COLUMN; |
| 100201 | 100299 | pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable + |
| 100202 | 100300 | sqlite3TableColumnToStorage(pTab, iCol) + 1; |
| 100203 | 100301 | }else{ |
| 100204 | 100302 | pExpr->iColumn = (i16)iCol; |
| 100205 | 100303 | eNewExprOp = TK_TRIGGER; |
| | @@ -109275,11 +109373,10 @@ |
| 109275 | 109373 | sqlite3 *db, /* Database handle */ |
| 109276 | 109374 | const char *zSql, /* SQL to parse */ |
| 109277 | 109375 | int bTemp /* True if SQL is from temp schema */ |
| 109278 | 109376 | ){ |
| 109279 | 109377 | int rc; |
| 109280 | | - char *zErr = 0; |
| 109281 | 109378 | |
| 109282 | 109379 | db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb); |
| 109283 | 109380 | |
| 109284 | 109381 | /* Parse the SQL statement passed as the first argument. If no error |
| 109285 | 109382 | ** occurs and the parse does not result in a new table, index or |
| | @@ -109286,14 +109383,11 @@ |
| 109286 | 109383 | ** trigger object, the database must be corrupt. */ |
| 109287 | 109384 | memset(p, 0, sizeof(Parse)); |
| 109288 | 109385 | p->eParseMode = PARSE_MODE_RENAME; |
| 109289 | 109386 | p->db = db; |
| 109290 | 109387 | p->nQueryLoop = 1; |
| 109291 | | - rc = zSql ? sqlite3RunParser(p, zSql, &zErr) : SQLITE_NOMEM; |
| 109292 | | - assert( p->zErrMsg==0 ); |
| 109293 | | - assert( rc!=SQLITE_OK || zErr==0 ); |
| 109294 | | - p->zErrMsg = zErr; |
| 109388 | + rc = zSql ? sqlite3RunParser(p, zSql) : SQLITE_NOMEM; |
| 109295 | 109389 | if( db->mallocFailed ) rc = SQLITE_NOMEM; |
| 109296 | 109390 | if( rc==SQLITE_OK |
| 109297 | 109391 | && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0 |
| 109298 | 109392 | ){ |
| 109299 | 109393 | rc = SQLITE_CORRUPT_BKPT; |
| | @@ -113359,11 +113453,11 @@ |
| 113359 | 113453 | Returning *pReturning = pParse->u1.pReturning; |
| 113360 | 113454 | int addrRewind; |
| 113361 | 113455 | int i; |
| 113362 | 113456 | int reg; |
| 113363 | 113457 | |
| 113364 | | - if( pReturning->nRetCol==0 ){ |
| 113458 | + if( NEVER(pReturning->nRetCol==0) ){ |
| 113365 | 113459 | assert( CORRUPT_DB ); |
| 113366 | 113460 | }else{ |
| 113367 | 113461 | sqlite3VdbeAddOp0(v, OP_FkCheck); |
| 113368 | 113462 | addrRewind = |
| 113369 | 113463 | sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur); |
| | @@ -113455,11 +113549,11 @@ |
| 113455 | 113549 | } |
| 113456 | 113550 | } |
| 113457 | 113551 | |
| 113458 | 113552 | if( pParse->bReturning ){ |
| 113459 | 113553 | Returning *pRet = pParse->u1.pReturning; |
| 113460 | | - if( pRet->nRetCol==0 ){ |
| 113554 | + if( NEVER(pRet->nRetCol==0) ){ |
| 113461 | 113555 | assert( CORRUPT_DB ); |
| 113462 | 113556 | }else{ |
| 113463 | 113557 | sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol); |
| 113464 | 113558 | } |
| 113465 | 113559 | } |
| | @@ -113496,11 +113590,10 @@ |
| 113496 | 113590 | ** built-in function. |
| 113497 | 113591 | */ |
| 113498 | 113592 | SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ |
| 113499 | 113593 | va_list ap; |
| 113500 | 113594 | char *zSql; |
| 113501 | | - char *zErrMsg = 0; |
| 113502 | 113595 | sqlite3 *db = pParse->db; |
| 113503 | 113596 | u32 savedDbFlags = db->mDbFlags; |
| 113504 | 113597 | char saveBuf[PARSE_TAIL_SZ]; |
| 113505 | 113598 | |
| 113506 | 113599 | if( pParse->nErr ) return; |
| | @@ -113518,13 +113611,12 @@ |
| 113518 | 113611 | } |
| 113519 | 113612 | pParse->nested++; |
| 113520 | 113613 | memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ); |
| 113521 | 113614 | memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); |
| 113522 | 113615 | db->mDbFlags |= DBFLAG_PreferBuiltin; |
| 113523 | | - sqlite3RunParser(pParse, zSql, &zErrMsg); |
| 113616 | + sqlite3RunParser(pParse, zSql); |
| 113524 | 113617 | db->mDbFlags = savedDbFlags; |
| 113525 | | - sqlite3DbFree(db, zErrMsg); |
| 113526 | 113618 | sqlite3DbFree(db, zSql); |
| 113527 | 113619 | memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ); |
| 113528 | 113620 | pParse->nested--; |
| 113529 | 113621 | } |
| 113530 | 113622 | |
| | @@ -119179,11 +119271,10 @@ |
| 119179 | 119271 | for(i=0; i<nDef; i++){ |
| 119180 | 119272 | FuncDef *pOther; |
| 119181 | 119273 | const char *zName = aDef[i].zName; |
| 119182 | 119274 | int nName = sqlite3Strlen30(zName); |
| 119183 | 119275 | int h = SQLITE_FUNC_HASH(zName[0], nName); |
| 119184 | | - assert( zName[0]>='a' && zName[0]<='z' ); |
| 119185 | 119276 | assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN ); |
| 119186 | 119277 | pOther = sqlite3FunctionSearch(h, zName); |
| 119187 | 119278 | if( pOther ){ |
| 119188 | 119279 | assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] ); |
| 119189 | 119280 | aDef[i].pNext = pOther->pNext; |
| | @@ -120442,10 +120533,21 @@ |
| 120442 | 120533 | ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT, |
| 120443 | 120534 | ** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */ |
| 120444 | 120535 | sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC); |
| 120445 | 120536 | } |
| 120446 | 120537 | |
| 120538 | +/* subtype(X) |
| 120539 | +** |
| 120540 | +** Return the subtype of X |
| 120541 | +*/ |
| 120542 | +static void subtypeFunc( |
| 120543 | + sqlite3_context *context, |
| 120544 | + int argc, |
| 120545 | + sqlite3_value **argv |
| 120546 | +){ |
| 120547 | + sqlite3_result_int(context, sqlite3_value_subtype(argv[0])); |
| 120548 | +} |
| 120447 | 120549 | |
| 120448 | 120550 | /* |
| 120449 | 120551 | ** Implementation of the length() function |
| 120450 | 120552 | */ |
| 120451 | 120553 | static void lengthFunc( |
| | @@ -120603,11 +120705,11 @@ |
| 120603 | 120705 | sqlite3_result_error_nomem(context); |
| 120604 | 120706 | goto endInstr; |
| 120605 | 120707 | } |
| 120606 | 120708 | |
| 120607 | 120709 | /* |
| 120608 | | -** Implementation of the printf() function. |
| 120710 | +** Implementation of the printf() (a.k.a. format()) SQL function. |
| 120609 | 120711 | */ |
| 120610 | 120712 | static void printfFunc( |
| 120611 | 120713 | sqlite3_context *context, |
| 120612 | 120714 | int argc, |
| 120613 | 120715 | sqlite3_value **argv |
| | @@ -121372,87 +121474,95 @@ |
| 121372 | 121474 | '0', '1', '2', '3', '4', '5', '6', '7', |
| 121373 | 121475 | '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' |
| 121374 | 121476 | }; |
| 121375 | 121477 | |
| 121376 | 121478 | /* |
| 121377 | | -** Implementation of the QUOTE() function. This function takes a single |
| 121378 | | -** argument. If the argument is numeric, the return value is the same as |
| 121379 | | -** the argument. If the argument is NULL, the return value is the string |
| 121380 | | -** "NULL". Otherwise, the argument is enclosed in single quotes with |
| 121381 | | -** single-quote escapes. |
| 121479 | +** Append to pStr text that is the SQL literal representation of the |
| 121480 | +** value contained in pValue. |
| 121382 | 121481 | */ |
| 121383 | | -static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ |
| 121384 | | - assert( argc==1 ); |
| 121385 | | - UNUSED_PARAMETER(argc); |
| 121386 | | - switch( sqlite3_value_type(argv[0]) ){ |
| 121482 | +SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){ |
| 121483 | + /* As currently implemented, the string must be initially empty. |
| 121484 | + ** we might relax this requirement in the future, but that will |
| 121485 | + ** require enhancements to the implementation. */ |
| 121486 | + assert( pStr!=0 && pStr->nChar==0 ); |
| 121487 | + |
| 121488 | + switch( sqlite3_value_type(pValue) ){ |
| 121387 | 121489 | case SQLITE_FLOAT: { |
| 121388 | 121490 | double r1, r2; |
| 121389 | | - char zBuf[50]; |
| 121390 | | - r1 = sqlite3_value_double(argv[0]); |
| 121391 | | - sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); |
| 121392 | | - sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); |
| 121393 | | - if( r1!=r2 ){ |
| 121394 | | - sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); |
| 121395 | | - } |
| 121396 | | - sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); |
| 121491 | + const char *zVal; |
| 121492 | + r1 = sqlite3_value_double(pValue); |
| 121493 | + sqlite3_str_appendf(pStr, "%!.15g", r1); |
| 121494 | + zVal = sqlite3_str_value(pStr); |
| 121495 | + if( zVal ){ |
| 121496 | + sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8); |
| 121497 | + if( r1!=r2 ){ |
| 121498 | + sqlite3_str_reset(pStr); |
| 121499 | + sqlite3_str_appendf(pStr, "%!.20e", r1); |
| 121500 | + } |
| 121501 | + } |
| 121397 | 121502 | break; |
| 121398 | 121503 | } |
| 121399 | 121504 | case SQLITE_INTEGER: { |
| 121400 | | - sqlite3_result_value(context, argv[0]); |
| 121505 | + sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue)); |
| 121401 | 121506 | break; |
| 121402 | 121507 | } |
| 121403 | 121508 | case SQLITE_BLOB: { |
| 121404 | | - char *zText = 0; |
| 121405 | | - char const *zBlob = sqlite3_value_blob(argv[0]); |
| 121406 | | - int nBlob = sqlite3_value_bytes(argv[0]); |
| 121407 | | - assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ |
| 121408 | | - zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); |
| 121409 | | - if( zText ){ |
| 121509 | + char const *zBlob = sqlite3_value_blob(pValue); |
| 121510 | + int nBlob = sqlite3_value_bytes(pValue); |
| 121511 | + assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */ |
| 121512 | + sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4); |
| 121513 | + if( pStr->accError==0 ){ |
| 121514 | + char *zText = pStr->zText; |
| 121410 | 121515 | int i; |
| 121411 | 121516 | for(i=0; i<nBlob; i++){ |
| 121412 | 121517 | zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; |
| 121413 | 121518 | zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; |
| 121414 | 121519 | } |
| 121415 | 121520 | zText[(nBlob*2)+2] = '\''; |
| 121416 | 121521 | zText[(nBlob*2)+3] = '\0'; |
| 121417 | 121522 | zText[0] = 'X'; |
| 121418 | 121523 | zText[1] = '\''; |
| 121419 | | - sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); |
| 121420 | | - sqlite3_free(zText); |
| 121524 | + pStr->nChar = nBlob*2 + 3; |
| 121421 | 121525 | } |
| 121422 | 121526 | break; |
| 121423 | 121527 | } |
| 121424 | 121528 | case SQLITE_TEXT: { |
| 121425 | | - int i,j; |
| 121426 | | - u64 n; |
| 121427 | | - const unsigned char *zArg = sqlite3_value_text(argv[0]); |
| 121428 | | - char *z; |
| 121429 | | - |
| 121430 | | - if( zArg==0 ) return; |
| 121431 | | - for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } |
| 121432 | | - z = contextMalloc(context, ((i64)i)+((i64)n)+3); |
| 121433 | | - if( z ){ |
| 121434 | | - z[0] = '\''; |
| 121435 | | - for(i=0, j=1; zArg[i]; i++){ |
| 121436 | | - z[j++] = zArg[i]; |
| 121437 | | - if( zArg[i]=='\'' ){ |
| 121438 | | - z[j++] = '\''; |
| 121439 | | - } |
| 121440 | | - } |
| 121441 | | - z[j++] = '\''; |
| 121442 | | - z[j] = 0; |
| 121443 | | - sqlite3_result_text(context, z, j, sqlite3_free); |
| 121444 | | - } |
| 121529 | + const unsigned char *zArg = sqlite3_value_text(pValue); |
| 121530 | + sqlite3_str_appendf(pStr, "%Q", zArg); |
| 121445 | 121531 | break; |
| 121446 | 121532 | } |
| 121447 | 121533 | default: { |
| 121448 | | - assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); |
| 121449 | | - sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); |
| 121534 | + assert( sqlite3_value_type(pValue)==SQLITE_NULL ); |
| 121535 | + sqlite3_str_append(pStr, "NULL", 4); |
| 121450 | 121536 | break; |
| 121451 | 121537 | } |
| 121452 | 121538 | } |
| 121453 | 121539 | } |
| 121540 | + |
| 121541 | +/* |
| 121542 | +** Implementation of the QUOTE() function. |
| 121543 | +** |
| 121544 | +** The quote(X) function returns the text of an SQL literal which is the |
| 121545 | +** value of its argument suitable for inclusion into an SQL statement. |
| 121546 | +** Strings are surrounded by single-quotes with escapes on interior quotes |
| 121547 | +** as needed. BLOBs are encoded as hexadecimal literals. Strings with |
| 121548 | +** embedded NUL characters cannot be represented as string literals in SQL |
| 121549 | +** and hence the returned string literal is truncated prior to the first NUL. |
| 121550 | +*/ |
| 121551 | +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ |
| 121552 | + sqlite3_str str; |
| 121553 | + sqlite3 *db = sqlite3_context_db_handle(context); |
| 121554 | + assert( argc==1 ); |
| 121555 | + UNUSED_PARAMETER(argc); |
| 121556 | + sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); |
| 121557 | + sqlite3QuoteValue(&str,argv[0]); |
| 121558 | + sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar, |
| 121559 | + SQLITE_DYNAMIC); |
| 121560 | + if( str.accError==SQLITE_NOMEM ){ |
| 121561 | + sqlite3_result_error_nomem(context); |
| 121562 | + } |
| 121563 | +} |
| 121454 | 121564 | |
| 121455 | 121565 | /* |
| 121456 | 121566 | ** The unicode() function. Return the integer unicode code-point value |
| 121457 | 121567 | ** for the first character of the input string. |
| 121458 | 121568 | */ |
| | @@ -122583,13 +122693,15 @@ |
| 122583 | 122693 | FUNCTION(max, -1, 1, 1, minmaxFunc ), |
| 122584 | 122694 | FUNCTION(max, 0, 1, 1, 0 ), |
| 122585 | 122695 | WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, |
| 122586 | 122696 | SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), |
| 122587 | 122697 | FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), |
| 122698 | + FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF), |
| 122588 | 122699 | FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), |
| 122589 | 122700 | FUNCTION(instr, 2, 0, 0, instrFunc ), |
| 122590 | 122701 | FUNCTION(printf, -1, 0, 0, printfFunc ), |
| 122702 | + FUNCTION(format, -1, 0, 0, printfFunc ), |
| 122591 | 122703 | FUNCTION(unicode, 1, 0, 0, unicodeFunc ), |
| 122592 | 122704 | FUNCTION(char, -1, 0, 0, charFunc ), |
| 122593 | 122705 | FUNCTION(abs, 1, 0, 0, absFunc ), |
| 122594 | 122706 | #ifndef SQLITE_OMIT_FLOATING_POINT |
| 122595 | 122707 | FUNCTION(round, 1, 0, 0, roundFunc ), |
| | @@ -122684,10 +122796,11 @@ |
| 122684 | 122796 | #ifndef SQLITE_OMIT_ALTERTABLE |
| 122685 | 122797 | sqlite3AlterFunctions(); |
| 122686 | 122798 | #endif |
| 122687 | 122799 | sqlite3WindowFunctions(); |
| 122688 | 122800 | sqlite3RegisterDateTimeFunctions(); |
| 122801 | + sqlite3RegisterJsonFunctions(); |
| 122689 | 122802 | sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); |
| 122690 | 122803 | |
| 122691 | 122804 | #if 0 /* Enable to print out how the built-in functions are hashed */ |
| 122692 | 122805 | { |
| 122693 | 122806 | int i; |
| | @@ -123409,10 +123522,29 @@ |
| 123409 | 123522 | sqlite3SelectDelete(dbMem, pStep->pSelect); |
| 123410 | 123523 | sqlite3ExprDelete(dbMem, p->pWhen); |
| 123411 | 123524 | sqlite3DbFree(dbMem, p); |
| 123412 | 123525 | } |
| 123413 | 123526 | } |
| 123527 | + |
| 123528 | +/* |
| 123529 | +** Clear the apTrigger[] cache of CASCADE triggers for all foreign keys |
| 123530 | +** in a particular database. This needs to happen when the schema |
| 123531 | +** changes. |
| 123532 | +*/ |
| 123533 | +SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){ |
| 123534 | + HashElem *k; |
| 123535 | + Hash *pHash = &db->aDb[iDb].pSchema->tblHash; |
| 123536 | + for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k)){ |
| 123537 | + Table *pTab = sqliteHashData(k); |
| 123538 | + FKey *pFKey; |
| 123539 | + if( !IsOrdinaryTable(pTab) ) continue; |
| 123540 | + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ |
| 123541 | + fkTriggerDelete(db, pFKey->apTrigger[0]); pFKey->apTrigger[0] = 0; |
| 123542 | + fkTriggerDelete(db, pFKey->apTrigger[1]); pFKey->apTrigger[1] = 0; |
| 123543 | + } |
| 123544 | + } |
| 123545 | +} |
| 123414 | 123546 | |
| 123415 | 123547 | /* |
| 123416 | 123548 | ** This function is called to generate code that runs when table pTab is |
| 123417 | 123549 | ** being dropped from the database. The SrcList passed as the second argument |
| 123418 | 123550 | ** to this function contains a single entry guaranteed to resolve to |
| | @@ -124210,11 +124342,11 @@ |
| 124210 | 124342 | sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol); |
| 124211 | 124343 | VdbeComment((v, "%s", pTab->zName)); |
| 124212 | 124344 | }else{ |
| 124213 | 124345 | Index *pPk = sqlite3PrimaryKeyIndex(pTab); |
| 124214 | 124346 | assert( pPk!=0 ); |
| 124215 | | - assert( pPk->tnum==pTab->tnum ); |
| 124347 | + assert( pPk->tnum==pTab->tnum || CORRUPT_DB ); |
| 124216 | 124348 | sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb); |
| 124217 | 124349 | sqlite3VdbeSetP4KeyInfo(pParse, pPk); |
| 124218 | 124350 | VdbeComment((v, "%s", pTab->zName)); |
| 124219 | 124351 | } |
| 124220 | 124352 | } |
| | @@ -126174,10 +126306,11 @@ |
| 126174 | 126306 | ** the UNIQUE constraints have run. |
| 126175 | 126307 | */ |
| 126176 | 126308 | if( onError==OE_Replace /* IPK rule is REPLACE */ |
| 126177 | 126309 | && onError!=overrideError /* Rules for other constraints are different */ |
| 126178 | 126310 | && pTab->pIndex /* There exist other constraints */ |
| 126311 | + && !upsertIpkDelay /* IPK check already deferred by UPSERT */ |
| 126179 | 126312 | ){ |
| 126180 | 126313 | ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1; |
| 126181 | 126314 | VdbeComment((v, "defer IPK REPLACE until last")); |
| 126182 | 126315 | } |
| 126183 | 126316 | |
| | @@ -126582,10 +126715,11 @@ |
| 126582 | 126715 | |
| 126583 | 126716 | /* If the IPK constraint is a REPLACE, run it last */ |
| 126584 | 126717 | if( ipkTop ){ |
| 126585 | 126718 | sqlite3VdbeGoto(v, ipkTop); |
| 126586 | 126719 | VdbeComment((v, "Do IPK REPLACE")); |
| 126720 | + assert( ipkBottom>0 ); |
| 126587 | 126721 | sqlite3VdbeJumpHere(v, ipkBottom); |
| 126588 | 126722 | } |
| 126589 | 126723 | |
| 126590 | 126724 | /* Recheck all uniqueness constraints after replace triggers have run */ |
| 126591 | 126725 | testcase( regTrigCnt!=0 && nReplaceTrig==0 ); |
| | @@ -126712,11 +126846,10 @@ |
| 126712 | 126846 | sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2); |
| 126713 | 126847 | VdbeCoverage(v); |
| 126714 | 126848 | } |
| 126715 | 126849 | pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0); |
| 126716 | 126850 | if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ |
| 126717 | | - assert( pParse->nested==0 ); |
| 126718 | 126851 | pik_flags |= OPFLAG_NCHANGE; |
| 126719 | 126852 | pik_flags |= (update_flags & OPFLAG_SAVEPOSITION); |
| 126720 | 126853 | if( update_flags==0 ){ |
| 126721 | 126854 | codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]); |
| 126722 | 126855 | } |
| | @@ -127802,10 +127935,12 @@ |
| 127802 | 127935 | sqlite3_int64 (*total_changes64)(sqlite3*); |
| 127803 | 127936 | /* Version 3.37.0 and later */ |
| 127804 | 127937 | int (*autovacuum_pages)(sqlite3*, |
| 127805 | 127938 | unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), |
| 127806 | 127939 | void*, void(*)(void*)); |
| 127940 | + /* Version 3.38.0 and later */ |
| 127941 | + int (*error_offset)(sqlite3*); |
| 127807 | 127942 | }; |
| 127808 | 127943 | |
| 127809 | 127944 | /* |
| 127810 | 127945 | ** This is the function signature used for all extension entry points. It |
| 127811 | 127946 | ** is also defined in the file "loadext.c". |
| | @@ -128113,10 +128248,12 @@ |
| 128113 | 128248 | /* Version 3.36.1 and later */ |
| 128114 | 128249 | #define sqlite3_changes64 sqlite3_api->changes64 |
| 128115 | 128250 | #define sqlite3_total_changes64 sqlite3_api->total_changes64 |
| 128116 | 128251 | /* Version 3.37.0 and later */ |
| 128117 | 128252 | #define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages |
| 128253 | +/* Version 3.38.0 and later */ |
| 128254 | +#define sqlite3_error_offset sqlite3_api->error_offset |
| 128118 | 128255 | #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ |
| 128119 | 128256 | |
| 128120 | 128257 | #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) |
| 128121 | 128258 | /* This case when the file really is being compiled as a loadable |
| 128122 | 128259 | ** extension */ |
| | @@ -128602,10 +128739,12 @@ |
| 128602 | 128739 | /* Version 3.36.1 and later */ |
| 128603 | 128740 | sqlite3_changes64, |
| 128604 | 128741 | sqlite3_total_changes64, |
| 128605 | 128742 | /* Version 3.37.0 and later */ |
| 128606 | 128743 | sqlite3_autovacuum_pages, |
| 128744 | + /* Version 3.38.0 and later */ |
| 128745 | + sqlite3_error_offset, |
| 128607 | 128746 | }; |
| 128608 | 128747 | |
| 128609 | 128748 | /* True if x is the directory separator character |
| 128610 | 128749 | */ |
| 128611 | 128750 | #if SQLITE_OS_WIN |
| | @@ -132941,10 +133080,14 @@ |
| 132941 | 133080 | /* |
| 132942 | 133081 | ** Free all memory allocations in the pParse object |
| 132943 | 133082 | */ |
| 132944 | 133083 | SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){ |
| 132945 | 133084 | sqlite3 *db = pParse->db; |
| 133085 | + assert( pParse->nested==0 ); |
| 133086 | +#ifndef SQLITE_OMIT_SHARED_CACHE |
| 133087 | + sqlite3DbFree(db, pParse->aTableLock); |
| 133088 | +#endif |
| 132946 | 133089 | while( pParse->pCleanup ){ |
| 132947 | 133090 | ParseCleanup *pCleanup = pParse->pCleanup; |
| 132948 | 133091 | pParse->pCleanup = pCleanup->pNext; |
| 132949 | 133092 | pCleanup->xCleanup(db, pCleanup->pPtr); |
| 132950 | 133093 | sqlite3DbFreeNN(db, pCleanup); |
| | @@ -133020,11 +133163,10 @@ |
| 133020 | 133163 | u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
| 133021 | 133164 | Vdbe *pReprepare, /* VM being reprepared */ |
| 133022 | 133165 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
| 133023 | 133166 | const char **pzTail /* OUT: End of parsed string */ |
| 133024 | 133167 | ){ |
| 133025 | | - char *zErrMsg = 0; /* Error message */ |
| 133026 | 133168 | int rc = SQLITE_OK; /* Result code */ |
| 133027 | 133169 | int i; /* Loop counter */ |
| 133028 | 133170 | Parse sParse; /* Parsing context */ |
| 133029 | 133171 | |
| 133030 | 133172 | memset(&sParse, 0, PARSE_HDR_SZ); |
| | @@ -133095,18 +133237,18 @@ |
| 133095 | 133237 | rc = sqlite3ApiExit(db, SQLITE_TOOBIG); |
| 133096 | 133238 | goto end_prepare; |
| 133097 | 133239 | } |
| 133098 | 133240 | zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); |
| 133099 | 133241 | if( zSqlCopy ){ |
| 133100 | | - sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg); |
| 133242 | + sqlite3RunParser(&sParse, zSqlCopy); |
| 133101 | 133243 | sParse.zTail = &zSql[sParse.zTail-zSqlCopy]; |
| 133102 | 133244 | sqlite3DbFree(db, zSqlCopy); |
| 133103 | 133245 | }else{ |
| 133104 | 133246 | sParse.zTail = &zSql[nBytes]; |
| 133105 | 133247 | } |
| 133106 | 133248 | }else{ |
| 133107 | | - sqlite3RunParser(&sParse, zSql, &zErrMsg); |
| 133249 | + sqlite3RunParser(&sParse, zSql); |
| 133108 | 133250 | } |
| 133109 | 133251 | assert( 0==sParse.nQueryLoop ); |
| 133110 | 133252 | |
| 133111 | 133253 | if( pzTail ){ |
| 133112 | 133254 | *pzTail = sParse.zTail; |
| | @@ -133118,26 +133260,26 @@ |
| 133118 | 133260 | if( db->mallocFailed ){ |
| 133119 | 133261 | sParse.rc = SQLITE_NOMEM_BKPT; |
| 133120 | 133262 | sParse.checkSchema = 0; |
| 133121 | 133263 | } |
| 133122 | 133264 | if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){ |
| 133123 | | - if( sParse.checkSchema ){ |
| 133265 | + if( sParse.checkSchema && db->init.busy==0 ){ |
| 133124 | 133266 | schemaIsValid(&sParse); |
| 133125 | 133267 | } |
| 133126 | 133268 | if( sParse.pVdbe ){ |
| 133127 | 133269 | sqlite3VdbeFinalize(sParse.pVdbe); |
| 133128 | 133270 | } |
| 133129 | 133271 | assert( 0==(*ppStmt) ); |
| 133130 | 133272 | rc = sParse.rc; |
| 133131 | | - if( zErrMsg ){ |
| 133132 | | - sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); |
| 133133 | | - sqlite3DbFree(db, zErrMsg); |
| 133273 | + if( sParse.zErrMsg ){ |
| 133274 | + sqlite3ErrorWithMsg(db, rc, "%s", sParse.zErrMsg); |
| 133275 | + sqlite3DbFree(db, sParse.zErrMsg); |
| 133134 | 133276 | }else{ |
| 133135 | 133277 | sqlite3Error(db, rc); |
| 133136 | 133278 | } |
| 133137 | 133279 | }else{ |
| 133138 | | - assert( zErrMsg==0 ); |
| 133280 | + assert( sParse.zErrMsg==0 ); |
| 133139 | 133281 | *ppStmt = (sqlite3_stmt*)sParse.pVdbe; |
| 133140 | 133282 | rc = SQLITE_OK; |
| 133141 | 133283 | sqlite3ErrorClear(db); |
| 133142 | 133284 | } |
| 133143 | 133285 | |
| | @@ -136696,10 +136838,12 @@ |
| 136696 | 136838 | Select *p, /* The right-most of SELECTs to be coded */ |
| 136697 | 136839 | SelectDest *pDest /* What to do with query results */ |
| 136698 | 136840 | ){ |
| 136699 | 136841 | int i, j; /* Loop counters */ |
| 136700 | 136842 | Select *pPrior; /* Another SELECT immediately to our left */ |
| 136843 | + Select *pSplit; /* Left-most SELECT in the right-hand group */ |
| 136844 | + int nSelect; /* Number of SELECT statements in the compound */ |
| 136701 | 136845 | Vdbe *v; /* Generate code to this VDBE */ |
| 136702 | 136846 | SelectDest destA; /* Destination for coroutine A */ |
| 136703 | 136847 | SelectDest destB; /* Destination for coroutine B */ |
| 136704 | 136848 | int regAddrA; /* Address register for select-A coroutine */ |
| 136705 | 136849 | int regAddrB; /* Address register for select-B coroutine */ |
| | @@ -136741,12 +136885,11 @@ |
| 136741 | 136885 | |
| 136742 | 136886 | |
| 136743 | 136887 | /* Patch up the ORDER BY clause |
| 136744 | 136888 | */ |
| 136745 | 136889 | op = p->op; |
| 136746 | | - pPrior = p->pPrior; |
| 136747 | | - assert( pPrior->pOrderBy==0 ); |
| 136890 | + assert( p->pPrior->pOrderBy==0 ); |
| 136748 | 136891 | pOrderBy = p->pOrderBy; |
| 136749 | 136892 | assert( pOrderBy ); |
| 136750 | 136893 | nOrderBy = pOrderBy->nExpr; |
| 136751 | 136894 | |
| 136752 | 136895 | /* For operators other than UNION ALL we have to make sure that |
| | @@ -136792,15 +136935,10 @@ |
| 136792 | 136935 | pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1); |
| 136793 | 136936 | }else{ |
| 136794 | 136937 | pKeyMerge = 0; |
| 136795 | 136938 | } |
| 136796 | 136939 | |
| 136797 | | - /* Reattach the ORDER BY clause to the query. |
| 136798 | | - */ |
| 136799 | | - p->pOrderBy = pOrderBy; |
| 136800 | | - pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); |
| 136801 | | - |
| 136802 | 136940 | /* Allocate a range of temporary registers and the KeyInfo needed |
| 136803 | 136941 | ** for the logic that removes duplicate result rows when the |
| 136804 | 136942 | ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL). |
| 136805 | 136943 | */ |
| 136806 | 136944 | if( op==TK_ALL ){ |
| | @@ -136821,16 +136959,33 @@ |
| 136821 | 136959 | } |
| 136822 | 136960 | } |
| 136823 | 136961 | |
| 136824 | 136962 | /* Separate the left and the right query from one another |
| 136825 | 136963 | */ |
| 136826 | | - p->pPrior = 0; |
| 136964 | + nSelect = 1; |
| 136965 | + if( (op==TK_ALL || op==TK_UNION) |
| 136966 | + && OptimizationEnabled(db, SQLITE_BalancedMerge) |
| 136967 | + ){ |
| 136968 | + for(pSplit=p; pSplit->pPrior!=0 && pSplit->op==op; pSplit=pSplit->pPrior){ |
| 136969 | + nSelect++; |
| 136970 | + assert( pSplit->pPrior->pNext==pSplit ); |
| 136971 | + } |
| 136972 | + } |
| 136973 | + if( nSelect<=3 ){ |
| 136974 | + pSplit = p; |
| 136975 | + }else{ |
| 136976 | + pSplit = p; |
| 136977 | + for(i=2; i<nSelect; i+=2){ pSplit = pSplit->pPrior; } |
| 136978 | + } |
| 136979 | + pPrior = pSplit->pPrior; |
| 136980 | + pSplit->pPrior = 0; |
| 136827 | 136981 | pPrior->pNext = 0; |
| 136982 | + assert( p->pOrderBy == pOrderBy ); |
| 136983 | + assert( pOrderBy!=0 || db->mallocFailed ); |
| 136984 | + pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); |
| 136828 | 136985 | sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER"); |
| 136829 | | - if( pPrior->pPrior==0 ){ |
| 136830 | | - sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER"); |
| 136831 | | - } |
| 136986 | + sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER"); |
| 136832 | 136987 | |
| 136833 | 136988 | /* Compute the limit registers */ |
| 136834 | 136989 | computeLimitRegisters(pParse, p, labelEnd); |
| 136835 | 136990 | if( p->iLimit && op==TK_ALL ){ |
| 136836 | 136991 | regLimitA = ++pParse->nMem; |
| | @@ -136977,16 +137132,15 @@ |
| 136977 | 137132 | */ |
| 136978 | 137133 | sqlite3VdbeResolveLabel(v, labelEnd); |
| 136979 | 137134 | |
| 136980 | 137135 | /* Reassembly the compound query so that it will be freed correctly |
| 136981 | 137136 | ** by the calling function */ |
| 136982 | | - if( p->pPrior ){ |
| 136983 | | - sqlite3SelectDelete(db, p->pPrior); |
| 137137 | + if( pSplit->pPrior ){ |
| 137138 | + sqlite3SelectDelete(db, pSplit->pPrior); |
| 136984 | 137139 | } |
| 136985 | | - p->pPrior = pPrior; |
| 136986 | | - pPrior->pNext = p; |
| 136987 | | - |
| 137140 | + pSplit->pPrior = pPrior; |
| 137141 | + pPrior->pNext = pSplit; |
| 136988 | 137142 | sqlite3ExprListDelete(db, pPrior->pOrderBy); |
| 136989 | 137143 | pPrior->pOrderBy = 0; |
| 136990 | 137144 | |
| 136991 | 137145 | /*** TBD: Insert subroutine calls to close cursors on incomplete |
| 136992 | 137146 | **** subqueries ****/ |
| | @@ -142061,11 +142215,11 @@ |
| 142061 | 142215 | if( db->mallocFailed==0 && pParse->nErr==0 ){ |
| 142062 | 142216 | sqlite3GenerateColumnNames(pParse, &sSelect); |
| 142063 | 142217 | } |
| 142064 | 142218 | sqlite3ExprListDelete(db, sSelect.pEList); |
| 142065 | 142219 | pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab); |
| 142066 | | - if( pNew ){ |
| 142220 | + if( !db->mallocFailed ){ |
| 142067 | 142221 | NameContext sNC; |
| 142068 | 142222 | memset(&sNC, 0, sizeof(sNC)); |
| 142069 | 142223 | if( pReturning->nRetCol==0 ){ |
| 142070 | 142224 | pReturning->nRetCol = pNew->nExpr; |
| 142071 | 142225 | pReturning->iRetCur = pParse->nTab++; |
| | @@ -142073,28 +142227,34 @@ |
| 142073 | 142227 | sNC.pParse = pParse; |
| 142074 | 142228 | sNC.uNC.iBaseReg = regIn; |
| 142075 | 142229 | sNC.ncFlags = NC_UBaseReg; |
| 142076 | 142230 | pParse->eTriggerOp = pTrigger->op; |
| 142077 | 142231 | pParse->pTriggerTab = pTab; |
| 142078 | | - if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK ){ |
| 142232 | + if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK |
| 142233 | + && !db->mallocFailed |
| 142234 | + ){ |
| 142079 | 142235 | int i; |
| 142080 | 142236 | int nCol = pNew->nExpr; |
| 142081 | 142237 | int reg = pParse->nMem+1; |
| 142082 | 142238 | pParse->nMem += nCol+2; |
| 142083 | 142239 | pReturning->iRetReg = reg; |
| 142084 | 142240 | for(i=0; i<nCol; i++){ |
| 142085 | 142241 | Expr *pCol = pNew->a[i].pExpr; |
| 142242 | + assert( pCol!=0 ); /* Due to !db->mallocFailed ~9 lines above */ |
| 142086 | 142243 | sqlite3ExprCodeFactorable(pParse, pCol, reg+i); |
| 142244 | + if( sqlite3ExprAffinity(pCol)==SQLITE_AFF_REAL ){ |
| 142245 | + sqlite3VdbeAddOp1(v, OP_RealAffinity, reg+i); |
| 142246 | + } |
| 142087 | 142247 | } |
| 142088 | 142248 | sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i); |
| 142089 | 142249 | sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1); |
| 142090 | 142250 | sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1); |
| 142091 | 142251 | } |
| 142092 | | - sqlite3ExprListDelete(db, pNew); |
| 142093 | | - pParse->eTriggerOp = 0; |
| 142094 | | - pParse->pTriggerTab = 0; |
| 142095 | 142252 | } |
| 142253 | + sqlite3ExprListDelete(db, pNew); |
| 142254 | + pParse->eTriggerOp = 0; |
| 142255 | + pParse->pTriggerTab = 0; |
| 142096 | 142256 | } |
| 142097 | 142257 | |
| 142098 | 142258 | |
| 142099 | 142259 | |
| 142100 | 142260 | /* |
| | @@ -145420,11 +145580,10 @@ |
| 145420 | 145580 | */ |
| 145421 | 145581 | SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ |
| 145422 | 145582 | VtabCtx *pCtx; |
| 145423 | 145583 | int rc = SQLITE_OK; |
| 145424 | 145584 | Table *pTab; |
| 145425 | | - char *zErr = 0; |
| 145426 | 145585 | Parse sParse; |
| 145427 | 145586 | int initBusy; |
| 145428 | 145587 | |
| 145429 | 145588 | #ifdef SQLITE_ENABLE_API_ARMOR |
| 145430 | 145589 | if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){ |
| | @@ -145449,15 +145608,16 @@ |
| 145449 | 145608 | ** in case a bug arises. */ |
| 145450 | 145609 | assert( db->init.busy==0 ); |
| 145451 | 145610 | initBusy = db->init.busy; |
| 145452 | 145611 | db->init.busy = 0; |
| 145453 | 145612 | sParse.nQueryLoop = 1; |
| 145454 | | - if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr) |
| 145455 | | - && sParse.pNewTable |
| 145456 | | - && !db->mallocFailed |
| 145613 | + if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) |
| 145614 | + && ALWAYS(sParse.pNewTable!=0) |
| 145615 | + && ALWAYS(!db->mallocFailed) |
| 145457 | 145616 | && IsOrdinaryTable(sParse.pNewTable) |
| 145458 | 145617 | ){ |
| 145618 | + assert( sParse.zErrMsg==0 ); |
| 145459 | 145619 | if( !pTab->aCol ){ |
| 145460 | 145620 | Table *pNew = sParse.pNewTable; |
| 145461 | 145621 | Index *pIdx; |
| 145462 | 145622 | pTab->aCol = pNew->aCol; |
| 145463 | 145623 | sqlite3ExprListDelete(db, pNew->u.tab.pDfltList); |
| | @@ -145483,12 +145643,13 @@ |
| 145483 | 145643 | pIdx->pTable = pTab; |
| 145484 | 145644 | } |
| 145485 | 145645 | } |
| 145486 | 145646 | pCtx->bDeclared = 1; |
| 145487 | 145647 | }else{ |
| 145488 | | - sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr); |
| 145489 | | - sqlite3DbFree(db, zErr); |
| 145648 | + sqlite3ErrorWithMsg(db, SQLITE_ERROR, |
| 145649 | + (sParse.zErrMsg ? "%s" : 0), sParse.zErrMsg); |
| 145650 | + sqlite3DbFree(db, sParse.zErrMsg); |
| 145490 | 145651 | rc = SQLITE_ERROR; |
| 145491 | 145652 | } |
| 145492 | 145653 | sParse.eParseMode = PARSE_MODE_NORMAL; |
| 145493 | 145654 | |
| 145494 | 145655 | if( sParse.pVdbe ){ |
| | @@ -146251,11 +146412,11 @@ |
| 146251 | 146412 | #define TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */ |
| 146252 | 146413 | #define TERM_CODED 0x0004 /* This term is already coded */ |
| 146253 | 146414 | #define TERM_COPIED 0x0008 /* Has a child */ |
| 146254 | 146415 | #define TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */ |
| 146255 | 146416 | #define TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */ |
| 146256 | | -#define TERM_OR_OK 0x0040 /* Used during OR-clause processing */ |
| 146417 | +#define TERM_OK 0x0040 /* Used during OR-clause processing */ |
| 146257 | 146418 | #define TERM_VNULL 0x0080 /* Manufactured x>NULL or x<=NULL term */ |
| 146258 | 146419 | #define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */ |
| 146259 | 146420 | #define TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */ |
| 146260 | 146421 | #define TERM_LIKE 0x0400 /* The original LIKE operator */ |
| 146261 | 146422 | #define TERM_IS 0x0800 /* Term.pExpr is an IS operator */ |
| | @@ -147961,11 +148122,11 @@ |
| 147961 | 148122 | ){ |
| 147962 | 148123 | while( ++iLevel < pWInfo->nLevel ){ |
| 147963 | 148124 | WhereLevel *pLevel = &pWInfo->a[iLevel]; |
| 147964 | 148125 | WhereLoop *pLoop = pLevel->pWLoop; |
| 147965 | 148126 | if( pLevel->regFilter==0 ) continue; |
| 147966 | | - /* ,--- Because constructBloomFilter() has will not have set |
| 148127 | + /* ,--- Because sqlite3ConstructBloomFilter() has will not have set |
| 147967 | 148128 | ** vvvvv--' pLevel->regFilter if this were true. */ |
| 147968 | 148129 | if( NEVER(pLoop->prereq & notReady) ) continue; |
| 147969 | 148130 | if( pLoop->wsFlags & WHERE_IPK ){ |
| 147970 | 148131 | WhereTerm *pTerm = pLoop->aLTerm[0]; |
| 147971 | 148132 | int regRowid; |
| | @@ -147981,10 +148142,11 @@ |
| 147981 | 148142 | u16 nEq = pLoop->u.btree.nEq; |
| 147982 | 148143 | int r1; |
| 147983 | 148144 | char *zStartAff; |
| 147984 | 148145 | |
| 147985 | 148146 | assert( pLoop->wsFlags & WHERE_INDEXED ); |
| 148147 | + assert( (pLoop->wsFlags & WHERE_COLUMN_IN)==0 ); |
| 147986 | 148148 | r1 = codeAllEqualityTerms(pParse,pLevel,0,0,&zStartAff); |
| 147987 | 148149 | codeApplyAffinity(pParse, r1, nEq, zStartAff); |
| 147988 | 148150 | sqlite3DbFree(pParse->db, zStartAff); |
| 147989 | 148151 | sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter, |
| 147990 | 148152 | addrNxt, r1, nEq); |
| | @@ -150043,11 +150205,11 @@ |
| 150043 | 150205 | for(j=0; j<2 && !okToChngToIN; j++){ |
| 150044 | 150206 | Expr *pLeft = 0; |
| 150045 | 150207 | pOrTerm = pOrWc->a; |
| 150046 | 150208 | for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){ |
| 150047 | 150209 | assert( pOrTerm->eOperator & WO_EQ ); |
| 150048 | | - pOrTerm->wtFlags &= ~TERM_OR_OK; |
| 150210 | + pOrTerm->wtFlags &= ~TERM_OK; |
| 150049 | 150211 | if( pOrTerm->leftCursor==iCursor ){ |
| 150050 | 150212 | /* This is the 2-bit case and we are on the second iteration and |
| 150051 | 150213 | ** current term is from the first iteration. So skip this term. */ |
| 150052 | 150214 | assert( j==1 ); |
| 150053 | 150215 | continue; |
| | @@ -150084,11 +150246,11 @@ |
| 150084 | 150246 | okToChngToIN = 1; |
| 150085 | 150247 | for(; i>=0 && okToChngToIN; i--, pOrTerm++){ |
| 150086 | 150248 | assert( pOrTerm->eOperator & WO_EQ ); |
| 150087 | 150249 | assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); |
| 150088 | 150250 | if( pOrTerm->leftCursor!=iCursor ){ |
| 150089 | | - pOrTerm->wtFlags &= ~TERM_OR_OK; |
| 150251 | + pOrTerm->wtFlags &= ~TERM_OK; |
| 150090 | 150252 | }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR |
| 150091 | 150253 | && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1) |
| 150092 | 150254 | )){ |
| 150093 | 150255 | okToChngToIN = 0; |
| 150094 | 150256 | }else{ |
| | @@ -150100,11 +150262,11 @@ |
| 150100 | 150262 | affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight); |
| 150101 | 150263 | affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft); |
| 150102 | 150264 | if( affRight!=0 && affRight!=affLeft ){ |
| 150103 | 150265 | okToChngToIN = 0; |
| 150104 | 150266 | }else{ |
| 150105 | | - pOrTerm->wtFlags |= TERM_OR_OK; |
| 150267 | + pOrTerm->wtFlags |= TERM_OK; |
| 150106 | 150268 | } |
| 150107 | 150269 | } |
| 150108 | 150270 | } |
| 150109 | 150271 | } |
| 150110 | 150272 | |
| | @@ -150117,11 +150279,11 @@ |
| 150117 | 150279 | ExprList *pList = 0; /* The RHS of the IN operator */ |
| 150118 | 150280 | Expr *pLeft = 0; /* The LHS of the IN operator */ |
| 150119 | 150281 | Expr *pNew; /* The complete IN operator */ |
| 150120 | 150282 | |
| 150121 | 150283 | for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){ |
| 150122 | | - if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue; |
| 150284 | + if( (pOrTerm->wtFlags & TERM_OK)==0 ) continue; |
| 150123 | 150285 | assert( pOrTerm->eOperator & WO_EQ ); |
| 150124 | 150286 | assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); |
| 150125 | 150287 | assert( pOrTerm->leftCursor==iCursor ); |
| 150126 | 150288 | assert( pOrTerm->u.x.leftColumn==iColumn ); |
| 150127 | 150289 | pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); |
| | @@ -151651,16 +151813,18 @@ |
| 151651 | 151813 | #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED) |
| 151652 | 151814 | static void whereTraceIndexInfoInputs(sqlite3_index_info *p){ |
| 151653 | 151815 | int i; |
| 151654 | 151816 | if( !sqlite3WhereTrace ) return; |
| 151655 | 151817 | for(i=0; i<p->nConstraint; i++){ |
| 151656 | | - sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n", |
| 151818 | + sqlite3DebugPrintf( |
| 151819 | + " constraint[%d]: col=%d termid=%d op=%d usabled=%d collseq=%s\n", |
| 151657 | 151820 | i, |
| 151658 | 151821 | p->aConstraint[i].iColumn, |
| 151659 | 151822 | p->aConstraint[i].iTermOffset, |
| 151660 | 151823 | p->aConstraint[i].op, |
| 151661 | | - p->aConstraint[i].usable); |
| 151824 | + p->aConstraint[i].usable, |
| 151825 | + sqlite3_vtab_collation(p,i)); |
| 151662 | 151826 | } |
| 151663 | 151827 | for(i=0; i<p->nOrderBy; i++){ |
| 151664 | 151828 | sqlite3DebugPrintf(" orderby[%d]: col=%d desc=%d\n", |
| 151665 | 151829 | i, |
| 151666 | 151830 | p->aOrderBy[i].iColumn, |
| | @@ -151960,11 +152124,11 @@ |
| 151960 | 152124 | ** |
| 151961 | 152125 | ** This routine may only be called if it has previously been determined that |
| 151962 | 152126 | ** the loop would benefit from a Bloom filter, and the WHERE_BLOOMFILTER bit |
| 151963 | 152127 | ** is set. |
| 151964 | 152128 | */ |
| 151965 | | -static SQLITE_NOINLINE void constructBloomFilter( |
| 152129 | +static SQLITE_NOINLINE void sqlite3ConstructBloomFilter( |
| 151966 | 152130 | WhereInfo *pWInfo, /* The WHERE clause */ |
| 151967 | 152131 | int iLevel, /* Index in pWInfo->a[] that is pLevel */ |
| 151968 | 152132 | WhereLevel *pLevel, /* Make a Bloom filter for this FROM term */ |
| 151969 | 152133 | Bitmask notReady /* Loops that are not ready */ |
| 151970 | 152134 | ){ |
| | @@ -152044,17 +152208,24 @@ |
| 152044 | 152208 | sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); |
| 152045 | 152209 | VdbeCoverage(v); |
| 152046 | 152210 | sqlite3VdbeJumpHere(v, addrTop); |
| 152047 | 152211 | pLoop->wsFlags &= ~WHERE_BLOOMFILTER; |
| 152048 | 152212 | if( OptimizationDisabled(pParse->db, SQLITE_BloomPulldown) ) break; |
| 152049 | | - while( iLevel < pWInfo->nLevel ){ |
| 152050 | | - iLevel++; |
| 152213 | + while( ++iLevel < pWInfo->nLevel ){ |
| 152051 | 152214 | pLevel = &pWInfo->a[iLevel]; |
| 152052 | 152215 | pLoop = pLevel->pWLoop; |
| 152053 | | - if( pLoop==0 ) continue; |
| 152216 | + if( NEVER(pLoop==0) ) continue; |
| 152054 | 152217 | if( pLoop->prereq & notReady ) continue; |
| 152055 | | - if( pLoop->wsFlags & WHERE_BLOOMFILTER ) break; |
| 152218 | + if( (pLoop->wsFlags & (WHERE_BLOOMFILTER|WHERE_COLUMN_IN)) |
| 152219 | + ==WHERE_BLOOMFILTER |
| 152220 | + ){ |
| 152221 | + /* This is a candidate for bloom-filter pull-down (early evaluation). |
| 152222 | + ** The test that WHERE_COLUMN_IN is omitted is important, as we are |
| 152223 | + ** not able to do early evaluation of bloom filters that make use of |
| 152224 | + ** the IN operator */ |
| 152225 | + break; |
| 152226 | + } |
| 152056 | 152227 | } |
| 152057 | 152228 | }while( iLevel < pWInfo->nLevel ); |
| 152058 | 152229 | sqlite3VdbeJumpHere(v, addrOnce); |
| 152059 | 152230 | } |
| 152060 | 152231 | |
| | @@ -152081,14 +152252,23 @@ |
| 152081 | 152252 | struct HiddenIndexInfo *pHidden; |
| 152082 | 152253 | WhereTerm *pTerm; |
| 152083 | 152254 | int nOrderBy; |
| 152084 | 152255 | sqlite3_index_info *pIdxInfo; |
| 152085 | 152256 | u16 mNoOmit = 0; |
| 152257 | + const Table *pTab; |
| 152086 | 152258 | |
| 152087 | | - /* Count the number of possible WHERE clause constraints referring |
| 152088 | | - ** to this virtual table */ |
| 152259 | + assert( pSrc!=0 ); |
| 152260 | + pTab = pSrc->pTab; |
| 152261 | + assert( pTab!=0 ); |
| 152262 | + assert( IsVirtual(pTab) ); |
| 152263 | + |
| 152264 | + /* Find all WHERE clause constraints referring to this virtual table. |
| 152265 | + ** Mark each term with the TERM_OK flag. Set nTerm to the number of |
| 152266 | + ** terms found. |
| 152267 | + */ |
| 152089 | 152268 | for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){ |
| 152269 | + pTerm->wtFlags &= ~TERM_OK; |
| 152090 | 152270 | if( pTerm->leftCursor != pSrc->iCursor ) continue; |
| 152091 | 152271 | if( pTerm->prereqRight & mUnusable ) continue; |
| 152092 | 152272 | assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); |
| 152093 | 152273 | testcase( pTerm->eOperator & WO_IN ); |
| 152094 | 152274 | testcase( pTerm->eOperator & WO_ISNULL ); |
| | @@ -152095,12 +152275,23 @@ |
| 152095 | 152275 | testcase( pTerm->eOperator & WO_IS ); |
| 152096 | 152276 | testcase( pTerm->eOperator & WO_ALL ); |
| 152097 | 152277 | if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; |
| 152098 | 152278 | if( pTerm->wtFlags & TERM_VNULL ) continue; |
| 152099 | 152279 | assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); |
| 152100 | | - assert( pTerm->u.x.leftColumn>=(-1) ); |
| 152280 | + assert( pTerm->u.x.leftColumn>=XN_ROWID ); |
| 152281 | + assert( pTerm->u.x.leftColumn<pTab->nCol ); |
| 152282 | + |
| 152283 | + /* tag-20191211-002: WHERE-clause constraints are not useful to the |
| 152284 | + ** right-hand table of a LEFT JOIN. See tag-20191211-001 for the |
| 152285 | + ** equivalent restriction for ordinary tables. */ |
| 152286 | + if( (pSrc->fg.jointype & JT_LEFT)!=0 |
| 152287 | + && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) |
| 152288 | + ){ |
| 152289 | + continue; |
| 152290 | + } |
| 152101 | 152291 | nTerm++; |
| 152292 | + pTerm->wtFlags |= TERM_OK; |
| 152102 | 152293 | } |
| 152103 | 152294 | |
| 152104 | 152295 | /* If the ORDER BY clause contains only columns in the current |
| 152105 | 152296 | ** virtual table then allocate space for the aOrderBy part of |
| 152106 | 152297 | ** the sqlite3_index_info structure. |
| | @@ -152108,12 +152299,45 @@ |
| 152108 | 152299 | nOrderBy = 0; |
| 152109 | 152300 | if( pOrderBy ){ |
| 152110 | 152301 | int n = pOrderBy->nExpr; |
| 152111 | 152302 | for(i=0; i<n; i++){ |
| 152112 | 152303 | Expr *pExpr = pOrderBy->a[i].pExpr; |
| 152113 | | - if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break; |
| 152304 | + Expr *pE2; |
| 152305 | + |
| 152306 | + /* Skip over constant terms in the ORDER BY clause */ |
| 152307 | + if( sqlite3ExprIsConstant(pExpr) ){ |
| 152308 | + continue; |
| 152309 | + } |
| 152310 | + |
| 152311 | + /* Virtual tables are unable to deal with NULLS FIRST */ |
| 152114 | 152312 | if( pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL ) break; |
| 152313 | + |
| 152314 | + /* First case - a direct column references without a COLLATE operator */ |
| 152315 | + if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){ |
| 152316 | + assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol ); |
| 152317 | + continue; |
| 152318 | + } |
| 152319 | + |
| 152320 | + /* 2nd case - a column reference with a COLLATE operator. Only match |
| 152321 | + ** of the COLLATE operator matches the collation of the column. */ |
| 152322 | + if( pExpr->op==TK_COLLATE |
| 152323 | + && (pE2 = pExpr->pLeft)->op==TK_COLUMN |
| 152324 | + && pE2->iTable==pSrc->iCursor |
| 152325 | + ){ |
| 152326 | + const char *zColl; /* The collating sequence name */ |
| 152327 | + assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
| 152328 | + assert( pExpr->u.zToken!=0 ); |
| 152329 | + assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol ); |
| 152330 | + pExpr->iColumn = pE2->iColumn; |
| 152331 | + if( pE2->iColumn<0 ) continue; /* Collseq does not matter for rowid */ |
| 152332 | + zColl = sqlite3ColumnColl(&pTab->aCol[pE2->iColumn]); |
| 152333 | + if( zColl==0 ) zColl = sqlite3StrBINARY; |
| 152334 | + if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue; |
| 152335 | + } |
| 152336 | + |
| 152337 | + /* No matches cause a break out of the loop */ |
| 152338 | + break; |
| 152115 | 152339 | } |
| 152116 | 152340 | if( i==n){ |
| 152117 | 152341 | nOrderBy = n; |
| 152118 | 152342 | } |
| 152119 | 152343 | } |
| | @@ -152129,38 +152353,18 @@ |
| 152129 | 152353 | } |
| 152130 | 152354 | pHidden = (struct HiddenIndexInfo*)&pIdxInfo[1]; |
| 152131 | 152355 | pIdxCons = (struct sqlite3_index_constraint*)&pHidden[1]; |
| 152132 | 152356 | pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm]; |
| 152133 | 152357 | pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy]; |
| 152134 | | - pIdxInfo->nOrderBy = nOrderBy; |
| 152135 | 152358 | pIdxInfo->aConstraint = pIdxCons; |
| 152136 | 152359 | pIdxInfo->aOrderBy = pIdxOrderBy; |
| 152137 | 152360 | pIdxInfo->aConstraintUsage = pUsage; |
| 152138 | 152361 | pHidden->pWC = pWC; |
| 152139 | 152362 | pHidden->pParse = pParse; |
| 152140 | 152363 | for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){ |
| 152141 | 152364 | u16 op; |
| 152142 | | - if( pTerm->leftCursor != pSrc->iCursor ) continue; |
| 152143 | | - if( pTerm->prereqRight & mUnusable ) continue; |
| 152144 | | - assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); |
| 152145 | | - testcase( pTerm->eOperator & WO_IN ); |
| 152146 | | - testcase( pTerm->eOperator & WO_IS ); |
| 152147 | | - testcase( pTerm->eOperator & WO_ISNULL ); |
| 152148 | | - testcase( pTerm->eOperator & WO_ALL ); |
| 152149 | | - if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; |
| 152150 | | - if( pTerm->wtFlags & TERM_VNULL ) continue; |
| 152151 | | - |
| 152152 | | - /* tag-20191211-002: WHERE-clause constraints are not useful to the |
| 152153 | | - ** right-hand table of a LEFT JOIN. See tag-20191211-001 for the |
| 152154 | | - ** equivalent restriction for ordinary tables. */ |
| 152155 | | - if( (pSrc->fg.jointype & JT_LEFT)!=0 |
| 152156 | | - && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) |
| 152157 | | - ){ |
| 152158 | | - continue; |
| 152159 | | - } |
| 152160 | | - assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); |
| 152161 | | - assert( pTerm->u.x.leftColumn>=(-1) ); |
| 152365 | + if( (pTerm->wtFlags & TERM_OK)==0 ) continue; |
| 152162 | 152366 | pIdxCons[j].iColumn = pTerm->u.x.leftColumn; |
| 152163 | 152367 | pIdxCons[j].iTermOffset = i; |
| 152164 | 152368 | op = pTerm->eOperator & WO_ALL; |
| 152165 | 152369 | if( op==WO_IN ) op = WO_EQ; |
| 152166 | 152370 | if( op==WO_AUX ){ |
| | @@ -152193,16 +152397,23 @@ |
| 152193 | 152397 | } |
| 152194 | 152398 | } |
| 152195 | 152399 | |
| 152196 | 152400 | j++; |
| 152197 | 152401 | } |
| 152402 | + assert( j==nTerm ); |
| 152198 | 152403 | pIdxInfo->nConstraint = j; |
| 152199 | | - for(i=0; i<nOrderBy; i++){ |
| 152404 | + for(i=j=0; i<nOrderBy; i++){ |
| 152200 | 152405 | Expr *pExpr = pOrderBy->a[i].pExpr; |
| 152201 | | - pIdxOrderBy[i].iColumn = pExpr->iColumn; |
| 152202 | | - pIdxOrderBy[i].desc = pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC; |
| 152406 | + if( sqlite3ExprIsConstant(pExpr) ) continue; |
| 152407 | + assert( pExpr->op==TK_COLUMN |
| 152408 | + || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN |
| 152409 | + && pExpr->iColumn==pExpr->pLeft->iColumn) ); |
| 152410 | + pIdxOrderBy[j].iColumn = pExpr->iColumn; |
| 152411 | + pIdxOrderBy[j].desc = pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC; |
| 152412 | + j++; |
| 152203 | 152413 | } |
| 152414 | + pIdxInfo->nOrderBy = j; |
| 152204 | 152415 | |
| 152205 | 152416 | *pmNoOmit = mNoOmit; |
| 152206 | 152417 | return pIdxInfo; |
| 152207 | 152418 | } |
| 152208 | 152419 | |
| | @@ -154530,15 +154741,23 @@ |
| 154530 | 154741 | |
| 154531 | 154742 | return rc; |
| 154532 | 154743 | } |
| 154533 | 154744 | |
| 154534 | 154745 | /* |
| 154535 | | -** If this function is invoked from within an xBestIndex() callback, it |
| 154536 | | -** returns a pointer to a buffer containing the name of the collation |
| 154537 | | -** sequence associated with element iCons of the sqlite3_index_info.aConstraint |
| 154538 | | -** array. Or, if iCons is out of range or there is no active xBestIndex |
| 154539 | | -** call, return NULL. |
| 154746 | +** Return the collating sequence for a constraint passed into xBestIndex. |
| 154747 | +** |
| 154748 | +** pIdxInfo must be an sqlite3_index_info structure passed into xBestIndex. |
| 154749 | +** This routine depends on there being a HiddenIndexInfo structure immediately |
| 154750 | +** following the sqlite3_index_info structure. |
| 154751 | +** |
| 154752 | +** Return a pointer to the collation name: |
| 154753 | +** |
| 154754 | +** 1. If there is an explicit COLLATE operator on the constaint, return it. |
| 154755 | +** |
| 154756 | +** 2. Else, if the column has an alternative collation, return that. |
| 154757 | +** |
| 154758 | +** 3. Otherwise, return "BINARY". |
| 154540 | 154759 | */ |
| 154541 | 154760 | SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int iCons){ |
| 154542 | 154761 | HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; |
| 154543 | 154762 | const char *zRet = 0; |
| 154544 | 154763 | if( iCons>=0 && iCons<pIdxInfo->nConstraint ){ |
| | @@ -155972,11 +156191,11 @@ |
| 155972 | 156191 | assert( pWInfo->nLevel>=2 ); |
| 155973 | 156192 | assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) ); |
| 155974 | 156193 | nSearch = pWInfo->a[0].pWLoop->nOut; |
| 155975 | 156194 | for(i=1; i<pWInfo->nLevel; i++){ |
| 155976 | 156195 | WhereLoop *pLoop = pWInfo->a[i].pWLoop; |
| 155977 | | - const int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ); |
| 156196 | + const unsigned int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ); |
| 155978 | 156197 | if( (pLoop->wsFlags & reqFlags)==reqFlags |
| 155979 | 156198 | /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */ |
| 155980 | 156199 | && ALWAYS((pLoop->wsFlags & (WHERE_IPK|WHERE_INDEXED))!=0) |
| 155981 | 156200 | ){ |
| 155982 | 156201 | SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab]; |
| | @@ -156590,11 +156809,11 @@ |
| 156590 | 156809 | #ifndef SQLITE_OMIT_AUTOMATIC_INDEX |
| 156591 | 156810 | constructAutomaticIndex(pParse, &pWInfo->sWC, |
| 156592 | 156811 | &pTabList->a[pLevel->iFrom], notReady, pLevel); |
| 156593 | 156812 | #endif |
| 156594 | 156813 | }else{ |
| 156595 | | - constructBloomFilter(pWInfo, ii, pLevel, notReady); |
| 156814 | + sqlite3ConstructBloomFilter(pWInfo, ii, pLevel, notReady); |
| 156596 | 156815 | } |
| 156597 | 156816 | if( db->mallocFailed ) goto whereBeginError; |
| 156598 | 156817 | } |
| 156599 | 156818 | addrExplain = sqlite3WhereExplainOneScan( |
| 156600 | 156819 | pParse, pTabList, pLevel, wctrlFlags |
| | @@ -160320,14 +160539,14 @@ |
| 160320 | 160539 | #define TK_DETACH 40 |
| 160321 | 160540 | #define TK_EACH 41 |
| 160322 | 160541 | #define TK_FAIL 42 |
| 160323 | 160542 | #define TK_OR 43 |
| 160324 | 160543 | #define TK_AND 44 |
| 160325 | | -#define TK_MATCH 45 |
| 160326 | | -#define TK_LIKE_KW 46 |
| 160327 | | -#define TK_BETWEEN 47 |
| 160328 | | -#define TK_IS 48 |
| 160544 | +#define TK_IS 45 |
| 160545 | +#define TK_MATCH 46 |
| 160546 | +#define TK_LIKE_KW 47 |
| 160547 | +#define TK_BETWEEN 48 |
| 160329 | 160548 | #define TK_IN 49 |
| 160330 | 160549 | #define TK_ISNULL 50 |
| 160331 | 160550 | #define TK_NOTNULL 51 |
| 160332 | 160551 | #define TK_NE 52 |
| 160333 | 160552 | #define TK_EQ 53 |
| | @@ -160387,82 +160606,83 @@ |
| 160387 | 160606 | #define TK_MINUS 107 |
| 160388 | 160607 | #define TK_STAR 108 |
| 160389 | 160608 | #define TK_SLASH 109 |
| 160390 | 160609 | #define TK_REM 110 |
| 160391 | 160610 | #define TK_CONCAT 111 |
| 160392 | | -#define TK_COLLATE 112 |
| 160393 | | -#define TK_BITNOT 113 |
| 160394 | | -#define TK_ON 114 |
| 160395 | | -#define TK_INDEXED 115 |
| 160396 | | -#define TK_STRING 116 |
| 160397 | | -#define TK_JOIN_KW 117 |
| 160398 | | -#define TK_CONSTRAINT 118 |
| 160399 | | -#define TK_DEFAULT 119 |
| 160400 | | -#define TK_NULL 120 |
| 160401 | | -#define TK_PRIMARY 121 |
| 160402 | | -#define TK_UNIQUE 122 |
| 160403 | | -#define TK_CHECK 123 |
| 160404 | | -#define TK_REFERENCES 124 |
| 160405 | | -#define TK_AUTOINCR 125 |
| 160406 | | -#define TK_INSERT 126 |
| 160407 | | -#define TK_DELETE 127 |
| 160408 | | -#define TK_UPDATE 128 |
| 160409 | | -#define TK_SET 129 |
| 160410 | | -#define TK_DEFERRABLE 130 |
| 160411 | | -#define TK_FOREIGN 131 |
| 160412 | | -#define TK_DROP 132 |
| 160413 | | -#define TK_UNION 133 |
| 160414 | | -#define TK_ALL 134 |
| 160415 | | -#define TK_EXCEPT 135 |
| 160416 | | -#define TK_INTERSECT 136 |
| 160417 | | -#define TK_SELECT 137 |
| 160418 | | -#define TK_VALUES 138 |
| 160419 | | -#define TK_DISTINCT 139 |
| 160420 | | -#define TK_DOT 140 |
| 160421 | | -#define TK_FROM 141 |
| 160422 | | -#define TK_JOIN 142 |
| 160423 | | -#define TK_USING 143 |
| 160424 | | -#define TK_ORDER 144 |
| 160425 | | -#define TK_GROUP 145 |
| 160426 | | -#define TK_HAVING 146 |
| 160427 | | -#define TK_LIMIT 147 |
| 160428 | | -#define TK_WHERE 148 |
| 160429 | | -#define TK_RETURNING 149 |
| 160430 | | -#define TK_INTO 150 |
| 160431 | | -#define TK_NOTHING 151 |
| 160432 | | -#define TK_FLOAT 152 |
| 160433 | | -#define TK_BLOB 153 |
| 160434 | | -#define TK_INTEGER 154 |
| 160435 | | -#define TK_VARIABLE 155 |
| 160436 | | -#define TK_CASE 156 |
| 160437 | | -#define TK_WHEN 157 |
| 160438 | | -#define TK_THEN 158 |
| 160439 | | -#define TK_ELSE 159 |
| 160440 | | -#define TK_INDEX 160 |
| 160441 | | -#define TK_ALTER 161 |
| 160442 | | -#define TK_ADD 162 |
| 160443 | | -#define TK_WINDOW 163 |
| 160444 | | -#define TK_OVER 164 |
| 160445 | | -#define TK_FILTER 165 |
| 160446 | | -#define TK_COLUMN 166 |
| 160447 | | -#define TK_AGG_FUNCTION 167 |
| 160448 | | -#define TK_AGG_COLUMN 168 |
| 160449 | | -#define TK_TRUEFALSE 169 |
| 160450 | | -#define TK_ISNOT 170 |
| 160451 | | -#define TK_FUNCTION 171 |
| 160452 | | -#define TK_UMINUS 172 |
| 160453 | | -#define TK_UPLUS 173 |
| 160454 | | -#define TK_TRUTH 174 |
| 160455 | | -#define TK_REGISTER 175 |
| 160456 | | -#define TK_VECTOR 176 |
| 160457 | | -#define TK_SELECT_COLUMN 177 |
| 160458 | | -#define TK_IF_NULL_ROW 178 |
| 160459 | | -#define TK_ASTERISK 179 |
| 160460 | | -#define TK_SPAN 180 |
| 160461 | | -#define TK_ERROR 181 |
| 160462 | | -#define TK_SPACE 182 |
| 160463 | | -#define TK_ILLEGAL 183 |
| 160611 | +#define TK_PTR 112 |
| 160612 | +#define TK_COLLATE 113 |
| 160613 | +#define TK_BITNOT 114 |
| 160614 | +#define TK_ON 115 |
| 160615 | +#define TK_INDEXED 116 |
| 160616 | +#define TK_STRING 117 |
| 160617 | +#define TK_JOIN_KW 118 |
| 160618 | +#define TK_CONSTRAINT 119 |
| 160619 | +#define TK_DEFAULT 120 |
| 160620 | +#define TK_NULL 121 |
| 160621 | +#define TK_PRIMARY 122 |
| 160622 | +#define TK_UNIQUE 123 |
| 160623 | +#define TK_CHECK 124 |
| 160624 | +#define TK_REFERENCES 125 |
| 160625 | +#define TK_AUTOINCR 126 |
| 160626 | +#define TK_INSERT 127 |
| 160627 | +#define TK_DELETE 128 |
| 160628 | +#define TK_UPDATE 129 |
| 160629 | +#define TK_SET 130 |
| 160630 | +#define TK_DEFERRABLE 131 |
| 160631 | +#define TK_FOREIGN 132 |
| 160632 | +#define TK_DROP 133 |
| 160633 | +#define TK_UNION 134 |
| 160634 | +#define TK_ALL 135 |
| 160635 | +#define TK_EXCEPT 136 |
| 160636 | +#define TK_INTERSECT 137 |
| 160637 | +#define TK_SELECT 138 |
| 160638 | +#define TK_VALUES 139 |
| 160639 | +#define TK_DISTINCT 140 |
| 160640 | +#define TK_DOT 141 |
| 160641 | +#define TK_FROM 142 |
| 160642 | +#define TK_JOIN 143 |
| 160643 | +#define TK_USING 144 |
| 160644 | +#define TK_ORDER 145 |
| 160645 | +#define TK_GROUP 146 |
| 160646 | +#define TK_HAVING 147 |
| 160647 | +#define TK_LIMIT 148 |
| 160648 | +#define TK_WHERE 149 |
| 160649 | +#define TK_RETURNING 150 |
| 160650 | +#define TK_INTO 151 |
| 160651 | +#define TK_NOTHING 152 |
| 160652 | +#define TK_FLOAT 153 |
| 160653 | +#define TK_BLOB 154 |
| 160654 | +#define TK_INTEGER 155 |
| 160655 | +#define TK_VARIABLE 156 |
| 160656 | +#define TK_CASE 157 |
| 160657 | +#define TK_WHEN 158 |
| 160658 | +#define TK_THEN 159 |
| 160659 | +#define TK_ELSE 160 |
| 160660 | +#define TK_INDEX 161 |
| 160661 | +#define TK_ALTER 162 |
| 160662 | +#define TK_ADD 163 |
| 160663 | +#define TK_WINDOW 164 |
| 160664 | +#define TK_OVER 165 |
| 160665 | +#define TK_FILTER 166 |
| 160666 | +#define TK_COLUMN 167 |
| 160667 | +#define TK_AGG_FUNCTION 168 |
| 160668 | +#define TK_AGG_COLUMN 169 |
| 160669 | +#define TK_TRUEFALSE 170 |
| 160670 | +#define TK_ISNOT 171 |
| 160671 | +#define TK_FUNCTION 172 |
| 160672 | +#define TK_UMINUS 173 |
| 160673 | +#define TK_UPLUS 174 |
| 160674 | +#define TK_TRUTH 175 |
| 160675 | +#define TK_REGISTER 176 |
| 160676 | +#define TK_VECTOR 177 |
| 160677 | +#define TK_SELECT_COLUMN 178 |
| 160678 | +#define TK_IF_NULL_ROW 179 |
| 160679 | +#define TK_ASTERISK 180 |
| 160680 | +#define TK_SPAN 181 |
| 160681 | +#define TK_ERROR 182 |
| 160682 | +#define TK_SPACE 183 |
| 160683 | +#define TK_ILLEGAL 184 |
| 160464 | 160684 | #endif |
| 160465 | 160685 | /**************** End token definitions ***************************************/ |
| 160466 | 160686 | |
| 160467 | 160687 | /* The next sections is a series of control #defines. |
| 160468 | 160688 | ** various aspects of the generated parser. |
| | @@ -160518,34 +160738,34 @@ |
| 160518 | 160738 | #ifndef INTERFACE |
| 160519 | 160739 | # define INTERFACE 1 |
| 160520 | 160740 | #endif |
| 160521 | 160741 | /************* Begin control #defines *****************************************/ |
| 160522 | 160742 | #define YYCODETYPE unsigned short int |
| 160523 | | -#define YYNOCODE 318 |
| 160743 | +#define YYNOCODE 319 |
| 160524 | 160744 | #define YYACTIONTYPE unsigned short int |
| 160525 | 160745 | #define YYWILDCARD 101 |
| 160526 | 160746 | #define sqlite3ParserTOKENTYPE Token |
| 160527 | 160747 | typedef union { |
| 160528 | 160748 | int yyinit; |
| 160529 | 160749 | sqlite3ParserTOKENTYPE yy0; |
| 160530 | | - With* yy43; |
| 160531 | | - u32 yy51; |
| 160532 | | - int yy64; |
| 160533 | | - struct FrameBound yy81; |
| 160534 | | - struct {int value; int mask;} yy83; |
| 160535 | | - TriggerStep* yy95; |
| 160536 | | - Upsert* yy138; |
| 160537 | | - IdList* yy240; |
| 160538 | | - Cte* yy255; |
| 160539 | | - Select* yy303; |
| 160540 | | - Window* yy375; |
| 160541 | | - u8 yy534; |
| 160542 | | - ExprList* yy562; |
| 160543 | | - struct TrigEvent yy570; |
| 160544 | | - const char* yy600; |
| 160545 | | - SrcList* yy607; |
| 160546 | | - Expr* yy626; |
| 160750 | + TriggerStep* yy33; |
| 160751 | + Window* yy41; |
| 160752 | + Select* yy47; |
| 160753 | + SrcList* yy131; |
| 160754 | + struct TrigEvent yy180; |
| 160755 | + struct {int value; int mask;} yy231; |
| 160756 | + IdList* yy254; |
| 160757 | + u32 yy285; |
| 160758 | + ExprList* yy322; |
| 160759 | + Cte* yy385; |
| 160760 | + int yy394; |
| 160761 | + Upsert* yy444; |
| 160762 | + u8 yy516; |
| 160763 | + With* yy521; |
| 160764 | + const char* yy522; |
| 160765 | + Expr* yy528; |
| 160766 | + struct FrameBound yy595; |
| 160547 | 160767 | } YYMINORTYPE; |
| 160548 | 160768 | #ifndef YYSTACKDEPTH |
| 160549 | 160769 | #define YYSTACKDEPTH 100 |
| 160550 | 160770 | #endif |
| 160551 | 160771 | #define sqlite3ParserARG_SDECL |
| | @@ -160557,22 +160777,22 @@ |
| 160557 | 160777 | #define sqlite3ParserCTX_PDECL ,Parse *pParse |
| 160558 | 160778 | #define sqlite3ParserCTX_PARAM ,pParse |
| 160559 | 160779 | #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse; |
| 160560 | 160780 | #define sqlite3ParserCTX_STORE yypParser->pParse=pParse; |
| 160561 | 160781 | #define YYFALLBACK 1 |
| 160562 | | -#define YYNSTATE 572 |
| 160563 | | -#define YYNRULE 401 |
| 160564 | | -#define YYNRULE_WITH_ACTION 339 |
| 160565 | | -#define YYNTOKEN 184 |
| 160566 | | -#define YY_MAX_SHIFT 571 |
| 160567 | | -#define YY_MIN_SHIFTREDUCE 829 |
| 160568 | | -#define YY_MAX_SHIFTREDUCE 1229 |
| 160569 | | -#define YY_ERROR_ACTION 1230 |
| 160570 | | -#define YY_ACCEPT_ACTION 1231 |
| 160571 | | -#define YY_NO_ACTION 1232 |
| 160572 | | -#define YY_MIN_REDUCE 1233 |
| 160573 | | -#define YY_MAX_REDUCE 1633 |
| 160782 | +#define YYNSTATE 574 |
| 160783 | +#define YYNRULE 402 |
| 160784 | +#define YYNRULE_WITH_ACTION 340 |
| 160785 | +#define YYNTOKEN 185 |
| 160786 | +#define YY_MAX_SHIFT 573 |
| 160787 | +#define YY_MIN_SHIFTREDUCE 831 |
| 160788 | +#define YY_MAX_SHIFTREDUCE 1232 |
| 160789 | +#define YY_ERROR_ACTION 1233 |
| 160790 | +#define YY_ACCEPT_ACTION 1234 |
| 160791 | +#define YY_NO_ACTION 1235 |
| 160792 | +#define YY_MIN_REDUCE 1236 |
| 160793 | +#define YY_MAX_REDUCE 1637 |
| 160574 | 160794 | /************* End control #defines *******************************************/ |
| 160575 | 160795 | #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) |
| 160576 | 160796 | |
| 160577 | 160797 | /* Define the yytestcase() macro to be a no-op if is not already defined |
| 160578 | 160798 | ** otherwise. |
| | @@ -160635,607 +160855,616 @@ |
| 160635 | 160855 | ** yy_reduce_ofst[] For each state, the offset into yy_action for |
| 160636 | 160856 | ** shifting non-terminals after a reduce. |
| 160637 | 160857 | ** yy_default[] Default action for each state. |
| 160638 | 160858 | ** |
| 160639 | 160859 | *********** Begin parsing tables **********************************************/ |
| 160640 | | -#define YY_ACTTAB_COUNT (2022) |
| 160860 | +#define YY_ACTTAB_COUNT (2070) |
| 160641 | 160861 | static const YYACTIONTYPE yy_action[] = { |
| 160642 | | - /* 0 */ 564, 115, 112, 220, 169, 199, 115, 112, 220, 564, |
| 160643 | | - /* 10 */ 375, 1266, 564, 376, 564, 270, 1309, 1309, 406, 407, |
| 160644 | | - /* 20 */ 1084, 199, 1513, 41, 41, 515, 489, 521, 558, 558, |
| 160645 | | - /* 30 */ 558, 965, 41, 41, 395, 41, 41, 51, 51, 966, |
| 160646 | | - /* 40 */ 296, 1269, 296, 122, 123, 1207, 1207, 1041, 113, 1044, |
| 160647 | | - /* 50 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 564, 407, |
| 160648 | | - /* 60 */ 275, 275, 275, 275, 1268, 115, 112, 220, 115, 112, |
| 160649 | | - /* 70 */ 220, 1512, 846, 561, 516, 561, 115, 112, 220, 250, |
| 160650 | | - /* 80 */ 217, 71, 71, 122, 123, 1207, 1207, 1041, 113, 1044, |
| 160651 | | - /* 90 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 440, 440, |
| 160652 | | - /* 100 */ 440, 1149, 119, 119, 119, 119, 118, 118, 117, 117, |
| 160653 | | - /* 110 */ 117, 116, 442, 1183, 1149, 116, 442, 1149, 546, 513, |
| 160654 | | - /* 120 */ 1548, 1554, 374, 213, 6, 169, 1154, 522, 1154, 407, |
| 160655 | | - /* 130 */ 1556, 461, 373, 1554, 535, 99, 463, 332, 121, 121, |
| 160656 | | - /* 140 */ 121, 121, 119, 119, 119, 119, 118, 118, 117, 117, |
| 160657 | | - /* 150 */ 117, 116, 442, 122, 123, 1207, 1207, 1041, 113, 1044, |
| 160658 | | - /* 160 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 1257, 1183, |
| 160659 | | - /* 170 */ 1184, 1185, 243, 1064, 564, 502, 499, 498, 567, 124, |
| 160660 | | - /* 180 */ 567, 1128, 1627, 344, 1627, 497, 119, 119, 119, 119, |
| 160661 | | - /* 190 */ 118, 118, 117, 117, 117, 116, 442, 70, 70, 407, |
| 160662 | | - /* 200 */ 121, 121, 121, 121, 114, 117, 117, 117, 116, 442, |
| 160663 | | - /* 210 */ 474, 1469, 119, 119, 119, 119, 118, 118, 117, 117, |
| 160664 | | - /* 220 */ 117, 116, 442, 122, 123, 1207, 1207, 1041, 113, 1044, |
| 160665 | | - /* 230 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 407, 208, |
| 160666 | | - /* 240 */ 539, 1548, 1424, 81, 339, 6, 342, 80, 119, 119, |
| 160667 | | - /* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 381, |
| 160668 | | - /* 260 */ 1126, 442, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, |
| 160669 | | - /* 270 */ 1034, 120, 120, 121, 121, 121, 121, 262, 463, 332, |
| 160670 | | - /* 280 */ 359, 1567, 119, 119, 119, 119, 118, 118, 117, 117, |
| 160671 | | - /* 290 */ 117, 116, 442, 1231, 1, 1, 571, 2, 1235, 1573, |
| 160672 | | - /* 300 */ 571, 2, 1235, 307, 1149, 141, 417, 307, 407, 141, |
| 160673 | | - /* 310 */ 1183, 98, 1317, 489, 866, 531, 1317, 1149, 215, 512, |
| 160674 | | - /* 320 */ 1149, 119, 119, 119, 119, 118, 118, 117, 117, 117, |
| 160675 | | - /* 330 */ 116, 442, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, |
| 160676 | | - /* 340 */ 1034, 120, 120, 121, 121, 121, 121, 275, 275, 1001, |
| 160677 | | - /* 350 */ 1257, 275, 275, 1128, 1628, 1021, 1628, 137, 415, 1600, |
| 160678 | | - /* 360 */ 561, 272, 1255, 950, 561, 1423, 1183, 1184, 1185, 1594, |
| 160679 | | - /* 370 */ 866, 1012, 530, 315, 231, 1011, 317, 1276, 231, 119, |
| 160680 | | - /* 380 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, |
| 160681 | | - /* 390 */ 1570, 119, 119, 119, 119, 118, 118, 117, 117, 117, |
| 160682 | | - /* 400 */ 116, 442, 330, 359, 1567, 564, 446, 1011, 1011, 1013, |
| 160683 | | - /* 410 */ 446, 877, 564, 306, 555, 407, 447, 1021, 563, 346, |
| 160684 | | - /* 420 */ 184, 118, 118, 117, 117, 117, 116, 442, 71, 71, |
| 160685 | | - /* 430 */ 439, 438, 1126, 1012, 472, 71, 71, 1011, 205, 122, |
| 160686 | | - /* 440 */ 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, |
| 160687 | | - /* 450 */ 121, 121, 121, 121, 1304, 219, 1283, 1183, 407, 570, |
| 160688 | | - /* 460 */ 1183, 1235, 503, 1477, 1304, 546, 307, 489, 141, 1011, |
| 160689 | | - /* 470 */ 1011, 1013, 546, 140, 545, 1317, 1214, 382, 1214, 378, |
| 160690 | | - /* 480 */ 950, 514, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, |
| 160691 | | - /* 490 */ 1034, 120, 120, 121, 121, 121, 121, 472, 119, 119, |
| 160692 | | - /* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 283, |
| 160693 | | - /* 510 */ 275, 275, 1476, 1183, 1184, 1185, 1183, 1184, 1185, 417, |
| 160694 | | - /* 520 */ 1183, 243, 541, 561, 502, 499, 498, 1001, 407, 478, |
| 160695 | | - /* 530 */ 1183, 472, 870, 143, 497, 1549, 185, 231, 9, 6, |
| 160696 | | - /* 540 */ 253, 119, 119, 119, 119, 118, 118, 117, 117, 117, |
| 160697 | | - /* 550 */ 116, 442, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, |
| 160698 | | - /* 560 */ 1034, 120, 120, 121, 121, 121, 121, 407, 372, 446, |
| 160699 | | - /* 570 */ 363, 863, 288, 1183, 397, 1204, 1183, 1184, 1185, 931, |
| 160700 | | - /* 580 */ 330, 458, 318, 526, 564, 541, 1183, 1184, 1185, 284, |
| 160701 | | - /* 590 */ 1183, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, |
| 160702 | | - /* 600 */ 120, 120, 121, 121, 121, 121, 291, 71, 71, 275, |
| 160703 | | - /* 610 */ 275, 119, 119, 119, 119, 118, 118, 117, 117, 117, |
| 160704 | | - /* 620 */ 116, 442, 561, 1031, 1031, 1042, 1183, 1045, 287, 1183, |
| 160705 | | - /* 630 */ 1184, 1185, 1204, 137, 218, 542, 1541, 407, 363, 470, |
| 160706 | | - /* 640 */ 431, 1167, 32, 363, 527, 350, 1183, 1184, 1185, 380, |
| 160707 | | - /* 650 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, |
| 160708 | | - /* 660 */ 442, 122, 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, |
| 160709 | | - /* 670 */ 120, 120, 121, 121, 121, 121, 407, 392, 1227, 1183, |
| 160710 | | - /* 680 */ 1022, 1540, 1183, 1184, 1185, 1523, 149, 1307, 1307, 306, |
| 160711 | | - /* 690 */ 555, 151, 1546, 361, 5, 564, 6, 3, 1035, 1542, |
| 160712 | | - /* 700 */ 122, 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, |
| 160713 | | - /* 710 */ 120, 121, 121, 121, 121, 411, 505, 83, 71, 71, |
| 160714 | | - /* 720 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, |
| 160715 | | - /* 730 */ 442, 1183, 426, 428, 1183, 1183, 1184, 1185, 191, 261, |
| 160716 | | - /* 740 */ 278, 358, 508, 353, 507, 248, 407, 455, 137, 1539, |
| 160717 | | - /* 750 */ 1006, 349, 363, 472, 1539, 302, 1228, 405, 281, 119, |
| 160718 | | - /* 760 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, |
| 160719 | | - /* 770 */ 122, 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, |
| 160720 | | - /* 780 */ 120, 121, 121, 121, 121, 407, 452, 1183, 1184, 1185, |
| 160721 | | - /* 790 */ 1183, 1184, 1185, 275, 275, 269, 269, 489, 483, 1525, |
| 160722 | | - /* 800 */ 148, 363, 480, 564, 306, 555, 561, 489, 561, 122, |
| 160723 | | - /* 810 */ 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, |
| 160724 | | - /* 820 */ 121, 121, 121, 121, 564, 886, 13, 13, 293, 119, |
| 160725 | | - /* 830 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 442, |
| 160726 | | - /* 840 */ 1183, 420, 1316, 564, 98, 417, 199, 13, 13, 150, |
| 160727 | | - /* 850 */ 306, 555, 1312, 322, 386, 407, 506, 478, 562, 400, |
| 160728 | | - /* 860 */ 920, 920, 425, 1539, 887, 292, 71, 71, 119, 119, |
| 160729 | | - /* 870 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 122, |
| 160730 | | - /* 880 */ 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, |
| 160731 | | - /* 890 */ 121, 121, 121, 121, 564, 1149, 1183, 1184, 1185, 407, |
| 160732 | | - /* 900 */ 275, 275, 451, 303, 1089, 1089, 486, 448, 1149, 276, |
| 160733 | | - /* 910 */ 276, 1149, 1539, 561, 319, 286, 321, 71, 71, 429, |
| 160734 | | - /* 920 */ 451, 450, 561, 952, 101, 1207, 1207, 1041, 113, 1044, |
| 160735 | | - /* 930 */ 1034, 1034, 120, 120, 121, 121, 121, 121, 119, 119, |
| 160736 | | - /* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 442, 1105, |
| 160737 | | - /* 950 */ 1183, 1547, 564, 12, 437, 6, 329, 564, 834, 835, |
| 160738 | | - /* 960 */ 836, 1629, 393, 547, 1106, 246, 245, 244, 1545, 1258, |
| 160739 | | - /* 970 */ 413, 1521, 6, 1086, 310, 71, 71, 1086, 564, 1107, |
| 160740 | | - /* 980 */ 13, 13, 119, 119, 119, 119, 118, 118, 117, 117, |
| 160741 | | - /* 990 */ 117, 116, 442, 451, 104, 427, 537, 320, 275, 275, |
| 160742 | | - /* 1000 */ 906, 13, 13, 520, 1482, 1105, 1183, 1184, 1185, 484, |
| 160743 | | - /* 1010 */ 907, 561, 546, 564, 407, 536, 295, 478, 253, 200, |
| 160744 | | - /* 1020 */ 1106, 548, 1482, 1484, 1160, 1409, 16, 16, 126, 557, |
| 160745 | | - /* 1030 */ 413, 479, 311, 951, 407, 1107, 71, 71, 122, 123, |
| 160746 | | - /* 1040 */ 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, 121, |
| 160747 | | - /* 1050 */ 121, 121, 121, 1204, 407, 544, 552, 314, 122, 123, |
| 160748 | | - /* 1060 */ 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, 121, |
| 160749 | | - /* 1070 */ 121, 121, 121, 441, 144, 1160, 468, 146, 122, 111, |
| 160750 | | - /* 1080 */ 1207, 1207, 1041, 113, 1044, 1034, 1034, 120, 120, 121, |
| 160751 | | - /* 1090 */ 121, 121, 121, 247, 12, 1482, 422, 119, 119, 119, |
| 160752 | | - /* 1100 */ 119, 118, 118, 117, 117, 117, 116, 442, 1183, 564, |
| 160753 | | - /* 1110 */ 1204, 207, 404, 403, 858, 950, 294, 119, 119, 119, |
| 160754 | | - /* 1120 */ 119, 118, 118, 117, 117, 117, 116, 442, 564, 30, |
| 160755 | | - /* 1130 */ 564, 1409, 55, 55, 1599, 564, 895, 119, 119, 119, |
| 160756 | | - /* 1140 */ 119, 118, 118, 117, 117, 117, 116, 442, 510, 1409, |
| 160757 | | - /* 1150 */ 1409, 56, 56, 15, 15, 439, 438, 407, 13, 13, |
| 160758 | | - /* 1160 */ 31, 1187, 412, 1211, 1183, 1184, 1185, 196, 1213, 306, |
| 160759 | | - /* 1170 */ 555, 858, 462, 193, 926, 564, 1212, 489, 361, 925, |
| 160760 | | - /* 1180 */ 1183, 564, 123, 1207, 1207, 1041, 113, 1044, 1034, 1034, |
| 160761 | | - /* 1190 */ 120, 120, 121, 121, 121, 121, 1544, 1149, 43, 43, |
| 160762 | | - /* 1200 */ 6, 1214, 423, 1214, 13, 13, 564, 219, 538, 494, |
| 160763 | | - /* 1210 */ 1149, 108, 556, 1149, 4, 392, 1127, 434, 1187, 194, |
| 160764 | | - /* 1220 */ 424, 485, 337, 1315, 414, 171, 1253, 1321, 559, 57, |
| 160765 | | - /* 1230 */ 57, 564, 950, 564, 224, 247, 1183, 1184, 1185, 561, |
| 160766 | | - /* 1240 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116, |
| 160767 | | - /* 1250 */ 442, 443, 564, 517, 13, 13, 44, 44, 275, 275, |
| 160768 | | - /* 1260 */ 1409, 275, 275, 553, 1353, 529, 213, 549, 456, 543, |
| 160769 | | - /* 1270 */ 465, 561, 564, 137, 561, 58, 58, 469, 405, 1222, |
| 160770 | | - /* 1280 */ 405, 274, 217, 108, 556, 110, 4, 405, 275, 275, |
| 160771 | | - /* 1290 */ 564, 1352, 1021, 564, 1228, 59, 59, 523, 106, 106, |
| 160772 | | - /* 1300 */ 559, 561, 275, 275, 412, 107, 457, 443, 566, 565, |
| 160773 | | - /* 1310 */ 564, 8, 1011, 60, 60, 561, 61, 61, 564, 965, |
| 160774 | | - /* 1320 */ 349, 926, 305, 443, 84, 204, 925, 966, 564, 306, |
| 160775 | | - /* 1330 */ 555, 435, 405, 62, 62, 553, 476, 105, 564, 103, |
| 160776 | | - /* 1340 */ 464, 45, 45, 1203, 1011, 1011, 1013, 1014, 27, 533, |
| 160777 | | - /* 1350 */ 564, 46, 46, 453, 532, 1572, 1171, 445, 1528, 564, |
| 160778 | | - /* 1360 */ 279, 47, 47, 327, 1021, 390, 390, 389, 264, 387, |
| 160779 | | - /* 1370 */ 106, 106, 843, 49, 49, 108, 556, 107, 4, 443, |
| 160780 | | - /* 1380 */ 566, 565, 50, 50, 1011, 225, 564, 313, 564, 96, |
| 160781 | | - /* 1390 */ 564, 228, 559, 524, 147, 312, 38, 1123, 564, 394, |
| 160782 | | - /* 1400 */ 466, 328, 280, 98, 544, 564, 17, 564, 323, 63, |
| 160783 | | - /* 1410 */ 63, 64, 64, 65, 65, 443, 1011, 1011, 1013, 1014, |
| 160784 | | - /* 1420 */ 27, 14, 14, 289, 564, 227, 564, 553, 66, 66, |
| 160785 | | - /* 1430 */ 128, 128, 477, 162, 564, 309, 135, 564, 1003, 277, |
| 160786 | | - /* 1440 */ 252, 533, 564, 1501, 564, 418, 534, 67, 67, 52, |
| 160787 | | - /* 1450 */ 52, 564, 1287, 226, 564, 1500, 1021, 68, 68, 208, |
| 160788 | | - /* 1460 */ 69, 69, 106, 106, 1286, 53, 53, 157, 157, 107, |
| 160789 | | - /* 1470 */ 873, 443, 566, 565, 158, 158, 1011, 76, 76, 564, |
| 160790 | | - /* 1480 */ 357, 564, 108, 556, 471, 4, 252, 408, 885, 884, |
| 160791 | | - /* 1490 */ 356, 564, 306, 555, 564, 473, 564, 252, 481, 559, |
| 160792 | | - /* 1500 */ 564, 334, 54, 54, 72, 72, 564, 230, 1011, 1011, |
| 160793 | | - /* 1510 */ 1013, 1014, 27, 564, 129, 129, 449, 73, 73, 130, |
| 160794 | | - /* 1520 */ 130, 564, 443, 131, 131, 519, 564, 873, 564, 127, |
| 160795 | | - /* 1530 */ 127, 333, 1071, 98, 553, 1349, 156, 156, 564, 495, |
| 160796 | | - /* 1540 */ 347, 249, 98, 338, 155, 155, 892, 893, 533, 136, |
| 160797 | | - /* 1550 */ 136, 134, 134, 532, 341, 1171, 445, 1587, 564, 279, |
| 160798 | | - /* 1560 */ 343, 132, 132, 1021, 390, 390, 389, 264, 387, 106, |
| 160799 | | - /* 1570 */ 106, 843, 564, 1067, 564, 249, 107, 564, 443, 566, |
| 160800 | | - /* 1580 */ 565, 133, 133, 1011, 225, 1015, 313, 108, 556, 1071, |
| 160801 | | - /* 1590 */ 4, 345, 968, 969, 312, 75, 75, 77, 77, 1300, |
| 160802 | | - /* 1600 */ 74, 74, 564, 1132, 559, 564, 108, 556, 959, 4, |
| 160803 | | - /* 1610 */ 252, 923, 1083, 110, 1083, 1011, 1011, 1013, 1014, 27, |
| 160804 | | - /* 1620 */ 1082, 1285, 1082, 559, 227, 42, 42, 443, 48, 48, |
| 160805 | | - /* 1630 */ 1284, 856, 162, 145, 924, 135, 110, 352, 362, 553, |
| 160806 | | - /* 1640 */ 1340, 1361, 1015, 1408, 1336, 301, 443, 1561, 1347, 550, |
| 160807 | | - /* 1650 */ 1414, 551, 226, 202, 1265, 1333, 1256, 1244, 553, 1243, |
| 160808 | | - /* 1660 */ 490, 1245, 1580, 267, 11, 391, 210, 223, 1021, 1390, |
| 160809 | | - /* 1670 */ 1395, 282, 365, 367, 106, 106, 930, 369, 454, 285, |
| 160810 | | - /* 1680 */ 1383, 107, 325, 443, 566, 565, 408, 1021, 1011, 326, |
| 160811 | | - /* 1690 */ 475, 306, 555, 106, 106, 100, 556, 500, 4, 1400, |
| 160812 | | - /* 1700 */ 107, 1399, 443, 566, 565, 398, 1283, 1011, 214, 355, |
| 160813 | | - /* 1710 */ 1473, 290, 559, 1472, 1583, 449, 554, 371, 331, 197, |
| 160814 | | - /* 1720 */ 1011, 1011, 1013, 1014, 27, 198, 209, 385, 1222, 173, |
| 160815 | | - /* 1730 */ 221, 256, 1520, 1518, 1219, 443, 79, 416, 206, 1011, |
| 160816 | | - /* 1740 */ 1011, 1013, 1014, 27, 83, 279, 182, 553, 82, 167, |
| 160817 | | - /* 1750 */ 390, 390, 389, 264, 387, 35, 1396, 843, 1478, 459, |
| 160818 | | - /* 1760 */ 175, 177, 460, 493, 178, 179, 180, 233, 96, 396, |
| 160819 | | - /* 1770 */ 225, 1402, 313, 1401, 36, 1404, 1021, 467, 186, 482, |
| 160820 | | - /* 1780 */ 312, 399, 106, 106, 237, 1467, 89, 1489, 488, 107, |
| 160821 | | - /* 1790 */ 239, 443, 566, 565, 268, 336, 1011, 190, 491, 340, |
| 160822 | | - /* 1800 */ 240, 401, 1246, 241, 509, 1294, 430, 1303, 91, 877, |
| 160823 | | - /* 1810 */ 227, 215, 1566, 1302, 1301, 1273, 1598, 432, 162, 518, |
| 160824 | | - /* 1820 */ 1272, 135, 1597, 354, 402, 433, 1271, 1596, 1011, 1011, |
| 160825 | | - /* 1830 */ 1013, 1014, 27, 1293, 299, 360, 300, 525, 226, 95, |
| 160826 | | - /* 1840 */ 254, 255, 1344, 364, 436, 125, 544, 1552, 10, 1453, |
| 160827 | | - /* 1850 */ 379, 1551, 102, 304, 97, 528, 34, 568, 1177, 263, |
| 160828 | | - /* 1860 */ 265, 266, 569, 1241, 1236, 172, 409, 410, 159, 383, |
| 160829 | | - /* 1870 */ 377, 366, 408, 1345, 1343, 368, 370, 306, 555, 1342, |
| 160830 | | - /* 1880 */ 1326, 1325, 1368, 201, 384, 1367, 1505, 1506, 160, 1504, |
| 160831 | | - /* 1890 */ 1503, 142, 161, 211, 212, 78, 830, 444, 203, 308, |
| 160832 | | - /* 1900 */ 297, 449, 222, 1081, 139, 1079, 316, 174, 163, 1203, |
| 160833 | | - /* 1910 */ 229, 176, 232, 909, 324, 1095, 164, 181, 165, 419, |
| 160834 | | - /* 1920 */ 421, 183, 85, 86, 87, 88, 166, 1098, 235, 234, |
| 160835 | | - /* 1930 */ 1094, 152, 18, 236, 335, 1087, 252, 1216, 487, 238, |
| 160836 | | - /* 1940 */ 37, 187, 188, 845, 492, 356, 242, 348, 496, 189, |
| 160837 | | - /* 1950 */ 90, 93, 19, 20, 168, 875, 501, 351, 92, 504, |
| 160838 | | - /* 1960 */ 888, 153, 511, 1133, 1165, 154, 298, 1047, 94, 1134, |
| 160839 | | - /* 1970 */ 39, 958, 216, 271, 273, 192, 953, 110, 1151, 251, |
| 160840 | | - /* 1980 */ 1155, 21, 1159, 22, 1158, 1139, 1153, 33, 23, 24, |
| 160841 | | - /* 1990 */ 540, 25, 195, 98, 26, 1062, 1048, 1046, 1050, 1104, |
| 160842 | | - /* 2000 */ 7, 1103, 257, 258, 1051, 28, 40, 560, 1016, 857, |
| 160843 | | - /* 2010 */ 109, 29, 919, 138, 259, 260, 170, 1589, 388, 1588, |
| 160844 | | - /* 2020 */ 1173, 1172, |
| 160862 | + /* 0 */ 566, 1307, 566, 1286, 201, 201, 566, 116, 112, 222, |
| 160863 | + /* 10 */ 566, 1307, 377, 566, 116, 112, 222, 397, 408, 409, |
| 160864 | + /* 20 */ 1260, 378, 1269, 41, 41, 41, 41, 1412, 1517, 71, |
| 160865 | + /* 30 */ 71, 967, 1258, 41, 41, 491, 71, 71, 272, 968, |
| 160866 | + /* 40 */ 298, 476, 298, 123, 124, 114, 1210, 1210, 1044, 1047, |
| 160867 | + /* 50 */ 1036, 1036, 121, 121, 122, 122, 122, 122, 543, 409, |
| 160868 | + /* 60 */ 1234, 1, 1, 573, 2, 1238, 548, 116, 112, 222, |
| 160869 | + /* 70 */ 309, 480, 142, 548, 1272, 524, 116, 112, 222, 1320, |
| 160870 | + /* 80 */ 417, 523, 547, 123, 124, 114, 1210, 1210, 1044, 1047, |
| 160871 | + /* 90 */ 1036, 1036, 121, 121, 122, 122, 122, 122, 424, 116, |
| 160872 | + /* 100 */ 112, 222, 120, 120, 120, 120, 119, 119, 118, 118, |
| 160873 | + /* 110 */ 118, 117, 113, 444, 277, 277, 277, 277, 560, 560, |
| 160874 | + /* 120 */ 560, 1558, 376, 1560, 1186, 375, 1157, 563, 1157, 563, |
| 160875 | + /* 130 */ 409, 1558, 537, 252, 219, 1553, 99, 141, 449, 6, |
| 160876 | + /* 140 */ 365, 233, 120, 120, 120, 120, 119, 119, 118, 118, |
| 160877 | + /* 150 */ 118, 117, 113, 444, 123, 124, 114, 1210, 1210, 1044, |
| 160878 | + /* 160 */ 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, 138, |
| 160879 | + /* 170 */ 289, 1186, 1546, 448, 118, 118, 118, 117, 113, 444, |
| 160880 | + /* 180 */ 125, 1186, 1187, 1188, 144, 465, 334, 566, 150, 127, |
| 160881 | + /* 190 */ 444, 122, 122, 122, 122, 115, 120, 120, 120, 120, |
| 160882 | + /* 200 */ 119, 119, 118, 118, 118, 117, 113, 444, 454, 419, |
| 160883 | + /* 210 */ 13, 13, 215, 120, 120, 120, 120, 119, 119, 118, |
| 160884 | + /* 220 */ 118, 118, 117, 113, 444, 422, 308, 557, 1186, 1187, |
| 160885 | + /* 230 */ 1188, 441, 440, 409, 1271, 122, 122, 122, 122, 120, |
| 160886 | + /* 240 */ 120, 120, 120, 119, 119, 118, 118, 118, 117, 113, |
| 160887 | + /* 250 */ 444, 1543, 98, 1033, 1033, 1045, 1048, 123, 124, 114, |
| 160888 | + /* 260 */ 1210, 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, |
| 160889 | + /* 270 */ 122, 122, 566, 406, 405, 1186, 566, 409, 1217, 319, |
| 160890 | + /* 280 */ 1217, 80, 81, 120, 120, 120, 120, 119, 119, 118, |
| 160891 | + /* 290 */ 118, 118, 117, 113, 444, 70, 70, 1186, 1604, 71, |
| 160892 | + /* 300 */ 71, 123, 124, 114, 1210, 1210, 1044, 1047, 1036, 1036, |
| 160893 | + /* 310 */ 121, 121, 122, 122, 122, 122, 120, 120, 120, 120, |
| 160894 | + /* 320 */ 119, 119, 118, 118, 118, 117, 113, 444, 1037, 210, |
| 160895 | + /* 330 */ 1186, 365, 1186, 1187, 1188, 245, 548, 399, 504, 501, |
| 160896 | + /* 340 */ 500, 108, 558, 138, 4, 516, 933, 433, 499, 217, |
| 160897 | + /* 350 */ 514, 522, 352, 879, 1186, 1187, 1188, 383, 561, 566, |
| 160898 | + /* 360 */ 120, 120, 120, 120, 119, 119, 118, 118, 118, 117, |
| 160899 | + /* 370 */ 113, 444, 277, 277, 16, 16, 1598, 441, 440, 153, |
| 160900 | + /* 380 */ 409, 445, 13, 13, 1279, 563, 1214, 1186, 1187, 1188, |
| 160901 | + /* 390 */ 1003, 1216, 264, 555, 1574, 186, 566, 427, 138, 1215, |
| 160902 | + /* 400 */ 308, 557, 472, 138, 123, 124, 114, 1210, 1210, 1044, |
| 160903 | + /* 410 */ 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, 55, |
| 160904 | + /* 420 */ 55, 413, 1023, 507, 1217, 1186, 1217, 474, 106, 106, |
| 160905 | + /* 430 */ 1312, 1312, 1186, 171, 566, 384, 107, 380, 445, 568, |
| 160906 | + /* 440 */ 567, 430, 1543, 1013, 332, 549, 565, 263, 280, 360, |
| 160907 | + /* 450 */ 510, 355, 509, 250, 491, 308, 557, 71, 71, 351, |
| 160908 | + /* 460 */ 308, 557, 374, 120, 120, 120, 120, 119, 119, 118, |
| 160909 | + /* 470 */ 118, 118, 117, 113, 444, 1013, 1013, 1015, 1016, 27, |
| 160910 | + /* 480 */ 277, 277, 1186, 1187, 1188, 1152, 566, 528, 409, 1186, |
| 160911 | + /* 490 */ 1187, 1188, 348, 563, 548, 1260, 533, 517, 1152, 1516, |
| 160912 | + /* 500 */ 317, 1152, 285, 550, 485, 569, 566, 569, 482, 51, |
| 160913 | + /* 510 */ 51, 207, 123, 124, 114, 1210, 1210, 1044, 1047, 1036, |
| 160914 | + /* 520 */ 1036, 121, 121, 122, 122, 122, 122, 171, 1412, 13, |
| 160915 | + /* 530 */ 13, 409, 277, 277, 1186, 505, 119, 119, 118, 118, |
| 160916 | + /* 540 */ 118, 117, 113, 444, 429, 563, 518, 220, 515, 1552, |
| 160917 | + /* 550 */ 365, 546, 1186, 6, 532, 123, 124, 114, 1210, 1210, |
| 160918 | + /* 560 */ 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, |
| 160919 | + /* 570 */ 145, 120, 120, 120, 120, 119, 119, 118, 118, 118, |
| 160920 | + /* 580 */ 117, 113, 444, 245, 566, 474, 504, 501, 500, 566, |
| 160921 | + /* 590 */ 1481, 1186, 1187, 1188, 1310, 1310, 499, 1186, 149, 425, |
| 160922 | + /* 600 */ 1186, 480, 409, 274, 365, 952, 872, 56, 56, 1186, |
| 160923 | + /* 610 */ 1187, 1188, 71, 71, 120, 120, 120, 120, 119, 119, |
| 160924 | + /* 620 */ 118, 118, 118, 117, 113, 444, 123, 124, 114, 1210, |
| 160925 | + /* 630 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160926 | + /* 640 */ 122, 409, 541, 1552, 83, 865, 98, 6, 928, 529, |
| 160927 | + /* 650 */ 848, 543, 151, 927, 1186, 1187, 1188, 1186, 1187, 1188, |
| 160928 | + /* 660 */ 290, 1543, 187, 1633, 395, 123, 124, 114, 1210, 1210, |
| 160929 | + /* 670 */ 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, |
| 160930 | + /* 680 */ 566, 954, 566, 453, 953, 120, 120, 120, 120, 119, |
| 160931 | + /* 690 */ 119, 118, 118, 118, 117, 113, 444, 1152, 221, 1186, |
| 160932 | + /* 700 */ 331, 453, 452, 13, 13, 13, 13, 1003, 365, 463, |
| 160933 | + /* 710 */ 1152, 193, 409, 1152, 382, 1543, 1170, 32, 297, 474, |
| 160934 | + /* 720 */ 195, 1527, 5, 952, 120, 120, 120, 120, 119, 119, |
| 160935 | + /* 730 */ 118, 118, 118, 117, 113, 444, 123, 124, 114, 1210, |
| 160936 | + /* 740 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160937 | + /* 750 */ 122, 409, 1067, 419, 1186, 1024, 1186, 1187, 1188, 1186, |
| 160938 | + /* 760 */ 419, 332, 460, 320, 544, 1545, 442, 442, 442, 566, |
| 160939 | + /* 770 */ 3, 117, 113, 444, 453, 123, 124, 114, 1210, 1210, |
| 160940 | + /* 780 */ 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, |
| 160941 | + /* 790 */ 1473, 566, 15, 15, 293, 120, 120, 120, 120, 119, |
| 160942 | + /* 800 */ 119, 118, 118, 118, 117, 113, 444, 1186, 566, 1486, |
| 160943 | + /* 810 */ 1412, 1186, 1187, 1188, 13, 13, 1186, 1187, 1188, 1544, |
| 160944 | + /* 820 */ 271, 271, 409, 286, 308, 557, 1008, 1486, 1488, 196, |
| 160945 | + /* 830 */ 288, 71, 71, 563, 120, 120, 120, 120, 119, 119, |
| 160946 | + /* 840 */ 118, 118, 118, 117, 113, 444, 123, 124, 114, 1210, |
| 160947 | + /* 850 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160948 | + /* 860 */ 122, 409, 201, 1087, 1186, 1187, 1188, 1324, 304, 1529, |
| 160949 | + /* 870 */ 388, 278, 278, 450, 564, 402, 922, 922, 566, 563, |
| 160950 | + /* 880 */ 566, 426, 491, 480, 563, 123, 124, 114, 1210, 1210, |
| 160951 | + /* 890 */ 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, 122, |
| 160952 | + /* 900 */ 1486, 71, 71, 13, 13, 120, 120, 120, 120, 119, |
| 160953 | + /* 910 */ 119, 118, 118, 118, 117, 113, 444, 566, 545, 566, |
| 160954 | + /* 920 */ 1577, 573, 2, 1238, 1092, 1092, 488, 1480, 309, 1525, |
| 160955 | + /* 930 */ 142, 324, 409, 836, 837, 838, 312, 1320, 305, 363, |
| 160956 | + /* 940 */ 43, 43, 57, 57, 120, 120, 120, 120, 119, 119, |
| 160957 | + /* 950 */ 118, 118, 118, 117, 113, 444, 123, 124, 114, 1210, |
| 160958 | + /* 960 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160959 | + /* 970 */ 122, 12, 277, 277, 566, 1152, 409, 572, 428, 1238, |
| 160960 | + /* 980 */ 465, 334, 296, 474, 309, 563, 142, 249, 1152, 308, |
| 160961 | + /* 990 */ 557, 1152, 321, 1320, 323, 491, 455, 71, 71, 233, |
| 160962 | + /* 1000 */ 283, 101, 114, 1210, 1210, 1044, 1047, 1036, 1036, 121, |
| 160963 | + /* 1010 */ 121, 122, 122, 122, 122, 120, 120, 120, 120, 119, |
| 160964 | + /* 1020 */ 119, 118, 118, 118, 117, 113, 444, 1108, 277, 277, |
| 160965 | + /* 1030 */ 1412, 448, 394, 1230, 439, 277, 277, 248, 247, 246, |
| 160966 | + /* 1040 */ 1319, 563, 1109, 313, 198, 294, 491, 1318, 563, 464, |
| 160967 | + /* 1050 */ 566, 1427, 394, 1130, 1023, 233, 414, 1110, 295, 120, |
| 160968 | + /* 1060 */ 120, 120, 120, 119, 119, 118, 118, 118, 117, 113, |
| 160969 | + /* 1070 */ 444, 1014, 104, 71, 71, 1013, 322, 496, 908, 566, |
| 160970 | + /* 1080 */ 277, 277, 277, 277, 1108, 1261, 415, 448, 909, 361, |
| 160971 | + /* 1090 */ 1571, 1315, 409, 563, 952, 563, 9, 202, 255, 1109, |
| 160972 | + /* 1100 */ 316, 487, 44, 44, 249, 559, 415, 1013, 1013, 1015, |
| 160973 | + /* 1110 */ 443, 1231, 409, 1603, 1110, 897, 123, 124, 114, 1210, |
| 160974 | + /* 1120 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160975 | + /* 1130 */ 122, 1231, 409, 1207, 215, 554, 123, 124, 114, 1210, |
| 160976 | + /* 1140 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160977 | + /* 1150 */ 122, 1131, 1631, 470, 1631, 255, 123, 111, 114, 1210, |
| 160978 | + /* 1160 */ 1210, 1044, 1047, 1036, 1036, 121, 121, 122, 122, 122, |
| 160979 | + /* 1170 */ 122, 1131, 1632, 414, 1632, 120, 120, 120, 120, 119, |
| 160980 | + /* 1180 */ 119, 118, 118, 118, 117, 113, 444, 221, 209, 351, |
| 160981 | + /* 1190 */ 1207, 1207, 147, 1426, 491, 120, 120, 120, 120, 119, |
| 160982 | + /* 1200 */ 119, 118, 118, 118, 117, 113, 444, 1256, 539, 519, |
| 160983 | + /* 1210 */ 888, 551, 952, 12, 566, 120, 120, 120, 120, 119, |
| 160984 | + /* 1220 */ 119, 118, 118, 118, 117, 113, 444, 538, 566, 860, |
| 160985 | + /* 1230 */ 1129, 361, 1571, 346, 1356, 409, 1163, 58, 58, 339, |
| 160986 | + /* 1240 */ 1355, 508, 277, 277, 277, 277, 277, 277, 1207, 889, |
| 160987 | + /* 1250 */ 1129, 59, 59, 459, 363, 563, 566, 563, 96, 563, |
| 160988 | + /* 1260 */ 124, 114, 1210, 1210, 1044, 1047, 1036, 1036, 121, 121, |
| 160989 | + /* 1270 */ 122, 122, 122, 122, 566, 1412, 566, 281, 1186, 60, |
| 160990 | + /* 1280 */ 60, 110, 392, 392, 391, 266, 389, 860, 1163, 845, |
| 160991 | + /* 1290 */ 566, 481, 566, 436, 341, 1152, 344, 61, 61, 62, |
| 160992 | + /* 1300 */ 62, 967, 227, 1550, 315, 431, 540, 6, 1152, 968, |
| 160993 | + /* 1310 */ 566, 1152, 314, 45, 45, 46, 46, 512, 120, 120, |
| 160994 | + /* 1320 */ 120, 120, 119, 119, 118, 118, 118, 117, 113, 444, |
| 160995 | + /* 1330 */ 416, 173, 1532, 47, 47, 1186, 1187, 1188, 108, 558, |
| 160996 | + /* 1340 */ 325, 4, 229, 1551, 928, 566, 437, 6, 566, 927, |
| 160997 | + /* 1350 */ 164, 566, 1290, 137, 1190, 561, 566, 1549, 566, 1089, |
| 160998 | + /* 1360 */ 566, 6, 566, 1089, 531, 566, 868, 8, 49, 49, |
| 160999 | + /* 1370 */ 228, 50, 50, 566, 63, 63, 566, 457, 445, 64, |
| 161000 | + /* 1380 */ 64, 65, 65, 14, 14, 66, 66, 407, 129, 129, |
| 161001 | + /* 1390 */ 555, 566, 458, 566, 1505, 486, 67, 67, 566, 52, |
| 161002 | + /* 1400 */ 52, 546, 407, 467, 535, 410, 226, 1023, 566, 534, |
| 161003 | + /* 1410 */ 308, 557, 1190, 407, 68, 68, 69, 69, 566, 1023, |
| 161004 | + /* 1420 */ 566, 53, 53, 868, 1014, 106, 106, 525, 1013, 566, |
| 161005 | + /* 1430 */ 1504, 159, 159, 107, 451, 445, 568, 567, 471, 307, |
| 161006 | + /* 1440 */ 1013, 160, 160, 76, 76, 566, 1548, 466, 407, 407, |
| 161007 | + /* 1450 */ 6, 1225, 54, 54, 478, 276, 219, 566, 887, 886, |
| 161008 | + /* 1460 */ 1013, 1013, 1015, 84, 206, 1206, 230, 282, 72, 72, |
| 161009 | + /* 1470 */ 329, 483, 1013, 1013, 1015, 1016, 27, 1576, 1174, 447, |
| 161010 | + /* 1480 */ 130, 130, 281, 148, 105, 38, 103, 392, 392, 391, |
| 161011 | + /* 1490 */ 266, 389, 566, 1126, 845, 396, 566, 108, 558, 566, |
| 161012 | + /* 1500 */ 4, 311, 566, 30, 17, 566, 279, 227, 566, 315, |
| 161013 | + /* 1510 */ 108, 558, 468, 4, 561, 73, 73, 314, 566, 157, |
| 161014 | + /* 1520 */ 157, 566, 131, 131, 526, 132, 132, 561, 128, 128, |
| 161015 | + /* 1530 */ 566, 158, 158, 566, 31, 291, 566, 445, 330, 521, |
| 161016 | + /* 1540 */ 98, 152, 152, 420, 136, 136, 1005, 229, 254, 555, |
| 161017 | + /* 1550 */ 445, 479, 336, 135, 135, 164, 133, 133, 137, 134, |
| 161018 | + /* 1560 */ 134, 875, 555, 535, 566, 473, 566, 254, 536, 475, |
| 161019 | + /* 1570 */ 335, 254, 98, 894, 895, 228, 535, 566, 1023, 566, |
| 161020 | + /* 1580 */ 1074, 534, 210, 232, 106, 106, 1352, 75, 75, 77, |
| 161021 | + /* 1590 */ 77, 1023, 107, 340, 445, 568, 567, 106, 106, 1013, |
| 161022 | + /* 1600 */ 74, 74, 42, 42, 566, 107, 343, 445, 568, 567, |
| 161023 | + /* 1610 */ 410, 497, 1013, 251, 359, 308, 557, 1135, 349, 875, |
| 161024 | + /* 1620 */ 98, 1070, 345, 251, 358, 1591, 347, 48, 48, 1017, |
| 161025 | + /* 1630 */ 1303, 1013, 1013, 1015, 1016, 27, 1289, 1287, 1074, 451, |
| 161026 | + /* 1640 */ 961, 925, 254, 110, 1013, 1013, 1015, 1016, 27, 1174, |
| 161027 | + /* 1650 */ 447, 970, 971, 281, 108, 558, 1288, 4, 392, 392, |
| 161028 | + /* 1660 */ 391, 266, 389, 1343, 1086, 845, 1086, 1085, 858, 1085, |
| 161029 | + /* 1670 */ 146, 561, 926, 354, 110, 303, 364, 553, 227, 1364, |
| 161030 | + /* 1680 */ 315, 108, 558, 1411, 4, 1339, 492, 1017, 314, 1350, |
| 161031 | + /* 1690 */ 1565, 552, 1417, 1268, 445, 204, 1259, 1247, 561, 1246, |
| 161032 | + /* 1700 */ 1248, 1584, 269, 1336, 367, 369, 555, 371, 11, 212, |
| 161033 | + /* 1710 */ 393, 225, 1393, 284, 1398, 456, 287, 327, 229, 328, |
| 161034 | + /* 1720 */ 292, 445, 1386, 216, 333, 1403, 164, 477, 373, 137, |
| 161035 | + /* 1730 */ 1402, 400, 502, 555, 1286, 1023, 357, 1477, 199, 1587, |
| 161036 | + /* 1740 */ 211, 106, 106, 932, 1476, 1225, 228, 556, 175, 107, |
| 161037 | + /* 1750 */ 200, 445, 568, 567, 258, 387, 1013, 1524, 1522, 223, |
| 161038 | + /* 1760 */ 1222, 418, 1023, 83, 208, 79, 82, 184, 106, 106, |
| 161039 | + /* 1770 */ 1482, 169, 177, 461, 179, 462, 107, 1399, 445, 568, |
| 161040 | + /* 1780 */ 567, 410, 180, 1013, 495, 181, 308, 557, 1013, 1013, |
| 161041 | + /* 1790 */ 1015, 1016, 27, 182, 35, 235, 100, 558, 398, 4, |
| 161042 | + /* 1800 */ 96, 1405, 1404, 36, 484, 469, 1407, 188, 401, 1471, |
| 161043 | + /* 1810 */ 451, 89, 1493, 561, 239, 1013, 1013, 1015, 1016, 27, |
| 161044 | + /* 1820 */ 490, 338, 270, 241, 192, 342, 493, 242, 403, 1249, |
| 161045 | + /* 1830 */ 243, 511, 432, 1297, 1306, 91, 445, 1305, 1304, 879, |
| 161046 | + /* 1840 */ 217, 434, 435, 1570, 1276, 1602, 520, 1601, 555, 301, |
| 161047 | + /* 1850 */ 527, 404, 1275, 302, 356, 1274, 1600, 95, 1347, 366, |
| 161048 | + /* 1860 */ 1296, 362, 1348, 368, 256, 257, 1556, 1555, 438, 1346, |
| 161049 | + /* 1870 */ 370, 126, 1345, 10, 1371, 546, 381, 1023, 102, 1457, |
| 161050 | + /* 1880 */ 97, 530, 34, 106, 106, 570, 1180, 372, 265, 1329, |
| 161051 | + /* 1890 */ 379, 107, 203, 445, 568, 567, 1328, 385, 1013, 1370, |
| 161052 | + /* 1900 */ 386, 267, 268, 571, 1244, 161, 1239, 162, 1509, 1510, |
| 161053 | + /* 1910 */ 1508, 143, 1507, 299, 832, 213, 214, 78, 446, 205, |
| 161054 | + /* 1920 */ 310, 306, 163, 224, 1084, 140, 1082, 318, 165, 176, |
| 161055 | + /* 1930 */ 1013, 1013, 1015, 1016, 27, 178, 1206, 231, 911, 234, |
| 161056 | + /* 1940 */ 326, 1098, 183, 421, 166, 167, 411, 185, 85, 423, |
| 161057 | + /* 1950 */ 412, 86, 174, 87, 168, 88, 1101, 236, 1097, 237, |
| 161058 | + /* 1960 */ 154, 18, 238, 254, 337, 1219, 489, 1090, 240, 190, |
| 161059 | + /* 1970 */ 37, 847, 189, 494, 358, 244, 350, 506, 191, 877, |
| 161060 | + /* 1980 */ 90, 498, 19, 20, 503, 92, 353, 890, 300, 170, |
| 161061 | + /* 1990 */ 155, 93, 513, 94, 1168, 156, 1050, 1137, 39, 218, |
| 161062 | + /* 2000 */ 273, 275, 1136, 960, 194, 955, 110, 1154, 1158, 253, |
| 161063 | + /* 2010 */ 7, 1162, 1156, 21, 22, 1161, 1142, 23, 24, 25, |
| 161064 | + /* 2020 */ 33, 542, 26, 260, 197, 98, 1065, 1051, 1049, 1053, |
| 161065 | + /* 2030 */ 1107, 1054, 1106, 259, 28, 40, 562, 1018, 859, 109, |
| 161066 | + /* 2040 */ 29, 921, 390, 1176, 172, 139, 1175, 1235, 261, 1235, |
| 161067 | + /* 2050 */ 1235, 1235, 1235, 1235, 1235, 1235, 1235, 262, 1235, 1235, |
| 161068 | + /* 2060 */ 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1593, 1592, |
| 160845 | 161069 | }; |
| 160846 | 161070 | static const YYCODETYPE yy_lookahead[] = { |
| 160847 | | - /* 0 */ 192, 273, 274, 275, 192, 192, 273, 274, 275, 192, |
| 160848 | | - /* 10 */ 218, 215, 192, 218, 192, 212, 234, 235, 205, 19, |
| 160849 | | - /* 20 */ 11, 192, 294, 215, 216, 203, 192, 203, 209, 210, |
| 160850 | | - /* 30 */ 211, 31, 215, 216, 205, 215, 216, 215, 216, 39, |
| 160851 | | - /* 40 */ 227, 215, 229, 43, 44, 45, 46, 47, 48, 49, |
| 160852 | | - /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 19, |
| 160853 | | - /* 60 */ 238, 239, 238, 239, 215, 273, 274, 275, 273, 274, |
| 160854 | | - /* 70 */ 275, 237, 21, 251, 252, 251, 273, 274, 275, 255, |
| 160855 | | - /* 80 */ 256, 215, 216, 43, 44, 45, 46, 47, 48, 49, |
| 160856 | | - /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 209, 210, |
| 160857 | | - /* 100 */ 211, 76, 102, 103, 104, 105, 106, 107, 108, 109, |
| 160858 | | - /* 110 */ 110, 111, 112, 59, 89, 111, 112, 92, 252, 307, |
| 160859 | | - /* 120 */ 308, 313, 314, 25, 312, 192, 86, 261, 88, 19, |
| 160860 | | - /* 130 */ 313, 80, 315, 313, 314, 25, 127, 128, 54, 55, |
| 160861 | | - /* 140 */ 56, 57, 102, 103, 104, 105, 106, 107, 108, 109, |
| 160862 | | - /* 150 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49, |
| 160863 | | - /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 115, |
| 160864 | | - /* 170 */ 116, 117, 118, 122, 192, 121, 122, 123, 202, 69, |
| 160865 | | - /* 180 */ 204, 22, 23, 16, 25, 131, 102, 103, 104, 105, |
| 160866 | | - /* 190 */ 106, 107, 108, 109, 110, 111, 112, 215, 216, 19, |
| 160867 | | - /* 200 */ 54, 55, 56, 57, 58, 108, 109, 110, 111, 112, |
| 160868 | | - /* 210 */ 192, 160, 102, 103, 104, 105, 106, 107, 108, 109, |
| 160869 | | - /* 220 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49, |
| 160870 | | - /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 141, |
| 160871 | | - /* 240 */ 307, 308, 272, 24, 77, 312, 79, 67, 102, 103, |
| 160872 | | - /* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 277, |
| 160873 | | - /* 260 */ 101, 112, 43, 44, 45, 46, 47, 48, 49, 50, |
| 160874 | | - /* 270 */ 51, 52, 53, 54, 55, 56, 57, 26, 127, 128, |
| 160875 | | - /* 280 */ 310, 311, 102, 103, 104, 105, 106, 107, 108, 109, |
| 160876 | | - /* 290 */ 110, 111, 112, 184, 185, 186, 187, 188, 189, 186, |
| 160877 | | - /* 300 */ 187, 188, 189, 194, 76, 196, 192, 194, 19, 196, |
| 160878 | | - /* 310 */ 59, 25, 203, 192, 59, 87, 203, 89, 164, 165, |
| 160879 | | - /* 320 */ 92, 102, 103, 104, 105, 106, 107, 108, 109, 110, |
| 160880 | | - /* 330 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50, |
| 160881 | | - /* 340 */ 51, 52, 53, 54, 55, 56, 57, 238, 239, 73, |
| 160882 | | - /* 350 */ 192, 238, 239, 22, 23, 100, 25, 81, 237, 229, |
| 160883 | | - /* 360 */ 251, 23, 204, 25, 251, 272, 115, 116, 117, 214, |
| 160884 | | - /* 370 */ 115, 116, 144, 192, 265, 120, 262, 222, 265, 102, |
| 160885 | | - /* 380 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 160886 | | - /* 390 */ 192, 102, 103, 104, 105, 106, 107, 108, 109, 110, |
| 160887 | | - /* 400 */ 111, 112, 126, 310, 311, 192, 297, 152, 153, 154, |
| 160888 | | - /* 410 */ 297, 125, 192, 137, 138, 19, 295, 100, 192, 23, |
| 160889 | | - /* 420 */ 22, 106, 107, 108, 109, 110, 111, 112, 215, 216, |
| 160890 | | - /* 430 */ 106, 107, 101, 116, 192, 215, 216, 120, 149, 43, |
| 160891 | | - /* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, |
| 160892 | | - /* 450 */ 54, 55, 56, 57, 222, 117, 224, 59, 19, 187, |
| 160893 | | - /* 460 */ 59, 189, 23, 282, 232, 252, 194, 192, 196, 152, |
| 160894 | | - /* 470 */ 153, 154, 252, 72, 261, 203, 152, 248, 154, 250, |
| 160895 | | - /* 480 */ 142, 261, 43, 44, 45, 46, 47, 48, 49, 50, |
| 160896 | | - /* 490 */ 51, 52, 53, 54, 55, 56, 57, 192, 102, 103, |
| 160897 | | - /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 267, |
| 160898 | | - /* 510 */ 238, 239, 237, 115, 116, 117, 115, 116, 117, 192, |
| 160899 | | - /* 520 */ 59, 118, 192, 251, 121, 122, 123, 73, 19, 192, |
| 160900 | | - /* 530 */ 59, 192, 23, 72, 131, 308, 22, 265, 22, 312, |
| 160901 | | - /* 540 */ 24, 102, 103, 104, 105, 106, 107, 108, 109, 110, |
| 160902 | | - /* 550 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50, |
| 160903 | | - /* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 192, 297, |
| 160904 | | - /* 570 */ 192, 23, 267, 59, 203, 59, 115, 116, 117, 108, |
| 160905 | | - /* 580 */ 126, 127, 128, 192, 192, 192, 115, 116, 117, 262, |
| 160906 | | - /* 590 */ 59, 43, 44, 45, 46, 47, 48, 49, 50, 51, |
| 160907 | | - /* 600 */ 52, 53, 54, 55, 56, 57, 267, 215, 216, 238, |
| 160908 | | - /* 610 */ 239, 102, 103, 104, 105, 106, 107, 108, 109, 110, |
| 160909 | | - /* 620 */ 111, 112, 251, 45, 46, 47, 59, 49, 291, 115, |
| 160910 | | - /* 630 */ 116, 117, 116, 81, 192, 305, 306, 19, 192, 268, |
| 160911 | | - /* 640 */ 19, 23, 22, 192, 252, 24, 115, 116, 117, 192, |
| 160912 | | - /* 650 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 160913 | | - /* 660 */ 112, 43, 44, 45, 46, 47, 48, 49, 50, 51, |
| 160914 | | - /* 670 */ 52, 53, 54, 55, 56, 57, 19, 22, 23, 59, |
| 160915 | | - /* 680 */ 23, 303, 115, 116, 117, 192, 240, 234, 235, 137, |
| 160916 | | - /* 690 */ 138, 240, 308, 192, 22, 192, 312, 22, 120, 306, |
| 160917 | | - /* 700 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, |
| 160918 | | - /* 710 */ 53, 54, 55, 56, 57, 197, 95, 150, 215, 216, |
| 160919 | | - /* 720 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 160920 | | - /* 730 */ 112, 59, 231, 112, 59, 115, 116, 117, 25, 118, |
| 160921 | | - /* 740 */ 119, 120, 121, 122, 123, 124, 19, 243, 81, 303, |
| 160922 | | - /* 750 */ 23, 130, 192, 192, 303, 252, 101, 253, 203, 102, |
| 160923 | | - /* 760 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 160924 | | - /* 770 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, |
| 160925 | | - /* 780 */ 53, 54, 55, 56, 57, 19, 119, 115, 116, 117, |
| 160926 | | - /* 790 */ 115, 116, 117, 238, 239, 238, 239, 192, 280, 192, |
| 160927 | | - /* 800 */ 240, 192, 284, 192, 137, 138, 251, 192, 251, 43, |
| 160928 | | - /* 810 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, |
| 160929 | | - /* 820 */ 54, 55, 56, 57, 192, 35, 215, 216, 267, 102, |
| 160930 | | - /* 830 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 160931 | | - /* 840 */ 59, 230, 237, 192, 25, 192, 192, 215, 216, 240, |
| 160932 | | - /* 850 */ 137, 138, 237, 16, 200, 19, 66, 192, 133, 205, |
| 160933 | | - /* 860 */ 135, 136, 230, 303, 74, 203, 215, 216, 102, 103, |
| 160934 | | - /* 870 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 43, |
| 160935 | | - /* 880 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, |
| 160936 | | - /* 890 */ 54, 55, 56, 57, 192, 76, 115, 116, 117, 19, |
| 160937 | | - /* 900 */ 238, 239, 192, 252, 126, 127, 128, 192, 89, 238, |
| 160938 | | - /* 910 */ 239, 92, 303, 251, 77, 262, 79, 215, 216, 129, |
| 160939 | | - /* 920 */ 210, 211, 251, 142, 158, 45, 46, 47, 48, 49, |
| 160940 | | - /* 930 */ 50, 51, 52, 53, 54, 55, 56, 57, 102, 103, |
| 160941 | | - /* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 12, |
| 160942 | | - /* 950 */ 59, 308, 192, 212, 252, 312, 291, 192, 7, 8, |
| 160943 | | - /* 960 */ 9, 300, 301, 203, 27, 126, 127, 128, 308, 207, |
| 160944 | | - /* 970 */ 208, 192, 312, 29, 192, 215, 216, 33, 192, 42, |
| 160945 | | - /* 980 */ 215, 216, 102, 103, 104, 105, 106, 107, 108, 109, |
| 160946 | | - /* 990 */ 110, 111, 112, 283, 158, 230, 66, 160, 238, 239, |
| 160947 | | - /* 1000 */ 63, 215, 216, 192, 192, 12, 115, 116, 117, 65, |
| 160948 | | - /* 1010 */ 73, 251, 252, 192, 19, 85, 230, 192, 24, 24, |
| 160949 | | - /* 1020 */ 27, 261, 210, 211, 94, 192, 215, 216, 22, 207, |
| 160950 | | - /* 1030 */ 208, 290, 192, 142, 19, 42, 215, 216, 43, 44, |
| 160951 | | - /* 1040 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, |
| 160952 | | - /* 1050 */ 55, 56, 57, 59, 19, 144, 63, 192, 43, 44, |
| 160953 | | - /* 1060 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, |
| 160954 | | - /* 1070 */ 55, 56, 57, 252, 163, 145, 114, 22, 43, 44, |
| 160955 | | - /* 1080 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, |
| 160956 | | - /* 1090 */ 55, 56, 57, 45, 212, 283, 263, 102, 103, 104, |
| 160957 | | - /* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 192, |
| 160958 | | - /* 1110 */ 116, 149, 106, 107, 59, 25, 291, 102, 103, 104, |
| 160959 | | - /* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 192, 22, |
| 160960 | | - /* 1130 */ 192, 192, 215, 216, 23, 192, 25, 102, 103, 104, |
| 160961 | | - /* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 108, 192, |
| 160962 | | - /* 1150 */ 192, 215, 216, 215, 216, 106, 107, 19, 215, 216, |
| 160963 | | - /* 1160 */ 53, 59, 114, 114, 115, 116, 117, 285, 119, 137, |
| 160964 | | - /* 1170 */ 138, 116, 290, 230, 134, 192, 127, 192, 192, 139, |
| 160965 | | - /* 1180 */ 59, 192, 44, 45, 46, 47, 48, 49, 50, 51, |
| 160966 | | - /* 1190 */ 52, 53, 54, 55, 56, 57, 308, 76, 215, 216, |
| 160967 | | - /* 1200 */ 312, 152, 263, 154, 215, 216, 192, 117, 87, 19, |
| 160968 | | - /* 1210 */ 89, 19, 20, 92, 22, 22, 23, 231, 116, 230, |
| 160969 | | - /* 1220 */ 263, 263, 237, 203, 298, 299, 203, 239, 36, 215, |
| 160970 | | - /* 1230 */ 216, 192, 142, 192, 15, 45, 115, 116, 117, 251, |
| 160971 | | - /* 1240 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 160972 | | - /* 1250 */ 112, 59, 192, 203, 215, 216, 215, 216, 238, 239, |
| 160973 | | - /* 1260 */ 192, 238, 239, 71, 192, 144, 25, 203, 243, 230, |
| 160974 | | - /* 1270 */ 243, 251, 192, 81, 251, 215, 216, 243, 253, 60, |
| 160975 | | - /* 1280 */ 253, 255, 256, 19, 20, 25, 22, 253, 238, 239, |
| 160976 | | - /* 1290 */ 192, 192, 100, 192, 101, 215, 216, 19, 106, 107, |
| 160977 | | - /* 1300 */ 36, 251, 238, 239, 114, 113, 192, 115, 116, 117, |
| 160978 | | - /* 1310 */ 192, 47, 120, 215, 216, 251, 215, 216, 192, 31, |
| 160979 | | - /* 1320 */ 130, 134, 243, 59, 148, 149, 139, 39, 192, 137, |
| 160980 | | - /* 1330 */ 138, 263, 253, 215, 216, 71, 19, 157, 192, 159, |
| 160981 | | - /* 1340 */ 128, 215, 216, 25, 152, 153, 154, 155, 156, 85, |
| 160982 | | - /* 1350 */ 192, 215, 216, 268, 90, 0, 1, 2, 192, 192, |
| 160983 | | - /* 1360 */ 5, 215, 216, 151, 100, 10, 11, 12, 13, 14, |
| 160984 | | - /* 1370 */ 106, 107, 17, 215, 216, 19, 20, 113, 22, 115, |
| 160985 | | - /* 1380 */ 116, 117, 215, 216, 120, 30, 192, 32, 192, 148, |
| 160986 | | - /* 1390 */ 192, 24, 36, 115, 22, 40, 24, 23, 192, 25, |
| 160987 | | - /* 1400 */ 128, 23, 99, 25, 144, 192, 22, 192, 192, 215, |
| 160988 | | - /* 1410 */ 216, 215, 216, 215, 216, 59, 152, 153, 154, 155, |
| 160989 | | - /* 1420 */ 156, 215, 216, 151, 192, 70, 192, 71, 215, 216, |
| 160990 | | - /* 1430 */ 215, 216, 115, 78, 192, 132, 81, 192, 23, 22, |
| 160991 | | - /* 1440 */ 25, 85, 192, 192, 192, 61, 90, 215, 216, 215, |
| 160992 | | - /* 1450 */ 216, 192, 225, 98, 192, 192, 100, 215, 216, 141, |
| 160993 | | - /* 1460 */ 215, 216, 106, 107, 225, 215, 216, 215, 216, 113, |
| 160994 | | - /* 1470 */ 59, 115, 116, 117, 215, 216, 120, 215, 216, 192, |
| 160995 | | - /* 1480 */ 120, 192, 19, 20, 23, 22, 25, 132, 119, 120, |
| 160996 | | - /* 1490 */ 130, 192, 137, 138, 192, 23, 192, 25, 192, 36, |
| 160997 | | - /* 1500 */ 192, 192, 215, 216, 215, 216, 192, 140, 152, 153, |
| 160998 | | - /* 1510 */ 154, 155, 156, 192, 215, 216, 161, 215, 216, 215, |
| 160999 | | - /* 1520 */ 216, 192, 59, 215, 216, 19, 192, 116, 192, 215, |
| 161000 | | - /* 1530 */ 216, 23, 59, 25, 71, 192, 215, 216, 192, 23, |
| 161001 | | - /* 1540 */ 23, 25, 25, 192, 215, 216, 7, 8, 85, 215, |
| 161002 | | - /* 1550 */ 216, 215, 216, 90, 192, 1, 2, 140, 192, 5, |
| 161003 | | - /* 1560 */ 192, 215, 216, 100, 10, 11, 12, 13, 14, 106, |
| 161004 | | - /* 1570 */ 107, 17, 192, 23, 192, 25, 113, 192, 115, 116, |
| 161005 | | - /* 1580 */ 117, 215, 216, 120, 30, 59, 32, 19, 20, 116, |
| 161006 | | - /* 1590 */ 22, 192, 83, 84, 40, 215, 216, 215, 216, 192, |
| 161007 | | - /* 1600 */ 215, 216, 192, 97, 36, 192, 19, 20, 23, 22, |
| 161008 | | - /* 1610 */ 25, 23, 152, 25, 154, 152, 153, 154, 155, 156, |
| 161009 | | - /* 1620 */ 152, 225, 154, 36, 70, 215, 216, 59, 215, 216, |
| 161010 | | - /* 1630 */ 192, 23, 78, 25, 23, 81, 25, 192, 192, 71, |
| 161011 | | - /* 1640 */ 257, 192, 116, 192, 192, 254, 59, 317, 192, 192, |
| 161012 | | - /* 1650 */ 192, 235, 98, 241, 192, 254, 192, 192, 71, 192, |
| 161013 | | - /* 1660 */ 287, 192, 192, 286, 242, 190, 213, 296, 100, 266, |
| 161014 | | - /* 1670 */ 270, 244, 254, 254, 106, 107, 108, 254, 258, 258, |
| 161015 | | - /* 1680 */ 266, 113, 292, 115, 116, 117, 132, 100, 120, 245, |
| 161016 | | - /* 1690 */ 292, 137, 138, 106, 107, 19, 20, 219, 22, 270, |
| 161017 | | - /* 1700 */ 113, 270, 115, 116, 117, 270, 224, 120, 228, 218, |
| 161018 | | - /* 1710 */ 218, 245, 36, 218, 195, 161, 279, 258, 244, 248, |
| 161019 | | - /* 1720 */ 152, 153, 154, 155, 156, 248, 242, 244, 60, 296, |
| 161020 | | - /* 1730 */ 296, 140, 199, 199, 38, 59, 293, 199, 149, 152, |
| 161021 | | - /* 1740 */ 153, 154, 155, 156, 150, 5, 22, 71, 293, 43, |
| 161022 | | - /* 1750 */ 10, 11, 12, 13, 14, 269, 271, 17, 282, 18, |
| 161023 | | - /* 1760 */ 233, 236, 199, 18, 236, 236, 236, 198, 148, 245, |
| 161024 | | - /* 1770 */ 30, 271, 32, 271, 269, 233, 100, 245, 233, 199, |
| 161025 | | - /* 1780 */ 40, 245, 106, 107, 198, 245, 157, 289, 62, 113, |
| 161026 | | - /* 1790 */ 198, 115, 116, 117, 199, 288, 120, 22, 220, 199, |
| 161027 | | - /* 1800 */ 198, 220, 199, 198, 114, 226, 64, 217, 22, 125, |
| 161028 | | - /* 1810 */ 70, 164, 311, 217, 217, 217, 223, 24, 78, 304, |
| 161029 | | - /* 1820 */ 219, 81, 223, 217, 220, 112, 217, 217, 152, 153, |
| 161030 | | - /* 1830 */ 154, 155, 156, 226, 281, 220, 281, 143, 98, 114, |
| 161031 | | - /* 1840 */ 199, 91, 260, 259, 82, 147, 144, 316, 22, 276, |
| 161032 | | - /* 1850 */ 199, 316, 157, 278, 146, 145, 25, 201, 13, 193, |
| 161033 | | - /* 1860 */ 193, 6, 191, 191, 191, 299, 302, 302, 206, 246, |
| 161034 | | - /* 1870 */ 248, 259, 132, 260, 260, 259, 259, 137, 138, 260, |
| 161035 | | - /* 1880 */ 249, 249, 264, 247, 245, 264, 212, 212, 206, 212, |
| 161036 | | - /* 1890 */ 212, 221, 206, 213, 213, 212, 4, 3, 22, 162, |
| 161037 | | - /* 1900 */ 221, 161, 15, 23, 16, 23, 138, 150, 129, 25, |
| 161038 | | - /* 1910 */ 24, 141, 143, 20, 16, 1, 129, 141, 129, 61, |
| 161039 | | - /* 1920 */ 37, 150, 53, 53, 53, 53, 129, 115, 140, 34, |
| 161040 | | - /* 1930 */ 1, 5, 22, 114, 160, 68, 25, 75, 41, 140, |
| 161041 | | - /* 1940 */ 24, 68, 114, 20, 19, 130, 124, 23, 67, 22, |
| 161042 | | - /* 1950 */ 22, 148, 22, 22, 37, 59, 67, 24, 22, 96, |
| 161043 | | - /* 1960 */ 28, 23, 22, 97, 23, 23, 67, 23, 25, 23, |
| 161044 | | - /* 1970 */ 22, 115, 140, 23, 23, 22, 142, 25, 88, 34, |
| 161045 | | - /* 1980 */ 75, 34, 75, 34, 93, 23, 86, 22, 34, 34, |
| 161046 | | - /* 1990 */ 24, 34, 25, 25, 34, 23, 23, 23, 23, 23, |
| 161047 | | - /* 2000 */ 44, 23, 25, 22, 11, 22, 22, 25, 23, 23, |
| 161048 | | - /* 2010 */ 22, 22, 134, 23, 140, 140, 25, 140, 15, 140, |
| 161049 | | - /* 2020 */ 1, 1, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161050 | | - /* 2030 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161051 | | - /* 2040 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161052 | | - /* 2050 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161053 | | - /* 2060 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161054 | | - /* 2070 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161055 | | - /* 2080 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161056 | | - /* 2090 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161057 | | - /* 2100 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161058 | | - /* 2110 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161059 | | - /* 2120 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161060 | | - /* 2130 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161061 | | - /* 2140 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161062 | | - /* 2150 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161063 | | - /* 2160 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161064 | | - /* 2170 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161065 | | - /* 2180 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161066 | | - /* 2190 */ 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, |
| 161067 | | - /* 2200 */ 318, 318, 318, 318, 318, 318, |
| 161068 | | -}; |
| 161069 | | -#define YY_SHIFT_COUNT (571) |
| 161071 | + /* 0 */ 193, 223, 193, 225, 193, 193, 193, 274, 275, 276, |
| 161072 | + /* 10 */ 193, 233, 219, 193, 274, 275, 276, 206, 206, 19, |
| 161073 | + /* 20 */ 193, 219, 216, 216, 217, 216, 217, 193, 295, 216, |
| 161074 | + /* 30 */ 217, 31, 205, 216, 217, 193, 216, 217, 213, 39, |
| 161075 | + /* 40 */ 228, 193, 230, 43, 44, 45, 46, 47, 48, 49, |
| 161076 | + /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 193, 19, |
| 161077 | + /* 60 */ 185, 186, 187, 188, 189, 190, 253, 274, 275, 276, |
| 161078 | + /* 70 */ 195, 193, 197, 253, 216, 262, 274, 275, 276, 204, |
| 161079 | + /* 80 */ 238, 204, 262, 43, 44, 45, 46, 47, 48, 49, |
| 161080 | + /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 264, 274, |
| 161081 | + /* 100 */ 275, 276, 102, 103, 104, 105, 106, 107, 108, 109, |
| 161082 | + /* 110 */ 110, 111, 112, 113, 239, 240, 239, 240, 210, 211, |
| 161083 | + /* 120 */ 212, 314, 315, 314, 59, 316, 86, 252, 88, 252, |
| 161084 | + /* 130 */ 19, 314, 315, 256, 257, 309, 25, 72, 296, 313, |
| 161085 | + /* 140 */ 193, 266, 102, 103, 104, 105, 106, 107, 108, 109, |
| 161086 | + /* 150 */ 110, 111, 112, 113, 43, 44, 45, 46, 47, 48, |
| 161087 | + /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 81, |
| 161088 | + /* 170 */ 292, 59, 307, 298, 108, 109, 110, 111, 112, 113, |
| 161089 | + /* 180 */ 69, 116, 117, 118, 72, 128, 129, 193, 241, 22, |
| 161090 | + /* 190 */ 113, 54, 55, 56, 57, 58, 102, 103, 104, 105, |
| 161091 | + /* 200 */ 106, 107, 108, 109, 110, 111, 112, 113, 120, 193, |
| 161092 | + /* 210 */ 216, 217, 25, 102, 103, 104, 105, 106, 107, 108, |
| 161093 | + /* 220 */ 109, 110, 111, 112, 113, 231, 138, 139, 116, 117, |
| 161094 | + /* 230 */ 118, 106, 107, 19, 216, 54, 55, 56, 57, 102, |
| 161095 | + /* 240 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 161096 | + /* 250 */ 113, 304, 25, 46, 47, 48, 49, 43, 44, 45, |
| 161097 | + /* 260 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, |
| 161098 | + /* 270 */ 56, 57, 193, 106, 107, 59, 193, 19, 153, 263, |
| 161099 | + /* 280 */ 155, 67, 24, 102, 103, 104, 105, 106, 107, 108, |
| 161100 | + /* 290 */ 109, 110, 111, 112, 113, 216, 217, 59, 230, 216, |
| 161101 | + /* 300 */ 217, 43, 44, 45, 46, 47, 48, 49, 50, 51, |
| 161102 | + /* 310 */ 52, 53, 54, 55, 56, 57, 102, 103, 104, 105, |
| 161103 | + /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 121, 142, |
| 161104 | + /* 330 */ 59, 193, 116, 117, 118, 119, 253, 204, 122, 123, |
| 161105 | + /* 340 */ 124, 19, 20, 81, 22, 262, 108, 19, 132, 165, |
| 161106 | + /* 350 */ 166, 193, 24, 126, 116, 117, 118, 278, 36, 193, |
| 161107 | + /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, |
| 161108 | + /* 370 */ 112, 113, 239, 240, 216, 217, 215, 106, 107, 241, |
| 161109 | + /* 380 */ 19, 59, 216, 217, 223, 252, 115, 116, 117, 118, |
| 161110 | + /* 390 */ 73, 120, 26, 71, 193, 22, 193, 231, 81, 128, |
| 161111 | + /* 400 */ 138, 139, 269, 81, 43, 44, 45, 46, 47, 48, |
| 161112 | + /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 216, |
| 161113 | + /* 420 */ 217, 198, 100, 95, 153, 59, 155, 193, 106, 107, |
| 161114 | + /* 430 */ 235, 236, 59, 193, 193, 249, 114, 251, 116, 117, |
| 161115 | + /* 440 */ 118, 113, 304, 121, 127, 204, 193, 119, 120, 121, |
| 161116 | + /* 450 */ 122, 123, 124, 125, 193, 138, 139, 216, 217, 131, |
| 161117 | + /* 460 */ 138, 139, 193, 102, 103, 104, 105, 106, 107, 108, |
| 161118 | + /* 470 */ 109, 110, 111, 112, 113, 153, 154, 155, 156, 157, |
| 161119 | + /* 480 */ 239, 240, 116, 117, 118, 76, 193, 193, 19, 116, |
| 161120 | + /* 490 */ 117, 118, 23, 252, 253, 193, 87, 204, 89, 238, |
| 161121 | + /* 500 */ 193, 92, 268, 262, 281, 203, 193, 205, 285, 216, |
| 161122 | + /* 510 */ 217, 150, 43, 44, 45, 46, 47, 48, 49, 50, |
| 161123 | + /* 520 */ 51, 52, 53, 54, 55, 56, 57, 193, 193, 216, |
| 161124 | + /* 530 */ 217, 19, 239, 240, 59, 23, 106, 107, 108, 109, |
| 161125 | + /* 540 */ 110, 111, 112, 113, 231, 252, 253, 193, 308, 309, |
| 161126 | + /* 550 */ 193, 145, 59, 313, 145, 43, 44, 45, 46, 47, |
| 161127 | + /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 161128 | + /* 570 */ 164, 102, 103, 104, 105, 106, 107, 108, 109, 110, |
| 161129 | + /* 580 */ 111, 112, 113, 119, 193, 193, 122, 123, 124, 193, |
| 161130 | + /* 590 */ 283, 116, 117, 118, 235, 236, 132, 59, 241, 264, |
| 161131 | + /* 600 */ 59, 193, 19, 23, 193, 25, 23, 216, 217, 116, |
| 161132 | + /* 610 */ 117, 118, 216, 217, 102, 103, 104, 105, 106, 107, |
| 161133 | + /* 620 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, |
| 161134 | + /* 630 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161135 | + /* 640 */ 57, 19, 308, 309, 151, 23, 25, 313, 135, 253, |
| 161136 | + /* 650 */ 21, 193, 241, 140, 116, 117, 118, 116, 117, 118, |
| 161137 | + /* 660 */ 268, 304, 22, 301, 302, 43, 44, 45, 46, 47, |
| 161138 | + /* 670 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 161139 | + /* 680 */ 193, 143, 193, 193, 143, 102, 103, 104, 105, 106, |
| 161140 | + /* 690 */ 107, 108, 109, 110, 111, 112, 113, 76, 118, 59, |
| 161141 | + /* 700 */ 292, 211, 212, 216, 217, 216, 217, 73, 193, 80, |
| 161142 | + /* 710 */ 89, 25, 19, 92, 193, 304, 23, 22, 231, 193, |
| 161143 | + /* 720 */ 231, 193, 22, 143, 102, 103, 104, 105, 106, 107, |
| 161144 | + /* 730 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, |
| 161145 | + /* 740 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161146 | + /* 750 */ 57, 19, 123, 193, 59, 23, 116, 117, 118, 59, |
| 161147 | + /* 760 */ 193, 127, 128, 129, 306, 307, 210, 211, 212, 193, |
| 161148 | + /* 770 */ 22, 111, 112, 113, 284, 43, 44, 45, 46, 47, |
| 161149 | + /* 780 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 161150 | + /* 790 */ 161, 193, 216, 217, 268, 102, 103, 104, 105, 106, |
| 161151 | + /* 800 */ 107, 108, 109, 110, 111, 112, 113, 59, 193, 193, |
| 161152 | + /* 810 */ 193, 116, 117, 118, 216, 217, 116, 117, 118, 304, |
| 161153 | + /* 820 */ 239, 240, 19, 263, 138, 139, 23, 211, 212, 231, |
| 161154 | + /* 830 */ 263, 216, 217, 252, 102, 103, 104, 105, 106, 107, |
| 161155 | + /* 840 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, |
| 161156 | + /* 850 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161157 | + /* 860 */ 57, 19, 193, 11, 116, 117, 118, 240, 253, 193, |
| 161158 | + /* 870 */ 201, 239, 240, 193, 134, 206, 136, 137, 193, 252, |
| 161159 | + /* 880 */ 193, 264, 193, 193, 252, 43, 44, 45, 46, 47, |
| 161160 | + /* 890 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, |
| 161161 | + /* 900 */ 284, 216, 217, 216, 217, 102, 103, 104, 105, 106, |
| 161162 | + /* 910 */ 107, 108, 109, 110, 111, 112, 113, 193, 231, 193, |
| 161163 | + /* 920 */ 187, 188, 189, 190, 127, 128, 129, 238, 195, 193, |
| 161164 | + /* 930 */ 197, 16, 19, 7, 8, 9, 193, 204, 253, 193, |
| 161165 | + /* 940 */ 216, 217, 216, 217, 102, 103, 104, 105, 106, 107, |
| 161166 | + /* 950 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, |
| 161167 | + /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161168 | + /* 970 */ 57, 213, 239, 240, 193, 76, 19, 188, 232, 190, |
| 161169 | + /* 980 */ 128, 129, 292, 193, 195, 252, 197, 46, 89, 138, |
| 161170 | + /* 990 */ 139, 92, 77, 204, 79, 193, 269, 216, 217, 266, |
| 161171 | + /* 1000 */ 204, 159, 45, 46, 47, 48, 49, 50, 51, 52, |
| 161172 | + /* 1010 */ 53, 54, 55, 56, 57, 102, 103, 104, 105, 106, |
| 161173 | + /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 12, 239, 240, |
| 161174 | + /* 1030 */ 193, 298, 22, 23, 253, 239, 240, 127, 128, 129, |
| 161175 | + /* 1040 */ 238, 252, 27, 193, 286, 204, 193, 204, 252, 291, |
| 161176 | + /* 1050 */ 193, 273, 22, 23, 100, 266, 115, 42, 268, 102, |
| 161177 | + /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, |
| 161178 | + /* 1070 */ 113, 117, 159, 216, 217, 121, 161, 19, 63, 193, |
| 161179 | + /* 1080 */ 239, 240, 239, 240, 12, 208, 209, 298, 73, 311, |
| 161180 | + /* 1090 */ 312, 238, 19, 252, 25, 252, 22, 24, 24, 27, |
| 161181 | + /* 1100 */ 193, 264, 216, 217, 46, 208, 209, 153, 154, 155, |
| 161182 | + /* 1110 */ 253, 101, 19, 23, 42, 25, 43, 44, 45, 46, |
| 161183 | + /* 1120 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161184 | + /* 1130 */ 57, 101, 19, 59, 25, 63, 43, 44, 45, 46, |
| 161185 | + /* 1140 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161186 | + /* 1150 */ 57, 22, 23, 115, 25, 24, 43, 44, 45, 46, |
| 161187 | + /* 1160 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, |
| 161188 | + /* 1170 */ 57, 22, 23, 115, 25, 102, 103, 104, 105, 106, |
| 161189 | + /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 118, 150, 131, |
| 161190 | + /* 1190 */ 59, 117, 22, 273, 193, 102, 103, 104, 105, 106, |
| 161191 | + /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 204, 66, 204, |
| 161192 | + /* 1210 */ 35, 204, 143, 213, 193, 102, 103, 104, 105, 106, |
| 161193 | + /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 85, 193, 59, |
| 161194 | + /* 1230 */ 101, 311, 312, 16, 193, 19, 94, 216, 217, 238, |
| 161195 | + /* 1240 */ 193, 66, 239, 240, 239, 240, 239, 240, 117, 74, |
| 161196 | + /* 1250 */ 101, 216, 217, 193, 193, 252, 193, 252, 149, 252, |
| 161197 | + /* 1260 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, |
| 161198 | + /* 1270 */ 54, 55, 56, 57, 193, 193, 193, 5, 59, 216, |
| 161199 | + /* 1280 */ 217, 25, 10, 11, 12, 13, 14, 117, 146, 17, |
| 161200 | + /* 1290 */ 193, 291, 193, 232, 77, 76, 79, 216, 217, 216, |
| 161201 | + /* 1300 */ 217, 31, 30, 309, 32, 130, 87, 313, 89, 39, |
| 161202 | + /* 1310 */ 193, 92, 40, 216, 217, 216, 217, 108, 102, 103, |
| 161203 | + /* 1320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, |
| 161204 | + /* 1330 */ 299, 300, 193, 216, 217, 116, 117, 118, 19, 20, |
| 161205 | + /* 1340 */ 193, 22, 70, 309, 135, 193, 264, 313, 193, 140, |
| 161206 | + /* 1350 */ 78, 193, 226, 81, 59, 36, 193, 309, 193, 29, |
| 161207 | + /* 1360 */ 193, 313, 193, 33, 145, 193, 59, 48, 216, 217, |
| 161208 | + /* 1370 */ 98, 216, 217, 193, 216, 217, 193, 244, 59, 216, |
| 161209 | + /* 1380 */ 217, 216, 217, 216, 217, 216, 217, 254, 216, 217, |
| 161210 | + /* 1390 */ 71, 193, 244, 193, 193, 65, 216, 217, 193, 216, |
| 161211 | + /* 1400 */ 217, 145, 254, 244, 85, 133, 15, 100, 193, 90, |
| 161212 | + /* 1410 */ 138, 139, 117, 254, 216, 217, 216, 217, 193, 100, |
| 161213 | + /* 1420 */ 193, 216, 217, 116, 117, 106, 107, 19, 121, 193, |
| 161214 | + /* 1430 */ 193, 216, 217, 114, 162, 116, 117, 118, 244, 244, |
| 161215 | + /* 1440 */ 121, 216, 217, 216, 217, 193, 309, 129, 254, 254, |
| 161216 | + /* 1450 */ 313, 60, 216, 217, 19, 256, 257, 193, 120, 121, |
| 161217 | + /* 1460 */ 153, 154, 155, 149, 150, 25, 24, 99, 216, 217, |
| 161218 | + /* 1470 */ 152, 193, 153, 154, 155, 156, 157, 0, 1, 2, |
| 161219 | + /* 1480 */ 216, 217, 5, 22, 158, 24, 160, 10, 11, 12, |
| 161220 | + /* 1490 */ 13, 14, 193, 23, 17, 25, 193, 19, 20, 193, |
| 161221 | + /* 1500 */ 22, 133, 193, 22, 22, 193, 22, 30, 193, 32, |
| 161222 | + /* 1510 */ 19, 20, 129, 22, 36, 216, 217, 40, 193, 216, |
| 161223 | + /* 1520 */ 217, 193, 216, 217, 116, 216, 217, 36, 216, 217, |
| 161224 | + /* 1530 */ 193, 216, 217, 193, 53, 152, 193, 59, 23, 19, |
| 161225 | + /* 1540 */ 25, 216, 217, 61, 216, 217, 23, 70, 25, 71, |
| 161226 | + /* 1550 */ 59, 116, 193, 216, 217, 78, 216, 217, 81, 216, |
| 161227 | + /* 1560 */ 217, 59, 71, 85, 193, 23, 193, 25, 90, 23, |
| 161228 | + /* 1570 */ 23, 25, 25, 7, 8, 98, 85, 193, 100, 193, |
| 161229 | + /* 1580 */ 59, 90, 142, 141, 106, 107, 193, 216, 217, 216, |
| 161230 | + /* 1590 */ 217, 100, 114, 193, 116, 117, 118, 106, 107, 121, |
| 161231 | + /* 1600 */ 216, 217, 216, 217, 193, 114, 193, 116, 117, 118, |
| 161232 | + /* 1610 */ 133, 23, 121, 25, 121, 138, 139, 97, 23, 117, |
| 161233 | + /* 1620 */ 25, 23, 193, 25, 131, 141, 193, 216, 217, 59, |
| 161234 | + /* 1630 */ 193, 153, 154, 155, 156, 157, 226, 193, 117, 162, |
| 161235 | + /* 1640 */ 23, 23, 25, 25, 153, 154, 155, 156, 157, 1, |
| 161236 | + /* 1650 */ 2, 83, 84, 5, 19, 20, 226, 22, 10, 11, |
| 161237 | + /* 1660 */ 12, 13, 14, 258, 153, 17, 155, 153, 23, 155, |
| 161238 | + /* 1670 */ 25, 36, 23, 193, 25, 255, 193, 236, 30, 193, |
| 161239 | + /* 1680 */ 32, 19, 20, 193, 22, 193, 288, 117, 40, 193, |
| 161240 | + /* 1690 */ 318, 193, 193, 193, 59, 242, 193, 193, 36, 193, |
| 161241 | + /* 1700 */ 193, 193, 287, 255, 255, 255, 71, 255, 243, 214, |
| 161242 | + /* 1710 */ 191, 297, 267, 245, 271, 259, 259, 293, 70, 246, |
| 161243 | + /* 1720 */ 246, 59, 267, 229, 245, 271, 78, 293, 259, 81, |
| 161244 | + /* 1730 */ 271, 271, 220, 71, 225, 100, 219, 219, 249, 196, |
| 161245 | + /* 1740 */ 243, 106, 107, 108, 219, 60, 98, 280, 297, 114, |
| 161246 | + /* 1750 */ 249, 116, 117, 118, 141, 245, 121, 200, 200, 297, |
| 161247 | + /* 1760 */ 38, 200, 100, 151, 150, 294, 294, 22, 106, 107, |
| 161248 | + /* 1770 */ 283, 43, 234, 18, 237, 200, 114, 272, 116, 117, |
| 161249 | + /* 1780 */ 118, 133, 237, 121, 18, 237, 138, 139, 153, 154, |
| 161250 | + /* 1790 */ 155, 156, 157, 237, 270, 199, 19, 20, 246, 22, |
| 161251 | + /* 1800 */ 149, 272, 272, 270, 200, 246, 234, 234, 246, 246, |
| 161252 | + /* 1810 */ 162, 158, 290, 36, 199, 153, 154, 155, 156, 157, |
| 161253 | + /* 1820 */ 62, 289, 200, 199, 22, 200, 221, 199, 221, 200, |
| 161254 | + /* 1830 */ 199, 115, 64, 227, 218, 22, 59, 218, 218, 126, |
| 161255 | + /* 1840 */ 165, 24, 113, 312, 218, 224, 305, 224, 71, 282, |
| 161256 | + /* 1850 */ 144, 221, 220, 282, 218, 218, 218, 115, 261, 260, |
| 161257 | + /* 1860 */ 227, 221, 261, 260, 200, 91, 317, 317, 82, 261, |
| 161258 | + /* 1870 */ 260, 148, 261, 22, 265, 145, 200, 100, 158, 277, |
| 161259 | + /* 1880 */ 147, 146, 25, 106, 107, 202, 13, 260, 194, 250, |
| 161260 | + /* 1890 */ 249, 114, 248, 116, 117, 118, 250, 247, 121, 265, |
| 161261 | + /* 1900 */ 246, 194, 6, 192, 192, 207, 192, 207, 213, 213, |
| 161262 | + /* 1910 */ 213, 222, 213, 222, 4, 214, 214, 213, 3, 22, |
| 161263 | + /* 1920 */ 163, 279, 207, 15, 23, 16, 23, 139, 130, 151, |
| 161264 | + /* 1930 */ 153, 154, 155, 156, 157, 142, 25, 24, 20, 144, |
| 161265 | + /* 1940 */ 16, 1, 142, 61, 130, 130, 303, 151, 53, 37, |
| 161266 | + /* 1950 */ 303, 53, 300, 53, 130, 53, 116, 34, 1, 141, |
| 161267 | + /* 1960 */ 5, 22, 115, 25, 161, 75, 41, 68, 141, 115, |
| 161268 | + /* 1970 */ 24, 20, 68, 19, 131, 125, 23, 96, 22, 59, |
| 161269 | + /* 1980 */ 22, 67, 22, 22, 67, 22, 24, 28, 67, 37, |
| 161270 | + /* 1990 */ 23, 149, 22, 25, 23, 23, 23, 23, 22, 141, |
| 161271 | + /* 2000 */ 23, 23, 97, 116, 22, 143, 25, 88, 75, 34, |
| 161272 | + /* 2010 */ 44, 75, 86, 34, 34, 93, 23, 34, 34, 34, |
| 161273 | + /* 2020 */ 22, 24, 34, 22, 25, 25, 23, 23, 23, 23, |
| 161274 | + /* 2030 */ 23, 11, 23, 25, 22, 22, 25, 23, 23, 22, |
| 161275 | + /* 2040 */ 22, 135, 15, 1, 25, 23, 1, 319, 141, 319, |
| 161276 | + /* 2050 */ 319, 319, 319, 319, 319, 319, 319, 141, 319, 319, |
| 161277 | + /* 2060 */ 319, 319, 319, 319, 319, 319, 319, 319, 141, 141, |
| 161278 | + /* 2070 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161279 | + /* 2080 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161280 | + /* 2090 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161281 | + /* 2100 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161282 | + /* 2110 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161283 | + /* 2120 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161284 | + /* 2130 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161285 | + /* 2140 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161286 | + /* 2150 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161287 | + /* 2160 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161288 | + /* 2170 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161289 | + /* 2180 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161290 | + /* 2190 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161291 | + /* 2200 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161292 | + /* 2210 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161293 | + /* 2220 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161294 | + /* 2230 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161295 | + /* 2240 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, |
| 161296 | + /* 2250 */ 319, 319, 319, 319, 319, |
| 161297 | +}; |
| 161298 | +#define YY_SHIFT_COUNT (573) |
| 161070 | 161299 | #define YY_SHIFT_MIN (0) |
| 161071 | | -#define YY_SHIFT_MAX (2020) |
| 161300 | +#define YY_SHIFT_MAX (2045) |
| 161072 | 161301 | static const unsigned short int yy_shift_ofst[] = { |
| 161073 | | - /* 0 */ 1554, 1355, 1740, 1192, 1192, 552, 1264, 1356, 1463, 1587, |
| 161074 | | - /* 10 */ 1587, 1587, 276, 0, 0, 180, 1015, 1587, 1587, 1587, |
| 161075 | | - /* 20 */ 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, |
| 161076 | | - /* 30 */ 1049, 1049, 1121, 1121, 54, 667, 552, 552, 552, 552, |
| 161077 | | - /* 40 */ 552, 40, 110, 219, 289, 396, 439, 509, 548, 618, |
| 161078 | | - /* 50 */ 657, 727, 766, 836, 995, 1015, 1015, 1015, 1015, 1015, |
| 161079 | | - /* 60 */ 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, |
| 161080 | | - /* 70 */ 1015, 1015, 1015, 1035, 1015, 1138, 880, 880, 1568, 1587, |
| 161081 | | - /* 80 */ 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, |
| 161082 | | - /* 90 */ 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, |
| 161083 | | - /* 100 */ 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, 1587, |
| 161084 | | - /* 110 */ 1587, 1587, 1587, 1676, 1587, 1587, 1587, 1587, 1587, 1587, |
| 161085 | | - /* 120 */ 1587, 1587, 1587, 1587, 1587, 1587, 1587, 146, 84, 84, |
| 161086 | | - /* 130 */ 84, 84, 84, 277, 315, 401, 97, 461, 251, 531, |
| 161087 | | - /* 140 */ 531, 51, 1190, 531, 531, 324, 324, 531, 713, 713, |
| 161088 | | - /* 150 */ 713, 713, 151, 154, 154, 4, 149, 2022, 2022, 621, |
| 161089 | | - /* 160 */ 621, 621, 567, 398, 398, 398, 398, 937, 937, 228, |
| 161090 | | - /* 170 */ 251, 159, 331, 531, 531, 531, 531, 531, 531, 531, |
| 161091 | | - /* 180 */ 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, |
| 161092 | | - /* 190 */ 531, 531, 531, 819, 819, 531, 9, 25, 25, 1102, |
| 161093 | | - /* 200 */ 1102, 911, 1032, 2022, 2022, 2022, 2022, 2022, 2022, 2022, |
| 161094 | | - /* 210 */ 255, 317, 317, 514, 403, 620, 471, 672, 781, 891, |
| 161095 | | - /* 220 */ 675, 531, 531, 531, 531, 531, 531, 531, 531, 531, |
| 161096 | | - /* 230 */ 531, 454, 531, 531, 531, 531, 531, 531, 531, 531, |
| 161097 | | - /* 240 */ 531, 531, 531, 531, 790, 790, 790, 531, 531, 531, |
| 161098 | | - /* 250 */ 338, 531, 531, 531, 516, 930, 531, 531, 993, 531, |
| 161099 | | - /* 260 */ 531, 531, 531, 531, 531, 531, 531, 778, 944, 725, |
| 161100 | | - /* 270 */ 994, 994, 994, 994, 1090, 725, 725, 1040, 1006, 951, |
| 161101 | | - /* 280 */ 1219, 962, 1176, 98, 1278, 1176, 1278, 1317, 1241, 962, |
| 161102 | | - /* 290 */ 962, 1241, 962, 98, 1317, 286, 1111, 1048, 1288, 1288, |
| 161103 | | - /* 300 */ 1288, 1278, 1260, 1260, 1180, 1318, 1187, 1372, 1668, 1668, |
| 161104 | | - /* 310 */ 1591, 1591, 1696, 1696, 1591, 1594, 1589, 1724, 1706, 1741, |
| 161105 | | - /* 320 */ 1741, 1741, 1741, 1591, 1745, 1620, 1589, 1589, 1620, 1724, |
| 161106 | | - /* 330 */ 1706, 1620, 1706, 1620, 1591, 1745, 1629, 1726, 1591, 1745, |
| 161107 | | - /* 340 */ 1775, 1591, 1745, 1591, 1745, 1775, 1690, 1690, 1690, 1742, |
| 161108 | | - /* 350 */ 1786, 1786, 1775, 1690, 1684, 1690, 1742, 1690, 1690, 1647, |
| 161109 | | - /* 360 */ 1793, 1713, 1713, 1775, 1694, 1725, 1694, 1725, 1694, 1725, |
| 161110 | | - /* 370 */ 1694, 1725, 1591, 1750, 1750, 1762, 1762, 1698, 1702, 1826, |
| 161111 | | - /* 380 */ 1591, 1695, 1698, 1708, 1710, 1620, 1831, 1845, 1845, 1855, |
| 161112 | | - /* 390 */ 1855, 1855, 2022, 2022, 2022, 2022, 2022, 2022, 2022, 2022, |
| 161113 | | - /* 400 */ 2022, 2022, 2022, 2022, 2022, 2022, 2022, 578, 837, 655, |
| 161114 | | - /* 410 */ 1193, 167, 839, 1055, 1374, 1303, 1107, 1367, 1212, 1272, |
| 161115 | | - /* 420 */ 1378, 1384, 1415, 1461, 1472, 1508, 1516, 1517, 1411, 1369, |
| 161116 | | - /* 430 */ 1539, 1360, 1506, 1473, 1550, 1585, 1509, 1588, 1460, 1468, |
| 161117 | | - /* 440 */ 1608, 1611, 1526, 1417, 1892, 1894, 1876, 1737, 1887, 1888, |
| 161118 | | - /* 450 */ 1880, 1882, 1768, 1757, 1779, 1884, 1884, 1886, 1770, 1893, |
| 161119 | | - /* 460 */ 1769, 1898, 1914, 1776, 1787, 1884, 1789, 1858, 1883, 1884, |
| 161120 | | - /* 470 */ 1771, 1869, 1870, 1871, 1872, 1797, 1812, 1895, 1788, 1929, |
| 161121 | | - /* 480 */ 1926, 1910, 1819, 1774, 1867, 1911, 1873, 1862, 1897, 1799, |
| 161122 | | - /* 490 */ 1828, 1916, 1923, 1925, 1815, 1822, 1927, 1881, 1928, 1930, |
| 161123 | | - /* 500 */ 1924, 1931, 1889, 1896, 1933, 1863, 1932, 1936, 1899, 1917, |
| 161124 | | - /* 510 */ 1938, 1803, 1940, 1941, 1942, 1944, 1943, 1946, 1948, 1866, |
| 161125 | | - /* 520 */ 1832, 1950, 1951, 1856, 1945, 1953, 1834, 1952, 1947, 1949, |
| 161126 | | - /* 530 */ 1954, 1955, 1890, 1905, 1900, 1956, 1907, 1891, 1957, 1962, |
| 161127 | | - /* 540 */ 1965, 1966, 1967, 1968, 1960, 1972, 1952, 1973, 1974, 1975, |
| 161128 | | - /* 550 */ 1976, 1977, 1978, 1981, 1993, 1983, 1984, 1985, 1986, 1988, |
| 161129 | | - /* 560 */ 1989, 1982, 1878, 1874, 1875, 1877, 1879, 1991, 1990, 2003, |
| 161130 | | - /* 570 */ 2019, 2020, |
| 161131 | | -}; |
| 161132 | | -#define YY_REDUCE_COUNT (406) |
| 161133 | | -#define YY_REDUCE_MIN (-272) |
| 161134 | | -#define YY_REDUCE_MAX (1686) |
| 161302 | + /* 0 */ 1648, 1477, 1272, 322, 322, 262, 1319, 1478, 1491, 1662, |
| 161303 | + /* 10 */ 1662, 1662, 317, 0, 0, 214, 1093, 1662, 1662, 1662, |
| 161304 | + /* 20 */ 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, |
| 161305 | + /* 30 */ 271, 271, 1219, 1219, 216, 88, 262, 262, 262, 262, |
| 161306 | + /* 40 */ 262, 40, 111, 258, 361, 469, 512, 583, 622, 693, |
| 161307 | + /* 50 */ 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093, 1093, |
| 161308 | + /* 60 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, |
| 161309 | + /* 70 */ 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1635, 1662, |
| 161310 | + /* 80 */ 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, |
| 161311 | + /* 90 */ 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, |
| 161312 | + /* 100 */ 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, |
| 161313 | + /* 110 */ 1662, 1662, 1662, 1662, 1777, 1662, 1662, 1662, 1662, 1662, |
| 161314 | + /* 120 */ 1662, 1662, 1662, 1662, 1662, 1662, 1662, 1662, 137, 181, |
| 161315 | + /* 130 */ 181, 181, 181, 181, 94, 430, 66, 65, 112, 366, |
| 161316 | + /* 140 */ 475, 475, 629, 1058, 475, 475, 125, 125, 475, 686, |
| 161317 | + /* 150 */ 686, 686, 660, 686, 57, 184, 184, 77, 77, 2070, |
| 161318 | + /* 160 */ 2070, 328, 328, 328, 493, 373, 373, 373, 373, 1015, |
| 161319 | + /* 170 */ 1015, 409, 366, 1129, 1149, 475, 475, 475, 475, 475, |
| 161320 | + /* 180 */ 475, 475, 475, 475, 475, 475, 475, 475, 475, 475, |
| 161321 | + /* 190 */ 475, 475, 475, 475, 475, 621, 621, 475, 852, 899, |
| 161322 | + /* 200 */ 899, 1295, 1295, 406, 851, 2070, 2070, 2070, 2070, 2070, |
| 161323 | + /* 210 */ 2070, 2070, 1307, 954, 954, 640, 464, 695, 238, 700, |
| 161324 | + /* 220 */ 538, 541, 748, 475, 475, 475, 475, 475, 475, 475, |
| 161325 | + /* 230 */ 475, 475, 475, 634, 475, 475, 475, 475, 475, 475, |
| 161326 | + /* 240 */ 475, 475, 475, 475, 475, 475, 1175, 1175, 1175, 475, |
| 161327 | + /* 250 */ 475, 475, 580, 475, 475, 475, 1074, 1142, 475, 475, |
| 161328 | + /* 260 */ 1072, 475, 475, 475, 475, 475, 475, 475, 475, 797, |
| 161329 | + /* 270 */ 1330, 740, 1131, 1131, 1131, 1131, 1069, 740, 740, 1209, |
| 161330 | + /* 280 */ 167, 926, 1391, 1038, 1314, 187, 1408, 1314, 1408, 1435, |
| 161331 | + /* 290 */ 1109, 1038, 1038, 1109, 1038, 187, 1435, 227, 1090, 941, |
| 161332 | + /* 300 */ 1270, 1270, 1270, 1408, 1256, 1256, 1326, 1440, 513, 1461, |
| 161333 | + /* 310 */ 1685, 1685, 1613, 1613, 1722, 1722, 1613, 1612, 1614, 1745, |
| 161334 | + /* 320 */ 1728, 1755, 1755, 1755, 1755, 1613, 1766, 1651, 1614, 1614, |
| 161335 | + /* 330 */ 1651, 1745, 1728, 1651, 1728, 1651, 1613, 1766, 1653, 1758, |
| 161336 | + /* 340 */ 1613, 1766, 1802, 1613, 1766, 1613, 1766, 1802, 1716, 1716, |
| 161337 | + /* 350 */ 1716, 1768, 1813, 1813, 1802, 1716, 1713, 1716, 1768, 1716, |
| 161338 | + /* 360 */ 1716, 1675, 1817, 1729, 1729, 1802, 1706, 1742, 1706, 1742, |
| 161339 | + /* 370 */ 1706, 1742, 1706, 1742, 1613, 1774, 1774, 1786, 1786, 1723, |
| 161340 | + /* 380 */ 1730, 1851, 1613, 1720, 1723, 1733, 1735, 1651, 1857, 1873, |
| 161341 | + /* 390 */ 1873, 1896, 1896, 1896, 2070, 2070, 2070, 2070, 2070, 2070, |
| 161342 | + /* 400 */ 2070, 2070, 2070, 2070, 2070, 2070, 2070, 2070, 2070, 207, |
| 161343 | + /* 410 */ 915, 1010, 1030, 1217, 910, 1170, 1470, 1368, 1481, 1442, |
| 161344 | + /* 420 */ 1318, 1383, 1515, 1482, 1523, 1542, 1546, 1547, 1588, 1595, |
| 161345 | + /* 430 */ 1502, 1338, 1566, 1493, 1520, 1521, 1598, 1617, 1568, 1618, |
| 161346 | + /* 440 */ 1511, 1514, 1645, 1649, 1570, 1484, 1910, 1915, 1897, 1757, |
| 161347 | + /* 450 */ 1908, 1909, 1901, 1903, 1788, 1778, 1798, 1911, 1911, 1913, |
| 161348 | + /* 460 */ 1793, 1918, 1795, 1924, 1940, 1800, 1814, 1911, 1815, 1882, |
| 161349 | + /* 470 */ 1912, 1911, 1796, 1895, 1898, 1900, 1902, 1824, 1840, 1923, |
| 161350 | + /* 480 */ 1818, 1957, 1955, 1939, 1847, 1803, 1899, 1938, 1904, 1890, |
| 161351 | + /* 490 */ 1925, 1827, 1854, 1946, 1951, 1954, 1843, 1850, 1956, 1914, |
| 161352 | + /* 500 */ 1958, 1960, 1953, 1961, 1917, 1920, 1962, 1881, 1959, 1963, |
| 161353 | + /* 510 */ 1921, 1952, 1967, 1842, 1970, 1971, 1972, 1973, 1968, 1974, |
| 161354 | + /* 520 */ 1976, 1905, 1858, 1977, 1978, 1887, 1975, 1982, 1862, 1981, |
| 161355 | + /* 530 */ 1979, 1980, 1983, 1984, 1919, 1933, 1926, 1966, 1936, 1922, |
| 161356 | + /* 540 */ 1985, 1993, 1998, 1997, 1999, 2000, 1988, 2003, 1981, 2004, |
| 161357 | + /* 550 */ 2005, 2006, 2007, 2008, 2009, 2001, 2020, 2012, 2013, 2014, |
| 161358 | + /* 560 */ 2015, 2017, 2018, 2011, 1906, 1907, 1916, 1927, 1928, 2019, |
| 161359 | + /* 570 */ 2022, 2027, 2042, 2045, |
| 161360 | +}; |
| 161361 | +#define YY_REDUCE_COUNT (408) |
| 161362 | +#define YY_REDUCE_MIN (-267) |
| 161363 | +#define YY_REDUCE_MAX (1715) |
| 161135 | 161364 | static const short yy_reduce_ofst[] = { |
| 161136 | | - /* 0 */ 109, 113, 272, 760, -178, -176, -192, -183, -180, -134, |
| 161137 | | - /* 10 */ 213, 220, 371, -208, -205, -272, -197, 611, 632, 765, |
| 161138 | | - /* 20 */ 786, 392, 943, 989, 503, 651, 1039, -18, 702, 821, |
| 161139 | | - /* 30 */ 710, 812, -188, -67, -187, 555, 662, 1020, 1023, 1050, |
| 161140 | | - /* 40 */ 1064, -267, -267, -267, -267, -267, -267, -267, -267, -267, |
| 161141 | | - /* 50 */ -267, -267, -267, -267, -267, -267, -267, -267, -267, -267, |
| 161142 | | - /* 60 */ -267, -267, -267, -267, -267, -267, -267, -267, -267, -267, |
| 161143 | | - /* 70 */ -267, -267, -267, -267, -267, -267, -267, -267, 811, 917, |
| 161144 | | - /* 80 */ 936, 938, 983, 1014, 1041, 1060, 1080, 1098, 1101, 1118, |
| 161145 | | - /* 90 */ 1126, 1136, 1146, 1158, 1167, 1194, 1196, 1198, 1206, 1213, |
| 161146 | | - /* 100 */ 1215, 1232, 1234, 1242, 1245, 1250, 1252, 1259, 1262, 1287, |
| 161147 | | - /* 110 */ 1289, 1299, 1302, 1304, 1308, 1314, 1321, 1329, 1334, 1336, |
| 161148 | | - /* 120 */ 1346, 1366, 1380, 1382, 1385, 1410, 1413, -267, -267, -267, |
| 161149 | | - /* 130 */ -267, -267, -267, -267, -267, 446, -267, 451, -24, 121, |
| 161150 | | - /* 140 */ 560, 518, 232, 609, 330, -181, -111, 654, 557, 671, |
| 161151 | | - /* 150 */ 557, 671, 882, -30, 93, -267, -267, -267, -267, 155, |
| 161152 | | - /* 160 */ 155, 155, 181, 242, 305, 339, 561, -218, 453, 227, |
| 161153 | | - /* 170 */ 158, 661, 661, -171, 114, 327, 653, -166, 275, 605, |
| 161154 | | - /* 180 */ 615, 337, 833, 665, 939, 957, 825, 958, 985, 501, |
| 161155 | | - /* 190 */ 986, 378, 1068, 384, 643, 393, 741, 660, 888, 762, |
| 161156 | | - /* 200 */ 822, 229, 988, 926, 504, 1025, 1027, 1034, 1026, 1079, |
| 161157 | | - /* 210 */ -204, -174, -151, 18, 130, 198, 226, 376, 391, 442, |
| 161158 | | - /* 220 */ 457, 493, 607, 715, 779, 782, 840, 865, 1072, 1099, |
| 161159 | | - /* 230 */ 1114, 1085, 1166, 1216, 1251, 1263, 1306, 1309, 1343, 1351, |
| 161160 | | - /* 240 */ 1362, 1368, 1399, 1407, 1227, 1239, 1396, 1438, 1445, 1446, |
| 161161 | | - /* 250 */ 1383, 1449, 1451, 1452, 1391, 1330, 1456, 1457, 1416, 1458, |
| 161162 | | - /* 260 */ 226, 1462, 1464, 1465, 1467, 1469, 1470, 1373, 1377, 1412, |
| 161163 | | - /* 270 */ 1401, 1418, 1419, 1423, 1383, 1412, 1412, 1422, 1453, 1475, |
| 161164 | | - /* 280 */ 1371, 1400, 1403, 1427, 1420, 1414, 1421, 1390, 1444, 1429, |
| 161165 | | - /* 290 */ 1431, 1466, 1435, 1474, 1398, 1478, 1480, 1482, 1491, 1492, |
| 161166 | | - /* 300 */ 1495, 1459, 1471, 1477, 1437, 1483, 1484, 1519, 1433, 1434, |
| 161167 | | - /* 310 */ 1533, 1534, 1443, 1455, 1538, 1476, 1485, 1486, 1527, 1525, |
| 161168 | | - /* 320 */ 1528, 1529, 1530, 1563, 1569, 1524, 1500, 1502, 1532, 1505, |
| 161169 | | - /* 330 */ 1542, 1536, 1545, 1540, 1580, 1586, 1498, 1507, 1595, 1592, |
| 161170 | | - /* 340 */ 1578, 1600, 1602, 1603, 1605, 1581, 1590, 1596, 1597, 1579, |
| 161171 | | - /* 350 */ 1593, 1599, 1604, 1598, 1601, 1606, 1607, 1609, 1610, 1501, |
| 161172 | | - /* 360 */ 1515, 1553, 1555, 1615, 1582, 1584, 1613, 1612, 1614, 1616, |
| 161173 | | - /* 370 */ 1619, 1617, 1641, 1531, 1535, 1618, 1621, 1631, 1622, 1573, |
| 161174 | | - /* 380 */ 1651, 1575, 1632, 1636, 1623, 1639, 1656, 1666, 1667, 1671, |
| 161175 | | - /* 390 */ 1672, 1673, 1564, 1565, 1566, 1662, 1674, 1675, 1677, 1678, |
| 161176 | | - /* 400 */ 1682, 1670, 1679, 1680, 1681, 1683, 1686, |
| 161365 | + /* 0 */ -125, 733, 789, 241, 293, -123, -193, -191, -183, -187, |
| 161366 | + /* 10 */ -180, 83, 133, -207, -198, -267, -175, -6, 166, 313, |
| 161367 | + /* 20 */ 487, 396, 489, 598, 615, 685, 687, 79, 781, 857, |
| 161368 | + /* 30 */ 490, 616, 240, 334, -188, 796, 841, 843, 1003, 1005, |
| 161369 | + /* 40 */ 1007, -260, -260, -260, -260, -260, -260, -260, -260, -260, |
| 161370 | + /* 50 */ -260, -260, -260, -260, -260, -260, -260, -260, -260, -260, |
| 161371 | + /* 60 */ -260, -260, -260, -260, -260, -260, -260, -260, -260, -260, |
| 161372 | + /* 70 */ -260, -260, -260, -260, -260, -260, -260, -260, 158, 203, |
| 161373 | + /* 80 */ 391, 576, 724, 726, 886, 1021, 1035, 1063, 1081, 1083, |
| 161374 | + /* 90 */ 1097, 1099, 1117, 1152, 1155, 1158, 1163, 1165, 1167, 1169, |
| 161375 | + /* 100 */ 1172, 1180, 1183, 1198, 1200, 1205, 1215, 1225, 1227, 1236, |
| 161376 | + /* 110 */ 1252, 1264, 1299, 1303, 1306, 1309, 1312, 1315, 1325, 1328, |
| 161377 | + /* 120 */ 1337, 1340, 1343, 1371, 1373, 1384, 1386, 1411, -260, -260, |
| 161378 | + /* 130 */ -260, -260, -260, -260, -260, -260, -260, -53, 138, 302, |
| 161379 | + /* 140 */ -158, 357, 223, -222, 411, 458, -92, 556, 669, 581, |
| 161380 | + /* 150 */ 632, 581, -260, 632, 758, 778, 920, -260, -260, -260, |
| 161381 | + /* 160 */ -260, 161, 161, 161, 307, 234, 392, 526, 790, 195, |
| 161382 | + /* 170 */ 359, -174, -173, 362, 362, -189, 16, 560, 567, 261, |
| 161383 | + /* 180 */ 689, 802, 853, -122, -166, 408, 335, 617, 690, 837, |
| 161384 | + /* 190 */ 1001, 746, 1061, 515, 1082, 994, 1034, -135, 1000, 1048, |
| 161385 | + /* 200 */ 1137, 877, 897, 186, 627, 1031, 1133, 1148, 1159, 1194, |
| 161386 | + /* 210 */ 1199, 1195, -194, -142, 18, -152, 68, 201, 253, 269, |
| 161387 | + /* 220 */ 294, 354, 521, 528, 676, 680, 736, 743, 850, 907, |
| 161388 | + /* 230 */ 1041, 1047, 1060, 727, 1139, 1147, 1201, 1237, 1278, 1359, |
| 161389 | + /* 240 */ 1393, 1400, 1413, 1429, 1433, 1437, 1126, 1410, 1430, 1444, |
| 161390 | + /* 250 */ 1480, 1483, 1405, 1486, 1490, 1492, 1420, 1372, 1496, 1498, |
| 161391 | + /* 260 */ 1441, 1499, 253, 1500, 1503, 1504, 1506, 1507, 1508, 1398, |
| 161392 | + /* 270 */ 1415, 1453, 1448, 1449, 1450, 1452, 1405, 1453, 1453, 1465, |
| 161393 | + /* 280 */ 1495, 1519, 1414, 1443, 1445, 1468, 1456, 1455, 1457, 1424, |
| 161394 | + /* 290 */ 1473, 1454, 1459, 1474, 1460, 1479, 1434, 1512, 1494, 1509, |
| 161395 | + /* 300 */ 1517, 1518, 1525, 1469, 1489, 1501, 1467, 1510, 1497, 1543, |
| 161396 | + /* 310 */ 1451, 1462, 1557, 1558, 1471, 1472, 1561, 1487, 1505, 1524, |
| 161397 | + /* 320 */ 1538, 1537, 1545, 1548, 1556, 1575, 1596, 1552, 1529, 1530, |
| 161398 | + /* 330 */ 1559, 1533, 1572, 1562, 1573, 1563, 1604, 1615, 1522, 1532, |
| 161399 | + /* 340 */ 1622, 1624, 1605, 1625, 1628, 1629, 1631, 1607, 1616, 1619, |
| 161400 | + /* 350 */ 1620, 1606, 1621, 1623, 1630, 1626, 1632, 1636, 1633, 1637, |
| 161401 | + /* 360 */ 1638, 1531, 1541, 1567, 1571, 1640, 1597, 1599, 1601, 1603, |
| 161402 | + /* 370 */ 1608, 1610, 1611, 1627, 1664, 1549, 1550, 1609, 1634, 1639, |
| 161403 | + /* 380 */ 1641, 1602, 1676, 1642, 1646, 1644, 1650, 1654, 1683, 1694, |
| 161404 | + /* 390 */ 1707, 1711, 1712, 1714, 1643, 1647, 1652, 1698, 1695, 1696, |
| 161405 | + /* 400 */ 1697, 1699, 1700, 1689, 1691, 1701, 1702, 1704, 1715, |
| 161177 | 161406 | }; |
| 161178 | 161407 | static const YYACTIONTYPE yy_default[] = { |
| 161179 | | - /* 0 */ 1633, 1633, 1633, 1462, 1230, 1341, 1230, 1230, 1230, 1462, |
| 161180 | | - /* 10 */ 1462, 1462, 1230, 1371, 1371, 1515, 1263, 1230, 1230, 1230, |
| 161181 | | - /* 20 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1461, 1230, 1230, |
| 161182 | | - /* 30 */ 1230, 1230, 1550, 1550, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161183 | | - /* 40 */ 1230, 1230, 1380, 1230, 1387, 1230, 1230, 1230, 1230, 1230, |
| 161184 | | - /* 50 */ 1463, 1464, 1230, 1230, 1230, 1514, 1516, 1479, 1394, 1393, |
| 161185 | | - /* 60 */ 1392, 1391, 1497, 1358, 1385, 1378, 1382, 1457, 1458, 1456, |
| 161186 | | - /* 70 */ 1460, 1464, 1463, 1230, 1381, 1428, 1442, 1427, 1230, 1230, |
| 161187 | | - /* 80 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161188 | | - /* 90 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161189 | | - /* 100 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161190 | | - /* 110 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161191 | | - /* 120 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1436, 1441, 1447, |
| 161192 | | - /* 130 */ 1440, 1437, 1430, 1429, 1431, 1230, 1432, 1230, 1254, 1230, |
| 161193 | | - /* 140 */ 1230, 1251, 1305, 1230, 1230, 1230, 1230, 1230, 1534, 1533, |
| 161194 | | - /* 150 */ 1230, 1230, 1263, 1422, 1421, 1433, 1434, 1444, 1443, 1522, |
| 161195 | | - /* 160 */ 1586, 1585, 1480, 1230, 1230, 1230, 1230, 1230, 1230, 1550, |
| 161196 | | - /* 170 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161197 | | - /* 180 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161198 | | - /* 190 */ 1230, 1230, 1230, 1550, 1550, 1230, 1263, 1550, 1550, 1259, |
| 161199 | | - /* 200 */ 1259, 1365, 1230, 1529, 1332, 1332, 1332, 1332, 1341, 1332, |
| 161200 | | - /* 210 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161201 | | - /* 220 */ 1230, 1230, 1230, 1230, 1230, 1519, 1517, 1230, 1230, 1230, |
| 161202 | | - /* 230 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161203 | | - /* 240 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161204 | | - /* 250 */ 1230, 1230, 1230, 1230, 1337, 1230, 1230, 1230, 1230, 1230, |
| 161205 | | - /* 260 */ 1230, 1230, 1230, 1230, 1230, 1230, 1579, 1230, 1492, 1319, |
| 161206 | | - /* 270 */ 1337, 1337, 1337, 1337, 1339, 1320, 1318, 1331, 1264, 1237, |
| 161207 | | - /* 280 */ 1625, 1397, 1386, 1338, 1360, 1386, 1360, 1622, 1384, 1397, |
| 161208 | | - /* 290 */ 1397, 1384, 1397, 1338, 1622, 1280, 1602, 1275, 1371, 1371, |
| 161209 | | - /* 300 */ 1371, 1360, 1365, 1365, 1459, 1338, 1331, 1230, 1625, 1625, |
| 161210 | | - /* 310 */ 1346, 1346, 1624, 1624, 1346, 1480, 1609, 1406, 1308, 1314, |
| 161211 | | - /* 320 */ 1314, 1314, 1314, 1346, 1248, 1384, 1609, 1609, 1384, 1406, |
| 161212 | | - /* 330 */ 1308, 1384, 1308, 1384, 1346, 1248, 1496, 1619, 1346, 1248, |
| 161213 | | - /* 340 */ 1470, 1346, 1248, 1346, 1248, 1470, 1306, 1306, 1306, 1295, |
| 161214 | | - /* 350 */ 1230, 1230, 1470, 1306, 1280, 1306, 1295, 1306, 1306, 1568, |
| 161215 | | - /* 360 */ 1230, 1474, 1474, 1470, 1364, 1359, 1364, 1359, 1364, 1359, |
| 161216 | | - /* 370 */ 1364, 1359, 1346, 1560, 1560, 1374, 1374, 1379, 1365, 1465, |
| 161217 | | - /* 380 */ 1346, 1230, 1379, 1377, 1375, 1384, 1298, 1582, 1582, 1578, |
| 161218 | | - /* 390 */ 1578, 1578, 1630, 1630, 1529, 1595, 1263, 1263, 1263, 1263, |
| 161219 | | - /* 400 */ 1595, 1282, 1282, 1264, 1264, 1263, 1595, 1230, 1230, 1230, |
| 161220 | | - /* 410 */ 1230, 1230, 1230, 1590, 1230, 1524, 1481, 1350, 1230, 1230, |
| 161221 | | - /* 420 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161222 | | - /* 430 */ 1230, 1230, 1535, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161223 | | - /* 440 */ 1230, 1230, 1230, 1411, 1230, 1233, 1526, 1230, 1230, 1230, |
| 161224 | | - /* 450 */ 1230, 1230, 1230, 1230, 1230, 1388, 1389, 1351, 1230, 1230, |
| 161225 | | - /* 460 */ 1230, 1230, 1230, 1230, 1230, 1403, 1230, 1230, 1230, 1398, |
| 161226 | | - /* 470 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1621, 1230, |
| 161227 | | - /* 480 */ 1230, 1230, 1230, 1230, 1230, 1495, 1494, 1230, 1230, 1348, |
| 161228 | | - /* 490 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161229 | | - /* 500 */ 1230, 1230, 1230, 1278, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161230 | | - /* 510 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161231 | | - /* 520 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1376, 1230, 1230, |
| 161232 | | - /* 530 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161233 | | - /* 540 */ 1230, 1230, 1565, 1366, 1230, 1230, 1612, 1230, 1230, 1230, |
| 161234 | | - /* 550 */ 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, |
| 161235 | | - /* 560 */ 1230, 1606, 1322, 1413, 1230, 1412, 1416, 1252, 1230, 1242, |
| 161236 | | - /* 570 */ 1230, 1230, |
| 161408 | + /* 0 */ 1637, 1637, 1637, 1466, 1233, 1344, 1233, 1233, 1233, 1466, |
| 161409 | + /* 10 */ 1466, 1466, 1233, 1374, 1374, 1519, 1266, 1233, 1233, 1233, |
| 161410 | + /* 20 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1465, 1233, 1233, |
| 161411 | + /* 30 */ 1233, 1233, 1554, 1554, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161412 | + /* 40 */ 1233, 1233, 1383, 1233, 1390, 1233, 1233, 1233, 1233, 1233, |
| 161413 | + /* 50 */ 1467, 1468, 1233, 1233, 1233, 1518, 1520, 1483, 1397, 1396, |
| 161414 | + /* 60 */ 1395, 1394, 1501, 1361, 1388, 1381, 1385, 1461, 1462, 1460, |
| 161415 | + /* 70 */ 1464, 1468, 1467, 1233, 1384, 1431, 1445, 1430, 1233, 1233, |
| 161416 | + /* 80 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161417 | + /* 90 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161418 | + /* 100 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161419 | + /* 110 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161420 | + /* 120 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1439, 1444, |
| 161421 | + /* 130 */ 1451, 1443, 1440, 1433, 1432, 1434, 1435, 1233, 1233, 1257, |
| 161422 | + /* 140 */ 1233, 1233, 1254, 1308, 1233, 1233, 1233, 1233, 1233, 1538, |
| 161423 | + /* 150 */ 1537, 1233, 1436, 1233, 1266, 1425, 1424, 1448, 1437, 1447, |
| 161424 | + /* 160 */ 1446, 1526, 1590, 1589, 1484, 1233, 1233, 1233, 1233, 1233, |
| 161425 | + /* 170 */ 1233, 1554, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161426 | + /* 180 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161427 | + /* 190 */ 1233, 1233, 1233, 1233, 1233, 1554, 1554, 1233, 1266, 1554, |
| 161428 | + /* 200 */ 1554, 1262, 1262, 1368, 1233, 1533, 1335, 1335, 1335, 1335, |
| 161429 | + /* 210 */ 1344, 1335, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161430 | + /* 220 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1523, 1521, 1233, |
| 161431 | + /* 230 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161432 | + /* 240 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161433 | + /* 250 */ 1233, 1233, 1233, 1233, 1233, 1233, 1340, 1233, 1233, 1233, |
| 161434 | + /* 260 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1583, 1233, |
| 161435 | + /* 270 */ 1496, 1322, 1340, 1340, 1340, 1340, 1342, 1323, 1321, 1334, |
| 161436 | + /* 280 */ 1267, 1240, 1629, 1400, 1389, 1341, 1363, 1389, 1363, 1626, |
| 161437 | + /* 290 */ 1387, 1400, 1400, 1387, 1400, 1341, 1626, 1283, 1606, 1278, |
| 161438 | + /* 300 */ 1374, 1374, 1374, 1363, 1368, 1368, 1463, 1341, 1334, 1233, |
| 161439 | + /* 310 */ 1629, 1629, 1349, 1349, 1628, 1628, 1349, 1484, 1613, 1409, |
| 161440 | + /* 320 */ 1311, 1317, 1317, 1317, 1317, 1349, 1251, 1387, 1613, 1613, |
| 161441 | + /* 330 */ 1387, 1409, 1311, 1387, 1311, 1387, 1349, 1251, 1500, 1623, |
| 161442 | + /* 340 */ 1349, 1251, 1474, 1349, 1251, 1349, 1251, 1474, 1309, 1309, |
| 161443 | + /* 350 */ 1309, 1298, 1233, 1233, 1474, 1309, 1283, 1309, 1298, 1309, |
| 161444 | + /* 360 */ 1309, 1572, 1233, 1478, 1478, 1474, 1367, 1362, 1367, 1362, |
| 161445 | + /* 370 */ 1367, 1362, 1367, 1362, 1349, 1564, 1564, 1377, 1377, 1382, |
| 161446 | + /* 380 */ 1368, 1469, 1349, 1233, 1382, 1380, 1378, 1387, 1301, 1586, |
| 161447 | + /* 390 */ 1586, 1582, 1582, 1582, 1634, 1634, 1533, 1599, 1266, 1266, |
| 161448 | + /* 400 */ 1266, 1266, 1599, 1285, 1285, 1267, 1267, 1266, 1599, 1233, |
| 161449 | + /* 410 */ 1233, 1233, 1233, 1233, 1233, 1594, 1233, 1528, 1485, 1353, |
| 161450 | + /* 420 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161451 | + /* 430 */ 1233, 1233, 1233, 1233, 1539, 1233, 1233, 1233, 1233, 1233, |
| 161452 | + /* 440 */ 1233, 1233, 1233, 1233, 1233, 1414, 1233, 1236, 1530, 1233, |
| 161453 | + /* 450 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1391, 1392, 1354, |
| 161454 | + /* 460 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1406, 1233, 1233, |
| 161455 | + /* 470 */ 1233, 1401, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161456 | + /* 480 */ 1625, 1233, 1233, 1233, 1233, 1233, 1233, 1499, 1498, 1233, |
| 161457 | + /* 490 */ 1233, 1351, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161458 | + /* 500 */ 1233, 1233, 1233, 1233, 1233, 1281, 1233, 1233, 1233, 1233, |
| 161459 | + /* 510 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161460 | + /* 520 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1379, |
| 161461 | + /* 530 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161462 | + /* 540 */ 1233, 1233, 1233, 1233, 1569, 1369, 1233, 1233, 1616, 1233, |
| 161463 | + /* 550 */ 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, 1233, |
| 161464 | + /* 560 */ 1233, 1233, 1233, 1610, 1325, 1416, 1233, 1415, 1419, 1255, |
| 161465 | + /* 570 */ 1233, 1245, 1233, 1233, |
| 161237 | 161466 | }; |
| 161238 | 161467 | /********** End of lemon-generated parsing tables *****************************/ |
| 161239 | 161468 | |
| 161240 | 161469 | /* The next table maps tokens (terminal symbols) into fallback tokens. |
| 161241 | 161470 | ** If a construct like the following: |
| | @@ -161296,14 +161525,14 @@ |
| 161296 | 161525 | 59, /* DETACH => ID */ |
| 161297 | 161526 | 59, /* EACH => ID */ |
| 161298 | 161527 | 59, /* FAIL => ID */ |
| 161299 | 161528 | 0, /* OR => nothing */ |
| 161300 | 161529 | 0, /* AND => nothing */ |
| 161530 | + 0, /* IS => nothing */ |
| 161301 | 161531 | 59, /* MATCH => ID */ |
| 161302 | 161532 | 59, /* LIKE_KW => ID */ |
| 161303 | 161533 | 0, /* BETWEEN => nothing */ |
| 161304 | | - 0, /* IS => nothing */ |
| 161305 | 161534 | 0, /* IN => nothing */ |
| 161306 | 161535 | 0, /* ISNULL => nothing */ |
| 161307 | 161536 | 0, /* NOTNULL => nothing */ |
| 161308 | 161537 | 0, /* NE => nothing */ |
| 161309 | 161538 | 0, /* EQ => nothing */ |
| | @@ -161363,10 +161592,11 @@ |
| 161363 | 161592 | 0, /* MINUS => nothing */ |
| 161364 | 161593 | 0, /* STAR => nothing */ |
| 161365 | 161594 | 0, /* SLASH => nothing */ |
| 161366 | 161595 | 0, /* REM => nothing */ |
| 161367 | 161596 | 0, /* CONCAT => nothing */ |
| 161597 | + 0, /* PTR => nothing */ |
| 161368 | 161598 | 0, /* COLLATE => nothing */ |
| 161369 | 161599 | 0, /* BITNOT => nothing */ |
| 161370 | 161600 | 0, /* ON => nothing */ |
| 161371 | 161601 | 0, /* INDEXED => nothing */ |
| 161372 | 161602 | 0, /* STRING => nothing */ |
| | @@ -161568,14 +161798,14 @@ |
| 161568 | 161798 | /* 40 */ "DETACH", |
| 161569 | 161799 | /* 41 */ "EACH", |
| 161570 | 161800 | /* 42 */ "FAIL", |
| 161571 | 161801 | /* 43 */ "OR", |
| 161572 | 161802 | /* 44 */ "AND", |
| 161573 | | - /* 45 */ "MATCH", |
| 161574 | | - /* 46 */ "LIKE_KW", |
| 161575 | | - /* 47 */ "BETWEEN", |
| 161576 | | - /* 48 */ "IS", |
| 161803 | + /* 45 */ "IS", |
| 161804 | + /* 46 */ "MATCH", |
| 161805 | + /* 47 */ "LIKE_KW", |
| 161806 | + /* 48 */ "BETWEEN", |
| 161577 | 161807 | /* 49 */ "IN", |
| 161578 | 161808 | /* 50 */ "ISNULL", |
| 161579 | 161809 | /* 51 */ "NOTNULL", |
| 161580 | 161810 | /* 52 */ "NE", |
| 161581 | 161811 | /* 53 */ "EQ", |
| | @@ -161635,216 +161865,217 @@ |
| 161635 | 161865 | /* 107 */ "MINUS", |
| 161636 | 161866 | /* 108 */ "STAR", |
| 161637 | 161867 | /* 109 */ "SLASH", |
| 161638 | 161868 | /* 110 */ "REM", |
| 161639 | 161869 | /* 111 */ "CONCAT", |
| 161640 | | - /* 112 */ "COLLATE", |
| 161641 | | - /* 113 */ "BITNOT", |
| 161642 | | - /* 114 */ "ON", |
| 161643 | | - /* 115 */ "INDEXED", |
| 161644 | | - /* 116 */ "STRING", |
| 161645 | | - /* 117 */ "JOIN_KW", |
| 161646 | | - /* 118 */ "CONSTRAINT", |
| 161647 | | - /* 119 */ "DEFAULT", |
| 161648 | | - /* 120 */ "NULL", |
| 161649 | | - /* 121 */ "PRIMARY", |
| 161650 | | - /* 122 */ "UNIQUE", |
| 161651 | | - /* 123 */ "CHECK", |
| 161652 | | - /* 124 */ "REFERENCES", |
| 161653 | | - /* 125 */ "AUTOINCR", |
| 161654 | | - /* 126 */ "INSERT", |
| 161655 | | - /* 127 */ "DELETE", |
| 161656 | | - /* 128 */ "UPDATE", |
| 161657 | | - /* 129 */ "SET", |
| 161658 | | - /* 130 */ "DEFERRABLE", |
| 161659 | | - /* 131 */ "FOREIGN", |
| 161660 | | - /* 132 */ "DROP", |
| 161661 | | - /* 133 */ "UNION", |
| 161662 | | - /* 134 */ "ALL", |
| 161663 | | - /* 135 */ "EXCEPT", |
| 161664 | | - /* 136 */ "INTERSECT", |
| 161665 | | - /* 137 */ "SELECT", |
| 161666 | | - /* 138 */ "VALUES", |
| 161667 | | - /* 139 */ "DISTINCT", |
| 161668 | | - /* 140 */ "DOT", |
| 161669 | | - /* 141 */ "FROM", |
| 161670 | | - /* 142 */ "JOIN", |
| 161671 | | - /* 143 */ "USING", |
| 161672 | | - /* 144 */ "ORDER", |
| 161673 | | - /* 145 */ "GROUP", |
| 161674 | | - /* 146 */ "HAVING", |
| 161675 | | - /* 147 */ "LIMIT", |
| 161676 | | - /* 148 */ "WHERE", |
| 161677 | | - /* 149 */ "RETURNING", |
| 161678 | | - /* 150 */ "INTO", |
| 161679 | | - /* 151 */ "NOTHING", |
| 161680 | | - /* 152 */ "FLOAT", |
| 161681 | | - /* 153 */ "BLOB", |
| 161682 | | - /* 154 */ "INTEGER", |
| 161683 | | - /* 155 */ "VARIABLE", |
| 161684 | | - /* 156 */ "CASE", |
| 161685 | | - /* 157 */ "WHEN", |
| 161686 | | - /* 158 */ "THEN", |
| 161687 | | - /* 159 */ "ELSE", |
| 161688 | | - /* 160 */ "INDEX", |
| 161689 | | - /* 161 */ "ALTER", |
| 161690 | | - /* 162 */ "ADD", |
| 161691 | | - /* 163 */ "WINDOW", |
| 161692 | | - /* 164 */ "OVER", |
| 161693 | | - /* 165 */ "FILTER", |
| 161694 | | - /* 166 */ "COLUMN", |
| 161695 | | - /* 167 */ "AGG_FUNCTION", |
| 161696 | | - /* 168 */ "AGG_COLUMN", |
| 161697 | | - /* 169 */ "TRUEFALSE", |
| 161698 | | - /* 170 */ "ISNOT", |
| 161699 | | - /* 171 */ "FUNCTION", |
| 161700 | | - /* 172 */ "UMINUS", |
| 161701 | | - /* 173 */ "UPLUS", |
| 161702 | | - /* 174 */ "TRUTH", |
| 161703 | | - /* 175 */ "REGISTER", |
| 161704 | | - /* 176 */ "VECTOR", |
| 161705 | | - /* 177 */ "SELECT_COLUMN", |
| 161706 | | - /* 178 */ "IF_NULL_ROW", |
| 161707 | | - /* 179 */ "ASTERISK", |
| 161708 | | - /* 180 */ "SPAN", |
| 161709 | | - /* 181 */ "ERROR", |
| 161710 | | - /* 182 */ "SPACE", |
| 161711 | | - /* 183 */ "ILLEGAL", |
| 161712 | | - /* 184 */ "input", |
| 161713 | | - /* 185 */ "cmdlist", |
| 161714 | | - /* 186 */ "ecmd", |
| 161715 | | - /* 187 */ "cmdx", |
| 161716 | | - /* 188 */ "explain", |
| 161717 | | - /* 189 */ "cmd", |
| 161718 | | - /* 190 */ "transtype", |
| 161719 | | - /* 191 */ "trans_opt", |
| 161720 | | - /* 192 */ "nm", |
| 161721 | | - /* 193 */ "savepoint_opt", |
| 161722 | | - /* 194 */ "create_table", |
| 161723 | | - /* 195 */ "create_table_args", |
| 161724 | | - /* 196 */ "createkw", |
| 161725 | | - /* 197 */ "temp", |
| 161726 | | - /* 198 */ "ifnotexists", |
| 161727 | | - /* 199 */ "dbnm", |
| 161728 | | - /* 200 */ "columnlist", |
| 161729 | | - /* 201 */ "conslist_opt", |
| 161730 | | - /* 202 */ "table_option_set", |
| 161731 | | - /* 203 */ "select", |
| 161732 | | - /* 204 */ "table_option", |
| 161733 | | - /* 205 */ "columnname", |
| 161734 | | - /* 206 */ "carglist", |
| 161735 | | - /* 207 */ "typetoken", |
| 161736 | | - /* 208 */ "typename", |
| 161737 | | - /* 209 */ "signed", |
| 161738 | | - /* 210 */ "plus_num", |
| 161739 | | - /* 211 */ "minus_num", |
| 161740 | | - /* 212 */ "scanpt", |
| 161741 | | - /* 213 */ "scantok", |
| 161742 | | - /* 214 */ "ccons", |
| 161743 | | - /* 215 */ "term", |
| 161744 | | - /* 216 */ "expr", |
| 161745 | | - /* 217 */ "onconf", |
| 161746 | | - /* 218 */ "sortorder", |
| 161747 | | - /* 219 */ "autoinc", |
| 161748 | | - /* 220 */ "eidlist_opt", |
| 161749 | | - /* 221 */ "refargs", |
| 161750 | | - /* 222 */ "defer_subclause", |
| 161751 | | - /* 223 */ "generated", |
| 161752 | | - /* 224 */ "refarg", |
| 161753 | | - /* 225 */ "refact", |
| 161754 | | - /* 226 */ "init_deferred_pred_opt", |
| 161755 | | - /* 227 */ "conslist", |
| 161756 | | - /* 228 */ "tconscomma", |
| 161757 | | - /* 229 */ "tcons", |
| 161758 | | - /* 230 */ "sortlist", |
| 161759 | | - /* 231 */ "eidlist", |
| 161760 | | - /* 232 */ "defer_subclause_opt", |
| 161761 | | - /* 233 */ "orconf", |
| 161762 | | - /* 234 */ "resolvetype", |
| 161763 | | - /* 235 */ "raisetype", |
| 161764 | | - /* 236 */ "ifexists", |
| 161765 | | - /* 237 */ "fullname", |
| 161766 | | - /* 238 */ "selectnowith", |
| 161767 | | - /* 239 */ "oneselect", |
| 161768 | | - /* 240 */ "wqlist", |
| 161769 | | - /* 241 */ "multiselect_op", |
| 161770 | | - /* 242 */ "distinct", |
| 161771 | | - /* 243 */ "selcollist", |
| 161772 | | - /* 244 */ "from", |
| 161773 | | - /* 245 */ "where_opt", |
| 161774 | | - /* 246 */ "groupby_opt", |
| 161775 | | - /* 247 */ "having_opt", |
| 161776 | | - /* 248 */ "orderby_opt", |
| 161777 | | - /* 249 */ "limit_opt", |
| 161778 | | - /* 250 */ "window_clause", |
| 161779 | | - /* 251 */ "values", |
| 161780 | | - /* 252 */ "nexprlist", |
| 161781 | | - /* 253 */ "sclp", |
| 161782 | | - /* 254 */ "as", |
| 161783 | | - /* 255 */ "seltablist", |
| 161784 | | - /* 256 */ "stl_prefix", |
| 161785 | | - /* 257 */ "joinop", |
| 161786 | | - /* 258 */ "indexed_opt", |
| 161787 | | - /* 259 */ "on_opt", |
| 161788 | | - /* 260 */ "using_opt", |
| 161789 | | - /* 261 */ "exprlist", |
| 161790 | | - /* 262 */ "xfullname", |
| 161791 | | - /* 263 */ "idlist", |
| 161792 | | - /* 264 */ "nulls", |
| 161793 | | - /* 265 */ "with", |
| 161794 | | - /* 266 */ "where_opt_ret", |
| 161795 | | - /* 267 */ "setlist", |
| 161796 | | - /* 268 */ "insert_cmd", |
| 161797 | | - /* 269 */ "idlist_opt", |
| 161798 | | - /* 270 */ "upsert", |
| 161799 | | - /* 271 */ "returning", |
| 161800 | | - /* 272 */ "filter_over", |
| 161801 | | - /* 273 */ "likeop", |
| 161802 | | - /* 274 */ "between_op", |
| 161803 | | - /* 275 */ "in_op", |
| 161804 | | - /* 276 */ "paren_exprlist", |
| 161805 | | - /* 277 */ "case_operand", |
| 161806 | | - /* 278 */ "case_exprlist", |
| 161807 | | - /* 279 */ "case_else", |
| 161808 | | - /* 280 */ "uniqueflag", |
| 161809 | | - /* 281 */ "collate", |
| 161810 | | - /* 282 */ "vinto", |
| 161811 | | - /* 283 */ "nmnum", |
| 161812 | | - /* 284 */ "trigger_decl", |
| 161813 | | - /* 285 */ "trigger_cmd_list", |
| 161814 | | - /* 286 */ "trigger_time", |
| 161815 | | - /* 287 */ "trigger_event", |
| 161816 | | - /* 288 */ "foreach_clause", |
| 161817 | | - /* 289 */ "when_clause", |
| 161818 | | - /* 290 */ "trigger_cmd", |
| 161819 | | - /* 291 */ "trnm", |
| 161820 | | - /* 292 */ "tridxby", |
| 161821 | | - /* 293 */ "database_kw_opt", |
| 161822 | | - /* 294 */ "key_opt", |
| 161823 | | - /* 295 */ "add_column_fullname", |
| 161824 | | - /* 296 */ "kwcolumn_opt", |
| 161825 | | - /* 297 */ "create_vtab", |
| 161826 | | - /* 298 */ "vtabarglist", |
| 161827 | | - /* 299 */ "vtabarg", |
| 161828 | | - /* 300 */ "vtabargtoken", |
| 161829 | | - /* 301 */ "lp", |
| 161830 | | - /* 302 */ "anylist", |
| 161831 | | - /* 303 */ "wqitem", |
| 161832 | | - /* 304 */ "wqas", |
| 161833 | | - /* 305 */ "windowdefn_list", |
| 161834 | | - /* 306 */ "windowdefn", |
| 161835 | | - /* 307 */ "window", |
| 161836 | | - /* 308 */ "frame_opt", |
| 161837 | | - /* 309 */ "part_opt", |
| 161838 | | - /* 310 */ "filter_clause", |
| 161839 | | - /* 311 */ "over_clause", |
| 161840 | | - /* 312 */ "range_or_rows", |
| 161841 | | - /* 313 */ "frame_bound", |
| 161842 | | - /* 314 */ "frame_bound_s", |
| 161843 | | - /* 315 */ "frame_bound_e", |
| 161844 | | - /* 316 */ "frame_exclude_opt", |
| 161845 | | - /* 317 */ "frame_exclude", |
| 161870 | + /* 112 */ "PTR", |
| 161871 | + /* 113 */ "COLLATE", |
| 161872 | + /* 114 */ "BITNOT", |
| 161873 | + /* 115 */ "ON", |
| 161874 | + /* 116 */ "INDEXED", |
| 161875 | + /* 117 */ "STRING", |
| 161876 | + /* 118 */ "JOIN_KW", |
| 161877 | + /* 119 */ "CONSTRAINT", |
| 161878 | + /* 120 */ "DEFAULT", |
| 161879 | + /* 121 */ "NULL", |
| 161880 | + /* 122 */ "PRIMARY", |
| 161881 | + /* 123 */ "UNIQUE", |
| 161882 | + /* 124 */ "CHECK", |
| 161883 | + /* 125 */ "REFERENCES", |
| 161884 | + /* 126 */ "AUTOINCR", |
| 161885 | + /* 127 */ "INSERT", |
| 161886 | + /* 128 */ "DELETE", |
| 161887 | + /* 129 */ "UPDATE", |
| 161888 | + /* 130 */ "SET", |
| 161889 | + /* 131 */ "DEFERRABLE", |
| 161890 | + /* 132 */ "FOREIGN", |
| 161891 | + /* 133 */ "DROP", |
| 161892 | + /* 134 */ "UNION", |
| 161893 | + /* 135 */ "ALL", |
| 161894 | + /* 136 */ "EXCEPT", |
| 161895 | + /* 137 */ "INTERSECT", |
| 161896 | + /* 138 */ "SELECT", |
| 161897 | + /* 139 */ "VALUES", |
| 161898 | + /* 140 */ "DISTINCT", |
| 161899 | + /* 141 */ "DOT", |
| 161900 | + /* 142 */ "FROM", |
| 161901 | + /* 143 */ "JOIN", |
| 161902 | + /* 144 */ "USING", |
| 161903 | + /* 145 */ "ORDER", |
| 161904 | + /* 146 */ "GROUP", |
| 161905 | + /* 147 */ "HAVING", |
| 161906 | + /* 148 */ "LIMIT", |
| 161907 | + /* 149 */ "WHERE", |
| 161908 | + /* 150 */ "RETURNING", |
| 161909 | + /* 151 */ "INTO", |
| 161910 | + /* 152 */ "NOTHING", |
| 161911 | + /* 153 */ "FLOAT", |
| 161912 | + /* 154 */ "BLOB", |
| 161913 | + /* 155 */ "INTEGER", |
| 161914 | + /* 156 */ "VARIABLE", |
| 161915 | + /* 157 */ "CASE", |
| 161916 | + /* 158 */ "WHEN", |
| 161917 | + /* 159 */ "THEN", |
| 161918 | + /* 160 */ "ELSE", |
| 161919 | + /* 161 */ "INDEX", |
| 161920 | + /* 162 */ "ALTER", |
| 161921 | + /* 163 */ "ADD", |
| 161922 | + /* 164 */ "WINDOW", |
| 161923 | + /* 165 */ "OVER", |
| 161924 | + /* 166 */ "FILTER", |
| 161925 | + /* 167 */ "COLUMN", |
| 161926 | + /* 168 */ "AGG_FUNCTION", |
| 161927 | + /* 169 */ "AGG_COLUMN", |
| 161928 | + /* 170 */ "TRUEFALSE", |
| 161929 | + /* 171 */ "ISNOT", |
| 161930 | + /* 172 */ "FUNCTION", |
| 161931 | + /* 173 */ "UMINUS", |
| 161932 | + /* 174 */ "UPLUS", |
| 161933 | + /* 175 */ "TRUTH", |
| 161934 | + /* 176 */ "REGISTER", |
| 161935 | + /* 177 */ "VECTOR", |
| 161936 | + /* 178 */ "SELECT_COLUMN", |
| 161937 | + /* 179 */ "IF_NULL_ROW", |
| 161938 | + /* 180 */ "ASTERISK", |
| 161939 | + /* 181 */ "SPAN", |
| 161940 | + /* 182 */ "ERROR", |
| 161941 | + /* 183 */ "SPACE", |
| 161942 | + /* 184 */ "ILLEGAL", |
| 161943 | + /* 185 */ "input", |
| 161944 | + /* 186 */ "cmdlist", |
| 161945 | + /* 187 */ "ecmd", |
| 161946 | + /* 188 */ "cmdx", |
| 161947 | + /* 189 */ "explain", |
| 161948 | + /* 190 */ "cmd", |
| 161949 | + /* 191 */ "transtype", |
| 161950 | + /* 192 */ "trans_opt", |
| 161951 | + /* 193 */ "nm", |
| 161952 | + /* 194 */ "savepoint_opt", |
| 161953 | + /* 195 */ "create_table", |
| 161954 | + /* 196 */ "create_table_args", |
| 161955 | + /* 197 */ "createkw", |
| 161956 | + /* 198 */ "temp", |
| 161957 | + /* 199 */ "ifnotexists", |
| 161958 | + /* 200 */ "dbnm", |
| 161959 | + /* 201 */ "columnlist", |
| 161960 | + /* 202 */ "conslist_opt", |
| 161961 | + /* 203 */ "table_option_set", |
| 161962 | + /* 204 */ "select", |
| 161963 | + /* 205 */ "table_option", |
| 161964 | + /* 206 */ "columnname", |
| 161965 | + /* 207 */ "carglist", |
| 161966 | + /* 208 */ "typetoken", |
| 161967 | + /* 209 */ "typename", |
| 161968 | + /* 210 */ "signed", |
| 161969 | + /* 211 */ "plus_num", |
| 161970 | + /* 212 */ "minus_num", |
| 161971 | + /* 213 */ "scanpt", |
| 161972 | + /* 214 */ "scantok", |
| 161973 | + /* 215 */ "ccons", |
| 161974 | + /* 216 */ "term", |
| 161975 | + /* 217 */ "expr", |
| 161976 | + /* 218 */ "onconf", |
| 161977 | + /* 219 */ "sortorder", |
| 161978 | + /* 220 */ "autoinc", |
| 161979 | + /* 221 */ "eidlist_opt", |
| 161980 | + /* 222 */ "refargs", |
| 161981 | + /* 223 */ "defer_subclause", |
| 161982 | + /* 224 */ "generated", |
| 161983 | + /* 225 */ "refarg", |
| 161984 | + /* 226 */ "refact", |
| 161985 | + /* 227 */ "init_deferred_pred_opt", |
| 161986 | + /* 228 */ "conslist", |
| 161987 | + /* 229 */ "tconscomma", |
| 161988 | + /* 230 */ "tcons", |
| 161989 | + /* 231 */ "sortlist", |
| 161990 | + /* 232 */ "eidlist", |
| 161991 | + /* 233 */ "defer_subclause_opt", |
| 161992 | + /* 234 */ "orconf", |
| 161993 | + /* 235 */ "resolvetype", |
| 161994 | + /* 236 */ "raisetype", |
| 161995 | + /* 237 */ "ifexists", |
| 161996 | + /* 238 */ "fullname", |
| 161997 | + /* 239 */ "selectnowith", |
| 161998 | + /* 240 */ "oneselect", |
| 161999 | + /* 241 */ "wqlist", |
| 162000 | + /* 242 */ "multiselect_op", |
| 162001 | + /* 243 */ "distinct", |
| 162002 | + /* 244 */ "selcollist", |
| 162003 | + /* 245 */ "from", |
| 162004 | + /* 246 */ "where_opt", |
| 162005 | + /* 247 */ "groupby_opt", |
| 162006 | + /* 248 */ "having_opt", |
| 162007 | + /* 249 */ "orderby_opt", |
| 162008 | + /* 250 */ "limit_opt", |
| 162009 | + /* 251 */ "window_clause", |
| 162010 | + /* 252 */ "values", |
| 162011 | + /* 253 */ "nexprlist", |
| 162012 | + /* 254 */ "sclp", |
| 162013 | + /* 255 */ "as", |
| 162014 | + /* 256 */ "seltablist", |
| 162015 | + /* 257 */ "stl_prefix", |
| 162016 | + /* 258 */ "joinop", |
| 162017 | + /* 259 */ "indexed_opt", |
| 162018 | + /* 260 */ "on_opt", |
| 162019 | + /* 261 */ "using_opt", |
| 162020 | + /* 262 */ "exprlist", |
| 162021 | + /* 263 */ "xfullname", |
| 162022 | + /* 264 */ "idlist", |
| 162023 | + /* 265 */ "nulls", |
| 162024 | + /* 266 */ "with", |
| 162025 | + /* 267 */ "where_opt_ret", |
| 162026 | + /* 268 */ "setlist", |
| 162027 | + /* 269 */ "insert_cmd", |
| 162028 | + /* 270 */ "idlist_opt", |
| 162029 | + /* 271 */ "upsert", |
| 162030 | + /* 272 */ "returning", |
| 162031 | + /* 273 */ "filter_over", |
| 162032 | + /* 274 */ "likeop", |
| 162033 | + /* 275 */ "between_op", |
| 162034 | + /* 276 */ "in_op", |
| 162035 | + /* 277 */ "paren_exprlist", |
| 162036 | + /* 278 */ "case_operand", |
| 162037 | + /* 279 */ "case_exprlist", |
| 162038 | + /* 280 */ "case_else", |
| 162039 | + /* 281 */ "uniqueflag", |
| 162040 | + /* 282 */ "collate", |
| 162041 | + /* 283 */ "vinto", |
| 162042 | + /* 284 */ "nmnum", |
| 162043 | + /* 285 */ "trigger_decl", |
| 162044 | + /* 286 */ "trigger_cmd_list", |
| 162045 | + /* 287 */ "trigger_time", |
| 162046 | + /* 288 */ "trigger_event", |
| 162047 | + /* 289 */ "foreach_clause", |
| 162048 | + /* 290 */ "when_clause", |
| 162049 | + /* 291 */ "trigger_cmd", |
| 162050 | + /* 292 */ "trnm", |
| 162051 | + /* 293 */ "tridxby", |
| 162052 | + /* 294 */ "database_kw_opt", |
| 162053 | + /* 295 */ "key_opt", |
| 162054 | + /* 296 */ "add_column_fullname", |
| 162055 | + /* 297 */ "kwcolumn_opt", |
| 162056 | + /* 298 */ "create_vtab", |
| 162057 | + /* 299 */ "vtabarglist", |
| 162058 | + /* 300 */ "vtabarg", |
| 162059 | + /* 301 */ "vtabargtoken", |
| 162060 | + /* 302 */ "lp", |
| 162061 | + /* 303 */ "anylist", |
| 162062 | + /* 304 */ "wqitem", |
| 162063 | + /* 305 */ "wqas", |
| 162064 | + /* 306 */ "windowdefn_list", |
| 162065 | + /* 307 */ "windowdefn", |
| 162066 | + /* 308 */ "window", |
| 162067 | + /* 309 */ "frame_opt", |
| 162068 | + /* 310 */ "part_opt", |
| 162069 | + /* 311 */ "filter_clause", |
| 162070 | + /* 312 */ "over_clause", |
| 162071 | + /* 313 */ "range_or_rows", |
| 162072 | + /* 314 */ "frame_bound", |
| 162073 | + /* 315 */ "frame_bound_s", |
| 162074 | + /* 316 */ "frame_bound_e", |
| 162075 | + /* 317 */ "frame_exclude_opt", |
| 162076 | + /* 318 */ "frame_exclude", |
| 161846 | 162077 | }; |
| 161847 | 162078 | #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ |
| 161848 | 162079 | |
| 161849 | 162080 | #ifndef NDEBUG |
| 161850 | 162081 | /* For tracing reduce actions, the names of all rules are required. |
| | @@ -162060,199 +162291,200 @@ |
| 162060 | 162291 | /* 207 */ "expr ::= expr IS expr", |
| 162061 | 162292 | /* 208 */ "expr ::= expr IS NOT expr", |
| 162062 | 162293 | /* 209 */ "expr ::= NOT expr", |
| 162063 | 162294 | /* 210 */ "expr ::= BITNOT expr", |
| 162064 | 162295 | /* 211 */ "expr ::= PLUS|MINUS expr", |
| 162065 | | - /* 212 */ "between_op ::= BETWEEN", |
| 162066 | | - /* 213 */ "between_op ::= NOT BETWEEN", |
| 162067 | | - /* 214 */ "expr ::= expr between_op expr AND expr", |
| 162068 | | - /* 215 */ "in_op ::= IN", |
| 162069 | | - /* 216 */ "in_op ::= NOT IN", |
| 162070 | | - /* 217 */ "expr ::= expr in_op LP exprlist RP", |
| 162071 | | - /* 218 */ "expr ::= LP select RP", |
| 162072 | | - /* 219 */ "expr ::= expr in_op LP select RP", |
| 162073 | | - /* 220 */ "expr ::= expr in_op nm dbnm paren_exprlist", |
| 162074 | | - /* 221 */ "expr ::= EXISTS LP select RP", |
| 162075 | | - /* 222 */ "expr ::= CASE case_operand case_exprlist case_else END", |
| 162076 | | - /* 223 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", |
| 162077 | | - /* 224 */ "case_exprlist ::= WHEN expr THEN expr", |
| 162078 | | - /* 225 */ "case_else ::= ELSE expr", |
| 162079 | | - /* 226 */ "case_else ::=", |
| 162080 | | - /* 227 */ "case_operand ::= expr", |
| 162081 | | - /* 228 */ "case_operand ::=", |
| 162082 | | - /* 229 */ "exprlist ::=", |
| 162083 | | - /* 230 */ "nexprlist ::= nexprlist COMMA expr", |
| 162084 | | - /* 231 */ "nexprlist ::= expr", |
| 162085 | | - /* 232 */ "paren_exprlist ::=", |
| 162086 | | - /* 233 */ "paren_exprlist ::= LP exprlist RP", |
| 162087 | | - /* 234 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", |
| 162088 | | - /* 235 */ "uniqueflag ::= UNIQUE", |
| 162089 | | - /* 236 */ "uniqueflag ::=", |
| 162090 | | - /* 237 */ "eidlist_opt ::=", |
| 162091 | | - /* 238 */ "eidlist_opt ::= LP eidlist RP", |
| 162092 | | - /* 239 */ "eidlist ::= eidlist COMMA nm collate sortorder", |
| 162093 | | - /* 240 */ "eidlist ::= nm collate sortorder", |
| 162094 | | - /* 241 */ "collate ::=", |
| 162095 | | - /* 242 */ "collate ::= COLLATE ID|STRING", |
| 162096 | | - /* 243 */ "cmd ::= DROP INDEX ifexists fullname", |
| 162097 | | - /* 244 */ "cmd ::= VACUUM vinto", |
| 162098 | | - /* 245 */ "cmd ::= VACUUM nm vinto", |
| 162099 | | - /* 246 */ "vinto ::= INTO expr", |
| 162100 | | - /* 247 */ "vinto ::=", |
| 162101 | | - /* 248 */ "cmd ::= PRAGMA nm dbnm", |
| 162102 | | - /* 249 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", |
| 162103 | | - /* 250 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", |
| 162104 | | - /* 251 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", |
| 162105 | | - /* 252 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", |
| 162106 | | - /* 253 */ "plus_num ::= PLUS INTEGER|FLOAT", |
| 162107 | | - /* 254 */ "minus_num ::= MINUS INTEGER|FLOAT", |
| 162108 | | - /* 255 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", |
| 162109 | | - /* 256 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", |
| 162110 | | - /* 257 */ "trigger_time ::= BEFORE|AFTER", |
| 162111 | | - /* 258 */ "trigger_time ::= INSTEAD OF", |
| 162112 | | - /* 259 */ "trigger_time ::=", |
| 162113 | | - /* 260 */ "trigger_event ::= DELETE|INSERT", |
| 162114 | | - /* 261 */ "trigger_event ::= UPDATE", |
| 162115 | | - /* 262 */ "trigger_event ::= UPDATE OF idlist", |
| 162116 | | - /* 263 */ "when_clause ::=", |
| 162117 | | - /* 264 */ "when_clause ::= WHEN expr", |
| 162118 | | - /* 265 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", |
| 162119 | | - /* 266 */ "trigger_cmd_list ::= trigger_cmd SEMI", |
| 162120 | | - /* 267 */ "trnm ::= nm DOT nm", |
| 162121 | | - /* 268 */ "tridxby ::= INDEXED BY nm", |
| 162122 | | - /* 269 */ "tridxby ::= NOT INDEXED", |
| 162123 | | - /* 270 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", |
| 162124 | | - /* 271 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", |
| 162125 | | - /* 272 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", |
| 162126 | | - /* 273 */ "trigger_cmd ::= scanpt select scanpt", |
| 162127 | | - /* 274 */ "expr ::= RAISE LP IGNORE RP", |
| 162128 | | - /* 275 */ "expr ::= RAISE LP raisetype COMMA nm RP", |
| 162129 | | - /* 276 */ "raisetype ::= ROLLBACK", |
| 162130 | | - /* 277 */ "raisetype ::= ABORT", |
| 162131 | | - /* 278 */ "raisetype ::= FAIL", |
| 162132 | | - /* 279 */ "cmd ::= DROP TRIGGER ifexists fullname", |
| 162133 | | - /* 280 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", |
| 162134 | | - /* 281 */ "cmd ::= DETACH database_kw_opt expr", |
| 162135 | | - /* 282 */ "key_opt ::=", |
| 162136 | | - /* 283 */ "key_opt ::= KEY expr", |
| 162137 | | - /* 284 */ "cmd ::= REINDEX", |
| 162138 | | - /* 285 */ "cmd ::= REINDEX nm dbnm", |
| 162139 | | - /* 286 */ "cmd ::= ANALYZE", |
| 162140 | | - /* 287 */ "cmd ::= ANALYZE nm dbnm", |
| 162141 | | - /* 288 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", |
| 162142 | | - /* 289 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", |
| 162143 | | - /* 290 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", |
| 162144 | | - /* 291 */ "add_column_fullname ::= fullname", |
| 162145 | | - /* 292 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", |
| 162146 | | - /* 293 */ "cmd ::= create_vtab", |
| 162147 | | - /* 294 */ "cmd ::= create_vtab LP vtabarglist RP", |
| 162148 | | - /* 295 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", |
| 162149 | | - /* 296 */ "vtabarg ::=", |
| 162150 | | - /* 297 */ "vtabargtoken ::= ANY", |
| 162151 | | - /* 298 */ "vtabargtoken ::= lp anylist RP", |
| 162152 | | - /* 299 */ "lp ::= LP", |
| 162153 | | - /* 300 */ "with ::= WITH wqlist", |
| 162154 | | - /* 301 */ "with ::= WITH RECURSIVE wqlist", |
| 162155 | | - /* 302 */ "wqas ::= AS", |
| 162156 | | - /* 303 */ "wqas ::= AS MATERIALIZED", |
| 162157 | | - /* 304 */ "wqas ::= AS NOT MATERIALIZED", |
| 162158 | | - /* 305 */ "wqitem ::= nm eidlist_opt wqas LP select RP", |
| 162159 | | - /* 306 */ "wqlist ::= wqitem", |
| 162160 | | - /* 307 */ "wqlist ::= wqlist COMMA wqitem", |
| 162161 | | - /* 308 */ "windowdefn_list ::= windowdefn", |
| 162162 | | - /* 309 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", |
| 162163 | | - /* 310 */ "windowdefn ::= nm AS LP window RP", |
| 162164 | | - /* 311 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", |
| 162165 | | - /* 312 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", |
| 162166 | | - /* 313 */ "window ::= ORDER BY sortlist frame_opt", |
| 162167 | | - /* 314 */ "window ::= nm ORDER BY sortlist frame_opt", |
| 162168 | | - /* 315 */ "window ::= frame_opt", |
| 162169 | | - /* 316 */ "window ::= nm frame_opt", |
| 162170 | | - /* 317 */ "frame_opt ::=", |
| 162171 | | - /* 318 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", |
| 162172 | | - /* 319 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", |
| 162173 | | - /* 320 */ "range_or_rows ::= RANGE|ROWS|GROUPS", |
| 162174 | | - /* 321 */ "frame_bound_s ::= frame_bound", |
| 162175 | | - /* 322 */ "frame_bound_s ::= UNBOUNDED PRECEDING", |
| 162176 | | - /* 323 */ "frame_bound_e ::= frame_bound", |
| 162177 | | - /* 324 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", |
| 162178 | | - /* 325 */ "frame_bound ::= expr PRECEDING|FOLLOWING", |
| 162179 | | - /* 326 */ "frame_bound ::= CURRENT ROW", |
| 162180 | | - /* 327 */ "frame_exclude_opt ::=", |
| 162181 | | - /* 328 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", |
| 162182 | | - /* 329 */ "frame_exclude ::= NO OTHERS", |
| 162183 | | - /* 330 */ "frame_exclude ::= CURRENT ROW", |
| 162184 | | - /* 331 */ "frame_exclude ::= GROUP|TIES", |
| 162185 | | - /* 332 */ "window_clause ::= WINDOW windowdefn_list", |
| 162186 | | - /* 333 */ "filter_over ::= filter_clause over_clause", |
| 162187 | | - /* 334 */ "filter_over ::= over_clause", |
| 162188 | | - /* 335 */ "filter_over ::= filter_clause", |
| 162189 | | - /* 336 */ "over_clause ::= OVER LP window RP", |
| 162190 | | - /* 337 */ "over_clause ::= OVER nm", |
| 162191 | | - /* 338 */ "filter_clause ::= FILTER LP WHERE expr RP", |
| 162192 | | - /* 339 */ "input ::= cmdlist", |
| 162193 | | - /* 340 */ "cmdlist ::= cmdlist ecmd", |
| 162194 | | - /* 341 */ "cmdlist ::= ecmd", |
| 162195 | | - /* 342 */ "ecmd ::= SEMI", |
| 162196 | | - /* 343 */ "ecmd ::= cmdx SEMI", |
| 162197 | | - /* 344 */ "ecmd ::= explain cmdx SEMI", |
| 162198 | | - /* 345 */ "trans_opt ::=", |
| 162199 | | - /* 346 */ "trans_opt ::= TRANSACTION", |
| 162200 | | - /* 347 */ "trans_opt ::= TRANSACTION nm", |
| 162201 | | - /* 348 */ "savepoint_opt ::= SAVEPOINT", |
| 162202 | | - /* 349 */ "savepoint_opt ::=", |
| 162203 | | - /* 350 */ "cmd ::= create_table create_table_args", |
| 162204 | | - /* 351 */ "table_option_set ::= table_option", |
| 162205 | | - /* 352 */ "columnlist ::= columnlist COMMA columnname carglist", |
| 162206 | | - /* 353 */ "columnlist ::= columnname carglist", |
| 162207 | | - /* 354 */ "nm ::= ID|INDEXED", |
| 162208 | | - /* 355 */ "nm ::= STRING", |
| 162209 | | - /* 356 */ "nm ::= JOIN_KW", |
| 162210 | | - /* 357 */ "typetoken ::= typename", |
| 162211 | | - /* 358 */ "typename ::= ID|STRING", |
| 162212 | | - /* 359 */ "signed ::= plus_num", |
| 162213 | | - /* 360 */ "signed ::= minus_num", |
| 162214 | | - /* 361 */ "carglist ::= carglist ccons", |
| 162215 | | - /* 362 */ "carglist ::=", |
| 162216 | | - /* 363 */ "ccons ::= NULL onconf", |
| 162217 | | - /* 364 */ "ccons ::= GENERATED ALWAYS AS generated", |
| 162218 | | - /* 365 */ "ccons ::= AS generated", |
| 162219 | | - /* 366 */ "conslist_opt ::= COMMA conslist", |
| 162220 | | - /* 367 */ "conslist ::= conslist tconscomma tcons", |
| 162221 | | - /* 368 */ "conslist ::= tcons", |
| 162222 | | - /* 369 */ "tconscomma ::=", |
| 162223 | | - /* 370 */ "defer_subclause_opt ::= defer_subclause", |
| 162224 | | - /* 371 */ "resolvetype ::= raisetype", |
| 162225 | | - /* 372 */ "selectnowith ::= oneselect", |
| 162226 | | - /* 373 */ "oneselect ::= values", |
| 162227 | | - /* 374 */ "sclp ::= selcollist COMMA", |
| 162228 | | - /* 375 */ "as ::= ID|STRING", |
| 162229 | | - /* 376 */ "returning ::=", |
| 162230 | | - /* 377 */ "expr ::= term", |
| 162231 | | - /* 378 */ "likeop ::= LIKE_KW|MATCH", |
| 162232 | | - /* 379 */ "exprlist ::= nexprlist", |
| 162233 | | - /* 380 */ "nmnum ::= plus_num", |
| 162234 | | - /* 381 */ "nmnum ::= nm", |
| 162235 | | - /* 382 */ "nmnum ::= ON", |
| 162236 | | - /* 383 */ "nmnum ::= DELETE", |
| 162237 | | - /* 384 */ "nmnum ::= DEFAULT", |
| 162238 | | - /* 385 */ "plus_num ::= INTEGER|FLOAT", |
| 162239 | | - /* 386 */ "foreach_clause ::=", |
| 162240 | | - /* 387 */ "foreach_clause ::= FOR EACH ROW", |
| 162241 | | - /* 388 */ "trnm ::= nm", |
| 162242 | | - /* 389 */ "tridxby ::=", |
| 162243 | | - /* 390 */ "database_kw_opt ::= DATABASE", |
| 162244 | | - /* 391 */ "database_kw_opt ::=", |
| 162245 | | - /* 392 */ "kwcolumn_opt ::=", |
| 162246 | | - /* 393 */ "kwcolumn_opt ::= COLUMNKW", |
| 162247 | | - /* 394 */ "vtabarglist ::= vtabarg", |
| 162248 | | - /* 395 */ "vtabarglist ::= vtabarglist COMMA vtabarg", |
| 162249 | | - /* 396 */ "vtabarg ::= vtabarg vtabargtoken", |
| 162250 | | - /* 397 */ "anylist ::=", |
| 162251 | | - /* 398 */ "anylist ::= anylist LP anylist RP", |
| 162252 | | - /* 399 */ "anylist ::= anylist ANY", |
| 162253 | | - /* 400 */ "with ::=", |
| 162296 | + /* 212 */ "expr ::= expr PTR expr", |
| 162297 | + /* 213 */ "between_op ::= BETWEEN", |
| 162298 | + /* 214 */ "between_op ::= NOT BETWEEN", |
| 162299 | + /* 215 */ "expr ::= expr between_op expr AND expr", |
| 162300 | + /* 216 */ "in_op ::= IN", |
| 162301 | + /* 217 */ "in_op ::= NOT IN", |
| 162302 | + /* 218 */ "expr ::= expr in_op LP exprlist RP", |
| 162303 | + /* 219 */ "expr ::= LP select RP", |
| 162304 | + /* 220 */ "expr ::= expr in_op LP select RP", |
| 162305 | + /* 221 */ "expr ::= expr in_op nm dbnm paren_exprlist", |
| 162306 | + /* 222 */ "expr ::= EXISTS LP select RP", |
| 162307 | + /* 223 */ "expr ::= CASE case_operand case_exprlist case_else END", |
| 162308 | + /* 224 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", |
| 162309 | + /* 225 */ "case_exprlist ::= WHEN expr THEN expr", |
| 162310 | + /* 226 */ "case_else ::= ELSE expr", |
| 162311 | + /* 227 */ "case_else ::=", |
| 162312 | + /* 228 */ "case_operand ::= expr", |
| 162313 | + /* 229 */ "case_operand ::=", |
| 162314 | + /* 230 */ "exprlist ::=", |
| 162315 | + /* 231 */ "nexprlist ::= nexprlist COMMA expr", |
| 162316 | + /* 232 */ "nexprlist ::= expr", |
| 162317 | + /* 233 */ "paren_exprlist ::=", |
| 162318 | + /* 234 */ "paren_exprlist ::= LP exprlist RP", |
| 162319 | + /* 235 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", |
| 162320 | + /* 236 */ "uniqueflag ::= UNIQUE", |
| 162321 | + /* 237 */ "uniqueflag ::=", |
| 162322 | + /* 238 */ "eidlist_opt ::=", |
| 162323 | + /* 239 */ "eidlist_opt ::= LP eidlist RP", |
| 162324 | + /* 240 */ "eidlist ::= eidlist COMMA nm collate sortorder", |
| 162325 | + /* 241 */ "eidlist ::= nm collate sortorder", |
| 162326 | + /* 242 */ "collate ::=", |
| 162327 | + /* 243 */ "collate ::= COLLATE ID|STRING", |
| 162328 | + /* 244 */ "cmd ::= DROP INDEX ifexists fullname", |
| 162329 | + /* 245 */ "cmd ::= VACUUM vinto", |
| 162330 | + /* 246 */ "cmd ::= VACUUM nm vinto", |
| 162331 | + /* 247 */ "vinto ::= INTO expr", |
| 162332 | + /* 248 */ "vinto ::=", |
| 162333 | + /* 249 */ "cmd ::= PRAGMA nm dbnm", |
| 162334 | + /* 250 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", |
| 162335 | + /* 251 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", |
| 162336 | + /* 252 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", |
| 162337 | + /* 253 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", |
| 162338 | + /* 254 */ "plus_num ::= PLUS INTEGER|FLOAT", |
| 162339 | + /* 255 */ "minus_num ::= MINUS INTEGER|FLOAT", |
| 162340 | + /* 256 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", |
| 162341 | + /* 257 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", |
| 162342 | + /* 258 */ "trigger_time ::= BEFORE|AFTER", |
| 162343 | + /* 259 */ "trigger_time ::= INSTEAD OF", |
| 162344 | + /* 260 */ "trigger_time ::=", |
| 162345 | + /* 261 */ "trigger_event ::= DELETE|INSERT", |
| 162346 | + /* 262 */ "trigger_event ::= UPDATE", |
| 162347 | + /* 263 */ "trigger_event ::= UPDATE OF idlist", |
| 162348 | + /* 264 */ "when_clause ::=", |
| 162349 | + /* 265 */ "when_clause ::= WHEN expr", |
| 162350 | + /* 266 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", |
| 162351 | + /* 267 */ "trigger_cmd_list ::= trigger_cmd SEMI", |
| 162352 | + /* 268 */ "trnm ::= nm DOT nm", |
| 162353 | + /* 269 */ "tridxby ::= INDEXED BY nm", |
| 162354 | + /* 270 */ "tridxby ::= NOT INDEXED", |
| 162355 | + /* 271 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", |
| 162356 | + /* 272 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", |
| 162357 | + /* 273 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", |
| 162358 | + /* 274 */ "trigger_cmd ::= scanpt select scanpt", |
| 162359 | + /* 275 */ "expr ::= RAISE LP IGNORE RP", |
| 162360 | + /* 276 */ "expr ::= RAISE LP raisetype COMMA nm RP", |
| 162361 | + /* 277 */ "raisetype ::= ROLLBACK", |
| 162362 | + /* 278 */ "raisetype ::= ABORT", |
| 162363 | + /* 279 */ "raisetype ::= FAIL", |
| 162364 | + /* 280 */ "cmd ::= DROP TRIGGER ifexists fullname", |
| 162365 | + /* 281 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", |
| 162366 | + /* 282 */ "cmd ::= DETACH database_kw_opt expr", |
| 162367 | + /* 283 */ "key_opt ::=", |
| 162368 | + /* 284 */ "key_opt ::= KEY expr", |
| 162369 | + /* 285 */ "cmd ::= REINDEX", |
| 162370 | + /* 286 */ "cmd ::= REINDEX nm dbnm", |
| 162371 | + /* 287 */ "cmd ::= ANALYZE", |
| 162372 | + /* 288 */ "cmd ::= ANALYZE nm dbnm", |
| 162373 | + /* 289 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", |
| 162374 | + /* 290 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", |
| 162375 | + /* 291 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", |
| 162376 | + /* 292 */ "add_column_fullname ::= fullname", |
| 162377 | + /* 293 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", |
| 162378 | + /* 294 */ "cmd ::= create_vtab", |
| 162379 | + /* 295 */ "cmd ::= create_vtab LP vtabarglist RP", |
| 162380 | + /* 296 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", |
| 162381 | + /* 297 */ "vtabarg ::=", |
| 162382 | + /* 298 */ "vtabargtoken ::= ANY", |
| 162383 | + /* 299 */ "vtabargtoken ::= lp anylist RP", |
| 162384 | + /* 300 */ "lp ::= LP", |
| 162385 | + /* 301 */ "with ::= WITH wqlist", |
| 162386 | + /* 302 */ "with ::= WITH RECURSIVE wqlist", |
| 162387 | + /* 303 */ "wqas ::= AS", |
| 162388 | + /* 304 */ "wqas ::= AS MATERIALIZED", |
| 162389 | + /* 305 */ "wqas ::= AS NOT MATERIALIZED", |
| 162390 | + /* 306 */ "wqitem ::= nm eidlist_opt wqas LP select RP", |
| 162391 | + /* 307 */ "wqlist ::= wqitem", |
| 162392 | + /* 308 */ "wqlist ::= wqlist COMMA wqitem", |
| 162393 | + /* 309 */ "windowdefn_list ::= windowdefn", |
| 162394 | + /* 310 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", |
| 162395 | + /* 311 */ "windowdefn ::= nm AS LP window RP", |
| 162396 | + /* 312 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", |
| 162397 | + /* 313 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", |
| 162398 | + /* 314 */ "window ::= ORDER BY sortlist frame_opt", |
| 162399 | + /* 315 */ "window ::= nm ORDER BY sortlist frame_opt", |
| 162400 | + /* 316 */ "window ::= frame_opt", |
| 162401 | + /* 317 */ "window ::= nm frame_opt", |
| 162402 | + /* 318 */ "frame_opt ::=", |
| 162403 | + /* 319 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", |
| 162404 | + /* 320 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", |
| 162405 | + /* 321 */ "range_or_rows ::= RANGE|ROWS|GROUPS", |
| 162406 | + /* 322 */ "frame_bound_s ::= frame_bound", |
| 162407 | + /* 323 */ "frame_bound_s ::= UNBOUNDED PRECEDING", |
| 162408 | + /* 324 */ "frame_bound_e ::= frame_bound", |
| 162409 | + /* 325 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", |
| 162410 | + /* 326 */ "frame_bound ::= expr PRECEDING|FOLLOWING", |
| 162411 | + /* 327 */ "frame_bound ::= CURRENT ROW", |
| 162412 | + /* 328 */ "frame_exclude_opt ::=", |
| 162413 | + /* 329 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", |
| 162414 | + /* 330 */ "frame_exclude ::= NO OTHERS", |
| 162415 | + /* 331 */ "frame_exclude ::= CURRENT ROW", |
| 162416 | + /* 332 */ "frame_exclude ::= GROUP|TIES", |
| 162417 | + /* 333 */ "window_clause ::= WINDOW windowdefn_list", |
| 162418 | + /* 334 */ "filter_over ::= filter_clause over_clause", |
| 162419 | + /* 335 */ "filter_over ::= over_clause", |
| 162420 | + /* 336 */ "filter_over ::= filter_clause", |
| 162421 | + /* 337 */ "over_clause ::= OVER LP window RP", |
| 162422 | + /* 338 */ "over_clause ::= OVER nm", |
| 162423 | + /* 339 */ "filter_clause ::= FILTER LP WHERE expr RP", |
| 162424 | + /* 340 */ "input ::= cmdlist", |
| 162425 | + /* 341 */ "cmdlist ::= cmdlist ecmd", |
| 162426 | + /* 342 */ "cmdlist ::= ecmd", |
| 162427 | + /* 343 */ "ecmd ::= SEMI", |
| 162428 | + /* 344 */ "ecmd ::= cmdx SEMI", |
| 162429 | + /* 345 */ "ecmd ::= explain cmdx SEMI", |
| 162430 | + /* 346 */ "trans_opt ::=", |
| 162431 | + /* 347 */ "trans_opt ::= TRANSACTION", |
| 162432 | + /* 348 */ "trans_opt ::= TRANSACTION nm", |
| 162433 | + /* 349 */ "savepoint_opt ::= SAVEPOINT", |
| 162434 | + /* 350 */ "savepoint_opt ::=", |
| 162435 | + /* 351 */ "cmd ::= create_table create_table_args", |
| 162436 | + /* 352 */ "table_option_set ::= table_option", |
| 162437 | + /* 353 */ "columnlist ::= columnlist COMMA columnname carglist", |
| 162438 | + /* 354 */ "columnlist ::= columnname carglist", |
| 162439 | + /* 355 */ "nm ::= ID|INDEXED", |
| 162440 | + /* 356 */ "nm ::= STRING", |
| 162441 | + /* 357 */ "nm ::= JOIN_KW", |
| 162442 | + /* 358 */ "typetoken ::= typename", |
| 162443 | + /* 359 */ "typename ::= ID|STRING", |
| 162444 | + /* 360 */ "signed ::= plus_num", |
| 162445 | + /* 361 */ "signed ::= minus_num", |
| 162446 | + /* 362 */ "carglist ::= carglist ccons", |
| 162447 | + /* 363 */ "carglist ::=", |
| 162448 | + /* 364 */ "ccons ::= NULL onconf", |
| 162449 | + /* 365 */ "ccons ::= GENERATED ALWAYS AS generated", |
| 162450 | + /* 366 */ "ccons ::= AS generated", |
| 162451 | + /* 367 */ "conslist_opt ::= COMMA conslist", |
| 162452 | + /* 368 */ "conslist ::= conslist tconscomma tcons", |
| 162453 | + /* 369 */ "conslist ::= tcons", |
| 162454 | + /* 370 */ "tconscomma ::=", |
| 162455 | + /* 371 */ "defer_subclause_opt ::= defer_subclause", |
| 162456 | + /* 372 */ "resolvetype ::= raisetype", |
| 162457 | + /* 373 */ "selectnowith ::= oneselect", |
| 162458 | + /* 374 */ "oneselect ::= values", |
| 162459 | + /* 375 */ "sclp ::= selcollist COMMA", |
| 162460 | + /* 376 */ "as ::= ID|STRING", |
| 162461 | + /* 377 */ "returning ::=", |
| 162462 | + /* 378 */ "expr ::= term", |
| 162463 | + /* 379 */ "likeop ::= LIKE_KW|MATCH", |
| 162464 | + /* 380 */ "exprlist ::= nexprlist", |
| 162465 | + /* 381 */ "nmnum ::= plus_num", |
| 162466 | + /* 382 */ "nmnum ::= nm", |
| 162467 | + /* 383 */ "nmnum ::= ON", |
| 162468 | + /* 384 */ "nmnum ::= DELETE", |
| 162469 | + /* 385 */ "nmnum ::= DEFAULT", |
| 162470 | + /* 386 */ "plus_num ::= INTEGER|FLOAT", |
| 162471 | + /* 387 */ "foreach_clause ::=", |
| 162472 | + /* 388 */ "foreach_clause ::= FOR EACH ROW", |
| 162473 | + /* 389 */ "trnm ::= nm", |
| 162474 | + /* 390 */ "tridxby ::=", |
| 162475 | + /* 391 */ "database_kw_opt ::= DATABASE", |
| 162476 | + /* 392 */ "database_kw_opt ::=", |
| 162477 | + /* 393 */ "kwcolumn_opt ::=", |
| 162478 | + /* 394 */ "kwcolumn_opt ::= COLUMNKW", |
| 162479 | + /* 395 */ "vtabarglist ::= vtabarg", |
| 162480 | + /* 396 */ "vtabarglist ::= vtabarglist COMMA vtabarg", |
| 162481 | + /* 397 */ "vtabarg ::= vtabarg vtabargtoken", |
| 162482 | + /* 398 */ "anylist ::=", |
| 162483 | + /* 399 */ "anylist ::= anylist LP anylist RP", |
| 162484 | + /* 400 */ "anylist ::= anylist ANY", |
| 162485 | + /* 401 */ "with ::=", |
| 162254 | 162486 | }; |
| 162255 | 162487 | #endif /* NDEBUG */ |
| 162256 | 162488 | |
| 162257 | 162489 | |
| 162258 | 162490 | #if YYSTACKDEPTH<=0 |
| | @@ -162374,103 +162606,103 @@ |
| 162374 | 162606 | ** Note: during a reduce, the only symbols destroyed are those |
| 162375 | 162607 | ** which appear on the RHS of the rule, but which are *not* used |
| 162376 | 162608 | ** inside the C code. |
| 162377 | 162609 | */ |
| 162378 | 162610 | /********* Begin destructor definitions ***************************************/ |
| 162379 | | - case 203: /* select */ |
| 162380 | | - case 238: /* selectnowith */ |
| 162381 | | - case 239: /* oneselect */ |
| 162382 | | - case 251: /* values */ |
| 162383 | | -{ |
| 162384 | | -sqlite3SelectDelete(pParse->db, (yypminor->yy303)); |
| 162385 | | -} |
| 162386 | | - break; |
| 162387 | | - case 215: /* term */ |
| 162388 | | - case 216: /* expr */ |
| 162389 | | - case 245: /* where_opt */ |
| 162390 | | - case 247: /* having_opt */ |
| 162391 | | - case 259: /* on_opt */ |
| 162392 | | - case 266: /* where_opt_ret */ |
| 162393 | | - case 277: /* case_operand */ |
| 162394 | | - case 279: /* case_else */ |
| 162395 | | - case 282: /* vinto */ |
| 162396 | | - case 289: /* when_clause */ |
| 162397 | | - case 294: /* key_opt */ |
| 162398 | | - case 310: /* filter_clause */ |
| 162399 | | -{ |
| 162400 | | -sqlite3ExprDelete(pParse->db, (yypminor->yy626)); |
| 162401 | | -} |
| 162402 | | - break; |
| 162403 | | - case 220: /* eidlist_opt */ |
| 162404 | | - case 230: /* sortlist */ |
| 162405 | | - case 231: /* eidlist */ |
| 162406 | | - case 243: /* selcollist */ |
| 162407 | | - case 246: /* groupby_opt */ |
| 162408 | | - case 248: /* orderby_opt */ |
| 162409 | | - case 252: /* nexprlist */ |
| 162410 | | - case 253: /* sclp */ |
| 162411 | | - case 261: /* exprlist */ |
| 162412 | | - case 267: /* setlist */ |
| 162413 | | - case 276: /* paren_exprlist */ |
| 162414 | | - case 278: /* case_exprlist */ |
| 162415 | | - case 309: /* part_opt */ |
| 162416 | | -{ |
| 162417 | | -sqlite3ExprListDelete(pParse->db, (yypminor->yy562)); |
| 162418 | | -} |
| 162419 | | - break; |
| 162420 | | - case 237: /* fullname */ |
| 162421 | | - case 244: /* from */ |
| 162422 | | - case 255: /* seltablist */ |
| 162423 | | - case 256: /* stl_prefix */ |
| 162424 | | - case 262: /* xfullname */ |
| 162425 | | -{ |
| 162426 | | -sqlite3SrcListDelete(pParse->db, (yypminor->yy607)); |
| 162427 | | -} |
| 162428 | | - break; |
| 162429 | | - case 240: /* wqlist */ |
| 162430 | | -{ |
| 162431 | | -sqlite3WithDelete(pParse->db, (yypminor->yy43)); |
| 162432 | | -} |
| 162433 | | - break; |
| 162434 | | - case 250: /* window_clause */ |
| 162435 | | - case 305: /* windowdefn_list */ |
| 162436 | | -{ |
| 162437 | | -sqlite3WindowListDelete(pParse->db, (yypminor->yy375)); |
| 162438 | | -} |
| 162439 | | - break; |
| 162440 | | - case 260: /* using_opt */ |
| 162441 | | - case 263: /* idlist */ |
| 162442 | | - case 269: /* idlist_opt */ |
| 162443 | | -{ |
| 162444 | | -sqlite3IdListDelete(pParse->db, (yypminor->yy240)); |
| 162445 | | -} |
| 162446 | | - break; |
| 162447 | | - case 272: /* filter_over */ |
| 162448 | | - case 306: /* windowdefn */ |
| 162449 | | - case 307: /* window */ |
| 162450 | | - case 308: /* frame_opt */ |
| 162451 | | - case 311: /* over_clause */ |
| 162452 | | -{ |
| 162453 | | -sqlite3WindowDelete(pParse->db, (yypminor->yy375)); |
| 162454 | | -} |
| 162455 | | - break; |
| 162456 | | - case 285: /* trigger_cmd_list */ |
| 162457 | | - case 290: /* trigger_cmd */ |
| 162458 | | -{ |
| 162459 | | -sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy95)); |
| 162460 | | -} |
| 162461 | | - break; |
| 162462 | | - case 287: /* trigger_event */ |
| 162463 | | -{ |
| 162464 | | -sqlite3IdListDelete(pParse->db, (yypminor->yy570).b); |
| 162465 | | -} |
| 162466 | | - break; |
| 162467 | | - case 313: /* frame_bound */ |
| 162468 | | - case 314: /* frame_bound_s */ |
| 162469 | | - case 315: /* frame_bound_e */ |
| 162470 | | -{ |
| 162471 | | -sqlite3ExprDelete(pParse->db, (yypminor->yy81).pExpr); |
| 162611 | + case 204: /* select */ |
| 162612 | + case 239: /* selectnowith */ |
| 162613 | + case 240: /* oneselect */ |
| 162614 | + case 252: /* values */ |
| 162615 | +{ |
| 162616 | +sqlite3SelectDelete(pParse->db, (yypminor->yy47)); |
| 162617 | +} |
| 162618 | + break; |
| 162619 | + case 216: /* term */ |
| 162620 | + case 217: /* expr */ |
| 162621 | + case 246: /* where_opt */ |
| 162622 | + case 248: /* having_opt */ |
| 162623 | + case 260: /* on_opt */ |
| 162624 | + case 267: /* where_opt_ret */ |
| 162625 | + case 278: /* case_operand */ |
| 162626 | + case 280: /* case_else */ |
| 162627 | + case 283: /* vinto */ |
| 162628 | + case 290: /* when_clause */ |
| 162629 | + case 295: /* key_opt */ |
| 162630 | + case 311: /* filter_clause */ |
| 162631 | +{ |
| 162632 | +sqlite3ExprDelete(pParse->db, (yypminor->yy528)); |
| 162633 | +} |
| 162634 | + break; |
| 162635 | + case 221: /* eidlist_opt */ |
| 162636 | + case 231: /* sortlist */ |
| 162637 | + case 232: /* eidlist */ |
| 162638 | + case 244: /* selcollist */ |
| 162639 | + case 247: /* groupby_opt */ |
| 162640 | + case 249: /* orderby_opt */ |
| 162641 | + case 253: /* nexprlist */ |
| 162642 | + case 254: /* sclp */ |
| 162643 | + case 262: /* exprlist */ |
| 162644 | + case 268: /* setlist */ |
| 162645 | + case 277: /* paren_exprlist */ |
| 162646 | + case 279: /* case_exprlist */ |
| 162647 | + case 310: /* part_opt */ |
| 162648 | +{ |
| 162649 | +sqlite3ExprListDelete(pParse->db, (yypminor->yy322)); |
| 162650 | +} |
| 162651 | + break; |
| 162652 | + case 238: /* fullname */ |
| 162653 | + case 245: /* from */ |
| 162654 | + case 256: /* seltablist */ |
| 162655 | + case 257: /* stl_prefix */ |
| 162656 | + case 263: /* xfullname */ |
| 162657 | +{ |
| 162658 | +sqlite3SrcListDelete(pParse->db, (yypminor->yy131)); |
| 162659 | +} |
| 162660 | + break; |
| 162661 | + case 241: /* wqlist */ |
| 162662 | +{ |
| 162663 | +sqlite3WithDelete(pParse->db, (yypminor->yy521)); |
| 162664 | +} |
| 162665 | + break; |
| 162666 | + case 251: /* window_clause */ |
| 162667 | + case 306: /* windowdefn_list */ |
| 162668 | +{ |
| 162669 | +sqlite3WindowListDelete(pParse->db, (yypminor->yy41)); |
| 162670 | +} |
| 162671 | + break; |
| 162672 | + case 261: /* using_opt */ |
| 162673 | + case 264: /* idlist */ |
| 162674 | + case 270: /* idlist_opt */ |
| 162675 | +{ |
| 162676 | +sqlite3IdListDelete(pParse->db, (yypminor->yy254)); |
| 162677 | +} |
| 162678 | + break; |
| 162679 | + case 273: /* filter_over */ |
| 162680 | + case 307: /* windowdefn */ |
| 162681 | + case 308: /* window */ |
| 162682 | + case 309: /* frame_opt */ |
| 162683 | + case 312: /* over_clause */ |
| 162684 | +{ |
| 162685 | +sqlite3WindowDelete(pParse->db, (yypminor->yy41)); |
| 162686 | +} |
| 162687 | + break; |
| 162688 | + case 286: /* trigger_cmd_list */ |
| 162689 | + case 291: /* trigger_cmd */ |
| 162690 | +{ |
| 162691 | +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy33)); |
| 162692 | +} |
| 162693 | + break; |
| 162694 | + case 288: /* trigger_event */ |
| 162695 | +{ |
| 162696 | +sqlite3IdListDelete(pParse->db, (yypminor->yy180).b); |
| 162697 | +} |
| 162698 | + break; |
| 162699 | + case 314: /* frame_bound */ |
| 162700 | + case 315: /* frame_bound_s */ |
| 162701 | + case 316: /* frame_bound_e */ |
| 162702 | +{ |
| 162703 | +sqlite3ExprDelete(pParse->db, (yypminor->yy595).pExpr); |
| 162472 | 162704 | } |
| 162473 | 162705 | break; |
| 162474 | 162706 | /********* End destructor definitions *****************************************/ |
| 162475 | 162707 | default: break; /* If no destructor action specified: do nothing */ |
| 162476 | 162708 | } |
| | @@ -162757,411 +162989,412 @@ |
| 162757 | 162989 | } |
| 162758 | 162990 | |
| 162759 | 162991 | /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side |
| 162760 | 162992 | ** of that rule */ |
| 162761 | 162993 | static const YYCODETYPE yyRuleInfoLhs[] = { |
| 162762 | | - 188, /* (0) explain ::= EXPLAIN */ |
| 162763 | | - 188, /* (1) explain ::= EXPLAIN QUERY PLAN */ |
| 162764 | | - 187, /* (2) cmdx ::= cmd */ |
| 162765 | | - 189, /* (3) cmd ::= BEGIN transtype trans_opt */ |
| 162766 | | - 190, /* (4) transtype ::= */ |
| 162767 | | - 190, /* (5) transtype ::= DEFERRED */ |
| 162768 | | - 190, /* (6) transtype ::= IMMEDIATE */ |
| 162769 | | - 190, /* (7) transtype ::= EXCLUSIVE */ |
| 162770 | | - 189, /* (8) cmd ::= COMMIT|END trans_opt */ |
| 162771 | | - 189, /* (9) cmd ::= ROLLBACK trans_opt */ |
| 162772 | | - 189, /* (10) cmd ::= SAVEPOINT nm */ |
| 162773 | | - 189, /* (11) cmd ::= RELEASE savepoint_opt nm */ |
| 162774 | | - 189, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ |
| 162775 | | - 194, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ |
| 162776 | | - 196, /* (14) createkw ::= CREATE */ |
| 162777 | | - 198, /* (15) ifnotexists ::= */ |
| 162778 | | - 198, /* (16) ifnotexists ::= IF NOT EXISTS */ |
| 162779 | | - 197, /* (17) temp ::= TEMP */ |
| 162780 | | - 197, /* (18) temp ::= */ |
| 162781 | | - 195, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ |
| 162782 | | - 195, /* (20) create_table_args ::= AS select */ |
| 162783 | | - 202, /* (21) table_option_set ::= */ |
| 162784 | | - 202, /* (22) table_option_set ::= table_option_set COMMA table_option */ |
| 162785 | | - 204, /* (23) table_option ::= WITHOUT nm */ |
| 162786 | | - 204, /* (24) table_option ::= nm */ |
| 162787 | | - 205, /* (25) columnname ::= nm typetoken */ |
| 162788 | | - 207, /* (26) typetoken ::= */ |
| 162789 | | - 207, /* (27) typetoken ::= typename LP signed RP */ |
| 162790 | | - 207, /* (28) typetoken ::= typename LP signed COMMA signed RP */ |
| 162791 | | - 208, /* (29) typename ::= typename ID|STRING */ |
| 162792 | | - 212, /* (30) scanpt ::= */ |
| 162793 | | - 213, /* (31) scantok ::= */ |
| 162794 | | - 214, /* (32) ccons ::= CONSTRAINT nm */ |
| 162795 | | - 214, /* (33) ccons ::= DEFAULT scantok term */ |
| 162796 | | - 214, /* (34) ccons ::= DEFAULT LP expr RP */ |
| 162797 | | - 214, /* (35) ccons ::= DEFAULT PLUS scantok term */ |
| 162798 | | - 214, /* (36) ccons ::= DEFAULT MINUS scantok term */ |
| 162799 | | - 214, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ |
| 162800 | | - 214, /* (38) ccons ::= NOT NULL onconf */ |
| 162801 | | - 214, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ |
| 162802 | | - 214, /* (40) ccons ::= UNIQUE onconf */ |
| 162803 | | - 214, /* (41) ccons ::= CHECK LP expr RP */ |
| 162804 | | - 214, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ |
| 162805 | | - 214, /* (43) ccons ::= defer_subclause */ |
| 162806 | | - 214, /* (44) ccons ::= COLLATE ID|STRING */ |
| 162807 | | - 223, /* (45) generated ::= LP expr RP */ |
| 162808 | | - 223, /* (46) generated ::= LP expr RP ID */ |
| 162809 | | - 219, /* (47) autoinc ::= */ |
| 162810 | | - 219, /* (48) autoinc ::= AUTOINCR */ |
| 162811 | | - 221, /* (49) refargs ::= */ |
| 162812 | | - 221, /* (50) refargs ::= refargs refarg */ |
| 162813 | | - 224, /* (51) refarg ::= MATCH nm */ |
| 162814 | | - 224, /* (52) refarg ::= ON INSERT refact */ |
| 162815 | | - 224, /* (53) refarg ::= ON DELETE refact */ |
| 162816 | | - 224, /* (54) refarg ::= ON UPDATE refact */ |
| 162817 | | - 225, /* (55) refact ::= SET NULL */ |
| 162818 | | - 225, /* (56) refact ::= SET DEFAULT */ |
| 162819 | | - 225, /* (57) refact ::= CASCADE */ |
| 162820 | | - 225, /* (58) refact ::= RESTRICT */ |
| 162821 | | - 225, /* (59) refact ::= NO ACTION */ |
| 162822 | | - 222, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ |
| 162823 | | - 222, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ |
| 162824 | | - 226, /* (62) init_deferred_pred_opt ::= */ |
| 162825 | | - 226, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ |
| 162826 | | - 226, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ |
| 162827 | | - 201, /* (65) conslist_opt ::= */ |
| 162828 | | - 228, /* (66) tconscomma ::= COMMA */ |
| 162829 | | - 229, /* (67) tcons ::= CONSTRAINT nm */ |
| 162830 | | - 229, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ |
| 162831 | | - 229, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ |
| 162832 | | - 229, /* (70) tcons ::= CHECK LP expr RP onconf */ |
| 162833 | | - 229, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ |
| 162834 | | - 232, /* (72) defer_subclause_opt ::= */ |
| 162835 | | - 217, /* (73) onconf ::= */ |
| 162836 | | - 217, /* (74) onconf ::= ON CONFLICT resolvetype */ |
| 162837 | | - 233, /* (75) orconf ::= */ |
| 162838 | | - 233, /* (76) orconf ::= OR resolvetype */ |
| 162839 | | - 234, /* (77) resolvetype ::= IGNORE */ |
| 162840 | | - 234, /* (78) resolvetype ::= REPLACE */ |
| 162841 | | - 189, /* (79) cmd ::= DROP TABLE ifexists fullname */ |
| 162842 | | - 236, /* (80) ifexists ::= IF EXISTS */ |
| 162843 | | - 236, /* (81) ifexists ::= */ |
| 162844 | | - 189, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ |
| 162845 | | - 189, /* (83) cmd ::= DROP VIEW ifexists fullname */ |
| 162846 | | - 189, /* (84) cmd ::= select */ |
| 162847 | | - 203, /* (85) select ::= WITH wqlist selectnowith */ |
| 162848 | | - 203, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ |
| 162849 | | - 203, /* (87) select ::= selectnowith */ |
| 162850 | | - 238, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ |
| 162851 | | - 241, /* (89) multiselect_op ::= UNION */ |
| 162852 | | - 241, /* (90) multiselect_op ::= UNION ALL */ |
| 162853 | | - 241, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ |
| 162854 | | - 239, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ |
| 162855 | | - 239, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ |
| 162856 | | - 251, /* (94) values ::= VALUES LP nexprlist RP */ |
| 162857 | | - 251, /* (95) values ::= values COMMA LP nexprlist RP */ |
| 162858 | | - 242, /* (96) distinct ::= DISTINCT */ |
| 162859 | | - 242, /* (97) distinct ::= ALL */ |
| 162860 | | - 242, /* (98) distinct ::= */ |
| 162861 | | - 253, /* (99) sclp ::= */ |
| 162862 | | - 243, /* (100) selcollist ::= sclp scanpt expr scanpt as */ |
| 162863 | | - 243, /* (101) selcollist ::= sclp scanpt STAR */ |
| 162864 | | - 243, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ |
| 162865 | | - 254, /* (103) as ::= AS nm */ |
| 162866 | | - 254, /* (104) as ::= */ |
| 162867 | | - 244, /* (105) from ::= */ |
| 162868 | | - 244, /* (106) from ::= FROM seltablist */ |
| 162869 | | - 256, /* (107) stl_prefix ::= seltablist joinop */ |
| 162870 | | - 256, /* (108) stl_prefix ::= */ |
| 162871 | | - 255, /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ |
| 162872 | | - 255, /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ |
| 162873 | | - 255, /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ |
| 162874 | | - 255, /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ |
| 162875 | | - 199, /* (113) dbnm ::= */ |
| 162876 | | - 199, /* (114) dbnm ::= DOT nm */ |
| 162877 | | - 237, /* (115) fullname ::= nm */ |
| 162878 | | - 237, /* (116) fullname ::= nm DOT nm */ |
| 162879 | | - 262, /* (117) xfullname ::= nm */ |
| 162880 | | - 262, /* (118) xfullname ::= nm DOT nm */ |
| 162881 | | - 262, /* (119) xfullname ::= nm DOT nm AS nm */ |
| 162882 | | - 262, /* (120) xfullname ::= nm AS nm */ |
| 162883 | | - 257, /* (121) joinop ::= COMMA|JOIN */ |
| 162884 | | - 257, /* (122) joinop ::= JOIN_KW JOIN */ |
| 162885 | | - 257, /* (123) joinop ::= JOIN_KW nm JOIN */ |
| 162886 | | - 257, /* (124) joinop ::= JOIN_KW nm nm JOIN */ |
| 162887 | | - 259, /* (125) on_opt ::= ON expr */ |
| 162888 | | - 259, /* (126) on_opt ::= */ |
| 162889 | | - 258, /* (127) indexed_opt ::= */ |
| 162890 | | - 258, /* (128) indexed_opt ::= INDEXED BY nm */ |
| 162891 | | - 258, /* (129) indexed_opt ::= NOT INDEXED */ |
| 162892 | | - 260, /* (130) using_opt ::= USING LP idlist RP */ |
| 162893 | | - 260, /* (131) using_opt ::= */ |
| 162894 | | - 248, /* (132) orderby_opt ::= */ |
| 162895 | | - 248, /* (133) orderby_opt ::= ORDER BY sortlist */ |
| 162896 | | - 230, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ |
| 162897 | | - 230, /* (135) sortlist ::= expr sortorder nulls */ |
| 162898 | | - 218, /* (136) sortorder ::= ASC */ |
| 162899 | | - 218, /* (137) sortorder ::= DESC */ |
| 162900 | | - 218, /* (138) sortorder ::= */ |
| 162901 | | - 264, /* (139) nulls ::= NULLS FIRST */ |
| 162902 | | - 264, /* (140) nulls ::= NULLS LAST */ |
| 162903 | | - 264, /* (141) nulls ::= */ |
| 162904 | | - 246, /* (142) groupby_opt ::= */ |
| 162905 | | - 246, /* (143) groupby_opt ::= GROUP BY nexprlist */ |
| 162906 | | - 247, /* (144) having_opt ::= */ |
| 162907 | | - 247, /* (145) having_opt ::= HAVING expr */ |
| 162908 | | - 249, /* (146) limit_opt ::= */ |
| 162909 | | - 249, /* (147) limit_opt ::= LIMIT expr */ |
| 162910 | | - 249, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ |
| 162911 | | - 249, /* (149) limit_opt ::= LIMIT expr COMMA expr */ |
| 162912 | | - 189, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ |
| 162913 | | - 245, /* (151) where_opt ::= */ |
| 162914 | | - 245, /* (152) where_opt ::= WHERE expr */ |
| 162915 | | - 266, /* (153) where_opt_ret ::= */ |
| 162916 | | - 266, /* (154) where_opt_ret ::= WHERE expr */ |
| 162917 | | - 266, /* (155) where_opt_ret ::= RETURNING selcollist */ |
| 162918 | | - 266, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ |
| 162919 | | - 189, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ |
| 162920 | | - 267, /* (158) setlist ::= setlist COMMA nm EQ expr */ |
| 162921 | | - 267, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ |
| 162922 | | - 267, /* (160) setlist ::= nm EQ expr */ |
| 162923 | | - 267, /* (161) setlist ::= LP idlist RP EQ expr */ |
| 162924 | | - 189, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ |
| 162925 | | - 189, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ |
| 162926 | | - 270, /* (164) upsert ::= */ |
| 162927 | | - 270, /* (165) upsert ::= RETURNING selcollist */ |
| 162928 | | - 270, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ |
| 162929 | | - 270, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ |
| 162930 | | - 270, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ |
| 162931 | | - 270, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ |
| 162932 | | - 271, /* (170) returning ::= RETURNING selcollist */ |
| 162933 | | - 268, /* (171) insert_cmd ::= INSERT orconf */ |
| 162934 | | - 268, /* (172) insert_cmd ::= REPLACE */ |
| 162935 | | - 269, /* (173) idlist_opt ::= */ |
| 162936 | | - 269, /* (174) idlist_opt ::= LP idlist RP */ |
| 162937 | | - 263, /* (175) idlist ::= idlist COMMA nm */ |
| 162938 | | - 263, /* (176) idlist ::= nm */ |
| 162939 | | - 216, /* (177) expr ::= LP expr RP */ |
| 162940 | | - 216, /* (178) expr ::= ID|INDEXED */ |
| 162941 | | - 216, /* (179) expr ::= JOIN_KW */ |
| 162942 | | - 216, /* (180) expr ::= nm DOT nm */ |
| 162943 | | - 216, /* (181) expr ::= nm DOT nm DOT nm */ |
| 162944 | | - 215, /* (182) term ::= NULL|FLOAT|BLOB */ |
| 162945 | | - 215, /* (183) term ::= STRING */ |
| 162946 | | - 215, /* (184) term ::= INTEGER */ |
| 162947 | | - 216, /* (185) expr ::= VARIABLE */ |
| 162948 | | - 216, /* (186) expr ::= expr COLLATE ID|STRING */ |
| 162949 | | - 216, /* (187) expr ::= CAST LP expr AS typetoken RP */ |
| 162950 | | - 216, /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */ |
| 162951 | | - 216, /* (189) expr ::= ID|INDEXED LP STAR RP */ |
| 162952 | | - 216, /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ |
| 162953 | | - 216, /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */ |
| 162954 | | - 215, /* (192) term ::= CTIME_KW */ |
| 162955 | | - 216, /* (193) expr ::= LP nexprlist COMMA expr RP */ |
| 162956 | | - 216, /* (194) expr ::= expr AND expr */ |
| 162957 | | - 216, /* (195) expr ::= expr OR expr */ |
| 162958 | | - 216, /* (196) expr ::= expr LT|GT|GE|LE expr */ |
| 162959 | | - 216, /* (197) expr ::= expr EQ|NE expr */ |
| 162960 | | - 216, /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ |
| 162961 | | - 216, /* (199) expr ::= expr PLUS|MINUS expr */ |
| 162962 | | - 216, /* (200) expr ::= expr STAR|SLASH|REM expr */ |
| 162963 | | - 216, /* (201) expr ::= expr CONCAT expr */ |
| 162964 | | - 273, /* (202) likeop ::= NOT LIKE_KW|MATCH */ |
| 162965 | | - 216, /* (203) expr ::= expr likeop expr */ |
| 162966 | | - 216, /* (204) expr ::= expr likeop expr ESCAPE expr */ |
| 162967 | | - 216, /* (205) expr ::= expr ISNULL|NOTNULL */ |
| 162968 | | - 216, /* (206) expr ::= expr NOT NULL */ |
| 162969 | | - 216, /* (207) expr ::= expr IS expr */ |
| 162970 | | - 216, /* (208) expr ::= expr IS NOT expr */ |
| 162971 | | - 216, /* (209) expr ::= NOT expr */ |
| 162972 | | - 216, /* (210) expr ::= BITNOT expr */ |
| 162973 | | - 216, /* (211) expr ::= PLUS|MINUS expr */ |
| 162974 | | - 274, /* (212) between_op ::= BETWEEN */ |
| 162975 | | - 274, /* (213) between_op ::= NOT BETWEEN */ |
| 162976 | | - 216, /* (214) expr ::= expr between_op expr AND expr */ |
| 162977 | | - 275, /* (215) in_op ::= IN */ |
| 162978 | | - 275, /* (216) in_op ::= NOT IN */ |
| 162979 | | - 216, /* (217) expr ::= expr in_op LP exprlist RP */ |
| 162980 | | - 216, /* (218) expr ::= LP select RP */ |
| 162981 | | - 216, /* (219) expr ::= expr in_op LP select RP */ |
| 162982 | | - 216, /* (220) expr ::= expr in_op nm dbnm paren_exprlist */ |
| 162983 | | - 216, /* (221) expr ::= EXISTS LP select RP */ |
| 162984 | | - 216, /* (222) expr ::= CASE case_operand case_exprlist case_else END */ |
| 162985 | | - 278, /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 162986 | | - 278, /* (224) case_exprlist ::= WHEN expr THEN expr */ |
| 162987 | | - 279, /* (225) case_else ::= ELSE expr */ |
| 162988 | | - 279, /* (226) case_else ::= */ |
| 162989 | | - 277, /* (227) case_operand ::= expr */ |
| 162990 | | - 277, /* (228) case_operand ::= */ |
| 162991 | | - 261, /* (229) exprlist ::= */ |
| 162992 | | - 252, /* (230) nexprlist ::= nexprlist COMMA expr */ |
| 162993 | | - 252, /* (231) nexprlist ::= expr */ |
| 162994 | | - 276, /* (232) paren_exprlist ::= */ |
| 162995 | | - 276, /* (233) paren_exprlist ::= LP exprlist RP */ |
| 162996 | | - 189, /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 162997 | | - 280, /* (235) uniqueflag ::= UNIQUE */ |
| 162998 | | - 280, /* (236) uniqueflag ::= */ |
| 162999 | | - 220, /* (237) eidlist_opt ::= */ |
| 163000 | | - 220, /* (238) eidlist_opt ::= LP eidlist RP */ |
| 163001 | | - 231, /* (239) eidlist ::= eidlist COMMA nm collate sortorder */ |
| 163002 | | - 231, /* (240) eidlist ::= nm collate sortorder */ |
| 163003 | | - 281, /* (241) collate ::= */ |
| 163004 | | - 281, /* (242) collate ::= COLLATE ID|STRING */ |
| 163005 | | - 189, /* (243) cmd ::= DROP INDEX ifexists fullname */ |
| 163006 | | - 189, /* (244) cmd ::= VACUUM vinto */ |
| 163007 | | - 189, /* (245) cmd ::= VACUUM nm vinto */ |
| 163008 | | - 282, /* (246) vinto ::= INTO expr */ |
| 163009 | | - 282, /* (247) vinto ::= */ |
| 163010 | | - 189, /* (248) cmd ::= PRAGMA nm dbnm */ |
| 163011 | | - 189, /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 163012 | | - 189, /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 163013 | | - 189, /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 163014 | | - 189, /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 163015 | | - 210, /* (253) plus_num ::= PLUS INTEGER|FLOAT */ |
| 163016 | | - 211, /* (254) minus_num ::= MINUS INTEGER|FLOAT */ |
| 163017 | | - 189, /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 163018 | | - 284, /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 163019 | | - 286, /* (257) trigger_time ::= BEFORE|AFTER */ |
| 163020 | | - 286, /* (258) trigger_time ::= INSTEAD OF */ |
| 163021 | | - 286, /* (259) trigger_time ::= */ |
| 163022 | | - 287, /* (260) trigger_event ::= DELETE|INSERT */ |
| 163023 | | - 287, /* (261) trigger_event ::= UPDATE */ |
| 163024 | | - 287, /* (262) trigger_event ::= UPDATE OF idlist */ |
| 163025 | | - 289, /* (263) when_clause ::= */ |
| 163026 | | - 289, /* (264) when_clause ::= WHEN expr */ |
| 163027 | | - 285, /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 163028 | | - 285, /* (266) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 163029 | | - 291, /* (267) trnm ::= nm DOT nm */ |
| 163030 | | - 292, /* (268) tridxby ::= INDEXED BY nm */ |
| 163031 | | - 292, /* (269) tridxby ::= NOT INDEXED */ |
| 163032 | | - 290, /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 163033 | | - 290, /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 163034 | | - 290, /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 163035 | | - 290, /* (273) trigger_cmd ::= scanpt select scanpt */ |
| 163036 | | - 216, /* (274) expr ::= RAISE LP IGNORE RP */ |
| 163037 | | - 216, /* (275) expr ::= RAISE LP raisetype COMMA nm RP */ |
| 163038 | | - 235, /* (276) raisetype ::= ROLLBACK */ |
| 163039 | | - 235, /* (277) raisetype ::= ABORT */ |
| 163040 | | - 235, /* (278) raisetype ::= FAIL */ |
| 163041 | | - 189, /* (279) cmd ::= DROP TRIGGER ifexists fullname */ |
| 163042 | | - 189, /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 163043 | | - 189, /* (281) cmd ::= DETACH database_kw_opt expr */ |
| 163044 | | - 294, /* (282) key_opt ::= */ |
| 163045 | | - 294, /* (283) key_opt ::= KEY expr */ |
| 163046 | | - 189, /* (284) cmd ::= REINDEX */ |
| 163047 | | - 189, /* (285) cmd ::= REINDEX nm dbnm */ |
| 163048 | | - 189, /* (286) cmd ::= ANALYZE */ |
| 163049 | | - 189, /* (287) cmd ::= ANALYZE nm dbnm */ |
| 163050 | | - 189, /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 163051 | | - 189, /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 163052 | | - 189, /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 163053 | | - 295, /* (291) add_column_fullname ::= fullname */ |
| 163054 | | - 189, /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 163055 | | - 189, /* (293) cmd ::= create_vtab */ |
| 163056 | | - 189, /* (294) cmd ::= create_vtab LP vtabarglist RP */ |
| 163057 | | - 297, /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 163058 | | - 299, /* (296) vtabarg ::= */ |
| 163059 | | - 300, /* (297) vtabargtoken ::= ANY */ |
| 163060 | | - 300, /* (298) vtabargtoken ::= lp anylist RP */ |
| 163061 | | - 301, /* (299) lp ::= LP */ |
| 163062 | | - 265, /* (300) with ::= WITH wqlist */ |
| 163063 | | - 265, /* (301) with ::= WITH RECURSIVE wqlist */ |
| 163064 | | - 304, /* (302) wqas ::= AS */ |
| 163065 | | - 304, /* (303) wqas ::= AS MATERIALIZED */ |
| 163066 | | - 304, /* (304) wqas ::= AS NOT MATERIALIZED */ |
| 163067 | | - 303, /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 163068 | | - 240, /* (306) wqlist ::= wqitem */ |
| 163069 | | - 240, /* (307) wqlist ::= wqlist COMMA wqitem */ |
| 163070 | | - 305, /* (308) windowdefn_list ::= windowdefn */ |
| 163071 | | - 305, /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 163072 | | - 306, /* (310) windowdefn ::= nm AS LP window RP */ |
| 163073 | | - 307, /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163074 | | - 307, /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163075 | | - 307, /* (313) window ::= ORDER BY sortlist frame_opt */ |
| 163076 | | - 307, /* (314) window ::= nm ORDER BY sortlist frame_opt */ |
| 163077 | | - 307, /* (315) window ::= frame_opt */ |
| 163078 | | - 307, /* (316) window ::= nm frame_opt */ |
| 163079 | | - 308, /* (317) frame_opt ::= */ |
| 163080 | | - 308, /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 163081 | | - 308, /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 163082 | | - 312, /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 163083 | | - 314, /* (321) frame_bound_s ::= frame_bound */ |
| 163084 | | - 314, /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 163085 | | - 315, /* (323) frame_bound_e ::= frame_bound */ |
| 163086 | | - 315, /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 163087 | | - 313, /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 163088 | | - 313, /* (326) frame_bound ::= CURRENT ROW */ |
| 163089 | | - 316, /* (327) frame_exclude_opt ::= */ |
| 163090 | | - 316, /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 163091 | | - 317, /* (329) frame_exclude ::= NO OTHERS */ |
| 163092 | | - 317, /* (330) frame_exclude ::= CURRENT ROW */ |
| 163093 | | - 317, /* (331) frame_exclude ::= GROUP|TIES */ |
| 163094 | | - 250, /* (332) window_clause ::= WINDOW windowdefn_list */ |
| 163095 | | - 272, /* (333) filter_over ::= filter_clause over_clause */ |
| 163096 | | - 272, /* (334) filter_over ::= over_clause */ |
| 163097 | | - 272, /* (335) filter_over ::= filter_clause */ |
| 163098 | | - 311, /* (336) over_clause ::= OVER LP window RP */ |
| 163099 | | - 311, /* (337) over_clause ::= OVER nm */ |
| 163100 | | - 310, /* (338) filter_clause ::= FILTER LP WHERE expr RP */ |
| 163101 | | - 184, /* (339) input ::= cmdlist */ |
| 163102 | | - 185, /* (340) cmdlist ::= cmdlist ecmd */ |
| 163103 | | - 185, /* (341) cmdlist ::= ecmd */ |
| 163104 | | - 186, /* (342) ecmd ::= SEMI */ |
| 163105 | | - 186, /* (343) ecmd ::= cmdx SEMI */ |
| 163106 | | - 186, /* (344) ecmd ::= explain cmdx SEMI */ |
| 163107 | | - 191, /* (345) trans_opt ::= */ |
| 163108 | | - 191, /* (346) trans_opt ::= TRANSACTION */ |
| 163109 | | - 191, /* (347) trans_opt ::= TRANSACTION nm */ |
| 163110 | | - 193, /* (348) savepoint_opt ::= SAVEPOINT */ |
| 163111 | | - 193, /* (349) savepoint_opt ::= */ |
| 163112 | | - 189, /* (350) cmd ::= create_table create_table_args */ |
| 163113 | | - 202, /* (351) table_option_set ::= table_option */ |
| 163114 | | - 200, /* (352) columnlist ::= columnlist COMMA columnname carglist */ |
| 163115 | | - 200, /* (353) columnlist ::= columnname carglist */ |
| 163116 | | - 192, /* (354) nm ::= ID|INDEXED */ |
| 163117 | | - 192, /* (355) nm ::= STRING */ |
| 163118 | | - 192, /* (356) nm ::= JOIN_KW */ |
| 163119 | | - 207, /* (357) typetoken ::= typename */ |
| 163120 | | - 208, /* (358) typename ::= ID|STRING */ |
| 163121 | | - 209, /* (359) signed ::= plus_num */ |
| 163122 | | - 209, /* (360) signed ::= minus_num */ |
| 163123 | | - 206, /* (361) carglist ::= carglist ccons */ |
| 163124 | | - 206, /* (362) carglist ::= */ |
| 163125 | | - 214, /* (363) ccons ::= NULL onconf */ |
| 163126 | | - 214, /* (364) ccons ::= GENERATED ALWAYS AS generated */ |
| 163127 | | - 214, /* (365) ccons ::= AS generated */ |
| 163128 | | - 201, /* (366) conslist_opt ::= COMMA conslist */ |
| 163129 | | - 227, /* (367) conslist ::= conslist tconscomma tcons */ |
| 163130 | | - 227, /* (368) conslist ::= tcons */ |
| 163131 | | - 228, /* (369) tconscomma ::= */ |
| 163132 | | - 232, /* (370) defer_subclause_opt ::= defer_subclause */ |
| 163133 | | - 234, /* (371) resolvetype ::= raisetype */ |
| 163134 | | - 238, /* (372) selectnowith ::= oneselect */ |
| 163135 | | - 239, /* (373) oneselect ::= values */ |
| 163136 | | - 253, /* (374) sclp ::= selcollist COMMA */ |
| 163137 | | - 254, /* (375) as ::= ID|STRING */ |
| 163138 | | - 271, /* (376) returning ::= */ |
| 163139 | | - 216, /* (377) expr ::= term */ |
| 163140 | | - 273, /* (378) likeop ::= LIKE_KW|MATCH */ |
| 163141 | | - 261, /* (379) exprlist ::= nexprlist */ |
| 163142 | | - 283, /* (380) nmnum ::= plus_num */ |
| 163143 | | - 283, /* (381) nmnum ::= nm */ |
| 163144 | | - 283, /* (382) nmnum ::= ON */ |
| 163145 | | - 283, /* (383) nmnum ::= DELETE */ |
| 163146 | | - 283, /* (384) nmnum ::= DEFAULT */ |
| 163147 | | - 210, /* (385) plus_num ::= INTEGER|FLOAT */ |
| 163148 | | - 288, /* (386) foreach_clause ::= */ |
| 163149 | | - 288, /* (387) foreach_clause ::= FOR EACH ROW */ |
| 163150 | | - 291, /* (388) trnm ::= nm */ |
| 163151 | | - 292, /* (389) tridxby ::= */ |
| 163152 | | - 293, /* (390) database_kw_opt ::= DATABASE */ |
| 163153 | | - 293, /* (391) database_kw_opt ::= */ |
| 163154 | | - 296, /* (392) kwcolumn_opt ::= */ |
| 163155 | | - 296, /* (393) kwcolumn_opt ::= COLUMNKW */ |
| 163156 | | - 298, /* (394) vtabarglist ::= vtabarg */ |
| 163157 | | - 298, /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 163158 | | - 299, /* (396) vtabarg ::= vtabarg vtabargtoken */ |
| 163159 | | - 302, /* (397) anylist ::= */ |
| 163160 | | - 302, /* (398) anylist ::= anylist LP anylist RP */ |
| 163161 | | - 302, /* (399) anylist ::= anylist ANY */ |
| 163162 | | - 265, /* (400) with ::= */ |
| 162994 | + 189, /* (0) explain ::= EXPLAIN */ |
| 162995 | + 189, /* (1) explain ::= EXPLAIN QUERY PLAN */ |
| 162996 | + 188, /* (2) cmdx ::= cmd */ |
| 162997 | + 190, /* (3) cmd ::= BEGIN transtype trans_opt */ |
| 162998 | + 191, /* (4) transtype ::= */ |
| 162999 | + 191, /* (5) transtype ::= DEFERRED */ |
| 163000 | + 191, /* (6) transtype ::= IMMEDIATE */ |
| 163001 | + 191, /* (7) transtype ::= EXCLUSIVE */ |
| 163002 | + 190, /* (8) cmd ::= COMMIT|END trans_opt */ |
| 163003 | + 190, /* (9) cmd ::= ROLLBACK trans_opt */ |
| 163004 | + 190, /* (10) cmd ::= SAVEPOINT nm */ |
| 163005 | + 190, /* (11) cmd ::= RELEASE savepoint_opt nm */ |
| 163006 | + 190, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ |
| 163007 | + 195, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ |
| 163008 | + 197, /* (14) createkw ::= CREATE */ |
| 163009 | + 199, /* (15) ifnotexists ::= */ |
| 163010 | + 199, /* (16) ifnotexists ::= IF NOT EXISTS */ |
| 163011 | + 198, /* (17) temp ::= TEMP */ |
| 163012 | + 198, /* (18) temp ::= */ |
| 163013 | + 196, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ |
| 163014 | + 196, /* (20) create_table_args ::= AS select */ |
| 163015 | + 203, /* (21) table_option_set ::= */ |
| 163016 | + 203, /* (22) table_option_set ::= table_option_set COMMA table_option */ |
| 163017 | + 205, /* (23) table_option ::= WITHOUT nm */ |
| 163018 | + 205, /* (24) table_option ::= nm */ |
| 163019 | + 206, /* (25) columnname ::= nm typetoken */ |
| 163020 | + 208, /* (26) typetoken ::= */ |
| 163021 | + 208, /* (27) typetoken ::= typename LP signed RP */ |
| 163022 | + 208, /* (28) typetoken ::= typename LP signed COMMA signed RP */ |
| 163023 | + 209, /* (29) typename ::= typename ID|STRING */ |
| 163024 | + 213, /* (30) scanpt ::= */ |
| 163025 | + 214, /* (31) scantok ::= */ |
| 163026 | + 215, /* (32) ccons ::= CONSTRAINT nm */ |
| 163027 | + 215, /* (33) ccons ::= DEFAULT scantok term */ |
| 163028 | + 215, /* (34) ccons ::= DEFAULT LP expr RP */ |
| 163029 | + 215, /* (35) ccons ::= DEFAULT PLUS scantok term */ |
| 163030 | + 215, /* (36) ccons ::= DEFAULT MINUS scantok term */ |
| 163031 | + 215, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ |
| 163032 | + 215, /* (38) ccons ::= NOT NULL onconf */ |
| 163033 | + 215, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ |
| 163034 | + 215, /* (40) ccons ::= UNIQUE onconf */ |
| 163035 | + 215, /* (41) ccons ::= CHECK LP expr RP */ |
| 163036 | + 215, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ |
| 163037 | + 215, /* (43) ccons ::= defer_subclause */ |
| 163038 | + 215, /* (44) ccons ::= COLLATE ID|STRING */ |
| 163039 | + 224, /* (45) generated ::= LP expr RP */ |
| 163040 | + 224, /* (46) generated ::= LP expr RP ID */ |
| 163041 | + 220, /* (47) autoinc ::= */ |
| 163042 | + 220, /* (48) autoinc ::= AUTOINCR */ |
| 163043 | + 222, /* (49) refargs ::= */ |
| 163044 | + 222, /* (50) refargs ::= refargs refarg */ |
| 163045 | + 225, /* (51) refarg ::= MATCH nm */ |
| 163046 | + 225, /* (52) refarg ::= ON INSERT refact */ |
| 163047 | + 225, /* (53) refarg ::= ON DELETE refact */ |
| 163048 | + 225, /* (54) refarg ::= ON UPDATE refact */ |
| 163049 | + 226, /* (55) refact ::= SET NULL */ |
| 163050 | + 226, /* (56) refact ::= SET DEFAULT */ |
| 163051 | + 226, /* (57) refact ::= CASCADE */ |
| 163052 | + 226, /* (58) refact ::= RESTRICT */ |
| 163053 | + 226, /* (59) refact ::= NO ACTION */ |
| 163054 | + 223, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ |
| 163055 | + 223, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ |
| 163056 | + 227, /* (62) init_deferred_pred_opt ::= */ |
| 163057 | + 227, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ |
| 163058 | + 227, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ |
| 163059 | + 202, /* (65) conslist_opt ::= */ |
| 163060 | + 229, /* (66) tconscomma ::= COMMA */ |
| 163061 | + 230, /* (67) tcons ::= CONSTRAINT nm */ |
| 163062 | + 230, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ |
| 163063 | + 230, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ |
| 163064 | + 230, /* (70) tcons ::= CHECK LP expr RP onconf */ |
| 163065 | + 230, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ |
| 163066 | + 233, /* (72) defer_subclause_opt ::= */ |
| 163067 | + 218, /* (73) onconf ::= */ |
| 163068 | + 218, /* (74) onconf ::= ON CONFLICT resolvetype */ |
| 163069 | + 234, /* (75) orconf ::= */ |
| 163070 | + 234, /* (76) orconf ::= OR resolvetype */ |
| 163071 | + 235, /* (77) resolvetype ::= IGNORE */ |
| 163072 | + 235, /* (78) resolvetype ::= REPLACE */ |
| 163073 | + 190, /* (79) cmd ::= DROP TABLE ifexists fullname */ |
| 163074 | + 237, /* (80) ifexists ::= IF EXISTS */ |
| 163075 | + 237, /* (81) ifexists ::= */ |
| 163076 | + 190, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ |
| 163077 | + 190, /* (83) cmd ::= DROP VIEW ifexists fullname */ |
| 163078 | + 190, /* (84) cmd ::= select */ |
| 163079 | + 204, /* (85) select ::= WITH wqlist selectnowith */ |
| 163080 | + 204, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ |
| 163081 | + 204, /* (87) select ::= selectnowith */ |
| 163082 | + 239, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ |
| 163083 | + 242, /* (89) multiselect_op ::= UNION */ |
| 163084 | + 242, /* (90) multiselect_op ::= UNION ALL */ |
| 163085 | + 242, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ |
| 163086 | + 240, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ |
| 163087 | + 240, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ |
| 163088 | + 252, /* (94) values ::= VALUES LP nexprlist RP */ |
| 163089 | + 252, /* (95) values ::= values COMMA LP nexprlist RP */ |
| 163090 | + 243, /* (96) distinct ::= DISTINCT */ |
| 163091 | + 243, /* (97) distinct ::= ALL */ |
| 163092 | + 243, /* (98) distinct ::= */ |
| 163093 | + 254, /* (99) sclp ::= */ |
| 163094 | + 244, /* (100) selcollist ::= sclp scanpt expr scanpt as */ |
| 163095 | + 244, /* (101) selcollist ::= sclp scanpt STAR */ |
| 163096 | + 244, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ |
| 163097 | + 255, /* (103) as ::= AS nm */ |
| 163098 | + 255, /* (104) as ::= */ |
| 163099 | + 245, /* (105) from ::= */ |
| 163100 | + 245, /* (106) from ::= FROM seltablist */ |
| 163101 | + 257, /* (107) stl_prefix ::= seltablist joinop */ |
| 163102 | + 257, /* (108) stl_prefix ::= */ |
| 163103 | + 256, /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ |
| 163104 | + 256, /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ |
| 163105 | + 256, /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ |
| 163106 | + 256, /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ |
| 163107 | + 200, /* (113) dbnm ::= */ |
| 163108 | + 200, /* (114) dbnm ::= DOT nm */ |
| 163109 | + 238, /* (115) fullname ::= nm */ |
| 163110 | + 238, /* (116) fullname ::= nm DOT nm */ |
| 163111 | + 263, /* (117) xfullname ::= nm */ |
| 163112 | + 263, /* (118) xfullname ::= nm DOT nm */ |
| 163113 | + 263, /* (119) xfullname ::= nm DOT nm AS nm */ |
| 163114 | + 263, /* (120) xfullname ::= nm AS nm */ |
| 163115 | + 258, /* (121) joinop ::= COMMA|JOIN */ |
| 163116 | + 258, /* (122) joinop ::= JOIN_KW JOIN */ |
| 163117 | + 258, /* (123) joinop ::= JOIN_KW nm JOIN */ |
| 163118 | + 258, /* (124) joinop ::= JOIN_KW nm nm JOIN */ |
| 163119 | + 260, /* (125) on_opt ::= ON expr */ |
| 163120 | + 260, /* (126) on_opt ::= */ |
| 163121 | + 259, /* (127) indexed_opt ::= */ |
| 163122 | + 259, /* (128) indexed_opt ::= INDEXED BY nm */ |
| 163123 | + 259, /* (129) indexed_opt ::= NOT INDEXED */ |
| 163124 | + 261, /* (130) using_opt ::= USING LP idlist RP */ |
| 163125 | + 261, /* (131) using_opt ::= */ |
| 163126 | + 249, /* (132) orderby_opt ::= */ |
| 163127 | + 249, /* (133) orderby_opt ::= ORDER BY sortlist */ |
| 163128 | + 231, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ |
| 163129 | + 231, /* (135) sortlist ::= expr sortorder nulls */ |
| 163130 | + 219, /* (136) sortorder ::= ASC */ |
| 163131 | + 219, /* (137) sortorder ::= DESC */ |
| 163132 | + 219, /* (138) sortorder ::= */ |
| 163133 | + 265, /* (139) nulls ::= NULLS FIRST */ |
| 163134 | + 265, /* (140) nulls ::= NULLS LAST */ |
| 163135 | + 265, /* (141) nulls ::= */ |
| 163136 | + 247, /* (142) groupby_opt ::= */ |
| 163137 | + 247, /* (143) groupby_opt ::= GROUP BY nexprlist */ |
| 163138 | + 248, /* (144) having_opt ::= */ |
| 163139 | + 248, /* (145) having_opt ::= HAVING expr */ |
| 163140 | + 250, /* (146) limit_opt ::= */ |
| 163141 | + 250, /* (147) limit_opt ::= LIMIT expr */ |
| 163142 | + 250, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ |
| 163143 | + 250, /* (149) limit_opt ::= LIMIT expr COMMA expr */ |
| 163144 | + 190, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ |
| 163145 | + 246, /* (151) where_opt ::= */ |
| 163146 | + 246, /* (152) where_opt ::= WHERE expr */ |
| 163147 | + 267, /* (153) where_opt_ret ::= */ |
| 163148 | + 267, /* (154) where_opt_ret ::= WHERE expr */ |
| 163149 | + 267, /* (155) where_opt_ret ::= RETURNING selcollist */ |
| 163150 | + 267, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ |
| 163151 | + 190, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ |
| 163152 | + 268, /* (158) setlist ::= setlist COMMA nm EQ expr */ |
| 163153 | + 268, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ |
| 163154 | + 268, /* (160) setlist ::= nm EQ expr */ |
| 163155 | + 268, /* (161) setlist ::= LP idlist RP EQ expr */ |
| 163156 | + 190, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ |
| 163157 | + 190, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ |
| 163158 | + 271, /* (164) upsert ::= */ |
| 163159 | + 271, /* (165) upsert ::= RETURNING selcollist */ |
| 163160 | + 271, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ |
| 163161 | + 271, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ |
| 163162 | + 271, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ |
| 163163 | + 271, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ |
| 163164 | + 272, /* (170) returning ::= RETURNING selcollist */ |
| 163165 | + 269, /* (171) insert_cmd ::= INSERT orconf */ |
| 163166 | + 269, /* (172) insert_cmd ::= REPLACE */ |
| 163167 | + 270, /* (173) idlist_opt ::= */ |
| 163168 | + 270, /* (174) idlist_opt ::= LP idlist RP */ |
| 163169 | + 264, /* (175) idlist ::= idlist COMMA nm */ |
| 163170 | + 264, /* (176) idlist ::= nm */ |
| 163171 | + 217, /* (177) expr ::= LP expr RP */ |
| 163172 | + 217, /* (178) expr ::= ID|INDEXED */ |
| 163173 | + 217, /* (179) expr ::= JOIN_KW */ |
| 163174 | + 217, /* (180) expr ::= nm DOT nm */ |
| 163175 | + 217, /* (181) expr ::= nm DOT nm DOT nm */ |
| 163176 | + 216, /* (182) term ::= NULL|FLOAT|BLOB */ |
| 163177 | + 216, /* (183) term ::= STRING */ |
| 163178 | + 216, /* (184) term ::= INTEGER */ |
| 163179 | + 217, /* (185) expr ::= VARIABLE */ |
| 163180 | + 217, /* (186) expr ::= expr COLLATE ID|STRING */ |
| 163181 | + 217, /* (187) expr ::= CAST LP expr AS typetoken RP */ |
| 163182 | + 217, /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */ |
| 163183 | + 217, /* (189) expr ::= ID|INDEXED LP STAR RP */ |
| 163184 | + 217, /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ |
| 163185 | + 217, /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */ |
| 163186 | + 216, /* (192) term ::= CTIME_KW */ |
| 163187 | + 217, /* (193) expr ::= LP nexprlist COMMA expr RP */ |
| 163188 | + 217, /* (194) expr ::= expr AND expr */ |
| 163189 | + 217, /* (195) expr ::= expr OR expr */ |
| 163190 | + 217, /* (196) expr ::= expr LT|GT|GE|LE expr */ |
| 163191 | + 217, /* (197) expr ::= expr EQ|NE expr */ |
| 163192 | + 217, /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ |
| 163193 | + 217, /* (199) expr ::= expr PLUS|MINUS expr */ |
| 163194 | + 217, /* (200) expr ::= expr STAR|SLASH|REM expr */ |
| 163195 | + 217, /* (201) expr ::= expr CONCAT expr */ |
| 163196 | + 274, /* (202) likeop ::= NOT LIKE_KW|MATCH */ |
| 163197 | + 217, /* (203) expr ::= expr likeop expr */ |
| 163198 | + 217, /* (204) expr ::= expr likeop expr ESCAPE expr */ |
| 163199 | + 217, /* (205) expr ::= expr ISNULL|NOTNULL */ |
| 163200 | + 217, /* (206) expr ::= expr NOT NULL */ |
| 163201 | + 217, /* (207) expr ::= expr IS expr */ |
| 163202 | + 217, /* (208) expr ::= expr IS NOT expr */ |
| 163203 | + 217, /* (209) expr ::= NOT expr */ |
| 163204 | + 217, /* (210) expr ::= BITNOT expr */ |
| 163205 | + 217, /* (211) expr ::= PLUS|MINUS expr */ |
| 163206 | + 217, /* (212) expr ::= expr PTR expr */ |
| 163207 | + 275, /* (213) between_op ::= BETWEEN */ |
| 163208 | + 275, /* (214) between_op ::= NOT BETWEEN */ |
| 163209 | + 217, /* (215) expr ::= expr between_op expr AND expr */ |
| 163210 | + 276, /* (216) in_op ::= IN */ |
| 163211 | + 276, /* (217) in_op ::= NOT IN */ |
| 163212 | + 217, /* (218) expr ::= expr in_op LP exprlist RP */ |
| 163213 | + 217, /* (219) expr ::= LP select RP */ |
| 163214 | + 217, /* (220) expr ::= expr in_op LP select RP */ |
| 163215 | + 217, /* (221) expr ::= expr in_op nm dbnm paren_exprlist */ |
| 163216 | + 217, /* (222) expr ::= EXISTS LP select RP */ |
| 163217 | + 217, /* (223) expr ::= CASE case_operand case_exprlist case_else END */ |
| 163218 | + 279, /* (224) case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 163219 | + 279, /* (225) case_exprlist ::= WHEN expr THEN expr */ |
| 163220 | + 280, /* (226) case_else ::= ELSE expr */ |
| 163221 | + 280, /* (227) case_else ::= */ |
| 163222 | + 278, /* (228) case_operand ::= expr */ |
| 163223 | + 278, /* (229) case_operand ::= */ |
| 163224 | + 262, /* (230) exprlist ::= */ |
| 163225 | + 253, /* (231) nexprlist ::= nexprlist COMMA expr */ |
| 163226 | + 253, /* (232) nexprlist ::= expr */ |
| 163227 | + 277, /* (233) paren_exprlist ::= */ |
| 163228 | + 277, /* (234) paren_exprlist ::= LP exprlist RP */ |
| 163229 | + 190, /* (235) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 163230 | + 281, /* (236) uniqueflag ::= UNIQUE */ |
| 163231 | + 281, /* (237) uniqueflag ::= */ |
| 163232 | + 221, /* (238) eidlist_opt ::= */ |
| 163233 | + 221, /* (239) eidlist_opt ::= LP eidlist RP */ |
| 163234 | + 232, /* (240) eidlist ::= eidlist COMMA nm collate sortorder */ |
| 163235 | + 232, /* (241) eidlist ::= nm collate sortorder */ |
| 163236 | + 282, /* (242) collate ::= */ |
| 163237 | + 282, /* (243) collate ::= COLLATE ID|STRING */ |
| 163238 | + 190, /* (244) cmd ::= DROP INDEX ifexists fullname */ |
| 163239 | + 190, /* (245) cmd ::= VACUUM vinto */ |
| 163240 | + 190, /* (246) cmd ::= VACUUM nm vinto */ |
| 163241 | + 283, /* (247) vinto ::= INTO expr */ |
| 163242 | + 283, /* (248) vinto ::= */ |
| 163243 | + 190, /* (249) cmd ::= PRAGMA nm dbnm */ |
| 163244 | + 190, /* (250) cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 163245 | + 190, /* (251) cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 163246 | + 190, /* (252) cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 163247 | + 190, /* (253) cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 163248 | + 211, /* (254) plus_num ::= PLUS INTEGER|FLOAT */ |
| 163249 | + 212, /* (255) minus_num ::= MINUS INTEGER|FLOAT */ |
| 163250 | + 190, /* (256) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 163251 | + 285, /* (257) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 163252 | + 287, /* (258) trigger_time ::= BEFORE|AFTER */ |
| 163253 | + 287, /* (259) trigger_time ::= INSTEAD OF */ |
| 163254 | + 287, /* (260) trigger_time ::= */ |
| 163255 | + 288, /* (261) trigger_event ::= DELETE|INSERT */ |
| 163256 | + 288, /* (262) trigger_event ::= UPDATE */ |
| 163257 | + 288, /* (263) trigger_event ::= UPDATE OF idlist */ |
| 163258 | + 290, /* (264) when_clause ::= */ |
| 163259 | + 290, /* (265) when_clause ::= WHEN expr */ |
| 163260 | + 286, /* (266) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 163261 | + 286, /* (267) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 163262 | + 292, /* (268) trnm ::= nm DOT nm */ |
| 163263 | + 293, /* (269) tridxby ::= INDEXED BY nm */ |
| 163264 | + 293, /* (270) tridxby ::= NOT INDEXED */ |
| 163265 | + 291, /* (271) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 163266 | + 291, /* (272) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 163267 | + 291, /* (273) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 163268 | + 291, /* (274) trigger_cmd ::= scanpt select scanpt */ |
| 163269 | + 217, /* (275) expr ::= RAISE LP IGNORE RP */ |
| 163270 | + 217, /* (276) expr ::= RAISE LP raisetype COMMA nm RP */ |
| 163271 | + 236, /* (277) raisetype ::= ROLLBACK */ |
| 163272 | + 236, /* (278) raisetype ::= ABORT */ |
| 163273 | + 236, /* (279) raisetype ::= FAIL */ |
| 163274 | + 190, /* (280) cmd ::= DROP TRIGGER ifexists fullname */ |
| 163275 | + 190, /* (281) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 163276 | + 190, /* (282) cmd ::= DETACH database_kw_opt expr */ |
| 163277 | + 295, /* (283) key_opt ::= */ |
| 163278 | + 295, /* (284) key_opt ::= KEY expr */ |
| 163279 | + 190, /* (285) cmd ::= REINDEX */ |
| 163280 | + 190, /* (286) cmd ::= REINDEX nm dbnm */ |
| 163281 | + 190, /* (287) cmd ::= ANALYZE */ |
| 163282 | + 190, /* (288) cmd ::= ANALYZE nm dbnm */ |
| 163283 | + 190, /* (289) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 163284 | + 190, /* (290) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 163285 | + 190, /* (291) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 163286 | + 296, /* (292) add_column_fullname ::= fullname */ |
| 163287 | + 190, /* (293) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 163288 | + 190, /* (294) cmd ::= create_vtab */ |
| 163289 | + 190, /* (295) cmd ::= create_vtab LP vtabarglist RP */ |
| 163290 | + 298, /* (296) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 163291 | + 300, /* (297) vtabarg ::= */ |
| 163292 | + 301, /* (298) vtabargtoken ::= ANY */ |
| 163293 | + 301, /* (299) vtabargtoken ::= lp anylist RP */ |
| 163294 | + 302, /* (300) lp ::= LP */ |
| 163295 | + 266, /* (301) with ::= WITH wqlist */ |
| 163296 | + 266, /* (302) with ::= WITH RECURSIVE wqlist */ |
| 163297 | + 305, /* (303) wqas ::= AS */ |
| 163298 | + 305, /* (304) wqas ::= AS MATERIALIZED */ |
| 163299 | + 305, /* (305) wqas ::= AS NOT MATERIALIZED */ |
| 163300 | + 304, /* (306) wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 163301 | + 241, /* (307) wqlist ::= wqitem */ |
| 163302 | + 241, /* (308) wqlist ::= wqlist COMMA wqitem */ |
| 163303 | + 306, /* (309) windowdefn_list ::= windowdefn */ |
| 163304 | + 306, /* (310) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 163305 | + 307, /* (311) windowdefn ::= nm AS LP window RP */ |
| 163306 | + 308, /* (312) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163307 | + 308, /* (313) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163308 | + 308, /* (314) window ::= ORDER BY sortlist frame_opt */ |
| 163309 | + 308, /* (315) window ::= nm ORDER BY sortlist frame_opt */ |
| 163310 | + 308, /* (316) window ::= frame_opt */ |
| 163311 | + 308, /* (317) window ::= nm frame_opt */ |
| 163312 | + 309, /* (318) frame_opt ::= */ |
| 163313 | + 309, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 163314 | + 309, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 163315 | + 313, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 163316 | + 315, /* (322) frame_bound_s ::= frame_bound */ |
| 163317 | + 315, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 163318 | + 316, /* (324) frame_bound_e ::= frame_bound */ |
| 163319 | + 316, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 163320 | + 314, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 163321 | + 314, /* (327) frame_bound ::= CURRENT ROW */ |
| 163322 | + 317, /* (328) frame_exclude_opt ::= */ |
| 163323 | + 317, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 163324 | + 318, /* (330) frame_exclude ::= NO OTHERS */ |
| 163325 | + 318, /* (331) frame_exclude ::= CURRENT ROW */ |
| 163326 | + 318, /* (332) frame_exclude ::= GROUP|TIES */ |
| 163327 | + 251, /* (333) window_clause ::= WINDOW windowdefn_list */ |
| 163328 | + 273, /* (334) filter_over ::= filter_clause over_clause */ |
| 163329 | + 273, /* (335) filter_over ::= over_clause */ |
| 163330 | + 273, /* (336) filter_over ::= filter_clause */ |
| 163331 | + 312, /* (337) over_clause ::= OVER LP window RP */ |
| 163332 | + 312, /* (338) over_clause ::= OVER nm */ |
| 163333 | + 311, /* (339) filter_clause ::= FILTER LP WHERE expr RP */ |
| 163334 | + 185, /* (340) input ::= cmdlist */ |
| 163335 | + 186, /* (341) cmdlist ::= cmdlist ecmd */ |
| 163336 | + 186, /* (342) cmdlist ::= ecmd */ |
| 163337 | + 187, /* (343) ecmd ::= SEMI */ |
| 163338 | + 187, /* (344) ecmd ::= cmdx SEMI */ |
| 163339 | + 187, /* (345) ecmd ::= explain cmdx SEMI */ |
| 163340 | + 192, /* (346) trans_opt ::= */ |
| 163341 | + 192, /* (347) trans_opt ::= TRANSACTION */ |
| 163342 | + 192, /* (348) trans_opt ::= TRANSACTION nm */ |
| 163343 | + 194, /* (349) savepoint_opt ::= SAVEPOINT */ |
| 163344 | + 194, /* (350) savepoint_opt ::= */ |
| 163345 | + 190, /* (351) cmd ::= create_table create_table_args */ |
| 163346 | + 203, /* (352) table_option_set ::= table_option */ |
| 163347 | + 201, /* (353) columnlist ::= columnlist COMMA columnname carglist */ |
| 163348 | + 201, /* (354) columnlist ::= columnname carglist */ |
| 163349 | + 193, /* (355) nm ::= ID|INDEXED */ |
| 163350 | + 193, /* (356) nm ::= STRING */ |
| 163351 | + 193, /* (357) nm ::= JOIN_KW */ |
| 163352 | + 208, /* (358) typetoken ::= typename */ |
| 163353 | + 209, /* (359) typename ::= ID|STRING */ |
| 163354 | + 210, /* (360) signed ::= plus_num */ |
| 163355 | + 210, /* (361) signed ::= minus_num */ |
| 163356 | + 207, /* (362) carglist ::= carglist ccons */ |
| 163357 | + 207, /* (363) carglist ::= */ |
| 163358 | + 215, /* (364) ccons ::= NULL onconf */ |
| 163359 | + 215, /* (365) ccons ::= GENERATED ALWAYS AS generated */ |
| 163360 | + 215, /* (366) ccons ::= AS generated */ |
| 163361 | + 202, /* (367) conslist_opt ::= COMMA conslist */ |
| 163362 | + 228, /* (368) conslist ::= conslist tconscomma tcons */ |
| 163363 | + 228, /* (369) conslist ::= tcons */ |
| 163364 | + 229, /* (370) tconscomma ::= */ |
| 163365 | + 233, /* (371) defer_subclause_opt ::= defer_subclause */ |
| 163366 | + 235, /* (372) resolvetype ::= raisetype */ |
| 163367 | + 239, /* (373) selectnowith ::= oneselect */ |
| 163368 | + 240, /* (374) oneselect ::= values */ |
| 163369 | + 254, /* (375) sclp ::= selcollist COMMA */ |
| 163370 | + 255, /* (376) as ::= ID|STRING */ |
| 163371 | + 272, /* (377) returning ::= */ |
| 163372 | + 217, /* (378) expr ::= term */ |
| 163373 | + 274, /* (379) likeop ::= LIKE_KW|MATCH */ |
| 163374 | + 262, /* (380) exprlist ::= nexprlist */ |
| 163375 | + 284, /* (381) nmnum ::= plus_num */ |
| 163376 | + 284, /* (382) nmnum ::= nm */ |
| 163377 | + 284, /* (383) nmnum ::= ON */ |
| 163378 | + 284, /* (384) nmnum ::= DELETE */ |
| 163379 | + 284, /* (385) nmnum ::= DEFAULT */ |
| 163380 | + 211, /* (386) plus_num ::= INTEGER|FLOAT */ |
| 163381 | + 289, /* (387) foreach_clause ::= */ |
| 163382 | + 289, /* (388) foreach_clause ::= FOR EACH ROW */ |
| 163383 | + 292, /* (389) trnm ::= nm */ |
| 163384 | + 293, /* (390) tridxby ::= */ |
| 163385 | + 294, /* (391) database_kw_opt ::= DATABASE */ |
| 163386 | + 294, /* (392) database_kw_opt ::= */ |
| 163387 | + 297, /* (393) kwcolumn_opt ::= */ |
| 163388 | + 297, /* (394) kwcolumn_opt ::= COLUMNKW */ |
| 163389 | + 299, /* (395) vtabarglist ::= vtabarg */ |
| 163390 | + 299, /* (396) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 163391 | + 300, /* (397) vtabarg ::= vtabarg vtabargtoken */ |
| 163392 | + 303, /* (398) anylist ::= */ |
| 163393 | + 303, /* (399) anylist ::= anylist LP anylist RP */ |
| 163394 | + 303, /* (400) anylist ::= anylist ANY */ |
| 163395 | + 266, /* (401) with ::= */ |
| 163163 | 163396 | }; |
| 163164 | 163397 | |
| 163165 | 163398 | /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number |
| 163166 | 163399 | ** of symbols on the right-hand side of that rule. */ |
| 163167 | 163400 | static const signed char yyRuleInfoNRhs[] = { |
| | @@ -163375,199 +163608,200 @@ |
| 163375 | 163608 | -3, /* (207) expr ::= expr IS expr */ |
| 163376 | 163609 | -4, /* (208) expr ::= expr IS NOT expr */ |
| 163377 | 163610 | -2, /* (209) expr ::= NOT expr */ |
| 163378 | 163611 | -2, /* (210) expr ::= BITNOT expr */ |
| 163379 | 163612 | -2, /* (211) expr ::= PLUS|MINUS expr */ |
| 163380 | | - -1, /* (212) between_op ::= BETWEEN */ |
| 163381 | | - -2, /* (213) between_op ::= NOT BETWEEN */ |
| 163382 | | - -5, /* (214) expr ::= expr between_op expr AND expr */ |
| 163383 | | - -1, /* (215) in_op ::= IN */ |
| 163384 | | - -2, /* (216) in_op ::= NOT IN */ |
| 163385 | | - -5, /* (217) expr ::= expr in_op LP exprlist RP */ |
| 163386 | | - -3, /* (218) expr ::= LP select RP */ |
| 163387 | | - -5, /* (219) expr ::= expr in_op LP select RP */ |
| 163388 | | - -5, /* (220) expr ::= expr in_op nm dbnm paren_exprlist */ |
| 163389 | | - -4, /* (221) expr ::= EXISTS LP select RP */ |
| 163390 | | - -5, /* (222) expr ::= CASE case_operand case_exprlist case_else END */ |
| 163391 | | - -5, /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 163392 | | - -4, /* (224) case_exprlist ::= WHEN expr THEN expr */ |
| 163393 | | - -2, /* (225) case_else ::= ELSE expr */ |
| 163394 | | - 0, /* (226) case_else ::= */ |
| 163395 | | - -1, /* (227) case_operand ::= expr */ |
| 163396 | | - 0, /* (228) case_operand ::= */ |
| 163397 | | - 0, /* (229) exprlist ::= */ |
| 163398 | | - -3, /* (230) nexprlist ::= nexprlist COMMA expr */ |
| 163399 | | - -1, /* (231) nexprlist ::= expr */ |
| 163400 | | - 0, /* (232) paren_exprlist ::= */ |
| 163401 | | - -3, /* (233) paren_exprlist ::= LP exprlist RP */ |
| 163402 | | - -12, /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 163403 | | - -1, /* (235) uniqueflag ::= UNIQUE */ |
| 163404 | | - 0, /* (236) uniqueflag ::= */ |
| 163405 | | - 0, /* (237) eidlist_opt ::= */ |
| 163406 | | - -3, /* (238) eidlist_opt ::= LP eidlist RP */ |
| 163407 | | - -5, /* (239) eidlist ::= eidlist COMMA nm collate sortorder */ |
| 163408 | | - -3, /* (240) eidlist ::= nm collate sortorder */ |
| 163409 | | - 0, /* (241) collate ::= */ |
| 163410 | | - -2, /* (242) collate ::= COLLATE ID|STRING */ |
| 163411 | | - -4, /* (243) cmd ::= DROP INDEX ifexists fullname */ |
| 163412 | | - -2, /* (244) cmd ::= VACUUM vinto */ |
| 163413 | | - -3, /* (245) cmd ::= VACUUM nm vinto */ |
| 163414 | | - -2, /* (246) vinto ::= INTO expr */ |
| 163415 | | - 0, /* (247) vinto ::= */ |
| 163416 | | - -3, /* (248) cmd ::= PRAGMA nm dbnm */ |
| 163417 | | - -5, /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 163418 | | - -6, /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 163419 | | - -5, /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 163420 | | - -6, /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 163421 | | - -2, /* (253) plus_num ::= PLUS INTEGER|FLOAT */ |
| 163422 | | - -2, /* (254) minus_num ::= MINUS INTEGER|FLOAT */ |
| 163423 | | - -5, /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 163424 | | - -11, /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 163425 | | - -1, /* (257) trigger_time ::= BEFORE|AFTER */ |
| 163426 | | - -2, /* (258) trigger_time ::= INSTEAD OF */ |
| 163427 | | - 0, /* (259) trigger_time ::= */ |
| 163428 | | - -1, /* (260) trigger_event ::= DELETE|INSERT */ |
| 163429 | | - -1, /* (261) trigger_event ::= UPDATE */ |
| 163430 | | - -3, /* (262) trigger_event ::= UPDATE OF idlist */ |
| 163431 | | - 0, /* (263) when_clause ::= */ |
| 163432 | | - -2, /* (264) when_clause ::= WHEN expr */ |
| 163433 | | - -3, /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 163434 | | - -2, /* (266) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 163435 | | - -3, /* (267) trnm ::= nm DOT nm */ |
| 163436 | | - -3, /* (268) tridxby ::= INDEXED BY nm */ |
| 163437 | | - -2, /* (269) tridxby ::= NOT INDEXED */ |
| 163438 | | - -9, /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 163439 | | - -8, /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 163440 | | - -6, /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 163441 | | - -3, /* (273) trigger_cmd ::= scanpt select scanpt */ |
| 163442 | | - -4, /* (274) expr ::= RAISE LP IGNORE RP */ |
| 163443 | | - -6, /* (275) expr ::= RAISE LP raisetype COMMA nm RP */ |
| 163444 | | - -1, /* (276) raisetype ::= ROLLBACK */ |
| 163445 | | - -1, /* (277) raisetype ::= ABORT */ |
| 163446 | | - -1, /* (278) raisetype ::= FAIL */ |
| 163447 | | - -4, /* (279) cmd ::= DROP TRIGGER ifexists fullname */ |
| 163448 | | - -6, /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 163449 | | - -3, /* (281) cmd ::= DETACH database_kw_opt expr */ |
| 163450 | | - 0, /* (282) key_opt ::= */ |
| 163451 | | - -2, /* (283) key_opt ::= KEY expr */ |
| 163452 | | - -1, /* (284) cmd ::= REINDEX */ |
| 163453 | | - -3, /* (285) cmd ::= REINDEX nm dbnm */ |
| 163454 | | - -1, /* (286) cmd ::= ANALYZE */ |
| 163455 | | - -3, /* (287) cmd ::= ANALYZE nm dbnm */ |
| 163456 | | - -6, /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 163457 | | - -7, /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 163458 | | - -6, /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 163459 | | - -1, /* (291) add_column_fullname ::= fullname */ |
| 163460 | | - -8, /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 163461 | | - -1, /* (293) cmd ::= create_vtab */ |
| 163462 | | - -4, /* (294) cmd ::= create_vtab LP vtabarglist RP */ |
| 163463 | | - -8, /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 163464 | | - 0, /* (296) vtabarg ::= */ |
| 163465 | | - -1, /* (297) vtabargtoken ::= ANY */ |
| 163466 | | - -3, /* (298) vtabargtoken ::= lp anylist RP */ |
| 163467 | | - -1, /* (299) lp ::= LP */ |
| 163468 | | - -2, /* (300) with ::= WITH wqlist */ |
| 163469 | | - -3, /* (301) with ::= WITH RECURSIVE wqlist */ |
| 163470 | | - -1, /* (302) wqas ::= AS */ |
| 163471 | | - -2, /* (303) wqas ::= AS MATERIALIZED */ |
| 163472 | | - -3, /* (304) wqas ::= AS NOT MATERIALIZED */ |
| 163473 | | - -6, /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 163474 | | - -1, /* (306) wqlist ::= wqitem */ |
| 163475 | | - -3, /* (307) wqlist ::= wqlist COMMA wqitem */ |
| 163476 | | - -1, /* (308) windowdefn_list ::= windowdefn */ |
| 163477 | | - -3, /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 163478 | | - -5, /* (310) windowdefn ::= nm AS LP window RP */ |
| 163479 | | - -5, /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163480 | | - -6, /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163481 | | - -4, /* (313) window ::= ORDER BY sortlist frame_opt */ |
| 163482 | | - -5, /* (314) window ::= nm ORDER BY sortlist frame_opt */ |
| 163483 | | - -1, /* (315) window ::= frame_opt */ |
| 163484 | | - -2, /* (316) window ::= nm frame_opt */ |
| 163485 | | - 0, /* (317) frame_opt ::= */ |
| 163486 | | - -3, /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 163487 | | - -6, /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 163488 | | - -1, /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 163489 | | - -1, /* (321) frame_bound_s ::= frame_bound */ |
| 163490 | | - -2, /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 163491 | | - -1, /* (323) frame_bound_e ::= frame_bound */ |
| 163492 | | - -2, /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 163493 | | - -2, /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 163494 | | - -2, /* (326) frame_bound ::= CURRENT ROW */ |
| 163495 | | - 0, /* (327) frame_exclude_opt ::= */ |
| 163496 | | - -2, /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 163497 | | - -2, /* (329) frame_exclude ::= NO OTHERS */ |
| 163498 | | - -2, /* (330) frame_exclude ::= CURRENT ROW */ |
| 163499 | | - -1, /* (331) frame_exclude ::= GROUP|TIES */ |
| 163500 | | - -2, /* (332) window_clause ::= WINDOW windowdefn_list */ |
| 163501 | | - -2, /* (333) filter_over ::= filter_clause over_clause */ |
| 163502 | | - -1, /* (334) filter_over ::= over_clause */ |
| 163503 | | - -1, /* (335) filter_over ::= filter_clause */ |
| 163504 | | - -4, /* (336) over_clause ::= OVER LP window RP */ |
| 163505 | | - -2, /* (337) over_clause ::= OVER nm */ |
| 163506 | | - -5, /* (338) filter_clause ::= FILTER LP WHERE expr RP */ |
| 163507 | | - -1, /* (339) input ::= cmdlist */ |
| 163508 | | - -2, /* (340) cmdlist ::= cmdlist ecmd */ |
| 163509 | | - -1, /* (341) cmdlist ::= ecmd */ |
| 163510 | | - -1, /* (342) ecmd ::= SEMI */ |
| 163511 | | - -2, /* (343) ecmd ::= cmdx SEMI */ |
| 163512 | | - -3, /* (344) ecmd ::= explain cmdx SEMI */ |
| 163513 | | - 0, /* (345) trans_opt ::= */ |
| 163514 | | - -1, /* (346) trans_opt ::= TRANSACTION */ |
| 163515 | | - -2, /* (347) trans_opt ::= TRANSACTION nm */ |
| 163516 | | - -1, /* (348) savepoint_opt ::= SAVEPOINT */ |
| 163517 | | - 0, /* (349) savepoint_opt ::= */ |
| 163518 | | - -2, /* (350) cmd ::= create_table create_table_args */ |
| 163519 | | - -1, /* (351) table_option_set ::= table_option */ |
| 163520 | | - -4, /* (352) columnlist ::= columnlist COMMA columnname carglist */ |
| 163521 | | - -2, /* (353) columnlist ::= columnname carglist */ |
| 163522 | | - -1, /* (354) nm ::= ID|INDEXED */ |
| 163523 | | - -1, /* (355) nm ::= STRING */ |
| 163524 | | - -1, /* (356) nm ::= JOIN_KW */ |
| 163525 | | - -1, /* (357) typetoken ::= typename */ |
| 163526 | | - -1, /* (358) typename ::= ID|STRING */ |
| 163527 | | - -1, /* (359) signed ::= plus_num */ |
| 163528 | | - -1, /* (360) signed ::= minus_num */ |
| 163529 | | - -2, /* (361) carglist ::= carglist ccons */ |
| 163530 | | - 0, /* (362) carglist ::= */ |
| 163531 | | - -2, /* (363) ccons ::= NULL onconf */ |
| 163532 | | - -4, /* (364) ccons ::= GENERATED ALWAYS AS generated */ |
| 163533 | | - -2, /* (365) ccons ::= AS generated */ |
| 163534 | | - -2, /* (366) conslist_opt ::= COMMA conslist */ |
| 163535 | | - -3, /* (367) conslist ::= conslist tconscomma tcons */ |
| 163536 | | - -1, /* (368) conslist ::= tcons */ |
| 163537 | | - 0, /* (369) tconscomma ::= */ |
| 163538 | | - -1, /* (370) defer_subclause_opt ::= defer_subclause */ |
| 163539 | | - -1, /* (371) resolvetype ::= raisetype */ |
| 163540 | | - -1, /* (372) selectnowith ::= oneselect */ |
| 163541 | | - -1, /* (373) oneselect ::= values */ |
| 163542 | | - -2, /* (374) sclp ::= selcollist COMMA */ |
| 163543 | | - -1, /* (375) as ::= ID|STRING */ |
| 163544 | | - 0, /* (376) returning ::= */ |
| 163545 | | - -1, /* (377) expr ::= term */ |
| 163546 | | - -1, /* (378) likeop ::= LIKE_KW|MATCH */ |
| 163547 | | - -1, /* (379) exprlist ::= nexprlist */ |
| 163548 | | - -1, /* (380) nmnum ::= plus_num */ |
| 163549 | | - -1, /* (381) nmnum ::= nm */ |
| 163550 | | - -1, /* (382) nmnum ::= ON */ |
| 163551 | | - -1, /* (383) nmnum ::= DELETE */ |
| 163552 | | - -1, /* (384) nmnum ::= DEFAULT */ |
| 163553 | | - -1, /* (385) plus_num ::= INTEGER|FLOAT */ |
| 163554 | | - 0, /* (386) foreach_clause ::= */ |
| 163555 | | - -3, /* (387) foreach_clause ::= FOR EACH ROW */ |
| 163556 | | - -1, /* (388) trnm ::= nm */ |
| 163557 | | - 0, /* (389) tridxby ::= */ |
| 163558 | | - -1, /* (390) database_kw_opt ::= DATABASE */ |
| 163559 | | - 0, /* (391) database_kw_opt ::= */ |
| 163560 | | - 0, /* (392) kwcolumn_opt ::= */ |
| 163561 | | - -1, /* (393) kwcolumn_opt ::= COLUMNKW */ |
| 163562 | | - -1, /* (394) vtabarglist ::= vtabarg */ |
| 163563 | | - -3, /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 163564 | | - -2, /* (396) vtabarg ::= vtabarg vtabargtoken */ |
| 163565 | | - 0, /* (397) anylist ::= */ |
| 163566 | | - -4, /* (398) anylist ::= anylist LP anylist RP */ |
| 163567 | | - -2, /* (399) anylist ::= anylist ANY */ |
| 163568 | | - 0, /* (400) with ::= */ |
| 163613 | + -3, /* (212) expr ::= expr PTR expr */ |
| 163614 | + -1, /* (213) between_op ::= BETWEEN */ |
| 163615 | + -2, /* (214) between_op ::= NOT BETWEEN */ |
| 163616 | + -5, /* (215) expr ::= expr between_op expr AND expr */ |
| 163617 | + -1, /* (216) in_op ::= IN */ |
| 163618 | + -2, /* (217) in_op ::= NOT IN */ |
| 163619 | + -5, /* (218) expr ::= expr in_op LP exprlist RP */ |
| 163620 | + -3, /* (219) expr ::= LP select RP */ |
| 163621 | + -5, /* (220) expr ::= expr in_op LP select RP */ |
| 163622 | + -5, /* (221) expr ::= expr in_op nm dbnm paren_exprlist */ |
| 163623 | + -4, /* (222) expr ::= EXISTS LP select RP */ |
| 163624 | + -5, /* (223) expr ::= CASE case_operand case_exprlist case_else END */ |
| 163625 | + -5, /* (224) case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 163626 | + -4, /* (225) case_exprlist ::= WHEN expr THEN expr */ |
| 163627 | + -2, /* (226) case_else ::= ELSE expr */ |
| 163628 | + 0, /* (227) case_else ::= */ |
| 163629 | + -1, /* (228) case_operand ::= expr */ |
| 163630 | + 0, /* (229) case_operand ::= */ |
| 163631 | + 0, /* (230) exprlist ::= */ |
| 163632 | + -3, /* (231) nexprlist ::= nexprlist COMMA expr */ |
| 163633 | + -1, /* (232) nexprlist ::= expr */ |
| 163634 | + 0, /* (233) paren_exprlist ::= */ |
| 163635 | + -3, /* (234) paren_exprlist ::= LP exprlist RP */ |
| 163636 | + -12, /* (235) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 163637 | + -1, /* (236) uniqueflag ::= UNIQUE */ |
| 163638 | + 0, /* (237) uniqueflag ::= */ |
| 163639 | + 0, /* (238) eidlist_opt ::= */ |
| 163640 | + -3, /* (239) eidlist_opt ::= LP eidlist RP */ |
| 163641 | + -5, /* (240) eidlist ::= eidlist COMMA nm collate sortorder */ |
| 163642 | + -3, /* (241) eidlist ::= nm collate sortorder */ |
| 163643 | + 0, /* (242) collate ::= */ |
| 163644 | + -2, /* (243) collate ::= COLLATE ID|STRING */ |
| 163645 | + -4, /* (244) cmd ::= DROP INDEX ifexists fullname */ |
| 163646 | + -2, /* (245) cmd ::= VACUUM vinto */ |
| 163647 | + -3, /* (246) cmd ::= VACUUM nm vinto */ |
| 163648 | + -2, /* (247) vinto ::= INTO expr */ |
| 163649 | + 0, /* (248) vinto ::= */ |
| 163650 | + -3, /* (249) cmd ::= PRAGMA nm dbnm */ |
| 163651 | + -5, /* (250) cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 163652 | + -6, /* (251) cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 163653 | + -5, /* (252) cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 163654 | + -6, /* (253) cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 163655 | + -2, /* (254) plus_num ::= PLUS INTEGER|FLOAT */ |
| 163656 | + -2, /* (255) minus_num ::= MINUS INTEGER|FLOAT */ |
| 163657 | + -5, /* (256) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 163658 | + -11, /* (257) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 163659 | + -1, /* (258) trigger_time ::= BEFORE|AFTER */ |
| 163660 | + -2, /* (259) trigger_time ::= INSTEAD OF */ |
| 163661 | + 0, /* (260) trigger_time ::= */ |
| 163662 | + -1, /* (261) trigger_event ::= DELETE|INSERT */ |
| 163663 | + -1, /* (262) trigger_event ::= UPDATE */ |
| 163664 | + -3, /* (263) trigger_event ::= UPDATE OF idlist */ |
| 163665 | + 0, /* (264) when_clause ::= */ |
| 163666 | + -2, /* (265) when_clause ::= WHEN expr */ |
| 163667 | + -3, /* (266) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 163668 | + -2, /* (267) trigger_cmd_list ::= trigger_cmd SEMI */ |
| 163669 | + -3, /* (268) trnm ::= nm DOT nm */ |
| 163670 | + -3, /* (269) tridxby ::= INDEXED BY nm */ |
| 163671 | + -2, /* (270) tridxby ::= NOT INDEXED */ |
| 163672 | + -9, /* (271) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 163673 | + -8, /* (272) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 163674 | + -6, /* (273) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 163675 | + -3, /* (274) trigger_cmd ::= scanpt select scanpt */ |
| 163676 | + -4, /* (275) expr ::= RAISE LP IGNORE RP */ |
| 163677 | + -6, /* (276) expr ::= RAISE LP raisetype COMMA nm RP */ |
| 163678 | + -1, /* (277) raisetype ::= ROLLBACK */ |
| 163679 | + -1, /* (278) raisetype ::= ABORT */ |
| 163680 | + -1, /* (279) raisetype ::= FAIL */ |
| 163681 | + -4, /* (280) cmd ::= DROP TRIGGER ifexists fullname */ |
| 163682 | + -6, /* (281) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 163683 | + -3, /* (282) cmd ::= DETACH database_kw_opt expr */ |
| 163684 | + 0, /* (283) key_opt ::= */ |
| 163685 | + -2, /* (284) key_opt ::= KEY expr */ |
| 163686 | + -1, /* (285) cmd ::= REINDEX */ |
| 163687 | + -3, /* (286) cmd ::= REINDEX nm dbnm */ |
| 163688 | + -1, /* (287) cmd ::= ANALYZE */ |
| 163689 | + -3, /* (288) cmd ::= ANALYZE nm dbnm */ |
| 163690 | + -6, /* (289) cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 163691 | + -7, /* (290) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 163692 | + -6, /* (291) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 163693 | + -1, /* (292) add_column_fullname ::= fullname */ |
| 163694 | + -8, /* (293) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 163695 | + -1, /* (294) cmd ::= create_vtab */ |
| 163696 | + -4, /* (295) cmd ::= create_vtab LP vtabarglist RP */ |
| 163697 | + -8, /* (296) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 163698 | + 0, /* (297) vtabarg ::= */ |
| 163699 | + -1, /* (298) vtabargtoken ::= ANY */ |
| 163700 | + -3, /* (299) vtabargtoken ::= lp anylist RP */ |
| 163701 | + -1, /* (300) lp ::= LP */ |
| 163702 | + -2, /* (301) with ::= WITH wqlist */ |
| 163703 | + -3, /* (302) with ::= WITH RECURSIVE wqlist */ |
| 163704 | + -1, /* (303) wqas ::= AS */ |
| 163705 | + -2, /* (304) wqas ::= AS MATERIALIZED */ |
| 163706 | + -3, /* (305) wqas ::= AS NOT MATERIALIZED */ |
| 163707 | + -6, /* (306) wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 163708 | + -1, /* (307) wqlist ::= wqitem */ |
| 163709 | + -3, /* (308) wqlist ::= wqlist COMMA wqitem */ |
| 163710 | + -1, /* (309) windowdefn_list ::= windowdefn */ |
| 163711 | + -3, /* (310) windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 163712 | + -5, /* (311) windowdefn ::= nm AS LP window RP */ |
| 163713 | + -5, /* (312) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163714 | + -6, /* (313) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 163715 | + -4, /* (314) window ::= ORDER BY sortlist frame_opt */ |
| 163716 | + -5, /* (315) window ::= nm ORDER BY sortlist frame_opt */ |
| 163717 | + -1, /* (316) window ::= frame_opt */ |
| 163718 | + -2, /* (317) window ::= nm frame_opt */ |
| 163719 | + 0, /* (318) frame_opt ::= */ |
| 163720 | + -3, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 163721 | + -6, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 163722 | + -1, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */ |
| 163723 | + -1, /* (322) frame_bound_s ::= frame_bound */ |
| 163724 | + -2, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 163725 | + -1, /* (324) frame_bound_e ::= frame_bound */ |
| 163726 | + -2, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */ |
| 163727 | + -2, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 163728 | + -2, /* (327) frame_bound ::= CURRENT ROW */ |
| 163729 | + 0, /* (328) frame_exclude_opt ::= */ |
| 163730 | + -2, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 163731 | + -2, /* (330) frame_exclude ::= NO OTHERS */ |
| 163732 | + -2, /* (331) frame_exclude ::= CURRENT ROW */ |
| 163733 | + -1, /* (332) frame_exclude ::= GROUP|TIES */ |
| 163734 | + -2, /* (333) window_clause ::= WINDOW windowdefn_list */ |
| 163735 | + -2, /* (334) filter_over ::= filter_clause over_clause */ |
| 163736 | + -1, /* (335) filter_over ::= over_clause */ |
| 163737 | + -1, /* (336) filter_over ::= filter_clause */ |
| 163738 | + -4, /* (337) over_clause ::= OVER LP window RP */ |
| 163739 | + -2, /* (338) over_clause ::= OVER nm */ |
| 163740 | + -5, /* (339) filter_clause ::= FILTER LP WHERE expr RP */ |
| 163741 | + -1, /* (340) input ::= cmdlist */ |
| 163742 | + -2, /* (341) cmdlist ::= cmdlist ecmd */ |
| 163743 | + -1, /* (342) cmdlist ::= ecmd */ |
| 163744 | + -1, /* (343) ecmd ::= SEMI */ |
| 163745 | + -2, /* (344) ecmd ::= cmdx SEMI */ |
| 163746 | + -3, /* (345) ecmd ::= explain cmdx SEMI */ |
| 163747 | + 0, /* (346) trans_opt ::= */ |
| 163748 | + -1, /* (347) trans_opt ::= TRANSACTION */ |
| 163749 | + -2, /* (348) trans_opt ::= TRANSACTION nm */ |
| 163750 | + -1, /* (349) savepoint_opt ::= SAVEPOINT */ |
| 163751 | + 0, /* (350) savepoint_opt ::= */ |
| 163752 | + -2, /* (351) cmd ::= create_table create_table_args */ |
| 163753 | + -1, /* (352) table_option_set ::= table_option */ |
| 163754 | + -4, /* (353) columnlist ::= columnlist COMMA columnname carglist */ |
| 163755 | + -2, /* (354) columnlist ::= columnname carglist */ |
| 163756 | + -1, /* (355) nm ::= ID|INDEXED */ |
| 163757 | + -1, /* (356) nm ::= STRING */ |
| 163758 | + -1, /* (357) nm ::= JOIN_KW */ |
| 163759 | + -1, /* (358) typetoken ::= typename */ |
| 163760 | + -1, /* (359) typename ::= ID|STRING */ |
| 163761 | + -1, /* (360) signed ::= plus_num */ |
| 163762 | + -1, /* (361) signed ::= minus_num */ |
| 163763 | + -2, /* (362) carglist ::= carglist ccons */ |
| 163764 | + 0, /* (363) carglist ::= */ |
| 163765 | + -2, /* (364) ccons ::= NULL onconf */ |
| 163766 | + -4, /* (365) ccons ::= GENERATED ALWAYS AS generated */ |
| 163767 | + -2, /* (366) ccons ::= AS generated */ |
| 163768 | + -2, /* (367) conslist_opt ::= COMMA conslist */ |
| 163769 | + -3, /* (368) conslist ::= conslist tconscomma tcons */ |
| 163770 | + -1, /* (369) conslist ::= tcons */ |
| 163771 | + 0, /* (370) tconscomma ::= */ |
| 163772 | + -1, /* (371) defer_subclause_opt ::= defer_subclause */ |
| 163773 | + -1, /* (372) resolvetype ::= raisetype */ |
| 163774 | + -1, /* (373) selectnowith ::= oneselect */ |
| 163775 | + -1, /* (374) oneselect ::= values */ |
| 163776 | + -2, /* (375) sclp ::= selcollist COMMA */ |
| 163777 | + -1, /* (376) as ::= ID|STRING */ |
| 163778 | + 0, /* (377) returning ::= */ |
| 163779 | + -1, /* (378) expr ::= term */ |
| 163780 | + -1, /* (379) likeop ::= LIKE_KW|MATCH */ |
| 163781 | + -1, /* (380) exprlist ::= nexprlist */ |
| 163782 | + -1, /* (381) nmnum ::= plus_num */ |
| 163783 | + -1, /* (382) nmnum ::= nm */ |
| 163784 | + -1, /* (383) nmnum ::= ON */ |
| 163785 | + -1, /* (384) nmnum ::= DELETE */ |
| 163786 | + -1, /* (385) nmnum ::= DEFAULT */ |
| 163787 | + -1, /* (386) plus_num ::= INTEGER|FLOAT */ |
| 163788 | + 0, /* (387) foreach_clause ::= */ |
| 163789 | + -3, /* (388) foreach_clause ::= FOR EACH ROW */ |
| 163790 | + -1, /* (389) trnm ::= nm */ |
| 163791 | + 0, /* (390) tridxby ::= */ |
| 163792 | + -1, /* (391) database_kw_opt ::= DATABASE */ |
| 163793 | + 0, /* (392) database_kw_opt ::= */ |
| 163794 | + 0, /* (393) kwcolumn_opt ::= */ |
| 163795 | + -1, /* (394) kwcolumn_opt ::= COLUMNKW */ |
| 163796 | + -1, /* (395) vtabarglist ::= vtabarg */ |
| 163797 | + -3, /* (396) vtabarglist ::= vtabarglist COMMA vtabarg */ |
| 163798 | + -2, /* (397) vtabarg ::= vtabarg vtabargtoken */ |
| 163799 | + 0, /* (398) anylist ::= */ |
| 163800 | + -4, /* (399) anylist ::= anylist LP anylist RP */ |
| 163801 | + -2, /* (400) anylist ::= anylist ANY */ |
| 163802 | + 0, /* (401) with ::= */ |
| 163569 | 163803 | }; |
| 163570 | 163804 | |
| 163571 | 163805 | static void yy_accept(yyParser*); /* Forward Declaration */ |
| 163572 | 163806 | |
| 163573 | 163807 | /* |
| | @@ -163615,20 +163849,20 @@ |
| 163615 | 163849 | break; |
| 163616 | 163850 | case 2: /* cmdx ::= cmd */ |
| 163617 | 163851 | { sqlite3FinishCoding(pParse); } |
| 163618 | 163852 | break; |
| 163619 | 163853 | case 3: /* cmd ::= BEGIN transtype trans_opt */ |
| 163620 | | -{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy64);} |
| 163854 | +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy394);} |
| 163621 | 163855 | break; |
| 163622 | 163856 | case 4: /* transtype ::= */ |
| 163623 | | -{yymsp[1].minor.yy64 = TK_DEFERRED;} |
| 163857 | +{yymsp[1].minor.yy394 = TK_DEFERRED;} |
| 163624 | 163858 | break; |
| 163625 | 163859 | case 5: /* transtype ::= DEFERRED */ |
| 163626 | 163860 | case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6); |
| 163627 | 163861 | case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7); |
| 163628 | | - case 320: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==320); |
| 163629 | | -{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/} |
| 163862 | + case 321: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==321); |
| 163863 | +{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/} |
| 163630 | 163864 | break; |
| 163631 | 163865 | case 8: /* cmd ::= COMMIT|END trans_opt */ |
| 163632 | 163866 | case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9); |
| 163633 | 163867 | {sqlite3EndTransaction(pParse,yymsp[-1].major);} |
| 163634 | 163868 | break; |
| | @@ -163647,11 +163881,11 @@ |
| 163647 | 163881 | sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0); |
| 163648 | 163882 | } |
| 163649 | 163883 | break; |
| 163650 | 163884 | case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ |
| 163651 | 163885 | { |
| 163652 | | - sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy64,0,0,yymsp[-2].minor.yy64); |
| 163886 | + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy394,0,0,yymsp[-2].minor.yy394); |
| 163653 | 163887 | } |
| 163654 | 163888 | break; |
| 163655 | 163889 | case 14: /* createkw ::= CREATE */ |
| 163656 | 163890 | {disableLookaside(pParse);} |
| 163657 | 163891 | break; |
| | @@ -163660,57 +163894,57 @@ |
| 163660 | 163894 | case 47: /* autoinc ::= */ yytestcase(yyruleno==47); |
| 163661 | 163895 | case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62); |
| 163662 | 163896 | case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72); |
| 163663 | 163897 | case 81: /* ifexists ::= */ yytestcase(yyruleno==81); |
| 163664 | 163898 | case 98: /* distinct ::= */ yytestcase(yyruleno==98); |
| 163665 | | - case 241: /* collate ::= */ yytestcase(yyruleno==241); |
| 163666 | | -{yymsp[1].minor.yy64 = 0;} |
| 163899 | + case 242: /* collate ::= */ yytestcase(yyruleno==242); |
| 163900 | +{yymsp[1].minor.yy394 = 0;} |
| 163667 | 163901 | break; |
| 163668 | 163902 | case 16: /* ifnotexists ::= IF NOT EXISTS */ |
| 163669 | | -{yymsp[-2].minor.yy64 = 1;} |
| 163903 | +{yymsp[-2].minor.yy394 = 1;} |
| 163670 | 163904 | break; |
| 163671 | 163905 | case 17: /* temp ::= TEMP */ |
| 163672 | | -{yymsp[0].minor.yy64 = pParse->db->init.busy==0;} |
| 163906 | +{yymsp[0].minor.yy394 = pParse->db->init.busy==0;} |
| 163673 | 163907 | break; |
| 163674 | 163908 | case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */ |
| 163675 | 163909 | { |
| 163676 | | - sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy51,0); |
| 163910 | + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy285,0); |
| 163677 | 163911 | } |
| 163678 | 163912 | break; |
| 163679 | 163913 | case 20: /* create_table_args ::= AS select */ |
| 163680 | 163914 | { |
| 163681 | | - sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy303); |
| 163682 | | - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303); |
| 163915 | + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy47); |
| 163916 | + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47); |
| 163683 | 163917 | } |
| 163684 | 163918 | break; |
| 163685 | 163919 | case 21: /* table_option_set ::= */ |
| 163686 | | -{yymsp[1].minor.yy51 = 0;} |
| 163920 | +{yymsp[1].minor.yy285 = 0;} |
| 163687 | 163921 | break; |
| 163688 | 163922 | case 22: /* table_option_set ::= table_option_set COMMA table_option */ |
| 163689 | | -{yylhsminor.yy51 = yymsp[-2].minor.yy51|yymsp[0].minor.yy51;} |
| 163690 | | - yymsp[-2].minor.yy51 = yylhsminor.yy51; |
| 163923 | +{yylhsminor.yy285 = yymsp[-2].minor.yy285|yymsp[0].minor.yy285;} |
| 163924 | + yymsp[-2].minor.yy285 = yylhsminor.yy285; |
| 163691 | 163925 | break; |
| 163692 | 163926 | case 23: /* table_option ::= WITHOUT nm */ |
| 163693 | 163927 | { |
| 163694 | 163928 | if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ |
| 163695 | | - yymsp[-1].minor.yy51 = TF_WithoutRowid | TF_NoVisibleRowid; |
| 163929 | + yymsp[-1].minor.yy285 = TF_WithoutRowid | TF_NoVisibleRowid; |
| 163696 | 163930 | }else{ |
| 163697 | | - yymsp[-1].minor.yy51 = 0; |
| 163931 | + yymsp[-1].minor.yy285 = 0; |
| 163698 | 163932 | sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); |
| 163699 | 163933 | } |
| 163700 | 163934 | } |
| 163701 | 163935 | break; |
| 163702 | 163936 | case 24: /* table_option ::= nm */ |
| 163703 | 163937 | { |
| 163704 | 163938 | if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){ |
| 163705 | | - yylhsminor.yy51 = TF_Strict; |
| 163939 | + yylhsminor.yy285 = TF_Strict; |
| 163706 | 163940 | }else{ |
| 163707 | | - yylhsminor.yy51 = 0; |
| 163941 | + yylhsminor.yy285 = 0; |
| 163708 | 163942 | sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); |
| 163709 | 163943 | } |
| 163710 | 163944 | } |
| 163711 | | - yymsp[0].minor.yy51 = yylhsminor.yy51; |
| 163945 | + yymsp[0].minor.yy285 = yylhsminor.yy285; |
| 163712 | 163946 | break; |
| 163713 | 163947 | case 25: /* columnname ::= nm typetoken */ |
| 163714 | 163948 | {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);} |
| 163715 | 163949 | break; |
| 163716 | 163950 | case 26: /* typetoken ::= */ |
| | @@ -163732,11 +163966,11 @@ |
| 163732 | 163966 | {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} |
| 163733 | 163967 | break; |
| 163734 | 163968 | case 30: /* scanpt ::= */ |
| 163735 | 163969 | { |
| 163736 | 163970 | assert( yyLookahead!=YYNOCODE ); |
| 163737 | | - yymsp[1].minor.yy600 = yyLookaheadToken.z; |
| 163971 | + yymsp[1].minor.yy522 = yyLookaheadToken.z; |
| 163738 | 163972 | } |
| 163739 | 163973 | break; |
| 163740 | 163974 | case 31: /* scantok ::= */ |
| 163741 | 163975 | { |
| 163742 | 163976 | assert( yyLookahead!=YYNOCODE ); |
| | @@ -163746,21 +163980,21 @@ |
| 163746 | 163980 | case 32: /* ccons ::= CONSTRAINT nm */ |
| 163747 | 163981 | case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67); |
| 163748 | 163982 | {pParse->constraintName = yymsp[0].minor.yy0;} |
| 163749 | 163983 | break; |
| 163750 | 163984 | case 33: /* ccons ::= DEFAULT scantok term */ |
| 163751 | | -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 163985 | +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 163752 | 163986 | break; |
| 163753 | 163987 | case 34: /* ccons ::= DEFAULT LP expr RP */ |
| 163754 | | -{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} |
| 163988 | +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} |
| 163755 | 163989 | break; |
| 163756 | 163990 | case 35: /* ccons ::= DEFAULT PLUS scantok term */ |
| 163757 | | -{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 163991 | +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} |
| 163758 | 163992 | break; |
| 163759 | 163993 | case 36: /* ccons ::= DEFAULT MINUS scantok term */ |
| 163760 | 163994 | { |
| 163761 | | - Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy626, 0); |
| 163995 | + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy528, 0); |
| 163762 | 163996 | sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); |
| 163763 | 163997 | } |
| 163764 | 163998 | break; |
| 163765 | 163999 | case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */ |
| 163766 | 164000 | { |
| | @@ -163771,308 +164005,308 @@ |
| 163771 | 164005 | } |
| 163772 | 164006 | sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); |
| 163773 | 164007 | } |
| 163774 | 164008 | break; |
| 163775 | 164009 | case 38: /* ccons ::= NOT NULL onconf */ |
| 163776 | | -{sqlite3AddNotNull(pParse, yymsp[0].minor.yy64);} |
| 164010 | +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy394);} |
| 163777 | 164011 | break; |
| 163778 | 164012 | case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ |
| 163779 | | -{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy64,yymsp[0].minor.yy64,yymsp[-2].minor.yy64);} |
| 164013 | +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy394,yymsp[0].minor.yy394,yymsp[-2].minor.yy394);} |
| 163780 | 164014 | break; |
| 163781 | 164015 | case 40: /* ccons ::= UNIQUE onconf */ |
| 163782 | | -{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy64,0,0,0,0, |
| 164016 | +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy394,0,0,0,0, |
| 163783 | 164017 | SQLITE_IDXTYPE_UNIQUE);} |
| 163784 | 164018 | break; |
| 163785 | 164019 | case 41: /* ccons ::= CHECK LP expr RP */ |
| 163786 | | -{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} |
| 164020 | +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} |
| 163787 | 164021 | break; |
| 163788 | 164022 | case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */ |
| 163789 | | -{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy562,yymsp[0].minor.yy64);} |
| 164023 | +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy394);} |
| 163790 | 164024 | break; |
| 163791 | 164025 | case 43: /* ccons ::= defer_subclause */ |
| 163792 | | -{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy64);} |
| 164026 | +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy394);} |
| 163793 | 164027 | break; |
| 163794 | 164028 | case 44: /* ccons ::= COLLATE ID|STRING */ |
| 163795 | 164029 | {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} |
| 163796 | 164030 | break; |
| 163797 | 164031 | case 45: /* generated ::= LP expr RP */ |
| 163798 | | -{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy626,0);} |
| 164032 | +{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy528,0);} |
| 163799 | 164033 | break; |
| 163800 | 164034 | case 46: /* generated ::= LP expr RP ID */ |
| 163801 | | -{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy626,&yymsp[0].minor.yy0);} |
| 164035 | +{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy528,&yymsp[0].minor.yy0);} |
| 163802 | 164036 | break; |
| 163803 | 164037 | case 48: /* autoinc ::= AUTOINCR */ |
| 163804 | | -{yymsp[0].minor.yy64 = 1;} |
| 164038 | +{yymsp[0].minor.yy394 = 1;} |
| 163805 | 164039 | break; |
| 163806 | 164040 | case 49: /* refargs ::= */ |
| 163807 | | -{ yymsp[1].minor.yy64 = OE_None*0x0101; /* EV: R-19803-45884 */} |
| 164041 | +{ yymsp[1].minor.yy394 = OE_None*0x0101; /* EV: R-19803-45884 */} |
| 163808 | 164042 | break; |
| 163809 | 164043 | case 50: /* refargs ::= refargs refarg */ |
| 163810 | | -{ yymsp[-1].minor.yy64 = (yymsp[-1].minor.yy64 & ~yymsp[0].minor.yy83.mask) | yymsp[0].minor.yy83.value; } |
| 164044 | +{ yymsp[-1].minor.yy394 = (yymsp[-1].minor.yy394 & ~yymsp[0].minor.yy231.mask) | yymsp[0].minor.yy231.value; } |
| 163811 | 164045 | break; |
| 163812 | 164046 | case 51: /* refarg ::= MATCH nm */ |
| 163813 | | -{ yymsp[-1].minor.yy83.value = 0; yymsp[-1].minor.yy83.mask = 0x000000; } |
| 164047 | +{ yymsp[-1].minor.yy231.value = 0; yymsp[-1].minor.yy231.mask = 0x000000; } |
| 163814 | 164048 | break; |
| 163815 | 164049 | case 52: /* refarg ::= ON INSERT refact */ |
| 163816 | | -{ yymsp[-2].minor.yy83.value = 0; yymsp[-2].minor.yy83.mask = 0x000000; } |
| 164050 | +{ yymsp[-2].minor.yy231.value = 0; yymsp[-2].minor.yy231.mask = 0x000000; } |
| 163817 | 164051 | break; |
| 163818 | 164052 | case 53: /* refarg ::= ON DELETE refact */ |
| 163819 | | -{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64; yymsp[-2].minor.yy83.mask = 0x0000ff; } |
| 164053 | +{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394; yymsp[-2].minor.yy231.mask = 0x0000ff; } |
| 163820 | 164054 | break; |
| 163821 | 164055 | case 54: /* refarg ::= ON UPDATE refact */ |
| 163822 | | -{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64<<8; yymsp[-2].minor.yy83.mask = 0x00ff00; } |
| 164056 | +{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394<<8; yymsp[-2].minor.yy231.mask = 0x00ff00; } |
| 163823 | 164057 | break; |
| 163824 | 164058 | case 55: /* refact ::= SET NULL */ |
| 163825 | | -{ yymsp[-1].minor.yy64 = OE_SetNull; /* EV: R-33326-45252 */} |
| 164059 | +{ yymsp[-1].minor.yy394 = OE_SetNull; /* EV: R-33326-45252 */} |
| 163826 | 164060 | break; |
| 163827 | 164061 | case 56: /* refact ::= SET DEFAULT */ |
| 163828 | | -{ yymsp[-1].minor.yy64 = OE_SetDflt; /* EV: R-33326-45252 */} |
| 164062 | +{ yymsp[-1].minor.yy394 = OE_SetDflt; /* EV: R-33326-45252 */} |
| 163829 | 164063 | break; |
| 163830 | 164064 | case 57: /* refact ::= CASCADE */ |
| 163831 | | -{ yymsp[0].minor.yy64 = OE_Cascade; /* EV: R-33326-45252 */} |
| 164065 | +{ yymsp[0].minor.yy394 = OE_Cascade; /* EV: R-33326-45252 */} |
| 163832 | 164066 | break; |
| 163833 | 164067 | case 58: /* refact ::= RESTRICT */ |
| 163834 | | -{ yymsp[0].minor.yy64 = OE_Restrict; /* EV: R-33326-45252 */} |
| 164068 | +{ yymsp[0].minor.yy394 = OE_Restrict; /* EV: R-33326-45252 */} |
| 163835 | 164069 | break; |
| 163836 | 164070 | case 59: /* refact ::= NO ACTION */ |
| 163837 | | -{ yymsp[-1].minor.yy64 = OE_None; /* EV: R-33326-45252 */} |
| 164071 | +{ yymsp[-1].minor.yy394 = OE_None; /* EV: R-33326-45252 */} |
| 163838 | 164072 | break; |
| 163839 | 164073 | case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ |
| 163840 | | -{yymsp[-2].minor.yy64 = 0;} |
| 164074 | +{yymsp[-2].minor.yy394 = 0;} |
| 163841 | 164075 | break; |
| 163842 | 164076 | case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ |
| 163843 | 164077 | case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76); |
| 163844 | 164078 | case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171); |
| 163845 | | -{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;} |
| 164079 | +{yymsp[-1].minor.yy394 = yymsp[0].minor.yy394;} |
| 163846 | 164080 | break; |
| 163847 | 164081 | case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ |
| 163848 | 164082 | case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80); |
| 163849 | | - case 213: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==213); |
| 163850 | | - case 216: /* in_op ::= NOT IN */ yytestcase(yyruleno==216); |
| 163851 | | - case 242: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==242); |
| 163852 | | -{yymsp[-1].minor.yy64 = 1;} |
| 164083 | + case 214: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==214); |
| 164084 | + case 217: /* in_op ::= NOT IN */ yytestcase(yyruleno==217); |
| 164085 | + case 243: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==243); |
| 164086 | +{yymsp[-1].minor.yy394 = 1;} |
| 163853 | 164087 | break; |
| 163854 | 164088 | case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ |
| 163855 | | -{yymsp[-1].minor.yy64 = 0;} |
| 164089 | +{yymsp[-1].minor.yy394 = 0;} |
| 163856 | 164090 | break; |
| 163857 | 164091 | case 66: /* tconscomma ::= COMMA */ |
| 163858 | 164092 | {pParse->constraintName.n = 0;} |
| 163859 | 164093 | break; |
| 163860 | 164094 | case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ |
| 163861 | | -{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy562,yymsp[0].minor.yy64,yymsp[-2].minor.yy64,0);} |
| 164095 | +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy394,yymsp[-2].minor.yy394,0);} |
| 163862 | 164096 | break; |
| 163863 | 164097 | case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */ |
| 163864 | | -{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy562,yymsp[0].minor.yy64,0,0,0,0, |
| 164098 | +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy394,0,0,0,0, |
| 163865 | 164099 | SQLITE_IDXTYPE_UNIQUE);} |
| 163866 | 164100 | break; |
| 163867 | 164101 | case 70: /* tcons ::= CHECK LP expr RP onconf */ |
| 163868 | | -{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy626,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} |
| 164102 | +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy528,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} |
| 163869 | 164103 | break; |
| 163870 | 164104 | case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ |
| 163871 | 164105 | { |
| 163872 | | - sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy562, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[-1].minor.yy64); |
| 163873 | | - sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy64); |
| 164106 | + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy394); |
| 164107 | + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy394); |
| 163874 | 164108 | } |
| 163875 | 164109 | break; |
| 163876 | 164110 | case 73: /* onconf ::= */ |
| 163877 | 164111 | case 75: /* orconf ::= */ yytestcase(yyruleno==75); |
| 163878 | | -{yymsp[1].minor.yy64 = OE_Default;} |
| 164112 | +{yymsp[1].minor.yy394 = OE_Default;} |
| 163879 | 164113 | break; |
| 163880 | 164114 | case 74: /* onconf ::= ON CONFLICT resolvetype */ |
| 163881 | | -{yymsp[-2].minor.yy64 = yymsp[0].minor.yy64;} |
| 164115 | +{yymsp[-2].minor.yy394 = yymsp[0].minor.yy394;} |
| 163882 | 164116 | break; |
| 163883 | 164117 | case 77: /* resolvetype ::= IGNORE */ |
| 163884 | | -{yymsp[0].minor.yy64 = OE_Ignore;} |
| 164118 | +{yymsp[0].minor.yy394 = OE_Ignore;} |
| 163885 | 164119 | break; |
| 163886 | 164120 | case 78: /* resolvetype ::= REPLACE */ |
| 163887 | 164121 | case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172); |
| 163888 | | -{yymsp[0].minor.yy64 = OE_Replace;} |
| 164122 | +{yymsp[0].minor.yy394 = OE_Replace;} |
| 163889 | 164123 | break; |
| 163890 | 164124 | case 79: /* cmd ::= DROP TABLE ifexists fullname */ |
| 163891 | 164125 | { |
| 163892 | | - sqlite3DropTable(pParse, yymsp[0].minor.yy607, 0, yymsp[-1].minor.yy64); |
| 164126 | + sqlite3DropTable(pParse, yymsp[0].minor.yy131, 0, yymsp[-1].minor.yy394); |
| 163893 | 164127 | } |
| 163894 | 164128 | break; |
| 163895 | 164129 | case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ |
| 163896 | 164130 | { |
| 163897 | | - sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[0].minor.yy303, yymsp[-7].minor.yy64, yymsp[-5].minor.yy64); |
| 164131 | + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[0].minor.yy47, yymsp[-7].minor.yy394, yymsp[-5].minor.yy394); |
| 163898 | 164132 | } |
| 163899 | 164133 | break; |
| 163900 | 164134 | case 83: /* cmd ::= DROP VIEW ifexists fullname */ |
| 163901 | 164135 | { |
| 163902 | | - sqlite3DropTable(pParse, yymsp[0].minor.yy607, 1, yymsp[-1].minor.yy64); |
| 164136 | + sqlite3DropTable(pParse, yymsp[0].minor.yy131, 1, yymsp[-1].minor.yy394); |
| 163903 | 164137 | } |
| 163904 | 164138 | break; |
| 163905 | 164139 | case 84: /* cmd ::= select */ |
| 163906 | 164140 | { |
| 163907 | 164141 | SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0}; |
| 163908 | | - sqlite3Select(pParse, yymsp[0].minor.yy303, &dest); |
| 163909 | | - sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303); |
| 164142 | + sqlite3Select(pParse, yymsp[0].minor.yy47, &dest); |
| 164143 | + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47); |
| 163910 | 164144 | } |
| 163911 | 164145 | break; |
| 163912 | 164146 | case 85: /* select ::= WITH wqlist selectnowith */ |
| 163913 | | -{yymsp[-2].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);} |
| 164147 | +{yymsp[-2].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);} |
| 163914 | 164148 | break; |
| 163915 | 164149 | case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */ |
| 163916 | | -{yymsp[-3].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);} |
| 164150 | +{yymsp[-3].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);} |
| 163917 | 164151 | break; |
| 163918 | 164152 | case 87: /* select ::= selectnowith */ |
| 163919 | 164153 | { |
| 163920 | | - Select *p = yymsp[0].minor.yy303; |
| 164154 | + Select *p = yymsp[0].minor.yy47; |
| 163921 | 164155 | if( p ){ |
| 163922 | 164156 | parserDoubleLinkSelect(pParse, p); |
| 163923 | 164157 | } |
| 163924 | | - yymsp[0].minor.yy303 = p; /*A-overwrites-X*/ |
| 164158 | + yymsp[0].minor.yy47 = p; /*A-overwrites-X*/ |
| 163925 | 164159 | } |
| 163926 | 164160 | break; |
| 163927 | 164161 | case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */ |
| 163928 | 164162 | { |
| 163929 | | - Select *pRhs = yymsp[0].minor.yy303; |
| 163930 | | - Select *pLhs = yymsp[-2].minor.yy303; |
| 164163 | + Select *pRhs = yymsp[0].minor.yy47; |
| 164164 | + Select *pLhs = yymsp[-2].minor.yy47; |
| 163931 | 164165 | if( pRhs && pRhs->pPrior ){ |
| 163932 | 164166 | SrcList *pFrom; |
| 163933 | 164167 | Token x; |
| 163934 | 164168 | x.n = 0; |
| 163935 | 164169 | parserDoubleLinkSelect(pParse, pRhs); |
| 163936 | 164170 | pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0); |
| 163937 | 164171 | pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); |
| 163938 | 164172 | } |
| 163939 | 164173 | if( pRhs ){ |
| 163940 | | - pRhs->op = (u8)yymsp[-1].minor.yy64; |
| 164174 | + pRhs->op = (u8)yymsp[-1].minor.yy394; |
| 163941 | 164175 | pRhs->pPrior = pLhs; |
| 163942 | 164176 | if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; |
| 163943 | 164177 | pRhs->selFlags &= ~SF_MultiValue; |
| 163944 | | - if( yymsp[-1].minor.yy64!=TK_ALL ) pParse->hasCompound = 1; |
| 164178 | + if( yymsp[-1].minor.yy394!=TK_ALL ) pParse->hasCompound = 1; |
| 163945 | 164179 | }else{ |
| 163946 | 164180 | sqlite3SelectDelete(pParse->db, pLhs); |
| 163947 | 164181 | } |
| 163948 | | - yymsp[-2].minor.yy303 = pRhs; |
| 164182 | + yymsp[-2].minor.yy47 = pRhs; |
| 163949 | 164183 | } |
| 163950 | 164184 | break; |
| 163951 | 164185 | case 89: /* multiselect_op ::= UNION */ |
| 163952 | 164186 | case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91); |
| 163953 | | -{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-OP*/} |
| 164187 | +{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-OP*/} |
| 163954 | 164188 | break; |
| 163955 | 164189 | case 90: /* multiselect_op ::= UNION ALL */ |
| 163956 | | -{yymsp[-1].minor.yy64 = TK_ALL;} |
| 164190 | +{yymsp[-1].minor.yy394 = TK_ALL;} |
| 163957 | 164191 | break; |
| 163958 | 164192 | case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ |
| 163959 | 164193 | { |
| 163960 | | - yymsp[-8].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy562,yymsp[-5].minor.yy607,yymsp[-4].minor.yy626,yymsp[-3].minor.yy562,yymsp[-2].minor.yy626,yymsp[-1].minor.yy562,yymsp[-7].minor.yy64,yymsp[0].minor.yy626); |
| 164194 | + yymsp[-8].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy131,yymsp[-4].minor.yy528,yymsp[-3].minor.yy322,yymsp[-2].minor.yy528,yymsp[-1].minor.yy322,yymsp[-7].minor.yy394,yymsp[0].minor.yy528); |
| 163961 | 164195 | } |
| 163962 | 164196 | break; |
| 163963 | 164197 | case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ |
| 163964 | 164198 | { |
| 163965 | | - yymsp[-9].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy562,yymsp[-6].minor.yy607,yymsp[-5].minor.yy626,yymsp[-4].minor.yy562,yymsp[-3].minor.yy626,yymsp[-1].minor.yy562,yymsp[-8].minor.yy64,yymsp[0].minor.yy626); |
| 163966 | | - if( yymsp[-9].minor.yy303 ){ |
| 163967 | | - yymsp[-9].minor.yy303->pWinDefn = yymsp[-2].minor.yy375; |
| 164199 | + yymsp[-9].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy322,yymsp[-6].minor.yy131,yymsp[-5].minor.yy528,yymsp[-4].minor.yy322,yymsp[-3].minor.yy528,yymsp[-1].minor.yy322,yymsp[-8].minor.yy394,yymsp[0].minor.yy528); |
| 164200 | + if( yymsp[-9].minor.yy47 ){ |
| 164201 | + yymsp[-9].minor.yy47->pWinDefn = yymsp[-2].minor.yy41; |
| 163968 | 164202 | }else{ |
| 163969 | | - sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy375); |
| 164203 | + sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy41); |
| 163970 | 164204 | } |
| 163971 | 164205 | } |
| 163972 | 164206 | break; |
| 163973 | 164207 | case 94: /* values ::= VALUES LP nexprlist RP */ |
| 163974 | 164208 | { |
| 163975 | | - yymsp[-3].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values,0); |
| 164209 | + yymsp[-3].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values,0); |
| 163976 | 164210 | } |
| 163977 | 164211 | break; |
| 163978 | 164212 | case 95: /* values ::= values COMMA LP nexprlist RP */ |
| 163979 | 164213 | { |
| 163980 | | - Select *pRight, *pLeft = yymsp[-4].minor.yy303; |
| 163981 | | - pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values|SF_MultiValue,0); |
| 164214 | + Select *pRight, *pLeft = yymsp[-4].minor.yy47; |
| 164215 | + pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values|SF_MultiValue,0); |
| 163982 | 164216 | if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; |
| 163983 | 164217 | if( pRight ){ |
| 163984 | 164218 | pRight->op = TK_ALL; |
| 163985 | 164219 | pRight->pPrior = pLeft; |
| 163986 | | - yymsp[-4].minor.yy303 = pRight; |
| 164220 | + yymsp[-4].minor.yy47 = pRight; |
| 163987 | 164221 | }else{ |
| 163988 | | - yymsp[-4].minor.yy303 = pLeft; |
| 164222 | + yymsp[-4].minor.yy47 = pLeft; |
| 163989 | 164223 | } |
| 163990 | 164224 | } |
| 163991 | 164225 | break; |
| 163992 | 164226 | case 96: /* distinct ::= DISTINCT */ |
| 163993 | | -{yymsp[0].minor.yy64 = SF_Distinct;} |
| 164227 | +{yymsp[0].minor.yy394 = SF_Distinct;} |
| 163994 | 164228 | break; |
| 163995 | 164229 | case 97: /* distinct ::= ALL */ |
| 163996 | | -{yymsp[0].minor.yy64 = SF_All;} |
| 164230 | +{yymsp[0].minor.yy394 = SF_All;} |
| 163997 | 164231 | break; |
| 163998 | 164232 | case 99: /* sclp ::= */ |
| 163999 | 164233 | case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132); |
| 164000 | 164234 | case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142); |
| 164001 | | - case 229: /* exprlist ::= */ yytestcase(yyruleno==229); |
| 164002 | | - case 232: /* paren_exprlist ::= */ yytestcase(yyruleno==232); |
| 164003 | | - case 237: /* eidlist_opt ::= */ yytestcase(yyruleno==237); |
| 164004 | | -{yymsp[1].minor.yy562 = 0;} |
| 164235 | + case 230: /* exprlist ::= */ yytestcase(yyruleno==230); |
| 164236 | + case 233: /* paren_exprlist ::= */ yytestcase(yyruleno==233); |
| 164237 | + case 238: /* eidlist_opt ::= */ yytestcase(yyruleno==238); |
| 164238 | +{yymsp[1].minor.yy322 = 0;} |
| 164005 | 164239 | break; |
| 164006 | 164240 | case 100: /* selcollist ::= sclp scanpt expr scanpt as */ |
| 164007 | 164241 | { |
| 164008 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[-2].minor.yy626); |
| 164009 | | - if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[0].minor.yy0, 1); |
| 164010 | | - sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy562,yymsp[-3].minor.yy600,yymsp[-1].minor.yy600); |
| 164242 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[-2].minor.yy528); |
| 164243 | + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[0].minor.yy0, 1); |
| 164244 | + sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy322,yymsp[-3].minor.yy522,yymsp[-1].minor.yy522); |
| 164011 | 164245 | } |
| 164012 | 164246 | break; |
| 164013 | 164247 | case 101: /* selcollist ::= sclp scanpt STAR */ |
| 164014 | 164248 | { |
| 164015 | 164249 | Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); |
| 164016 | | - yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy562, p); |
| 164250 | + yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, p); |
| 164017 | 164251 | } |
| 164018 | 164252 | break; |
| 164019 | 164253 | case 102: /* selcollist ::= sclp scanpt nm DOT STAR */ |
| 164020 | 164254 | { |
| 164021 | 164255 | Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); |
| 164022 | 164256 | Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); |
| 164023 | 164257 | Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); |
| 164024 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, pDot); |
| 164258 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, pDot); |
| 164025 | 164259 | } |
| 164026 | 164260 | break; |
| 164027 | 164261 | case 103: /* as ::= AS nm */ |
| 164028 | 164262 | case 114: /* dbnm ::= DOT nm */ yytestcase(yyruleno==114); |
| 164029 | | - case 253: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==253); |
| 164030 | | - case 254: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==254); |
| 164263 | + case 254: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==254); |
| 164264 | + case 255: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==255); |
| 164031 | 164265 | {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} |
| 164032 | 164266 | break; |
| 164033 | 164267 | case 105: /* from ::= */ |
| 164034 | 164268 | case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108); |
| 164035 | | -{yymsp[1].minor.yy607 = 0;} |
| 164269 | +{yymsp[1].minor.yy131 = 0;} |
| 164036 | 164270 | break; |
| 164037 | 164271 | case 106: /* from ::= FROM seltablist */ |
| 164038 | 164272 | { |
| 164039 | | - yymsp[-1].minor.yy607 = yymsp[0].minor.yy607; |
| 164040 | | - sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy607); |
| 164273 | + yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; |
| 164274 | + sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy131); |
| 164041 | 164275 | } |
| 164042 | 164276 | break; |
| 164043 | 164277 | case 107: /* stl_prefix ::= seltablist joinop */ |
| 164044 | 164278 | { |
| 164045 | | - if( ALWAYS(yymsp[-1].minor.yy607 && yymsp[-1].minor.yy607->nSrc>0) ) yymsp[-1].minor.yy607->a[yymsp[-1].minor.yy607->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy64; |
| 164279 | + if( ALWAYS(yymsp[-1].minor.yy131 && yymsp[-1].minor.yy131->nSrc>0) ) yymsp[-1].minor.yy131->a[yymsp[-1].minor.yy131->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy394; |
| 164046 | 164280 | } |
| 164047 | 164281 | break; |
| 164048 | 164282 | case 109: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ |
| 164049 | 164283 | { |
| 164050 | | - yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); |
| 164051 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy607, &yymsp[-2].minor.yy0); |
| 164284 | + yymsp[-6].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy131,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy528,yymsp[0].minor.yy254); |
| 164285 | + sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy131, &yymsp[-2].minor.yy0); |
| 164052 | 164286 | } |
| 164053 | 164287 | break; |
| 164054 | 164288 | case 110: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ |
| 164055 | 164289 | { |
| 164056 | | - yymsp[-8].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy607,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); |
| 164057 | | - sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy607, yymsp[-4].minor.yy562); |
| 164290 | + yymsp[-8].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy131,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy528,yymsp[0].minor.yy254); |
| 164291 | + sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy131, yymsp[-4].minor.yy322); |
| 164058 | 164292 | } |
| 164059 | 164293 | break; |
| 164060 | 164294 | case 111: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */ |
| 164061 | 164295 | { |
| 164062 | | - yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy303,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); |
| 164296 | + yymsp[-6].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy131,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy47,yymsp[-1].minor.yy528,yymsp[0].minor.yy254); |
| 164063 | 164297 | } |
| 164064 | 164298 | break; |
| 164065 | 164299 | case 112: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ |
| 164066 | 164300 | { |
| 164067 | | - if( yymsp[-6].minor.yy607==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy626==0 && yymsp[0].minor.yy240==0 ){ |
| 164068 | | - yymsp[-6].minor.yy607 = yymsp[-4].minor.yy607; |
| 164069 | | - }else if( yymsp[-4].minor.yy607->nSrc==1 ){ |
| 164070 | | - yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); |
| 164071 | | - if( yymsp[-6].minor.yy607 ){ |
| 164072 | | - SrcItem *pNew = &yymsp[-6].minor.yy607->a[yymsp[-6].minor.yy607->nSrc-1]; |
| 164073 | | - SrcItem *pOld = yymsp[-4].minor.yy607->a; |
| 164301 | + if( yymsp[-6].minor.yy131==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy528==0 && yymsp[0].minor.yy254==0 ){ |
| 164302 | + yymsp[-6].minor.yy131 = yymsp[-4].minor.yy131; |
| 164303 | + }else if( yymsp[-4].minor.yy131->nSrc==1 ){ |
| 164304 | + yymsp[-6].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy131,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy528,yymsp[0].minor.yy254); |
| 164305 | + if( yymsp[-6].minor.yy131 ){ |
| 164306 | + SrcItem *pNew = &yymsp[-6].minor.yy131->a[yymsp[-6].minor.yy131->nSrc-1]; |
| 164307 | + SrcItem *pOld = yymsp[-4].minor.yy131->a; |
| 164074 | 164308 | pNew->zName = pOld->zName; |
| 164075 | 164309 | pNew->zDatabase = pOld->zDatabase; |
| 164076 | 164310 | pNew->pSelect = pOld->pSelect; |
| 164077 | 164311 | if( pOld->fg.isTabFunc ){ |
| 164078 | 164312 | pNew->u1.pFuncArg = pOld->u1.pFuncArg; |
| | @@ -164081,240 +164315,240 @@ |
| 164081 | 164315 | pNew->fg.isTabFunc = 1; |
| 164082 | 164316 | } |
| 164083 | 164317 | pOld->zName = pOld->zDatabase = 0; |
| 164084 | 164318 | pOld->pSelect = 0; |
| 164085 | 164319 | } |
| 164086 | | - sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy607); |
| 164320 | + sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy131); |
| 164087 | 164321 | }else{ |
| 164088 | 164322 | Select *pSubquery; |
| 164089 | | - sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy607); |
| 164090 | | - pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy607,0,0,0,0,SF_NestedFrom,0); |
| 164091 | | - yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy626,yymsp[0].minor.yy240); |
| 164323 | + sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy131); |
| 164324 | + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy131,0,0,0,0,SF_NestedFrom,0); |
| 164325 | + yymsp[-6].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy131,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy528,yymsp[0].minor.yy254); |
| 164092 | 164326 | } |
| 164093 | 164327 | } |
| 164094 | 164328 | break; |
| 164095 | 164329 | case 113: /* dbnm ::= */ |
| 164096 | 164330 | case 127: /* indexed_opt ::= */ yytestcase(yyruleno==127); |
| 164097 | 164331 | {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;} |
| 164098 | 164332 | break; |
| 164099 | 164333 | case 115: /* fullname ::= nm */ |
| 164100 | 164334 | { |
| 164101 | | - yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); |
| 164102 | | - if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0); |
| 164335 | + yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); |
| 164336 | + if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0); |
| 164103 | 164337 | } |
| 164104 | | - yymsp[0].minor.yy607 = yylhsminor.yy607; |
| 164338 | + yymsp[0].minor.yy131 = yylhsminor.yy131; |
| 164105 | 164339 | break; |
| 164106 | 164340 | case 116: /* fullname ::= nm DOT nm */ |
| 164107 | 164341 | { |
| 164108 | | - yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); |
| 164109 | | - if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0); |
| 164342 | + yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); |
| 164343 | + if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0); |
| 164110 | 164344 | } |
| 164111 | | - yymsp[-2].minor.yy607 = yylhsminor.yy607; |
| 164345 | + yymsp[-2].minor.yy131 = yylhsminor.yy131; |
| 164112 | 164346 | break; |
| 164113 | 164347 | case 117: /* xfullname ::= nm */ |
| 164114 | | -{yymsp[0].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} |
| 164348 | +{yymsp[0].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} |
| 164115 | 164349 | break; |
| 164116 | 164350 | case 118: /* xfullname ::= nm DOT nm */ |
| 164117 | | -{yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164351 | +{yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164118 | 164352 | break; |
| 164119 | 164353 | case 119: /* xfullname ::= nm DOT nm AS nm */ |
| 164120 | 164354 | { |
| 164121 | | - yymsp[-4].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ |
| 164122 | | - if( yymsp[-4].minor.yy607 ) yymsp[-4].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 164355 | + yymsp[-4].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ |
| 164356 | + if( yymsp[-4].minor.yy131 ) yymsp[-4].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 164123 | 164357 | } |
| 164124 | 164358 | break; |
| 164125 | 164359 | case 120: /* xfullname ::= nm AS nm */ |
| 164126 | 164360 | { |
| 164127 | | - yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ |
| 164128 | | - if( yymsp[-2].minor.yy607 ) yymsp[-2].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 164361 | + yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ |
| 164362 | + if( yymsp[-2].minor.yy131 ) yymsp[-2].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); |
| 164129 | 164363 | } |
| 164130 | 164364 | break; |
| 164131 | 164365 | case 121: /* joinop ::= COMMA|JOIN */ |
| 164132 | | -{ yymsp[0].minor.yy64 = JT_INNER; } |
| 164366 | +{ yymsp[0].minor.yy394 = JT_INNER; } |
| 164133 | 164367 | break; |
| 164134 | 164368 | case 122: /* joinop ::= JOIN_KW JOIN */ |
| 164135 | | -{yymsp[-1].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} |
| 164369 | +{yymsp[-1].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} |
| 164136 | 164370 | break; |
| 164137 | 164371 | case 123: /* joinop ::= JOIN_KW nm JOIN */ |
| 164138 | | -{yymsp[-2].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} |
| 164372 | +{yymsp[-2].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} |
| 164139 | 164373 | break; |
| 164140 | 164374 | case 124: /* joinop ::= JOIN_KW nm nm JOIN */ |
| 164141 | | -{yymsp[-3].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} |
| 164375 | +{yymsp[-3].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} |
| 164142 | 164376 | break; |
| 164143 | 164377 | case 125: /* on_opt ::= ON expr */ |
| 164144 | 164378 | case 145: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==145); |
| 164145 | 164379 | case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152); |
| 164146 | 164380 | case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154); |
| 164147 | | - case 225: /* case_else ::= ELSE expr */ yytestcase(yyruleno==225); |
| 164148 | | - case 246: /* vinto ::= INTO expr */ yytestcase(yyruleno==246); |
| 164149 | | -{yymsp[-1].minor.yy626 = yymsp[0].minor.yy626;} |
| 164381 | + case 226: /* case_else ::= ELSE expr */ yytestcase(yyruleno==226); |
| 164382 | + case 247: /* vinto ::= INTO expr */ yytestcase(yyruleno==247); |
| 164383 | +{yymsp[-1].minor.yy528 = yymsp[0].minor.yy528;} |
| 164150 | 164384 | break; |
| 164151 | 164385 | case 126: /* on_opt ::= */ |
| 164152 | 164386 | case 144: /* having_opt ::= */ yytestcase(yyruleno==144); |
| 164153 | 164387 | case 146: /* limit_opt ::= */ yytestcase(yyruleno==146); |
| 164154 | 164388 | case 151: /* where_opt ::= */ yytestcase(yyruleno==151); |
| 164155 | 164389 | case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153); |
| 164156 | | - case 226: /* case_else ::= */ yytestcase(yyruleno==226); |
| 164157 | | - case 228: /* case_operand ::= */ yytestcase(yyruleno==228); |
| 164158 | | - case 247: /* vinto ::= */ yytestcase(yyruleno==247); |
| 164159 | | -{yymsp[1].minor.yy626 = 0;} |
| 164390 | + case 227: /* case_else ::= */ yytestcase(yyruleno==227); |
| 164391 | + case 229: /* case_operand ::= */ yytestcase(yyruleno==229); |
| 164392 | + case 248: /* vinto ::= */ yytestcase(yyruleno==248); |
| 164393 | +{yymsp[1].minor.yy528 = 0;} |
| 164160 | 164394 | break; |
| 164161 | 164395 | case 128: /* indexed_opt ::= INDEXED BY nm */ |
| 164162 | 164396 | {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;} |
| 164163 | 164397 | break; |
| 164164 | 164398 | case 129: /* indexed_opt ::= NOT INDEXED */ |
| 164165 | 164399 | {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;} |
| 164166 | 164400 | break; |
| 164167 | 164401 | case 130: /* using_opt ::= USING LP idlist RP */ |
| 164168 | | -{yymsp[-3].minor.yy240 = yymsp[-1].minor.yy240;} |
| 164402 | +{yymsp[-3].minor.yy254 = yymsp[-1].minor.yy254;} |
| 164169 | 164403 | break; |
| 164170 | 164404 | case 131: /* using_opt ::= */ |
| 164171 | 164405 | case 173: /* idlist_opt ::= */ yytestcase(yyruleno==173); |
| 164172 | | -{yymsp[1].minor.yy240 = 0;} |
| 164406 | +{yymsp[1].minor.yy254 = 0;} |
| 164173 | 164407 | break; |
| 164174 | 164408 | case 133: /* orderby_opt ::= ORDER BY sortlist */ |
| 164175 | 164409 | case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143); |
| 164176 | | -{yymsp[-2].minor.yy562 = yymsp[0].minor.yy562;} |
| 164410 | +{yymsp[-2].minor.yy322 = yymsp[0].minor.yy322;} |
| 164177 | 164411 | break; |
| 164178 | 164412 | case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */ |
| 164179 | 164413 | { |
| 164180 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562,yymsp[-2].minor.yy626); |
| 164181 | | - sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64); |
| 164414 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322,yymsp[-2].minor.yy528); |
| 164415 | + sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394); |
| 164182 | 164416 | } |
| 164183 | 164417 | break; |
| 164184 | 164418 | case 135: /* sortlist ::= expr sortorder nulls */ |
| 164185 | 164419 | { |
| 164186 | | - yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy626); /*A-overwrites-Y*/ |
| 164187 | | - sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64); |
| 164420 | + yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy528); /*A-overwrites-Y*/ |
| 164421 | + sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394); |
| 164188 | 164422 | } |
| 164189 | 164423 | break; |
| 164190 | 164424 | case 136: /* sortorder ::= ASC */ |
| 164191 | | -{yymsp[0].minor.yy64 = SQLITE_SO_ASC;} |
| 164425 | +{yymsp[0].minor.yy394 = SQLITE_SO_ASC;} |
| 164192 | 164426 | break; |
| 164193 | 164427 | case 137: /* sortorder ::= DESC */ |
| 164194 | | -{yymsp[0].minor.yy64 = SQLITE_SO_DESC;} |
| 164428 | +{yymsp[0].minor.yy394 = SQLITE_SO_DESC;} |
| 164195 | 164429 | break; |
| 164196 | 164430 | case 138: /* sortorder ::= */ |
| 164197 | 164431 | case 141: /* nulls ::= */ yytestcase(yyruleno==141); |
| 164198 | | -{yymsp[1].minor.yy64 = SQLITE_SO_UNDEFINED;} |
| 164432 | +{yymsp[1].minor.yy394 = SQLITE_SO_UNDEFINED;} |
| 164199 | 164433 | break; |
| 164200 | 164434 | case 139: /* nulls ::= NULLS FIRST */ |
| 164201 | | -{yymsp[-1].minor.yy64 = SQLITE_SO_ASC;} |
| 164435 | +{yymsp[-1].minor.yy394 = SQLITE_SO_ASC;} |
| 164202 | 164436 | break; |
| 164203 | 164437 | case 140: /* nulls ::= NULLS LAST */ |
| 164204 | | -{yymsp[-1].minor.yy64 = SQLITE_SO_DESC;} |
| 164438 | +{yymsp[-1].minor.yy394 = SQLITE_SO_DESC;} |
| 164205 | 164439 | break; |
| 164206 | 164440 | case 147: /* limit_opt ::= LIMIT expr */ |
| 164207 | | -{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,0);} |
| 164441 | +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,0);} |
| 164208 | 164442 | break; |
| 164209 | 164443 | case 148: /* limit_opt ::= LIMIT expr OFFSET expr */ |
| 164210 | | -{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} |
| 164444 | +{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} |
| 164211 | 164445 | break; |
| 164212 | 164446 | case 149: /* limit_opt ::= LIMIT expr COMMA expr */ |
| 164213 | | -{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,yymsp[-2].minor.yy626);} |
| 164447 | +{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,yymsp[-2].minor.yy528);} |
| 164214 | 164448 | break; |
| 164215 | 164449 | case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ |
| 164216 | 164450 | { |
| 164217 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy607, &yymsp[-1].minor.yy0); |
| 164218 | | - sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy607,yymsp[0].minor.yy626,0,0); |
| 164451 | + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy131, &yymsp[-1].minor.yy0); |
| 164452 | + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy131,yymsp[0].minor.yy528,0,0); |
| 164219 | 164453 | } |
| 164220 | 164454 | break; |
| 164221 | 164455 | case 155: /* where_opt_ret ::= RETURNING selcollist */ |
| 164222 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-1].minor.yy626 = 0;} |
| 164456 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-1].minor.yy528 = 0;} |
| 164223 | 164457 | break; |
| 164224 | 164458 | case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */ |
| 164225 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-3].minor.yy626 = yymsp[-2].minor.yy626;} |
| 164459 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-3].minor.yy528 = yymsp[-2].minor.yy528;} |
| 164226 | 164460 | break; |
| 164227 | 164461 | case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ |
| 164228 | 164462 | { |
| 164229 | | - sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy607, &yymsp[-4].minor.yy0); |
| 164230 | | - sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy562,"set list"); |
| 164231 | | - yymsp[-5].minor.yy607 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy607, yymsp[-1].minor.yy607); |
| 164232 | | - sqlite3Update(pParse,yymsp[-5].minor.yy607,yymsp[-2].minor.yy562,yymsp[0].minor.yy626,yymsp[-6].minor.yy64,0,0,0); |
| 164463 | + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy131, &yymsp[-4].minor.yy0); |
| 164464 | + sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy322,"set list"); |
| 164465 | + yymsp[-5].minor.yy131 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy131, yymsp[-1].minor.yy131); |
| 164466 | + sqlite3Update(pParse,yymsp[-5].minor.yy131,yymsp[-2].minor.yy322,yymsp[0].minor.yy528,yymsp[-6].minor.yy394,0,0,0); |
| 164233 | 164467 | } |
| 164234 | 164468 | break; |
| 164235 | 164469 | case 158: /* setlist ::= setlist COMMA nm EQ expr */ |
| 164236 | 164470 | { |
| 164237 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[0].minor.yy626); |
| 164238 | | - sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, 1); |
| 164471 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy528); |
| 164472 | + sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, 1); |
| 164239 | 164473 | } |
| 164240 | 164474 | break; |
| 164241 | 164475 | case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ |
| 164242 | 164476 | { |
| 164243 | | - yymsp[-6].minor.yy562 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy562, yymsp[-3].minor.yy240, yymsp[0].minor.yy626); |
| 164477 | + yymsp[-6].minor.yy322 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy322, yymsp[-3].minor.yy254, yymsp[0].minor.yy528); |
| 164244 | 164478 | } |
| 164245 | 164479 | break; |
| 164246 | 164480 | case 160: /* setlist ::= nm EQ expr */ |
| 164247 | 164481 | { |
| 164248 | | - yylhsminor.yy562 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy626); |
| 164249 | | - sqlite3ExprListSetName(pParse, yylhsminor.yy562, &yymsp[-2].minor.yy0, 1); |
| 164482 | + yylhsminor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy528); |
| 164483 | + sqlite3ExprListSetName(pParse, yylhsminor.yy322, &yymsp[-2].minor.yy0, 1); |
| 164250 | 164484 | } |
| 164251 | | - yymsp[-2].minor.yy562 = yylhsminor.yy562; |
| 164485 | + yymsp[-2].minor.yy322 = yylhsminor.yy322; |
| 164252 | 164486 | break; |
| 164253 | 164487 | case 161: /* setlist ::= LP idlist RP EQ expr */ |
| 164254 | 164488 | { |
| 164255 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy240, yymsp[0].minor.yy626); |
| 164489 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy254, yymsp[0].minor.yy528); |
| 164256 | 164490 | } |
| 164257 | 164491 | break; |
| 164258 | 164492 | case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ |
| 164259 | 164493 | { |
| 164260 | | - sqlite3Insert(pParse, yymsp[-3].minor.yy607, yymsp[-1].minor.yy303, yymsp[-2].minor.yy240, yymsp[-5].minor.yy64, yymsp[0].minor.yy138); |
| 164494 | + sqlite3Insert(pParse, yymsp[-3].minor.yy131, yymsp[-1].minor.yy47, yymsp[-2].minor.yy254, yymsp[-5].minor.yy394, yymsp[0].minor.yy444); |
| 164261 | 164495 | } |
| 164262 | 164496 | break; |
| 164263 | 164497 | case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ |
| 164264 | 164498 | { |
| 164265 | | - sqlite3Insert(pParse, yymsp[-4].minor.yy607, 0, yymsp[-3].minor.yy240, yymsp[-6].minor.yy64, 0); |
| 164499 | + sqlite3Insert(pParse, yymsp[-4].minor.yy131, 0, yymsp[-3].minor.yy254, yymsp[-6].minor.yy394, 0); |
| 164266 | 164500 | } |
| 164267 | 164501 | break; |
| 164268 | 164502 | case 164: /* upsert ::= */ |
| 164269 | | -{ yymsp[1].minor.yy138 = 0; } |
| 164503 | +{ yymsp[1].minor.yy444 = 0; } |
| 164270 | 164504 | break; |
| 164271 | 164505 | case 165: /* upsert ::= RETURNING selcollist */ |
| 164272 | | -{ yymsp[-1].minor.yy138 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy562); } |
| 164506 | +{ yymsp[-1].minor.yy444 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy322); } |
| 164273 | 164507 | break; |
| 164274 | 164508 | case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ |
| 164275 | | -{ yymsp[-11].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy562,yymsp[-6].minor.yy626,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,yymsp[0].minor.yy138);} |
| 164509 | +{ yymsp[-11].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy322,yymsp[-6].minor.yy528,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,yymsp[0].minor.yy444);} |
| 164276 | 164510 | break; |
| 164277 | 164511 | case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ |
| 164278 | | -{ yymsp[-8].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy562,yymsp[-3].minor.yy626,0,0,yymsp[0].minor.yy138); } |
| 164512 | +{ yymsp[-8].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy322,yymsp[-3].minor.yy528,0,0,yymsp[0].minor.yy444); } |
| 164279 | 164513 | break; |
| 164280 | 164514 | case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */ |
| 164281 | | -{ yymsp[-4].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } |
| 164515 | +{ yymsp[-4].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } |
| 164282 | 164516 | break; |
| 164283 | 164517 | case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ |
| 164284 | | -{ yymsp[-7].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,0);} |
| 164518 | +{ yymsp[-7].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,0);} |
| 164285 | 164519 | break; |
| 164286 | 164520 | case 170: /* returning ::= RETURNING selcollist */ |
| 164287 | | -{sqlite3AddReturning(pParse,yymsp[0].minor.yy562);} |
| 164521 | +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322);} |
| 164288 | 164522 | break; |
| 164289 | 164523 | case 174: /* idlist_opt ::= LP idlist RP */ |
| 164290 | | -{yymsp[-2].minor.yy240 = yymsp[-1].minor.yy240;} |
| 164524 | +{yymsp[-2].minor.yy254 = yymsp[-1].minor.yy254;} |
| 164291 | 164525 | break; |
| 164292 | 164526 | case 175: /* idlist ::= idlist COMMA nm */ |
| 164293 | | -{yymsp[-2].minor.yy240 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy240,&yymsp[0].minor.yy0);} |
| 164527 | +{yymsp[-2].minor.yy254 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);} |
| 164294 | 164528 | break; |
| 164295 | 164529 | case 176: /* idlist ::= nm */ |
| 164296 | | -{yymsp[0].minor.yy240 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} |
| 164530 | +{yymsp[0].minor.yy254 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} |
| 164297 | 164531 | break; |
| 164298 | 164532 | case 177: /* expr ::= LP expr RP */ |
| 164299 | | -{yymsp[-2].minor.yy626 = yymsp[-1].minor.yy626;} |
| 164533 | +{yymsp[-2].minor.yy528 = yymsp[-1].minor.yy528;} |
| 164300 | 164534 | break; |
| 164301 | 164535 | case 178: /* expr ::= ID|INDEXED */ |
| 164302 | 164536 | case 179: /* expr ::= JOIN_KW */ yytestcase(yyruleno==179); |
| 164303 | | -{yymsp[0].minor.yy626=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164537 | +{yymsp[0].minor.yy528=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164304 | 164538 | break; |
| 164305 | 164539 | case 180: /* expr ::= nm DOT nm */ |
| 164306 | 164540 | { |
| 164307 | 164541 | Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); |
| 164308 | 164542 | Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1); |
| 164309 | 164543 | if( IN_RENAME_OBJECT ){ |
| 164310 | 164544 | sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0); |
| 164311 | 164545 | sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0); |
| 164312 | 164546 | } |
| 164313 | | - yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); |
| 164547 | + yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); |
| 164314 | 164548 | } |
| 164315 | | - yymsp[-2].minor.yy626 = yylhsminor.yy626; |
| 164549 | + yymsp[-2].minor.yy528 = yylhsminor.yy528; |
| 164316 | 164550 | break; |
| 164317 | 164551 | case 181: /* expr ::= nm DOT nm DOT nm */ |
| 164318 | 164552 | { |
| 164319 | 164553 | Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1); |
| 164320 | 164554 | Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); |
| | @@ -164322,768 +164556,776 @@ |
| 164322 | 164556 | Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); |
| 164323 | 164557 | if( IN_RENAME_OBJECT ){ |
| 164324 | 164558 | sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0); |
| 164325 | 164559 | sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0); |
| 164326 | 164560 | } |
| 164327 | | - yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); |
| 164561 | + yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); |
| 164328 | 164562 | } |
| 164329 | | - yymsp[-4].minor.yy626 = yylhsminor.yy626; |
| 164563 | + yymsp[-4].minor.yy528 = yylhsminor.yy528; |
| 164330 | 164564 | break; |
| 164331 | 164565 | case 182: /* term ::= NULL|FLOAT|BLOB */ |
| 164332 | 164566 | case 183: /* term ::= STRING */ yytestcase(yyruleno==183); |
| 164333 | | -{yymsp[0].minor.yy626=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164567 | +{yymsp[0].minor.yy528=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} |
| 164334 | 164568 | break; |
| 164335 | 164569 | case 184: /* term ::= INTEGER */ |
| 164336 | 164570 | { |
| 164337 | | - yylhsminor.yy626 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); |
| 164571 | + yylhsminor.yy528 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); |
| 164338 | 164572 | } |
| 164339 | | - yymsp[0].minor.yy626 = yylhsminor.yy626; |
| 164573 | + yymsp[0].minor.yy528 = yylhsminor.yy528; |
| 164340 | 164574 | break; |
| 164341 | 164575 | case 185: /* expr ::= VARIABLE */ |
| 164342 | 164576 | { |
| 164343 | 164577 | if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){ |
| 164344 | 164578 | u32 n = yymsp[0].minor.yy0.n; |
| 164345 | | - yymsp[0].minor.yy626 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); |
| 164346 | | - sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy626, n); |
| 164579 | + yymsp[0].minor.yy528 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); |
| 164580 | + sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy528, n); |
| 164347 | 164581 | }else{ |
| 164348 | 164582 | /* When doing a nested parse, one can include terms in an expression |
| 164349 | 164583 | ** that look like this: #1 #2 ... These terms refer to registers |
| 164350 | 164584 | ** in the virtual machine. #N is the N-th register. */ |
| 164351 | 164585 | Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/ |
| 164352 | 164586 | assert( t.n>=2 ); |
| 164353 | 164587 | if( pParse->nested==0 ){ |
| 164354 | 164588 | sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); |
| 164355 | | - yymsp[0].minor.yy626 = 0; |
| 164589 | + yymsp[0].minor.yy528 = 0; |
| 164356 | 164590 | }else{ |
| 164357 | | - yymsp[0].minor.yy626 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); |
| 164358 | | - if( yymsp[0].minor.yy626 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy626->iTable); |
| 164591 | + yymsp[0].minor.yy528 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); |
| 164592 | + if( yymsp[0].minor.yy528 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy528->iTable); |
| 164359 | 164593 | } |
| 164360 | 164594 | } |
| 164361 | 164595 | } |
| 164362 | 164596 | break; |
| 164363 | 164597 | case 186: /* expr ::= expr COLLATE ID|STRING */ |
| 164364 | 164598 | { |
| 164365 | | - yymsp[-2].minor.yy626 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy626, &yymsp[0].minor.yy0, 1); |
| 164599 | + yymsp[-2].minor.yy528 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy528, &yymsp[0].minor.yy0, 1); |
| 164366 | 164600 | } |
| 164367 | 164601 | break; |
| 164368 | 164602 | case 187: /* expr ::= CAST LP expr AS typetoken RP */ |
| 164369 | 164603 | { |
| 164370 | | - yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); |
| 164371 | | - sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy626, yymsp[-3].minor.yy626, 0); |
| 164604 | + yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); |
| 164605 | + sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy528, yymsp[-3].minor.yy528, 0); |
| 164372 | 164606 | } |
| 164373 | 164607 | break; |
| 164374 | 164608 | case 188: /* expr ::= ID|INDEXED LP distinct exprlist RP */ |
| 164375 | 164609 | { |
| 164376 | | - yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy64); |
| 164610 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy394); |
| 164377 | 164611 | } |
| 164378 | | - yymsp[-4].minor.yy626 = yylhsminor.yy626; |
| 164612 | + yymsp[-4].minor.yy528 = yylhsminor.yy528; |
| 164379 | 164613 | break; |
| 164380 | 164614 | case 189: /* expr ::= ID|INDEXED LP STAR RP */ |
| 164381 | 164615 | { |
| 164382 | | - yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); |
| 164616 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); |
| 164383 | 164617 | } |
| 164384 | | - yymsp[-3].minor.yy626 = yylhsminor.yy626; |
| 164618 | + yymsp[-3].minor.yy528 = yylhsminor.yy528; |
| 164385 | 164619 | break; |
| 164386 | 164620 | case 190: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ |
| 164387 | 164621 | { |
| 164388 | | - yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy562, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy64); |
| 164389 | | - sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375); |
| 164622 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy322, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy394); |
| 164623 | + sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41); |
| 164390 | 164624 | } |
| 164391 | | - yymsp[-5].minor.yy626 = yylhsminor.yy626; |
| 164625 | + yymsp[-5].minor.yy528 = yylhsminor.yy528; |
| 164392 | 164626 | break; |
| 164393 | 164627 | case 191: /* expr ::= ID|INDEXED LP STAR RP filter_over */ |
| 164394 | 164628 | { |
| 164395 | | - yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); |
| 164396 | | - sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375); |
| 164629 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); |
| 164630 | + sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41); |
| 164397 | 164631 | } |
| 164398 | | - yymsp[-4].minor.yy626 = yylhsminor.yy626; |
| 164632 | + yymsp[-4].minor.yy528 = yylhsminor.yy528; |
| 164399 | 164633 | break; |
| 164400 | 164634 | case 192: /* term ::= CTIME_KW */ |
| 164401 | 164635 | { |
| 164402 | | - yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); |
| 164636 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); |
| 164403 | 164637 | } |
| 164404 | | - yymsp[0].minor.yy626 = yylhsminor.yy626; |
| 164638 | + yymsp[0].minor.yy528 = yylhsminor.yy528; |
| 164405 | 164639 | break; |
| 164406 | 164640 | case 193: /* expr ::= LP nexprlist COMMA expr RP */ |
| 164407 | 164641 | { |
| 164408 | | - ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626); |
| 164409 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); |
| 164410 | | - if( yymsp[-4].minor.yy626 ){ |
| 164411 | | - yymsp[-4].minor.yy626->x.pList = pList; |
| 164642 | + ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528); |
| 164643 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); |
| 164644 | + if( yymsp[-4].minor.yy528 ){ |
| 164645 | + yymsp[-4].minor.yy528->x.pList = pList; |
| 164412 | 164646 | if( ALWAYS(pList->nExpr) ){ |
| 164413 | | - yymsp[-4].minor.yy626->flags |= pList->a[0].pExpr->flags & EP_Propagate; |
| 164647 | + yymsp[-4].minor.yy528->flags |= pList->a[0].pExpr->flags & EP_Propagate; |
| 164414 | 164648 | } |
| 164415 | 164649 | }else{ |
| 164416 | 164650 | sqlite3ExprListDelete(pParse->db, pList); |
| 164417 | 164651 | } |
| 164418 | 164652 | } |
| 164419 | 164653 | break; |
| 164420 | 164654 | case 194: /* expr ::= expr AND expr */ |
| 164421 | | -{yymsp[-2].minor.yy626=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} |
| 164655 | +{yymsp[-2].minor.yy528=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} |
| 164422 | 164656 | break; |
| 164423 | 164657 | case 195: /* expr ::= expr OR expr */ |
| 164424 | 164658 | case 196: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==196); |
| 164425 | 164659 | case 197: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==197); |
| 164426 | 164660 | case 198: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==198); |
| 164427 | 164661 | case 199: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==199); |
| 164428 | 164662 | case 200: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==200); |
| 164429 | 164663 | case 201: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==201); |
| 164430 | | -{yymsp[-2].minor.yy626=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);} |
| 164664 | +{yymsp[-2].minor.yy528=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} |
| 164431 | 164665 | break; |
| 164432 | 164666 | case 202: /* likeop ::= NOT LIKE_KW|MATCH */ |
| 164433 | 164667 | {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/} |
| 164434 | 164668 | break; |
| 164435 | 164669 | case 203: /* expr ::= expr likeop expr */ |
| 164436 | 164670 | { |
| 164437 | 164671 | ExprList *pList; |
| 164438 | 164672 | int bNot = yymsp[-1].minor.yy0.n & 0x80000000; |
| 164439 | 164673 | yymsp[-1].minor.yy0.n &= 0x7fffffff; |
| 164440 | | - pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy626); |
| 164441 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy626); |
| 164442 | | - yymsp[-2].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 164443 | | - if( bNot ) yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy626, 0); |
| 164444 | | - if( yymsp[-2].minor.yy626 ) yymsp[-2].minor.yy626->flags |= EP_InfixFunc; |
| 164674 | + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy528); |
| 164675 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy528); |
| 164676 | + yymsp[-2].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 164677 | + if( bNot ) yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy528, 0); |
| 164678 | + if( yymsp[-2].minor.yy528 ) yymsp[-2].minor.yy528->flags |= EP_InfixFunc; |
| 164445 | 164679 | } |
| 164446 | 164680 | break; |
| 164447 | 164681 | case 204: /* expr ::= expr likeop expr ESCAPE expr */ |
| 164448 | 164682 | { |
| 164449 | 164683 | ExprList *pList; |
| 164450 | 164684 | int bNot = yymsp[-3].minor.yy0.n & 0x80000000; |
| 164451 | 164685 | yymsp[-3].minor.yy0.n &= 0x7fffffff; |
| 164452 | | - pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); |
| 164453 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy626); |
| 164454 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626); |
| 164455 | | - yymsp[-4].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); |
| 164456 | | - if( bNot ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); |
| 164457 | | - if( yymsp[-4].minor.yy626 ) yymsp[-4].minor.yy626->flags |= EP_InfixFunc; |
| 164686 | + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); |
| 164687 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy528); |
| 164688 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528); |
| 164689 | + yymsp[-4].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); |
| 164690 | + if( bNot ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); |
| 164691 | + if( yymsp[-4].minor.yy528 ) yymsp[-4].minor.yy528->flags |= EP_InfixFunc; |
| 164458 | 164692 | } |
| 164459 | 164693 | break; |
| 164460 | 164694 | case 205: /* expr ::= expr ISNULL|NOTNULL */ |
| 164461 | | -{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy626,0);} |
| 164695 | +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy528,0);} |
| 164462 | 164696 | break; |
| 164463 | 164697 | case 206: /* expr ::= expr NOT NULL */ |
| 164464 | | -{yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy626,0);} |
| 164698 | +{yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy528,0);} |
| 164465 | 164699 | break; |
| 164466 | 164700 | case 207: /* expr ::= expr IS expr */ |
| 164467 | 164701 | { |
| 164468 | | - yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy626,yymsp[0].minor.yy626); |
| 164469 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-2].minor.yy626, TK_ISNULL); |
| 164702 | + yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy528,yymsp[0].minor.yy528); |
| 164703 | + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-2].minor.yy528, TK_ISNULL); |
| 164470 | 164704 | } |
| 164471 | 164705 | break; |
| 164472 | 164706 | case 208: /* expr ::= expr IS NOT expr */ |
| 164473 | 164707 | { |
| 164474 | | - yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy626,yymsp[0].minor.yy626); |
| 164475 | | - binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-3].minor.yy626, TK_NOTNULL); |
| 164708 | + yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy528,yymsp[0].minor.yy528); |
| 164709 | + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-3].minor.yy528, TK_NOTNULL); |
| 164476 | 164710 | } |
| 164477 | 164711 | break; |
| 164478 | 164712 | case 209: /* expr ::= NOT expr */ |
| 164479 | 164713 | case 210: /* expr ::= BITNOT expr */ yytestcase(yyruleno==210); |
| 164480 | | -{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy626, 0);/*A-overwrites-B*/} |
| 164714 | +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy528, 0);/*A-overwrites-B*/} |
| 164481 | 164715 | break; |
| 164482 | 164716 | case 211: /* expr ::= PLUS|MINUS expr */ |
| 164483 | 164717 | { |
| 164484 | | - yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy626, 0); |
| 164718 | + yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy528, 0); |
| 164485 | 164719 | /*A-overwrites-B*/ |
| 164486 | 164720 | } |
| 164487 | 164721 | break; |
| 164488 | | - case 212: /* between_op ::= BETWEEN */ |
| 164489 | | - case 215: /* in_op ::= IN */ yytestcase(yyruleno==215); |
| 164490 | | -{yymsp[0].minor.yy64 = 0;} |
| 164722 | + case 212: /* expr ::= expr PTR expr */ |
| 164723 | +{ |
| 164724 | + ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy528); |
| 164725 | + pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy528); |
| 164726 | + yylhsminor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); |
| 164727 | +} |
| 164728 | + yymsp[-2].minor.yy528 = yylhsminor.yy528; |
| 164491 | 164729 | break; |
| 164492 | | - case 214: /* expr ::= expr between_op expr AND expr */ |
| 164730 | + case 213: /* between_op ::= BETWEEN */ |
| 164731 | + case 216: /* in_op ::= IN */ yytestcase(yyruleno==216); |
| 164732 | +{yymsp[0].minor.yy394 = 0;} |
| 164733 | + break; |
| 164734 | + case 215: /* expr ::= expr between_op expr AND expr */ |
| 164493 | 164735 | { |
| 164494 | | - ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); |
| 164495 | | - pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626); |
| 164496 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy626, 0); |
| 164497 | | - if( yymsp[-4].minor.yy626 ){ |
| 164498 | | - yymsp[-4].minor.yy626->x.pList = pList; |
| 164736 | + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); |
| 164737 | + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528); |
| 164738 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy528, 0); |
| 164739 | + if( yymsp[-4].minor.yy528 ){ |
| 164740 | + yymsp[-4].minor.yy528->x.pList = pList; |
| 164499 | 164741 | }else{ |
| 164500 | 164742 | sqlite3ExprListDelete(pParse->db, pList); |
| 164501 | 164743 | } |
| 164502 | | - if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); |
| 164744 | + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); |
| 164503 | 164745 | } |
| 164504 | 164746 | break; |
| 164505 | | - case 217: /* expr ::= expr in_op LP exprlist RP */ |
| 164747 | + case 218: /* expr ::= expr in_op LP exprlist RP */ |
| 164506 | 164748 | { |
| 164507 | | - if( yymsp[-1].minor.yy562==0 ){ |
| 164749 | + if( yymsp[-1].minor.yy322==0 ){ |
| 164508 | 164750 | /* Expressions of the form |
| 164509 | 164751 | ** |
| 164510 | 164752 | ** expr1 IN () |
| 164511 | 164753 | ** expr1 NOT IN () |
| 164512 | 164754 | ** |
| 164513 | 164755 | ** simplify to constants 0 (false) and 1 (true), respectively, |
| 164514 | 164756 | ** regardless of the value of expr1. |
| 164515 | 164757 | */ |
| 164516 | | - sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy626); |
| 164517 | | - yymsp[-4].minor.yy626 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy64 ? "1" : "0"); |
| 164758 | + sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy528); |
| 164759 | + yymsp[-4].minor.yy528 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy394 ? "1" : "0"); |
| 164518 | 164760 | }else{ |
| 164519 | | - Expr *pRHS = yymsp[-1].minor.yy562->a[0].pExpr; |
| 164520 | | - if( yymsp[-1].minor.yy562->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy626->op!=TK_VECTOR ){ |
| 164521 | | - yymsp[-1].minor.yy562->a[0].pExpr = 0; |
| 164522 | | - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562); |
| 164761 | + Expr *pRHS = yymsp[-1].minor.yy322->a[0].pExpr; |
| 164762 | + if( yymsp[-1].minor.yy322->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy528->op!=TK_VECTOR ){ |
| 164763 | + yymsp[-1].minor.yy322->a[0].pExpr = 0; |
| 164764 | + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322); |
| 164523 | 164765 | pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); |
| 164524 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy626, pRHS); |
| 164766 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy528, pRHS); |
| 164525 | 164767 | }else{ |
| 164526 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); |
| 164527 | | - if( yymsp[-4].minor.yy626==0 ){ |
| 164528 | | - sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562); |
| 164529 | | - }else if( yymsp[-4].minor.yy626->pLeft->op==TK_VECTOR ){ |
| 164530 | | - int nExpr = yymsp[-4].minor.yy626->pLeft->x.pList->nExpr; |
| 164531 | | - Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy562); |
| 164768 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); |
| 164769 | + if( yymsp[-4].minor.yy528==0 ){ |
| 164770 | + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322); |
| 164771 | + }else if( yymsp[-4].minor.yy528->pLeft->op==TK_VECTOR ){ |
| 164772 | + int nExpr = yymsp[-4].minor.yy528->pLeft->x.pList->nExpr; |
| 164773 | + Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy322); |
| 164532 | 164774 | if( pSelectRHS ){ |
| 164533 | 164775 | parserDoubleLinkSelect(pParse, pSelectRHS); |
| 164534 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelectRHS); |
| 164535 | | - } |
| 164536 | | - }else{ |
| 164537 | | - yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy562; |
| 164538 | | - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626); |
| 164539 | | - } |
| 164540 | | - } |
| 164541 | | - if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); |
| 164542 | | - } |
| 164543 | | - } |
| 164544 | | - break; |
| 164545 | | - case 218: /* expr ::= LP select RP */ |
| 164546 | | -{ |
| 164547 | | - yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); |
| 164548 | | - sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy626, yymsp[-1].minor.yy303); |
| 164549 | | - } |
| 164550 | | - break; |
| 164551 | | - case 219: /* expr ::= expr in_op LP select RP */ |
| 164552 | | -{ |
| 164553 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); |
| 164554 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, yymsp[-1].minor.yy303); |
| 164555 | | - if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); |
| 164556 | | - } |
| 164557 | | - break; |
| 164558 | | - case 220: /* expr ::= expr in_op nm dbnm paren_exprlist */ |
| 164776 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelectRHS); |
| 164777 | + } |
| 164778 | + }else{ |
| 164779 | + yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy322; |
| 164780 | + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528); |
| 164781 | + } |
| 164782 | + } |
| 164783 | + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); |
| 164784 | + } |
| 164785 | + } |
| 164786 | + break; |
| 164787 | + case 219: /* expr ::= LP select RP */ |
| 164788 | +{ |
| 164789 | + yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); |
| 164790 | + sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy528, yymsp[-1].minor.yy47); |
| 164791 | + } |
| 164792 | + break; |
| 164793 | + case 220: /* expr ::= expr in_op LP select RP */ |
| 164794 | +{ |
| 164795 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); |
| 164796 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, yymsp[-1].minor.yy47); |
| 164797 | + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); |
| 164798 | + } |
| 164799 | + break; |
| 164800 | + case 221: /* expr ::= expr in_op nm dbnm paren_exprlist */ |
| 164559 | 164801 | { |
| 164560 | 164802 | SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); |
| 164561 | 164803 | Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); |
| 164562 | | - if( yymsp[0].minor.yy562 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy562); |
| 164563 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0); |
| 164564 | | - sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelect); |
| 164565 | | - if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0); |
| 164804 | + if( yymsp[0].minor.yy322 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy322); |
| 164805 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); |
| 164806 | + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelect); |
| 164807 | + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); |
| 164566 | 164808 | } |
| 164567 | 164809 | break; |
| 164568 | | - case 221: /* expr ::= EXISTS LP select RP */ |
| 164810 | + case 222: /* expr ::= EXISTS LP select RP */ |
| 164569 | 164811 | { |
| 164570 | 164812 | Expr *p; |
| 164571 | | - p = yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); |
| 164572 | | - sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy303); |
| 164573 | | - } |
| 164574 | | - break; |
| 164575 | | - case 222: /* expr ::= CASE case_operand case_exprlist case_else END */ |
| 164576 | | -{ |
| 164577 | | - yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy626, 0); |
| 164578 | | - if( yymsp[-4].minor.yy626 ){ |
| 164579 | | - yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy626 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626) : yymsp[-2].minor.yy562; |
| 164580 | | - sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626); |
| 164581 | | - }else{ |
| 164582 | | - sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy562); |
| 164583 | | - sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626); |
| 164584 | | - } |
| 164585 | | -} |
| 164586 | | - break; |
| 164587 | | - case 223: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 164588 | | -{ |
| 164589 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[-2].minor.yy626); |
| 164590 | | - yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[0].minor.yy626); |
| 164591 | | -} |
| 164592 | | - break; |
| 164593 | | - case 224: /* case_exprlist ::= WHEN expr THEN expr */ |
| 164594 | | -{ |
| 164595 | | - yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626); |
| 164596 | | - yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy562, yymsp[0].minor.yy626); |
| 164597 | | -} |
| 164598 | | - break; |
| 164599 | | - case 227: /* case_operand ::= expr */ |
| 164600 | | -{yymsp[0].minor.yy626 = yymsp[0].minor.yy626; /*A-overwrites-X*/} |
| 164601 | | - break; |
| 164602 | | - case 230: /* nexprlist ::= nexprlist COMMA expr */ |
| 164603 | | -{yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[0].minor.yy626);} |
| 164604 | | - break; |
| 164605 | | - case 231: /* nexprlist ::= expr */ |
| 164606 | | -{yymsp[0].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy626); /*A-overwrites-Y*/} |
| 164607 | | - break; |
| 164608 | | - case 233: /* paren_exprlist ::= LP exprlist RP */ |
| 164609 | | - case 238: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==238); |
| 164610 | | -{yymsp[-2].minor.yy562 = yymsp[-1].minor.yy562;} |
| 164611 | | - break; |
| 164612 | | - case 234: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 164813 | + p = yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); |
| 164814 | + sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy47); |
| 164815 | + } |
| 164816 | + break; |
| 164817 | + case 223: /* expr ::= CASE case_operand case_exprlist case_else END */ |
| 164818 | +{ |
| 164819 | + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy528, 0); |
| 164820 | + if( yymsp[-4].minor.yy528 ){ |
| 164821 | + yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy528 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528) : yymsp[-2].minor.yy322; |
| 164822 | + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528); |
| 164823 | + }else{ |
| 164824 | + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322); |
| 164825 | + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528); |
| 164826 | + } |
| 164827 | +} |
| 164828 | + break; |
| 164829 | + case 224: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ |
| 164830 | +{ |
| 164831 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy528); |
| 164832 | + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[0].minor.yy528); |
| 164833 | +} |
| 164834 | + break; |
| 164835 | + case 225: /* case_exprlist ::= WHEN expr THEN expr */ |
| 164836 | +{ |
| 164837 | + yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); |
| 164838 | + yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, yymsp[0].minor.yy528); |
| 164839 | +} |
| 164840 | + break; |
| 164841 | + case 228: /* case_operand ::= expr */ |
| 164842 | +{yymsp[0].minor.yy528 = yymsp[0].minor.yy528; /*A-overwrites-X*/} |
| 164843 | + break; |
| 164844 | + case 231: /* nexprlist ::= nexprlist COMMA expr */ |
| 164845 | +{yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy528);} |
| 164846 | + break; |
| 164847 | + case 232: /* nexprlist ::= expr */ |
| 164848 | +{yymsp[0].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy528); /*A-overwrites-Y*/} |
| 164849 | + break; |
| 164850 | + case 234: /* paren_exprlist ::= LP exprlist RP */ |
| 164851 | + case 239: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==239); |
| 164852 | +{yymsp[-2].minor.yy322 = yymsp[-1].minor.yy322;} |
| 164853 | + break; |
| 164854 | + case 235: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ |
| 164613 | 164855 | { |
| 164614 | 164856 | sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, |
| 164615 | | - sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy562, yymsp[-10].minor.yy64, |
| 164616 | | - &yymsp[-11].minor.yy0, yymsp[0].minor.yy626, SQLITE_SO_ASC, yymsp[-8].minor.yy64, SQLITE_IDXTYPE_APPDEF); |
| 164857 | + sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy322, yymsp[-10].minor.yy394, |
| 164858 | + &yymsp[-11].minor.yy0, yymsp[0].minor.yy528, SQLITE_SO_ASC, yymsp[-8].minor.yy394, SQLITE_IDXTYPE_APPDEF); |
| 164617 | 164859 | if( IN_RENAME_OBJECT && pParse->pNewIndex ){ |
| 164618 | 164860 | sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); |
| 164619 | 164861 | } |
| 164620 | 164862 | } |
| 164621 | 164863 | break; |
| 164622 | | - case 235: /* uniqueflag ::= UNIQUE */ |
| 164623 | | - case 277: /* raisetype ::= ABORT */ yytestcase(yyruleno==277); |
| 164624 | | -{yymsp[0].minor.yy64 = OE_Abort;} |
| 164625 | | - break; |
| 164626 | | - case 236: /* uniqueflag ::= */ |
| 164627 | | -{yymsp[1].minor.yy64 = OE_None;} |
| 164628 | | - break; |
| 164629 | | - case 239: /* eidlist ::= eidlist COMMA nm collate sortorder */ |
| 164630 | | -{ |
| 164631 | | - yymsp[-4].minor.yy562 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64); |
| 164632 | | -} |
| 164633 | | - break; |
| 164634 | | - case 240: /* eidlist ::= nm collate sortorder */ |
| 164635 | | -{ |
| 164636 | | - yymsp[-2].minor.yy562 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64); /*A-overwrites-Y*/ |
| 164637 | | -} |
| 164638 | | - break; |
| 164639 | | - case 243: /* cmd ::= DROP INDEX ifexists fullname */ |
| 164640 | | -{sqlite3DropIndex(pParse, yymsp[0].minor.yy607, yymsp[-1].minor.yy64);} |
| 164641 | | - break; |
| 164642 | | - case 244: /* cmd ::= VACUUM vinto */ |
| 164643 | | -{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy626);} |
| 164644 | | - break; |
| 164645 | | - case 245: /* cmd ::= VACUUM nm vinto */ |
| 164646 | | -{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy626);} |
| 164647 | | - break; |
| 164648 | | - case 248: /* cmd ::= PRAGMA nm dbnm */ |
| 164864 | + case 236: /* uniqueflag ::= UNIQUE */ |
| 164865 | + case 278: /* raisetype ::= ABORT */ yytestcase(yyruleno==278); |
| 164866 | +{yymsp[0].minor.yy394 = OE_Abort;} |
| 164867 | + break; |
| 164868 | + case 237: /* uniqueflag ::= */ |
| 164869 | +{yymsp[1].minor.yy394 = OE_None;} |
| 164870 | + break; |
| 164871 | + case 240: /* eidlist ::= eidlist COMMA nm collate sortorder */ |
| 164872 | +{ |
| 164873 | + yymsp[-4].minor.yy322 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394); |
| 164874 | +} |
| 164875 | + break; |
| 164876 | + case 241: /* eidlist ::= nm collate sortorder */ |
| 164877 | +{ |
| 164878 | + yymsp[-2].minor.yy322 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394); /*A-overwrites-Y*/ |
| 164879 | +} |
| 164880 | + break; |
| 164881 | + case 244: /* cmd ::= DROP INDEX ifexists fullname */ |
| 164882 | +{sqlite3DropIndex(pParse, yymsp[0].minor.yy131, yymsp[-1].minor.yy394);} |
| 164883 | + break; |
| 164884 | + case 245: /* cmd ::= VACUUM vinto */ |
| 164885 | +{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy528);} |
| 164886 | + break; |
| 164887 | + case 246: /* cmd ::= VACUUM nm vinto */ |
| 164888 | +{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy528);} |
| 164889 | + break; |
| 164890 | + case 249: /* cmd ::= PRAGMA nm dbnm */ |
| 164649 | 164891 | {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} |
| 164650 | 164892 | break; |
| 164651 | | - case 249: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 164893 | + case 250: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ |
| 164652 | 164894 | {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} |
| 164653 | 164895 | break; |
| 164654 | | - case 250: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 164896 | + case 251: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ |
| 164655 | 164897 | {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} |
| 164656 | 164898 | break; |
| 164657 | | - case 251: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 164899 | + case 252: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ |
| 164658 | 164900 | {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} |
| 164659 | 164901 | break; |
| 164660 | | - case 252: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 164902 | + case 253: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ |
| 164661 | 164903 | {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);} |
| 164662 | 164904 | break; |
| 164663 | | - case 255: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 164905 | + case 256: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ |
| 164664 | 164906 | { |
| 164665 | 164907 | Token all; |
| 164666 | 164908 | all.z = yymsp[-3].minor.yy0.z; |
| 164667 | 164909 | all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; |
| 164668 | | - sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy95, &all); |
| 164910 | + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy33, &all); |
| 164669 | 164911 | } |
| 164670 | 164912 | break; |
| 164671 | | - case 256: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 164913 | + case 257: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ |
| 164672 | 164914 | { |
| 164673 | | - sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy64, yymsp[-4].minor.yy570.a, yymsp[-4].minor.yy570.b, yymsp[-2].minor.yy607, yymsp[0].minor.yy626, yymsp[-10].minor.yy64, yymsp[-8].minor.yy64); |
| 164915 | + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy394, yymsp[-4].minor.yy180.a, yymsp[-4].minor.yy180.b, yymsp[-2].minor.yy131, yymsp[0].minor.yy528, yymsp[-10].minor.yy394, yymsp[-8].minor.yy394); |
| 164674 | 164916 | yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/ |
| 164675 | 164917 | } |
| 164676 | 164918 | break; |
| 164677 | | - case 257: /* trigger_time ::= BEFORE|AFTER */ |
| 164678 | | -{ yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/ } |
| 164679 | | - break; |
| 164680 | | - case 258: /* trigger_time ::= INSTEAD OF */ |
| 164681 | | -{ yymsp[-1].minor.yy64 = TK_INSTEAD;} |
| 164682 | | - break; |
| 164683 | | - case 259: /* trigger_time ::= */ |
| 164684 | | -{ yymsp[1].minor.yy64 = TK_BEFORE; } |
| 164685 | | - break; |
| 164686 | | - case 260: /* trigger_event ::= DELETE|INSERT */ |
| 164687 | | - case 261: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==261); |
| 164688 | | -{yymsp[0].minor.yy570.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy570.b = 0;} |
| 164689 | | - break; |
| 164690 | | - case 262: /* trigger_event ::= UPDATE OF idlist */ |
| 164691 | | -{yymsp[-2].minor.yy570.a = TK_UPDATE; yymsp[-2].minor.yy570.b = yymsp[0].minor.yy240;} |
| 164692 | | - break; |
| 164693 | | - case 263: /* when_clause ::= */ |
| 164694 | | - case 282: /* key_opt ::= */ yytestcase(yyruleno==282); |
| 164695 | | -{ yymsp[1].minor.yy626 = 0; } |
| 164696 | | - break; |
| 164697 | | - case 264: /* when_clause ::= WHEN expr */ |
| 164698 | | - case 283: /* key_opt ::= KEY expr */ yytestcase(yyruleno==283); |
| 164699 | | -{ yymsp[-1].minor.yy626 = yymsp[0].minor.yy626; } |
| 164700 | | - break; |
| 164701 | | - case 265: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 164702 | | -{ |
| 164703 | | - assert( yymsp[-2].minor.yy95!=0 ); |
| 164704 | | - yymsp[-2].minor.yy95->pLast->pNext = yymsp[-1].minor.yy95; |
| 164705 | | - yymsp[-2].minor.yy95->pLast = yymsp[-1].minor.yy95; |
| 164706 | | -} |
| 164707 | | - break; |
| 164708 | | - case 266: /* trigger_cmd_list ::= trigger_cmd SEMI */ |
| 164709 | | -{ |
| 164710 | | - assert( yymsp[-1].minor.yy95!=0 ); |
| 164711 | | - yymsp[-1].minor.yy95->pLast = yymsp[-1].minor.yy95; |
| 164712 | | -} |
| 164713 | | - break; |
| 164714 | | - case 267: /* trnm ::= nm DOT nm */ |
| 164919 | + case 258: /* trigger_time ::= BEFORE|AFTER */ |
| 164920 | +{ yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/ } |
| 164921 | + break; |
| 164922 | + case 259: /* trigger_time ::= INSTEAD OF */ |
| 164923 | +{ yymsp[-1].minor.yy394 = TK_INSTEAD;} |
| 164924 | + break; |
| 164925 | + case 260: /* trigger_time ::= */ |
| 164926 | +{ yymsp[1].minor.yy394 = TK_BEFORE; } |
| 164927 | + break; |
| 164928 | + case 261: /* trigger_event ::= DELETE|INSERT */ |
| 164929 | + case 262: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==262); |
| 164930 | +{yymsp[0].minor.yy180.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy180.b = 0;} |
| 164931 | + break; |
| 164932 | + case 263: /* trigger_event ::= UPDATE OF idlist */ |
| 164933 | +{yymsp[-2].minor.yy180.a = TK_UPDATE; yymsp[-2].minor.yy180.b = yymsp[0].minor.yy254;} |
| 164934 | + break; |
| 164935 | + case 264: /* when_clause ::= */ |
| 164936 | + case 283: /* key_opt ::= */ yytestcase(yyruleno==283); |
| 164937 | +{ yymsp[1].minor.yy528 = 0; } |
| 164938 | + break; |
| 164939 | + case 265: /* when_clause ::= WHEN expr */ |
| 164940 | + case 284: /* key_opt ::= KEY expr */ yytestcase(yyruleno==284); |
| 164941 | +{ yymsp[-1].minor.yy528 = yymsp[0].minor.yy528; } |
| 164942 | + break; |
| 164943 | + case 266: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ |
| 164944 | +{ |
| 164945 | + assert( yymsp[-2].minor.yy33!=0 ); |
| 164946 | + yymsp[-2].minor.yy33->pLast->pNext = yymsp[-1].minor.yy33; |
| 164947 | + yymsp[-2].minor.yy33->pLast = yymsp[-1].minor.yy33; |
| 164948 | +} |
| 164949 | + break; |
| 164950 | + case 267: /* trigger_cmd_list ::= trigger_cmd SEMI */ |
| 164951 | +{ |
| 164952 | + assert( yymsp[-1].minor.yy33!=0 ); |
| 164953 | + yymsp[-1].minor.yy33->pLast = yymsp[-1].minor.yy33; |
| 164954 | +} |
| 164955 | + break; |
| 164956 | + case 268: /* trnm ::= nm DOT nm */ |
| 164715 | 164957 | { |
| 164716 | 164958 | yymsp[-2].minor.yy0 = yymsp[0].minor.yy0; |
| 164717 | 164959 | sqlite3ErrorMsg(pParse, |
| 164718 | 164960 | "qualified table names are not allowed on INSERT, UPDATE, and DELETE " |
| 164719 | 164961 | "statements within triggers"); |
| 164720 | 164962 | } |
| 164721 | 164963 | break; |
| 164722 | | - case 268: /* tridxby ::= INDEXED BY nm */ |
| 164964 | + case 269: /* tridxby ::= INDEXED BY nm */ |
| 164723 | 164965 | { |
| 164724 | 164966 | sqlite3ErrorMsg(pParse, |
| 164725 | 164967 | "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " |
| 164726 | 164968 | "within triggers"); |
| 164727 | 164969 | } |
| 164728 | 164970 | break; |
| 164729 | | - case 269: /* tridxby ::= NOT INDEXED */ |
| 164971 | + case 270: /* tridxby ::= NOT INDEXED */ |
| 164730 | 164972 | { |
| 164731 | 164973 | sqlite3ErrorMsg(pParse, |
| 164732 | 164974 | "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " |
| 164733 | 164975 | "within triggers"); |
| 164734 | 164976 | } |
| 164735 | 164977 | break; |
| 164736 | | - case 270: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 164737 | | -{yylhsminor.yy95 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy607, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626, yymsp[-7].minor.yy64, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy600);} |
| 164738 | | - yymsp[-8].minor.yy95 = yylhsminor.yy95; |
| 164739 | | - break; |
| 164740 | | - case 271: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 164741 | | -{ |
| 164742 | | - yylhsminor.yy95 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy240,yymsp[-2].minor.yy303,yymsp[-6].minor.yy64,yymsp[-1].minor.yy138,yymsp[-7].minor.yy600,yymsp[0].minor.yy600);/*yylhsminor.yy95-overwrites-yymsp[-6].minor.yy64*/ |
| 164743 | | -} |
| 164744 | | - yymsp[-7].minor.yy95 = yylhsminor.yy95; |
| 164745 | | - break; |
| 164746 | | - case 272: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 164747 | | -{yylhsminor.yy95 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy626, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy600);} |
| 164748 | | - yymsp[-5].minor.yy95 = yylhsminor.yy95; |
| 164749 | | - break; |
| 164750 | | - case 273: /* trigger_cmd ::= scanpt select scanpt */ |
| 164751 | | -{yylhsminor.yy95 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy303, yymsp[-2].minor.yy600, yymsp[0].minor.yy600); /*yylhsminor.yy95-overwrites-yymsp[-1].minor.yy303*/} |
| 164752 | | - yymsp[-2].minor.yy95 = yylhsminor.yy95; |
| 164753 | | - break; |
| 164754 | | - case 274: /* expr ::= RAISE LP IGNORE RP */ |
| 164755 | | -{ |
| 164756 | | - yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); |
| 164757 | | - if( yymsp[-3].minor.yy626 ){ |
| 164758 | | - yymsp[-3].minor.yy626->affExpr = OE_Ignore; |
| 164759 | | - } |
| 164760 | | -} |
| 164761 | | - break; |
| 164762 | | - case 275: /* expr ::= RAISE LP raisetype COMMA nm RP */ |
| 164763 | | -{ |
| 164764 | | - yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); |
| 164765 | | - if( yymsp[-5].minor.yy626 ) { |
| 164766 | | - yymsp[-5].minor.yy626->affExpr = (char)yymsp[-3].minor.yy64; |
| 164767 | | - } |
| 164768 | | -} |
| 164769 | | - break; |
| 164770 | | - case 276: /* raisetype ::= ROLLBACK */ |
| 164771 | | -{yymsp[0].minor.yy64 = OE_Rollback;} |
| 164772 | | - break; |
| 164773 | | - case 278: /* raisetype ::= FAIL */ |
| 164774 | | -{yymsp[0].minor.yy64 = OE_Fail;} |
| 164775 | | - break; |
| 164776 | | - case 279: /* cmd ::= DROP TRIGGER ifexists fullname */ |
| 164777 | | -{ |
| 164778 | | - sqlite3DropTrigger(pParse,yymsp[0].minor.yy607,yymsp[-1].minor.yy64); |
| 164779 | | -} |
| 164780 | | - break; |
| 164781 | | - case 280: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 164782 | | -{ |
| 164783 | | - sqlite3Attach(pParse, yymsp[-3].minor.yy626, yymsp[-1].minor.yy626, yymsp[0].minor.yy626); |
| 164784 | | -} |
| 164785 | | - break; |
| 164786 | | - case 281: /* cmd ::= DETACH database_kw_opt expr */ |
| 164787 | | -{ |
| 164788 | | - sqlite3Detach(pParse, yymsp[0].minor.yy626); |
| 164789 | | -} |
| 164790 | | - break; |
| 164791 | | - case 284: /* cmd ::= REINDEX */ |
| 164978 | + case 271: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ |
| 164979 | +{yylhsminor.yy33 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy131, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528, yymsp[-7].minor.yy394, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy522);} |
| 164980 | + yymsp[-8].minor.yy33 = yylhsminor.yy33; |
| 164981 | + break; |
| 164982 | + case 272: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ |
| 164983 | +{ |
| 164984 | + yylhsminor.yy33 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy254,yymsp[-2].minor.yy47,yymsp[-6].minor.yy394,yymsp[-1].minor.yy444,yymsp[-7].minor.yy522,yymsp[0].minor.yy522);/*yylhsminor.yy33-overwrites-yymsp[-6].minor.yy394*/ |
| 164985 | +} |
| 164986 | + yymsp[-7].minor.yy33 = yylhsminor.yy33; |
| 164987 | + break; |
| 164988 | + case 273: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ |
| 164989 | +{yylhsminor.yy33 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy528, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy522);} |
| 164990 | + yymsp[-5].minor.yy33 = yylhsminor.yy33; |
| 164991 | + break; |
| 164992 | + case 274: /* trigger_cmd ::= scanpt select scanpt */ |
| 164993 | +{yylhsminor.yy33 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy47, yymsp[-2].minor.yy522, yymsp[0].minor.yy522); /*yylhsminor.yy33-overwrites-yymsp[-1].minor.yy47*/} |
| 164994 | + yymsp[-2].minor.yy33 = yylhsminor.yy33; |
| 164995 | + break; |
| 164996 | + case 275: /* expr ::= RAISE LP IGNORE RP */ |
| 164997 | +{ |
| 164998 | + yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); |
| 164999 | + if( yymsp[-3].minor.yy528 ){ |
| 165000 | + yymsp[-3].minor.yy528->affExpr = OE_Ignore; |
| 165001 | + } |
| 165002 | +} |
| 165003 | + break; |
| 165004 | + case 276: /* expr ::= RAISE LP raisetype COMMA nm RP */ |
| 165005 | +{ |
| 165006 | + yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); |
| 165007 | + if( yymsp[-5].minor.yy528 ) { |
| 165008 | + yymsp[-5].minor.yy528->affExpr = (char)yymsp[-3].minor.yy394; |
| 165009 | + } |
| 165010 | +} |
| 165011 | + break; |
| 165012 | + case 277: /* raisetype ::= ROLLBACK */ |
| 165013 | +{yymsp[0].minor.yy394 = OE_Rollback;} |
| 165014 | + break; |
| 165015 | + case 279: /* raisetype ::= FAIL */ |
| 165016 | +{yymsp[0].minor.yy394 = OE_Fail;} |
| 165017 | + break; |
| 165018 | + case 280: /* cmd ::= DROP TRIGGER ifexists fullname */ |
| 165019 | +{ |
| 165020 | + sqlite3DropTrigger(pParse,yymsp[0].minor.yy131,yymsp[-1].minor.yy394); |
| 165021 | +} |
| 165022 | + break; |
| 165023 | + case 281: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ |
| 165024 | +{ |
| 165025 | + sqlite3Attach(pParse, yymsp[-3].minor.yy528, yymsp[-1].minor.yy528, yymsp[0].minor.yy528); |
| 165026 | +} |
| 165027 | + break; |
| 165028 | + case 282: /* cmd ::= DETACH database_kw_opt expr */ |
| 165029 | +{ |
| 165030 | + sqlite3Detach(pParse, yymsp[0].minor.yy528); |
| 165031 | +} |
| 165032 | + break; |
| 165033 | + case 285: /* cmd ::= REINDEX */ |
| 164792 | 165034 | {sqlite3Reindex(pParse, 0, 0);} |
| 164793 | 165035 | break; |
| 164794 | | - case 285: /* cmd ::= REINDEX nm dbnm */ |
| 165036 | + case 286: /* cmd ::= REINDEX nm dbnm */ |
| 164795 | 165037 | {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} |
| 164796 | 165038 | break; |
| 164797 | | - case 286: /* cmd ::= ANALYZE */ |
| 165039 | + case 287: /* cmd ::= ANALYZE */ |
| 164798 | 165040 | {sqlite3Analyze(pParse, 0, 0);} |
| 164799 | 165041 | break; |
| 164800 | | - case 287: /* cmd ::= ANALYZE nm dbnm */ |
| 165042 | + case 288: /* cmd ::= ANALYZE nm dbnm */ |
| 164801 | 165043 | {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} |
| 164802 | 165044 | break; |
| 164803 | | - case 288: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 165045 | + case 289: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ |
| 164804 | 165046 | { |
| 164805 | | - sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy607,&yymsp[0].minor.yy0); |
| 165047 | + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy131,&yymsp[0].minor.yy0); |
| 164806 | 165048 | } |
| 164807 | 165049 | break; |
| 164808 | | - case 289: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 165050 | + case 290: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ |
| 164809 | 165051 | { |
| 164810 | 165052 | yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n; |
| 164811 | 165053 | sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0); |
| 164812 | 165054 | } |
| 164813 | 165055 | break; |
| 164814 | | - case 290: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 165056 | + case 291: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ |
| 164815 | 165057 | { |
| 164816 | | - sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy607, &yymsp[0].minor.yy0); |
| 165058 | + sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy131, &yymsp[0].minor.yy0); |
| 164817 | 165059 | } |
| 164818 | 165060 | break; |
| 164819 | | - case 291: /* add_column_fullname ::= fullname */ |
| 165061 | + case 292: /* add_column_fullname ::= fullname */ |
| 164820 | 165062 | { |
| 164821 | 165063 | disableLookaside(pParse); |
| 164822 | | - sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy607); |
| 164823 | | -} |
| 164824 | | - break; |
| 164825 | | - case 292: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 164826 | | -{ |
| 164827 | | - sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy607, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
| 164828 | | -} |
| 164829 | | - break; |
| 164830 | | - case 293: /* cmd ::= create_vtab */ |
| 165064 | + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy131); |
| 165065 | +} |
| 165066 | + break; |
| 165067 | + case 293: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ |
| 165068 | +{ |
| 165069 | + sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy131, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
| 165070 | +} |
| 165071 | + break; |
| 165072 | + case 294: /* cmd ::= create_vtab */ |
| 164831 | 165073 | {sqlite3VtabFinishParse(pParse,0);} |
| 164832 | 165074 | break; |
| 164833 | | - case 294: /* cmd ::= create_vtab LP vtabarglist RP */ |
| 165075 | + case 295: /* cmd ::= create_vtab LP vtabarglist RP */ |
| 164834 | 165076 | {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} |
| 164835 | 165077 | break; |
| 164836 | | - case 295: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 165078 | + case 296: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ |
| 164837 | 165079 | { |
| 164838 | | - sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy64); |
| 165080 | + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy394); |
| 164839 | 165081 | } |
| 164840 | 165082 | break; |
| 164841 | | - case 296: /* vtabarg ::= */ |
| 165083 | + case 297: /* vtabarg ::= */ |
| 164842 | 165084 | {sqlite3VtabArgInit(pParse);} |
| 164843 | 165085 | break; |
| 164844 | | - case 297: /* vtabargtoken ::= ANY */ |
| 164845 | | - case 298: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==298); |
| 164846 | | - case 299: /* lp ::= LP */ yytestcase(yyruleno==299); |
| 165086 | + case 298: /* vtabargtoken ::= ANY */ |
| 165087 | + case 299: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==299); |
| 165088 | + case 300: /* lp ::= LP */ yytestcase(yyruleno==300); |
| 164847 | 165089 | {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} |
| 164848 | 165090 | break; |
| 164849 | | - case 300: /* with ::= WITH wqlist */ |
| 164850 | | - case 301: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==301); |
| 164851 | | -{ sqlite3WithPush(pParse, yymsp[0].minor.yy43, 1); } |
| 164852 | | - break; |
| 164853 | | - case 302: /* wqas ::= AS */ |
| 164854 | | -{yymsp[0].minor.yy534 = M10d_Any;} |
| 164855 | | - break; |
| 164856 | | - case 303: /* wqas ::= AS MATERIALIZED */ |
| 164857 | | -{yymsp[-1].minor.yy534 = M10d_Yes;} |
| 164858 | | - break; |
| 164859 | | - case 304: /* wqas ::= AS NOT MATERIALIZED */ |
| 164860 | | -{yymsp[-2].minor.yy534 = M10d_No;} |
| 164861 | | - break; |
| 164862 | | - case 305: /* wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 164863 | | -{ |
| 164864 | | - yymsp[-5].minor.yy255 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy562, yymsp[-1].minor.yy303, yymsp[-3].minor.yy534); /*A-overwrites-X*/ |
| 164865 | | -} |
| 164866 | | - break; |
| 164867 | | - case 306: /* wqlist ::= wqitem */ |
| 164868 | | -{ |
| 164869 | | - yymsp[0].minor.yy43 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy255); /*A-overwrites-X*/ |
| 164870 | | -} |
| 164871 | | - break; |
| 164872 | | - case 307: /* wqlist ::= wqlist COMMA wqitem */ |
| 164873 | | -{ |
| 164874 | | - yymsp[-2].minor.yy43 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy43, yymsp[0].minor.yy255); |
| 164875 | | -} |
| 164876 | | - break; |
| 164877 | | - case 308: /* windowdefn_list ::= windowdefn */ |
| 164878 | | -{ yylhsminor.yy375 = yymsp[0].minor.yy375; } |
| 164879 | | - yymsp[0].minor.yy375 = yylhsminor.yy375; |
| 164880 | | - break; |
| 164881 | | - case 309: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 164882 | | -{ |
| 164883 | | - assert( yymsp[0].minor.yy375!=0 ); |
| 164884 | | - sqlite3WindowChain(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy375); |
| 164885 | | - yymsp[0].minor.yy375->pNextWin = yymsp[-2].minor.yy375; |
| 164886 | | - yylhsminor.yy375 = yymsp[0].minor.yy375; |
| 164887 | | -} |
| 164888 | | - yymsp[-2].minor.yy375 = yylhsminor.yy375; |
| 164889 | | - break; |
| 164890 | | - case 310: /* windowdefn ::= nm AS LP window RP */ |
| 164891 | | -{ |
| 164892 | | - if( ALWAYS(yymsp[-1].minor.yy375) ){ |
| 164893 | | - yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); |
| 164894 | | - } |
| 164895 | | - yylhsminor.yy375 = yymsp[-1].minor.yy375; |
| 164896 | | -} |
| 164897 | | - yymsp[-4].minor.yy375 = yylhsminor.yy375; |
| 164898 | | - break; |
| 164899 | | - case 311: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 164900 | | -{ |
| 164901 | | - yymsp[-4].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, 0); |
| 164902 | | -} |
| 164903 | | - break; |
| 164904 | | - case 312: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 164905 | | -{ |
| 164906 | | - yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, &yymsp[-5].minor.yy0); |
| 164907 | | -} |
| 164908 | | - yymsp[-5].minor.yy375 = yylhsminor.yy375; |
| 164909 | | - break; |
| 164910 | | - case 313: /* window ::= ORDER BY sortlist frame_opt */ |
| 164911 | | -{ |
| 164912 | | - yymsp[-3].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, 0); |
| 164913 | | -} |
| 164914 | | - break; |
| 164915 | | - case 314: /* window ::= nm ORDER BY sortlist frame_opt */ |
| 164916 | | -{ |
| 164917 | | - yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0); |
| 164918 | | -} |
| 164919 | | - yymsp[-4].minor.yy375 = yylhsminor.yy375; |
| 164920 | | - break; |
| 164921 | | - case 315: /* window ::= frame_opt */ |
| 164922 | | - case 334: /* filter_over ::= over_clause */ yytestcase(yyruleno==334); |
| 164923 | | -{ |
| 164924 | | - yylhsminor.yy375 = yymsp[0].minor.yy375; |
| 164925 | | -} |
| 164926 | | - yymsp[0].minor.yy375 = yylhsminor.yy375; |
| 164927 | | - break; |
| 164928 | | - case 316: /* window ::= nm frame_opt */ |
| 164929 | | -{ |
| 164930 | | - yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, 0, &yymsp[-1].minor.yy0); |
| 164931 | | -} |
| 164932 | | - yymsp[-1].minor.yy375 = yylhsminor.yy375; |
| 164933 | | - break; |
| 164934 | | - case 317: /* frame_opt ::= */ |
| 164935 | | -{ |
| 164936 | | - yymsp[1].minor.yy375 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); |
| 164937 | | -} |
| 164938 | | - break; |
| 164939 | | - case 318: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 164940 | | -{ |
| 164941 | | - yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy64, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy534); |
| 164942 | | -} |
| 164943 | | - yymsp[-2].minor.yy375 = yylhsminor.yy375; |
| 164944 | | - break; |
| 164945 | | - case 319: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 164946 | | -{ |
| 164947 | | - yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy64, yymsp[-3].minor.yy81.eType, yymsp[-3].minor.yy81.pExpr, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, yymsp[0].minor.yy534); |
| 164948 | | -} |
| 164949 | | - yymsp[-5].minor.yy375 = yylhsminor.yy375; |
| 164950 | | - break; |
| 164951 | | - case 321: /* frame_bound_s ::= frame_bound */ |
| 164952 | | - case 323: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==323); |
| 164953 | | -{yylhsminor.yy81 = yymsp[0].minor.yy81;} |
| 164954 | | - yymsp[0].minor.yy81 = yylhsminor.yy81; |
| 164955 | | - break; |
| 164956 | | - case 322: /* frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 164957 | | - case 324: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==324); |
| 164958 | | - case 326: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==326); |
| 164959 | | -{yylhsminor.yy81.eType = yymsp[-1].major; yylhsminor.yy81.pExpr = 0;} |
| 164960 | | - yymsp[-1].minor.yy81 = yylhsminor.yy81; |
| 164961 | | - break; |
| 164962 | | - case 325: /* frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 164963 | | -{yylhsminor.yy81.eType = yymsp[0].major; yylhsminor.yy81.pExpr = yymsp[-1].minor.yy626;} |
| 164964 | | - yymsp[-1].minor.yy81 = yylhsminor.yy81; |
| 164965 | | - break; |
| 164966 | | - case 327: /* frame_exclude_opt ::= */ |
| 164967 | | -{yymsp[1].minor.yy534 = 0;} |
| 164968 | | - break; |
| 164969 | | - case 328: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 164970 | | -{yymsp[-1].minor.yy534 = yymsp[0].minor.yy534;} |
| 164971 | | - break; |
| 164972 | | - case 329: /* frame_exclude ::= NO OTHERS */ |
| 164973 | | - case 330: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==330); |
| 164974 | | -{yymsp[-1].minor.yy534 = yymsp[-1].major; /*A-overwrites-X*/} |
| 164975 | | - break; |
| 164976 | | - case 331: /* frame_exclude ::= GROUP|TIES */ |
| 164977 | | -{yymsp[0].minor.yy534 = yymsp[0].major; /*A-overwrites-X*/} |
| 164978 | | - break; |
| 164979 | | - case 332: /* window_clause ::= WINDOW windowdefn_list */ |
| 164980 | | -{ yymsp[-1].minor.yy375 = yymsp[0].minor.yy375; } |
| 164981 | | - break; |
| 164982 | | - case 333: /* filter_over ::= filter_clause over_clause */ |
| 164983 | | -{ |
| 164984 | | - if( yymsp[0].minor.yy375 ){ |
| 164985 | | - yymsp[0].minor.yy375->pFilter = yymsp[-1].minor.yy626; |
| 164986 | | - }else{ |
| 164987 | | - sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626); |
| 164988 | | - } |
| 164989 | | - yylhsminor.yy375 = yymsp[0].minor.yy375; |
| 164990 | | -} |
| 164991 | | - yymsp[-1].minor.yy375 = yylhsminor.yy375; |
| 164992 | | - break; |
| 164993 | | - case 335: /* filter_over ::= filter_clause */ |
| 164994 | | -{ |
| 164995 | | - yylhsminor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 164996 | | - if( yylhsminor.yy375 ){ |
| 164997 | | - yylhsminor.yy375->eFrmType = TK_FILTER; |
| 164998 | | - yylhsminor.yy375->pFilter = yymsp[0].minor.yy626; |
| 164999 | | - }else{ |
| 165000 | | - sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy626); |
| 165001 | | - } |
| 165002 | | -} |
| 165003 | | - yymsp[0].minor.yy375 = yylhsminor.yy375; |
| 165004 | | - break; |
| 165005 | | - case 336: /* over_clause ::= OVER LP window RP */ |
| 165006 | | -{ |
| 165007 | | - yymsp[-3].minor.yy375 = yymsp[-1].minor.yy375; |
| 165008 | | - assert( yymsp[-3].minor.yy375!=0 ); |
| 165009 | | -} |
| 165010 | | - break; |
| 165011 | | - case 337: /* over_clause ::= OVER nm */ |
| 165012 | | -{ |
| 165013 | | - yymsp[-1].minor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 165014 | | - if( yymsp[-1].minor.yy375 ){ |
| 165015 | | - yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); |
| 165016 | | - } |
| 165017 | | -} |
| 165018 | | - break; |
| 165019 | | - case 338: /* filter_clause ::= FILTER LP WHERE expr RP */ |
| 165020 | | -{ yymsp[-4].minor.yy626 = yymsp[-1].minor.yy626; } |
| 165091 | + case 301: /* with ::= WITH wqlist */ |
| 165092 | + case 302: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==302); |
| 165093 | +{ sqlite3WithPush(pParse, yymsp[0].minor.yy521, 1); } |
| 165094 | + break; |
| 165095 | + case 303: /* wqas ::= AS */ |
| 165096 | +{yymsp[0].minor.yy516 = M10d_Any;} |
| 165097 | + break; |
| 165098 | + case 304: /* wqas ::= AS MATERIALIZED */ |
| 165099 | +{yymsp[-1].minor.yy516 = M10d_Yes;} |
| 165100 | + break; |
| 165101 | + case 305: /* wqas ::= AS NOT MATERIALIZED */ |
| 165102 | +{yymsp[-2].minor.yy516 = M10d_No;} |
| 165103 | + break; |
| 165104 | + case 306: /* wqitem ::= nm eidlist_opt wqas LP select RP */ |
| 165105 | +{ |
| 165106 | + yymsp[-5].minor.yy385 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy322, yymsp[-1].minor.yy47, yymsp[-3].minor.yy516); /*A-overwrites-X*/ |
| 165107 | +} |
| 165108 | + break; |
| 165109 | + case 307: /* wqlist ::= wqitem */ |
| 165110 | +{ |
| 165111 | + yymsp[0].minor.yy521 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy385); /*A-overwrites-X*/ |
| 165112 | +} |
| 165113 | + break; |
| 165114 | + case 308: /* wqlist ::= wqlist COMMA wqitem */ |
| 165115 | +{ |
| 165116 | + yymsp[-2].minor.yy521 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy521, yymsp[0].minor.yy385); |
| 165117 | +} |
| 165118 | + break; |
| 165119 | + case 309: /* windowdefn_list ::= windowdefn */ |
| 165120 | +{ yylhsminor.yy41 = yymsp[0].minor.yy41; } |
| 165121 | + yymsp[0].minor.yy41 = yylhsminor.yy41; |
| 165122 | + break; |
| 165123 | + case 310: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ |
| 165124 | +{ |
| 165125 | + assert( yymsp[0].minor.yy41!=0 ); |
| 165126 | + sqlite3WindowChain(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy41); |
| 165127 | + yymsp[0].minor.yy41->pNextWin = yymsp[-2].minor.yy41; |
| 165128 | + yylhsminor.yy41 = yymsp[0].minor.yy41; |
| 165129 | +} |
| 165130 | + yymsp[-2].minor.yy41 = yylhsminor.yy41; |
| 165131 | + break; |
| 165132 | + case 311: /* windowdefn ::= nm AS LP window RP */ |
| 165133 | +{ |
| 165134 | + if( ALWAYS(yymsp[-1].minor.yy41) ){ |
| 165135 | + yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); |
| 165136 | + } |
| 165137 | + yylhsminor.yy41 = yymsp[-1].minor.yy41; |
| 165138 | +} |
| 165139 | + yymsp[-4].minor.yy41 = yylhsminor.yy41; |
| 165140 | + break; |
| 165141 | + case 312: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ |
| 165142 | +{ |
| 165143 | + yymsp[-4].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, 0); |
| 165144 | +} |
| 165145 | + break; |
| 165146 | + case 313: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ |
| 165147 | +{ |
| 165148 | + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, &yymsp[-5].minor.yy0); |
| 165149 | +} |
| 165150 | + yymsp[-5].minor.yy41 = yylhsminor.yy41; |
| 165151 | + break; |
| 165152 | + case 314: /* window ::= ORDER BY sortlist frame_opt */ |
| 165153 | +{ |
| 165154 | + yymsp[-3].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, 0); |
| 165155 | +} |
| 165156 | + break; |
| 165157 | + case 315: /* window ::= nm ORDER BY sortlist frame_opt */ |
| 165158 | +{ |
| 165159 | + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0); |
| 165160 | +} |
| 165161 | + yymsp[-4].minor.yy41 = yylhsminor.yy41; |
| 165162 | + break; |
| 165163 | + case 316: /* window ::= frame_opt */ |
| 165164 | + case 335: /* filter_over ::= over_clause */ yytestcase(yyruleno==335); |
| 165165 | +{ |
| 165166 | + yylhsminor.yy41 = yymsp[0].minor.yy41; |
| 165167 | +} |
| 165168 | + yymsp[0].minor.yy41 = yylhsminor.yy41; |
| 165169 | + break; |
| 165170 | + case 317: /* window ::= nm frame_opt */ |
| 165171 | +{ |
| 165172 | + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, 0, &yymsp[-1].minor.yy0); |
| 165173 | +} |
| 165174 | + yymsp[-1].minor.yy41 = yylhsminor.yy41; |
| 165175 | + break; |
| 165176 | + case 318: /* frame_opt ::= */ |
| 165177 | +{ |
| 165178 | + yymsp[1].minor.yy41 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); |
| 165179 | +} |
| 165180 | + break; |
| 165181 | + case 319: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ |
| 165182 | +{ |
| 165183 | + yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy394, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy516); |
| 165184 | +} |
| 165185 | + yymsp[-2].minor.yy41 = yylhsminor.yy41; |
| 165186 | + break; |
| 165187 | + case 320: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ |
| 165188 | +{ |
| 165189 | + yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy394, yymsp[-3].minor.yy595.eType, yymsp[-3].minor.yy595.pExpr, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, yymsp[0].minor.yy516); |
| 165190 | +} |
| 165191 | + yymsp[-5].minor.yy41 = yylhsminor.yy41; |
| 165192 | + break; |
| 165193 | + case 322: /* frame_bound_s ::= frame_bound */ |
| 165194 | + case 324: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==324); |
| 165195 | +{yylhsminor.yy595 = yymsp[0].minor.yy595;} |
| 165196 | + yymsp[0].minor.yy595 = yylhsminor.yy595; |
| 165197 | + break; |
| 165198 | + case 323: /* frame_bound_s ::= UNBOUNDED PRECEDING */ |
| 165199 | + case 325: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==325); |
| 165200 | + case 327: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==327); |
| 165201 | +{yylhsminor.yy595.eType = yymsp[-1].major; yylhsminor.yy595.pExpr = 0;} |
| 165202 | + yymsp[-1].minor.yy595 = yylhsminor.yy595; |
| 165203 | + break; |
| 165204 | + case 326: /* frame_bound ::= expr PRECEDING|FOLLOWING */ |
| 165205 | +{yylhsminor.yy595.eType = yymsp[0].major; yylhsminor.yy595.pExpr = yymsp[-1].minor.yy528;} |
| 165206 | + yymsp[-1].minor.yy595 = yylhsminor.yy595; |
| 165207 | + break; |
| 165208 | + case 328: /* frame_exclude_opt ::= */ |
| 165209 | +{yymsp[1].minor.yy516 = 0;} |
| 165210 | + break; |
| 165211 | + case 329: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ |
| 165212 | +{yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;} |
| 165213 | + break; |
| 165214 | + case 330: /* frame_exclude ::= NO OTHERS */ |
| 165215 | + case 331: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==331); |
| 165216 | +{yymsp[-1].minor.yy516 = yymsp[-1].major; /*A-overwrites-X*/} |
| 165217 | + break; |
| 165218 | + case 332: /* frame_exclude ::= GROUP|TIES */ |
| 165219 | +{yymsp[0].minor.yy516 = yymsp[0].major; /*A-overwrites-X*/} |
| 165220 | + break; |
| 165221 | + case 333: /* window_clause ::= WINDOW windowdefn_list */ |
| 165222 | +{ yymsp[-1].minor.yy41 = yymsp[0].minor.yy41; } |
| 165223 | + break; |
| 165224 | + case 334: /* filter_over ::= filter_clause over_clause */ |
| 165225 | +{ |
| 165226 | + if( yymsp[0].minor.yy41 ){ |
| 165227 | + yymsp[0].minor.yy41->pFilter = yymsp[-1].minor.yy528; |
| 165228 | + }else{ |
| 165229 | + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528); |
| 165230 | + } |
| 165231 | + yylhsminor.yy41 = yymsp[0].minor.yy41; |
| 165232 | +} |
| 165233 | + yymsp[-1].minor.yy41 = yylhsminor.yy41; |
| 165234 | + break; |
| 165235 | + case 336: /* filter_over ::= filter_clause */ |
| 165236 | +{ |
| 165237 | + yylhsminor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 165238 | + if( yylhsminor.yy41 ){ |
| 165239 | + yylhsminor.yy41->eFrmType = TK_FILTER; |
| 165240 | + yylhsminor.yy41->pFilter = yymsp[0].minor.yy528; |
| 165241 | + }else{ |
| 165242 | + sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy528); |
| 165243 | + } |
| 165244 | +} |
| 165245 | + yymsp[0].minor.yy41 = yylhsminor.yy41; |
| 165246 | + break; |
| 165247 | + case 337: /* over_clause ::= OVER LP window RP */ |
| 165248 | +{ |
| 165249 | + yymsp[-3].minor.yy41 = yymsp[-1].minor.yy41; |
| 165250 | + assert( yymsp[-3].minor.yy41!=0 ); |
| 165251 | +} |
| 165252 | + break; |
| 165253 | + case 338: /* over_clause ::= OVER nm */ |
| 165254 | +{ |
| 165255 | + yymsp[-1].minor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); |
| 165256 | + if( yymsp[-1].minor.yy41 ){ |
| 165257 | + yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); |
| 165258 | + } |
| 165259 | +} |
| 165260 | + break; |
| 165261 | + case 339: /* filter_clause ::= FILTER LP WHERE expr RP */ |
| 165262 | +{ yymsp[-4].minor.yy528 = yymsp[-1].minor.yy528; } |
| 165021 | 165263 | break; |
| 165022 | 165264 | default: |
| 165023 | | - /* (339) input ::= cmdlist */ yytestcase(yyruleno==339); |
| 165024 | | - /* (340) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==340); |
| 165025 | | - /* (341) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=341); |
| 165026 | | - /* (342) ecmd ::= SEMI */ yytestcase(yyruleno==342); |
| 165027 | | - /* (343) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==343); |
| 165028 | | - /* (344) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=344); |
| 165029 | | - /* (345) trans_opt ::= */ yytestcase(yyruleno==345); |
| 165030 | | - /* (346) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==346); |
| 165031 | | - /* (347) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==347); |
| 165032 | | - /* (348) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==348); |
| 165033 | | - /* (349) savepoint_opt ::= */ yytestcase(yyruleno==349); |
| 165034 | | - /* (350) cmd ::= create_table create_table_args */ yytestcase(yyruleno==350); |
| 165035 | | - /* (351) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=351); |
| 165036 | | - /* (352) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==352); |
| 165037 | | - /* (353) columnlist ::= columnname carglist */ yytestcase(yyruleno==353); |
| 165038 | | - /* (354) nm ::= ID|INDEXED */ yytestcase(yyruleno==354); |
| 165039 | | - /* (355) nm ::= STRING */ yytestcase(yyruleno==355); |
| 165040 | | - /* (356) nm ::= JOIN_KW */ yytestcase(yyruleno==356); |
| 165041 | | - /* (357) typetoken ::= typename */ yytestcase(yyruleno==357); |
| 165042 | | - /* (358) typename ::= ID|STRING */ yytestcase(yyruleno==358); |
| 165043 | | - /* (359) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=359); |
| 165044 | | - /* (360) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=360); |
| 165045 | | - /* (361) carglist ::= carglist ccons */ yytestcase(yyruleno==361); |
| 165046 | | - /* (362) carglist ::= */ yytestcase(yyruleno==362); |
| 165047 | | - /* (363) ccons ::= NULL onconf */ yytestcase(yyruleno==363); |
| 165048 | | - /* (364) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==364); |
| 165049 | | - /* (365) ccons ::= AS generated */ yytestcase(yyruleno==365); |
| 165050 | | - /* (366) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==366); |
| 165051 | | - /* (367) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==367); |
| 165052 | | - /* (368) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=368); |
| 165053 | | - /* (369) tconscomma ::= */ yytestcase(yyruleno==369); |
| 165054 | | - /* (370) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=370); |
| 165055 | | - /* (371) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=371); |
| 165056 | | - /* (372) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=372); |
| 165057 | | - /* (373) oneselect ::= values */ yytestcase(yyruleno==373); |
| 165058 | | - /* (374) sclp ::= selcollist COMMA */ yytestcase(yyruleno==374); |
| 165059 | | - /* (375) as ::= ID|STRING */ yytestcase(yyruleno==375); |
| 165060 | | - /* (376) returning ::= */ yytestcase(yyruleno==376); |
| 165061 | | - /* (377) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=377); |
| 165062 | | - /* (378) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==378); |
| 165063 | | - /* (379) exprlist ::= nexprlist */ yytestcase(yyruleno==379); |
| 165064 | | - /* (380) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=380); |
| 165065 | | - /* (381) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=381); |
| 165066 | | - /* (382) nmnum ::= ON */ yytestcase(yyruleno==382); |
| 165067 | | - /* (383) nmnum ::= DELETE */ yytestcase(yyruleno==383); |
| 165068 | | - /* (384) nmnum ::= DEFAULT */ yytestcase(yyruleno==384); |
| 165069 | | - /* (385) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==385); |
| 165070 | | - /* (386) foreach_clause ::= */ yytestcase(yyruleno==386); |
| 165071 | | - /* (387) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==387); |
| 165072 | | - /* (388) trnm ::= nm */ yytestcase(yyruleno==388); |
| 165073 | | - /* (389) tridxby ::= */ yytestcase(yyruleno==389); |
| 165074 | | - /* (390) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==390); |
| 165075 | | - /* (391) database_kw_opt ::= */ yytestcase(yyruleno==391); |
| 165076 | | - /* (392) kwcolumn_opt ::= */ yytestcase(yyruleno==392); |
| 165077 | | - /* (393) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==393); |
| 165078 | | - /* (394) vtabarglist ::= vtabarg */ yytestcase(yyruleno==394); |
| 165079 | | - /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==395); |
| 165080 | | - /* (396) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==396); |
| 165081 | | - /* (397) anylist ::= */ yytestcase(yyruleno==397); |
| 165082 | | - /* (398) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==398); |
| 165083 | | - /* (399) anylist ::= anylist ANY */ yytestcase(yyruleno==399); |
| 165084 | | - /* (400) with ::= */ yytestcase(yyruleno==400); |
| 165265 | + /* (340) input ::= cmdlist */ yytestcase(yyruleno==340); |
| 165266 | + /* (341) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==341); |
| 165267 | + /* (342) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=342); |
| 165268 | + /* (343) ecmd ::= SEMI */ yytestcase(yyruleno==343); |
| 165269 | + /* (344) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==344); |
| 165270 | + /* (345) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=345); |
| 165271 | + /* (346) trans_opt ::= */ yytestcase(yyruleno==346); |
| 165272 | + /* (347) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==347); |
| 165273 | + /* (348) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==348); |
| 165274 | + /* (349) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==349); |
| 165275 | + /* (350) savepoint_opt ::= */ yytestcase(yyruleno==350); |
| 165276 | + /* (351) cmd ::= create_table create_table_args */ yytestcase(yyruleno==351); |
| 165277 | + /* (352) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=352); |
| 165278 | + /* (353) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==353); |
| 165279 | + /* (354) columnlist ::= columnname carglist */ yytestcase(yyruleno==354); |
| 165280 | + /* (355) nm ::= ID|INDEXED */ yytestcase(yyruleno==355); |
| 165281 | + /* (356) nm ::= STRING */ yytestcase(yyruleno==356); |
| 165282 | + /* (357) nm ::= JOIN_KW */ yytestcase(yyruleno==357); |
| 165283 | + /* (358) typetoken ::= typename */ yytestcase(yyruleno==358); |
| 165284 | + /* (359) typename ::= ID|STRING */ yytestcase(yyruleno==359); |
| 165285 | + /* (360) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=360); |
| 165286 | + /* (361) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=361); |
| 165287 | + /* (362) carglist ::= carglist ccons */ yytestcase(yyruleno==362); |
| 165288 | + /* (363) carglist ::= */ yytestcase(yyruleno==363); |
| 165289 | + /* (364) ccons ::= NULL onconf */ yytestcase(yyruleno==364); |
| 165290 | + /* (365) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==365); |
| 165291 | + /* (366) ccons ::= AS generated */ yytestcase(yyruleno==366); |
| 165292 | + /* (367) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==367); |
| 165293 | + /* (368) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==368); |
| 165294 | + /* (369) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=369); |
| 165295 | + /* (370) tconscomma ::= */ yytestcase(yyruleno==370); |
| 165296 | + /* (371) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=371); |
| 165297 | + /* (372) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=372); |
| 165298 | + /* (373) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=373); |
| 165299 | + /* (374) oneselect ::= values */ yytestcase(yyruleno==374); |
| 165300 | + /* (375) sclp ::= selcollist COMMA */ yytestcase(yyruleno==375); |
| 165301 | + /* (376) as ::= ID|STRING */ yytestcase(yyruleno==376); |
| 165302 | + /* (377) returning ::= */ yytestcase(yyruleno==377); |
| 165303 | + /* (378) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=378); |
| 165304 | + /* (379) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==379); |
| 165305 | + /* (380) exprlist ::= nexprlist */ yytestcase(yyruleno==380); |
| 165306 | + /* (381) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=381); |
| 165307 | + /* (382) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=382); |
| 165308 | + /* (383) nmnum ::= ON */ yytestcase(yyruleno==383); |
| 165309 | + /* (384) nmnum ::= DELETE */ yytestcase(yyruleno==384); |
| 165310 | + /* (385) nmnum ::= DEFAULT */ yytestcase(yyruleno==385); |
| 165311 | + /* (386) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==386); |
| 165312 | + /* (387) foreach_clause ::= */ yytestcase(yyruleno==387); |
| 165313 | + /* (388) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==388); |
| 165314 | + /* (389) trnm ::= nm */ yytestcase(yyruleno==389); |
| 165315 | + /* (390) tridxby ::= */ yytestcase(yyruleno==390); |
| 165316 | + /* (391) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==391); |
| 165317 | + /* (392) database_kw_opt ::= */ yytestcase(yyruleno==392); |
| 165318 | + /* (393) kwcolumn_opt ::= */ yytestcase(yyruleno==393); |
| 165319 | + /* (394) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==394); |
| 165320 | + /* (395) vtabarglist ::= vtabarg */ yytestcase(yyruleno==395); |
| 165321 | + /* (396) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==396); |
| 165322 | + /* (397) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==397); |
| 165323 | + /* (398) anylist ::= */ yytestcase(yyruleno==398); |
| 165324 | + /* (399) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==399); |
| 165325 | + /* (400) anylist ::= anylist ANY */ yytestcase(yyruleno==400); |
| 165326 | + /* (401) with ::= */ yytestcase(yyruleno==401); |
| 165085 | 165327 | break; |
| 165086 | 165328 | /********** End reduce actions ************************************************/ |
| 165087 | 165329 | }; |
| 165088 | 165330 | assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) ); |
| 165089 | 165331 | yygoto = yyRuleInfoLhs[yyruleno]; |
| | @@ -166202,10 +166444,13 @@ |
| 166202 | 166444 | case CC_MINUS: { |
| 166203 | 166445 | if( z[1]=='-' ){ |
| 166204 | 166446 | for(i=2; (c=z[i])!=0 && c!='\n'; i++){} |
| 166205 | 166447 | *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ |
| 166206 | 166448 | return i; |
| 166449 | + }else if( z[1]=='>' ){ |
| 166450 | + *tokenType = TK_PTR; |
| 166451 | + return 2 + (z[2]=='>'); |
| 166207 | 166452 | } |
| 166208 | 166453 | *tokenType = TK_MINUS; |
| 166209 | 166454 | return 1; |
| 166210 | 166455 | } |
| 166211 | 166456 | case CC_LP: { |
| | @@ -166471,17 +166716,13 @@ |
| 166471 | 166716 | *tokenType = TK_ID; |
| 166472 | 166717 | return i; |
| 166473 | 166718 | } |
| 166474 | 166719 | |
| 166475 | 166720 | /* |
| 166476 | | -** Run the parser on the given SQL string. The parser structure is |
| 166477 | | -** passed in. An SQLITE_ status code is returned. If an error occurs |
| 166478 | | -** then an and attempt is made to write an error message into |
| 166479 | | -** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that |
| 166480 | | -** error message. |
| 166721 | +** Run the parser on the given SQL string. |
| 166481 | 166722 | */ |
| 166482 | | -SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ |
| 166723 | +SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql){ |
| 166483 | 166724 | int nErr = 0; /* Number of errors encountered */ |
| 166484 | 166725 | void *pEngine; /* The LEMON-generated LALR(1) parser */ |
| 166485 | 166726 | int n = 0; /* Length of the next token token */ |
| 166486 | 166727 | int tokenType; /* type of the next token */ |
| 166487 | 166728 | int lastTokenParsed = -1; /* type of the previous token */ |
| | @@ -166498,11 +166739,10 @@ |
| 166498 | 166739 | if( db->nVdbeActive==0 ){ |
| 166499 | 166740 | AtomicStore(&db->u1.isInterrupted, 0); |
| 166500 | 166741 | } |
| 166501 | 166742 | pParse->rc = SQLITE_OK; |
| 166502 | 166743 | pParse->zTail = zSql; |
| 166503 | | - assert( pzErrMsg!=0 ); |
| 166504 | 166744 | #ifdef SQLITE_DEBUG |
| 166505 | 166745 | if( db->flags & SQLITE_ParserTrace ){ |
| 166506 | 166746 | printf("parser: [[[%s]]]\n", zSql); |
| 166507 | 166747 | sqlite3ParserTrace(stdout, "parser: "); |
| 166508 | 166748 | }else{ |
| | @@ -166541,10 +166781,11 @@ |
| 166541 | 166781 | if( tokenType>=TK_SPACE ){ |
| 166542 | 166782 | assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL ); |
| 166543 | 166783 | #endif /* SQLITE_OMIT_WINDOWFUNC */ |
| 166544 | 166784 | if( AtomicLoad(&db->u1.isInterrupted) ){ |
| 166545 | 166785 | pParse->rc = SQLITE_INTERRUPT; |
| 166786 | + pParse->nErr++; |
| 166546 | 166787 | break; |
| 166547 | 166788 | } |
| 166548 | 166789 | if( tokenType==TK_SPACE ){ |
| 166549 | 166790 | zSql += n; |
| 166550 | 166791 | continue; |
| | @@ -166598,45 +166839,30 @@ |
| 166598 | 166839 | sqlite3ParserFree(pEngine, sqlite3_free); |
| 166599 | 166840 | #endif |
| 166600 | 166841 | if( db->mallocFailed ){ |
| 166601 | 166842 | pParse->rc = SQLITE_NOMEM_BKPT; |
| 166602 | 166843 | } |
| 166603 | | - if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ |
| 166604 | | - pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); |
| 166605 | | - } |
| 166606 | | - assert( pzErrMsg!=0 ); |
| 166607 | | - if( pParse->zErrMsg ){ |
| 166608 | | - *pzErrMsg = pParse->zErrMsg; |
| 166609 | | - sqlite3_log(pParse->rc, "%s in \"%s\"", |
| 166610 | | - *pzErrMsg, pParse->zTail); |
| 166611 | | - pParse->zErrMsg = 0; |
| 166844 | + if( pParse->zErrMsg || (pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE) ){ |
| 166845 | + if( pParse->zErrMsg==0 ){ |
| 166846 | + pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); |
| 166847 | + } |
| 166848 | + sqlite3_log(pParse->rc, "%s in \"%s\"", pParse->zErrMsg, pParse->zTail); |
| 166612 | 166849 | nErr++; |
| 166613 | 166850 | } |
| 166614 | 166851 | pParse->zTail = zSql; |
| 166615 | | - if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){ |
| 166616 | | - sqlite3VdbeDelete(pParse->pVdbe); |
| 166617 | | - pParse->pVdbe = 0; |
| 166618 | | - } |
| 166619 | | -#ifndef SQLITE_OMIT_SHARED_CACHE |
| 166620 | | - if( pParse->nested==0 ){ |
| 166621 | | - sqlite3DbFree(db, pParse->aTableLock); |
| 166622 | | - pParse->aTableLock = 0; |
| 166623 | | - pParse->nTableLock = 0; |
| 166624 | | - } |
| 166625 | | -#endif |
| 166626 | 166852 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 166627 | 166853 | sqlite3_free(pParse->apVtabLock); |
| 166628 | 166854 | #endif |
| 166629 | 166855 | |
| 166630 | | - if( !IN_SPECIAL_PARSE ){ |
| 166856 | + if( pParse->pNewTable && !IN_SPECIAL_PARSE ){ |
| 166631 | 166857 | /* If the pParse->declareVtab flag is set, do not delete any table |
| 166632 | 166858 | ** structure built up in pParse->pNewTable. The calling code (see vtab.c) |
| 166633 | 166859 | ** will take responsibility for freeing the Table structure. |
| 166634 | 166860 | */ |
| 166635 | 166861 | sqlite3DeleteTable(db, pParse->pNewTable); |
| 166636 | 166862 | } |
| 166637 | | - if( !IN_RENAME_OBJECT ){ |
| 166863 | + if( pParse->pNewTrigger && !IN_RENAME_OBJECT ){ |
| 166638 | 166864 | sqlite3DeleteTrigger(db, pParse->pNewTrigger); |
| 166639 | 166865 | } |
| 166640 | 166866 | sqlite3DbFree(db, pParse->pVList); |
| 166641 | 166867 | db->pParse = pParentParse; |
| 166642 | 166868 | assert( nErr==0 || pParse->rc!=SQLITE_OK ); |
| | @@ -167217,13 +167443,10 @@ |
| 167217 | 167443 | SQLITE_PRIVATE int sqlite3Fts2Init(sqlite3*); |
| 167218 | 167444 | #endif |
| 167219 | 167445 | #ifdef SQLITE_ENABLE_FTS5 |
| 167220 | 167446 | SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3*); |
| 167221 | 167447 | #endif |
| 167222 | | -#ifdef SQLITE_ENABLE_JSON1 |
| 167223 | | -SQLITE_PRIVATE int sqlite3Json1Init(sqlite3*); |
| 167224 | | -#endif |
| 167225 | 167448 | #ifdef SQLITE_ENABLE_STMTVTAB |
| 167226 | 167449 | SQLITE_PRIVATE int sqlite3StmtVtabInit(sqlite3*); |
| 167227 | 167450 | #endif |
| 167228 | 167451 | |
| 167229 | 167452 | /* |
| | @@ -167254,12 +167477,12 @@ |
| 167254 | 167477 | #endif |
| 167255 | 167478 | #ifdef SQLITE_ENABLE_DBSTAT_VTAB |
| 167256 | 167479 | sqlite3DbstatRegister, |
| 167257 | 167480 | #endif |
| 167258 | 167481 | sqlite3TestExtInit, |
| 167259 | | -#ifdef SQLITE_ENABLE_JSON1 |
| 167260 | | - sqlite3Json1Init, |
| 167482 | +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) |
| 167483 | + sqlite3JsonTableFunctions, |
| 167261 | 167484 | #endif |
| 167262 | 167485 | #ifdef SQLITE_ENABLE_STMTVTAB |
| 167263 | 167486 | sqlite3StmtVtabInit, |
| 167264 | 167487 | #endif |
| 167265 | 167488 | #ifdef SQLITE_ENABLE_BYTECODE_VTAB |
| | @@ -169763,10 +169986,23 @@ |
| 169763 | 169986 | } |
| 169764 | 169987 | } |
| 169765 | 169988 | sqlite3_mutex_leave(db->mutex); |
| 169766 | 169989 | return z; |
| 169767 | 169990 | } |
| 169991 | + |
| 169992 | +/* |
| 169993 | +** Return the byte offset of the most recent error |
| 169994 | +*/ |
| 169995 | +SQLITE_API int sqlite3_error_offset(sqlite3 *db){ |
| 169996 | + int iOffset = -1; |
| 169997 | + if( db && sqlite3SafetyCheckSickOrOk(db) && db->errCode ){ |
| 169998 | + sqlite3_mutex_enter(db->mutex); |
| 169999 | + iOffset = db->errByteOffset; |
| 170000 | + sqlite3_mutex_leave(db->mutex); |
| 170001 | + } |
| 170002 | + return iOffset; |
| 170003 | +} |
| 169768 | 170004 | |
| 169769 | 170005 | #ifndef SQLITE_OMIT_UTF16 |
| 169770 | 170006 | /* |
| 169771 | 170007 | ** Return UTF-16 encoded English language explanation of the most recent |
| 169772 | 170008 | ** error. |
| | @@ -173514,11 +173750,11 @@ |
| 173514 | 173750 | SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); |
| 173515 | 173751 | SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *); |
| 173516 | 173752 | SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr); |
| 173517 | 173753 | |
| 173518 | 173754 | /* fts3_tokenize_vtab.c */ |
| 173519 | | -SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *); |
| 173755 | +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *, void(*xDestroy)(void*)); |
| 173520 | 173756 | |
| 173521 | 173757 | /* fts3_unicode2.c (functions generated by parsing unicode text files) */ |
| 173522 | 173758 | #ifndef SQLITE_DISABLE_FTS3_UNICODE |
| 173523 | 173759 | SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int, int); |
| 173524 | 173760 | SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int); |
| | @@ -173546,10 +173782,16 @@ |
| 173546 | 173782 | /* #include "fts3.h" */ |
| 173547 | 173783 | #ifndef SQLITE_CORE |
| 173548 | 173784 | /* # include "sqlite3ext.h" */ |
| 173549 | 173785 | SQLITE_EXTENSION_INIT1 |
| 173550 | 173786 | #endif |
| 173787 | + |
| 173788 | +typedef struct Fts3HashWrapper Fts3HashWrapper; |
| 173789 | +struct Fts3HashWrapper { |
| 173790 | + Fts3Hash hash; /* Hash table */ |
| 173791 | + int nRef; /* Number of pointers to this object */ |
| 173792 | +}; |
| 173551 | 173793 | |
| 173552 | 173794 | static int fts3EvalNext(Fts3Cursor *pCsr); |
| 173553 | 173795 | static int fts3EvalStart(Fts3Cursor *pCsr); |
| 173554 | 173796 | static int fts3TermSegReaderCursor( |
| 173555 | 173797 | Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **); |
| | @@ -174411,11 +174653,11 @@ |
| 174411 | 174653 | int argc, /* Number of elements in argv array */ |
| 174412 | 174654 | const char * const *argv, /* xCreate/xConnect argument array */ |
| 174413 | 174655 | sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */ |
| 174414 | 174656 | char **pzErr /* Write any error message here */ |
| 174415 | 174657 | ){ |
| 174416 | | - Fts3Hash *pHash = (Fts3Hash *)pAux; |
| 174658 | + Fts3Hash *pHash = &((Fts3HashWrapper*)pAux)->hash; |
| 174417 | 174659 | Fts3Table *p = 0; /* Pointer to allocated vtab */ |
| 174418 | 174660 | int rc = SQLITE_OK; /* Return code */ |
| 174419 | 174661 | int i; /* Iterator variable */ |
| 174420 | 174662 | sqlite3_int64 nByte; /* Size of allocation used for *p */ |
| 174421 | 174663 | int iCol; /* Column index */ |
| | @@ -177246,13 +177488,16 @@ |
| 177246 | 177488 | ** This function is registered as the module destructor (called when an |
| 177247 | 177489 | ** FTS3 enabled database connection is closed). It frees the memory |
| 177248 | 177490 | ** allocated for the tokenizer hash table. |
| 177249 | 177491 | */ |
| 177250 | 177492 | static void hashDestroy(void *p){ |
| 177251 | | - Fts3Hash *pHash = (Fts3Hash *)p; |
| 177252 | | - sqlite3Fts3HashClear(pHash); |
| 177253 | | - sqlite3_free(pHash); |
| 177493 | + Fts3HashWrapper *pHash = (Fts3HashWrapper *)p; |
| 177494 | + pHash->nRef--; |
| 177495 | + if( pHash->nRef<=0 ){ |
| 177496 | + sqlite3Fts3HashClear(&pHash->hash); |
| 177497 | + sqlite3_free(pHash); |
| 177498 | + } |
| 177254 | 177499 | } |
| 177255 | 177500 | |
| 177256 | 177501 | /* |
| 177257 | 177502 | ** The fts3 built-in tokenizers - "simple", "porter" and "icu"- are |
| 177258 | 177503 | ** implemented in files fts3_tokenizer1.c, fts3_porter.c and fts3_icu.c |
| | @@ -177278,11 +177523,11 @@ |
| 177278 | 177523 | ** SQLite. If fts3 is built as a dynamically loadable extension, this |
| 177279 | 177524 | ** function is called by the sqlite3_extension_init() entry point. |
| 177280 | 177525 | */ |
| 177281 | 177526 | SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){ |
| 177282 | 177527 | int rc = SQLITE_OK; |
| 177283 | | - Fts3Hash *pHash = 0; |
| 177528 | + Fts3HashWrapper *pHash = 0; |
| 177284 | 177529 | const sqlite3_tokenizer_module *pSimple = 0; |
| 177285 | 177530 | const sqlite3_tokenizer_module *pPorter = 0; |
| 177286 | 177531 | #ifndef SQLITE_DISABLE_FTS3_UNICODE |
| 177287 | 177532 | const sqlite3_tokenizer_module *pUnicode = 0; |
| 177288 | 177533 | #endif |
| | @@ -177306,70 +177551,74 @@ |
| 177306 | 177551 | |
| 177307 | 177552 | sqlite3Fts3SimpleTokenizerModule(&pSimple); |
| 177308 | 177553 | sqlite3Fts3PorterTokenizerModule(&pPorter); |
| 177309 | 177554 | |
| 177310 | 177555 | /* Allocate and initialize the hash-table used to store tokenizers. */ |
| 177311 | | - pHash = sqlite3_malloc(sizeof(Fts3Hash)); |
| 177556 | + pHash = sqlite3_malloc(sizeof(Fts3HashWrapper)); |
| 177312 | 177557 | if( !pHash ){ |
| 177313 | 177558 | rc = SQLITE_NOMEM; |
| 177314 | 177559 | }else{ |
| 177315 | | - sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1); |
| 177560 | + sqlite3Fts3HashInit(&pHash->hash, FTS3_HASH_STRING, 1); |
| 177561 | + pHash->nRef = 0; |
| 177316 | 177562 | } |
| 177317 | 177563 | |
| 177318 | 177564 | /* Load the built-in tokenizers into the hash table */ |
| 177319 | 177565 | if( rc==SQLITE_OK ){ |
| 177320 | | - if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple) |
| 177321 | | - || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter) |
| 177566 | + if( sqlite3Fts3HashInsert(&pHash->hash, "simple", 7, (void *)pSimple) |
| 177567 | + || sqlite3Fts3HashInsert(&pHash->hash, "porter", 7, (void *)pPorter) |
| 177322 | 177568 | |
| 177323 | 177569 | #ifndef SQLITE_DISABLE_FTS3_UNICODE |
| 177324 | | - || sqlite3Fts3HashInsert(pHash, "unicode61", 10, (void *)pUnicode) |
| 177570 | + || sqlite3Fts3HashInsert(&pHash->hash, "unicode61", 10, (void *)pUnicode) |
| 177325 | 177571 | #endif |
| 177326 | 177572 | #ifdef SQLITE_ENABLE_ICU |
| 177327 | | - || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu)) |
| 177573 | + || (pIcu && sqlite3Fts3HashInsert(&pHash->hash, "icu", 4, (void *)pIcu)) |
| 177328 | 177574 | #endif |
| 177329 | 177575 | ){ |
| 177330 | 177576 | rc = SQLITE_NOMEM; |
| 177331 | 177577 | } |
| 177332 | 177578 | } |
| 177333 | 177579 | |
| 177334 | 177580 | #ifdef SQLITE_TEST |
| 177335 | 177581 | if( rc==SQLITE_OK ){ |
| 177336 | | - rc = sqlite3Fts3ExprInitTestInterface(db, pHash); |
| 177582 | + rc = sqlite3Fts3ExprInitTestInterface(db, &pHash->hash); |
| 177337 | 177583 | } |
| 177338 | 177584 | #endif |
| 177339 | 177585 | |
| 177340 | 177586 | /* Create the virtual table wrapper around the hash-table and overload |
| 177341 | 177587 | ** the four scalar functions. If this is successful, register the |
| 177342 | 177588 | ** module with sqlite. |
| 177343 | 177589 | */ |
| 177344 | 177590 | if( SQLITE_OK==rc |
| 177345 | | - && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer")) |
| 177591 | + && SQLITE_OK==(rc=sqlite3Fts3InitHashTable(db,&pHash->hash,"fts3_tokenizer")) |
| 177346 | 177592 | && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1)) |
| 177347 | 177593 | && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1)) |
| 177348 | 177594 | && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1)) |
| 177349 | 177595 | && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2)) |
| 177350 | 177596 | && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1)) |
| 177351 | 177597 | ){ |
| 177598 | + pHash->nRef++; |
| 177352 | 177599 | rc = sqlite3_create_module_v2( |
| 177353 | 177600 | db, "fts3", &fts3Module, (void *)pHash, hashDestroy |
| 177354 | 177601 | ); |
| 177355 | 177602 | if( rc==SQLITE_OK ){ |
| 177603 | + pHash->nRef++; |
| 177356 | 177604 | rc = sqlite3_create_module_v2( |
| 177357 | | - db, "fts4", &fts3Module, (void *)pHash, 0 |
| 177605 | + db, "fts4", &fts3Module, (void *)pHash, hashDestroy |
| 177358 | 177606 | ); |
| 177359 | 177607 | } |
| 177360 | 177608 | if( rc==SQLITE_OK ){ |
| 177361 | | - rc = sqlite3Fts3InitTok(db, (void *)pHash); |
| 177609 | + pHash->nRef++; |
| 177610 | + rc = sqlite3Fts3InitTok(db, (void *)pHash, hashDestroy); |
| 177362 | 177611 | } |
| 177363 | 177612 | return rc; |
| 177364 | 177613 | } |
| 177365 | 177614 | |
| 177366 | 177615 | |
| 177367 | 177616 | /* An error has occurred. Delete the hash table and return the error code. */ |
| 177368 | 177617 | assert( rc!=SQLITE_OK ); |
| 177369 | 177618 | if( pHash ){ |
| 177370 | | - sqlite3Fts3HashClear(pHash); |
| 177619 | + sqlite3Fts3HashClear(&pHash->hash); |
| 177371 | 177620 | sqlite3_free(pHash); |
| 177372 | 177621 | } |
| 177373 | 177622 | return rc; |
| 177374 | 177623 | } |
| 177375 | 177624 | |
| | @@ -177712,11 +177961,11 @@ |
| 177712 | 177961 | ){ |
| 177713 | 177962 | char *p = *ppIter; |
| 177714 | 177963 | |
| 177715 | 177964 | assert( nDoclist>0 ); |
| 177716 | 177965 | assert( *pbEof==0 ); |
| 177717 | | - assert( p || *piDocid==0 ); |
| 177966 | + assert_fts3_nc( p || *piDocid==0 ); |
| 177718 | 177967 | assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) ); |
| 177719 | 177968 | |
| 177720 | 177969 | if( p==0 ){ |
| 177721 | 177970 | sqlite3_int64 iDocid = 0; |
| 177722 | 177971 | char *pNext = 0; |
| | @@ -183429,11 +183678,11 @@ |
| 183429 | 183678 | |
| 183430 | 183679 | /* |
| 183431 | 183680 | ** Register the fts3tok module with database connection db. Return SQLITE_OK |
| 183432 | 183681 | ** if successful or an error code if sqlite3_create_module() fails. |
| 183433 | 183682 | */ |
| 183434 | | -SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){ |
| 183683 | +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash, void(*xDestroy)(void*)){ |
| 183435 | 183684 | static const sqlite3_module fts3tok_module = { |
| 183436 | 183685 | 0, /* iVersion */ |
| 183437 | 183686 | fts3tokConnectMethod, /* xCreate */ |
| 183438 | 183687 | fts3tokConnectMethod, /* xConnect */ |
| 183439 | 183688 | fts3tokBestIndexMethod, /* xBestIndex */ |
| | @@ -183458,11 +183707,13 @@ |
| 183458 | 183707 | 0, /* xRollbackTo */ |
| 183459 | 183708 | 0 /* xShadowName */ |
| 183460 | 183709 | }; |
| 183461 | 183710 | int rc; /* Return code */ |
| 183462 | 183711 | |
| 183463 | | - rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash); |
| 183712 | + rc = sqlite3_create_module_v2( |
| 183713 | + db, "fts3tokenize", &fts3tok_module, (void*)pHash, xDestroy |
| 183714 | + ); |
| 183464 | 183715 | return rc; |
| 183465 | 183716 | } |
| 183466 | 183717 | |
| 183467 | 183718 | #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ |
| 183468 | 183719 | |
| | @@ -191817,11 +192068,11 @@ |
| 191817 | 192068 | } |
| 191818 | 192069 | #endif /* defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) */ |
| 191819 | 192070 | #endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */ |
| 191820 | 192071 | |
| 191821 | 192072 | /************** End of fts3_unicode2.c ***************************************/ |
| 191822 | | -/************** Begin file json1.c *******************************************/ |
| 192073 | +/************** Begin file json.c ********************************************/ |
| 191823 | 192074 | /* |
| 191824 | 192075 | ** 2015-08-12 |
| 191825 | 192076 | ** |
| 191826 | 192077 | ** The author disclaims copyright to this source code. In place of |
| 191827 | 192078 | ** a legal notice, here is a blessing: |
| | @@ -191830,63 +192081,23 @@ |
| 191830 | 192081 | ** May you find forgiveness for yourself and forgive others. |
| 191831 | 192082 | ** May you share freely, never taking more than you give. |
| 191832 | 192083 | ** |
| 191833 | 192084 | ****************************************************************************** |
| 191834 | 192085 | ** |
| 191835 | | -** This SQLite extension implements JSON functions. The interface is |
| 191836 | | -** modeled after MySQL JSON functions: |
| 192086 | +** This SQLite JSON functions. |
| 191837 | 192087 | ** |
| 191838 | | -** https://dev.mysql.com/doc/refman/5.7/en/json.html |
| 192088 | +** This file began as an extension in ext/misc/json1.c in 2015. That |
| 192089 | +** extension proved so useful that it has now been moved into the core. |
| 191839 | 192090 | ** |
| 191840 | 192091 | ** For the time being, all JSON is stored as pure text. (We might add |
| 191841 | 192092 | ** a JSONB type in the future which stores a binary encoding of JSON in |
| 191842 | 192093 | ** a BLOB, but there is no support for JSONB in the current implementation. |
| 191843 | 192094 | ** This implementation parses JSON text at 250 MB/s, so it is hard to see |
| 191844 | 192095 | ** how JSONB might improve on that.) |
| 191845 | 192096 | */ |
| 191846 | | -#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) |
| 191847 | | -#if !defined(SQLITEINT_H) |
| 191848 | | -/* #include "sqlite3ext.h" */ |
| 191849 | | -#endif |
| 191850 | | -SQLITE_EXTENSION_INIT1 |
| 191851 | | -/* #include <assert.h> */ |
| 191852 | | -/* #include <string.h> */ |
| 191853 | | -/* #include <stdlib.h> */ |
| 191854 | | -/* #include <stdarg.h> */ |
| 191855 | | - |
| 191856 | | -/* Mark a function parameter as unused, to suppress nuisance compiler |
| 191857 | | -** warnings. */ |
| 191858 | | -#ifndef UNUSED_PARAM |
| 191859 | | -# define UNUSED_PARAM(X) (void)(X) |
| 191860 | | -#endif |
| 191861 | | - |
| 191862 | | -#ifndef LARGEST_INT64 |
| 191863 | | -# define LARGEST_INT64 (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32)) |
| 191864 | | -# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64) |
| 191865 | | -#endif |
| 191866 | | - |
| 191867 | | -#ifndef deliberate_fall_through |
| 191868 | | -# define deliberate_fall_through |
| 191869 | | -#endif |
| 191870 | | - |
| 191871 | | -/* |
| 191872 | | -** Versions of isspace(), isalnum() and isdigit() to which it is safe |
| 191873 | | -** to pass signed char values. |
| 191874 | | -*/ |
| 191875 | | -#ifdef sqlite3Isdigit |
| 191876 | | - /* Use the SQLite core versions if this routine is part of the |
| 191877 | | - ** SQLite amalgamation */ |
| 191878 | | -# define safe_isdigit(x) sqlite3Isdigit(x) |
| 191879 | | -# define safe_isalnum(x) sqlite3Isalnum(x) |
| 191880 | | -# define safe_isxdigit(x) sqlite3Isxdigit(x) |
| 191881 | | -#else |
| 191882 | | - /* Use the standard library for separate compilation */ |
| 191883 | | -#include <ctype.h> /* amalgamator: keep */ |
| 191884 | | -# define safe_isdigit(x) isdigit((unsigned char)(x)) |
| 191885 | | -# define safe_isalnum(x) isalnum((unsigned char)(x)) |
| 191886 | | -# define safe_isxdigit(x) isxdigit((unsigned char)(x)) |
| 191887 | | -#endif |
| 192097 | +#ifndef SQLITE_OMIT_JSON |
| 192098 | +/* #include "sqliteInt.h" */ |
| 191888 | 192099 | |
| 191889 | 192100 | /* |
| 191890 | 192101 | ** Growing our own isspace() routine this way is twice as fast as |
| 191891 | 192102 | ** the library isspace() function, resulting in a 7% overall performance |
| 191892 | 192103 | ** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os). |
| | @@ -191907,48 +192118,18 @@ |
| 191907 | 192118 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 191908 | 192119 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 191909 | 192120 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 191910 | 192121 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 191911 | 192122 | }; |
| 191912 | | -#define safe_isspace(x) (jsonIsSpace[(unsigned char)x]) |
| 191913 | | - |
| 191914 | | -#ifndef SQLITE_AMALGAMATION |
| 191915 | | - /* Unsigned integer types. These are already defined in the sqliteInt.h, |
| 191916 | | - ** but the definitions need to be repeated for separate compilation. */ |
| 191917 | | - typedef sqlite3_uint64 u64; |
| 191918 | | - typedef unsigned int u32; |
| 191919 | | - typedef unsigned short int u16; |
| 191920 | | - typedef unsigned char u8; |
| 191921 | | -# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) |
| 191922 | | -# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 |
| 191923 | | -# endif |
| 191924 | | -# if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) |
| 191925 | | -# define ALWAYS(X) (1) |
| 191926 | | -# define NEVER(X) (0) |
| 191927 | | -# elif !defined(NDEBUG) |
| 191928 | | -# define ALWAYS(X) ((X)?1:(assert(0),0)) |
| 191929 | | -# define NEVER(X) ((X)?(assert(0),1):0) |
| 191930 | | -# else |
| 191931 | | -# define ALWAYS(X) (X) |
| 191932 | | -# define NEVER(X) (X) |
| 191933 | | -# endif |
| 191934 | | -# define testcase(X) |
| 191935 | | -#endif |
| 192123 | +#define fast_isspace(x) (jsonIsSpace[(unsigned char)x]) |
| 192124 | + |
| 191936 | 192125 | #if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST) |
| 191937 | 192126 | # define VVA(X) |
| 191938 | 192127 | #else |
| 191939 | 192128 | # define VVA(X) X |
| 191940 | 192129 | #endif |
| 191941 | 192130 | |
| 191942 | | -/* |
| 191943 | | -** Some of the testcase() macros in this file are problematic for gcov |
| 191944 | | -** in that they generate false-miss errors randomly. This is a gcov problem, |
| 191945 | | -** not a problem in this case. But to work around it, we disable the |
| 191946 | | -** problematic test cases for production builds. |
| 191947 | | -*/ |
| 191948 | | -#define json_testcase(X) |
| 191949 | | - |
| 191950 | 192131 | /* Objects */ |
| 191951 | 192132 | typedef struct JsonString JsonString; |
| 191952 | 192133 | typedef struct JsonNode JsonNode; |
| 191953 | 192134 | typedef struct JsonParse JsonParse; |
| 191954 | 192135 | |
| | @@ -192402,14 +192583,14 @@ |
| 192402 | 192583 | /* |
| 192403 | 192584 | ** Convert a 4-byte hex string into an integer |
| 192404 | 192585 | */ |
| 192405 | 192586 | static u32 jsonHexToInt4(const char *z){ |
| 192406 | 192587 | u32 v; |
| 192407 | | - assert( safe_isxdigit(z[0]) ); |
| 192408 | | - assert( safe_isxdigit(z[1]) ); |
| 192409 | | - assert( safe_isxdigit(z[2]) ); |
| 192410 | | - assert( safe_isxdigit(z[3]) ); |
| 192588 | + assert( sqlite3Isxdigit(z[0]) ); |
| 192589 | + assert( sqlite3Isxdigit(z[1]) ); |
| 192590 | + assert( sqlite3Isxdigit(z[2]) ); |
| 192591 | + assert( sqlite3Isxdigit(z[3]) ); |
| 192411 | 192592 | v = (jsonHexToInt(z[0])<<12) |
| 192412 | 192593 | + (jsonHexToInt(z[1])<<8) |
| 192413 | 192594 | + (jsonHexToInt(z[2])<<4) |
| 192414 | 192595 | + jsonHexToInt(z[3]); |
| 192415 | 192596 | return v; |
| | @@ -192640,11 +192821,11 @@ |
| 192640 | 192821 | /* |
| 192641 | 192822 | ** Return true if z[] begins with 4 (or more) hexadecimal digits |
| 192642 | 192823 | */ |
| 192643 | 192824 | static int jsonIs4Hex(const char *z){ |
| 192644 | 192825 | int i; |
| 192645 | | - for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0; |
| 192826 | + for(i=0; i<4; i++) if( !sqlite3Isxdigit(z[i]) ) return 0; |
| 192646 | 192827 | return 1; |
| 192647 | 192828 | } |
| 192648 | 192829 | |
| 192649 | 192830 | /* |
| 192650 | 192831 | ** Parse a single JSON value which begins at pParse->zJson[i]. Return the |
| | @@ -192659,17 +192840,17 @@ |
| 192659 | 192840 | u32 j; |
| 192660 | 192841 | int iThis; |
| 192661 | 192842 | int x; |
| 192662 | 192843 | JsonNode *pNode; |
| 192663 | 192844 | const char *z = pParse->zJson; |
| 192664 | | - while( safe_isspace(z[i]) ){ i++; } |
| 192845 | + while( fast_isspace(z[i]) ){ i++; } |
| 192665 | 192846 | if( (c = z[i])=='{' ){ |
| 192666 | 192847 | /* Parse object */ |
| 192667 | 192848 | iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); |
| 192668 | 192849 | if( iThis<0 ) return -1; |
| 192669 | 192850 | for(j=i+1;;j++){ |
| 192670 | | - while( safe_isspace(z[j]) ){ j++; } |
| 192851 | + while( fast_isspace(z[j]) ){ j++; } |
| 192671 | 192852 | if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; |
| 192672 | 192853 | x = jsonParseValue(pParse, j); |
| 192673 | 192854 | if( x<0 ){ |
| 192674 | 192855 | pParse->iDepth--; |
| 192675 | 192856 | if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1; |
| | @@ -192678,18 +192859,18 @@ |
| 192678 | 192859 | if( pParse->oom ) return -1; |
| 192679 | 192860 | pNode = &pParse->aNode[pParse->nNode-1]; |
| 192680 | 192861 | if( pNode->eType!=JSON_STRING ) return -1; |
| 192681 | 192862 | pNode->jnFlags |= JNODE_LABEL; |
| 192682 | 192863 | j = x; |
| 192683 | | - while( safe_isspace(z[j]) ){ j++; } |
| 192864 | + while( fast_isspace(z[j]) ){ j++; } |
| 192684 | 192865 | if( z[j]!=':' ) return -1; |
| 192685 | 192866 | j++; |
| 192686 | 192867 | x = jsonParseValue(pParse, j); |
| 192687 | 192868 | pParse->iDepth--; |
| 192688 | 192869 | if( x<0 ) return -1; |
| 192689 | 192870 | j = x; |
| 192690 | | - while( safe_isspace(z[j]) ){ j++; } |
| 192871 | + while( fast_isspace(z[j]) ){ j++; } |
| 192691 | 192872 | c = z[j]; |
| 192692 | 192873 | if( c==',' ) continue; |
| 192693 | 192874 | if( c!='}' ) return -1; |
| 192694 | 192875 | break; |
| 192695 | 192876 | } |
| | @@ -192699,20 +192880,20 @@ |
| 192699 | 192880 | /* Parse array */ |
| 192700 | 192881 | iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); |
| 192701 | 192882 | if( iThis<0 ) return -1; |
| 192702 | 192883 | memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u)); |
| 192703 | 192884 | for(j=i+1;;j++){ |
| 192704 | | - while( safe_isspace(z[j]) ){ j++; } |
| 192885 | + while( fast_isspace(z[j]) ){ j++; } |
| 192705 | 192886 | if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; |
| 192706 | 192887 | x = jsonParseValue(pParse, j); |
| 192707 | 192888 | pParse->iDepth--; |
| 192708 | 192889 | if( x<0 ){ |
| 192709 | 192890 | if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1; |
| 192710 | 192891 | return -1; |
| 192711 | 192892 | } |
| 192712 | 192893 | j = x; |
| 192713 | | - while( safe_isspace(z[j]) ){ j++; } |
| 192894 | + while( fast_isspace(z[j]) ){ j++; } |
| 192714 | 192895 | c = z[j]; |
| 192715 | 192896 | if( c==',' ) continue; |
| 192716 | 192897 | if( c!=']' ) return -1; |
| 192717 | 192898 | break; |
| 192718 | 192899 | } |
| | @@ -192745,21 +192926,21 @@ |
| 192745 | 192926 | jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]); |
| 192746 | 192927 | if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags; |
| 192747 | 192928 | return j+1; |
| 192748 | 192929 | }else if( c=='n' |
| 192749 | 192930 | && strncmp(z+i,"null",4)==0 |
| 192750 | | - && !safe_isalnum(z[i+4]) ){ |
| 192931 | + && !sqlite3Isalnum(z[i+4]) ){ |
| 192751 | 192932 | jsonParseAddNode(pParse, JSON_NULL, 0, 0); |
| 192752 | 192933 | return i+4; |
| 192753 | 192934 | }else if( c=='t' |
| 192754 | 192935 | && strncmp(z+i,"true",4)==0 |
| 192755 | | - && !safe_isalnum(z[i+4]) ){ |
| 192936 | + && !sqlite3Isalnum(z[i+4]) ){ |
| 192756 | 192937 | jsonParseAddNode(pParse, JSON_TRUE, 0, 0); |
| 192757 | 192938 | return i+4; |
| 192758 | 192939 | }else if( c=='f' |
| 192759 | 192940 | && strncmp(z+i,"false",5)==0 |
| 192760 | | - && !safe_isalnum(z[i+5]) ){ |
| 192941 | + && !sqlite3Isalnum(z[i+5]) ){ |
| 192761 | 192942 | jsonParseAddNode(pParse, JSON_FALSE, 0, 0); |
| 192762 | 192943 | return i+5; |
| 192763 | 192944 | }else if( c=='-' || (c>='0' && c<='9') ){ |
| 192764 | 192945 | /* Parse number */ |
| 192765 | 192946 | u8 seenDP = 0; |
| | @@ -192826,11 +193007,11 @@ |
| 192826 | 193007 | pParse->zJson = zJson; |
| 192827 | 193008 | i = jsonParseValue(pParse, 0); |
| 192828 | 193009 | if( pParse->oom ) i = -1; |
| 192829 | 193010 | if( i>0 ){ |
| 192830 | 193011 | assert( pParse->iDepth==0 ); |
| 192831 | | - while( safe_isspace(zJson[i]) ) i++; |
| 193012 | + while( fast_isspace(zJson[i]) ) i++; |
| 192832 | 193013 | if( zJson[i] ) i = -1; |
| 192833 | 193014 | } |
| 192834 | 193015 | if( i<=0 ){ |
| 192835 | 193016 | if( pCtx!=0 ){ |
| 192836 | 193017 | if( pParse->oom ){ |
| | @@ -193054,11 +193235,11 @@ |
| 193054 | 193235 | return pNode; |
| 193055 | 193236 | } |
| 193056 | 193237 | }else if( zPath[0]=='[' ){ |
| 193057 | 193238 | i = 0; |
| 193058 | 193239 | j = 1; |
| 193059 | | - while( safe_isdigit(zPath[j]) ){ |
| 193240 | + while( sqlite3Isdigit(zPath[j]) ){ |
| 193060 | 193241 | i = i*10 + zPath[j] - '0'; |
| 193061 | 193242 | j++; |
| 193062 | 193243 | } |
| 193063 | 193244 | if( j<2 || zPath[j]!=']' ){ |
| 193064 | 193245 | if( zPath[1]=='#' ){ |
| | @@ -193075,17 +193256,17 @@ |
| 193075 | 193256 | iBase += pBase->u.iAppend; |
| 193076 | 193257 | pBase = &pParse->aNode[iBase]; |
| 193077 | 193258 | j = 1; |
| 193078 | 193259 | } |
| 193079 | 193260 | j = 2; |
| 193080 | | - if( zPath[2]=='-' && safe_isdigit(zPath[3]) ){ |
| 193261 | + if( zPath[2]=='-' && sqlite3Isdigit(zPath[3]) ){ |
| 193081 | 193262 | unsigned int x = 0; |
| 193082 | 193263 | j = 3; |
| 193083 | 193264 | do{ |
| 193084 | 193265 | x = x*10 + zPath[j] - '0'; |
| 193085 | 193266 | j++; |
| 193086 | | - }while( safe_isdigit(zPath[j]) ); |
| 193267 | + }while( sqlite3Isdigit(zPath[j]) ); |
| 193087 | 193268 | if( x>i ) return 0; |
| 193088 | 193269 | i -= x; |
| 193089 | 193270 | } |
| 193090 | 193271 | if( zPath[j]!=']' ){ |
| 193091 | 193272 | *pzErr = zPath; |
| | @@ -193300,11 +193481,11 @@ |
| 193300 | 193481 | static void jsonTest1Func( |
| 193301 | 193482 | sqlite3_context *ctx, |
| 193302 | 193483 | int argc, |
| 193303 | 193484 | sqlite3_value **argv |
| 193304 | 193485 | ){ |
| 193305 | | - UNUSED_PARAM(argc); |
| 193486 | + UNUSED_PARAMETER(argc); |
| 193306 | 193487 | sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE); |
| 193307 | 193488 | } |
| 193308 | 193489 | #endif /* SQLITE_DEBUG */ |
| 193309 | 193490 | |
| 193310 | 193491 | /**************************************************************************** |
| | @@ -193321,11 +193502,11 @@ |
| 193321 | 193502 | sqlite3_context *ctx, |
| 193322 | 193503 | int argc, |
| 193323 | 193504 | sqlite3_value **argv |
| 193324 | 193505 | ){ |
| 193325 | 193506 | JsonString jx; |
| 193326 | | - UNUSED_PARAM(argc); |
| 193507 | + UNUSED_PARAMETER(argc); |
| 193327 | 193508 | |
| 193328 | 193509 | jsonInit(&jx, ctx); |
| 193329 | 193510 | jsonAppendValue(&jx, argv[0]); |
| 193330 | 193511 | jsonResult(&jx); |
| 193331 | 193512 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
| | @@ -193392,55 +193573,118 @@ |
| 193392 | 193573 | } |
| 193393 | 193574 | } |
| 193394 | 193575 | sqlite3_result_int64(ctx, n); |
| 193395 | 193576 | } |
| 193396 | 193577 | |
| 193578 | +/* |
| 193579 | +** Bit values for the flags passed into jsonExtractFunc() or |
| 193580 | +** jsonSetFunc() via the user-data value. |
| 193581 | +*/ |
| 193582 | +#define JSON_JSON 0x01 /* Result is always JSON */ |
| 193583 | +#define JSON_SQL 0x02 /* Result is always SQL */ |
| 193584 | +#define JSON_ABPATH 0x03 /* Allow abbreviated JSON path specs */ |
| 193585 | +#define JSON_ISSET 0x04 /* json_set(), not json_insert() */ |
| 193586 | + |
| 193397 | 193587 | /* |
| 193398 | 193588 | ** json_extract(JSON, PATH, ...) |
| 193589 | +** "->"(JSON,PATH) |
| 193590 | +** "->>"(JSON,PATH) |
| 193399 | 193591 | ** |
| 193400 | | -** Return the element described by PATH. Return NULL if there is no |
| 193401 | | -** PATH element. If there are multiple PATHs, then return a JSON array |
| 193402 | | -** with the result from each path. Throw an error if the JSON or any PATH |
| 193403 | | -** is malformed. |
| 193592 | +** Return the element described by PATH. Return NULL if that PATH element |
| 193593 | +** is not found. |
| 193594 | +** |
| 193595 | +** If JSON_JSON is set or if more that one PATH argument is supplied then |
| 193596 | +** always return a JSON representation of the result. If JSON_SQL is set, |
| 193597 | +** then always return an SQL representation of the result. If neither flag |
| 193598 | +** is present and argc==2, then return JSON for objects and arrays and SQL |
| 193599 | +** for all other values. |
| 193600 | +** |
| 193601 | +** When multiple PATH arguments are supplied, the result is a JSON array |
| 193602 | +** containing the result of each PATH. |
| 193603 | +** |
| 193604 | +** Abbreviated JSON path expressions are allows if JSON_ABPATH, for |
| 193605 | +** compatibility with PG. |
| 193404 | 193606 | */ |
| 193405 | 193607 | static void jsonExtractFunc( |
| 193406 | 193608 | sqlite3_context *ctx, |
| 193407 | 193609 | int argc, |
| 193408 | 193610 | sqlite3_value **argv |
| 193409 | 193611 | ){ |
| 193410 | 193612 | JsonParse *p; /* The parse */ |
| 193411 | 193613 | JsonNode *pNode; |
| 193412 | 193614 | const char *zPath; |
| 193615 | + int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx)); |
| 193413 | 193616 | JsonString jx; |
| 193414 | | - int i; |
| 193415 | 193617 | |
| 193416 | 193618 | if( argc<2 ) return; |
| 193417 | 193619 | p = jsonParseCached(ctx, argv, ctx); |
| 193418 | 193620 | if( p==0 ) return; |
| 193419 | | - jsonInit(&jx, ctx); |
| 193420 | | - jsonAppendChar(&jx, '['); |
| 193421 | | - for(i=1; i<argc; i++){ |
| 193422 | | - zPath = (const char*)sqlite3_value_text(argv[i]); |
| 193423 | | - pNode = jsonLookup(p, zPath, 0, ctx); |
| 193424 | | - if( p->nErr ) break; |
| 193425 | | - if( argc>2 ){ |
| 193621 | + if( argc==2 ){ |
| 193622 | + /* With a single PATH argument */ |
| 193623 | + zPath = (const char*)sqlite3_value_text(argv[1]); |
| 193624 | + if( zPath==0 ) return; |
| 193625 | + if( flags & JSON_ABPATH ){ |
| 193626 | + if( zPath[0]!='$' ){ |
| 193627 | + /* The -> and ->> operators accept abbreviated PATH arguments. This |
| 193628 | + ** is mostly for compatibility with PostgreSQL, but also for |
| 193629 | + ** convenience. |
| 193630 | + ** |
| 193631 | + ** NUMBER ==> $[NUMBER] // PG compatible |
| 193632 | + ** LABEL ==> $.LABEL // PG compatible |
| 193633 | + ** [NUMBER] ==> $[NUMBER] // Not PG. Purely for convenience |
| 193634 | + */ |
| 193635 | + jsonInit(&jx, ctx); |
| 193636 | + if( sqlite3Isdigit(zPath[0]) ){ |
| 193637 | + jsonAppendRaw(&jx, "$[", 2); |
| 193638 | + jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); |
| 193639 | + jsonAppendRaw(&jx, "]", 2); |
| 193640 | + }else{ |
| 193641 | + jsonAppendRaw(&jx, "$.", 1 + (zPath[0]!='[')); |
| 193642 | + jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); |
| 193643 | + jsonAppendChar(&jx, 0); |
| 193644 | + } |
| 193645 | + pNode = jx.bErr ? 0 : jsonLookup(p, jx.zBuf, 0, ctx); |
| 193646 | + jsonReset(&jx); |
| 193647 | + }else{ |
| 193648 | + pNode = jsonLookup(p, zPath, 0, ctx); |
| 193649 | + } |
| 193650 | + if( pNode ){ |
| 193651 | + if( flags & JSON_JSON ){ |
| 193652 | + jsonReturnJson(pNode, ctx, 0); |
| 193653 | + }else{ |
| 193654 | + jsonReturn(pNode, ctx, 0); |
| 193655 | + sqlite3_result_subtype(ctx, 0); |
| 193656 | + } |
| 193657 | + } |
| 193658 | + }else{ |
| 193659 | + pNode = jsonLookup(p, zPath, 0, ctx); |
| 193660 | + if( p->nErr==0 && pNode ) jsonReturn(pNode, ctx, 0); |
| 193661 | + } |
| 193662 | + }else{ |
| 193663 | + /* Two or more PATH arguments results in a JSON array with each |
| 193664 | + ** element of the array being the value selected by one of the PATHs */ |
| 193665 | + int i; |
| 193666 | + jsonInit(&jx, ctx); |
| 193667 | + jsonAppendChar(&jx, '['); |
| 193668 | + for(i=1; i<argc; i++){ |
| 193669 | + zPath = (const char*)sqlite3_value_text(argv[i]); |
| 193670 | + pNode = jsonLookup(p, zPath, 0, ctx); |
| 193671 | + if( p->nErr ) break; |
| 193426 | 193672 | jsonAppendSeparator(&jx); |
| 193427 | 193673 | if( pNode ){ |
| 193428 | 193674 | jsonRenderNode(pNode, &jx, 0); |
| 193429 | 193675 | }else{ |
| 193430 | 193676 | jsonAppendRaw(&jx, "null", 4); |
| 193431 | 193677 | } |
| 193432 | | - }else if( pNode ){ |
| 193433 | | - jsonReturn(pNode, ctx, 0); |
| 193434 | | - } |
| 193435 | | - } |
| 193436 | | - if( argc>2 && i==argc ){ |
| 193437 | | - jsonAppendChar(&jx, ']'); |
| 193438 | | - jsonResult(&jx); |
| 193439 | | - sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
| 193440 | | - } |
| 193441 | | - jsonReset(&jx); |
| 193678 | + } |
| 193679 | + if( i==argc ){ |
| 193680 | + jsonAppendChar(&jx, ']'); |
| 193681 | + jsonResult(&jx); |
| 193682 | + sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
| 193683 | + } |
| 193684 | + jsonReset(&jx); |
| 193685 | + } |
| 193442 | 193686 | } |
| 193443 | 193687 | |
| 193444 | 193688 | /* This is the RFC 7396 MergePatch algorithm. |
| 193445 | 193689 | */ |
| 193446 | 193690 | static JsonNode *jsonMergePatch( |
| | @@ -193532,11 +193776,11 @@ |
| 193532 | 193776 | ){ |
| 193533 | 193777 | JsonParse x; /* The JSON that is being patched */ |
| 193534 | 193778 | JsonParse y; /* The patch */ |
| 193535 | 193779 | JsonNode *pResult; /* The result of the merge */ |
| 193536 | 193780 | |
| 193537 | | - UNUSED_PARAM(argc); |
| 193781 | + UNUSED_PARAMETER(argc); |
| 193538 | 193782 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
| 193539 | 193783 | if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){ |
| 193540 | 193784 | jsonParseReset(&x); |
| 193541 | 193785 | return; |
| 193542 | 193786 | } |
| | @@ -193653,11 +193897,11 @@ |
| 193653 | 193897 | zPath = (const char*)sqlite3_value_text(argv[i]); |
| 193654 | 193898 | pNode = jsonLookup(&x, zPath, 0, ctx); |
| 193655 | 193899 | if( x.nErr ) goto replace_err; |
| 193656 | 193900 | if( pNode ){ |
| 193657 | 193901 | assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 ); |
| 193658 | | - json_testcase( pNode->eU!=0 && pNode->eU!=1 ); |
| 193902 | + testcase( pNode->eU!=0 && pNode->eU!=1 ); |
| 193659 | 193903 | pNode->jnFlags |= (u8)JNODE_REPLACE; |
| 193660 | 193904 | VVA( pNode->eU = 4 ); |
| 193661 | 193905 | pNode->u.iReplace = i + 1; |
| 193662 | 193906 | } |
| 193663 | 193907 | } |
| | @@ -193668,10 +193912,11 @@ |
| 193668 | 193912 | jsonReturnJson(x.aNode, ctx, argv); |
| 193669 | 193913 | } |
| 193670 | 193914 | replace_err: |
| 193671 | 193915 | jsonParseReset(&x); |
| 193672 | 193916 | } |
| 193917 | + |
| 193673 | 193918 | |
| 193674 | 193919 | /* |
| 193675 | 193920 | ** json_set(JSON, PATH, VALUE, ...) |
| 193676 | 193921 | ** |
| 193677 | 193922 | ** Set the value at PATH to VALUE. Create the PATH if it does not already |
| | @@ -193691,11 +193936,11 @@ |
| 193691 | 193936 | JsonParse x; /* The parse */ |
| 193692 | 193937 | JsonNode *pNode; |
| 193693 | 193938 | const char *zPath; |
| 193694 | 193939 | u32 i; |
| 193695 | 193940 | int bApnd; |
| 193696 | | - int bIsSet = *(int*)sqlite3_user_data(ctx); |
| 193941 | + int bIsSet = sqlite3_user_data(ctx)!=0; |
| 193697 | 193942 | |
| 193698 | 193943 | if( argc<1 ) return; |
| 193699 | 193944 | if( (argc&1)==0 ) { |
| 193700 | 193945 | jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert"); |
| 193701 | 193946 | return; |
| | @@ -193710,11 +193955,11 @@ |
| 193710 | 193955 | sqlite3_result_error_nomem(ctx); |
| 193711 | 193956 | goto jsonSetDone; |
| 193712 | 193957 | }else if( x.nErr ){ |
| 193713 | 193958 | goto jsonSetDone; |
| 193714 | 193959 | }else if( pNode && (bApnd || bIsSet) ){ |
| 193715 | | - json_testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 ); |
| 193960 | + testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 ); |
| 193716 | 193961 | assert( pNode->eU!=3 || pNode->eU!=5 ); |
| 193717 | 193962 | VVA( pNode->eU = 4 ); |
| 193718 | 193963 | pNode->jnFlags |= (u8)JNODE_REPLACE; |
| 193719 | 193964 | pNode->u.iReplace = i + 1; |
| 193720 | 193965 | } |
| | @@ -193731,12 +193976,12 @@ |
| 193731 | 193976 | |
| 193732 | 193977 | /* |
| 193733 | 193978 | ** json_type(JSON) |
| 193734 | 193979 | ** json_type(JSON, PATH) |
| 193735 | 193980 | ** |
| 193736 | | -** Return the top-level "type" of a JSON string. Throw an error if |
| 193737 | | -** either the JSON or PATH inputs are not well-formed. |
| 193981 | +** Return the top-level "type" of a JSON string. json_type() raises an |
| 193982 | +** error if either the JSON or PATH inputs are not well-formed. |
| 193738 | 193983 | */ |
| 193739 | 193984 | static void jsonTypeFunc( |
| 193740 | 193985 | sqlite3_context *ctx, |
| 193741 | 193986 | int argc, |
| 193742 | 193987 | sqlite3_value **argv |
| | @@ -193768,11 +194013,11 @@ |
| 193768 | 194013 | sqlite3_context *ctx, |
| 193769 | 194014 | int argc, |
| 193770 | 194015 | sqlite3_value **argv |
| 193771 | 194016 | ){ |
| 193772 | 194017 | JsonParse *p; /* The parse */ |
| 193773 | | - UNUSED_PARAM(argc); |
| 194018 | + UNUSED_PARAMETER(argc); |
| 193774 | 194019 | p = jsonParseCached(ctx, argv, 0); |
| 193775 | 194020 | sqlite3_result_int(ctx, p!=0); |
| 193776 | 194021 | } |
| 193777 | 194022 | |
| 193778 | 194023 | |
| | @@ -193788,11 +194033,11 @@ |
| 193788 | 194033 | sqlite3_context *ctx, |
| 193789 | 194034 | int argc, |
| 193790 | 194035 | sqlite3_value **argv |
| 193791 | 194036 | ){ |
| 193792 | 194037 | JsonString *pStr; |
| 193793 | | - UNUSED_PARAM(argc); |
| 194038 | + UNUSED_PARAMETER(argc); |
| 193794 | 194039 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); |
| 193795 | 194040 | if( pStr ){ |
| 193796 | 194041 | if( pStr->zBuf==0 ){ |
| 193797 | 194042 | jsonInit(pStr, ctx); |
| 193798 | 194043 | jsonAppendChar(pStr, '['); |
| | @@ -193848,12 +194093,12 @@ |
| 193848 | 194093 | int inStr = 0; |
| 193849 | 194094 | int nNest = 0; |
| 193850 | 194095 | char *z; |
| 193851 | 194096 | char c; |
| 193852 | 194097 | JsonString *pStr; |
| 193853 | | - UNUSED_PARAM(argc); |
| 193854 | | - UNUSED_PARAM(argv); |
| 194098 | + UNUSED_PARAMETER(argc); |
| 194099 | + UNUSED_PARAMETER(argv); |
| 193855 | 194100 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); |
| 193856 | 194101 | #ifdef NEVER |
| 193857 | 194102 | /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will |
| 193858 | 194103 | ** always have been called to initalize it */ |
| 193859 | 194104 | if( NEVER(!pStr) ) return; |
| | @@ -193893,11 +194138,11 @@ |
| 193893 | 194138 | sqlite3_value **argv |
| 193894 | 194139 | ){ |
| 193895 | 194140 | JsonString *pStr; |
| 193896 | 194141 | const char *z; |
| 193897 | 194142 | u32 n; |
| 193898 | | - UNUSED_PARAM(argc); |
| 194143 | + UNUSED_PARAMETER(argc); |
| 193899 | 194144 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); |
| 193900 | 194145 | if( pStr ){ |
| 193901 | 194146 | if( pStr->zBuf==0 ){ |
| 193902 | 194147 | jsonInit(pStr, ctx); |
| 193903 | 194148 | jsonAppendChar(pStr, '{'); |
| | @@ -193984,14 +194229,14 @@ |
| 193984 | 194229 | ** the last two columns in the table. Should this ever changes, be |
| 193985 | 194230 | ** sure to update the xBestIndex method. */ |
| 193986 | 194231 | #define JEACH_JSON 8 |
| 193987 | 194232 | #define JEACH_ROOT 9 |
| 193988 | 194233 | |
| 193989 | | - UNUSED_PARAM(pzErr); |
| 193990 | | - UNUSED_PARAM(argv); |
| 193991 | | - UNUSED_PARAM(argc); |
| 193992 | | - UNUSED_PARAM(pAux); |
| 194234 | + UNUSED_PARAMETER(pzErr); |
| 194235 | + UNUSED_PARAMETER(argv); |
| 194236 | + UNUSED_PARAMETER(argc); |
| 194237 | + UNUSED_PARAMETER(pAux); |
| 193993 | 194238 | rc = sqlite3_declare_vtab(db, |
| 193994 | 194239 | "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path," |
| 193995 | 194240 | "json HIDDEN,root HIDDEN)"); |
| 193996 | 194241 | if( rc==SQLITE_OK ){ |
| 193997 | 194242 | pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); |
| | @@ -194010,11 +194255,11 @@ |
| 194010 | 194255 | |
| 194011 | 194256 | /* constructor for a JsonEachCursor object for json_each(). */ |
| 194012 | 194257 | static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ |
| 194013 | 194258 | JsonEachCursor *pCur; |
| 194014 | 194259 | |
| 194015 | | - UNUSED_PARAM(p); |
| 194260 | + UNUSED_PARAMETER(p); |
| 194016 | 194261 | pCur = sqlite3_malloc( sizeof(*pCur) ); |
| 194017 | 194262 | if( pCur==0 ) return SQLITE_NOMEM; |
| 194018 | 194263 | memset(pCur, 0, sizeof(*pCur)); |
| 194019 | 194264 | *ppCursor = &pCur->base; |
| 194020 | 194265 | return SQLITE_OK; |
| | @@ -194070,11 +194315,11 @@ |
| 194070 | 194315 | u32 iUp = p->sParse.aUp[p->i]; |
| 194071 | 194316 | JsonNode *pUp = &p->sParse.aNode[iUp]; |
| 194072 | 194317 | p->eType = pUp->eType; |
| 194073 | 194318 | if( pUp->eType==JSON_ARRAY ){ |
| 194074 | 194319 | assert( pUp->eU==0 || pUp->eU==3 ); |
| 194075 | | - json_testcase( pUp->eU==3 ); |
| 194320 | + testcase( pUp->eU==3 ); |
| 194076 | 194321 | VVA( pUp->eU = 3 ); |
| 194077 | 194322 | if( iUp==p->i-1 ){ |
| 194078 | 194323 | pUp->u.iKey = 0; |
| 194079 | 194324 | }else{ |
| 194080 | 194325 | pUp->u.iKey++; |
| | @@ -194257,11 +194502,11 @@ |
| 194257 | 194502 | const struct sqlite3_index_constraint *pConstraint; |
| 194258 | 194503 | |
| 194259 | 194504 | /* This implementation assumes that JSON and ROOT are the last two |
| 194260 | 194505 | ** columns in the table */ |
| 194261 | 194506 | assert( JEACH_ROOT == JEACH_JSON+1 ); |
| 194262 | | - UNUSED_PARAM(tab); |
| 194507 | + UNUSED_PARAMETER(tab); |
| 194263 | 194508 | aIdx[0] = aIdx[1] = -1; |
| 194264 | 194509 | pConstraint = pIdxInfo->aConstraint; |
| 194265 | 194510 | for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ |
| 194266 | 194511 | int iCol; |
| 194267 | 194512 | int iMask; |
| | @@ -194313,12 +194558,12 @@ |
| 194313 | 194558 | JsonEachCursor *p = (JsonEachCursor*)cur; |
| 194314 | 194559 | const char *z; |
| 194315 | 194560 | const char *zRoot = 0; |
| 194316 | 194561 | sqlite3_int64 n; |
| 194317 | 194562 | |
| 194318 | | - UNUSED_PARAM(idxStr); |
| 194319 | | - UNUSED_PARAM(argc); |
| 194563 | + UNUSED_PARAMETER(idxStr); |
| 194564 | + UNUSED_PARAMETER(argc); |
| 194320 | 194565 | jsonEachCursorReset(p); |
| 194321 | 194566 | if( idxNum==0 ) return SQLITE_OK; |
| 194322 | 194567 | z = (const char*)sqlite3_value_text(argv[0]); |
| 194323 | 194568 | if( z==0 ) return SQLITE_OK; |
| 194324 | 194569 | n = sqlite3_value_bytes(argv[0]); |
| | @@ -194439,112 +194684,72 @@ |
| 194439 | 194684 | 0, /* xRelease */ |
| 194440 | 194685 | 0, /* xRollbackTo */ |
| 194441 | 194686 | 0 /* xShadowName */ |
| 194442 | 194687 | }; |
| 194443 | 194688 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| 194444 | | - |
| 194445 | | -/**************************************************************************** |
| 194446 | | -** The following routines are the only publically visible identifiers in this |
| 194447 | | -** file. Call the following routines in order to register the various SQL |
| 194448 | | -** functions and the virtual table implemented by this file. |
| 194449 | | -****************************************************************************/ |
| 194450 | | - |
| 194451 | | -SQLITE_PRIVATE int sqlite3Json1Init(sqlite3 *db){ |
| 194452 | | - int rc = SQLITE_OK; |
| 194453 | | - unsigned int i; |
| 194454 | | - static const struct { |
| 194455 | | - const char *zName; |
| 194456 | | - int nArg; |
| 194457 | | - int flag; |
| 194458 | | - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); |
| 194459 | | - } aFunc[] = { |
| 194460 | | - { "json", 1, 0, jsonRemoveFunc }, |
| 194461 | | - { "json_array", -1, 0, jsonArrayFunc }, |
| 194462 | | - { "json_array_length", 1, 0, jsonArrayLengthFunc }, |
| 194463 | | - { "json_array_length", 2, 0, jsonArrayLengthFunc }, |
| 194464 | | - { "json_extract", -1, 0, jsonExtractFunc }, |
| 194465 | | - { "json_insert", -1, 0, jsonSetFunc }, |
| 194466 | | - { "json_object", -1, 0, jsonObjectFunc }, |
| 194467 | | - { "json_patch", 2, 0, jsonPatchFunc }, |
| 194468 | | - { "json_quote", 1, 0, jsonQuoteFunc }, |
| 194469 | | - { "json_remove", -1, 0, jsonRemoveFunc }, |
| 194470 | | - { "json_replace", -1, 0, jsonReplaceFunc }, |
| 194471 | | - { "json_set", -1, 1, jsonSetFunc }, |
| 194472 | | - { "json_type", 1, 0, jsonTypeFunc }, |
| 194473 | | - { "json_type", 2, 0, jsonTypeFunc }, |
| 194474 | | - { "json_valid", 1, 0, jsonValidFunc }, |
| 194475 | | - |
| 194689 | +#endif /* !defined(SQLITE_OMIT_JSON) */ |
| 194690 | + |
| 194691 | +/* |
| 194692 | +** Register JSON functions. |
| 194693 | +*/ |
| 194694 | +SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){ |
| 194695 | +#ifndef SQLITE_OMIT_JSON |
| 194696 | + static FuncDef aJsonFunc[] = { |
| 194697 | + JFUNCTION(json, 1, 0, jsonRemoveFunc), |
| 194698 | + JFUNCTION(json_array, -1, 0, jsonArrayFunc), |
| 194699 | + JFUNCTION(json_array_length, 1, 0, jsonArrayLengthFunc), |
| 194700 | + JFUNCTION(json_array_length, 2, 0, jsonArrayLengthFunc), |
| 194701 | + JFUNCTION(json_extract, -1, 0, jsonExtractFunc), |
| 194702 | + JFUNCTION(->, 2, JSON_JSON, jsonExtractFunc), |
| 194703 | + JFUNCTION(->>, 2, JSON_SQL, jsonExtractFunc), |
| 194704 | + JFUNCTION(json_insert, -1, 0, jsonSetFunc), |
| 194705 | + JFUNCTION(json_object, -1, 0, jsonObjectFunc), |
| 194706 | + JFUNCTION(json_patch, 2, 0, jsonPatchFunc), |
| 194707 | + JFUNCTION(json_quote, 1, 0, jsonQuoteFunc), |
| 194708 | + JFUNCTION(json_remove, -1, 0, jsonRemoveFunc), |
| 194709 | + JFUNCTION(json_replace, -1, 0, jsonReplaceFunc), |
| 194710 | + JFUNCTION(json_set, -1, JSON_ISSET, jsonSetFunc), |
| 194711 | + JFUNCTION(json_type, 1, 0, jsonTypeFunc), |
| 194712 | + JFUNCTION(json_type, 2, 0, jsonTypeFunc), |
| 194713 | + JFUNCTION(json_valid, 1, 0, jsonValidFunc), |
| 194476 | 194714 | #if SQLITE_DEBUG |
| 194477 | | - /* DEBUG and TESTING functions */ |
| 194478 | | - { "json_parse", 1, 0, jsonParseFunc }, |
| 194479 | | - { "json_test1", 1, 0, jsonTest1Func }, |
| 194480 | | -#endif |
| 194481 | | - }; |
| 194482 | | - static const struct { |
| 194483 | | - const char *zName; |
| 194484 | | - int nArg; |
| 194485 | | - void (*xStep)(sqlite3_context*,int,sqlite3_value**); |
| 194486 | | - void (*xFinal)(sqlite3_context*); |
| 194487 | | - void (*xValue)(sqlite3_context*); |
| 194488 | | - } aAgg[] = { |
| 194489 | | - { "json_group_array", 1, |
| 194490 | | - jsonArrayStep, jsonArrayFinal, jsonArrayValue }, |
| 194491 | | - { "json_group_object", 2, |
| 194492 | | - jsonObjectStep, jsonObjectFinal, jsonObjectValue }, |
| 194493 | | - }; |
| 194494 | | -#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 194495 | | - static const struct { |
| 194496 | | - const char *zName; |
| 194497 | | - sqlite3_module *pModule; |
| 194715 | + JFUNCTION(json_parse, 1, 0, jsonParseFunc), |
| 194716 | + JFUNCTION(json_test1, 1, 0, jsonTest1Func), |
| 194717 | +#endif |
| 194718 | + WAGGREGATE(json_group_array, 1, 0, 0, |
| 194719 | + jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse, |
| 194720 | + SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS), |
| 194721 | + WAGGREGATE(json_group_object, 2, 0, 0, |
| 194722 | + jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse, |
| 194723 | + SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS) |
| 194724 | + }; |
| 194725 | + sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc)); |
| 194726 | +#endif |
| 194727 | +} |
| 194728 | + |
| 194729 | +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) |
| 194730 | +/* |
| 194731 | +** Register the JSON table-valued functions |
| 194732 | +*/ |
| 194733 | +SQLITE_PRIVATE int sqlite3JsonTableFunctions(sqlite3 *db){ |
| 194734 | + int rc = SQLITE_OK; |
| 194735 | + static const struct { |
| 194736 | + const char *zName; |
| 194737 | + sqlite3_module *pModule; |
| 194498 | 194738 | } aMod[] = { |
| 194499 | 194739 | { "json_each", &jsonEachModule }, |
| 194500 | 194740 | { "json_tree", &jsonTreeModule }, |
| 194501 | 194741 | }; |
| 194502 | | -#endif |
| 194503 | | - static const int enc = |
| 194504 | | - SQLITE_UTF8 | |
| 194505 | | - SQLITE_DETERMINISTIC | |
| 194506 | | - SQLITE_INNOCUOUS; |
| 194507 | | - for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){ |
| 194508 | | - rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg, enc, |
| 194509 | | - (void*)&aFunc[i].flag, |
| 194510 | | - aFunc[i].xFunc, 0, 0); |
| 194511 | | - } |
| 194512 | | -#ifndef SQLITE_OMIT_WINDOWFUNC |
| 194513 | | - for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){ |
| 194514 | | - rc = sqlite3_create_window_function(db, aAgg[i].zName, aAgg[i].nArg, |
| 194515 | | - SQLITE_SUBTYPE | enc, 0, |
| 194516 | | - aAgg[i].xStep, aAgg[i].xFinal, |
| 194517 | | - aAgg[i].xValue, jsonGroupInverse, 0); |
| 194518 | | - } |
| 194519 | | -#endif |
| 194520 | | -#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 194742 | + int i; |
| 194521 | 194743 | for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){ |
| 194522 | 194744 | rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0); |
| 194523 | 194745 | } |
| 194524 | | -#endif |
| 194525 | 194746 | return rc; |
| 194526 | 194747 | } |
| 194527 | | - |
| 194528 | | - |
| 194529 | | -#ifndef SQLITE_CORE |
| 194530 | | -#ifdef _WIN32 |
| 194531 | | -__declspec(dllexport) |
| 194532 | | -#endif |
| 194533 | | -SQLITE_API int sqlite3_json_init( |
| 194534 | | - sqlite3 *db, |
| 194535 | | - char **pzErrMsg, |
| 194536 | | - const sqlite3_api_routines *pApi |
| 194537 | | -){ |
| 194538 | | - SQLITE_EXTENSION_INIT2(pApi); |
| 194539 | | - (void)pzErrMsg; /* Unused parameter */ |
| 194540 | | - return sqlite3Json1Init(db); |
| 194541 | | -} |
| 194542 | | -#endif |
| 194543 | | -#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) */ |
| 194544 | | - |
| 194545 | | -/************** End of json1.c ***********************************************/ |
| 194748 | +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) */ |
| 194749 | + |
| 194750 | +/************** End of json.c ************************************************/ |
| 194546 | 194751 | /************** Begin file rtree.c *******************************************/ |
| 194547 | 194752 | /* |
| 194548 | 194753 | ** 2001 September 15 |
| 194549 | 194754 | ** |
| 194550 | 194755 | ** The author disclaims copyright to this source code. In place of |
| | @@ -198974,15 +199179,11 @@ |
| 198974 | 199179 | # define GEODEBUG(X) if(geo_debug)printf X |
| 198975 | 199180 | #else |
| 198976 | 199181 | # define GEODEBUG(X) |
| 198977 | 199182 | #endif |
| 198978 | 199183 | |
| 198979 | | -#ifndef JSON_NULL /* The following stuff repeats things found in json1 */ |
| 198980 | | -/* |
| 198981 | | -** Versions of isspace(), isalnum() and isdigit() to which it is safe |
| 198982 | | -** to pass signed char values. |
| 198983 | | -*/ |
| 199184 | +/* Character class routines */ |
| 198984 | 199185 | #ifdef sqlite3Isdigit |
| 198985 | 199186 | /* Use the SQLite core versions if this routine is part of the |
| 198986 | 199187 | ** SQLite amalgamation */ |
| 198987 | 199188 | # define safe_isdigit(x) sqlite3Isdigit(x) |
| 198988 | 199189 | # define safe_isalnum(x) sqlite3Isalnum(x) |
| | @@ -198993,10 +199194,11 @@ |
| 198993 | 199194 | # define safe_isdigit(x) isdigit((unsigned char)(x)) |
| 198994 | 199195 | # define safe_isalnum(x) isalnum((unsigned char)(x)) |
| 198995 | 199196 | # define safe_isxdigit(x) isxdigit((unsigned char)(x)) |
| 198996 | 199197 | #endif |
| 198997 | 199198 | |
| 199199 | +#ifndef JSON_NULL /* The following stuff repeats things found in json1 */ |
| 198998 | 199200 | /* |
| 198999 | 199201 | ** Growing our own isspace() routine this way is twice as fast as |
| 199000 | 199202 | ** the library isspace() function. |
| 199001 | 199203 | */ |
| 199002 | 199204 | static const char geopolyIsSpace[] = { |
| | @@ -199015,11 +199217,11 @@ |
| 199015 | 199217 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 199016 | 199218 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 199017 | 199219 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 199018 | 199220 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 199019 | 199221 | }; |
| 199020 | | -#define safe_isspace(x) (geopolyIsSpace[(unsigned char)x]) |
| 199222 | +#define fast_isspace(x) (geopolyIsSpace[(unsigned char)x]) |
| 199021 | 199223 | #endif /* JSON NULL - back to original code */ |
| 199022 | 199224 | |
| 199023 | 199225 | /* Compiler and version */ |
| 199024 | 199226 | #ifndef GCC_VERSION |
| 199025 | 199227 | #if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) |
| | @@ -199104,11 +199306,11 @@ |
| 199104 | 199306 | a[2] = t; |
| 199105 | 199307 | } |
| 199106 | 199308 | |
| 199107 | 199309 | /* Skip whitespace. Return the next non-whitespace character. */ |
| 199108 | 199310 | static char geopolySkipSpace(GeoParse *p){ |
| 199109 | | - while( safe_isspace(p->z[0]) ) p->z++; |
| 199311 | + while( fast_isspace(p->z[0]) ) p->z++; |
| 199110 | 199312 | return p->z[0]; |
| 199111 | 199313 | } |
| 199112 | 199314 | |
| 199113 | 199315 | /* Parse out a number. Write the value into *pVal if pVal!=0. |
| 199114 | 199316 | ** return non-zero on success and zero if the next token is not a number. |
| | @@ -229084,11 +229286,11 @@ |
| 229084 | 229286 | assert( (flags & FTS5INDEX_QUERY_SCAN)==0 || flags==FTS5INDEX_QUERY_SCAN ); |
| 229085 | 229287 | |
| 229086 | 229288 | if( sqlite3Fts5BufferSize(&p->rc, &buf, nToken+1)==0 ){ |
| 229087 | 229289 | int iIdx = 0; /* Index to search */ |
| 229088 | 229290 | int iPrefixIdx = 0; /* +1 prefix index */ |
| 229089 | | - if( nToken ) memcpy(&buf.p[1], pToken, nToken); |
| 229291 | + if( nToken>0 ) memcpy(&buf.p[1], pToken, nToken); |
| 229090 | 229292 | |
| 229091 | 229293 | /* Figure out which index to search and set iIdx accordingly. If this |
| 229092 | 229294 | ** is a prefix query for which there is no prefix index, set iIdx to |
| 229093 | 229295 | ** greater than pConfig->nPrefix to indicate that the query will be |
| 229094 | 229296 | ** satisfied by scanning multiple terms in the main index. |
| | @@ -233132,11 +233334,11 @@ |
| 233132 | 233334 | int nArg, /* Number of args */ |
| 233133 | 233335 | sqlite3_value **apUnused /* Function arguments */ |
| 233134 | 233336 | ){ |
| 233135 | 233337 | assert( nArg==0 ); |
| 233136 | 233338 | UNUSED_PARAM2(nArg, apUnused); |
| 233137 | | - sqlite3_result_text(pCtx, "fts5: 2021-12-09 20:06:18 633bfeeea2bccdd44126acf3f61ecca163c9d933bdc787a2c18a697dc9406882", -1, SQLITE_TRANSIENT); |
| 233339 | + sqlite3_result_text(pCtx, "fts5: 2022-01-12 00:28:12 adebb9d7478d092f16fb0ef7d5246ce152b166479d6f949110b5878b89ea2cec", -1, SQLITE_TRANSIENT); |
| 233138 | 233340 | } |
| 233139 | 233341 | |
| 233140 | 233342 | /* |
| 233141 | 233343 | ** Return true if zName is the extension on one of the shadow tables used |
| 233142 | 233344 | ** by this module. |
| 233143 | 233345 | |