* [tarantool-patches] [PATCH v3] sql: remove support of partial indexes
@ 2018-04-24 18:39 Gleb
2018-04-25 9:22 ` [tarantool-patches] " Alexander Turenko
0 siblings, 1 reply; 5+ messages in thread
From: Gleb @ 2018-04-24 18:39 UTC (permalink / raw)
To: tarantool-patches
Remove support of partial indexes.
Add test which checks inaccessibility of partial index syntax.
Delete usage of partial index from tests.
They can be enabled after #2626.
Fixes #2165
---
Issue from https://github.com/tarantool/tarantool/issues/2165.
Source from https://github.com/tarantool/tarantool/tree/gh-2165-remove-support-partial-indexes.
Changes in v3:
-return tests which use partial.
-delete "WHERE" from returned tests.
-correct syntax errors in commit
src/box/sql/parse.c | 4014 ++++++++++++++++++++
src/box/sql/parse.y | 4 +-
test/sql-tap/analyze9.test.lua | 2 +-
test/sql-tap/autoindex4.test.lua | 2 +-
test/sql-tap/fkey1.test.lua | 2 +-
...gh-2165-remove-support-partial-indexes.test.lua | 17 +
test/sql-tap/index6.test.lua | 12 +-
test/sql-tap/index7.test.lua | 25 +-
8 files changed, 4055 insertions(+), 23 deletions(-)
create mode 100644 src/box/sql/parse.c
create mode 100644 test/sql-tap/gh-2165-remove-support-partial-indexes.test.lua
diff --git a/src/box/sql/parse.c b/src/box/sql/parse.c
new file mode 100644
index 0000000..36246c3
--- /dev/null
+++ b/src/box/sql/parse.c
@@ -0,0 +1,4014 @@
+/*
+** 2000-05-29
+**
+** The author disclaims copyright to this source code. In place of
+** a legal notice, here is a blessing:
+**
+** May you do good and not evil.
+** May you find forgiveness for yourself and forgive others.
+** May you share freely, never taking more than you give.
+**
+*************************************************************************
+** Driver template for the LEMON parser generator.
+**
+** The "lemon" program processes an LALR(1) input grammar file, then uses
+** this template to construct a parser. The "lemon" program inserts text
+** at each "%%" line. Also, any "P-a-r-s-e" identifer prefix (without the
+** interstitial "-" characters) contained in this template is changed into
+** the value of the %name directive from the grammar. Otherwise, the content
+** of this template is copied straight through into the generate parser
+** source file.
+**
+** The following is the concatenation of all %include directives from the
+** input grammar file:
+*/
+#include <stdio.h>
+#include <stdbool.h>
+/************ Begin %include sections from the grammar ************************/
+#line 52 "parse.y"
+
+#include "sqliteInt.h"
+
+/*
+** Disable all error recovery processing in the parser push-down
+** automaton.
+*/
+#define YYNOERRORRECOVERY 1
+
+/*
+** Make yytestcase() the same as testcase()
+*/
+#define yytestcase(X) testcase(X)
+
+/*
+** Indicate that sqlite3ParserFree() will never be called with a null
+** pointer.
+*/
+#define YYPARSEFREENEVERNULL 1
+
+/*
+** Alternative datatype for the argument to the malloc() routine passed
+** into sqlite3ParserAlloc(). The default is size_t.
+*/
+#define YYMALLOCARGTYPE u64
+
+/*
+** An instance of this structure holds information about the
+** LIMIT clause of a SELECT statement.
+*/
+struct LimitVal {
+ Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */
+ Expr *pOffset; /* The OFFSET expression. NULL if there is none */
+};
+
+/*
+** An instance of the following structure describes the event of a
+** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
+** TK_DELETE, or TK_INSTEAD. If the event is of the form
+**
+** UPDATE ON (a,b,c)
+**
+** Then the "b" IdList records the list "a,b,c".
+*/
+struct TrigEvent { int a; IdList * b; };
+
+/*
+** Disable lookaside memory allocation for objects that might be
+** shared across database connections.
+*/
+static void disableLookaside(Parse *pParse){
+ pParse->disableLookaside++;
+ pParse->db->lookaside.bDisable++;
+}
+
+#line 403 "parse.y"
+
+ /*
+ ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
+ ** all elements in the list. And make sure list length does not exceed
+ ** SQLITE_LIMIT_COMPOUND_SELECT.
+ */
+ static void parserDoubleLinkSelect(Parse *pParse, Select *p){
+ if( p->pPrior ){
+ Select *pNext = 0, *pLoop;
+ int mxSelect, cnt = 0;
+ for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
+ pLoop->pNext = pNext;
+ pLoop->selFlags |= SF_Compound;
+ }
+ if( (p->selFlags & SF_MultiValue)==0 &&
+ (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&
+ cnt>mxSelect
+ ){
+ sqlite3ErrorMsg(pParse, "Too many UNION or EXCEPT or INTERSECT operations");
+ }
+ }
+ }
+#line 840 "parse.y"
+
+ /* This is a utility routine used to set the ExprSpan.zStart and
+ ** ExprSpan.zEnd values of pOut so that the span covers the complete
+ ** range of text beginning with pStart and going to the end of pEnd.
+ */
+ static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
+ pOut->zStart = pStart->z;
+ pOut->zEnd = &pEnd->z[pEnd->n];
+ }
+
+ /* Construct a new Expr object from a single identifier. Use the
+ ** new Expr to populate pOut. Set the span of pOut to be the identifier
+ ** that created the expression.
+ */
+ static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token t){
+ Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
+ if( p ){
+ memset(p, 0, sizeof(Expr));
+ p->op = (u8)op;
+ p->flags = EP_Leaf;
+ p->iAgg = -1;
+ p->u.zToken = (char*)&p[1];
+ memcpy(p->u.zToken, t.z, t.n);
+ p->u.zToken[t.n] = 0;
+ if (op != TK_VARIABLE){
+ sqlite3NormalizeName(p->u.zToken);
+ }
+#if SQLITE_MAX_EXPR_DEPTH>0
+ p->nHeight = 1;
+#endif
+ }
+ pOut->pExpr = p;
+ pOut->zStart = t.z;
+ pOut->zEnd = &t.z[t.n];
+ }
+#line 948 "parse.y"
+
+ /* This routine constructs a binary expression node out of two ExprSpan
+ ** objects and uses the result to populate a new ExprSpan object.
+ */
+ static void spanBinaryExpr(
+ Parse *pParse, /* The parsing context. Errors accumulate here */
+ int op, /* The binary operation */
+ ExprSpan *pLeft, /* The left operand, and output */
+ ExprSpan *pRight /* The right operand */
+ ){
+ pLeft->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr);
+ pLeft->zEnd = pRight->zEnd;
+ }
+
+ /* If doNot is true, then add a TK_NOT Expr-node wrapper around the
+ ** outside of *ppExpr.
+ */
+ static void exprNot(Parse *pParse, int doNot, ExprSpan *pSpan){
+ if( doNot ){
+ pSpan->pExpr = sqlite3PExpr(pParse, TK_NOT, pSpan->pExpr, 0);
+ }
+ }
+#line 1022 "parse.y"
+
+ /* Construct an expression node for a unary postfix operator
+ */
+ static void spanUnaryPostfix(
+ Parse *pParse, /* Parsing context to record errors */
+ int op, /* The operator */
+ ExprSpan *pOperand, /* The operand, and output */
+ Token *pPostOp /* The operand token for setting the span */
+ ){
+ pOperand->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0);
+ pOperand->zEnd = &pPostOp->z[pPostOp->n];
+ }
+#line 1039 "parse.y"
+
+ /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
+ ** unary TK_ISNULL or TK_NOTNULL expression. */
+ static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
+ sqlite3 *db = pParse->db;
+ if( pA && pY && pY->op==TK_NULL ){
+ pA->op = (u8)op;
+ sql_expr_free(db, pA->pRight, false);
+ pA->pRight = 0;
+ }
+ }
+#line 1067 "parse.y"
+
+ /* Construct an expression node for a unary prefix operator
+ */
+ static void spanUnaryPrefix(
+ ExprSpan *pOut, /* Write the new expression node here */
+ Parse *pParse, /* Parsing context to record errors */
+ int op, /* The operator */
+ ExprSpan *pOperand, /* The operand */
+ Token *pPreOp /* The operand token for setting the span */
+ ){
+ pOut->zStart = pPreOp->z;
+ pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0);
+ pOut->zEnd = pOperand->zEnd;
+ }
+#line 1268 "parse.y"
+
+ /* Add a single new term to an ExprList that is used to store a
+ ** list of identifiers. Report an error if the ID list contains
+ ** a COLLATE clause or an ASC or DESC keyword, except ignore the
+ ** error while parsing a legacy schema.
+ */
+ static ExprList *parserAddExprIdListTerm(
+ Parse *pParse,
+ ExprList *pPrior,
+ Token *pIdToken,
+ int hasCollate,
+ int sortOrder
+ ){
+ ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
+ if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED)
+ && pParse->db->init.busy==0
+ ){
+ sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
+ pIdToken->n, pIdToken->z);
+ }
+ sqlite3ExprListSetName(pParse, p, pIdToken, 1);
+ return p;
+ }
+#line 231 "parse.c"
+/**************** End of %include directives **********************************/
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders". This section is blank unless
+** "lemon" is run with the "-m" command-line option.
+***************** Begin makeheaders token definitions *************************/
+/**************** End makeheaders token definitions ***************************/
+
+/* The next sections is a series of control #defines.
+** various aspects of the generated parser.
+** YYCODETYPE is the data type used to store the integer codes
+** that represent terminal and non-terminal symbols.
+** "unsigned char" is used if there are fewer than
+** 256 symbols. Larger types otherwise.
+** YYNOCODE is a number of type YYCODETYPE that is not used for
+** any terminal or nonterminal symbol.
+** YYFALLBACK If defined, this indicates that one or more tokens
+** (also known as: "terminal symbols") have fall-back
+** values which should be used if the original symbol
+** would not parse. This permits keywords to sometimes
+** be used as identifiers, for example.
+** YYACTIONTYPE is the data type used for "action codes" - numbers
+** that indicate what to do in response to the next
+** token.
+** sqlite3ParserTOKENTYPE is the data type used for minor type for terminal
+** symbols. Background: A "minor type" is a semantic
+** value associated with a terminal or non-terminal
+** symbols. For example, for an "ID" terminal symbol,
+** the minor type might be the name of the identifier.
+** Each non-terminal can have a different minor type.
+** Terminal symbols all have the same minor type, though.
+** This macros defines the minor type for terminal
+** symbols.
+** YYMINORTYPE is the data type used for all minor types.
+** This is typically a union of many types, one of
+** which is sqlite3ParserTOKENTYPE. The entry in the union
+** for terminal symbols is called "yy0".
+** YYSTACKDEPTH is the maximum depth of the parser's stack. If
+** zero the stack is dynamically sized using realloc()
+** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument
+** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument
+** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser
+** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser
+** YYERRORSYMBOL is the code number of the error symbol. If not
+** defined, then do no error processing.
+** YYNSTATE the combined number of states.
+** YYNRULE the number of rules in the grammar
+** YY_MAX_SHIFT Maximum value for shift actions
+** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+** YY_MIN_REDUCE Maximum value for reduce actions
+** YY_ERROR_ACTION The yy_action[] code for syntax error
+** YY_ACCEPT_ACTION The yy_action[] code for accept
+** YY_NO_ACTION The yy_action[] code for no-op
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/************* Begin control #defines *****************************************/
+#define YYCODETYPE unsigned char
+#define YYNOCODE 231
+#define YYACTIONTYPE unsigned short int
+#define YYWILDCARD 74
+#define sqlite3ParserTOKENTYPE Token
+typedef union {
+ int yyinit;
+ sqlite3ParserTOKENTYPE yy0;
+ struct TrigEvent yy10;
+ IdList* yy40;
+ int yy52;
+ struct {int value; int mask;} yy107;
+ With* yy151;
+ ExprSpan yy162;
+ Select* yy279;
+ Expr* yy362;
+ ExprList* yy382;
+ struct LimitVal yy384;
+ SrcList* yy387;
+ TriggerStep* yy427;
+} YYMINORTYPE;
+#ifndef YYSTACKDEPTH
+#define YYSTACKDEPTH 100
+#endif
+#define sqlite3ParserARG_SDECL Parse *pParse;
+#define sqlite3ParserARG_PDECL ,Parse *pParse
+#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
+#define sqlite3ParserARG_STORE yypParser->pParse = pParse
+#define YYFALLBACK 1
+#define YYNSTATE 408
+#define YYNRULE 297
+#define YY_MAX_SHIFT 407
+#define YY_MIN_SHIFTREDUCE 603
+#define YY_MAX_SHIFTREDUCE 899
+#define YY_MIN_REDUCE 900
+#define YY_MAX_REDUCE 1196
+#define YY_ERROR_ACTION 1197
+#define YY_ACCEPT_ACTION 1198
+#define YY_NO_ACTION 1199
+/************* End control #defines *******************************************/
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage. For production
+** code the yytestcase() macro should be turned off. But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token. These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N. Then the action is determined as
+** follows
+**
+** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead
+** token onto the stack and goto state N.
+**
+** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
+** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE.
+**
+** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE
+** and YY_MAX_REDUCE
+**
+** N == YY_ERROR_ACTION A syntax error has occurred.
+**
+** N == YY_ACCEPT_ACTION The parser accepts its input.
+**
+** N == YY_NO_ACTION No such action. Denotes unused
+** slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as either:
+**
+** (A) N = yy_action[ yy_shift_ofst[S] + X ]
+** (B) N = yy_default[S]
+**
+** The (A) formula is preferred. The B formula is used instead if:
+** (1) The yy_shift_ofst[S]+X value is out of range, or
+** (2) yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
+** (3) yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
+** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
+** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
+** Hence only tests (1) and (2) need to be evaluated.)
+**
+** The formulas above are for computing the action when the lookahead is
+** a terminal symbol. If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+** yy_action[] A single table containing all actions.
+** yy_lookahead[] A table containing the lookahead for each entry in
+** yy_action. Used to detect hash collisions.
+** yy_shift_ofst[] For each state, the offset into yy_action for
+** shifting terminals.
+** yy_reduce_ofst[] For each state, the offset into yy_action for
+** shifting non-terminals after a reduce.
+** yy_default[] Default action for each state.
+**
+*********** Begin parsing tables **********************************************/
+#define YY_ACTTAB_COUNT (1401)
+static const YYACTIONTYPE yy_action[] = {
+ /* 0 */ 91, 92, 284, 82, 770, 770, 782, 785, 774, 774,
+ /* 10 */ 89, 89, 90, 90, 90, 90, 306, 88, 88, 88,
+ /* 20 */ 88, 87, 87, 86, 86, 86, 85, 306, 90, 90,
+ /* 30 */ 90, 90, 83, 88, 88, 88, 88, 87, 87, 86,
+ /* 40 */ 86, 86, 85, 306, 208, 201, 884, 90, 90, 90,
+ /* 50 */ 90, 122, 88, 88, 88, 88, 87, 87, 86, 86,
+ /* 60 */ 86, 85, 306, 87, 87, 86, 86, 86, 85, 306,
+ /* 70 */ 884, 86, 86, 86, 85, 306, 91, 92, 284, 82,
+ /* 80 */ 770, 770, 782, 785, 774, 774, 89, 89, 90, 90,
+ /* 90 */ 90, 90, 629, 88, 88, 88, 88, 87, 87, 86,
+ /* 100 */ 86, 86, 85, 306, 91, 92, 284, 82, 770, 770,
+ /* 110 */ 782, 785, 774, 774, 89, 89, 90, 90, 90, 90,
+ /* 120 */ 286, 88, 88, 88, 88, 87, 87, 86, 86, 86,
+ /* 130 */ 85, 306, 704, 91, 92, 284, 82, 770, 770, 782,
+ /* 140 */ 785, 774, 774, 89, 89, 90, 90, 90, 90, 67,
+ /* 150 */ 88, 88, 88, 88, 87, 87, 86, 86, 86, 85,
+ /* 160 */ 306, 771, 771, 783, 786, 739, 93, 172, 279, 705,
+ /* 170 */ 311, 277, 276, 275, 220, 273, 242, 632, 617, 720,
+ /* 180 */ 721, 631, 91, 92, 284, 82, 770, 770, 782, 785,
+ /* 190 */ 774, 774, 89, 89, 90, 90, 90, 90, 109, 88,
+ /* 200 */ 88, 88, 88, 87, 87, 86, 86, 86, 85, 306,
+ /* 210 */ 88, 88, 88, 88, 87, 87, 86, 86, 86, 85,
+ /* 220 */ 306, 343, 165, 705, 340, 637, 285, 304, 303, 823,
+ /* 230 */ 775, 91, 92, 284, 82, 770, 770, 782, 785, 774,
+ /* 240 */ 774, 89, 89, 90, 90, 90, 90, 332, 88, 88,
+ /* 250 */ 88, 88, 87, 87, 86, 86, 86, 85, 306, 182,
+ /* 260 */ 742, 665, 644, 406, 406, 180, 312, 122, 137, 218,
+ /* 270 */ 665, 119, 623, 623, 630, 678, 236, 329, 235, 876,
+ /* 280 */ 91, 92, 284, 82, 770, 770, 782, 785, 774, 774,
+ /* 290 */ 89, 89, 90, 90, 90, 90, 742, 88, 88, 88,
+ /* 300 */ 88, 87, 87, 86, 86, 86, 85, 306, 22, 215,
+ /* 310 */ 403, 183, 236, 319, 224, 760, 895, 753, 895, 54,
+ /* 320 */ 748, 719, 704, 761, 122, 216, 365, 48, 48, 91,
+ /* 330 */ 92, 284, 82, 770, 770, 782, 785, 774, 774, 89,
+ /* 340 */ 89, 90, 90, 90, 90, 264, 88, 88, 88, 88,
+ /* 350 */ 87, 87, 86, 86, 86, 85, 306, 752, 752, 754,
+ /* 360 */ 223, 199, 381, 366, 355, 352, 351, 648, 84, 81,
+ /* 370 */ 176, 698, 747, 1198, 407, 3, 350, 293, 91, 92,
+ /* 380 */ 284, 82, 770, 770, 782, 785, 774, 774, 89, 89,
+ /* 390 */ 90, 90, 90, 90, 316, 88, 88, 88, 88, 87,
+ /* 400 */ 87, 86, 86, 86, 85, 306, 91, 92, 284, 82,
+ /* 410 */ 770, 770, 782, 785, 774, 774, 89, 89, 90, 90,
+ /* 420 */ 90, 90, 647, 88, 88, 88, 88, 87, 87, 86,
+ /* 430 */ 86, 86, 85, 306, 91, 92, 284, 82, 770, 770,
+ /* 440 */ 782, 785, 774, 774, 89, 89, 90, 90, 90, 90,
+ /* 450 */ 122, 88, 88, 88, 88, 87, 87, 86, 86, 86,
+ /* 460 */ 85, 306, 91, 92, 284, 82, 770, 770, 782, 785,
+ /* 470 */ 774, 774, 89, 89, 90, 90, 90, 90, 145, 88,
+ /* 480 */ 88, 88, 88, 87, 87, 86, 86, 86, 85, 306,
+ /* 490 */ 1149, 1149, 84, 81, 176, 70, 92, 284, 82, 770,
+ /* 500 */ 770, 782, 785, 774, 774, 89, 89, 90, 90, 90,
+ /* 510 */ 90, 646, 88, 88, 88, 88, 87, 87, 86, 86,
+ /* 520 */ 86, 85, 306, 73, 207, 122, 401, 401, 401, 91,
+ /* 530 */ 80, 284, 82, 770, 770, 782, 785, 774, 774, 89,
+ /* 540 */ 89, 90, 90, 90, 90, 375, 88, 88, 88, 88,
+ /* 550 */ 87, 87, 86, 86, 86, 85, 306, 284, 82, 770,
+ /* 560 */ 770, 782, 785, 774, 774, 89, 89, 90, 90, 90,
+ /* 570 */ 90, 78, 88, 88, 88, 88, 87, 87, 86, 86,
+ /* 580 */ 86, 85, 306, 403, 305, 305, 305, 604, 309, 141,
+ /* 590 */ 75, 76, 263, 623, 623, 691, 872, 77, 283, 314,
+ /* 600 */ 48, 48, 304, 303, 639, 78, 264, 84, 81, 176,
+ /* 610 */ 399, 2, 1096, 314, 313, 307, 307, 200, 199, 200,
+ /* 620 */ 141, 355, 352, 351, 75, 76, 272, 623, 623, 280,
+ /* 630 */ 403, 77, 388, 350, 386, 381, 371, 760, 302, 753,
+ /* 640 */ 742, 1172, 748, 660, 399, 2, 403, 10, 10, 307,
+ /* 650 */ 307, 890, 298, 894, 382, 372, 236, 329, 235, 370,
+ /* 660 */ 892, 292, 893, 48, 48, 360, 388, 750, 347, 332,
+ /* 670 */ 201, 760, 845, 753, 704, 314, 748, 295, 397, 752,
+ /* 680 */ 752, 754, 755, 402, 18, 138, 846, 109, 403, 623,
+ /* 690 */ 623, 895, 109, 895, 847, 671, 164, 122, 381, 383,
+ /* 700 */ 373, 750, 672, 842, 122, 48, 48, 162, 174, 78,
+ /* 710 */ 718, 842, 184, 752, 752, 754, 755, 402, 18, 885,
+ /* 720 */ 885, 217, 155, 252, 358, 247, 357, 203, 75, 76,
+ /* 730 */ 692, 122, 688, 189, 245, 77, 109, 687, 403, 327,
+ /* 740 */ 381, 380, 869, 78, 109, 286, 362, 403, 399, 2,
+ /* 750 */ 245, 85, 306, 307, 307, 30, 30, 84, 81, 176,
+ /* 760 */ 330, 657, 75, 76, 48, 48, 869, 403, 330, 77,
+ /* 770 */ 388, 886, 707, 23, 369, 760, 167, 753, 328, 109,
+ /* 780 */ 748, 254, 399, 2, 10, 10, 339, 307, 307, 403,
+ /* 790 */ 363, 9, 9, 216, 365, 403, 177, 177, 294, 381,
+ /* 800 */ 361, 829, 829, 324, 388, 750, 48, 48, 368, 760,
+ /* 810 */ 704, 753, 10, 10, 748, 658, 403, 752, 752, 754,
+ /* 820 */ 755, 402, 18, 623, 623, 403, 198, 403, 338, 885,
+ /* 830 */ 885, 670, 670, 48, 48, 315, 157, 156, 822, 750,
+ /* 840 */ 822, 299, 47, 47, 10, 10, 66, 68, 185, 815,
+ /* 850 */ 817, 752, 752, 754, 755, 402, 18, 95, 378, 146,
+ /* 860 */ 403, 633, 633, 177, 177, 651, 75, 76, 376, 240,
+ /* 870 */ 5, 356, 208, 77, 884, 368, 652, 34, 34, 642,
+ /* 880 */ 338, 886, 706, 760, 403, 753, 399, 2, 748, 317,
+ /* 890 */ 704, 307, 307, 705, 296, 229, 262, 704, 884, 403,
+ /* 900 */ 24, 35, 35, 334, 623, 623, 805, 845, 388, 623,
+ /* 910 */ 623, 815, 188, 760, 403, 753, 36, 36, 748, 239,
+ /* 920 */ 178, 846, 403, 746, 403, 752, 752, 754, 848, 847,
+ /* 930 */ 387, 37, 37, 403, 704, 320, 403, 668, 668, 38,
+ /* 940 */ 38, 26, 26, 750, 403, 228, 165, 705, 403, 840,
+ /* 950 */ 27, 27, 232, 29, 29, 752, 752, 754, 755, 402,
+ /* 960 */ 18, 39, 39, 403, 234, 40, 40, 826, 263, 825,
+ /* 970 */ 403, 704, 677, 403, 920, 322, 227, 403, 226, 403,
+ /* 980 */ 41, 41, 109, 622, 287, 403, 323, 11, 11, 403,
+ /* 990 */ 42, 42, 143, 403, 97, 97, 43, 43, 403, 746,
+ /* 1000 */ 403, 256, 44, 44, 403, 338, 31, 31, 403, 673,
+ /* 1010 */ 45, 45, 403, 746, 403, 46, 46, 32, 32, 403,
+ /* 1020 */ 751, 112, 112, 251, 693, 113, 113, 403, 704, 114,
+ /* 1030 */ 114, 52, 52, 403, 250, 403, 33, 33, 403, 676,
+ /* 1040 */ 403, 208, 403, 884, 98, 98, 403, 623, 623, 258,
+ /* 1050 */ 49, 49, 99, 99, 393, 100, 100, 96, 96, 111,
+ /* 1060 */ 111, 403, 289, 108, 108, 403, 231, 884, 403, 746,
+ /* 1070 */ 403, 746, 109, 403, 163, 403, 290, 403, 104, 104,
+ /* 1080 */ 403, 169, 103, 103, 403, 101, 101, 102, 102, 191,
+ /* 1090 */ 51, 51, 53, 53, 50, 50, 107, 25, 25, 1,
+ /* 1100 */ 627, 28, 28, 623, 623, 364, 680, 683, 683, 621,
+ /* 1110 */ 161, 160, 159, 400, 287, 390, 394, 368, 398, 175,
+ /* 1120 */ 174, 336, 720, 721, 627, 74, 883, 72, 688, 110,
+ /* 1130 */ 261, 149, 291, 687, 300, 744, 20, 206, 331, 333,
+ /* 1140 */ 206, 206, 109, 804, 64, 66, 650, 649, 109, 109,
+ /* 1150 */ 348, 109, 212, 243, 821, 66, 821, 640, 640, 685,
+ /* 1160 */ 714, 69, 206, 7, 812, 812, 337, 19, 734, 808,
+ /* 1170 */ 625, 212, 106, 851, 756, 756, 318, 850, 153, 819,
+ /* 1180 */ 288, 813, 225, 168, 233, 837, 839, 836, 335, 341,
+ /* 1190 */ 342, 238, 353, 616, 241, 158, 661, 645, 246, 712,
+ /* 1200 */ 644, 745, 260, 694, 249, 389, 810, 265, 809, 266,
+ /* 1210 */ 271, 628, 154, 865, 614, 613, 615, 862, 135, 124,
+ /* 1220 */ 117, 64, 321, 824, 731, 55, 326, 230, 346, 187,
+ /* 1230 */ 147, 194, 144, 195, 126, 359, 196, 297, 642, 128,
+ /* 1240 */ 664, 129, 130, 131, 344, 281, 663, 139, 662, 374,
+ /* 1250 */ 63, 6, 741, 71, 841, 636, 301, 282, 635, 655,
+ /* 1260 */ 94, 248, 634, 874, 379, 65, 654, 21, 377, 863,
+ /* 1270 */ 222, 606, 609, 308, 179, 310, 123, 278, 219, 221,
+ /* 1280 */ 404, 702, 405, 611, 392, 818, 610, 607, 816, 181,
+ /* 1290 */ 115, 396, 740, 125, 120, 116, 127, 186, 674, 827,
+ /* 1300 */ 253, 206, 132, 897, 105, 202, 133, 703, 835, 325,
+ /* 1310 */ 255, 134, 136, 701, 700, 56, 57, 270, 257, 259,
+ /* 1320 */ 684, 267, 268, 269, 58, 59, 121, 838, 190, 192,
+ /* 1330 */ 790, 834, 8, 209, 12, 237, 619, 193, 148, 345,
+ /* 1340 */ 197, 140, 210, 211, 250, 349, 354, 653, 60, 13,
+ /* 1350 */ 204, 244, 14, 61, 62, 118, 682, 170, 759, 758,
+ /* 1360 */ 788, 15, 205, 686, 4, 713, 367, 171, 173, 142,
+ /* 1370 */ 708, 69, 384, 16, 66, 803, 17, 789, 385, 787,
+ /* 1380 */ 792, 844, 843, 166, 391, 855, 150, 151, 213, 856,
+ /* 1390 */ 274, 152, 395, 791, 757, 626, 79, 214, 620, 603,
+ /* 1400 */ 1154,
+};
+static const YYCODETYPE yy_lookahead[] = {
+ /* 0 */ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ /* 10 */ 15, 16, 17, 18, 19, 20, 32, 22, 23, 24,
+ /* 20 */ 25, 26, 27, 28, 29, 30, 31, 32, 17, 18,
+ /* 30 */ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+ /* 40 */ 29, 30, 31, 32, 49, 9, 51, 17, 18, 19,
+ /* 50 */ 20, 133, 22, 23, 24, 25, 26, 27, 28, 29,
+ /* 60 */ 30, 31, 32, 26, 27, 28, 29, 30, 31, 32,
+ /* 70 */ 75, 28, 29, 30, 31, 32, 5, 6, 7, 8,
+ /* 80 */ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+ /* 90 */ 19, 20, 160, 22, 23, 24, 25, 26, 27, 28,
+ /* 100 */ 29, 30, 31, 32, 5, 6, 7, 8, 9, 10,
+ /* 110 */ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ /* 120 */ 84, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ /* 130 */ 31, 32, 143, 5, 6, 7, 8, 9, 10, 11,
+ /* 140 */ 12, 13, 14, 15, 16, 17, 18, 19, 20, 50,
+ /* 150 */ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ /* 160 */ 32, 9, 10, 11, 12, 151, 67, 48, 34, 50,
+ /* 170 */ 181, 37, 38, 39, 40, 41, 48, 160, 44, 108,
+ /* 180 */ 109, 160, 5, 6, 7, 8, 9, 10, 11, 12,
+ /* 190 */ 13, 14, 15, 16, 17, 18, 19, 20, 184, 22,
+ /* 200 */ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ /* 210 */ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ /* 220 */ 32, 217, 103, 104, 220, 48, 92, 26, 27, 38,
+ /* 230 */ 78, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ /* 240 */ 14, 15, 16, 17, 18, 19, 20, 143, 22, 23,
+ /* 250 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 125,
+ /* 260 */ 69, 167, 168, 139, 140, 131, 132, 133, 47, 145,
+ /* 270 */ 176, 147, 51, 52, 48, 151, 85, 86, 87, 173,
+ /* 280 */ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ /* 290 */ 15, 16, 17, 18, 19, 20, 69, 22, 23, 24,
+ /* 300 */ 25, 26, 27, 28, 29, 30, 31, 32, 184, 187,
+ /* 310 */ 143, 207, 85, 86, 87, 73, 115, 75, 117, 197,
+ /* 320 */ 78, 163, 143, 48, 133, 98, 99, 160, 161, 5,
+ /* 330 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ /* 340 */ 16, 17, 18, 19, 20, 143, 22, 23, 24, 25,
+ /* 350 */ 26, 27, 28, 29, 30, 31, 32, 115, 116, 117,
+ /* 360 */ 181, 76, 195, 196, 79, 80, 81, 169, 210, 211,
+ /* 370 */ 212, 201, 48, 136, 137, 138, 91, 175, 5, 6,
+ /* 380 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ /* 390 */ 17, 18, 19, 20, 77, 22, 23, 24, 25, 26,
+ /* 400 */ 27, 28, 29, 30, 31, 32, 5, 6, 7, 8,
+ /* 410 */ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+ /* 420 */ 19, 20, 169, 22, 23, 24, 25, 26, 27, 28,
+ /* 430 */ 29, 30, 31, 32, 5, 6, 7, 8, 9, 10,
+ /* 440 */ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ /* 450 */ 133, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ /* 460 */ 31, 32, 5, 6, 7, 8, 9, 10, 11, 12,
+ /* 470 */ 13, 14, 15, 16, 17, 18, 19, 20, 49, 22,
+ /* 480 */ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ /* 490 */ 98, 99, 210, 211, 212, 122, 6, 7, 8, 9,
+ /* 500 */ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ /* 510 */ 20, 169, 22, 23, 24, 25, 26, 27, 28, 29,
+ /* 520 */ 30, 31, 32, 122, 198, 133, 156, 157, 158, 5,
+ /* 530 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ /* 540 */ 16, 17, 18, 19, 20, 205, 22, 23, 24, 25,
+ /* 550 */ 26, 27, 28, 29, 30, 31, 32, 7, 8, 9,
+ /* 560 */ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ /* 570 */ 20, 7, 22, 23, 24, 25, 26, 27, 28, 29,
+ /* 580 */ 30, 31, 32, 143, 156, 157, 158, 1, 2, 143,
+ /* 590 */ 26, 27, 143, 51, 52, 198, 159, 33, 152, 143,
+ /* 600 */ 160, 161, 26, 27, 167, 7, 143, 210, 211, 212,
+ /* 610 */ 46, 47, 48, 157, 158, 51, 52, 171, 76, 173,
+ /* 620 */ 143, 79, 80, 81, 26, 27, 149, 51, 52, 152,
+ /* 630 */ 143, 33, 68, 91, 179, 195, 196, 73, 175, 75,
+ /* 640 */ 69, 48, 78, 50, 46, 47, 143, 160, 161, 51,
+ /* 650 */ 52, 75, 7, 77, 151, 7, 85, 86, 87, 151,
+ /* 660 */ 84, 174, 86, 160, 161, 28, 68, 103, 7, 143,
+ /* 670 */ 9, 73, 39, 75, 143, 219, 78, 32, 229, 115,
+ /* 680 */ 116, 117, 118, 119, 120, 47, 53, 184, 143, 51,
+ /* 690 */ 52, 115, 184, 117, 61, 62, 205, 133, 195, 196,
+ /* 700 */ 52, 103, 69, 151, 133, 160, 161, 199, 200, 7,
+ /* 710 */ 163, 151, 181, 115, 116, 117, 118, 119, 120, 51,
+ /* 720 */ 52, 76, 77, 78, 79, 80, 81, 82, 26, 27,
+ /* 730 */ 28, 133, 95, 207, 89, 33, 184, 100, 143, 223,
+ /* 740 */ 195, 196, 51, 7, 184, 84, 151, 143, 46, 47,
+ /* 750 */ 89, 31, 32, 51, 52, 160, 161, 210, 211, 212,
+ /* 760 */ 208, 36, 26, 27, 160, 161, 75, 143, 208, 33,
+ /* 770 */ 68, 103, 104, 221, 143, 73, 222, 75, 226, 184,
+ /* 780 */ 78, 198, 46, 47, 160, 161, 226, 51, 52, 143,
+ /* 790 */ 195, 160, 161, 98, 99, 143, 182, 183, 174, 195,
+ /* 800 */ 196, 85, 86, 87, 68, 103, 160, 161, 194, 73,
+ /* 810 */ 143, 75, 160, 161, 78, 90, 143, 115, 116, 117,
+ /* 820 */ 118, 119, 120, 51, 52, 143, 174, 143, 143, 51,
+ /* 830 */ 52, 178, 179, 160, 161, 143, 26, 27, 115, 103,
+ /* 840 */ 117, 195, 160, 161, 160, 161, 50, 7, 181, 157,
+ /* 850 */ 158, 115, 116, 117, 118, 119, 120, 47, 174, 185,
+ /* 860 */ 143, 51, 52, 182, 183, 59, 26, 27, 195, 43,
+ /* 870 */ 47, 65, 49, 33, 51, 194, 70, 160, 161, 83,
+ /* 880 */ 143, 103, 104, 73, 143, 75, 46, 47, 78, 208,
+ /* 890 */ 143, 51, 52, 50, 88, 43, 214, 143, 75, 143,
+ /* 900 */ 47, 160, 161, 143, 51, 52, 80, 39, 68, 51,
+ /* 910 */ 52, 219, 227, 73, 143, 75, 160, 161, 78, 93,
+ /* 920 */ 47, 53, 143, 143, 143, 115, 116, 117, 181, 61,
+ /* 930 */ 62, 160, 161, 143, 143, 181, 143, 178, 179, 160,
+ /* 940 */ 161, 160, 161, 103, 143, 93, 103, 104, 143, 151,
+ /* 950 */ 160, 161, 126, 160, 161, 115, 116, 117, 118, 119,
+ /* 960 */ 120, 160, 161, 143, 227, 160, 161, 56, 143, 58,
+ /* 970 */ 143, 143, 181, 143, 101, 64, 124, 143, 126, 143,
+ /* 980 */ 160, 161, 184, 154, 155, 143, 206, 160, 161, 143,
+ /* 990 */ 160, 161, 134, 143, 160, 161, 160, 161, 143, 143,
+ /* 1000 */ 143, 198, 160, 161, 143, 143, 160, 161, 143, 181,
+ /* 1010 */ 160, 161, 143, 143, 143, 160, 161, 160, 161, 143,
+ /* 1020 */ 143, 160, 161, 78, 28, 160, 161, 143, 143, 160,
+ /* 1030 */ 161, 160, 161, 143, 89, 143, 160, 161, 143, 151,
+ /* 1040 */ 143, 49, 143, 51, 160, 161, 143, 51, 52, 198,
+ /* 1050 */ 160, 161, 160, 161, 229, 160, 161, 160, 161, 160,
+ /* 1060 */ 161, 143, 206, 160, 161, 143, 181, 75, 143, 143,
+ /* 1070 */ 143, 143, 184, 143, 143, 143, 206, 143, 160, 161,
+ /* 1080 */ 143, 50, 160, 161, 143, 160, 161, 160, 161, 227,
+ /* 1090 */ 160, 161, 160, 161, 160, 161, 47, 160, 161, 47,
+ /* 1100 */ 51, 160, 161, 51, 52, 94, 183, 96, 97, 151,
+ /* 1110 */ 85, 86, 87, 154, 155, 151, 151, 194, 151, 199,
+ /* 1120 */ 200, 7, 108, 109, 75, 121, 50, 123, 95, 47,
+ /* 1130 */ 143, 49, 206, 100, 206, 48, 16, 50, 48, 48,
+ /* 1140 */ 50, 50, 184, 48, 113, 50, 77, 78, 184, 184,
+ /* 1150 */ 48, 184, 50, 48, 115, 50, 117, 51, 52, 48,
+ /* 1160 */ 48, 50, 50, 186, 51, 52, 52, 47, 189, 48,
+ /* 1170 */ 48, 50, 50, 143, 51, 52, 202, 143, 102, 143,
+ /* 1180 */ 143, 143, 202, 143, 228, 143, 189, 143, 228, 143,
+ /* 1190 */ 143, 143, 164, 143, 143, 172, 143, 143, 143, 143,
+ /* 1200 */ 168, 143, 202, 143, 163, 216, 163, 143, 163, 143,
+ /* 1210 */ 188, 143, 186, 146, 143, 143, 143, 143, 47, 209,
+ /* 1220 */ 5, 113, 45, 225, 189, 121, 128, 224, 45, 148,
+ /* 1230 */ 209, 148, 47, 148, 177, 84, 148, 63, 83, 180,
+ /* 1240 */ 162, 180, 180, 180, 165, 165, 162, 177, 162, 106,
+ /* 1250 */ 84, 47, 177, 121, 189, 162, 32, 165, 164, 170,
+ /* 1260 */ 112, 162, 162, 162, 107, 111, 170, 50, 110, 40,
+ /* 1270 */ 35, 4, 36, 3, 42, 72, 43, 141, 144, 144,
+ /* 1280 */ 150, 204, 142, 142, 165, 48, 142, 142, 48, 101,
+ /* 1290 */ 153, 165, 99, 114, 88, 153, 102, 84, 46, 127,
+ /* 1300 */ 203, 50, 127, 130, 166, 166, 84, 204, 1, 129,
+ /* 1310 */ 203, 102, 114, 204, 204, 16, 16, 189, 203, 203,
+ /* 1320 */ 193, 192, 191, 190, 16, 16, 88, 52, 105, 101,
+ /* 1330 */ 213, 1, 34, 215, 47, 124, 46, 84, 49, 7,
+ /* 1340 */ 82, 47, 218, 218, 89, 66, 66, 54, 47, 47,
+ /* 1350 */ 66, 48, 47, 47, 50, 60, 95, 101, 48, 48,
+ /* 1360 */ 48, 47, 105, 48, 47, 52, 50, 48, 48, 47,
+ /* 1370 */ 104, 50, 75, 105, 50, 48, 105, 48, 50, 48,
+ /* 1380 */ 38, 48, 48, 47, 49, 48, 47, 47, 50, 48,
+ /* 1390 */ 42, 47, 49, 48, 48, 48, 47, 101, 48, 1,
+ /* 1400 */ 0,
+};
+#define YY_SHIFT_USE_DFLT (1401)
+#define YY_SHIFT_COUNT (407)
+#define YY_SHIFT_MIN (-82)
+#define YY_SHIFT_MAX (1400)
+static const short yy_shift_ofst[] = {
+ /* 0 */ 586, 564, 598, 134, 736, 736, 736, 736, 571, -5,
+ /* 10 */ 71, 71, 736, 736, 736, 736, 736, 736, 736, 576,
+ /* 20 */ 576, 542, 227, 191, 392, 99, 128, 177, 226, 275,
+ /* 30 */ 324, 373, 401, 429, 457, 457, 457, 457, 457, 457,
+ /* 40 */ 457, 457, 457, 457, 457, 457, 457, 457, 457, 524,
+ /* 50 */ 457, 490, 550, 550, 702, 736, 736, 736, 736, 736,
+ /* 60 */ 736, 736, 736, 736, 736, 736, 736, 736, 736, 736,
+ /* 70 */ 736, 736, 736, 736, 736, 736, 736, 736, 736, 736,
+ /* 80 */ 736, 736, 840, 736, 736, 736, 736, 736, 736, 736,
+ /* 90 */ 736, 736, 736, 736, 736, 736, 11, 30, 30, 30,
+ /* 100 */ 30, 30, 188, 37, 43, 661, 201, 201, 720, 695,
+ /* 110 */ 772, -16, 1401, 1401, 1401, 645, 645, 633, 633, 826,
+ /* 120 */ 221, 221, 858, 772, 317, 772, 772, 772, 772, 772,
+ /* 130 */ 772, 772, 772, 772, 772, 772, 772, 772, 772, 772,
+ /* 140 */ 772, 691, 772, 772, 772, 691, 695, -82, -82, -82,
+ /* 150 */ -82, -82, -82, 1401, 1401, 810, 242, 242, 285, 806,
+ /* 160 */ 806, 806, 119, 823, 668, 778, 868, 716, 911, 638,
+ /* 170 */ 996, 992, 992, 992, 853, 843, 1052, 1011, 637, 772,
+ /* 180 */ 772, 772, 772, 1031, 648, 648, 772, 772, 1114, 1031,
+ /* 190 */ 772, 1114, 772, 772, 772, 772, 772, 772, 796, 772,
+ /* 200 */ 593, 772, 36, 772, 1014, 772, 772, 648, 772, 1004,
+ /* 210 */ 1014, 1014, 772, 772, 772, 1076, 1033, 772, 1082, 772,
+ /* 220 */ 772, 772, 772, 1171, 1215, 1108, 1177, 1177, 1177, 1177,
+ /* 230 */ 1104, 1098, 1183, 1108, 1171, 1215, 1215, 1183, 1185, 1183,
+ /* 240 */ 1183, 1185, 1151, 1151, 1151, 1174, 1185, 1151, 1155, 1151,
+ /* 250 */ 1174, 1151, 1151, 1143, 1166, 1143, 1166, 1143, 1166, 1143,
+ /* 260 */ 1166, 1204, 1132, 1185, 1224, 1224, 1185, 1148, 1157, 1154,
+ /* 270 */ 1158, 1108, 1217, 1229, 1229, 1235, 1235, 1235, 1235, 1236,
+ /* 280 */ 1401, 1401, 1401, 1401, 152, 852, 1025, 1049, 1120, 1087,
+ /* 290 */ 1090, 1091, 1095, 1102, 1105, 1106, 1069, 725, 945, 1111,
+ /* 300 */ 1112, 1113, 1121, 723, 1039, 1122, 1123, 873, 1267, 1270,
+ /* 310 */ 1232, 1203, 1233, 1237, 1240, 1188, 1193, 1179, 1206, 1194,
+ /* 320 */ 1213, 1252, 1172, 1251, 1175, 1173, 1180, 1222, 1307, 1209,
+ /* 330 */ 1198, 1299, 1300, 1308, 1309, 1238, 1275, 1223, 1228, 1330,
+ /* 340 */ 1298, 1287, 1253, 1211, 1289, 1290, 1332, 1255, 1258, 1294,
+ /* 350 */ 1279, 1301, 1302, 1303, 1305, 1280, 1293, 1306, 1284, 1295,
+ /* 360 */ 1310, 1311, 1312, 1304, 1261, 1314, 1315, 1317, 1316, 1256,
+ /* 370 */ 1319, 1320, 1313, 1257, 1322, 1266, 1321, 1268, 1324, 1271,
+ /* 380 */ 1327, 1321, 1329, 1331, 1333, 1297, 1328, 1334, 1336, 1342,
+ /* 390 */ 1337, 1339, 1335, 1338, 1341, 1340, 1343, 1338, 1345, 1344,
+ /* 400 */ 1346, 1347, 1349, 1296, 1350, 1348, 1398, 1400,
+};
+#define YY_REDUCE_USE_DFLT (-69)
+#define YY_REDUCE_COUNT (283)
+#define YY_REDUCE_MIN (-68)
+#define YY_REDUCE_MAX (1145)
+static const short yy_reduce_ofst[] = {
+ /* 0 */ 237, 503, 595, 124, 167, 440, 545, 604, 552, 397,
+ /* 10 */ 158, 547, 487, 624, 652, 646, 673, 684, 682, 456,
+ /* 20 */ 692, 446, 681, 560, 508, 282, 282, 282, 282, 282,
+ /* 30 */ 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
+ /* 40 */ 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
+ /* 50 */ 282, 282, 282, 282, 631, 717, 741, 756, 771, 779,
+ /* 60 */ 781, 790, 793, 801, 805, 820, 827, 830, 834, 836,
+ /* 70 */ 842, 846, 850, 855, 857, 861, 865, 869, 871, 876,
+ /* 80 */ 884, 890, 892, 895, 897, 899, 903, 918, 922, 925,
+ /* 90 */ 927, 930, 932, 934, 937, 941, 282, 282, 282, 282,
+ /* 100 */ 282, 282, 282, 282, 282, 94, 370, 428, 282, 614,
+ /* 110 */ 477, 282, 282, 282, 282, 437, 437, 653, 759, 4,
+ /* 120 */ 104, 526, 449, -11, 14, 179, 531, 667, 747, 754,
+ /* 130 */ 791, 828, 780, 885, 685, 856, 737, 870, 926, 862,
+ /* 140 */ 202, 829, 928, 825, 463, 959, 923, 798, 888, 958,
+ /* 150 */ 964, 965, 967, 920, 122, -68, 17, 21, 106, 198,
+ /* 160 */ 253, 342, 170, 326, 340, 491, 455, 516, 554, 760,
+ /* 170 */ 877, 583, 803, 851, 931, 170, 987, 674, 977, 1030,
+ /* 180 */ 1034, 1036, 1037, 979, 974, 980, 1038, 1040, 956, 997,
+ /* 190 */ 1042, 960, 1044, 1046, 1047, 1048, 1050, 1051, 1028, 1053,
+ /* 200 */ 1023, 1054, 1032, 1055, 1041, 1056, 1058, 1000, 1060, 989,
+ /* 210 */ 1043, 1045, 1064, 1066, 877, 1022, 1026, 1068, 1067, 1071,
+ /* 220 */ 1072, 1073, 1074, 1010, 1057, 1035, 1059, 1061, 1062, 1063,
+ /* 230 */ 998, 1003, 1081, 1065, 1021, 1070, 1075, 1083, 1079, 1085,
+ /* 240 */ 1088, 1080, 1078, 1084, 1086, 1089, 1092, 1093, 1094, 1099,
+ /* 250 */ 1096, 1100, 1101, 1077, 1097, 1103, 1107, 1109, 1115, 1110,
+ /* 260 */ 1116, 1117, 1118, 1119, 1124, 1125, 1126, 1127, 1129, 1131,
+ /* 270 */ 1133, 1128, 1130, 1134, 1135, 1140, 1141, 1144, 1145, 1136,
+ /* 280 */ 1137, 1138, 1139, 1142,
+};
+static const YYACTIONTYPE yy_default[] = {
+ /* 0 */ 1155, 1149, 1149, 1149, 1096, 1096, 1096, 1096, 1149, 992,
+ /* 10 */ 1019, 1019, 1197, 1197, 1197, 1197, 1197, 1197, 1095, 1197,
+ /* 20 */ 1197, 1197, 1197, 1149, 996, 1025, 1197, 1197, 1197, 1097,
+ /* 30 */ 1098, 1197, 1197, 1197, 1130, 1035, 1034, 1033, 1032, 1006,
+ /* 40 */ 1030, 1023, 1027, 1097, 1091, 1092, 1090, 1094, 1098, 1197,
+ /* 50 */ 1026, 1060, 1075, 1059, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 60 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 70 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 80 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 90 */ 1197, 1197, 1197, 1197, 1197, 1197, 1069, 1074, 1081, 1073,
+ /* 100 */ 1070, 1062, 1061, 1063, 1064, 963, 1197, 1197, 1065, 1197,
+ /* 110 */ 1197, 1066, 1078, 1077, 1076, 1164, 1163, 1197, 1197, 1103,
+ /* 120 */ 1197, 1197, 1197, 1197, 1149, 1197, 1197, 1197, 1197, 1197,
+ /* 130 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 140 */ 1197, 921, 1197, 1197, 1197, 921, 1197, 1149, 1149, 1149,
+ /* 150 */ 1149, 1149, 1149, 996, 987, 1197, 1197, 1197, 1197, 1197,
+ /* 160 */ 1197, 1197, 1197, 992, 1197, 1197, 1197, 1197, 1125, 1197,
+ /* 170 */ 1197, 992, 992, 992, 1197, 994, 1197, 976, 986, 1197,
+ /* 180 */ 1146, 1197, 1117, 1029, 1008, 1008, 1197, 1197, 1196, 1029,
+ /* 190 */ 1197, 1196, 1197, 1197, 1197, 1197, 1197, 1197, 938, 1197,
+ /* 200 */ 1175, 1197, 935, 1197, 1019, 1197, 1197, 1008, 1197, 1093,
+ /* 210 */ 1019, 1019, 1197, 1197, 1197, 993, 986, 1197, 1197, 1197,
+ /* 220 */ 1197, 1197, 1158, 1040, 966, 1029, 972, 972, 972, 972,
+ /* 230 */ 1129, 1193, 915, 1029, 1040, 966, 966, 915, 1104, 915,
+ /* 240 */ 915, 1104, 964, 964, 964, 953, 1104, 964, 938, 964,
+ /* 250 */ 953, 964, 964, 1012, 1007, 1012, 1007, 1012, 1007, 1012,
+ /* 260 */ 1007, 1099, 1197, 1104, 1108, 1108, 1104, 1024, 1013, 1022,
+ /* 270 */ 1020, 1029, 956, 1161, 1161, 1157, 1157, 1157, 1157, 905,
+ /* 280 */ 1170, 940, 940, 1170, 1197, 1197, 1197, 1165, 1111, 1197,
+ /* 290 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 300 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1046, 1197, 902,
+ /* 310 */ 1197, 1197, 1197, 1197, 1197, 1188, 1197, 1197, 1197, 1197,
+ /* 320 */ 1197, 1197, 1197, 1128, 1127, 1197, 1197, 1197, 1197, 1197,
+ /* 330 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1195, 1197,
+ /* 340 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 350 */ 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 360 */ 1197, 1197, 1197, 1197, 978, 1197, 1197, 1197, 1179, 1197,
+ /* 370 */ 1197, 1197, 1197, 1197, 1197, 1197, 1021, 1197, 1014, 1197,
+ /* 380 */ 1197, 1185, 1197, 1197, 1197, 1197, 1197, 1197, 1197, 1197,
+ /* 390 */ 1197, 1197, 1197, 1151, 1197, 1197, 1197, 1150, 1197, 1197,
+ /* 400 */ 1197, 1197, 1197, 1197, 1197, 909, 1197, 1197,
+};
+/********** End of lemon-generated parsing tables *****************************/
+
+/* The next table maps tokens (terminal symbols) into fallback tokens.
+** If a construct like the following:
+**
+** %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+**
+** This feature can be used, for example, to cause some keywords in a language
+** to revert to identifiers if they keyword does not apply in the context where
+** it appears.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+ 0, /* $ => nothing */
+ 0, /* SEMI => nothing */
+ 0, /* EXPLAIN => nothing */
+ 51, /* QUERY => ID */
+ 51, /* PLAN => ID */
+ 0, /* OR => nothing */
+ 0, /* AND => nothing */
+ 0, /* NOT => nothing */
+ 0, /* IS => nothing */
+ 51, /* MATCH => ID */
+ 0, /* LIKE_KW => nothing */
+ 0, /* BETWEEN => nothing */
+ 0, /* IN => nothing */
+ 51, /* ISNULL => ID */
+ 51, /* NOTNULL => ID */
+ 0, /* NE => nothing */
+ 0, /* EQ => nothing */
+ 0, /* GT => nothing */
+ 0, /* LE => nothing */
+ 0, /* LT => nothing */
+ 0, /* GE => nothing */
+ 0, /* ESCAPE => nothing */
+ 0, /* BITAND => nothing */
+ 0, /* BITOR => nothing */
+ 0, /* LSHIFT => nothing */
+ 0, /* RSHIFT => nothing */
+ 0, /* PLUS => nothing */
+ 0, /* MINUS => nothing */
+ 0, /* STAR => nothing */
+ 0, /* SLASH => nothing */
+ 0, /* REM => nothing */
+ 0, /* CONCAT => nothing */
+ 0, /* COLLATE => nothing */
+ 0, /* BITNOT => nothing */
+ 0, /* BEGIN => nothing */
+ 0, /* TRANSACTION => nothing */
+ 51, /* DEFERRED => ID */
+ 0, /* COMMIT => nothing */
+ 51, /* END => ID */
+ 0, /* ROLLBACK => nothing */
+ 0, /* SAVEPOINT => nothing */
+ 51, /* RELEASE => ID */
+ 0, /* TO => nothing */
+ 0, /* TABLE => nothing */
+ 0, /* CREATE => nothing */
+ 51, /* IF => ID */
+ 0, /* EXISTS => nothing */
+ 0, /* LP => nothing */
+ 0, /* RP => nothing */
+ 0, /* AS => nothing */
+ 0, /* COMMA => nothing */
+ 0, /* ID => nothing */
+ 0, /* INDEXED => nothing */
+ 51, /* ABORT => ID */
+ 51, /* ACTION => ID */
+ 51, /* ADD => ID */
+ 51, /* AFTER => ID */
+ 51, /* AUTOINCREMENT => ID */
+ 51, /* BEFORE => ID */
+ 51, /* CASCADE => ID */
+ 51, /* CONFLICT => ID */
+ 51, /* FAIL => ID */
+ 51, /* IGNORE => ID */
+ 51, /* INITIALLY => ID */
+ 51, /* INSTEAD => ID */
+ 51, /* NO => ID */
+ 51, /* KEY => ID */
+ 51, /* OFFSET => ID */
+ 51, /* RAISE => ID */
+ 51, /* REPLACE => ID */
+ 51, /* RESTRICT => ID */
+ 51, /* REINDEX => ID */
+ 51, /* RENAME => ID */
+ 51, /* CTIME_KW => ID */
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack. Information stored includes:
+**
+** + The state number for the parser at this level of the stack.
+**
+** + The value of the token stored at this level of the stack.
+** (In other words, the "major" token.)
+**
+** + The semantic value stored at this level of the stack. This is
+** the information used by the action routines in the grammar.
+** It is sometimes called the "minor" token.
+**
+** After the "shift" half of a SHIFTREDUCE action, the stateno field
+** actually contains the reduce action for the second half of the
+** SHIFTREDUCE.
+*/
+struct yyStackEntry {
+ YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */
+ YYCODETYPE major; /* The major token value. This is the code
+ ** number for the token at this stack level */
+ YYMINORTYPE minor; /* The user-supplied minor token value. This
+ ** is the value of the token */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+ yyStackEntry *yytos; /* Pointer to top element of the stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+ int yyhwm; /* High-water mark of the stack */
+#endif
+#ifndef YYNOERRORRECOVERY
+ int yyerrcnt; /* Shifts left before out of the error */
+#endif
+ bool is_fallback_failed; /* Shows if fallback failed or not */
+ sqlite3ParserARG_SDECL /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+ int yystksz; /* Current side of the stack */
+ yyStackEntry *yystack; /* The parser's stack */
+ yyStackEntry yystk0; /* First stack entry */
+#else
+ yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message. Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+** If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+** line of trace output. If NULL, then tracing is
+** turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
+ yyTraceFILE = TraceFILE;
+ yyTracePrompt = zTracePrompt;
+ if( yyTraceFILE==0 ) yyTracePrompt = 0;
+ else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required. The following table supplies these names */
+static const char *const yyTokenName[] = {
+ "$", "SEMI", "EXPLAIN", "QUERY",
+ "PLAN", "OR", "AND", "NOT",
+ "IS", "MATCH", "LIKE_KW", "BETWEEN",
+ "IN", "ISNULL", "NOTNULL", "NE",
+ "EQ", "GT", "LE", "LT",
+ "GE", "ESCAPE", "BITAND", "BITOR",
+ "LSHIFT", "RSHIFT", "PLUS", "MINUS",
+ "STAR", "SLASH", "REM", "CONCAT",
+ "COLLATE", "BITNOT", "BEGIN", "TRANSACTION",
+ "DEFERRED", "COMMIT", "END", "ROLLBACK",
+ "SAVEPOINT", "RELEASE", "TO", "TABLE",
+ "CREATE", "IF", "EXISTS", "LP",
+ "RP", "AS", "COMMA", "ID",
+ "INDEXED", "ABORT", "ACTION", "ADD",
+ "AFTER", "AUTOINCREMENT", "BEFORE", "CASCADE",
+ "CONFLICT", "FAIL", "IGNORE", "INITIALLY",
+ "INSTEAD", "NO", "KEY", "OFFSET",
+ "RAISE", "REPLACE", "RESTRICT", "REINDEX",
+ "RENAME", "CTIME_KW", "ANY", "STRING",
+ "CONSTRAINT", "DEFAULT", "NULL", "PRIMARY",
+ "UNIQUE", "CHECK", "REFERENCES", "AUTOINCR",
+ "ON", "INSERT", "DELETE", "UPDATE",
+ "SET", "DEFERRABLE", "IMMEDIATE", "FOREIGN",
+ "DROP", "VIEW", "UNION", "ALL",
+ "EXCEPT", "INTERSECT", "SELECT", "VALUES",
+ "DISTINCT", "DOT", "FROM", "JOIN_KW",
+ "JOIN", "BY", "USING", "ORDER",
+ "ASC", "DESC", "GROUP", "HAVING",
+ "LIMIT", "WHERE", "INTO", "FLOAT",
+ "BLOB", "INTEGER", "VARIABLE", "CAST",
+ "CASE", "WHEN", "THEN", "ELSE",
+ "INDEX", "PRAGMA", "TRIGGER", "OF",
+ "FOR", "EACH", "ROW", "ANALYZE",
+ "ALTER", "WITH", "RECURSIVE", "error",
+ "input", "ecmd", "explain", "cmdx",
+ "cmd", "transtype", "trans_opt", "nm",
+ "savepoint_opt", "create_table", "create_table_args", "createkw",
+ "ifnotexists", "columnlist", "conslist_opt", "select",
+ "columnname", "carglist", "typetoken", "typename",
+ "signed", "plus_num", "minus_num", "ccons",
+ "term", "expr", "onconf", "sortorder",
+ "autoinc", "eidlist_opt", "refargs", "defer_subclause",
+ "refarg", "refact", "init_deferred_pred_opt", "conslist",
+ "tconscomma", "tcons", "sortlist", "eidlist",
+ "defer_subclause_opt", "orconf", "resolvetype", "raisetype",
+ "ifexists", "fullname", "selectnowith", "oneselect",
+ "with", "multiselect_op", "distinct", "selcollist",
+ "from", "where_opt", "groupby_opt", "having_opt",
+ "orderby_opt", "limit_opt", "values", "nexprlist",
+ "exprlist", "sclp", "as", "seltablist",
+ "stl_prefix", "joinop", "indexed_opt", "on_opt",
+ "using_opt", "join_nm", "idlist", "setlist",
+ "insert_cmd", "idlist_opt", "likeop", "between_op",
+ "in_op", "paren_exprlist", "case_operand", "case_exprlist",
+ "case_else", "uniqueflag", "collate", "nmnum",
+ "trigger_decl", "trigger_cmd_list", "trigger_time", "trigger_event",
+ "foreach_clause", "when_clause", "trigger_cmd", "trnm",
+ "tridxby", "wqlist",
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+ /* 0 */ "ecmd ::= explain cmdx SEMI",
+ /* 1 */ "ecmd ::= SEMI",
+ /* 2 */ "explain ::= EXPLAIN",
+ /* 3 */ "explain ::= EXPLAIN QUERY PLAN",
+ /* 4 */ "cmd ::= BEGIN transtype trans_opt",
+ /* 5 */ "transtype ::=",
+ /* 6 */ "transtype ::= DEFERRED",
+ /* 7 */ "cmd ::= COMMIT trans_opt",
+ /* 8 */ "cmd ::= END trans_opt",
+ /* 9 */ "cmd ::= ROLLBACK trans_opt",
+ /* 10 */ "cmd ::= SAVEPOINT nm",
+ /* 11 */ "cmd ::= RELEASE savepoint_opt nm",
+ /* 12 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm",
+ /* 13 */ "create_table ::= createkw TABLE ifnotexists nm",
+ /* 14 */ "createkw ::= CREATE",
+ /* 15 */ "ifnotexists ::=",
+ /* 16 */ "ifnotexists ::= IF NOT EXISTS",
+ /* 17 */ "create_table_args ::= LP columnlist conslist_opt RP",
+ /* 18 */ "create_table_args ::= AS select",
+ /* 19 */ "columnname ::= nm typetoken",
+ /* 20 */ "nm ::= ID|INDEXED",
+ /* 21 */ "typetoken ::=",
+ /* 22 */ "typetoken ::= typename LP signed RP",
+ /* 23 */ "typetoken ::= typename LP signed COMMA signed RP",
+ /* 24 */ "typename ::= typename ID|STRING",
+ /* 25 */ "ccons ::= CONSTRAINT nm",
+ /* 26 */ "ccons ::= DEFAULT term",
+ /* 27 */ "ccons ::= DEFAULT LP expr RP",
+ /* 28 */ "ccons ::= DEFAULT PLUS term",
+ /* 29 */ "ccons ::= DEFAULT MINUS term",
+ /* 30 */ "ccons ::= DEFAULT ID|INDEXED",
+ /* 31 */ "ccons ::= NOT NULL onconf",
+ /* 32 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
+ /* 33 */ "ccons ::= UNIQUE onconf",
+ /* 34 */ "ccons ::= CHECK LP expr RP",
+ /* 35 */ "ccons ::= REFERENCES nm eidlist_opt refargs",
+ /* 36 */ "ccons ::= defer_subclause",
+ /* 37 */ "ccons ::= COLLATE ID|INDEXED",
+ /* 38 */ "autoinc ::=",
+ /* 39 */ "autoinc ::= AUTOINCR",
+ /* 40 */ "refargs ::=",
+ /* 41 */ "refargs ::= refargs refarg",
+ /* 42 */ "refarg ::= MATCH nm",
+ /* 43 */ "refarg ::= ON INSERT refact",
+ /* 44 */ "refarg ::= ON DELETE refact",
+ /* 45 */ "refarg ::= ON UPDATE refact",
+ /* 46 */ "refact ::= SET NULL",
+ /* 47 */ "refact ::= SET DEFAULT",
+ /* 48 */ "refact ::= CASCADE",
+ /* 49 */ "refact ::= RESTRICT",
+ /* 50 */ "refact ::= NO ACTION",
+ /* 51 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
+ /* 52 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
+ /* 53 */ "init_deferred_pred_opt ::=",
+ /* 54 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
+ /* 55 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
+ /* 56 */ "conslist_opt ::=",
+ /* 57 */ "tconscomma ::= COMMA",
+ /* 58 */ "tcons ::= CONSTRAINT nm",
+ /* 59 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf",
+ /* 60 */ "tcons ::= UNIQUE LP sortlist RP onconf",
+ /* 61 */ "tcons ::= CHECK LP expr RP onconf",
+ /* 62 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt",
+ /* 63 */ "defer_subclause_opt ::=",
+ /* 64 */ "onconf ::=",
+ /* 65 */ "onconf ::= ON CONFLICT resolvetype",
+ /* 66 */ "orconf ::=",
+ /* 67 */ "orconf ::= OR resolvetype",
+ /* 68 */ "resolvetype ::= IGNORE",
+ /* 69 */ "resolvetype ::= REPLACE",
+ /* 70 */ "cmd ::= DROP TABLE ifexists fullname",
+ /* 71 */ "ifexists ::= IF EXISTS",
+ /* 72 */ "ifexists ::=",
+ /* 73 */ "cmd ::= createkw VIEW ifnotexists nm eidlist_opt AS select",
+ /* 74 */ "cmd ::= DROP VIEW ifexists fullname",
+ /* 75 */ "cmd ::= select",
+ /* 76 */ "select ::= with selectnowith",
+ /* 77 */ "selectnowith ::= selectnowith multiselect_op oneselect",
+ /* 78 */ "multiselect_op ::= UNION",
+ /* 79 */ "multiselect_op ::= UNION ALL",
+ /* 80 */ "multiselect_op ::= EXCEPT|INTERSECT",
+ /* 81 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
+ /* 82 */ "values ::= VALUES LP nexprlist RP",
+ /* 83 */ "values ::= values COMMA LP exprlist RP",
+ /* 84 */ "distinct ::= DISTINCT",
+ /* 85 */ "distinct ::= ALL",
+ /* 86 */ "distinct ::=",
+ /* 87 */ "sclp ::=",
+ /* 88 */ "selcollist ::= sclp expr as",
+ /* 89 */ "selcollist ::= sclp STAR",
+ /* 90 */ "selcollist ::= sclp nm DOT STAR",
+ /* 91 */ "as ::= AS nm",
+ /* 92 */ "as ::=",
+ /* 93 */ "from ::=",
+ /* 94 */ "from ::= FROM seltablist",
+ /* 95 */ "stl_prefix ::= seltablist joinop",
+ /* 96 */ "stl_prefix ::=",
+ /* 97 */ "seltablist ::= stl_prefix nm as indexed_opt on_opt using_opt",
+ /* 98 */ "seltablist ::= stl_prefix nm LP exprlist RP as on_opt using_opt",
+ /* 99 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
+ /* 100 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
+ /* 101 */ "fullname ::= nm",
+ /* 102 */ "joinop ::= COMMA|JOIN",
+ /* 103 */ "joinop ::= JOIN_KW JOIN",
+ /* 104 */ "joinop ::= JOIN_KW join_nm JOIN",
+ /* 105 */ "joinop ::= JOIN_KW join_nm join_nm JOIN",
+ /* 106 */ "on_opt ::= ON expr",
+ /* 107 */ "on_opt ::=",
+ /* 108 */ "indexed_opt ::=",
+ /* 109 */ "indexed_opt ::= INDEXED BY nm",
+ /* 110 */ "indexed_opt ::= NOT INDEXED",
+ /* 111 */ "using_opt ::= USING LP idlist RP",
+ /* 112 */ "using_opt ::=",
+ /* 113 */ "orderby_opt ::=",
+ /* 114 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 115 */ "sortlist ::= sortlist COMMA expr sortorder",
+ /* 116 */ "sortlist ::= expr sortorder",
+ /* 117 */ "sortorder ::= ASC",
+ /* 118 */ "sortorder ::= DESC",
+ /* 119 */ "sortorder ::=",
+ /* 120 */ "groupby_opt ::=",
+ /* 121 */ "groupby_opt ::= GROUP BY nexprlist",
+ /* 122 */ "having_opt ::=",
+ /* 123 */ "having_opt ::= HAVING expr",
+ /* 124 */ "limit_opt ::=",
+ /* 125 */ "limit_opt ::= LIMIT expr",
+ /* 126 */ "limit_opt ::= LIMIT expr OFFSET expr",
+ /* 127 */ "limit_opt ::= LIMIT expr COMMA expr",
+ /* 128 */ "cmd ::= with DELETE FROM fullname indexed_opt where_opt",
+ /* 129 */ "where_opt ::=",
+ /* 130 */ "where_opt ::= WHERE expr",
+ /* 131 */ "cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt",
+ /* 132 */ "setlist ::= setlist COMMA nm EQ expr",
+ /* 133 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
+ /* 134 */ "setlist ::= nm EQ expr",
+ /* 135 */ "setlist ::= LP idlist RP EQ expr",
+ /* 136 */ "cmd ::= with insert_cmd INTO fullname idlist_opt select",
+ /* 137 */ "cmd ::= with insert_cmd INTO fullname idlist_opt DEFAULT VALUES",
+ /* 138 */ "insert_cmd ::= INSERT orconf",
+ /* 139 */ "insert_cmd ::= REPLACE",
+ /* 140 */ "idlist_opt ::=",
+ /* 141 */ "idlist_opt ::= LP idlist RP",
+ /* 142 */ "idlist ::= idlist COMMA nm",
+ /* 143 */ "idlist ::= nm",
+ /* 144 */ "expr ::= LP expr RP",
+ /* 145 */ "term ::= NULL",
+ /* 146 */ "expr ::= ID|INDEXED",
+ /* 147 */ "expr ::= JOIN_KW",
+ /* 148 */ "expr ::= nm DOT nm",
+ /* 149 */ "term ::= FLOAT|BLOB",
+ /* 150 */ "term ::= STRING",
+ /* 151 */ "term ::= INTEGER",
+ /* 152 */ "expr ::= VARIABLE",
+ /* 153 */ "expr ::= expr COLLATE ID|INDEXED",
+ /* 154 */ "expr ::= CAST LP expr AS typetoken RP",
+ /* 155 */ "expr ::= ID|INDEXED LP distinct exprlist RP",
+ /* 156 */ "expr ::= ID|INDEXED LP STAR RP",
+ /* 157 */ "term ::= CTIME_KW",
+ /* 158 */ "expr ::= LP nexprlist COMMA expr RP",
+ /* 159 */ "expr ::= expr AND expr",
+ /* 160 */ "expr ::= expr OR expr",
+ /* 161 */ "expr ::= expr LT|GT|GE|LE expr",
+ /* 162 */ "expr ::= expr EQ|NE expr",
+ /* 163 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
+ /* 164 */ "expr ::= expr PLUS|MINUS expr",
+ /* 165 */ "expr ::= expr STAR|SLASH|REM expr",
+ /* 166 */ "expr ::= expr CONCAT expr",
+ /* 167 */ "likeop ::= LIKE_KW|MATCH",
+ /* 168 */ "likeop ::= NOT LIKE_KW|MATCH",
+ /* 169 */ "expr ::= expr likeop expr",
+ /* 170 */ "expr ::= expr likeop expr ESCAPE expr",
+ /* 171 */ "expr ::= expr ISNULL|NOTNULL",
+ /* 172 */ "expr ::= expr NOT NULL",
+ /* 173 */ "expr ::= expr IS expr",
+ /* 174 */ "expr ::= expr IS NOT expr",
+ /* 175 */ "expr ::= NOT expr",
+ /* 176 */ "expr ::= BITNOT expr",
+ /* 177 */ "expr ::= MINUS expr",
+ /* 178 */ "expr ::= PLUS expr",
+ /* 179 */ "between_op ::= BETWEEN",
+ /* 180 */ "between_op ::= NOT BETWEEN",
+ /* 181 */ "expr ::= expr between_op expr AND expr",
+ /* 182 */ "in_op ::= IN",
+ /* 183 */ "in_op ::= NOT IN",
+ /* 184 */ "expr ::= expr in_op LP exprlist RP",
+ /* 185 */ "expr ::= LP select RP",
+ /* 186 */ "expr ::= expr in_op LP select RP",
+ /* 187 */ "expr ::= expr in_op nm paren_exprlist",
+ /* 188 */ "expr ::= EXISTS LP select RP",
+ /* 189 */ "expr ::= CASE case_operand case_exprlist case_else END",
+ /* 190 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
+ /* 191 */ "case_exprlist ::= WHEN expr THEN expr",
+ /* 192 */ "case_else ::= ELSE expr",
+ /* 193 */ "case_else ::=",
+ /* 194 */ "case_operand ::= expr",
+ /* 195 */ "case_operand ::=",
+ /* 196 */ "exprlist ::=",
+ /* 197 */ "nexprlist ::= nexprlist COMMA expr",
+ /* 198 */ "nexprlist ::= expr",
+ /* 199 */ "paren_exprlist ::=",
+ /* 200 */ "paren_exprlist ::= LP exprlist RP",
+ /* 201 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm ON nm LP sortlist RP",
+ /* 202 */ "uniqueflag ::= UNIQUE",
+ /* 203 */ "uniqueflag ::=",
+ /* 204 */ "eidlist_opt ::=",
+ /* 205 */ "eidlist_opt ::= LP eidlist RP",
+ /* 206 */ "eidlist ::= eidlist COMMA nm collate sortorder",
+ /* 207 */ "eidlist ::= nm collate sortorder",
+ /* 208 */ "collate ::=",
+ /* 209 */ "collate ::= COLLATE ID|INDEXED",
+ /* 210 */ "cmd ::= DROP INDEX ifexists fullname ON nm",
+ /* 211 */ "cmd ::= PRAGMA nm",
+ /* 212 */ "cmd ::= PRAGMA nm EQ nmnum",
+ /* 213 */ "cmd ::= PRAGMA nm LP nmnum RP",
+ /* 214 */ "cmd ::= PRAGMA nm EQ minus_num",
+ /* 215 */ "cmd ::= PRAGMA nm LP minus_num RP",
+ /* 216 */ "cmd ::= PRAGMA nm EQ nm DOT nm",
+ /* 217 */ "cmd ::= PRAGMA",
+ /* 218 */ "plus_num ::= PLUS INTEGER|FLOAT",
+ /* 219 */ "minus_num ::= MINUS INTEGER|FLOAT",
+ /* 220 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
+ /* 221 */ "trigger_decl ::= TRIGGER ifnotexists nm trigger_time trigger_event ON fullname foreach_clause when_clause",
+ /* 222 */ "trigger_time ::= BEFORE",
+ /* 223 */ "trigger_time ::= AFTER",
+ /* 224 */ "trigger_time ::= INSTEAD OF",
+ /* 225 */ "trigger_time ::=",
+ /* 226 */ "trigger_event ::= DELETE|INSERT",
+ /* 227 */ "trigger_event ::= UPDATE",
+ /* 228 */ "trigger_event ::= UPDATE OF idlist",
+ /* 229 */ "when_clause ::=",
+ /* 230 */ "when_clause ::= WHEN expr",
+ /* 231 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
+ /* 232 */ "trigger_cmd_list ::= trigger_cmd SEMI",
+ /* 233 */ "trnm ::= nm DOT nm",
+ /* 234 */ "tridxby ::= INDEXED BY nm",
+ /* 235 */ "tridxby ::= NOT INDEXED",
+ /* 236 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
+ /* 237 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select",
+ /* 238 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
+ /* 239 */ "trigger_cmd ::= select",
+ /* 240 */ "expr ::= RAISE LP IGNORE RP",
+ /* 241 */ "expr ::= RAISE LP raisetype COMMA STRING RP",
+ /* 242 */ "raisetype ::= ROLLBACK",
+ /* 243 */ "raisetype ::= ABORT",
+ /* 244 */ "raisetype ::= FAIL",
+ /* 245 */ "cmd ::= DROP TRIGGER ifexists fullname",
+ /* 246 */ "cmd ::= ANALYZE",
+ /* 247 */ "cmd ::= ANALYZE nm",
+ /* 248 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
+ /* 249 */ "with ::=",
+ /* 250 */ "with ::= WITH wqlist",
+ /* 251 */ "with ::= WITH RECURSIVE wqlist",
+ /* 252 */ "wqlist ::= nm eidlist_opt AS LP select RP",
+ /* 253 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
+ /* 254 */ "input ::= ecmd",
+ /* 255 */ "explain ::=",
+ /* 256 */ "cmdx ::= cmd",
+ /* 257 */ "trans_opt ::=",
+ /* 258 */ "trans_opt ::= TRANSACTION",
+ /* 259 */ "trans_opt ::= TRANSACTION nm",
+ /* 260 */ "savepoint_opt ::= SAVEPOINT",
+ /* 261 */ "savepoint_opt ::=",
+ /* 262 */ "cmd ::= create_table create_table_args",
+ /* 263 */ "columnlist ::= columnlist COMMA columnname carglist",
+ /* 264 */ "columnlist ::= columnname carglist",
+ /* 265 */ "typetoken ::= typename",
+ /* 266 */ "typename ::= ID|STRING",
+ /* 267 */ "signed ::= plus_num",
+ /* 268 */ "signed ::= minus_num",
+ /* 269 */ "carglist ::= carglist ccons",
+ /* 270 */ "carglist ::=",
+ /* 271 */ "ccons ::= NULL onconf",
+ /* 272 */ "conslist_opt ::= COMMA conslist",
+ /* 273 */ "conslist ::= conslist tconscomma tcons",
+ /* 274 */ "conslist ::= tcons",
+ /* 275 */ "tconscomma ::=",
+ /* 276 */ "defer_subclause_opt ::= defer_subclause",
+ /* 277 */ "resolvetype ::= raisetype",
+ /* 278 */ "selectnowith ::= oneselect",
+ /* 279 */ "oneselect ::= values",
+ /* 280 */ "sclp ::= selcollist COMMA",
+ /* 281 */ "as ::= ID|STRING",
+ /* 282 */ "join_nm ::= ID|INDEXED",
+ /* 283 */ "join_nm ::= JOIN_KW",
+ /* 284 */ "expr ::= term",
+ /* 285 */ "exprlist ::= nexprlist",
+ /* 286 */ "nmnum ::= plus_num",
+ /* 287 */ "nmnum ::= STRING",
+ /* 288 */ "nmnum ::= nm",
+ /* 289 */ "nmnum ::= ON",
+ /* 290 */ "nmnum ::= DELETE",
+ /* 291 */ "nmnum ::= DEFAULT",
+ /* 292 */ "plus_num ::= INTEGER|FLOAT",
+ /* 293 */ "foreach_clause ::=",
+ /* 294 */ "foreach_clause ::= FOR EACH ROW",
+ /* 295 */ "trnm ::= nm",
+ /* 296 */ "tridxby ::=",
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack. Return the number
+** of errors. Return 0 on success.
+*/
+static int yyGrowStack(yyParser *p){
+ int newSize;
+ int idx;
+ yyStackEntry *pNew;
+
+ newSize = p->yystksz*2 + 100;
+ idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;
+ if( p->yystack==&p->yystk0 ){
+ pNew = malloc(newSize*sizeof(pNew[0]));
+ if( pNew ) pNew[0] = p->yystk0;
+ }else{
+ pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+ }
+ if( pNew ){
+ p->yystack = pNew;
+ p->yytos = &p->yystack[idx];
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
+ yyTracePrompt, p->yystksz, newSize);
+ }
+#endif
+ p->yystksz = newSize;
+ }
+ return pNew==0;
+}
+#endif
+
+/* Datatype of the argument to the memory allocated passed as the
+** second argument to sqlite3ParserAlloc() below. This can be changed by
+** putting an appropriate #define in the %include section of the input
+** grammar.
+*/
+#ifndef YYMALLOCARGTYPE
+# define YYMALLOCARGTYPE size_t
+#endif
+
+/*
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser. This pointer is used in subsequent calls
+** to sqlite3Parser and sqlite3ParserFree.
+*/
+void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
+ yyParser *pParser;
+ pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+ if( pParser ){
+#ifdef YYTRACKMAXSTACKDEPTH
+ pParser->yyhwm = 0;
+ pParser->is_fallback_failed = false;
+#endif
+#if YYSTACKDEPTH<=0
+ pParser->yytos = NULL;
+ pParser->yystack = NULL;
+ pParser->yystksz = 0;
+ if( yyGrowStack(pParser) ){
+ pParser->yystack = &pParser->yystk0;
+ pParser->yystksz = 1;
+ }
+#endif
+#ifndef YYNOERRORRECOVERY
+ pParser->yyerrcnt = -1;
+#endif
+ pParser->yytos = pParser->yystack;
+ pParser->yystack[0].stateno = 0;
+ pParser->yystack[0].major = 0;
+ }
+ return pParser;
+}
+
+/* The following function deletes the "minor type" or semantic value
+** associated with a symbol. The symbol can be either a terminal
+** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+** a pointer to the value to be deleted. The code used to do the
+** deletions is derived from the %destructor and/or %token_destructor
+** directives of the input grammar.
+*/
+static void yy_destructor(
+ yyParser *yypParser, /* The parser */
+ YYCODETYPE yymajor, /* Type code for object to destroy */
+ YYMINORTYPE *yypminor /* The object to be destroyed */
+){
+ sqlite3ParserARG_FETCH;
+ switch( yymajor ){
+ /* Here is inserted the actions which take place when a
+ ** terminal or non-terminal is destroyed. This can happen
+ ** when the symbol is popped from the stack during a
+ ** reduce or during error processing or when a parser is
+ ** being destroyed before it is finished parsing.
+ **
+ ** Note: during a reduce, the only symbols destroyed are those
+ ** which appear on the RHS of the rule, but which are *not* used
+ ** inside the C code.
+ */
+/********* Begin destructor definitions ***************************************/
+ case 151: /* select */
+ case 182: /* selectnowith */
+ case 183: /* oneselect */
+ case 194: /* values */
+{
+#line 397 "parse.y"
+sqlite3SelectDelete(pParse->db, (yypminor->yy279));
+#line 1469 "parse.c"
+}
+ break;
+ case 160: /* term */
+ case 161: /* expr */
+{
+#line 838 "parse.y"
+sql_expr_free(pParse->db, (yypminor->yy162).pExpr, false);
+#line 1477 "parse.c"
+}
+ break;
+ case 165: /* eidlist_opt */
+ case 174: /* sortlist */
+ case 175: /* eidlist */
+ case 187: /* selcollist */
+ case 190: /* groupby_opt */
+ case 192: /* orderby_opt */
+ case 195: /* nexprlist */
+ case 196: /* exprlist */
+ case 197: /* sclp */
+ case 207: /* setlist */
+ case 213: /* paren_exprlist */
+ case 215: /* case_exprlist */
+{
+#line 1266 "parse.y"
+sqlite3ExprListDelete(pParse->db, (yypminor->yy382));
+#line 1495 "parse.c"
+}
+ break;
+ case 181: /* fullname */
+ case 188: /* from */
+ case 199: /* seltablist */
+ case 200: /* stl_prefix */
+{
+#line 622 "parse.y"
+sqlite3SrcListDelete(pParse->db, (yypminor->yy387));
+#line 1505 "parse.c"
+}
+ break;
+ case 184: /* with */
+ case 229: /* wqlist */
+{
+#line 1517 "parse.y"
+sqlite3WithDelete(pParse->db, (yypminor->yy151));
+#line 1513 "parse.c"
+}
+ break;
+ case 189: /* where_opt */
+ case 191: /* having_opt */
+ case 203: /* on_opt */
+ case 214: /* case_operand */
+ case 216: /* case_else */
+ case 225: /* when_clause */
+{
+#line 747 "parse.y"
+sql_expr_free(pParse->db, (yypminor->yy362), false);
+#line 1525 "parse.c"
+}
+ break;
+ case 204: /* using_opt */
+ case 206: /* idlist */
+ case 209: /* idlist_opt */
+{
+#line 659 "parse.y"
+sqlite3IdListDelete(pParse->db, (yypminor->yy40));
+#line 1534 "parse.c"
+}
+ break;
+ case 221: /* trigger_cmd_list */
+ case 226: /* trigger_cmd */
+{
+#line 1390 "parse.y"
+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
+#line 1542 "parse.c"
+}
+ break;
+ case 223: /* trigger_event */
+{
+#line 1376 "parse.y"
+sqlite3IdListDelete(pParse->db, (yypminor->yy10).b);
+#line 1549 "parse.c"
+}
+ break;
+/********* End destructor definitions *****************************************/
+ default: break; /* If no destructor action specified: do nothing */
+ }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+*/
+static void yy_pop_parser_stack(yyParser *pParser){
+ yyStackEntry *yytos;
+ assert( pParser->yytos!=0 );
+ assert( pParser->yytos > pParser->yystack );
+ yytos = pParser->yytos--;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sPopping %s\n",
+ yyTracePrompt,
+ yyTokenName[yytos->major]);
+ }
+#endif
+ yy_destructor(pParser, yytos->major, &yytos->minor);
+}
+
+/*
+** Deallocate and destroy a parser. Destructors are called for
+** all stack elements before shutting the parser down.
+**
+** If the YYPARSEFREENEVERNULL macro exists (for example because it
+** is defined in a %include section of the input grammar) then it is
+** assumed that the input pointer is never NULL.
+*/
+void sqlite3ParserFree(
+ void *p, /* The parser to be deleted */
+ void (*freeProc)(void*) /* Function used to reclaim memory */
+){
+ yyParser *pParser = (yyParser*)p;
+#ifndef YYPARSEFREENEVERNULL
+ if( pParser==0 ) return;
+#endif
+ while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+ if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
+#endif
+ (*freeProc)((void*)pParser);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int sqlite3ParserStackPeak(void *p){
+ yyParser *pParser = (yyParser*)p;
+ return pParser->yyhwm;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+*/
+static unsigned int yy_find_shift_action(
+ yyParser *pParser, /* The parser */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+ int stateno = pParser->yytos->stateno;
+
+ if( stateno>=YY_MIN_REDUCE ) return stateno;
+ assert( stateno <= YY_SHIFT_COUNT );
+ do{
+ i = yy_shift_ofst[stateno];
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+#ifdef YYFALLBACK
+ YYCODETYPE iFallback = -1; /* Fallback token */
+ if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+ && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+ }
+#endif
+ assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
+ iLookAhead = iFallback;
+ continue;
+ } else if ( iFallback==0 ) {
+ pParser->is_fallback_failed = true;
+ }
+#endif
+#ifdef YYWILDCARD
+ {
+ int j = i - iLookAhead + YYWILDCARD;
+ if(
+#if YY_SHIFT_MIN+YYWILDCARD<0
+ j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+ j<YY_ACTTAB_COUNT &&
+#endif
+ yy_lookahead[j]==YYWILDCARD && iLookAhead>0
+ ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead],
+ yyTokenName[YYWILDCARD]);
+ }
+#endif /* NDEBUG */
+ return yy_action[j];
+ }
+ }
+#endif /* YYWILDCARD */
+ return yy_default[stateno];
+ }else{
+ return yy_action[i];
+ }
+ }while(1);
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+*/
+static int yy_find_reduce_action(
+ int stateno, /* Current state number */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+#ifdef YYERRORSYMBOL
+ if( stateno>YY_REDUCE_COUNT ){
+ return yy_default[stateno];
+ }
+#else
+ assert( stateno<=YY_REDUCE_COUNT );
+#endif
+ i = yy_reduce_ofst[stateno];
+ assert( i!=YY_REDUCE_USE_DFLT );
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+#ifdef YYERRORSYMBOL
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+ return yy_default[stateno];
+ }
+#else
+ assert( i>=0 && i<YY_ACTTAB_COUNT );
+ assert( yy_lookahead[i]==iLookAhead );
+#endif
+ return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser){
+ sqlite3ParserARG_FETCH;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will execute if the parser
+ ** stack every overflows */
+/******** Begin %stack_overflow code ******************************************/
+#line 41 "parse.y"
+
+ sqlite3ErrorMsg(pParse, "parser stack overflow");
+#line 1724 "parse.c"
+/******** End %stack_overflow code ********************************************/
+ sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Print tracing information for a SHIFT action
+*/
+#ifndef NDEBUG
+static void yyTraceShift(yyParser *yypParser, int yyNewState){
+ if( yyTraceFILE ){
+ if( yyNewState<YYNSTATE ){
+ fprintf(yyTraceFILE,"%sShift '%s', go to state %d\n",
+ yyTracePrompt,yyTokenName[yypParser->yytos->major],
+ yyNewState);
+ }else{
+ fprintf(yyTraceFILE,"%sShift '%s'\n",
+ yyTracePrompt,yyTokenName[yypParser->yytos->major]);
+ }
+ }
+}
+#else
+# define yyTraceShift(X,Y)
+#endif
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+ yyParser *yypParser, /* The parser to be shifted */
+ int yyNewState, /* The new state to shift in */
+ int yyMajor, /* The major token to shift in */
+ sqlite3ParserTOKENTYPE yyMinor /* The minor token to shift in */
+){
+ yyStackEntry *yytos;
+ yypParser->yytos++;
+#ifdef YYTRACKMAXSTACKDEPTH
+ if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+ yypParser->yyhwm++;
+ assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+ }
+#endif
+#if YYSTACKDEPTH>0
+ if( yypParser->yytos>=&yypParser->yystack[YYSTACKDEPTH] ){
+ yypParser->yytos--;
+ yyStackOverflow(yypParser);
+ return;
+ }
+#else
+ if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
+ if( yyGrowStack(yypParser) ){
+ yypParser->yytos--;
+ yyStackOverflow(yypParser);
+ return;
+ }
+ }
+#endif
+ if( yyNewState > YY_MAX_SHIFT ){
+ yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
+ }
+ yytos = yypParser->yytos;
+ yytos->stateno = (YYACTIONTYPE)yyNewState;
+ yytos->major = (YYCODETYPE)yyMajor;
+ yytos->minor.yy0 = yyMinor;
+ yyTraceShift(yypParser, yyNewState);
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+ YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
+ unsigned char nrhs; /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+ { 137, 3 },
+ { 137, 1 },
+ { 138, 1 },
+ { 138, 3 },
+ { 140, 3 },
+ { 141, 0 },
+ { 141, 1 },
+ { 140, 2 },
+ { 140, 2 },
+ { 140, 2 },
+ { 140, 2 },
+ { 140, 3 },
+ { 140, 5 },
+ { 145, 4 },
+ { 147, 1 },
+ { 148, 0 },
+ { 148, 3 },
+ { 146, 4 },
+ { 146, 2 },
+ { 152, 2 },
+ { 143, 1 },
+ { 154, 0 },
+ { 154, 4 },
+ { 154, 6 },
+ { 155, 2 },
+ { 159, 2 },
+ { 159, 2 },
+ { 159, 4 },
+ { 159, 3 },
+ { 159, 3 },
+ { 159, 2 },
+ { 159, 3 },
+ { 159, 5 },
+ { 159, 2 },
+ { 159, 4 },
+ { 159, 4 },
+ { 159, 1 },
+ { 159, 2 },
+ { 164, 0 },
+ { 164, 1 },
+ { 166, 0 },
+ { 166, 2 },
+ { 168, 2 },
+ { 168, 3 },
+ { 168, 3 },
+ { 168, 3 },
+ { 169, 2 },
+ { 169, 2 },
+ { 169, 1 },
+ { 169, 1 },
+ { 169, 2 },
+ { 167, 3 },
+ { 167, 2 },
+ { 170, 0 },
+ { 170, 2 },
+ { 170, 2 },
+ { 150, 0 },
+ { 172, 1 },
+ { 173, 2 },
+ { 173, 7 },
+ { 173, 5 },
+ { 173, 5 },
+ { 173, 10 },
+ { 176, 0 },
+ { 162, 0 },
+ { 162, 3 },
+ { 177, 0 },
+ { 177, 2 },
+ { 178, 1 },
+ { 178, 1 },
+ { 140, 4 },
+ { 180, 2 },
+ { 180, 0 },
+ { 140, 7 },
+ { 140, 4 },
+ { 140, 1 },
+ { 151, 2 },
+ { 182, 3 },
+ { 185, 1 },
+ { 185, 2 },
+ { 185, 1 },
+ { 183, 9 },
+ { 194, 4 },
+ { 194, 5 },
+ { 186, 1 },
+ { 186, 1 },
+ { 186, 0 },
+ { 197, 0 },
+ { 187, 3 },
+ { 187, 2 },
+ { 187, 4 },
+ { 198, 2 },
+ { 198, 0 },
+ { 188, 0 },
+ { 188, 2 },
+ { 200, 2 },
+ { 200, 0 },
+ { 199, 6 },
+ { 199, 8 },
+ { 199, 7 },
+ { 199, 7 },
+ { 181, 1 },
+ { 201, 1 },
+ { 201, 2 },
+ { 201, 3 },
+ { 201, 4 },
+ { 203, 2 },
+ { 203, 0 },
+ { 202, 0 },
+ { 202, 3 },
+ { 202, 2 },
+ { 204, 4 },
+ { 204, 0 },
+ { 192, 0 },
+ { 192, 3 },
+ { 174, 4 },
+ { 174, 2 },
+ { 163, 1 },
+ { 163, 1 },
+ { 163, 0 },
+ { 190, 0 },
+ { 190, 3 },
+ { 191, 0 },
+ { 191, 2 },
+ { 193, 0 },
+ { 193, 2 },
+ { 193, 4 },
+ { 193, 4 },
+ { 140, 6 },
+ { 189, 0 },
+ { 189, 2 },
+ { 140, 8 },
+ { 207, 5 },
+ { 207, 7 },
+ { 207, 3 },
+ { 207, 5 },
+ { 140, 6 },
+ { 140, 7 },
+ { 208, 2 },
+ { 208, 1 },
+ { 209, 0 },
+ { 209, 3 },
+ { 206, 3 },
+ { 206, 1 },
+ { 161, 3 },
+ { 160, 1 },
+ { 161, 1 },
+ { 161, 1 },
+ { 161, 3 },
+ { 160, 1 },
+ { 160, 1 },
+ { 160, 1 },
+ { 161, 1 },
+ { 161, 3 },
+ { 161, 6 },
+ { 161, 5 },
+ { 161, 4 },
+ { 160, 1 },
+ { 161, 5 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 3 },
+ { 210, 1 },
+ { 210, 2 },
+ { 161, 3 },
+ { 161, 5 },
+ { 161, 2 },
+ { 161, 3 },
+ { 161, 3 },
+ { 161, 4 },
+ { 161, 2 },
+ { 161, 2 },
+ { 161, 2 },
+ { 161, 2 },
+ { 211, 1 },
+ { 211, 2 },
+ { 161, 5 },
+ { 212, 1 },
+ { 212, 2 },
+ { 161, 5 },
+ { 161, 3 },
+ { 161, 5 },
+ { 161, 4 },
+ { 161, 4 },
+ { 161, 5 },
+ { 215, 5 },
+ { 215, 4 },
+ { 216, 2 },
+ { 216, 0 },
+ { 214, 1 },
+ { 214, 0 },
+ { 196, 0 },
+ { 195, 3 },
+ { 195, 1 },
+ { 213, 0 },
+ { 213, 3 },
+ { 140, 10 },
+ { 217, 1 },
+ { 217, 0 },
+ { 165, 0 },
+ { 165, 3 },
+ { 175, 5 },
+ { 175, 3 },
+ { 218, 0 },
+ { 218, 2 },
+ { 140, 6 },
+ { 140, 2 },
+ { 140, 4 },
+ { 140, 5 },
+ { 140, 4 },
+ { 140, 5 },
+ { 140, 6 },
+ { 140, 1 },
+ { 157, 2 },
+ { 158, 2 },
+ { 140, 5 },
+ { 220, 9 },
+ { 222, 1 },
+ { 222, 1 },
+ { 222, 2 },
+ { 222, 0 },
+ { 223, 1 },
+ { 223, 1 },
+ { 223, 3 },
+ { 225, 0 },
+ { 225, 2 },
+ { 221, 3 },
+ { 221, 2 },
+ { 227, 3 },
+ { 228, 3 },
+ { 228, 2 },
+ { 226, 7 },
+ { 226, 5 },
+ { 226, 5 },
+ { 226, 1 },
+ { 161, 4 },
+ { 161, 6 },
+ { 179, 1 },
+ { 179, 1 },
+ { 179, 1 },
+ { 140, 4 },
+ { 140, 1 },
+ { 140, 2 },
+ { 140, 6 },
+ { 184, 0 },
+ { 184, 2 },
+ { 184, 3 },
+ { 229, 6 },
+ { 229, 8 },
+ { 136, 1 },
+ { 138, 0 },
+ { 139, 1 },
+ { 142, 0 },
+ { 142, 1 },
+ { 142, 2 },
+ { 144, 1 },
+ { 144, 0 },
+ { 140, 2 },
+ { 149, 4 },
+ { 149, 2 },
+ { 154, 1 },
+ { 155, 1 },
+ { 156, 1 },
+ { 156, 1 },
+ { 153, 2 },
+ { 153, 0 },
+ { 159, 2 },
+ { 150, 2 },
+ { 171, 3 },
+ { 171, 1 },
+ { 172, 0 },
+ { 176, 1 },
+ { 178, 1 },
+ { 182, 1 },
+ { 183, 1 },
+ { 197, 2 },
+ { 198, 1 },
+ { 205, 1 },
+ { 205, 1 },
+ { 161, 1 },
+ { 196, 1 },
+ { 219, 1 },
+ { 219, 1 },
+ { 219, 1 },
+ { 219, 1 },
+ { 219, 1 },
+ { 219, 1 },
+ { 157, 1 },
+ { 224, 0 },
+ { 224, 3 },
+ { 227, 1 },
+ { 228, 0 },
+};
+
+static void yy_accept(yyParser*); /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+ yyParser *yypParser, /* The parser */
+ unsigned int yyruleno /* Number of the rule by which to reduce */
+){
+ int yygoto; /* The next state */
+ int yyact; /* The next action */
+ yyStackEntry *yymsp; /* The top of the parser's stack */
+ int yysize; /* Amount to pop the stack */
+ sqlite3ParserARG_FETCH;
+ yymsp = yypParser->yytos;
+#ifndef NDEBUG
+ if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+ yysize = yyRuleInfo[yyruleno].nrhs;
+ fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt,
+ yyRuleName[yyruleno], yymsp[-yysize].stateno);
+ }
+#endif /* NDEBUG */
+
+ /* Check that the stack is large enough to grow by a single entry
+ ** if the RHS of the rule is empty. This ensures that there is room
+ ** enough on the stack to push the LHS value */
+ if( yyRuleInfo[yyruleno].nrhs==0 ){
+#ifdef YYTRACKMAXSTACKDEPTH
+ if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+ yypParser->yyhwm++;
+ assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+ }
+#endif
+#if YYSTACKDEPTH>0
+ if( yypParser->yytos>=&yypParser->yystack[YYSTACKDEPTH-1] ){
+ yyStackOverflow(yypParser);
+ return;
+ }
+#else
+ if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
+ if( yyGrowStack(yypParser) ){
+ yyStackOverflow(yypParser);
+ return;
+ }
+ yymsp = yypParser->yytos;
+ }
+#endif
+ }
+
+ switch( yyruleno ){
+ /* Beginning here are the reduction cases. A typical example
+ ** follows:
+ ** case 0:
+ ** #line <lineno> <grammarfile>
+ ** { ... } // User supplied code
+ ** #line <lineno> <thisfile>
+ ** break;
+ */
+/********** Begin reduce actions **********************************************/
+ YYMINORTYPE yylhsminor;
+ case 0: /* ecmd ::= explain cmdx SEMI */
+#line 111 "parse.y"
+{
+ if (!pParse->parse_only)
+ sqlite3FinishCoding(pParse);
+}
+#line 2164 "parse.c"
+ break;
+ case 1: /* ecmd ::= SEMI */
+#line 115 "parse.y"
+{
+ sqlite3ErrorMsg(pParse, "syntax error: empty request");
+}
+#line 2171 "parse.c"
+ break;
+ case 2: /* explain ::= EXPLAIN */
+#line 119 "parse.y"
+{ pParse->explain = 1; }
+#line 2176 "parse.c"
+ break;
+ case 3: /* explain ::= EXPLAIN QUERY PLAN */
+#line 120 "parse.y"
+{ pParse->explain = 2; }
+#line 2181 "parse.c"
+ break;
+ case 4: /* cmd ::= BEGIN transtype trans_opt */
+#line 151 "parse.y"
+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy52);}
+#line 2186 "parse.c"
+ break;
+ case 5: /* transtype ::= */
+#line 156 "parse.y"
+{yymsp[1].minor.yy52 = TK_DEFERRED;}
+#line 2191 "parse.c"
+ break;
+ case 6: /* transtype ::= DEFERRED */
+#line 157 "parse.y"
+{yymsp[0].minor.yy52 = yymsp[0].major; /*A-overwrites-X*/}
+#line 2196 "parse.c"
+ break;
+ case 7: /* cmd ::= COMMIT trans_opt */
+ case 8: /* cmd ::= END trans_opt */ yytestcase(yyruleno==8);
+#line 158 "parse.y"
+{sqlite3CommitTransaction(pParse);}
+#line 2202 "parse.c"
+ break;
+ case 9: /* cmd ::= ROLLBACK trans_opt */
+#line 160 "parse.y"
+{sqlite3RollbackTransaction(pParse);}
+#line 2207 "parse.c"
+ break;
+ case 10: /* cmd ::= SAVEPOINT nm */
+#line 164 "parse.y"
+{
+ sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
+}
+#line 2214 "parse.c"
+ break;
+ case 11: /* cmd ::= RELEASE savepoint_opt nm */
+#line 167 "parse.y"
+{
+ sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
+}
+#line 2221 "parse.c"
+ break;
+ case 12: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
+#line 170 "parse.y"
+{
+ sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
+}
+#line 2228 "parse.c"
+ break;
+ case 13: /* create_table ::= createkw TABLE ifnotexists nm */
+#line 177 "parse.y"
+{
+ sqlite3StartTable(pParse,&yymsp[0].minor.yy0,yymsp[-1].minor.yy52);
+}
+#line 2235 "parse.c"
+ break;
+ case 14: /* createkw ::= CREATE */
+#line 180 "parse.y"
+{disableLookaside(pParse);}
+#line 2240 "parse.c"
+ break;
+ case 15: /* ifnotexists ::= */
+ case 38: /* autoinc ::= */ yytestcase(yyruleno==38);
+ case 53: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==53);
+ case 63: /* defer_subclause_opt ::= */ yytestcase(yyruleno==63);
+ case 72: /* ifexists ::= */ yytestcase(yyruleno==72);
+ case 86: /* distinct ::= */ yytestcase(yyruleno==86);
+ case 208: /* collate ::= */ yytestcase(yyruleno==208);
+#line 183 "parse.y"
+{yymsp[1].minor.yy52 = 0;}
+#line 2251 "parse.c"
+ break;
+ case 16: /* ifnotexists ::= IF NOT EXISTS */
+#line 184 "parse.y"
+{yymsp[-2].minor.yy52 = 1;}
+#line 2256 "parse.c"
+ break;
+ case 17: /* create_table_args ::= LP columnlist conslist_opt RP */
+#line 186 "parse.y"
+{
+ sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
+}
+#line 2263 "parse.c"
+ break;
+ case 18: /* create_table_args ::= AS select */
+#line 189 "parse.y"
+{
+ sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy279);
+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy279);
+}
+#line 2271 "parse.c"
+ break;
+ case 19: /* columnname ::= nm typetoken */
+#line 195 "parse.y"
+{sqlite3AddColumn(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
+#line 2276 "parse.c"
+ break;
+ case 20: /* nm ::= ID|INDEXED */
+#line 233 "parse.y"
+{
+ if(yymsp[0].minor.yy0.isReserved) {
+ sqlite3ErrorMsg(pParse, "keyword \"%T\" is reserved", &yymsp[0].minor.yy0);
+ }
+}
+#line 2285 "parse.c"
+ break;
+ case 21: /* typetoken ::= */
+ case 56: /* conslist_opt ::= */ yytestcase(yyruleno==56);
+ case 92: /* as ::= */ yytestcase(yyruleno==92);
+#line 244 "parse.y"
+{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
+#line 2292 "parse.c"
+ break;
+ case 22: /* typetoken ::= typename LP signed RP */
+#line 246 "parse.y"
+{
+ yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
+}
+#line 2299 "parse.c"
+ break;
+ case 23: /* typetoken ::= typename LP signed COMMA signed RP */
+#line 249 "parse.y"
+{
+ yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
+}
+#line 2306 "parse.c"
+ break;
+ case 24: /* typename ::= typename ID|STRING */
+#line 254 "parse.y"
+{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
+#line 2311 "parse.c"
+ break;
+ case 25: /* ccons ::= CONSTRAINT nm */
+ case 58: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==58);
+#line 263 "parse.y"
+{pParse->constraintName = yymsp[0].minor.yy0;}
+#line 2317 "parse.c"
+ break;
+ case 26: /* ccons ::= DEFAULT term */
+ case 28: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==28);
+#line 264 "parse.y"
+{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy162);}
+#line 2323 "parse.c"
+ break;
+ case 27: /* ccons ::= DEFAULT LP expr RP */
+#line 265 "parse.y"
+{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy162);}
+#line 2328 "parse.c"
+ break;
+ case 29: /* ccons ::= DEFAULT MINUS term */
+#line 267 "parse.y"
+{
+ ExprSpan v;
+ v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy162.pExpr, 0);
+ v.zStart = yymsp[-1].minor.yy0.z;
+ v.zEnd = yymsp[0].minor.yy162.zEnd;
+ sqlite3AddDefaultValue(pParse,&v);
+}
+#line 2339 "parse.c"
+ break;
+ case 30: /* ccons ::= DEFAULT ID|INDEXED */
+#line 274 "parse.y"
+{
+ ExprSpan v;
+ spanExpr(&v, pParse, TK_STRING, yymsp[0].minor.yy0);
+ sqlite3AddDefaultValue(pParse,&v);
+}
+#line 2348 "parse.c"
+ break;
+ case 31: /* ccons ::= NOT NULL onconf */
+#line 284 "parse.y"
+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy52);}
+#line 2353 "parse.c"
+ break;
+ case 32: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
+#line 286 "parse.y"
+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy52,yymsp[0].minor.yy52,yymsp[-2].minor.yy52);}
+#line 2358 "parse.c"
+ break;
+ case 33: /* ccons ::= UNIQUE onconf */
+#line 287 "parse.y"
+{sqlite3CreateIndex(pParse,0,0,0,yymsp[0].minor.yy52,0,0,0,0,
+ SQLITE_IDXTYPE_UNIQUE);}
+#line 2364 "parse.c"
+ break;
+ case 34: /* ccons ::= CHECK LP expr RP */
+#line 289 "parse.y"
+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy162.pExpr);}
+#line 2369 "parse.c"
+ break;
+ case 35: /* ccons ::= REFERENCES nm eidlist_opt refargs */
+#line 291 "parse.y"
+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy382,yymsp[0].minor.yy52);}
+#line 2374 "parse.c"
+ break;
+ case 36: /* ccons ::= defer_subclause */
+#line 292 "parse.y"
+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy52);}
+#line 2379 "parse.c"
+ break;
+ case 37: /* ccons ::= COLLATE ID|INDEXED */
+#line 293 "parse.y"
+{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
+#line 2384 "parse.c"
+ break;
+ case 39: /* autoinc ::= AUTOINCR */
+#line 298 "parse.y"
+{yymsp[0].minor.yy52 = 1;}
+#line 2389 "parse.c"
+ break;
+ case 40: /* refargs ::= */
+#line 306 "parse.y"
+{ yymsp[1].minor.yy52 = ON_CONFLICT_ACTION_NONE*0x0101; /* EV: R-19803-45884 */}
+#line 2394 "parse.c"
+ break;
+ case 41: /* refargs ::= refargs refarg */
+#line 307 "parse.y"
+{ yymsp[-1].minor.yy52 = (yymsp[-1].minor.yy52 & ~yymsp[0].minor.yy107.mask) | yymsp[0].minor.yy107.value; }
+#line 2399 "parse.c"
+ break;
+ case 42: /* refarg ::= MATCH nm */
+#line 309 "parse.y"
+{ yymsp[-1].minor.yy107.value = 0; yymsp[-1].minor.yy107.mask = 0x000000; }
+#line 2404 "parse.c"
+ break;
+ case 43: /* refarg ::= ON INSERT refact */
+#line 310 "parse.y"
+{ yymsp[-2].minor.yy107.value = 0; yymsp[-2].minor.yy107.mask = 0x000000; }
+#line 2409 "parse.c"
+ break;
+ case 44: /* refarg ::= ON DELETE refact */
+#line 311 "parse.y"
+{ yymsp[-2].minor.yy107.value = yymsp[0].minor.yy52; yymsp[-2].minor.yy107.mask = 0x0000ff; }
+#line 2414 "parse.c"
+ break;
+ case 45: /* refarg ::= ON UPDATE refact */
+#line 312 "parse.y"
+{ yymsp[-2].minor.yy107.value = yymsp[0].minor.yy52<<8; yymsp[-2].minor.yy107.mask = 0x00ff00; }
+#line 2419 "parse.c"
+ break;
+ case 46: /* refact ::= SET NULL */
+#line 314 "parse.y"
+{ yymsp[-1].minor.yy52 = OE_SetNull; /* EV: R-33326-45252 */}
+#line 2424 "parse.c"
+ break;
+ case 47: /* refact ::= SET DEFAULT */
+#line 315 "parse.y"
+{ yymsp[-1].minor.yy52 = OE_SetDflt; /* EV: R-33326-45252 */}
+#line 2429 "parse.c"
+ break;
+ case 48: /* refact ::= CASCADE */
+#line 316 "parse.y"
+{ yymsp[0].minor.yy52 = OE_Cascade; /* EV: R-33326-45252 */}
+#line 2434 "parse.c"
+ break;
+ case 49: /* refact ::= RESTRICT */
+#line 317 "parse.y"
+{ yymsp[0].minor.yy52 = OE_Restrict; /* EV: R-33326-45252 */}
+#line 2439 "parse.c"
+ break;
+ case 50: /* refact ::= NO ACTION */
+#line 318 "parse.y"
+{ yymsp[-1].minor.yy52 = ON_CONFLICT_ACTION_NONE; /* EV: R-33326-45252 */}
+#line 2444 "parse.c"
+ break;
+ case 51: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
+#line 320 "parse.y"
+{yymsp[-2].minor.yy52 = 0;}
+#line 2449 "parse.c"
+ break;
+ case 52: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
+ case 67: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==67);
+ case 138: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==138);
+#line 321 "parse.y"
+{yymsp[-1].minor.yy52 = yymsp[0].minor.yy52;}
+#line 2456 "parse.c"
+ break;
+ case 54: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
+ case 71: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==71);
+ case 180: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==180);
+ case 183: /* in_op ::= NOT IN */ yytestcase(yyruleno==183);
+ case 209: /* collate ::= COLLATE ID|INDEXED */ yytestcase(yyruleno==209);
+#line 324 "parse.y"
+{yymsp[-1].minor.yy52 = 1;}
+#line 2465 "parse.c"
+ break;
+ case 55: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
+#line 325 "parse.y"
+{yymsp[-1].minor.yy52 = 0;}
+#line 2470 "parse.c"
+ break;
+ case 57: /* tconscomma ::= COMMA */
+#line 331 "parse.y"
+{pParse->constraintName.n = 0;}
+#line 2475 "parse.c"
+ break;
+ case 59: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
+#line 335 "parse.y"
+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy382,yymsp[0].minor.yy52,yymsp[-2].minor.yy52,0);}
+#line 2480 "parse.c"
+ break;
+ case 60: /* tcons ::= UNIQUE LP sortlist RP onconf */
+#line 337 "parse.y"
+{sqlite3CreateIndex(pParse,0,0,yymsp[-2].minor.yy382,yymsp[0].minor.yy52,0,0,0,0,
+ SQLITE_IDXTYPE_UNIQUE);}
+#line 2486 "parse.c"
+ break;
+ case 61: /* tcons ::= CHECK LP expr RP onconf */
+#line 340 "parse.y"
+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy162.pExpr);}
+#line 2491 "parse.c"
+ break;
+ case 62: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
+#line 342 "parse.y"
+{
+ sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy382, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy382, yymsp[-1].minor.yy52);
+ sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy52);
+}
+#line 2499 "parse.c"
+ break;
+ case 64: /* onconf ::= */
+ case 66: /* orconf ::= */ yytestcase(yyruleno==66);
+#line 356 "parse.y"
+{yymsp[1].minor.yy52 = ON_CONFLICT_ACTION_DEFAULT;}
+#line 2505 "parse.c"
+ break;
+ case 65: /* onconf ::= ON CONFLICT resolvetype */
+#line 357 "parse.y"
+{yymsp[-2].minor.yy52 = yymsp[0].minor.yy52;}
+#line 2510 "parse.c"
+ break;
+ case 68: /* resolvetype ::= IGNORE */
+#line 361 "parse.y"
+{yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_IGNORE;}
+#line 2515 "parse.c"
+ break;
+ case 69: /* resolvetype ::= REPLACE */
+ case 139: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==139);
+#line 362 "parse.y"
+{yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_REPLACE;}
+#line 2521 "parse.c"
+ break;
+ case 70: /* cmd ::= DROP TABLE ifexists fullname */
+#line 366 "parse.y"
+{
+ sql_drop_table(pParse, yymsp[0].minor.yy387, 0, yymsp[-1].minor.yy52);
+}
+#line 2528 "parse.c"
+ break;
+ case 73: /* cmd ::= createkw VIEW ifnotexists nm eidlist_opt AS select */
+#line 377 "parse.y"
+{
+ sqlite3CreateView(pParse, &yymsp[-6].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy382, yymsp[0].minor.yy279, yymsp[-4].minor.yy52);
+}
+#line 2535 "parse.c"
+ break;
+ case 74: /* cmd ::= DROP VIEW ifexists fullname */
+#line 380 "parse.y"
+{
+ sql_drop_table(pParse, yymsp[0].minor.yy387, 1, yymsp[-1].minor.yy52);
+}
+#line 2542 "parse.c"
+ break;
+ case 75: /* cmd ::= select */
+#line 387 "parse.y"
+{
+ SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0};
+ if(!pParse->parse_only)
+ sqlite3Select(pParse, yymsp[0].minor.yy279, &dest);
+ else
+ sql_expr_extract_select(pParse, yymsp[0].minor.yy279);
+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy279);
+}
+#line 2554 "parse.c"
+ break;
+ case 76: /* select ::= with selectnowith */
+#line 427 "parse.y"
+{
+ Select *p = yymsp[0].minor.yy279;
+ if( p ){
+ p->pWith = yymsp[-1].minor.yy151;
+ parserDoubleLinkSelect(pParse, p);
+ }else{
+ sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy151);
+ }
+ yymsp[-1].minor.yy279 = p; /*A-overwrites-W*/
+}
+#line 2568 "parse.c"
+ break;
+ case 77: /* selectnowith ::= selectnowith multiselect_op oneselect */
+#line 440 "parse.y"
+{
+ Select *pRhs = yymsp[0].minor.yy279;
+ Select *pLhs = yymsp[-2].minor.yy279;
+ if( pRhs && pRhs->pPrior ){
+ SrcList *pFrom;
+ Token x;
+ x.n = 0;
+ parserDoubleLinkSelect(pParse, pRhs);
+ pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,&x,pRhs,0,0);
+ pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);
+ }
+ if( pRhs ){
+ pRhs->op = (u8)yymsp[-1].minor.yy52;
+ pRhs->pPrior = pLhs;
+ if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
+ pRhs->selFlags &= ~SF_MultiValue;
+ if( yymsp[-1].minor.yy52!=TK_ALL ) pParse->hasCompound = 1;
+ }else{
+ sqlite3SelectDelete(pParse->db, pLhs);
+ }
+ yymsp[-2].minor.yy279 = pRhs;
+}
+#line 2594 "parse.c"
+ break;
+ case 78: /* multiselect_op ::= UNION */
+ case 80: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==80);
+#line 463 "parse.y"
+{yymsp[0].minor.yy52 = yymsp[0].major; /*A-overwrites-OP*/}
+#line 2600 "parse.c"
+ break;
+ case 79: /* multiselect_op ::= UNION ALL */
+#line 464 "parse.y"
+{yymsp[-1].minor.yy52 = TK_ALL;}
+#line 2605 "parse.c"
+ break;
+ case 81: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
+#line 468 "parse.y"
+{
+#ifdef SELECTTRACE_ENABLED
+ Token s = yymsp[-8].minor.yy0; /*A-overwrites-S*/
+#endif
+ yymsp[-8].minor.yy279 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy382,yymsp[-5].minor.yy387,yymsp[-4].minor.yy362,yymsp[-3].minor.yy382,yymsp[-2].minor.yy362,yymsp[-1].minor.yy382,yymsp[-7].minor.yy52,yymsp[0].minor.yy384.pLimit,yymsp[0].minor.yy384.pOffset);
+#ifdef SELECTTRACE_ENABLED
+ /* Populate the Select.zSelName[] string that is used to help with
+ ** query planner debugging, to differentiate between multiple Select
+ ** objects in a complex query.
+ **
+ ** If the SELECT keyword is immediately followed by a C-style comment
+ ** then extract the first few alphanumeric characters from within that
+ ** comment to be the zSelName value. Otherwise, the label is #N where
+ ** is an integer that is incremented with each SELECT statement seen.
+ */
+ if( yymsp[-8].minor.yy279!=0 ){
+ const char *z = s.z+6;
+ int i;
+ sqlite3_snprintf(sizeof(yymsp[-8].minor.yy279->zSelName), yymsp[-8].minor.yy279->zSelName, "#%d",
+ ++pParse->nSelect);
+ while( z[0]==' ' ) z++;
+ if( z[0]=='/' && z[1]=='*' ){
+ z += 2;
+ while( z[0]==' ' ) z++;
+ for(i=0; sqlite3Isalnum(z[i]); i++){}
+ sqlite3_snprintf(sizeof(yymsp[-8].minor.yy279->zSelName), yymsp[-8].minor.yy279->zSelName, "%.*s", i, z);
+ }
+ }
+#endif /* SELECTRACE_ENABLED */
+}
+#line 2639 "parse.c"
+ break;
+ case 82: /* values ::= VALUES LP nexprlist RP */
+#line 502 "parse.y"
+{
+ yymsp[-3].minor.yy279 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy382,0,0,0,0,0,SF_Values,0,0);
+}
+#line 2646 "parse.c"
+ break;
+ case 83: /* values ::= values COMMA LP exprlist RP */
+#line 505 "parse.y"
+{
+ Select *pRight, *pLeft = yymsp[-4].minor.yy279;
+ pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy382,0,0,0,0,0,SF_Values|SF_MultiValue,0,0);
+ if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
+ if( pRight ){
+ pRight->op = TK_ALL;
+ pRight->pPrior = pLeft;
+ yymsp[-4].minor.yy279 = pRight;
+ }else{
+ yymsp[-4].minor.yy279 = pLeft;
+ }
+}
+#line 2662 "parse.c"
+ break;
+ case 84: /* distinct ::= DISTINCT */
+#line 522 "parse.y"
+{yymsp[0].minor.yy52 = SF_Distinct;}
+#line 2667 "parse.c"
+ break;
+ case 85: /* distinct ::= ALL */
+#line 523 "parse.y"
+{yymsp[0].minor.yy52 = SF_All;}
+#line 2672 "parse.c"
+ break;
+ case 87: /* sclp ::= */
+ case 113: /* orderby_opt ::= */ yytestcase(yyruleno==113);
+ case 120: /* groupby_opt ::= */ yytestcase(yyruleno==120);
+ case 196: /* exprlist ::= */ yytestcase(yyruleno==196);
+ case 199: /* paren_exprlist ::= */ yytestcase(yyruleno==199);
+ case 204: /* eidlist_opt ::= */ yytestcase(yyruleno==204);
+#line 536 "parse.y"
+{yymsp[1].minor.yy382 = 0;}
+#line 2682 "parse.c"
+ break;
+ case 88: /* selcollist ::= sclp expr as */
+#line 537 "parse.y"
+{
+ yymsp[-2].minor.yy382 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy382, yymsp[-1].minor.yy162.pExpr);
+ if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-2].minor.yy382, &yymsp[0].minor.yy0, 1);
+ sqlite3ExprListSetSpan(pParse,yymsp[-2].minor.yy382,&yymsp[-1].minor.yy162);
+}
+#line 2691 "parse.c"
+ break;
+ case 89: /* selcollist ::= sclp STAR */
+#line 542 "parse.y"
+{
+ Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
+ yymsp[-1].minor.yy382 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy382, p);
+}
+#line 2699 "parse.c"
+ break;
+ case 90: /* selcollist ::= sclp nm DOT STAR */
+#line 546 "parse.y"
+{
+ Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
+ Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
+ Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
+ yymsp[-3].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy382, pDot);
+}
+#line 2709 "parse.c"
+ break;
+ case 91: /* as ::= AS nm */
+ case 218: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==218);
+ case 219: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==219);
+#line 557 "parse.y"
+{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
+#line 2716 "parse.c"
+ break;
+ case 93: /* from ::= */
+#line 571 "parse.y"
+{yymsp[1].minor.yy387 = sqlite3DbMallocZero(pParse->db, sizeof(*yymsp[1].minor.yy387));}
+#line 2721 "parse.c"
+ break;
+ case 94: /* from ::= FROM seltablist */
+#line 572 "parse.y"
+{
+ yymsp[-1].minor.yy387 = yymsp[0].minor.yy387;
+ sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy387);
+}
+#line 2729 "parse.c"
+ break;
+ case 95: /* stl_prefix ::= seltablist joinop */
+#line 580 "parse.y"
+{
+ if( ALWAYS(yymsp[-1].minor.yy387 && yymsp[-1].minor.yy387->nSrc>0) ) yymsp[-1].minor.yy387->a[yymsp[-1].minor.yy387->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy52;
+}
+#line 2736 "parse.c"
+ break;
+ case 96: /* stl_prefix ::= */
+#line 583 "parse.y"
+{yymsp[1].minor.yy387 = 0;}
+#line 2741 "parse.c"
+ break;
+ case 97: /* seltablist ::= stl_prefix nm as indexed_opt on_opt using_opt */
+#line 585 "parse.y"
+{
+ yymsp[-5].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy387,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy362,yymsp[0].minor.yy40);
+ sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy387, &yymsp[-2].minor.yy0);
+}
+#line 2749 "parse.c"
+ break;
+ case 98: /* seltablist ::= stl_prefix nm LP exprlist RP as on_opt using_opt */
+#line 590 "parse.y"
+{
+ yymsp[-7].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy387,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy362,yymsp[0].minor.yy40);
+ sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy387, yymsp[-4].minor.yy382);
+}
+#line 2757 "parse.c"
+ break;
+ case 99: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
+#line 595 "parse.y"
+{
+ yymsp[-6].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy387,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy279,yymsp[-1].minor.yy362,yymsp[0].minor.yy40);
+}
+#line 2764 "parse.c"
+ break;
+ case 100: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
+#line 599 "parse.y"
+{
+ if( yymsp[-6].minor.yy387==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy362==0 && yymsp[0].minor.yy40==0 ){
+ yymsp[-6].minor.yy387 = yymsp[-4].minor.yy387;
+ }else if( yymsp[-4].minor.yy387->nSrc==1 ){
+ yymsp[-6].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy387,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy362,yymsp[0].minor.yy40);
+ if( yymsp[-6].minor.yy387 ){
+ struct SrcList_item *pNew = &yymsp[-6].minor.yy387->a[yymsp[-6].minor.yy387->nSrc-1];
+ struct SrcList_item *pOld = yymsp[-4].minor.yy387->a;
+ pNew->zName = pOld->zName;
+ pNew->pSelect = pOld->pSelect;
+ pOld->zName = 0;
+ pOld->pSelect = 0;
+ }
+ sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy387);
+ }else{
+ Select *pSubquery;
+ sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy387);
+ pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy387,0,0,0,0,SF_NestedFrom,0,0);
+ yymsp[-6].minor.yy387 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy387,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy362,yymsp[0].minor.yy40);
+ }
+}
+#line 2789 "parse.c"
+ break;
+ case 101: /* fullname ::= nm */
+#line 624 "parse.y"
+{yymsp[0].minor.yy387 = sqlite3SrcListAppend(pParse->db,0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
+#line 2794 "parse.c"
+ break;
+ case 102: /* joinop ::= COMMA|JOIN */
+#line 630 "parse.y"
+{ yymsp[0].minor.yy52 = JT_INNER; }
+#line 2799 "parse.c"
+ break;
+ case 103: /* joinop ::= JOIN_KW JOIN */
+#line 632 "parse.y"
+{yymsp[-1].minor.yy52 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
+#line 2804 "parse.c"
+ break;
+ case 104: /* joinop ::= JOIN_KW join_nm JOIN */
+#line 634 "parse.y"
+{yymsp[-2].minor.yy52 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
+#line 2809 "parse.c"
+ break;
+ case 105: /* joinop ::= JOIN_KW join_nm join_nm JOIN */
+#line 636 "parse.y"
+{yymsp[-3].minor.yy52 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
+#line 2814 "parse.c"
+ break;
+ case 106: /* on_opt ::= ON expr */
+ case 123: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==123);
+ case 130: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==130);
+ case 192: /* case_else ::= ELSE expr */ yytestcase(yyruleno==192);
+#line 640 "parse.y"
+{yymsp[-1].minor.yy362 = yymsp[0].minor.yy162.pExpr;}
+#line 2822 "parse.c"
+ break;
+ case 107: /* on_opt ::= */
+ case 122: /* having_opt ::= */ yytestcase(yyruleno==122);
+ case 129: /* where_opt ::= */ yytestcase(yyruleno==129);
+ case 193: /* case_else ::= */ yytestcase(yyruleno==193);
+ case 195: /* case_operand ::= */ yytestcase(yyruleno==195);
+#line 641 "parse.y"
+{yymsp[1].minor.yy362 = 0;}
+#line 2831 "parse.c"
+ break;
+ case 108: /* indexed_opt ::= */
+#line 654 "parse.y"
+{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
+#line 2836 "parse.c"
+ break;
+ case 109: /* indexed_opt ::= INDEXED BY nm */
+#line 655 "parse.y"
+{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
+#line 2841 "parse.c"
+ break;
+ case 110: /* indexed_opt ::= NOT INDEXED */
+#line 656 "parse.y"
+{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
+#line 2846 "parse.c"
+ break;
+ case 111: /* using_opt ::= USING LP idlist RP */
+#line 660 "parse.y"
+{yymsp[-3].minor.yy40 = yymsp[-1].minor.yy40;}
+#line 2851 "parse.c"
+ break;
+ case 112: /* using_opt ::= */
+ case 140: /* idlist_opt ::= */ yytestcase(yyruleno==140);
+#line 661 "parse.y"
+{yymsp[1].minor.yy40 = 0;}
+#line 2857 "parse.c"
+ break;
+ case 114: /* orderby_opt ::= ORDER BY sortlist */
+ case 121: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==121);
+#line 675 "parse.y"
+{yymsp[-2].minor.yy382 = yymsp[0].minor.yy382;}
+#line 2863 "parse.c"
+ break;
+ case 115: /* sortlist ::= sortlist COMMA expr sortorder */
+#line 676 "parse.y"
+{
+ yymsp[-3].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy382,yymsp[-1].minor.yy162.pExpr);
+ sqlite3ExprListSetSortOrder(yymsp[-3].minor.yy382,yymsp[0].minor.yy52);
+}
+#line 2871 "parse.c"
+ break;
+ case 116: /* sortlist ::= expr sortorder */
+#line 680 "parse.y"
+{
+ yymsp[-1].minor.yy382 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy162.pExpr); /*A-overwrites-Y*/
+ sqlite3ExprListSetSortOrder(yymsp[-1].minor.yy382,yymsp[0].minor.yy52);
+}
+#line 2879 "parse.c"
+ break;
+ case 117: /* sortorder ::= ASC */
+#line 687 "parse.y"
+{yymsp[0].minor.yy52 = SQLITE_SO_ASC;}
+#line 2884 "parse.c"
+ break;
+ case 118: /* sortorder ::= DESC */
+#line 688 "parse.y"
+{yymsp[0].minor.yy52 = SQLITE_SO_DESC;}
+#line 2889 "parse.c"
+ break;
+ case 119: /* sortorder ::= */
+#line 689 "parse.y"
+{yymsp[1].minor.yy52 = SQLITE_SO_UNDEFINED;}
+#line 2894 "parse.c"
+ break;
+ case 124: /* limit_opt ::= */
+#line 714 "parse.y"
+{yymsp[1].minor.yy384.pLimit = 0; yymsp[1].minor.yy384.pOffset = 0;}
+#line 2899 "parse.c"
+ break;
+ case 125: /* limit_opt ::= LIMIT expr */
+#line 715 "parse.y"
+{yymsp[-1].minor.yy384.pLimit = yymsp[0].minor.yy162.pExpr; yymsp[-1].minor.yy384.pOffset = 0;}
+#line 2904 "parse.c"
+ break;
+ case 126: /* limit_opt ::= LIMIT expr OFFSET expr */
+#line 717 "parse.y"
+{yymsp[-3].minor.yy384.pLimit = yymsp[-2].minor.yy162.pExpr; yymsp[-3].minor.yy384.pOffset = yymsp[0].minor.yy162.pExpr;}
+#line 2909 "parse.c"
+ break;
+ case 127: /* limit_opt ::= LIMIT expr COMMA expr */
+#line 719 "parse.y"
+{yymsp[-3].minor.yy384.pOffset = yymsp[-2].minor.yy162.pExpr; yymsp[-3].minor.yy384.pLimit = yymsp[0].minor.yy162.pExpr;}
+#line 2914 "parse.c"
+ break;
+ case 128: /* cmd ::= with DELETE FROM fullname indexed_opt where_opt */
+#line 736 "parse.y"
+{
+ sqlite3WithPush(pParse, yymsp[-5].minor.yy151, 1);
+ sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy387, &yymsp[-1].minor.yy0);
+ sqlSubProgramsRemaining = SQL_MAX_COMPILING_TRIGGERS;
+ /* Instruct SQL to initate Tarantool's transaction. */
+ pParse->initiateTTrans = true;
+ sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy387,yymsp[0].minor.yy362);
+}
+#line 2926 "parse.c"
+ break;
+ case 131: /* cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt */
+#line 769 "parse.y"
+{
+ sqlite3WithPush(pParse, yymsp[-7].minor.yy151, 1);
+ sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy387, &yymsp[-3].minor.yy0);
+ sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy382,"set list");
+ sqlSubProgramsRemaining = SQL_MAX_COMPILING_TRIGGERS;
+ /* Instruct SQL to initate Tarantool's transaction. */
+ pParse->initiateTTrans = true;
+ sqlite3Update(pParse,yymsp[-4].minor.yy387,yymsp[-1].minor.yy382,yymsp[0].minor.yy362,yymsp[-5].minor.yy52);
+}
+#line 2939 "parse.c"
+ break;
+ case 132: /* setlist ::= setlist COMMA nm EQ expr */
+#line 783 "parse.y"
+{
+ yymsp[-4].minor.yy382 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy382, yymsp[0].minor.yy162.pExpr);
+ sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy382, &yymsp[-2].minor.yy0, 1);
+}
+#line 2947 "parse.c"
+ break;
+ case 133: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
+#line 787 "parse.y"
+{
+ yymsp[-6].minor.yy382 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy382, yymsp[-3].minor.yy40, yymsp[0].minor.yy162.pExpr);
+}
+#line 2954 "parse.c"
+ break;
+ case 134: /* setlist ::= nm EQ expr */
+#line 790 "parse.y"
+{
+ yylhsminor.yy382 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy162.pExpr);
+ sqlite3ExprListSetName(pParse, yylhsminor.yy382, &yymsp[-2].minor.yy0, 1);
+}
+#line 2962 "parse.c"
+ yymsp[-2].minor.yy382 = yylhsminor.yy382;
+ break;
+ case 135: /* setlist ::= LP idlist RP EQ expr */
+#line 794 "parse.y"
+{
+ yymsp[-4].minor.yy382 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy40, yymsp[0].minor.yy162.pExpr);
+}
+#line 2970 "parse.c"
+ break;
+ case 136: /* cmd ::= with insert_cmd INTO fullname idlist_opt select */
+#line 800 "parse.y"
+{
+ sqlite3WithPush(pParse, yymsp[-5].minor.yy151, 1);
+ sqlSubProgramsRemaining = SQL_MAX_COMPILING_TRIGGERS;
+ /* Instruct SQL to initate Tarantool's transaction. */
+ pParse->initiateTTrans = true;
+ sqlite3Insert(pParse, yymsp[-2].minor.yy387, yymsp[0].minor.yy279, yymsp[-1].minor.yy40, yymsp[-4].minor.yy52);
+}
+#line 2981 "parse.c"
+ break;
+ case 137: /* cmd ::= with insert_cmd INTO fullname idlist_opt DEFAULT VALUES */
+#line 808 "parse.y"
+{
+ sqlite3WithPush(pParse, yymsp[-6].minor.yy151, 1);
+ sqlSubProgramsRemaining = SQL_MAX_COMPILING_TRIGGERS;
+ /* Instruct SQL to initate Tarantool's transaction. */
+ pParse->initiateTTrans = true;
+ sqlite3Insert(pParse, yymsp[-3].minor.yy387, 0, yymsp[-2].minor.yy40, yymsp[-5].minor.yy52);
+}
+#line 2992 "parse.c"
+ break;
+ case 141: /* idlist_opt ::= LP idlist RP */
+#line 826 "parse.y"
+{yymsp[-2].minor.yy40 = yymsp[-1].minor.yy40;}
+#line 2997 "parse.c"
+ break;
+ case 142: /* idlist ::= idlist COMMA nm */
+#line 828 "parse.y"
+{yymsp[-2].minor.yy40 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy40,&yymsp[0].minor.yy0);}
+#line 3002 "parse.c"
+ break;
+ case 143: /* idlist ::= nm */
+#line 830 "parse.y"
+{yymsp[0].minor.yy40 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
+#line 3007 "parse.c"
+ break;
+ case 144: /* expr ::= LP expr RP */
+#line 879 "parse.y"
+{spanSet(&yymsp[-2].minor.yy162,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-B*/ yymsp[-2].minor.yy162.pExpr = yymsp[-1].minor.yy162.pExpr;}
+#line 3012 "parse.c"
+ break;
+ case 145: /* term ::= NULL */
+ case 149: /* term ::= FLOAT|BLOB */ yytestcase(yyruleno==149);
+ case 150: /* term ::= STRING */ yytestcase(yyruleno==150);
+#line 880 "parse.y"
+{spanExpr(&yymsp[0].minor.yy162,pParse,yymsp[0].major,yymsp[0].minor.yy0);/*A-overwrites-X*/}
+#line 3019 "parse.c"
+ break;
+ case 146: /* expr ::= ID|INDEXED */
+ case 147: /* expr ::= JOIN_KW */ yytestcase(yyruleno==147);
+#line 881 "parse.y"
+{spanExpr(&yymsp[0].minor.yy162,pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+#line 3025 "parse.c"
+ break;
+ case 148: /* expr ::= nm DOT nm */
+#line 883 "parse.y"
+{
+ Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
+ Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
+ spanSet(&yymsp[-2].minor.yy162,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/
+ yymsp[-2].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
+}
+#line 3035 "parse.c"
+ break;
+ case 151: /* term ::= INTEGER */
+#line 891 "parse.y"
+{
+ yylhsminor.yy162.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
+ yylhsminor.yy162.zStart = yymsp[0].minor.yy0.z;
+ yylhsminor.yy162.zEnd = yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n;
+ if( yylhsminor.yy162.pExpr ) yylhsminor.yy162.pExpr->flags |= EP_Leaf;
+}
+#line 3045 "parse.c"
+ yymsp[0].minor.yy162 = yylhsminor.yy162;
+ break;
+ case 152: /* expr ::= VARIABLE */
+#line 897 "parse.y"
+{
+ if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
+ u32 n = yymsp[0].minor.yy0.n;
+ spanExpr(&yymsp[0].minor.yy162, pParse, TK_VARIABLE, yymsp[0].minor.yy0);
+ sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy162.pExpr, n);
+ }else{
+ /* When doing a nested parse, one can include terms in an expression
+ ** that look like this: #1 #2 ... These terms refer to registers
+ ** in the virtual machine. #N is the N-th register. */
+ Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
+ assert( t.n>=2 );
+ spanSet(&yymsp[0].minor.yy162, &t, &t);
+ if( pParse->nested==0 ){
+ sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
+ yymsp[0].minor.yy162.pExpr = 0;
+ }else{
+ yymsp[0].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
+ if( yymsp[0].minor.yy162.pExpr ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy162.pExpr->iTable);
+ }
+ }
+}
+#line 3071 "parse.c"
+ break;
+ case 153: /* expr ::= expr COLLATE ID|INDEXED */
+#line 918 "parse.y"
+{
+ yymsp[-2].minor.yy162.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy162.pExpr, &yymsp[0].minor.yy0, 1);
+ yymsp[-2].minor.yy162.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
+}
+#line 3079 "parse.c"
+ break;
+ case 154: /* expr ::= CAST LP expr AS typetoken RP */
+#line 923 "parse.y"
+{
+ spanSet(&yymsp[-5].minor.yy162,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/
+ yymsp[-5].minor.yy162.pExpr = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
+ sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy162.pExpr, yymsp[-3].minor.yy162.pExpr, 0);
+}
+#line 3088 "parse.c"
+ break;
+ case 155: /* expr ::= ID|INDEXED LP distinct exprlist RP */
+#line 929 "parse.y"
+{
+ if( yymsp[-1].minor.yy382 && yymsp[-1].minor.yy382->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
+ sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
+ }
+ yylhsminor.yy162.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy382, &yymsp[-4].minor.yy0);
+ spanSet(&yylhsminor.yy162,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
+ if( yymsp[-2].minor.yy52==SF_Distinct && yylhsminor.yy162.pExpr ){
+ yylhsminor.yy162.pExpr->flags |= EP_Distinct;
+ }
+}
+#line 3102 "parse.c"
+ yymsp[-4].minor.yy162 = yylhsminor.yy162;
+ break;
+ case 156: /* expr ::= ID|INDEXED LP STAR RP */
+#line 939 "parse.y"
+{
+ yylhsminor.yy162.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
+ spanSet(&yylhsminor.yy162,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
+}
+#line 3111 "parse.c"
+ yymsp[-3].minor.yy162 = yylhsminor.yy162;
+ break;
+ case 157: /* term ::= CTIME_KW */
+#line 943 "parse.y"
+{
+ yylhsminor.yy162.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0);
+ spanSet(&yylhsminor.yy162, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
+}
+#line 3120 "parse.c"
+ yymsp[0].minor.yy162 = yylhsminor.yy162;
+ break;
+ case 158: /* expr ::= LP nexprlist COMMA expr RP */
+#line 972 "parse.y"
+{
+ ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy382, yymsp[-1].minor.yy162.pExpr);
+ yylhsminor.yy162.pExpr = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
+ if( yylhsminor.yy162.pExpr ){
+ yylhsminor.yy162.pExpr->x.pList = pList;
+ spanSet(&yylhsminor.yy162, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0);
+ }else{
+ sqlite3ExprListDelete(pParse->db, pList);
+ }
+}
+#line 3135 "parse.c"
+ yymsp[-4].minor.yy162 = yylhsminor.yy162;
+ break;
+ case 159: /* expr ::= expr AND expr */
+ case 160: /* expr ::= expr OR expr */ yytestcase(yyruleno==160);
+ case 161: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==161);
+ case 162: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==162);
+ case 163: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==163);
+ case 164: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==164);
+ case 165: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==165);
+ case 166: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==166);
+#line 983 "parse.y"
+{spanBinaryExpr(pParse,yymsp[-1].major,&yymsp[-2].minor.yy162,&yymsp[0].minor.yy162);}
+#line 3148 "parse.c"
+ break;
+ case 167: /* likeop ::= LIKE_KW|MATCH */
+#line 996 "parse.y"
+{yymsp[0].minor.yy0=yymsp[0].minor.yy0;/*A-overwrites-X*/}
+#line 3153 "parse.c"
+ break;
+ case 168: /* likeop ::= NOT LIKE_KW|MATCH */
+#line 997 "parse.y"
+{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
+#line 3158 "parse.c"
+ break;
+ case 169: /* expr ::= expr likeop expr */
+#line 998 "parse.y"
+{
+ ExprList *pList;
+ int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
+ yymsp[-1].minor.yy0.n &= 0x7fffffff;
+ pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy162.pExpr);
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy162.pExpr);
+ yymsp[-2].minor.yy162.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0);
+ exprNot(pParse, bNot, &yymsp[-2].minor.yy162);
+ yymsp[-2].minor.yy162.zEnd = yymsp[0].minor.yy162.zEnd;
+ if( yymsp[-2].minor.yy162.pExpr ) yymsp[-2].minor.yy162.pExpr->flags |= EP_InfixFunc;
+}
+#line 3173 "parse.c"
+ break;
+ case 170: /* expr ::= expr likeop expr ESCAPE expr */
+#line 1009 "parse.y"
+{
+ ExprList *pList;
+ int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
+ yymsp[-3].minor.yy0.n &= 0x7fffffff;
+ pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy162.pExpr);
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy162.pExpr);
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy162.pExpr);
+ yymsp[-4].minor.yy162.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0);
+ exprNot(pParse, bNot, &yymsp[-4].minor.yy162);
+ yymsp[-4].minor.yy162.zEnd = yymsp[0].minor.yy162.zEnd;
+ if( yymsp[-4].minor.yy162.pExpr ) yymsp[-4].minor.yy162.pExpr->flags |= EP_InfixFunc;
+}
+#line 3189 "parse.c"
+ break;
+ case 171: /* expr ::= expr ISNULL|NOTNULL */
+#line 1036 "parse.y"
+{spanUnaryPostfix(pParse,yymsp[0].major,&yymsp[-1].minor.yy162,&yymsp[0].minor.yy0);}
+#line 3194 "parse.c"
+ break;
+ case 172: /* expr ::= expr NOT NULL */
+#line 1037 "parse.y"
+{spanUnaryPostfix(pParse,TK_NOTNULL,&yymsp[-2].minor.yy162,&yymsp[0].minor.yy0);}
+#line 3199 "parse.c"
+ break;
+ case 173: /* expr ::= expr IS expr */
+#line 1058 "parse.y"
+{
+ spanBinaryExpr(pParse,TK_IS,&yymsp[-2].minor.yy162,&yymsp[0].minor.yy162);
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy162.pExpr, yymsp[-2].minor.yy162.pExpr, TK_ISNULL);
+}
+#line 3207 "parse.c"
+ break;
+ case 174: /* expr ::= expr IS NOT expr */
+#line 1062 "parse.y"
+{
+ spanBinaryExpr(pParse,TK_ISNOT,&yymsp[-3].minor.yy162,&yymsp[0].minor.yy162);
+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy162.pExpr, yymsp[-3].minor.yy162.pExpr, TK_NOTNULL);
+}
+#line 3215 "parse.c"
+ break;
+ case 175: /* expr ::= NOT expr */
+ case 176: /* expr ::= BITNOT expr */ yytestcase(yyruleno==176);
+#line 1086 "parse.y"
+{spanUnaryPrefix(&yymsp[-1].minor.yy162,pParse,yymsp[-1].major,&yymsp[0].minor.yy162,&yymsp[-1].minor.yy0);/*A-overwrites-B*/}
+#line 3221 "parse.c"
+ break;
+ case 177: /* expr ::= MINUS expr */
+#line 1090 "parse.y"
+{spanUnaryPrefix(&yymsp[-1].minor.yy162,pParse,TK_UMINUS,&yymsp[0].minor.yy162,&yymsp[-1].minor.yy0);/*A-overwrites-B*/}
+#line 3226 "parse.c"
+ break;
+ case 178: /* expr ::= PLUS expr */
+#line 1092 "parse.y"
+{spanUnaryPrefix(&yymsp[-1].minor.yy162,pParse,TK_UPLUS,&yymsp[0].minor.yy162,&yymsp[-1].minor.yy0);/*A-overwrites-B*/}
+#line 3231 "parse.c"
+ break;
+ case 179: /* between_op ::= BETWEEN */
+ case 182: /* in_op ::= IN */ yytestcase(yyruleno==182);
+#line 1095 "parse.y"
+{yymsp[0].minor.yy52 = 0;}
+#line 3237 "parse.c"
+ break;
+ case 181: /* expr ::= expr between_op expr AND expr */
+#line 1097 "parse.y"
+{
+ ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy162.pExpr);
+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy162.pExpr);
+ yymsp[-4].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy162.pExpr, 0);
+ if( yymsp[-4].minor.yy162.pExpr ){
+ yymsp[-4].minor.yy162.pExpr->x.pList = pList;
+ }else{
+ sqlite3ExprListDelete(pParse->db, pList);
+ }
+ exprNot(pParse, yymsp[-3].minor.yy52, &yymsp[-4].minor.yy162);
+ yymsp[-4].minor.yy162.zEnd = yymsp[0].minor.yy162.zEnd;
+}
+#line 3253 "parse.c"
+ break;
+ case 184: /* expr ::= expr in_op LP exprlist RP */
+#line 1112 "parse.y"
+{
+ if( yymsp[-1].minor.yy382==0 ){
+ /* Expressions of the form
+ **
+ ** expr1 IN ()
+ ** expr1 NOT IN ()
+ **
+ ** simplify to constants 0 (false) and 1 (true), respectively,
+ ** regardless of the value of expr1.
+ */
+ sql_expr_free(pParse->db, yymsp[-4].minor.yy162.pExpr, false);
+ yymsp[-4].minor.yy162.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER,&sqlite3IntTokens[yymsp[-3].minor.yy52],1);
+ }else if( yymsp[-1].minor.yy382->nExpr==1 ){
+ /* Expressions of the form:
+ **
+ ** expr1 IN (?1)
+ ** expr1 NOT IN (?2)
+ **
+ ** with exactly one value on the RHS can be simplified to something
+ ** like this:
+ **
+ ** expr1 == ?1
+ ** expr1 <> ?2
+ **
+ ** But, the RHS of the == or <> is marked with the EP_Generic flag
+ ** so that it may not contribute to the computation of comparison
+ ** affinity or the collating sequence to use for comparison. Otherwise,
+ ** the semantics would be subtly different from IN or NOT IN.
+ */
+ Expr *pRHS = yymsp[-1].minor.yy382->a[0].pExpr;
+ yymsp[-1].minor.yy382->a[0].pExpr = 0;
+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy382);
+ /* pRHS cannot be NULL because a malloc error would have been detected
+ ** before now and control would have never reached this point */
+ if( ALWAYS(pRHS) ){
+ pRHS->flags &= ~EP_Collate;
+ pRHS->flags |= EP_Generic;
+ }
+ yymsp[-4].minor.yy162.pExpr = sqlite3PExpr(pParse, yymsp[-3].minor.yy52 ? TK_NE : TK_EQ, yymsp[-4].minor.yy162.pExpr, pRHS);
+ }else{
+ yymsp[-4].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy162.pExpr, 0);
+ if( yymsp[-4].minor.yy162.pExpr ){
+ yymsp[-4].minor.yy162.pExpr->x.pList = yymsp[-1].minor.yy382;
+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy162.pExpr);
+ }else{
+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy382);
+ }
+ exprNot(pParse, yymsp[-3].minor.yy52, &yymsp[-4].minor.yy162);
+ }
+ yymsp[-4].minor.yy162.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
+}
+#line 3308 "parse.c"
+ break;
+ case 185: /* expr ::= LP select RP */
+#line 1163 "parse.y"
+{
+ spanSet(&yymsp[-2].minor.yy162,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-B*/
+ yymsp[-2].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
+ sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy162.pExpr, yymsp[-1].minor.yy279);
+}
+#line 3317 "parse.c"
+ break;
+ case 186: /* expr ::= expr in_op LP select RP */
+#line 1168 "parse.y"
+{
+ yymsp[-4].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy162.pExpr, 0);
+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy162.pExpr, yymsp[-1].minor.yy279);
+ exprNot(pParse, yymsp[-3].minor.yy52, &yymsp[-4].minor.yy162);
+ yymsp[-4].minor.yy162.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
+}
+#line 3327 "parse.c"
+ break;
+ case 187: /* expr ::= expr in_op nm paren_exprlist */
+#line 1174 "parse.y"
+{
+ SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0);
+ Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
+ if( yymsp[0].minor.yy382 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy382);
+ yymsp[-3].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy162.pExpr, 0);
+ sqlite3PExprAddSelect(pParse, yymsp[-3].minor.yy162.pExpr, pSelect);
+ exprNot(pParse, yymsp[-2].minor.yy52, &yymsp[-3].minor.yy162);
+ yymsp[-3].minor.yy162.zEnd = &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
+}
+#line 3340 "parse.c"
+ break;
+ case 188: /* expr ::= EXISTS LP select RP */
+#line 1183 "parse.y"
+{
+ Expr *p;
+ spanSet(&yymsp[-3].minor.yy162,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-B*/
+ p = yymsp[-3].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
+ sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy279);
+}
+#line 3350 "parse.c"
+ break;
+ case 189: /* expr ::= CASE case_operand case_exprlist case_else END */
+#line 1191 "parse.y"
+{
+ spanSet(&yymsp[-4].minor.yy162,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-C*/
+ yymsp[-4].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy362, 0);
+ if( yymsp[-4].minor.yy162.pExpr ){
+ yymsp[-4].minor.yy162.pExpr->x.pList = yymsp[-1].minor.yy362 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy382,yymsp[-1].minor.yy362) : yymsp[-2].minor.yy382;
+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy162.pExpr);
+ }else{
+ sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy382);
+ sql_expr_free(pParse->db, yymsp[-1].minor.yy362, false);
+ }
+}
+#line 3365 "parse.c"
+ break;
+ case 190: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
+#line 1204 "parse.y"
+{
+ yymsp[-4].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy382, yymsp[-2].minor.yy162.pExpr);
+ yymsp[-4].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy382, yymsp[0].minor.yy162.pExpr);
+}
+#line 3373 "parse.c"
+ break;
+ case 191: /* case_exprlist ::= WHEN expr THEN expr */
+#line 1208 "parse.y"
+{
+ yymsp[-3].minor.yy382 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy162.pExpr);
+ yymsp[-3].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy382, yymsp[0].minor.yy162.pExpr);
+}
+#line 3381 "parse.c"
+ break;
+ case 194: /* case_operand ::= expr */
+#line 1218 "parse.y"
+{yymsp[0].minor.yy362 = yymsp[0].minor.yy162.pExpr; /*A-overwrites-X*/}
+#line 3386 "parse.c"
+ break;
+ case 197: /* nexprlist ::= nexprlist COMMA expr */
+#line 1229 "parse.y"
+{yymsp[-2].minor.yy382 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy382,yymsp[0].minor.yy162.pExpr);}
+#line 3391 "parse.c"
+ break;
+ case 198: /* nexprlist ::= expr */
+#line 1231 "parse.y"
+{yymsp[0].minor.yy382 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy162.pExpr); /*A-overwrites-Y*/}
+#line 3396 "parse.c"
+ break;
+ case 200: /* paren_exprlist ::= LP exprlist RP */
+ case 205: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==205);
+#line 1238 "parse.y"
+{yymsp[-2].minor.yy382 = yymsp[-1].minor.yy382;}
+#line 3402 "parse.c"
+ break;
+ case 201: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm ON nm LP sortlist RP */
+#line 1244 "parse.y"
+{
+ sqlite3CreateIndex(pParse, &yymsp[-5].minor.yy0,
+ sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0), yymsp[-1].minor.yy382, yymsp[-8].minor.yy52,
+ &yymsp[-9].minor.yy0, 0, SQLITE_SO_ASC, yymsp[-6].minor.yy52, SQLITE_IDXTYPE_APPDEF);
+}
+#line 3411 "parse.c"
+ break;
+ case 202: /* uniqueflag ::= UNIQUE */
+ case 243: /* raisetype ::= ABORT */ yytestcase(yyruleno==243);
+#line 1251 "parse.y"
+{yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_ABORT;}
+#line 3417 "parse.c"
+ break;
+ case 203: /* uniqueflag ::= */
+#line 1252 "parse.y"
+{yymsp[1].minor.yy52 = ON_CONFLICT_ACTION_NONE;}
+#line 3422 "parse.c"
+ break;
+ case 206: /* eidlist ::= eidlist COMMA nm collate sortorder */
+#line 1295 "parse.y"
+{
+ yymsp[-4].minor.yy382 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy382, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy52, yymsp[0].minor.yy52);
+}
+#line 3429 "parse.c"
+ break;
+ case 207: /* eidlist ::= nm collate sortorder */
+#line 1298 "parse.y"
+{
+ yymsp[-2].minor.yy382 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy52, yymsp[0].minor.yy52); /*A-overwrites-Y*/
+}
+#line 3436 "parse.c"
+ break;
+ case 210: /* cmd ::= DROP INDEX ifexists fullname ON nm */
+#line 1309 "parse.y"
+{
+ sql_drop_index(pParse, yymsp[-2].minor.yy387, &yymsp[0].minor.yy0, yymsp[-3].minor.yy52);
+}
+#line 3443 "parse.c"
+ break;
+ case 211: /* cmd ::= PRAGMA nm */
+#line 1316 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[0].minor.yy0,0,0,0);
+}
+#line 3450 "parse.c"
+ break;
+ case 212: /* cmd ::= PRAGMA nm EQ nmnum */
+#line 1319 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0,0);
+}
+#line 3457 "parse.c"
+ break;
+ case 213: /* cmd ::= PRAGMA nm LP nmnum RP */
+#line 1322 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0,0);
+}
+#line 3464 "parse.c"
+ break;
+ case 214: /* cmd ::= PRAGMA nm EQ minus_num */
+#line 1325 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0,1);
+}
+#line 3471 "parse.c"
+ break;
+ case 215: /* cmd ::= PRAGMA nm LP minus_num RP */
+#line 1328 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0,1);
+}
+#line 3478 "parse.c"
+ break;
+ case 216: /* cmd ::= PRAGMA nm EQ nm DOT nm */
+#line 1331 "parse.y"
+{
+ sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0,0);
+}
+#line 3485 "parse.c"
+ break;
+ case 217: /* cmd ::= PRAGMA */
+#line 1334 "parse.y"
+{
+ sqlite3Pragma(pParse, 0,0,0,0);
+}
+#line 3492 "parse.c"
+ break;
+ case 220: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+#line 1354 "parse.y"
+{
+ Token all;
+ all.z = yymsp[-3].minor.yy0.z;
+ all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
+ pParse->initiateTTrans = false;
+ sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
+}
+#line 3503 "parse.c"
+ break;
+ case 221: /* trigger_decl ::= TRIGGER ifnotexists nm trigger_time trigger_event ON fullname foreach_clause when_clause */
+#line 1364 "parse.y"
+{
+ sqlite3BeginTrigger(pParse, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy52, yymsp[-4].minor.yy10.a, yymsp[-4].minor.yy10.b, yymsp[-2].minor.yy387, yymsp[0].minor.yy362, yymsp[-7].minor.yy52);
+ yymsp[-8].minor.yy0 = yymsp[-6].minor.yy0; /*yymsp[-8].minor.yy0-overwrites-T*/
+}
+#line 3511 "parse.c"
+ break;
+ case 222: /* trigger_time ::= BEFORE */
+#line 1370 "parse.y"
+{ yymsp[0].minor.yy52 = TK_BEFORE; }
+#line 3516 "parse.c"
+ break;
+ case 223: /* trigger_time ::= AFTER */
+#line 1371 "parse.y"
+{ yymsp[0].minor.yy52 = TK_AFTER; }
+#line 3521 "parse.c"
+ break;
+ case 224: /* trigger_time ::= INSTEAD OF */
+#line 1372 "parse.y"
+{ yymsp[-1].minor.yy52 = TK_INSTEAD;}
+#line 3526 "parse.c"
+ break;
+ case 225: /* trigger_time ::= */
+#line 1373 "parse.y"
+{ yymsp[1].minor.yy52 = TK_BEFORE; }
+#line 3531 "parse.c"
+ break;
+ case 226: /* trigger_event ::= DELETE|INSERT */
+ case 227: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==227);
+#line 1377 "parse.y"
+{yymsp[0].minor.yy10.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy10.b = 0;}
+#line 3537 "parse.c"
+ break;
+ case 228: /* trigger_event ::= UPDATE OF idlist */
+#line 1379 "parse.y"
+{yymsp[-2].minor.yy10.a = TK_UPDATE; yymsp[-2].minor.yy10.b = yymsp[0].minor.yy40;}
+#line 3542 "parse.c"
+ break;
+ case 229: /* when_clause ::= */
+#line 1386 "parse.y"
+{ yymsp[1].minor.yy362 = 0; }
+#line 3547 "parse.c"
+ break;
+ case 230: /* when_clause ::= WHEN expr */
+#line 1387 "parse.y"
+{ yymsp[-1].minor.yy362 = yymsp[0].minor.yy162.pExpr; }
+#line 3552 "parse.c"
+ break;
+ case 231: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+#line 1391 "parse.y"
+{
+ assert( yymsp[-2].minor.yy427!=0 );
+ yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
+ yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
+}
+#line 3561 "parse.c"
+ break;
+ case 232: /* trigger_cmd_list ::= trigger_cmd SEMI */
+#line 1396 "parse.y"
+{
+ assert( yymsp[-1].minor.yy427!=0 );
+ yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
+}
+#line 3569 "parse.c"
+ break;
+ case 233: /* trnm ::= nm DOT nm */
+#line 1407 "parse.y"
+{
+ yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
+ sqlite3ErrorMsg(pParse,
+ "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
+ "statements within triggers");
+}
+#line 3579 "parse.c"
+ break;
+ case 234: /* tridxby ::= INDEXED BY nm */
+#line 1419 "parse.y"
+{
+ sqlite3ErrorMsg(pParse,
+ "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
+ "within triggers");
+}
+#line 3588 "parse.c"
+ break;
+ case 235: /* tridxby ::= NOT INDEXED */
+#line 1424 "parse.y"
+{
+ sqlite3ErrorMsg(pParse,
+ "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
+ "within triggers");
+}
+#line 3597 "parse.c"
+ break;
+ case 236: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
+#line 1437 "parse.y"
+{yymsp[-6].minor.yy427 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy382, yymsp[0].minor.yy362, yymsp[-5].minor.yy52);}
+#line 3602 "parse.c"
+ break;
+ case 237: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
+#line 1441 "parse.y"
+{yymsp[-4].minor.yy427 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy40, yymsp[0].minor.yy279, yymsp[-4].minor.yy52);/*A-overwrites-R*/}
+#line 3607 "parse.c"
+ break;
+ case 238: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
+#line 1445 "parse.y"
+{yymsp[-4].minor.yy427 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy362);}
+#line 3612 "parse.c"
+ break;
+ case 239: /* trigger_cmd ::= select */
+#line 1449 "parse.y"
+{yymsp[0].minor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy279); /*A-overwrites-X*/}
+#line 3617 "parse.c"
+ break;
+ case 240: /* expr ::= RAISE LP IGNORE RP */
+#line 1452 "parse.y"
+{
+ spanSet(&yymsp[-3].minor.yy162,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/
+ yymsp[-3].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
+ if( yymsp[-3].minor.yy162.pExpr ){
+ yymsp[-3].minor.yy162.pExpr->affinity = ON_CONFLICT_ACTION_IGNORE;
+ }
+}
+#line 3628 "parse.c"
+ break;
+ case 241: /* expr ::= RAISE LP raisetype COMMA STRING RP */
+#line 1459 "parse.y"
+{
+ spanSet(&yymsp[-5].minor.yy162,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/
+ yymsp[-5].minor.yy162.pExpr = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
+ if( yymsp[-5].minor.yy162.pExpr ) {
+ yymsp[-5].minor.yy162.pExpr->affinity = (char)yymsp[-3].minor.yy52;
+ }
+}
+#line 3639 "parse.c"
+ break;
+ case 242: /* raisetype ::= ROLLBACK */
+#line 1469 "parse.y"
+{yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_ROLLBACK;}
+#line 3644 "parse.c"
+ break;
+ case 244: /* raisetype ::= FAIL */
+#line 1471 "parse.y"
+{yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_FAIL;}
+#line 3649 "parse.c"
+ break;
+ case 245: /* cmd ::= DROP TRIGGER ifexists fullname */
+#line 1476 "parse.y"
+{
+ sqlite3DropTrigger(pParse,yymsp[0].minor.yy387,yymsp[-1].minor.yy52);
+}
+#line 3656 "parse.c"
+ break;
+ case 246: /* cmd ::= ANALYZE */
+#line 1491 "parse.y"
+{sqlite3Analyze(pParse, 0);}
+#line 3661 "parse.c"
+ break;
+ case 247: /* cmd ::= ANALYZE nm */
+#line 1492 "parse.y"
+{sqlite3Analyze(pParse, &yymsp[0].minor.yy0);}
+#line 3666 "parse.c"
+ break;
+ case 248: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
+#line 1497 "parse.y"
+{
+ sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy387,&yymsp[0].minor.yy0);
+}
+#line 3673 "parse.c"
+ break;
+ case 249: /* with ::= */
+#line 1520 "parse.y"
+{yymsp[1].minor.yy151 = 0;}
+#line 3678 "parse.c"
+ break;
+ case 250: /* with ::= WITH wqlist */
+#line 1522 "parse.y"
+{ yymsp[-1].minor.yy151 = yymsp[0].minor.yy151; }
+#line 3683 "parse.c"
+ break;
+ case 251: /* with ::= WITH RECURSIVE wqlist */
+#line 1523 "parse.y"
+{ yymsp[-2].minor.yy151 = yymsp[0].minor.yy151; }
+#line 3688 "parse.c"
+ break;
+ case 252: /* wqlist ::= nm eidlist_opt AS LP select RP */
+#line 1525 "parse.y"
+{
+ yymsp[-5].minor.yy151 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy382, yymsp[-1].minor.yy279); /*A-overwrites-X*/
+}
+#line 3695 "parse.c"
+ break;
+ case 253: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
+#line 1528 "parse.y"
+{
+ yymsp[-7].minor.yy151 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy151, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy382, yymsp[-1].minor.yy279);
+}
+#line 3702 "parse.c"
+ break;
+ default:
+ /* (254) input ::= ecmd */ yytestcase(yyruleno==254);
+ /* (255) explain ::= */ yytestcase(yyruleno==255);
+ /* (256) cmdx ::= cmd (OPTIMIZED OUT) */ assert(yyruleno!=256);
+ /* (257) trans_opt ::= */ yytestcase(yyruleno==257);
+ /* (258) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==258);
+ /* (259) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==259);
+ /* (260) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==260);
+ /* (261) savepoint_opt ::= */ yytestcase(yyruleno==261);
+ /* (262) cmd ::= create_table create_table_args */ yytestcase(yyruleno==262);
+ /* (263) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==263);
+ /* (264) columnlist ::= columnname carglist */ yytestcase(yyruleno==264);
+ /* (265) typetoken ::= typename */ yytestcase(yyruleno==265);
+ /* (266) typename ::= ID|STRING */ yytestcase(yyruleno==266);
+ /* (267) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=267);
+ /* (268) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=268);
+ /* (269) carglist ::= carglist ccons */ yytestcase(yyruleno==269);
+ /* (270) carglist ::= */ yytestcase(yyruleno==270);
+ /* (271) ccons ::= NULL onconf */ yytestcase(yyruleno==271);
+ /* (272) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==272);
+ /* (273) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==273);
+ /* (274) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=274);
+ /* (275) tconscomma ::= */ yytestcase(yyruleno==275);
+ /* (276) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=276);
+ /* (277) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=277);
+ /* (278) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=278);
+ /* (279) oneselect ::= values */ yytestcase(yyruleno==279);
+ /* (280) sclp ::= selcollist COMMA */ yytestcase(yyruleno==280);
+ /* (281) as ::= ID|STRING */ yytestcase(yyruleno==281);
+ /* (282) join_nm ::= ID|INDEXED */ yytestcase(yyruleno==282);
+ /* (283) join_nm ::= JOIN_KW */ yytestcase(yyruleno==283);
+ /* (284) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=284);
+ /* (285) exprlist ::= nexprlist */ yytestcase(yyruleno==285);
+ /* (286) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=286);
+ /* (287) nmnum ::= STRING */ yytestcase(yyruleno==287);
+ /* (288) nmnum ::= nm */ yytestcase(yyruleno==288);
+ /* (289) nmnum ::= ON */ yytestcase(yyruleno==289);
+ /* (290) nmnum ::= DELETE */ yytestcase(yyruleno==290);
+ /* (291) nmnum ::= DEFAULT */ yytestcase(yyruleno==291);
+ /* (292) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==292);
+ /* (293) foreach_clause ::= */ yytestcase(yyruleno==293);
+ /* (294) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==294);
+ /* (295) trnm ::= nm */ yytestcase(yyruleno==295);
+ /* (296) tridxby ::= */ yytestcase(yyruleno==296);
+ break;
+/********** End reduce actions ************************************************/
+ };
+ assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+ yygoto = yyRuleInfo[yyruleno].lhs;
+ yysize = yyRuleInfo[yyruleno].nrhs;
+ yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
+ if( yyact <= YY_MAX_SHIFTREDUCE ){
+ if( yyact>YY_MAX_SHIFT ){
+ yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
+ }
+ yymsp -= yysize-1;
+ yypParser->yytos = yymsp;
+ yymsp->stateno = (YYACTIONTYPE)yyact;
+ yymsp->major = (YYCODETYPE)yygoto;
+ yyTraceShift(yypParser, yyact);
+ }else{
+ assert( yyact == YY_ACCEPT_ACTION );
+ yypParser->yytos -= yysize;
+ yy_accept(yypParser);
+ }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+ yyParser *yypParser /* The parser */
+){
+ sqlite3ParserARG_FETCH;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will be executed whenever the
+ ** parser fails */
+/************ Begin %parse_failure code ***************************************/
+/************ End %parse_failure code *****************************************/
+ sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+ yyParser *yypParser, /* The parser */
+ int yymajor, /* The major type of the error token */
+ sqlite3ParserTOKENTYPE yyminor /* The minor type of the error token */
+){
+ sqlite3ParserARG_FETCH;
+#define TOKEN yyminor
+/************ Begin %syntax_error code ****************************************/
+#line 32 "parse.y"
+
+ UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */
+ assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */
+ if (yypParser->is_fallback_failed && TOKEN.isReserved) {
+ sqlite3ErrorMsg(pParse, "keyword \"%T\" is reserved", &TOKEN);
+ } else {
+ sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
+ }
+#line 3813 "parse.c"
+/************ End %syntax_error code ******************************************/
+ sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+ yyParser *yypParser /* The parser */
+){
+ sqlite3ParserARG_FETCH;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+ }
+#endif
+#ifndef YYNOERRORRECOVERY
+ yypParser->yyerrcnt = -1;
+#endif
+ assert( yypParser->yytos==yypParser->yystack );
+ /* Here code is inserted which will be executed whenever the
+ ** parser accepts */
+/*********** Begin %parse_accept code *****************************************/
+/*********** End %parse_accept code *******************************************/
+ sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "sqlite3ParserAlloc" which describes the current state of the parser.
+** The second argument is the major token number. The third is
+** the minor token. The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void sqlite3Parser(
+ void *yyp, /* The parser */
+ int yymajor, /* The major token code number */
+ sqlite3ParserTOKENTYPE yyminor /* The value for the token */
+ sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */
+){
+ YYMINORTYPE yyminorunion;
+ unsigned int yyact; /* The parser action. */
+#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+ int yyendofinput; /* True if we are at the end of input */
+#endif
+#ifdef YYERRORSYMBOL
+ int yyerrorhit = 0; /* True if yymajor has invoked an error */
+#endif
+ yyParser *yypParser; /* The parser */
+
+ yypParser = (yyParser*)yyp;
+ assert( yypParser->yytos!=0 );
+#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+ yyendofinput = (yymajor==0);
+#endif
+ sqlite3ParserARG_STORE;
+
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sInput '%s'\n",yyTracePrompt,yyTokenName[yymajor]);
+ }
+#endif
+
+ do{
+ yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
+ if( yyact <= YY_MAX_SHIFTREDUCE ){
+ yy_shift(yypParser,yyact,yymajor,yyminor);
+#ifndef YYNOERRORRECOVERY
+ yypParser->yyerrcnt--;
+#endif
+ yymajor = YYNOCODE;
+ }else if( yyact <= YY_MAX_REDUCE ){
+ yy_reduce(yypParser,yyact-YY_MIN_REDUCE);
+ }else{
+ assert( yyact == YY_ERROR_ACTION );
+ yyminorunion.yy0 = yyminor;
+#ifdef YYERRORSYMBOL
+ int yymx;
+#endif
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+ }
+#endif
+#ifdef YYERRORSYMBOL
+ /* A syntax error has occurred.
+ ** The response to an error depends upon whether or not the
+ ** grammar defines an error token "ERROR".
+ **
+ ** This is what we do if the grammar does define ERROR:
+ **
+ ** * Call the %syntax_error function.
+ **
+ ** * Begin popping the stack until we enter a state where
+ ** it is legal to shift the error symbol, then shift
+ ** the error symbol.
+ **
+ ** * Set the error count to three.
+ **
+ ** * Begin accepting and shifting new tokens. No new error
+ ** processing will occur until three tokens have been
+ ** shifted successfully.
+ **
+ */
+ if( yypParser->yyerrcnt<0 ){
+ yy_syntax_error(yypParser,yymajor,yyminor);
+ }
+ yymx = yypParser->yytos->major;
+ if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+ yyTracePrompt,yyTokenName[yymajor]);
+ }
+#endif
+ yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+ yymajor = YYNOCODE;
+ }else{
+ while( yypParser->yytos >= yypParser->yystack
+ && yymx != YYERRORSYMBOL
+ && (yyact = yy_find_reduce_action(
+ yypParser->yytos->stateno,
+ YYERRORSYMBOL)) >= YY_MIN_REDUCE
+ ){
+ yy_pop_parser_stack(yypParser);
+ }
+ if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ yy_parse_failed(yypParser);
+#ifndef YYNOERRORRECOVERY
+ yypParser->yyerrcnt = -1;
+#endif
+ yymajor = YYNOCODE;
+ }else if( yymx!=YYERRORSYMBOL ){
+ yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
+ }
+ }
+ yypParser->yyerrcnt = 3;
+ yyerrorhit = 1;
+#elif defined(YYNOERRORRECOVERY)
+ /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+ ** do any kind of error recovery. Instead, simply invoke the syntax
+ ** error routine and continue going as if nothing had happened.
+ **
+ ** Applications can set this macro (for example inside %include) if
+ ** they intend to abandon the parse upon the first syntax error seen.
+ */
+ yy_syntax_error(yypParser,yymajor, yyminor);
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ yymajor = YYNOCODE;
+
+#else /* YYERRORSYMBOL is not defined */
+ /* This is what we do if the grammar does not define ERROR:
+ **
+ ** * Report an error message, and throw away the input token.
+ **
+ ** * If the input token is $, then fail the parse.
+ **
+ ** As before, subsequent error messages are suppressed until
+ ** three input tokens have been successfully shifted.
+ */
+ if( yypParser->yyerrcnt<=0 ){
+ yy_syntax_error(yypParser,yymajor, yyminor);
+ }
+ yypParser->yyerrcnt = 3;
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ if( yyendofinput ){
+ yy_parse_failed(yypParser);
+#ifndef YYNOERRORRECOVERY
+ yypParser->yyerrcnt = -1;
+#endif
+ }
+ yymajor = YYNOCODE;
+#endif
+ }
+ }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ yyStackEntry *i;
+ char cDiv = '[';
+ fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
+ for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
+ fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
+ cDiv = ' ';
+ }
+ fprintf(yyTraceFILE,"]\n");
+ }
+#endif
+ return;
+}
diff --git a/src/box/sql/parse.y b/src/box/sql/parse.y
index b078e20..e0b5a2e 100644
--- a/src/box/sql/parse.y
+++ b/src/box/sql/parse.y
@@ -1241,10 +1241,10 @@ paren_exprlist(A) ::= LP exprlist(X) RP. {A = X;}
///////////////////////////// The CREATE INDEX command ///////////////////////
//
cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X)
- ON nm(Y) LP sortlist(Z) RP where_opt(W). {
+ ON nm(Y) LP sortlist(Z) RP. {
sqlite3CreateIndex(pParse, &X,
sqlite3SrcListAppend(pParse->db,0,&Y), Z, U,
- &S, W, SQLITE_SO_ASC, NE, SQLITE_IDXTYPE_APPDEF);
+ &S, 0, SQLITE_SO_ASC, NE, SQLITE_IDXTYPE_APPDEF);
}
%type uniqueflag {int}
diff --git a/test/sql-tap/analyze9.test.lua b/test/sql-tap/analyze9.test.lua
index 4ce575e..3668211 100755
--- a/test/sql-tap/analyze9.test.lua
+++ b/test/sql-tap/analyze9.test.lua
@@ -1111,7 +1111,7 @@ test:do_test(
test:execsql([[
DROP TABLE IF EXISTS t1;
CREATE TABLE t1(id INTEGER PRIMARY KEY AUTOINCREMENT, a, b, c, d);
- CREATE INDEX i1 ON t1(a, b) WHERE d IS NOT NULL;
+ CREATE INDEX i1 ON t1(a, b);
INSERT INTO t1 VALUES(null, -1, -1, -1, NULL);
INSERT INTO t1 SELECT null, 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT null, 2*a,2*b,2*c,d FROM t1;
diff --git a/test/sql-tap/autoindex4.test.lua b/test/sql-tap/autoindex4.test.lua
index 45bae48..a567c5e 100755
--- a/test/sql-tap/autoindex4.test.lua
+++ b/test/sql-tap/autoindex4.test.lua
@@ -111,7 +111,7 @@ test:do_execsql_test(
test:do_execsql_test(
"autoindex4-3.1",
[[
- CREATE INDEX Items_x1 ON Items(ItemName,Name) WHERE ItemName = 'dummy';
+ CREATE INDEX Items_x1 ON Items(ItemName,Name);
SELECT Items.ItemName
FROM Items
diff --git a/test/sql-tap/fkey1.test.lua b/test/sql-tap/fkey1.test.lua
index 8749e1f..bca82d9 100755
--- a/test/sql-tap/fkey1.test.lua
+++ b/test/sql-tap/fkey1.test.lua
@@ -212,7 +212,7 @@ test:do_execsql_test(
"fkey1-6.1",
[[
CREATE TABLE p1(id PRIMARY KEY, x, y);
- CREATE UNIQUE INDEX p1x ON p1(x) WHERE y<2;
+ CREATE INDEX p1x ON p1(x);
INSERT INTO p1 VALUES(1, 1, 1);
CREATE TABLE c1(a PRIMARY KEY REFERENCES p1(x));
]], {
diff --git a/test/sql-tap/gh-2165-remove-support-partial-indexes.test.lua b/test/sql-tap/gh-2165-remove-support-partial-indexes.test.lua
new file mode 100644
index 0000000..d8210fc
--- /dev/null
+++ b/test/sql-tap/gh-2165-remove-support-partial-indexes.test.lua
@@ -0,0 +1,17 @@
+#!/usr/bin/env tarantool
+test = require("sqltester")
+
+test:plan(1)
+
+
+test:do_catchsql_test(
+ "partial-index-1",
+ [[
+ CREATE TABLE t1 (a INTEGER PRIMARY KEY, b INTEGER)
+ CREATE UNIQUE INDEX i ON t1 (a) WHERE a = 3;
+ ]], {
+ 1, "keyword \"CREATE\" is reserved"
+ })
+
+--This test intended to be deleted in #2626
+test:finish_test()
diff --git a/test/sql-tap/index6.test.lua b/test/sql-tap/index6.test.lua
index 2aa97e8..069623f 100755
--- a/test/sql-tap/index6.test.lua
+++ b/test/sql-tap/index6.test.lua
@@ -225,7 +225,7 @@ test:do_execsql_test(
"index6-6.0",
[[
CREATE TABLE t6(a,b, PRIMARY KEY (a,b));
- CREATE INDEX t6b ON t6(b) WHERE b=1;
+ CREATE INDEX t6b ON t6(b);
INSERT INTO t6(a,b) VALUES(123,456);
SELECT * FROM t6;
]], {
@@ -262,7 +262,7 @@ test:do_execsql_test(
CREATE TABLE t7a(id primary key, x);
CREATE TABLE t7b(id primary key, y);
INSERT INTO t7a VALUES(1, 1);
- CREATE INDEX t7ax ON t7a(x) WHERE x=99;
+ CREATE INDEX t7ax ON t7a(x);
SELECT x,y FROM t7a LEFT JOIN t7b ON (x=99) ORDER BY x;
]], {
-- <index6-7.0>
@@ -318,7 +318,7 @@ test:do_execsql_test(
[[
CREATE TABLE t8a(id primary key, a,b);
CREATE TABLE t8b(id primary key, x,y);
- CREATE INDEX i8c ON t8b(y) WHERE x = 'value';
+ CREATE INDEX i8c ON t8b(y);
INSERT INTO t8a VALUES(1, 1, 'one');
INSERT INTO t8a VALUES(2, 2, 'two');
@@ -364,7 +364,7 @@ if (0 > 0)
"index6-9.1",
[[
CREATE TABLE t9(a int, b int, c int);
- CREATE INDEX t9ca ON t9(c,a) WHERE a in (10,12,20);
+ CREATE INDEX t9ca ON t9(c,a);
INSERT INTO t9 VALUES(1,1,9),(10,2,35),(11,15,82),(20,19,5),(NULL,7,3);
UPDATE t9 SET b=c WHERE a in (10,12,20);
SELECT a,b,c,'|' FROM t9 ORDER BY a;
@@ -379,7 +379,7 @@ test:do_execsql_test(
[[
--DROP TABLE t9;
CREATE TABLE t9(a int, b int, c int, PRIMARY KEY(a));
- CREATE INDEX t9ca ON t9(c,a) WHERE a in (10,12,20);
+ CREATE INDEX t9ca ON t9(c,a);
INSERT INTO t9 VALUES(1,1,9),(10,2,35),(11,15,82),(20,19,5);
UPDATE t9 SET b=c WHERE a in (10,12,20);
SELECT a,b,c,'|' FROM t9 ORDER BY a;
@@ -400,7 +400,7 @@ test:do_execsql_test(
(2,3,4,5,6),
(3,4,5,6,7),
(1,2,3,8,9);
- CREATE INDEX t10x ON t10(d) WHERE a=1 AND b=2 AND c=3;
+ CREATE INDEX t10x ON t10(d);
SELECT e FROM t10 WHERE a=1 AND b=2 AND c=3 ORDER BY d;
]], {
-- <index6-10.1>
diff --git a/test/sql-tap/index7.test.lua b/test/sql-tap/index7.test.lua
index c8f56eb..c194859 100755
--- a/test/sql-tap/index7.test.lua
+++ b/test/sql-tap/index7.test.lua
@@ -1,6 +1,6 @@
#!/usr/bin/env tarantool
test = require("sqltester")
-test:plan(5)
+test:plan(4)
--!./tcltestrunner.lua
-- 2013-11-04
@@ -261,7 +261,7 @@ test:do_execsql_test(
test:do_execsql_test(
"index7-6.2",
[[
- CREATE INDEX i4 ON t4(c) WHERE d='xyz';
+ CREATE INDEX i4 ON t4(c);
SELECT a,b,c,d FROM (SELECT a,b FROM t5 WHERE a=1 AND b='xyz'), t4 WHERE c='abc';
]], {
-- <index7-6.2>
@@ -291,14 +291,15 @@ test:do_eqp_test(
-- </index7-6.4>
})
-test:do_catchsql_test(
- "index7-6.5",
- [[
- CREATE INDEX t5a ON t5(a) WHERE a=#1;
- ]], {
- -- <index7-6.5>
- 1, [[near "#1": syntax error]]
- -- </index7-6.5>
- })
-
+--test:do_catchsql_test(
+-- "index7-6.5",
+-- [[
+-- CREATE INDEX t5a ON t5(a) WHERE a=#1;
+-- ]], {
+-- -- <index7-6.5>
+-- 1, [[near "#1": syntax error]]
+-- -- </index7-6.5>
+-- })
+-- this test checks incorrect syntax of partial indexes
+-- to be enabled after #2626
test:finish_test()
--
2.7.4
^ permalink raw reply [flat|nested] 5+ messages in thread
* [tarantool-patches] Re: [PATCH v3] sql: remove support of partial indexes
2018-04-24 18:39 [tarantool-patches] [PATCH v3] sql: remove support of partial indexes Gleb
@ 2018-04-25 9:22 ` Alexander Turenko
0 siblings, 0 replies; 5+ messages in thread
From: Alexander Turenko @ 2018-04-25 9:22 UTC (permalink / raw)
To: Gleb Skiba; +Cc: tarantool-patches
Hi Gleb!
Firstly, don't add autogenerated files like parse.c under version
control.
Add a person you want to respond you into 'To' header and others
(including mailing list) in 'Cc'. Just sending a message to the mailing
list doesn't trigger any review processes.
Send a message with open email to allow direct reply you (not through
mailing list). Here your email is shown as dmarc-noreply@freelists.org.
Please, fix the patch and ask me for review again.
WBR, Alexander Turenko.
On Tue, Apr 24, 2018 at 09:39:07PM +0300, Gleb wrote:
> Remove support of partial indexes.
> Add test which checks inaccessibility of partial index syntax.
> Delete usage of partial index from tests.
> They can be enabled after #2626.
>
> Fixes #2165
> ---
> Issue from https://github.com/tarantool/tarantool/issues/2165.
> Source from https://github.com/tarantool/tarantool/tree/gh-2165-remove-support-partial-indexes.
> Changes in v3:
> -return tests which use partial.
> -delete "WHERE" from returned tests.
> -correct syntax errors in commit
^ permalink raw reply [flat|nested] 5+ messages in thread
* [tarantool-patches] Re: [PATCH v3] sql: remove support of partial indexes
2018-04-25 15:44 ` n.pettik
@ 2018-04-26 9:02 ` Kirill Yukhin
0 siblings, 0 replies; 5+ messages in thread
From: Kirill Yukhin @ 2018-04-26 9:02 UTC (permalink / raw)
To: n.pettik; +Cc: tarantool-patches, Alexander Turenko, gleb-skiba
Hello,
On 25 апр 18:44, n.pettik wrote:
>
> > LGTM. Nikita, can you look?
>
> Hello. Generally speaking, patch looks OK to me as well.
>
> I don’t like error message: it is possible to make it more
> intelligible. To do it, you need to left parser as is, but in
> sqlite3CreateIndex() check that ‘WHERE’ arg is empty.
> On the other hand, this is temporary ban and to enable this
> feature back, it is enough to revert this patch, so never mind.
New test fails for me:
/export/kyukhin/tarantool/src/test$ ./test-run.py --builddir ../../bld sql-tap/gh-2165-remove-support-partial-indexes.test.lua
======================================================================================
WORKR TEST PARAMS RESULT
---------------------------------------------------------------------------------
Traceback (most recent call last):
File "/usr/lib/python2.7/dist-packages/gevent/greenlet.py", line 534, in run
result = self._run(*self.args, **self.kwargs)
File "/export/kyukhin/tarantool/src/test-run/lib/test.py", line 38, in _run
self.callable(*self.callable_args, **self.callable_kwargs)
File "/export/kyukhin/tarantool/src/test-run/lib/app_server.py", line 18, in run_server
server.process = Popen(execs, stdout=PIPE, stderr=PIPE, cwd=cwd)
File "/usr/lib/python2.7/dist-packages/gevent/subprocess.py", line 534, in __init__
reraise(*exc_info)
File "/usr/lib/python2.7/dist-packages/gevent/subprocess.py", line 503, in __init__
restore_signals, start_new_session)
File "/usr/lib/python2.7/dist-packages/gevent/subprocess.py", line 1253, in _execute_child
raise child_exception
OSError: [Errno 13] Permission denied
<TestRunGreenlet at 0x7f25b3d20730 info='None'> failed with OSError
[001] sql-tap/gh-2165-remove-support-partial-indexes.test.lua
[001] TAP13 parse failed: Missing plan in the TAP source
[001] [ new ]
---------------------------------------------------------------------------------
Statistics:
* new: 1
--
Regards, Kirill Yukhin
^ permalink raw reply [flat|nested] 5+ messages in thread
* [tarantool-patches] Re: [PATCH v3] sql: remove support of partial indexes
2018-04-25 15:17 ` [tarantool-patches] " Alexander Turenko
@ 2018-04-25 15:44 ` n.pettik
2018-04-26 9:02 ` Kirill Yukhin
0 siblings, 1 reply; 5+ messages in thread
From: n.pettik @ 2018-04-25 15:44 UTC (permalink / raw)
To: tarantool-patches
Cc: Alexander Turenko, gleb-skiba,
Кирилл
Юхин
> LGTM. Nikita, can you look?
Hello. Generally speaking, patch looks OK to me as well.
I don’t like error message: it is possible to make it more
intelligible. To do it, you need to left parser as is, but in
sqlite3CreateIndex() check that ‘WHERE’ arg is empty.
On the other hand, this is temporary ban and to enable this
feature back, it is enough to revert this patch, so never mind.
^ permalink raw reply [flat|nested] 5+ messages in thread
* [tarantool-patches] Re: [PATCH v3] sql: remove support of partial indexes
2018-04-25 11:00 [tarantool-patches] " Redacted sender "gleb-skiba" for DMARC
@ 2018-04-25 15:17 ` Alexander Turenko
2018-04-25 15:44 ` n.pettik
0 siblings, 1 reply; 5+ messages in thread
From: Alexander Turenko @ 2018-04-25 15:17 UTC (permalink / raw)
To: Nikita Pettik, Gleb Skiba; +Cc: tarantool-patches
LGTM. Nikita, can you look?
Gleb, why do you sent two v3 patches? Also there are no any list of
changes of this v3 in comparison to the previous v3. It is for you
information, no actions expected from you for now.
WBR, Alexander Turenko.
On Wed, Apr 25, 2018 at 02:00:44PM +0300, Redacted sender "gleb-skiba" for DMARC wrote:
> From: Gleb <gleb-skiba@mail.ru>
>
> Remove support of partial indexes.
> Add test which checks inaccessibility of partial index syntax.
> Delete usage of partial index from tests.
> They can be enabled after #2626.
>
> Fixes #2165
> ---
> Issue from https://github.com/tarantool/tarantool/issues/2165.
> Source from https://github.com/tarantool/tarantool/tree/gh-2165-remove-support-partial-indexes.
> Changes in v3:
> -return tests which use partial.
> -delete "WHERE" from returned tests.
> -correct syntax errors in commit
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2018-04-26 9:02 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-04-24 18:39 [tarantool-patches] [PATCH v3] sql: remove support of partial indexes Gleb
2018-04-25 9:22 ` [tarantool-patches] " Alexander Turenko
2018-04-25 11:00 [tarantool-patches] " Redacted sender "gleb-skiba" for DMARC
2018-04-25 15:17 ` [tarantool-patches] " Alexander Turenko
2018-04-25 15:44 ` n.pettik
2018-04-26 9:02 ` Kirill Yukhin
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox