000001 /*
000002 ** 2001 September 15
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 ** This file contains SQLite's grammar for SQL. Process this file
000013 ** using the lemon parser generator to generate C code that runs
000014 ** the parser. Lemon will also generate a header file containing
000015 ** numeric codes for all of the tokens.
000016 */
000017
000018 // All token codes are small integers with #defines that begin with "TK_"
000019 %token_prefix TK_
000020
000021 // The type of the data attached to each token is Token. This is also the
000022 // default type for non-terminals.
000023 //
000024 %token_type {Token}
000025 %default_type {Token}
000026
000027 // An extra argument to the constructor for the parser, which is available
000028 // to all actions.
000029 %extra_context {Parse *pParse}
000030
000031 // This code runs whenever there is a syntax error
000032 //
000033 %syntax_error {
000034 UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */
000035 if( TOKEN.z[0] ){
000036 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
000037 }else{
000038 sqlite3ErrorMsg(pParse, "incomplete input");
000039 }
000040 }
000041 %stack_overflow {
000042 sqlite3ErrorMsg(pParse, "parser stack overflow");
000043 }
000044
000045 // The name of the generated procedure that implements the parser
000046 // is as follows:
000047 %name sqlite3Parser
000048
000049 // The following text is included near the beginning of the C source
000050 // code file that implements the parser.
000051 //
000052 %include {
000053 #include "sqliteInt.h"
000054
000055 /*
000056 ** Disable all error recovery processing in the parser push-down
000057 ** automaton.
000058 */
000059 #define YYNOERRORRECOVERY 1
000060
000061 /*
000062 ** Make yytestcase() the same as testcase()
000063 */
000064 #define yytestcase(X) testcase(X)
000065
000066 /*
000067 ** Indicate that sqlite3ParserFree() will never be called with a null
000068 ** pointer.
000069 */
000070 #define YYPARSEFREENEVERNULL 1
000071
000072 /*
000073 ** In the amalgamation, the parse.c file generated by lemon and the
000074 ** tokenize.c file are concatenated. In that case, sqlite3RunParser()
000075 ** has access to the the size of the yyParser object and so the parser
000076 ** engine can be allocated from stack. In that case, only the
000077 ** sqlite3ParserInit() and sqlite3ParserFinalize() routines are invoked
000078 ** and the sqlite3ParserAlloc() and sqlite3ParserFree() routines can be
000079 ** omitted.
000080 */
000081 #ifdef SQLITE_AMALGAMATION
000082 # define sqlite3Parser_ENGINEALWAYSONSTACK 1
000083 #endif
000084
000085 /*
000086 ** Alternative datatype for the argument to the malloc() routine passed
000087 ** into sqlite3ParserAlloc(). The default is size_t.
000088 */
000089 #define YYMALLOCARGTYPE u64
000090
000091 /*
000092 ** An instance of the following structure describes the event of a
000093 ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
000094 ** TK_DELETE, or TK_INSTEAD. If the event is of the form
000095 **
000096 ** UPDATE ON (a,b,c)
000097 **
000098 ** Then the "b" IdList records the list "a,b,c".
000099 */
000100 struct TrigEvent { int a; IdList * b; };
000101
000102 struct FrameBound { int eType; Expr *pExpr; };
000103
000104 /*
000105 ** Disable lookaside memory allocation for objects that might be
000106 ** shared across database connections.
000107 */
000108 static void disableLookaside(Parse *pParse){
000109 sqlite3 *db = pParse->db;
000110 pParse->disableLookaside++;
000111 DisableLookaside;
000112 }
000113
000114 } // end %include
000115
000116 // Input is a single SQL command
000117 input ::= cmdlist.
000118 cmdlist ::= cmdlist ecmd.
000119 cmdlist ::= ecmd.
000120 ecmd ::= SEMI.
000121 ecmd ::= cmdx SEMI.
000122 %ifndef SQLITE_OMIT_EXPLAIN
000123 ecmd ::= explain cmdx SEMI. {NEVER-REDUCE}
000124 explain ::= EXPLAIN. { pParse->explain = 1; }
000125 explain ::= EXPLAIN QUERY PLAN. { pParse->explain = 2; }
000126 %endif SQLITE_OMIT_EXPLAIN
000127 cmdx ::= cmd. { sqlite3FinishCoding(pParse); }
000128
000129 ///////////////////// Begin and end transactions. ////////////////////////////
000130 //
000131
000132 cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);}
000133 trans_opt ::= .
000134 trans_opt ::= TRANSACTION.
000135 trans_opt ::= TRANSACTION nm.
000136 %type transtype {int}
000137 transtype(A) ::= . {A = TK_DEFERRED;}
000138 transtype(A) ::= DEFERRED(X). {A = @X; /*A-overwrites-X*/}
000139 transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/}
000140 transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/}
000141 cmd ::= COMMIT|END(X) trans_opt. {sqlite3EndTransaction(pParse,@X);}
000142 cmd ::= ROLLBACK(X) trans_opt. {sqlite3EndTransaction(pParse,@X);}
000143
000144 savepoint_opt ::= SAVEPOINT.
000145 savepoint_opt ::= .
000146 cmd ::= SAVEPOINT nm(X). {
000147 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X);
000148 }
000149 cmd ::= RELEASE savepoint_opt nm(X). {
000150 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X);
000151 }
000152 cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). {
000153 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X);
000154 }
000155
000156 ///////////////////// The CREATE TABLE statement ////////////////////////////
000157 //
000158 cmd ::= create_table create_table_args.
000159 create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {
000160 sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);
000161 }
000162 createkw(A) ::= CREATE(A). {disableLookaside(pParse);}
000163
000164 %type ifnotexists {int}
000165 ifnotexists(A) ::= . {A = 0;}
000166 ifnotexists(A) ::= IF NOT EXISTS. {A = 1;}
000167 %type temp {int}
000168 %ifndef SQLITE_OMIT_TEMPDB
000169 temp(A) ::= TEMP. {A = 1;}
000170 %endif SQLITE_OMIT_TEMPDB
000171 temp(A) ::= . {A = 0;}
000172 create_table_args ::= LP columnlist conslist_opt(X) RP(E) table_options(F). {
000173 sqlite3EndTable(pParse,&X,&E,F,0);
000174 }
000175 create_table_args ::= AS select(S). {
000176 sqlite3EndTable(pParse,0,0,0,S);
000177 sqlite3SelectDelete(pParse->db, S);
000178 }
000179 %type table_options {int}
000180 table_options(A) ::= . {A = 0;}
000181 table_options(A) ::= WITHOUT nm(X). {
000182 if( X.n==5 && sqlite3_strnicmp(X.z,"rowid",5)==0 ){
000183 A = TF_WithoutRowid | TF_NoVisibleRowid;
000184 }else{
000185 A = 0;
000186 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", X.n, X.z);
000187 }
000188 }
000189 columnlist ::= columnlist COMMA columnname carglist.
000190 columnlist ::= columnname carglist.
000191 columnname(A) ::= nm(A) typetoken(Y). {sqlite3AddColumn(pParse,&A,&Y);}
000192
000193 // Declare some tokens early in order to influence their values, to
000194 // improve performance and reduce the executable size. The goal here is
000195 // to get the "jump" operations in ISNULL through ESCAPE to have numeric
000196 // values that are early enough so that all jump operations are clustered
000197 // at the beginning.
000198 //
000199 %token ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST.
000200 %token CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL.
000201 %token OR AND NOT IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
000202 %token GT LE LT GE ESCAPE.
000203
000204 // The following directive causes tokens ABORT, AFTER, ASC, etc. to
000205 // fallback to ID if they will not parse as their original value.
000206 // This obviates the need for the "id" nonterminal.
000207 //
000208 %fallback ID
000209 ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW
000210 CONFLICT DATABASE DEFERRED DESC DETACH DO
000211 EACH END EXCLUSIVE EXPLAIN FAIL FOR
000212 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH NO PLAN
000213 QUERY KEY OF OFFSET PRAGMA RAISE RECURSIVE RELEASE REPLACE RESTRICT ROW ROWS
000214 ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT
000215 NULLS FIRST LAST
000216 %ifdef SQLITE_OMIT_COMPOUND_SELECT
000217 EXCEPT INTERSECT UNION
000218 %endif SQLITE_OMIT_COMPOUND_SELECT
000219 %ifndef SQLITE_OMIT_WINDOWFUNC
000220 CURRENT FOLLOWING PARTITION PRECEDING RANGE UNBOUNDED
000221 EXCLUDE GROUPS OTHERS TIES
000222 %endif SQLITE_OMIT_WINDOWFUNC
000223 %ifndef SQLITE_OMIT_GENERATED_COLUMNS
000224 GENERATED ALWAYS
000225 %endif
000226 REINDEX RENAME CTIME_KW IF
000227 .
000228 %wildcard ANY.
000229
000230 // Define operator precedence early so that this is the first occurrence
000231 // of the operator tokens in the grammer. Keeping the operators together
000232 // causes them to be assigned integer values that are close together,
000233 // which keeps parser tables smaller.
000234 //
000235 // The token values assigned to these symbols is determined by the order
000236 // in which lemon first sees them. It must be the case that ISNULL/NOTNULL,
000237 // NE/EQ, GT/LE, and GE/LT are separated by only a single value. See
000238 // the sqlite3ExprIfFalse() routine for additional information on this
000239 // constraint.
000240 //
000241 %left OR.
000242 %left AND.
000243 %right NOT.
000244 %left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
000245 %left GT LE LT GE.
000246 %right ESCAPE.
000247 %left BITAND BITOR LSHIFT RSHIFT.
000248 %left PLUS MINUS.
000249 %left STAR SLASH REM.
000250 %left CONCAT.
000251 %left COLLATE.
000252 %right BITNOT.
000253 %nonassoc ON.
000254
000255 // An IDENTIFIER can be a generic identifier, or one of several
000256 // keywords. Any non-standard keyword can also be an identifier.
000257 //
000258 %token_class id ID|INDEXED.
000259
000260
000261 // And "ids" is an identifer-or-string.
000262 //
000263 %token_class ids ID|STRING.
000264
000265 // The name of a column or table can be any of the following:
000266 //
000267 %type nm {Token}
000268 nm(A) ::= id(A).
000269 nm(A) ::= STRING(A).
000270 nm(A) ::= JOIN_KW(A).
000271
000272 // A typetoken is really zero or more tokens that form a type name such
000273 // as can be found after the column name in a CREATE TABLE statement.
000274 // Multiple tokens are concatenated to form the value of the typetoken.
000275 //
000276 %type typetoken {Token}
000277 typetoken(A) ::= . {A.n = 0; A.z = 0;}
000278 typetoken(A) ::= typename(A).
000279 typetoken(A) ::= typename(A) LP signed RP(Y). {
000280 A.n = (int)(&Y.z[Y.n] - A.z);
000281 }
000282 typetoken(A) ::= typename(A) LP signed COMMA signed RP(Y). {
000283 A.n = (int)(&Y.z[Y.n] - A.z);
000284 }
000285 %type typename {Token}
000286 typename(A) ::= ids(A).
000287 typename(A) ::= typename(A) ids(Y). {A.n=Y.n+(int)(Y.z-A.z);}
000288 signed ::= plus_num.
000289 signed ::= minus_num.
000290
000291 // The scanpt non-terminal takes a value which is a pointer to the
000292 // input text just past the last token that has been shifted into
000293 // the parser. By surrounding some phrase in the grammar with two
000294 // scanpt non-terminals, we can capture the input text for that phrase.
000295 // For example:
000296 //
000297 // something ::= .... scanpt(A) phrase scanpt(Z).
000298 //
000299 // The text that is parsed as "phrase" is a string starting at A
000300 // and containing (int)(Z-A) characters. There might be some extra
000301 // whitespace on either end of the text, but that can be removed in
000302 // post-processing, if needed.
000303 //
000304 %type scanpt {const char*}
000305 scanpt(A) ::= . {
000306 assert( yyLookahead!=YYNOCODE );
000307 A = yyLookaheadToken.z;
000308 }
000309 scantok(A) ::= . {
000310 assert( yyLookahead!=YYNOCODE );
000311 A = yyLookaheadToken;
000312 }
000313
000314 // "carglist" is a list of additional constraints that come after the
000315 // column name and column type in a CREATE TABLE statement.
000316 //
000317 carglist ::= carglist ccons.
000318 carglist ::= .
000319 ccons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}
000320 ccons ::= DEFAULT scantok(A) term(X).
000321 {sqlite3AddDefaultValue(pParse,X,A.z,&A.z[A.n]);}
000322 ccons ::= DEFAULT LP(A) expr(X) RP(Z).
000323 {sqlite3AddDefaultValue(pParse,X,A.z+1,Z.z);}
000324 ccons ::= DEFAULT PLUS(A) scantok(Z) term(X).
000325 {sqlite3AddDefaultValue(pParse,X,A.z,&Z.z[Z.n]);}
000326 ccons ::= DEFAULT MINUS(A) scantok(Z) term(X). {
000327 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0);
000328 sqlite3AddDefaultValue(pParse,p,A.z,&Z.z[Z.n]);
000329 }
000330 ccons ::= DEFAULT scantok id(X). {
000331 Expr *p = tokenExpr(pParse, TK_STRING, X);
000332 if( p ){
000333 sqlite3ExprIdToTrueFalse(p);
000334 testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );
000335 }
000336 sqlite3AddDefaultValue(pParse,p,X.z,X.z+X.n);
000337 }
000338
000339 // In addition to the type name, we also care about the primary key and
000340 // UNIQUE constraints.
000341 //
000342 ccons ::= NULL onconf.
000343 ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);}
000344 ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).
000345 {sqlite3AddPrimaryKey(pParse,0,R,I,Z);}
000346 ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0,
000347 SQLITE_IDXTYPE_UNIQUE);}
000348 ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X);}
000349 ccons ::= REFERENCES nm(T) eidlist_opt(TA) refargs(R).
000350 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
000351 ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);}
000352 ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);}
000353 ccons ::= GENERATED ALWAYS AS generated.
000354 ccons ::= AS generated.
000355 generated ::= LP expr(E) RP. {sqlite3AddGenerated(pParse,E,0);}
000356 generated ::= LP expr(E) RP ID(TYPE). {sqlite3AddGenerated(pParse,E,&TYPE);}
000357
000358 // The optional AUTOINCREMENT keyword
000359 %type autoinc {int}
000360 autoinc(X) ::= . {X = 0;}
000361 autoinc(X) ::= AUTOINCR. {X = 1;}
000362
000363 // The next group of rules parses the arguments to a REFERENCES clause
000364 // that determine if the referential integrity checking is deferred or
000365 // or immediate and which determine what action to take if a ref-integ
000366 // check fails.
000367 //
000368 %type refargs {int}
000369 refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */}
000370 refargs(A) ::= refargs(A) refarg(Y). { A = (A & ~Y.mask) | Y.value; }
000371 %type refarg {struct {int value; int mask;}}
000372 refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }
000373 refarg(A) ::= ON INSERT refact. { A.value = 0; A.mask = 0x000000; }
000374 refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }
000375 refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }
000376 %type refact {int}
000377 refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */}
000378 refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */}
000379 refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */}
000380 refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */}
000381 refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */}
000382 %type defer_subclause {int}
000383 defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt. {A = 0;}
000384 defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;}
000385 %type init_deferred_pred_opt {int}
000386 init_deferred_pred_opt(A) ::= . {A = 0;}
000387 init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;}
000388 init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;}
000389
000390 conslist_opt(A) ::= . {A.n = 0; A.z = 0;}
000391 conslist_opt(A) ::= COMMA(A) conslist.
000392 conslist ::= conslist tconscomma tcons.
000393 conslist ::= tcons.
000394 tconscomma ::= COMMA. {pParse->constraintName.n = 0;}
000395 tconscomma ::= .
000396 tcons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}
000397 tcons ::= PRIMARY KEY LP sortlist(X) autoinc(I) RP onconf(R).
000398 {sqlite3AddPrimaryKey(pParse,X,R,I,0);}
000399 tcons ::= UNIQUE LP sortlist(X) RP onconf(R).
000400 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0,
000401 SQLITE_IDXTYPE_UNIQUE);}
000402 tcons ::= CHECK LP expr(E) RP onconf.
000403 {sqlite3AddCheckConstraint(pParse,E);}
000404 tcons ::= FOREIGN KEY LP eidlist(FA) RP
000405 REFERENCES nm(T) eidlist_opt(TA) refargs(R) defer_subclause_opt(D). {
000406 sqlite3CreateForeignKey(pParse, FA, &T, TA, R);
000407 sqlite3DeferForeignKey(pParse, D);
000408 }
000409 %type defer_subclause_opt {int}
000410 defer_subclause_opt(A) ::= . {A = 0;}
000411 defer_subclause_opt(A) ::= defer_subclause(A).
000412
000413 // The following is a non-standard extension that allows us to declare the
000414 // default behavior when there is a constraint conflict.
000415 //
000416 %type onconf {int}
000417 %type orconf {int}
000418 %type resolvetype {int}
000419 onconf(A) ::= . {A = OE_Default;}
000420 onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;}
000421 orconf(A) ::= . {A = OE_Default;}
000422 orconf(A) ::= OR resolvetype(X). {A = X;}
000423 resolvetype(A) ::= raisetype(A).
000424 resolvetype(A) ::= IGNORE. {A = OE_Ignore;}
000425 resolvetype(A) ::= REPLACE. {A = OE_Replace;}
000426
000427 ////////////////////////// The DROP TABLE /////////////////////////////////////
000428 //
000429 cmd ::= DROP TABLE ifexists(E) fullname(X). {
000430 sqlite3DropTable(pParse, X, 0, E);
000431 }
000432 %type ifexists {int}
000433 ifexists(A) ::= IF EXISTS. {A = 1;}
000434 ifexists(A) ::= . {A = 0;}
000435
000436 ///////////////////// The CREATE VIEW statement /////////////////////////////
000437 //
000438 %ifndef SQLITE_OMIT_VIEW
000439 cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) eidlist_opt(C)
000440 AS select(S). {
000441 sqlite3CreateView(pParse, &X, &Y, &Z, C, S, T, E);
000442 }
000443 cmd ::= DROP VIEW ifexists(E) fullname(X). {
000444 sqlite3DropTable(pParse, X, 1, E);
000445 }
000446 %endif SQLITE_OMIT_VIEW
000447
000448 //////////////////////// The SELECT statement /////////////////////////////////
000449 //
000450 cmd ::= select(X). {
000451 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0};
000452 sqlite3Select(pParse, X, &dest);
000453 sqlite3SelectDelete(pParse->db, X);
000454 }
000455
000456 %type select {Select*}
000457 %destructor select {sqlite3SelectDelete(pParse->db, $$);}
000458 %type selectnowith {Select*}
000459 %destructor selectnowith {sqlite3SelectDelete(pParse->db, $$);}
000460 %type oneselect {Select*}
000461 %destructor oneselect {sqlite3SelectDelete(pParse->db, $$);}
000462
000463 %include {
000464 /*
000465 ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
000466 ** all elements in the list. And make sure list length does not exceed
000467 ** SQLITE_LIMIT_COMPOUND_SELECT.
000468 */
000469 static void parserDoubleLinkSelect(Parse *pParse, Select *p){
000470 assert( p!=0 );
000471 if( p->pPrior ){
000472 Select *pNext = 0, *pLoop;
000473 int mxSelect, cnt = 0;
000474 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
000475 pLoop->pNext = pNext;
000476 pLoop->selFlags |= SF_Compound;
000477 }
000478 if( (p->selFlags & SF_MultiValue)==0 &&
000479 (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&
000480 cnt>mxSelect
000481 ){
000482 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
000483 }
000484 }
000485 }
000486 }
000487
000488 %ifndef SQLITE_OMIT_CTE
000489 select(A) ::= WITH wqlist(W) selectnowith(X). {
000490 Select *p = X;
000491 if( p ){
000492 p->pWith = W;
000493 parserDoubleLinkSelect(pParse, p);
000494 }else{
000495 sqlite3WithDelete(pParse->db, W);
000496 }
000497 A = p;
000498 }
000499 select(A) ::= WITH RECURSIVE wqlist(W) selectnowith(X). {
000500 Select *p = X;
000501 if( p ){
000502 p->pWith = W;
000503 parserDoubleLinkSelect(pParse, p);
000504 }else{
000505 sqlite3WithDelete(pParse->db, W);
000506 }
000507 A = p;
000508 }
000509 %endif /* SQLITE_OMIT_CTE */
000510 select(A) ::= selectnowith(X). {
000511 Select *p = X;
000512 if( p ){
000513 parserDoubleLinkSelect(pParse, p);
000514 }
000515 A = p; /*A-overwrites-X*/
000516 }
000517
000518 selectnowith(A) ::= oneselect(A).
000519 %ifndef SQLITE_OMIT_COMPOUND_SELECT
000520 selectnowith(A) ::= selectnowith(A) multiselect_op(Y) oneselect(Z). {
000521 Select *pRhs = Z;
000522 Select *pLhs = A;
000523 if( pRhs && pRhs->pPrior ){
000524 SrcList *pFrom;
000525 Token x;
000526 x.n = 0;
000527 parserDoubleLinkSelect(pParse, pRhs);
000528 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
000529 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
000530 }
000531 if( pRhs ){
000532 pRhs->op = (u8)Y;
000533 pRhs->pPrior = pLhs;
000534 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
000535 pRhs->selFlags &= ~SF_MultiValue;
000536 if( Y!=TK_ALL ) pParse->hasCompound = 1;
000537 }else{
000538 sqlite3SelectDelete(pParse->db, pLhs);
000539 }
000540 A = pRhs;
000541 }
000542 %type multiselect_op {int}
000543 multiselect_op(A) ::= UNION(OP). {A = @OP; /*A-overwrites-OP*/}
000544 multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}
000545 multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP; /*A-overwrites-OP*/}
000546 %endif SQLITE_OMIT_COMPOUND_SELECT
000547
000548 oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
000549 groupby_opt(P) having_opt(Q)
000550 orderby_opt(Z) limit_opt(L). {
000551 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L);
000552 }
000553 %ifndef SQLITE_OMIT_WINDOWFUNC
000554 oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
000555 groupby_opt(P) having_opt(Q) window_clause(R)
000556 orderby_opt(Z) limit_opt(L). {
000557 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L);
000558 if( A ){
000559 A->pWinDefn = R;
000560 }else{
000561 sqlite3WindowListDelete(pParse->db, R);
000562 }
000563 }
000564 %endif
000565
000566
000567 oneselect(A) ::= values(A).
000568
000569 %type values {Select*}
000570 %destructor values {sqlite3SelectDelete(pParse->db, $$);}
000571 values(A) ::= VALUES LP nexprlist(X) RP. {
000572 A = sqlite3SelectNew(pParse,X,0,0,0,0,0,SF_Values,0);
000573 }
000574 values(A) ::= values(A) COMMA LP nexprlist(Y) RP. {
000575 Select *pRight, *pLeft = A;
000576 pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values|SF_MultiValue,0);
000577 if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
000578 if( pRight ){
000579 pRight->op = TK_ALL;
000580 pRight->pPrior = pLeft;
000581 A = pRight;
000582 }else{
000583 A = pLeft;
000584 }
000585 }
000586
000587 // The "distinct" nonterminal is true (1) if the DISTINCT keyword is
000588 // present and false (0) if it is not.
000589 //
000590 %type distinct {int}
000591 distinct(A) ::= DISTINCT. {A = SF_Distinct;}
000592 distinct(A) ::= ALL. {A = SF_All;}
000593 distinct(A) ::= . {A = 0;}
000594
000595 // selcollist is a list of expressions that are to become the return
000596 // values of the SELECT statement. The "*" in statements like
000597 // "SELECT * FROM ..." is encoded as a special expression with an
000598 // opcode of TK_ASTERISK.
000599 //
000600 %type selcollist {ExprList*}
000601 %destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);}
000602 %type sclp {ExprList*}
000603 %destructor sclp {sqlite3ExprListDelete(pParse->db, $$);}
000604 sclp(A) ::= selcollist(A) COMMA.
000605 sclp(A) ::= . {A = 0;}
000606 selcollist(A) ::= sclp(A) scanpt(B) expr(X) scanpt(Z) as(Y). {
000607 A = sqlite3ExprListAppend(pParse, A, X);
000608 if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1);
000609 sqlite3ExprListSetSpan(pParse,A,B,Z);
000610 }
000611 selcollist(A) ::= sclp(A) scanpt STAR. {
000612 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
000613 A = sqlite3ExprListAppend(pParse, A, p);
000614 }
000615 selcollist(A) ::= sclp(A) scanpt nm(X) DOT STAR. {
000616 Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
000617 Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
000618 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
000619 A = sqlite3ExprListAppend(pParse,A, pDot);
000620 }
000621
000622 // An option "AS <id>" phrase that can follow one of the expressions that
000623 // define the result set, or one of the tables in the FROM clause.
000624 //
000625 %type as {Token}
000626 as(X) ::= AS nm(Y). {X = Y;}
000627 as(X) ::= ids(X).
000628 as(X) ::= . {X.n = 0; X.z = 0;}
000629
000630
000631 %type seltablist {SrcList*}
000632 %destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);}
000633 %type stl_prefix {SrcList*}
000634 %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);}
000635 %type from {SrcList*}
000636 %destructor from {sqlite3SrcListDelete(pParse->db, $$);}
000637
000638 // A complete FROM clause.
000639 //
000640 from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
000641 from(A) ::= FROM seltablist(X). {
000642 A = X;
000643 sqlite3SrcListShiftJoinType(A);
000644 }
000645
000646 // "seltablist" is a "Select Table List" - the content of the FROM clause
000647 // in a SELECT statement. "stl_prefix" is a prefix of this list.
000648 //
000649 stl_prefix(A) ::= seltablist(A) joinop(Y). {
000650 if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].fg.jointype = (u8)Y;
000651 }
000652 stl_prefix(A) ::= . {A = 0;}
000653 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) as(Z) indexed_opt(I)
000654 on_opt(N) using_opt(U). {
000655 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U);
000656 sqlite3SrcListIndexedBy(pParse, A, &I);
000657 }
000658 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) LP exprlist(E) RP as(Z)
000659 on_opt(N) using_opt(U). {
000660 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U);
000661 sqlite3SrcListFuncArgs(pParse, A, E);
000662 }
000663 %ifndef SQLITE_OMIT_SUBQUERY
000664 seltablist(A) ::= stl_prefix(A) LP select(S) RP
000665 as(Z) on_opt(N) using_opt(U). {
000666 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,S,N,U);
000667 }
000668 seltablist(A) ::= stl_prefix(A) LP seltablist(F) RP
000669 as(Z) on_opt(N) using_opt(U). {
000670 if( A==0 && Z.n==0 && N==0 && U==0 ){
000671 A = F;
000672 }else if( F->nSrc==1 ){
000673 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,0,N,U);
000674 if( A ){
000675 struct SrcList_item *pNew = &A->a[A->nSrc-1];
000676 struct SrcList_item *pOld = F->a;
000677 pNew->zName = pOld->zName;
000678 pNew->zDatabase = pOld->zDatabase;
000679 pNew->pSelect = pOld->pSelect;
000680 if( pOld->fg.isTabFunc ){
000681 pNew->u1.pFuncArg = pOld->u1.pFuncArg;
000682 pOld->u1.pFuncArg = 0;
000683 pOld->fg.isTabFunc = 0;
000684 pNew->fg.isTabFunc = 1;
000685 }
000686 pOld->zName = pOld->zDatabase = 0;
000687 pOld->pSelect = 0;
000688 }
000689 sqlite3SrcListDelete(pParse->db, F);
000690 }else{
000691 Select *pSubquery;
000692 sqlite3SrcListShiftJoinType(F);
000693 pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,SF_NestedFrom,0);
000694 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,pSubquery,N,U);
000695 }
000696 }
000697 %endif SQLITE_OMIT_SUBQUERY
000698
000699 %type dbnm {Token}
000700 dbnm(A) ::= . {A.z=0; A.n=0;}
000701 dbnm(A) ::= DOT nm(X). {A = X;}
000702
000703 %type fullname {SrcList*}
000704 %destructor fullname {sqlite3SrcListDelete(pParse->db, $$);}
000705 fullname(A) ::= nm(X). {
000706 A = sqlite3SrcListAppend(pParse,0,&X,0);
000707 if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &X);
000708 }
000709 fullname(A) ::= nm(X) DOT nm(Y). {
000710 A = sqlite3SrcListAppend(pParse,0,&X,&Y);
000711 if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &Y);
000712 }
000713
000714 %type xfullname {SrcList*}
000715 %destructor xfullname {sqlite3SrcListDelete(pParse->db, $$);}
000716 xfullname(A) ::= nm(X).
000717 {A = sqlite3SrcListAppend(pParse,0,&X,0); /*A-overwrites-X*/}
000718 xfullname(A) ::= nm(X) DOT nm(Y).
000719 {A = sqlite3SrcListAppend(pParse,0,&X,&Y); /*A-overwrites-X*/}
000720 xfullname(A) ::= nm(X) DOT nm(Y) AS nm(Z). {
000721 A = sqlite3SrcListAppend(pParse,0,&X,&Y); /*A-overwrites-X*/
000722 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z);
000723 }
000724 xfullname(A) ::= nm(X) AS nm(Z). {
000725 A = sqlite3SrcListAppend(pParse,0,&X,0); /*A-overwrites-X*/
000726 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z);
000727 }
000728
000729 %type joinop {int}
000730 joinop(X) ::= COMMA|JOIN. { X = JT_INNER; }
000731 joinop(X) ::= JOIN_KW(A) JOIN.
000732 {X = sqlite3JoinType(pParse,&A,0,0); /*X-overwrites-A*/}
000733 joinop(X) ::= JOIN_KW(A) nm(B) JOIN.
000734 {X = sqlite3JoinType(pParse,&A,&B,0); /*X-overwrites-A*/}
000735 joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
000736 {X = sqlite3JoinType(pParse,&A,&B,&C);/*X-overwrites-A*/}
000737
000738 // There is a parsing abiguity in an upsert statement that uses a
000739 // SELECT on the RHS of a the INSERT:
000740 //
000741 // INSERT INTO tab SELECT * FROM aaa JOIN bbb ON CONFLICT ...
000742 // here ----^^
000743 //
000744 // When the ON token is encountered, the parser does not know if it is
000745 // the beginning of an ON CONFLICT clause, or the beginning of an ON
000746 // clause associated with the JOIN. The conflict is resolved in favor
000747 // of the JOIN. If an ON CONFLICT clause is intended, insert a dummy
000748 // WHERE clause in between, like this:
000749 //
000750 // INSERT INTO tab SELECT * FROM aaa JOIN bbb WHERE true ON CONFLICT ...
000751 //
000752 // The [AND] and [OR] precedence marks in the rules for on_opt cause the
000753 // ON in this context to always be interpreted as belonging to the JOIN.
000754 //
000755 %type on_opt {Expr*}
000756 %destructor on_opt {sqlite3ExprDelete(pParse->db, $$);}
000757 on_opt(N) ::= ON expr(E). {N = E;}
000758 on_opt(N) ::= . [OR] {N = 0;}
000759
000760 // Note that this block abuses the Token type just a little. If there is
000761 // no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If
000762 // there is an INDEXED BY clause, then the token is populated as per normal,
000763 // with z pointing to the token data and n containing the number of bytes
000764 // in the token.
000765 //
000766 // If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is
000767 // normally illegal. The sqlite3SrcListIndexedBy() function
000768 // recognizes and interprets this as a special case.
000769 //
000770 %type indexed_opt {Token}
000771 indexed_opt(A) ::= . {A.z=0; A.n=0;}
000772 indexed_opt(A) ::= INDEXED BY nm(X). {A = X;}
000773 indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;}
000774
000775 %type using_opt {IdList*}
000776 %destructor using_opt {sqlite3IdListDelete(pParse->db, $$);}
000777 using_opt(U) ::= USING LP idlist(L) RP. {U = L;}
000778 using_opt(U) ::= . {U = 0;}
000779
000780
000781 %type orderby_opt {ExprList*}
000782 %destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);}
000783
000784 // the sortlist non-terminal stores a list of expression where each
000785 // expression is optionally followed by ASC or DESC to indicate the
000786 // sort order.
000787 //
000788 %type sortlist {ExprList*}
000789 %destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);}
000790
000791 orderby_opt(A) ::= . {A = 0;}
000792 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
000793 sortlist(A) ::= sortlist(A) COMMA expr(Y) sortorder(Z) nulls(X). {
000794 A = sqlite3ExprListAppend(pParse,A,Y);
000795 sqlite3ExprListSetSortOrder(A,Z,X);
000796 }
000797 sortlist(A) ::= expr(Y) sortorder(Z) nulls(X). {
000798 A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/
000799 sqlite3ExprListSetSortOrder(A,Z,X);
000800 }
000801
000802 %type sortorder {int}
000803
000804 sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}
000805 sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}
000806 sortorder(A) ::= . {A = SQLITE_SO_UNDEFINED;}
000807
000808 %type nulls {int}
000809 nulls(A) ::= NULLS FIRST. {A = SQLITE_SO_ASC;}
000810 nulls(A) ::= NULLS LAST. {A = SQLITE_SO_DESC;}
000811 nulls(A) ::= . {A = SQLITE_SO_UNDEFINED;}
000812
000813 %type groupby_opt {ExprList*}
000814 %destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);}
000815 groupby_opt(A) ::= . {A = 0;}
000816 groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}
000817
000818 %type having_opt {Expr*}
000819 %destructor having_opt {sqlite3ExprDelete(pParse->db, $$);}
000820 having_opt(A) ::= . {A = 0;}
000821 having_opt(A) ::= HAVING expr(X). {A = X;}
000822
000823 %type limit_opt {Expr*}
000824
000825 // The destructor for limit_opt will never fire in the current grammar.
000826 // The limit_opt non-terminal only occurs at the end of a single production
000827 // rule for SELECT statements. As soon as the rule that create the
000828 // limit_opt non-terminal reduces, the SELECT statement rule will also
000829 // reduce. So there is never a limit_opt non-terminal on the stack
000830 // except as a transient. So there is never anything to destroy.
000831 //
000832 //%destructor limit_opt {sqlite3ExprDelete(pParse->db, $$);}
000833 limit_opt(A) ::= . {A = 0;}
000834 limit_opt(A) ::= LIMIT expr(X).
000835 {A = sqlite3PExpr(pParse,TK_LIMIT,X,0);}
000836 limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).
000837 {A = sqlite3PExpr(pParse,TK_LIMIT,X,Y);}
000838 limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).
000839 {A = sqlite3PExpr(pParse,TK_LIMIT,Y,X);}
000840
000841 /////////////////////////// The DELETE statement /////////////////////////////
000842 //
000843 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
000844 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W)
000845 orderby_opt(O) limit_opt(L). {
000846 sqlite3SrcListIndexedBy(pParse, X, &I);
000847 #ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
000848 sqlite3ExprListDelete(pParse->db, O); O = 0;
000849 sqlite3ExprDelete(pParse->db, L); L = 0;
000850 #endif
000851 sqlite3DeleteFrom(pParse,X,W,O,L);
000852 }
000853 %endif
000854 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
000855 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W). {
000856 sqlite3SrcListIndexedBy(pParse, X, &I);
000857 sqlite3DeleteFrom(pParse,X,W,0,0);
000858 }
000859 %endif
000860
000861 %type where_opt {Expr*}
000862 %destructor where_opt {sqlite3ExprDelete(pParse->db, $$);}
000863
000864 where_opt(A) ::= . {A = 0;}
000865 where_opt(A) ::= WHERE expr(X). {A = X;}
000866
000867 ////////////////////////// The UPDATE command ////////////////////////////////
000868 //
000869 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
000870 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y)
000871 where_opt(W) orderby_opt(O) limit_opt(L). {
000872 sqlite3SrcListIndexedBy(pParse, X, &I);
000873 sqlite3ExprListCheckLength(pParse,Y,"set list");
000874 sqlite3Update(pParse,X,Y,W,R,O,L,0);
000875 }
000876 %endif
000877 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
000878 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y)
000879 where_opt(W). {
000880 sqlite3SrcListIndexedBy(pParse, X, &I);
000881 sqlite3ExprListCheckLength(pParse,Y,"set list");
000882 sqlite3Update(pParse,X,Y,W,R,0,0,0);
000883 }
000884 %endif
000885
000886 %type setlist {ExprList*}
000887 %destructor setlist {sqlite3ExprListDelete(pParse->db, $$);}
000888
000889 setlist(A) ::= setlist(A) COMMA nm(X) EQ expr(Y). {
000890 A = sqlite3ExprListAppend(pParse, A, Y);
000891 sqlite3ExprListSetName(pParse, A, &X, 1);
000892 }
000893 setlist(A) ::= setlist(A) COMMA LP idlist(X) RP EQ expr(Y). {
000894 A = sqlite3ExprListAppendVector(pParse, A, X, Y);
000895 }
000896 setlist(A) ::= nm(X) EQ expr(Y). {
000897 A = sqlite3ExprListAppend(pParse, 0, Y);
000898 sqlite3ExprListSetName(pParse, A, &X, 1);
000899 }
000900 setlist(A) ::= LP idlist(X) RP EQ expr(Y). {
000901 A = sqlite3ExprListAppendVector(pParse, 0, X, Y);
000902 }
000903
000904 ////////////////////////// The INSERT command /////////////////////////////////
000905 //
000906 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) select(S)
000907 upsert(U). {
000908 sqlite3Insert(pParse, X, S, F, R, U);
000909 }
000910 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) DEFAULT VALUES.
000911 {
000912 sqlite3Insert(pParse, X, 0, F, R, 0);
000913 }
000914
000915 %type upsert {Upsert*}
000916
000917 // Because upsert only occurs at the tip end of the INSERT rule for cmd,
000918 // there is never a case where the value of the upsert pointer will not
000919 // be destroyed by the cmd action. So comment-out the destructor to
000920 // avoid unreachable code.
000921 //%destructor upsert {sqlite3UpsertDelete(pParse->db,$$);}
000922 upsert(A) ::= . { A = 0; }
000923 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW)
000924 DO UPDATE SET setlist(Z) where_opt(W).
000925 { A = sqlite3UpsertNew(pParse->db,T,TW,Z,W);}
000926 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW) DO NOTHING.
000927 { A = sqlite3UpsertNew(pParse->db,T,TW,0,0); }
000928 upsert(A) ::= ON CONFLICT DO NOTHING.
000929 { A = sqlite3UpsertNew(pParse->db,0,0,0,0); }
000930
000931 %type insert_cmd {int}
000932 insert_cmd(A) ::= INSERT orconf(R). {A = R;}
000933 insert_cmd(A) ::= REPLACE. {A = OE_Replace;}
000934
000935 %type idlist_opt {IdList*}
000936 %destructor idlist_opt {sqlite3IdListDelete(pParse->db, $$);}
000937 %type idlist {IdList*}
000938 %destructor idlist {sqlite3IdListDelete(pParse->db, $$);}
000939
000940 idlist_opt(A) ::= . {A = 0;}
000941 idlist_opt(A) ::= LP idlist(X) RP. {A = X;}
000942 idlist(A) ::= idlist(A) COMMA nm(Y).
000943 {A = sqlite3IdListAppend(pParse,A,&Y);}
000944 idlist(A) ::= nm(Y).
000945 {A = sqlite3IdListAppend(pParse,0,&Y); /*A-overwrites-Y*/}
000946
000947 /////////////////////////// Expression Processing /////////////////////////////
000948 //
000949
000950 %type expr {Expr*}
000951 %destructor expr {sqlite3ExprDelete(pParse->db, $$);}
000952 %type term {Expr*}
000953 %destructor term {sqlite3ExprDelete(pParse->db, $$);}
000954
000955 %include {
000956
000957 /* Construct a new Expr object from a single identifier. Use the
000958 ** new Expr to populate pOut. Set the span of pOut to be the identifier
000959 ** that created the expression.
000960 */
000961 static Expr *tokenExpr(Parse *pParse, int op, Token t){
000962 Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
000963 if( p ){
000964 /* memset(p, 0, sizeof(Expr)); */
000965 p->op = (u8)op;
000966 p->affExpr = 0;
000967 p->flags = EP_Leaf;
000968 p->iAgg = -1;
000969 p->pLeft = p->pRight = 0;
000970 p->x.pList = 0;
000971 p->pAggInfo = 0;
000972 p->y.pTab = 0;
000973 p->op2 = 0;
000974 p->iTable = 0;
000975 p->iColumn = 0;
000976 p->u.zToken = (char*)&p[1];
000977 memcpy(p->u.zToken, t.z, t.n);
000978 p->u.zToken[t.n] = 0;
000979 if( sqlite3Isquote(p->u.zToken[0]) ){
000980 sqlite3DequoteExpr(p);
000981 }
000982 #if SQLITE_MAX_EXPR_DEPTH>0
000983 p->nHeight = 1;
000984 #endif
000985 if( IN_RENAME_OBJECT ){
000986 return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
000987 }
000988 }
000989 return p;
000990 }
000991
000992 }
000993
000994 expr(A) ::= term(A).
000995 expr(A) ::= LP expr(X) RP. {A = X;}
000996 expr(A) ::= id(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/}
000997 expr(A) ::= JOIN_KW(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/}
000998 expr(A) ::= nm(X) DOT nm(Y). {
000999 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
001000 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);
001001 if( IN_RENAME_OBJECT ){
001002 sqlite3RenameTokenMap(pParse, (void*)temp2, &Y);
001003 sqlite3RenameTokenMap(pParse, (void*)temp1, &X);
001004 }
001005 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
001006 }
001007 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
001008 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
001009 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);
001010 Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &Z, 1);
001011 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
001012 if( IN_RENAME_OBJECT ){
001013 sqlite3RenameTokenMap(pParse, (void*)temp3, &Z);
001014 sqlite3RenameTokenMap(pParse, (void*)temp2, &Y);
001015 }
001016 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
001017 }
001018 term(A) ::= NULL|FLOAT|BLOB(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/}
001019 term(A) ::= STRING(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/}
001020 term(A) ::= INTEGER(X). {
001021 A = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &X, 1);
001022 }
001023 expr(A) ::= VARIABLE(X). {
001024 if( !(X.z[0]=='#' && sqlite3Isdigit(X.z[1])) ){
001025 u32 n = X.n;
001026 A = tokenExpr(pParse, TK_VARIABLE, X);
001027 sqlite3ExprAssignVarNumber(pParse, A, n);
001028 }else{
001029 /* When doing a nested parse, one can include terms in an expression
001030 ** that look like this: #1 #2 ... These terms refer to registers
001031 ** in the virtual machine. #N is the N-th register. */
001032 Token t = X; /*A-overwrites-X*/
001033 assert( t.n>=2 );
001034 if( pParse->nested==0 ){
001035 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
001036 A = 0;
001037 }else{
001038 A = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
001039 if( A ) sqlite3GetInt32(&t.z[1], &A->iTable);
001040 }
001041 }
001042 }
001043 expr(A) ::= expr(A) COLLATE ids(C). {
001044 A = sqlite3ExprAddCollateToken(pParse, A, &C, 1);
001045 }
001046 %ifndef SQLITE_OMIT_CAST
001047 expr(A) ::= CAST LP expr(E) AS typetoken(T) RP. {
001048 A = sqlite3ExprAlloc(pParse->db, TK_CAST, &T, 1);
001049 sqlite3ExprAttachSubtrees(pParse->db, A, E, 0);
001050 }
001051 %endif SQLITE_OMIT_CAST
001052
001053
001054 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP. {
001055 A = sqlite3ExprFunction(pParse, Y, &X, D);
001056 }
001057 expr(A) ::= id(X) LP STAR RP. {
001058 A = sqlite3ExprFunction(pParse, 0, &X, 0);
001059 }
001060
001061 %ifndef SQLITE_OMIT_WINDOWFUNC
001062 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP filter_over(Z). {
001063 A = sqlite3ExprFunction(pParse, Y, &X, D);
001064 sqlite3WindowAttach(pParse, A, Z);
001065 }
001066 expr(A) ::= id(X) LP STAR RP filter_over(Z). {
001067 A = sqlite3ExprFunction(pParse, 0, &X, 0);
001068 sqlite3WindowAttach(pParse, A, Z);
001069 }
001070 %endif
001071
001072 term(A) ::= CTIME_KW(OP). {
001073 A = sqlite3ExprFunction(pParse, 0, &OP, 0);
001074 }
001075
001076 expr(A) ::= LP nexprlist(X) COMMA expr(Y) RP. {
001077 ExprList *pList = sqlite3ExprListAppend(pParse, X, Y);
001078 A = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
001079 if( A ){
001080 A->x.pList = pList;
001081 if( ALWAYS(pList->nExpr) ){
001082 A->flags |= pList->a[0].pExpr->flags & EP_Propagate;
001083 }
001084 }else{
001085 sqlite3ExprListDelete(pParse->db, pList);
001086 }
001087 }
001088
001089 expr(A) ::= expr(A) AND expr(Y). {A=sqlite3ExprAnd(pParse,A,Y);}
001090 expr(A) ::= expr(A) OR(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);}
001091 expr(A) ::= expr(A) LT|GT|GE|LE(OP) expr(Y).
001092 {A=sqlite3PExpr(pParse,@OP,A,Y);}
001093 expr(A) ::= expr(A) EQ|NE(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);}
001094 expr(A) ::= expr(A) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).
001095 {A=sqlite3PExpr(pParse,@OP,A,Y);}
001096 expr(A) ::= expr(A) PLUS|MINUS(OP) expr(Y).
001097 {A=sqlite3PExpr(pParse,@OP,A,Y);}
001098 expr(A) ::= expr(A) STAR|SLASH|REM(OP) expr(Y).
001099 {A=sqlite3PExpr(pParse,@OP,A,Y);}
001100 expr(A) ::= expr(A) CONCAT(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);}
001101 %type likeop {Token}
001102 likeop(A) ::= LIKE_KW|MATCH(A).
001103 likeop(A) ::= NOT LIKE_KW|MATCH(X). {A=X; A.n|=0x80000000; /*A-overwrite-X*/}
001104 expr(A) ::= expr(A) likeop(OP) expr(Y). [LIKE_KW] {
001105 ExprList *pList;
001106 int bNot = OP.n & 0x80000000;
001107 OP.n &= 0x7fffffff;
001108 pList = sqlite3ExprListAppend(pParse,0, Y);
001109 pList = sqlite3ExprListAppend(pParse,pList, A);
001110 A = sqlite3ExprFunction(pParse, pList, &OP, 0);
001111 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001112 if( A ) A->flags |= EP_InfixFunc;
001113 }
001114 expr(A) ::= expr(A) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] {
001115 ExprList *pList;
001116 int bNot = OP.n & 0x80000000;
001117 OP.n &= 0x7fffffff;
001118 pList = sqlite3ExprListAppend(pParse,0, Y);
001119 pList = sqlite3ExprListAppend(pParse,pList, A);
001120 pList = sqlite3ExprListAppend(pParse,pList, E);
001121 A = sqlite3ExprFunction(pParse, pList, &OP, 0);
001122 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001123 if( A ) A->flags |= EP_InfixFunc;
001124 }
001125
001126 expr(A) ::= expr(A) ISNULL|NOTNULL(E). {A = sqlite3PExpr(pParse,@E,A,0);}
001127 expr(A) ::= expr(A) NOT NULL. {A = sqlite3PExpr(pParse,TK_NOTNULL,A,0);}
001128
001129 %include {
001130 /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
001131 ** unary TK_ISNULL or TK_NOTNULL expression. */
001132 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
001133 sqlite3 *db = pParse->db;
001134 if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){
001135 pA->op = (u8)op;
001136 sqlite3ExprDelete(db, pA->pRight);
001137 pA->pRight = 0;
001138 }
001139 }
001140 }
001141
001142 // expr1 IS expr2
001143 // expr1 IS NOT expr2
001144 //
001145 // If expr2 is NULL then code as TK_ISNULL or TK_NOTNULL. If expr2
001146 // is any other expression, code as TK_IS or TK_ISNOT.
001147 //
001148 expr(A) ::= expr(A) IS expr(Y). {
001149 A = sqlite3PExpr(pParse,TK_IS,A,Y);
001150 binaryToUnaryIfNull(pParse, Y, A, TK_ISNULL);
001151 }
001152 expr(A) ::= expr(A) IS NOT expr(Y). {
001153 A = sqlite3PExpr(pParse,TK_ISNOT,A,Y);
001154 binaryToUnaryIfNull(pParse, Y, A, TK_NOTNULL);
001155 }
001156
001157 expr(A) ::= NOT(B) expr(X).
001158 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/}
001159 expr(A) ::= BITNOT(B) expr(X).
001160 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/}
001161 expr(A) ::= PLUS|MINUS(B) expr(X). [BITNOT] {
001162 A = sqlite3PExpr(pParse, @B==TK_PLUS ? TK_UPLUS : TK_UMINUS, X, 0);
001163 /*A-overwrites-B*/
001164 }
001165
001166 %type between_op {int}
001167 between_op(A) ::= BETWEEN. {A = 0;}
001168 between_op(A) ::= NOT BETWEEN. {A = 1;}
001169 expr(A) ::= expr(A) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
001170 ExprList *pList = sqlite3ExprListAppend(pParse,0, X);
001171 pList = sqlite3ExprListAppend(pParse,pList, Y);
001172 A = sqlite3PExpr(pParse, TK_BETWEEN, A, 0);
001173 if( A ){
001174 A->x.pList = pList;
001175 }else{
001176 sqlite3ExprListDelete(pParse->db, pList);
001177 }
001178 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001179 }
001180 %ifndef SQLITE_OMIT_SUBQUERY
001181 %type in_op {int}
001182 in_op(A) ::= IN. {A = 0;}
001183 in_op(A) ::= NOT IN. {A = 1;}
001184 expr(A) ::= expr(A) in_op(N) LP exprlist(Y) RP. [IN] {
001185 if( Y==0 ){
001186 /* Expressions of the form
001187 **
001188 ** expr1 IN ()
001189 ** expr1 NOT IN ()
001190 **
001191 ** simplify to constants 0 (false) and 1 (true), respectively,
001192 ** regardless of the value of expr1.
001193 */
001194 sqlite3ExprUnmapAndDelete(pParse, A);
001195 A = sqlite3Expr(pParse->db, TK_INTEGER, N ? "1" : "0");
001196 }else{
001197 A = sqlite3PExpr(pParse, TK_IN, A, 0);
001198 if( A ){
001199 A->x.pList = Y;
001200 sqlite3ExprSetHeightAndFlags(pParse, A);
001201 }else{
001202 sqlite3ExprListDelete(pParse->db, Y);
001203 }
001204 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001205 }
001206 }
001207 expr(A) ::= LP select(X) RP. {
001208 A = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
001209 sqlite3PExprAddSelect(pParse, A, X);
001210 }
001211 expr(A) ::= expr(A) in_op(N) LP select(Y) RP. [IN] {
001212 A = sqlite3PExpr(pParse, TK_IN, A, 0);
001213 sqlite3PExprAddSelect(pParse, A, Y);
001214 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001215 }
001216 expr(A) ::= expr(A) in_op(N) nm(Y) dbnm(Z) paren_exprlist(E). [IN] {
001217 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&Y,&Z);
001218 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
001219 if( E ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, E);
001220 A = sqlite3PExpr(pParse, TK_IN, A, 0);
001221 sqlite3PExprAddSelect(pParse, A, pSelect);
001222 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0);
001223 }
001224 expr(A) ::= EXISTS LP select(Y) RP. {
001225 Expr *p;
001226 p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
001227 sqlite3PExprAddSelect(pParse, p, Y);
001228 }
001229 %endif SQLITE_OMIT_SUBQUERY
001230
001231 /* CASE expressions */
001232 expr(A) ::= CASE case_operand(X) case_exprlist(Y) case_else(Z) END. {
001233 A = sqlite3PExpr(pParse, TK_CASE, X, 0);
001234 if( A ){
001235 A->x.pList = Z ? sqlite3ExprListAppend(pParse,Y,Z) : Y;
001236 sqlite3ExprSetHeightAndFlags(pParse, A);
001237 }else{
001238 sqlite3ExprListDelete(pParse->db, Y);
001239 sqlite3ExprDelete(pParse->db, Z);
001240 }
001241 }
001242 %type case_exprlist {ExprList*}
001243 %destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);}
001244 case_exprlist(A) ::= case_exprlist(A) WHEN expr(Y) THEN expr(Z). {
001245 A = sqlite3ExprListAppend(pParse,A, Y);
001246 A = sqlite3ExprListAppend(pParse,A, Z);
001247 }
001248 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
001249 A = sqlite3ExprListAppend(pParse,0, Y);
001250 A = sqlite3ExprListAppend(pParse,A, Z);
001251 }
001252 %type case_else {Expr*}
001253 %destructor case_else {sqlite3ExprDelete(pParse->db, $$);}
001254 case_else(A) ::= ELSE expr(X). {A = X;}
001255 case_else(A) ::= . {A = 0;}
001256 %type case_operand {Expr*}
001257 %destructor case_operand {sqlite3ExprDelete(pParse->db, $$);}
001258 case_operand(A) ::= expr(X). {A = X; /*A-overwrites-X*/}
001259 case_operand(A) ::= . {A = 0;}
001260
001261 %type exprlist {ExprList*}
001262 %destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);}
001263 %type nexprlist {ExprList*}
001264 %destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);}
001265
001266 exprlist(A) ::= nexprlist(A).
001267 exprlist(A) ::= . {A = 0;}
001268 nexprlist(A) ::= nexprlist(A) COMMA expr(Y).
001269 {A = sqlite3ExprListAppend(pParse,A,Y);}
001270 nexprlist(A) ::= expr(Y).
001271 {A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/}
001272
001273 %ifndef SQLITE_OMIT_SUBQUERY
001274 /* A paren_exprlist is an optional expression list contained inside
001275 ** of parenthesis */
001276 %type paren_exprlist {ExprList*}
001277 %destructor paren_exprlist {sqlite3ExprListDelete(pParse->db, $$);}
001278 paren_exprlist(A) ::= . {A = 0;}
001279 paren_exprlist(A) ::= LP exprlist(X) RP. {A = X;}
001280 %endif SQLITE_OMIT_SUBQUERY
001281
001282
001283 ///////////////////////////// The CREATE INDEX command ///////////////////////
001284 //
001285 cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)
001286 ON nm(Y) LP sortlist(Z) RP where_opt(W). {
001287 sqlite3CreateIndex(pParse, &X, &D,
001288 sqlite3SrcListAppend(pParse,0,&Y,0), Z, U,
001289 &S, W, SQLITE_SO_ASC, NE, SQLITE_IDXTYPE_APPDEF);
001290 if( IN_RENAME_OBJECT && pParse->pNewIndex ){
001291 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &Y);
001292 }
001293 }
001294
001295 %type uniqueflag {int}
001296 uniqueflag(A) ::= UNIQUE. {A = OE_Abort;}
001297 uniqueflag(A) ::= . {A = OE_None;}
001298
001299
001300 // The eidlist non-terminal (Expression Id List) generates an ExprList
001301 // from a list of identifiers. The identifier names are in ExprList.a[].zName.
001302 // This list is stored in an ExprList rather than an IdList so that it
001303 // can be easily sent to sqlite3ColumnsExprList().
001304 //
001305 // eidlist is grouped with CREATE INDEX because it used to be the non-terminal
001306 // used for the arguments to an index. That is just an historical accident.
001307 //
001308 // IMPORTANT COMPATIBILITY NOTE: Some prior versions of SQLite accepted
001309 // COLLATE clauses and ASC or DESC keywords on ID lists in inappropriate
001310 // places - places that might have been stored in the sqlite_master schema.
001311 // Those extra features were ignored. But because they might be in some
001312 // (busted) old databases, we need to continue parsing them when loading
001313 // historical schemas.
001314 //
001315 %type eidlist {ExprList*}
001316 %destructor eidlist {sqlite3ExprListDelete(pParse->db, $$);}
001317 %type eidlist_opt {ExprList*}
001318 %destructor eidlist_opt {sqlite3ExprListDelete(pParse->db, $$);}
001319
001320 %include {
001321 /* Add a single new term to an ExprList that is used to store a
001322 ** list of identifiers. Report an error if the ID list contains
001323 ** a COLLATE clause or an ASC or DESC keyword, except ignore the
001324 ** error while parsing a legacy schema.
001325 */
001326 static ExprList *parserAddExprIdListTerm(
001327 Parse *pParse,
001328 ExprList *pPrior,
001329 Token *pIdToken,
001330 int hasCollate,
001331 int sortOrder
001332 ){
001333 ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
001334 if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED)
001335 && pParse->db->init.busy==0
001336 ){
001337 sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
001338 pIdToken->n, pIdToken->z);
001339 }
001340 sqlite3ExprListSetName(pParse, p, pIdToken, 1);
001341 return p;
001342 }
001343 } // end %include
001344
001345 eidlist_opt(A) ::= . {A = 0;}
001346 eidlist_opt(A) ::= LP eidlist(X) RP. {A = X;}
001347 eidlist(A) ::= eidlist(A) COMMA nm(Y) collate(C) sortorder(Z). {
001348 A = parserAddExprIdListTerm(pParse, A, &Y, C, Z);
001349 }
001350 eidlist(A) ::= nm(Y) collate(C) sortorder(Z). {
001351 A = parserAddExprIdListTerm(pParse, 0, &Y, C, Z); /*A-overwrites-Y*/
001352 }
001353
001354 %type collate {int}
001355 collate(C) ::= . {C = 0;}
001356 collate(C) ::= COLLATE ids. {C = 1;}
001357
001358
001359 ///////////////////////////// The DROP INDEX command /////////////////////////
001360 //
001361 cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);}
001362
001363 ///////////////////////////// The VACUUM command /////////////////////////////
001364 //
001365 %ifndef SQLITE_OMIT_VACUUM
001366 %ifndef SQLITE_OMIT_ATTACH
001367 %type vinto {Expr*}
001368 %destructor vinto {sqlite3ExprDelete(pParse->db, $$);}
001369 cmd ::= VACUUM vinto(Y). {sqlite3Vacuum(pParse,0,Y);}
001370 cmd ::= VACUUM nm(X) vinto(Y). {sqlite3Vacuum(pParse,&X,Y);}
001371 vinto(A) ::= INTO expr(X). {A = X;}
001372 vinto(A) ::= . {A = 0;}
001373 %endif SQLITE_OMIT_ATTACH
001374 %endif SQLITE_OMIT_VACUUM
001375
001376 ///////////////////////////// The PRAGMA command /////////////////////////////
001377 //
001378 %ifndef SQLITE_OMIT_PRAGMA
001379 cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);}
001380 cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
001381 cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
001382 cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y).
001383 {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
001384 cmd ::= PRAGMA nm(X) dbnm(Z) LP minus_num(Y) RP.
001385 {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
001386
001387 nmnum(A) ::= plus_num(A).
001388 nmnum(A) ::= nm(A).
001389 nmnum(A) ::= ON(A).
001390 nmnum(A) ::= DELETE(A).
001391 nmnum(A) ::= DEFAULT(A).
001392 %endif SQLITE_OMIT_PRAGMA
001393 %token_class number INTEGER|FLOAT.
001394 plus_num(A) ::= PLUS number(X). {A = X;}
001395 plus_num(A) ::= number(A).
001396 minus_num(A) ::= MINUS number(X). {A = X;}
001397 //////////////////////////// The CREATE TRIGGER command /////////////////////
001398
001399 %ifndef SQLITE_OMIT_TRIGGER
001400
001401 cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
001402 Token all;
001403 all.z = A.z;
001404 all.n = (int)(Z.z - A.z) + Z.n;
001405 sqlite3FinishTrigger(pParse, S, &all);
001406 }
001407
001408 trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z)
001409 trigger_time(C) trigger_event(D)
001410 ON fullname(E) foreach_clause when_clause(G). {
001411 sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR);
001412 A = (Z.n==0?B:Z); /*A-overwrites-T*/
001413 }
001414
001415 %type trigger_time {int}
001416 trigger_time(A) ::= BEFORE|AFTER(X). { A = @X; /*A-overwrites-X*/ }
001417 trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
001418 trigger_time(A) ::= . { A = TK_BEFORE; }
001419
001420 %type trigger_event {struct TrigEvent}
001421 %destructor trigger_event {sqlite3IdListDelete(pParse->db, $$.b);}
001422 trigger_event(A) ::= DELETE|INSERT(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;}
001423 trigger_event(A) ::= UPDATE(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;}
001424 trigger_event(A) ::= UPDATE OF idlist(X).{A.a = TK_UPDATE; A.b = X;}
001425
001426 foreach_clause ::= .
001427 foreach_clause ::= FOR EACH ROW.
001428
001429 %type when_clause {Expr*}
001430 %destructor when_clause {sqlite3ExprDelete(pParse->db, $$);}
001431 when_clause(A) ::= . { A = 0; }
001432 when_clause(A) ::= WHEN expr(X). { A = X; }
001433
001434 %type trigger_cmd_list {TriggerStep*}
001435 %destructor trigger_cmd_list {sqlite3DeleteTriggerStep(pParse->db, $$);}
001436 trigger_cmd_list(A) ::= trigger_cmd_list(A) trigger_cmd(X) SEMI. {
001437 assert( A!=0 );
001438 A->pLast->pNext = X;
001439 A->pLast = X;
001440 }
001441 trigger_cmd_list(A) ::= trigger_cmd(A) SEMI. {
001442 assert( A!=0 );
001443 A->pLast = A;
001444 }
001445
001446 // Disallow qualified table names on INSERT, UPDATE, and DELETE statements
001447 // within a trigger. The table to INSERT, UPDATE, or DELETE is always in
001448 // the same database as the table that the trigger fires on.
001449 //
001450 %type trnm {Token}
001451 trnm(A) ::= nm(A).
001452 trnm(A) ::= nm DOT nm(X). {
001453 A = X;
001454 sqlite3ErrorMsg(pParse,
001455 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
001456 "statements within triggers");
001457 }
001458
001459 // Disallow the INDEX BY and NOT INDEXED clauses on UPDATE and DELETE
001460 // statements within triggers. We make a specific error message for this
001461 // since it is an exception to the default grammar rules.
001462 //
001463 tridxby ::= .
001464 tridxby ::= INDEXED BY nm. {
001465 sqlite3ErrorMsg(pParse,
001466 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
001467 "within triggers");
001468 }
001469 tridxby ::= NOT INDEXED. {
001470 sqlite3ErrorMsg(pParse,
001471 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
001472 "within triggers");
001473 }
001474
001475
001476
001477 %type trigger_cmd {TriggerStep*}
001478 %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);}
001479 // UPDATE
001480 trigger_cmd(A) ::=
001481 UPDATE(B) orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z) scanpt(E).
001482 {A = sqlite3TriggerUpdateStep(pParse, &X, Y, Z, R, B.z, E);}
001483
001484 // INSERT
001485 trigger_cmd(A) ::= scanpt(B) insert_cmd(R) INTO
001486 trnm(X) idlist_opt(F) select(S) upsert(U) scanpt(Z). {
001487 A = sqlite3TriggerInsertStep(pParse,&X,F,S,R,U,B,Z);/*A-overwrites-R*/
001488 }
001489 // DELETE
001490 trigger_cmd(A) ::= DELETE(B) FROM trnm(X) tridxby where_opt(Y) scanpt(E).
001491 {A = sqlite3TriggerDeleteStep(pParse, &X, Y, B.z, E);}
001492
001493 // SELECT
001494 trigger_cmd(A) ::= scanpt(B) select(X) scanpt(E).
001495 {A = sqlite3TriggerSelectStep(pParse->db, X, B, E); /*A-overwrites-X*/}
001496
001497 // The special RAISE expression that may occur in trigger programs
001498 expr(A) ::= RAISE LP IGNORE RP. {
001499 A = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
001500 if( A ){
001501 A->affExpr = OE_Ignore;
001502 }
001503 }
001504 expr(A) ::= RAISE LP raisetype(T) COMMA nm(Z) RP. {
001505 A = sqlite3ExprAlloc(pParse->db, TK_RAISE, &Z, 1);
001506 if( A ) {
001507 A->affExpr = (char)T;
001508 }
001509 }
001510 %endif !SQLITE_OMIT_TRIGGER
001511
001512 %type raisetype {int}
001513 raisetype(A) ::= ROLLBACK. {A = OE_Rollback;}
001514 raisetype(A) ::= ABORT. {A = OE_Abort;}
001515 raisetype(A) ::= FAIL. {A = OE_Fail;}
001516
001517
001518 //////////////////////// DROP TRIGGER statement //////////////////////////////
001519 %ifndef SQLITE_OMIT_TRIGGER
001520 cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
001521 sqlite3DropTrigger(pParse,X,NOERR);
001522 }
001523 %endif !SQLITE_OMIT_TRIGGER
001524
001525 //////////////////////// ATTACH DATABASE file AS name /////////////////////////
001526 %ifndef SQLITE_OMIT_ATTACH
001527 cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). {
001528 sqlite3Attach(pParse, F, D, K);
001529 }
001530 cmd ::= DETACH database_kw_opt expr(D). {
001531 sqlite3Detach(pParse, D);
001532 }
001533
001534 %type key_opt {Expr*}
001535 %destructor key_opt {sqlite3ExprDelete(pParse->db, $$);}
001536 key_opt(A) ::= . { A = 0; }
001537 key_opt(A) ::= KEY expr(X). { A = X; }
001538
001539 database_kw_opt ::= DATABASE.
001540 database_kw_opt ::= .
001541 %endif SQLITE_OMIT_ATTACH
001542
001543 ////////////////////////// REINDEX collation //////////////////////////////////
001544 %ifndef SQLITE_OMIT_REINDEX
001545 cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);}
001546 cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);}
001547 %endif SQLITE_OMIT_REINDEX
001548
001549 /////////////////////////////////// ANALYZE ///////////////////////////////////
001550 %ifndef SQLITE_OMIT_ANALYZE
001551 cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);}
001552 cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);}
001553 %endif
001554
001555 //////////////////////// ALTER TABLE table ... ////////////////////////////////
001556 %ifndef SQLITE_OMIT_ALTERTABLE
001557 cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). {
001558 sqlite3AlterRenameTable(pParse,X,&Z);
001559 }
001560 cmd ::= ALTER TABLE add_column_fullname
001561 ADD kwcolumn_opt columnname(Y) carglist. {
001562 Y.n = (int)(pParse->sLastToken.z-Y.z) + pParse->sLastToken.n;
001563 sqlite3AlterFinishAddColumn(pParse, &Y);
001564 }
001565 add_column_fullname ::= fullname(X). {
001566 disableLookaside(pParse);
001567 sqlite3AlterBeginAddColumn(pParse, X);
001568 }
001569 cmd ::= ALTER TABLE fullname(X) RENAME kwcolumn_opt nm(Y) TO nm(Z). {
001570 sqlite3AlterRenameColumn(pParse, X, &Y, &Z);
001571 }
001572
001573 kwcolumn_opt ::= .
001574 kwcolumn_opt ::= COLUMNKW.
001575
001576 %endif SQLITE_OMIT_ALTERTABLE
001577
001578 //////////////////////// CREATE VIRTUAL TABLE ... /////////////////////////////
001579 %ifndef SQLITE_OMIT_VIRTUALTABLE
001580 cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);}
001581 cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);}
001582 create_vtab ::= createkw VIRTUAL TABLE ifnotexists(E)
001583 nm(X) dbnm(Y) USING nm(Z). {
001584 sqlite3VtabBeginParse(pParse, &X, &Y, &Z, E);
001585 }
001586 vtabarglist ::= vtabarg.
001587 vtabarglist ::= vtabarglist COMMA vtabarg.
001588 vtabarg ::= . {sqlite3VtabArgInit(pParse);}
001589 vtabarg ::= vtabarg vtabargtoken.
001590 vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);}
001591 vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);}
001592 lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);}
001593 anylist ::= .
001594 anylist ::= anylist LP anylist RP.
001595 anylist ::= anylist ANY.
001596 %endif SQLITE_OMIT_VIRTUALTABLE
001597
001598
001599 //////////////////////// COMMON TABLE EXPRESSIONS ////////////////////////////
001600 %type wqlist {With*}
001601 %destructor wqlist {sqlite3WithDelete(pParse->db, $$);}
001602
001603 with ::= .
001604 %ifndef SQLITE_OMIT_CTE
001605 with ::= WITH wqlist(W). { sqlite3WithPush(pParse, W, 1); }
001606 with ::= WITH RECURSIVE wqlist(W). { sqlite3WithPush(pParse, W, 1); }
001607
001608 wqlist(A) ::= nm(X) eidlist_opt(Y) AS LP select(Z) RP. {
001609 A = sqlite3WithAdd(pParse, 0, &X, Y, Z); /*A-overwrites-X*/
001610 }
001611 wqlist(A) ::= wqlist(A) COMMA nm(X) eidlist_opt(Y) AS LP select(Z) RP. {
001612 A = sqlite3WithAdd(pParse, A, &X, Y, Z);
001613 }
001614 %endif SQLITE_OMIT_CTE
001615
001616 //////////////////////// WINDOW FUNCTION EXPRESSIONS /////////////////////////
001617 // These must be at the end of this file. Specifically, the rules that
001618 // introduce tokens WINDOW, OVER and FILTER must appear last. This causes
001619 // the integer values assigned to these tokens to be larger than all other
001620 // tokens that may be output by the tokenizer except TK_SPACE and TK_ILLEGAL.
001621 //
001622 %ifndef SQLITE_OMIT_WINDOWFUNC
001623 %type windowdefn_list {Window*}
001624 %destructor windowdefn_list {sqlite3WindowListDelete(pParse->db, $$);}
001625 windowdefn_list(A) ::= windowdefn(Z). { A = Z; }
001626 windowdefn_list(A) ::= windowdefn_list(Y) COMMA windowdefn(Z). {
001627 assert( Z!=0 );
001628 sqlite3WindowChain(pParse, Z, Y);
001629 Z->pNextWin = Y;
001630 A = Z;
001631 }
001632
001633 %type windowdefn {Window*}
001634 %destructor windowdefn {sqlite3WindowDelete(pParse->db, $$);}
001635 windowdefn(A) ::= nm(X) AS LP window(Y) RP. {
001636 if( ALWAYS(Y) ){
001637 Y->zName = sqlite3DbStrNDup(pParse->db, X.z, X.n);
001638 }
001639 A = Y;
001640 }
001641
001642 %type window {Window*}
001643 %destructor window {sqlite3WindowDelete(pParse->db, $$);}
001644
001645 %type frame_opt {Window*}
001646 %destructor frame_opt {sqlite3WindowDelete(pParse->db, $$);}
001647
001648 %type part_opt {ExprList*}
001649 %destructor part_opt {sqlite3ExprListDelete(pParse->db, $$);}
001650
001651 %type filter_clause {Expr*}
001652 %destructor filter_clause {sqlite3ExprDelete(pParse->db, $$);}
001653
001654 %type over_clause {Window*}
001655 %destructor over_clause {sqlite3WindowDelete(pParse->db, $$);}
001656
001657 %type filter_over {Window*}
001658 %destructor filter_over {sqlite3WindowDelete(pParse->db, $$);}
001659
001660 %type range_or_rows {int}
001661
001662 %type frame_bound {struct FrameBound}
001663 %destructor frame_bound {sqlite3ExprDelete(pParse->db, $$.pExpr);}
001664 %type frame_bound_s {struct FrameBound}
001665 %destructor frame_bound_s {sqlite3ExprDelete(pParse->db, $$.pExpr);}
001666 %type frame_bound_e {struct FrameBound}
001667 %destructor frame_bound_e {sqlite3ExprDelete(pParse->db, $$.pExpr);}
001668
001669 window(A) ::= PARTITION BY nexprlist(X) orderby_opt(Y) frame_opt(Z). {
001670 A = sqlite3WindowAssemble(pParse, Z, X, Y, 0);
001671 }
001672 window(A) ::= nm(W) PARTITION BY nexprlist(X) orderby_opt(Y) frame_opt(Z). {
001673 A = sqlite3WindowAssemble(pParse, Z, X, Y, &W);
001674 }
001675 window(A) ::= ORDER BY sortlist(Y) frame_opt(Z). {
001676 A = sqlite3WindowAssemble(pParse, Z, 0, Y, 0);
001677 }
001678 window(A) ::= nm(W) ORDER BY sortlist(Y) frame_opt(Z). {
001679 A = sqlite3WindowAssemble(pParse, Z, 0, Y, &W);
001680 }
001681 window(A) ::= frame_opt(Z). {
001682 A = Z;
001683 }
001684 window(A) ::= nm(W) frame_opt(Z). {
001685 A = sqlite3WindowAssemble(pParse, Z, 0, 0, &W);
001686 }
001687
001688 frame_opt(A) ::= . {
001689 A = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
001690 }
001691 frame_opt(A) ::= range_or_rows(X) frame_bound_s(Y) frame_exclude_opt(Z). {
001692 A = sqlite3WindowAlloc(pParse, X, Y.eType, Y.pExpr, TK_CURRENT, 0, Z);
001693 }
001694 frame_opt(A) ::= range_or_rows(X) BETWEEN frame_bound_s(Y) AND
001695 frame_bound_e(Z) frame_exclude_opt(W). {
001696 A = sqlite3WindowAlloc(pParse, X, Y.eType, Y.pExpr, Z.eType, Z.pExpr, W);
001697 }
001698
001699 range_or_rows(A) ::= RANGE|ROWS|GROUPS(X). {A = @X; /*A-overwrites-X*/}
001700
001701 frame_bound_s(A) ::= frame_bound(X). {A = X;}
001702 frame_bound_s(A) ::= UNBOUNDED(X) PRECEDING. {A.eType = @X; A.pExpr = 0;}
001703 frame_bound_e(A) ::= frame_bound(X). {A = X;}
001704 frame_bound_e(A) ::= UNBOUNDED(X) FOLLOWING. {A.eType = @X; A.pExpr = 0;}
001705
001706 frame_bound(A) ::= expr(X) PRECEDING|FOLLOWING(Y).
001707 {A.eType = @Y; A.pExpr = X;}
001708 frame_bound(A) ::= CURRENT(X) ROW. {A.eType = @X; A.pExpr = 0;}
001709
001710 %type frame_exclude_opt {u8}
001711 frame_exclude_opt(A) ::= . {A = 0;}
001712 frame_exclude_opt(A) ::= EXCLUDE frame_exclude(X). {A = X;}
001713
001714 %type frame_exclude {u8}
001715 frame_exclude(A) ::= NO(X) OTHERS. {A = @X; /*A-overwrites-X*/}
001716 frame_exclude(A) ::= CURRENT(X) ROW. {A = @X; /*A-overwrites-X*/}
001717 frame_exclude(A) ::= GROUP|TIES(X). {A = @X; /*A-overwrites-X*/}
001718
001719
001720 %type window_clause {Window*}
001721 %destructor window_clause {sqlite3WindowListDelete(pParse->db, $$);}
001722 window_clause(A) ::= WINDOW windowdefn_list(B). { A = B; }
001723
001724 filter_over(A) ::= filter_clause(F) over_clause(O). {
001725 O->pFilter = F;
001726 A = O;
001727 }
001728 filter_over(A) ::= over_clause(O). {
001729 A = O;
001730 }
001731 filter_over(A) ::= filter_clause(F). {
001732 A = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
001733 if( A ){
001734 A->eFrmType = TK_FILTER;
001735 A->pFilter = F;
001736 }else{
001737 sqlite3ExprDelete(pParse->db, F);
001738 }
001739 }
001740
001741 over_clause(A) ::= OVER LP window(Z) RP. {
001742 A = Z;
001743 assert( A!=0 );
001744 }
001745 over_clause(A) ::= OVER nm(Z). {
001746 A = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
001747 if( A ){
001748 A->zName = sqlite3DbStrNDup(pParse->db, Z.z, Z.n);
001749 }
001750 }
001751
001752 filter_clause(A) ::= FILTER LP WHERE expr(X) RP. { A = X; }
001753 %endif /* SQLITE_OMIT_WINDOWFUNC */
001754
001755 /*
001756 ** The code generator needs some extra TK_ token values for tokens that
001757 ** are synthesized and do not actually appear in the grammar:
001758 */
001759 %token
001760 COLUMN /* Reference to a table column */
001761 AGG_FUNCTION /* An aggregate function */
001762 AGG_COLUMN /* An aggregated column */
001763 TRUEFALSE /* True or false keyword */
001764 ISNOT /* Combination of IS and NOT */
001765 FUNCTION /* A function invocation */
001766 UMINUS /* Unary minus */
001767 UPLUS /* Unary plus */
001768 TRUTH /* IS TRUE or IS FALSE or IS NOT TRUE or IS NOT FALSE */
001769 REGISTER /* Reference to a VDBE register */
001770 VECTOR /* Vector */
001771 SELECT_COLUMN /* Choose a single column from a multi-column SELECT */
001772 IF_NULL_ROW /* the if-null-row operator */
001773 ASTERISK /* The "*" in count(*) and similar */
001774 SPAN /* The span operator */
001775 .
001776 /* There must be no more than 255 tokens defined above. If this grammar
001777 ** is extended with new rules and tokens, they must either be so few in
001778 ** number that TK_SPAN is no more than 255, or else the new tokens must
001779 ** appear after this line.
001780 */
001781 %include {
001782 #if TK_SPAN>255
001783 # error too many tokens in the grammar
001784 #endif
001785 }
001786
001787 /*
001788 ** The TK_SPACE and TK_ILLEGAL tokens must be the last two tokens. The
001789 ** parser depends on this. Those tokens are not used in any grammar rule.
001790 ** They are only used by the tokenizer. Declare them last so that they
001791 ** are guaranteed to be the last two tokens
001792 */
001793 %token SPACE ILLEGAL.