1 /* 2 ** 2001 September 15 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ************************************************************************* 12 ** This file contains SQLite's grammar for SQL. Process this file 13 ** using the lemon parser generator to generate C code that runs 14 ** the parser. Lemon will also generate a header file containing 15 ** numeric codes for all of the tokens. 16 */ 17 18 // All token codes are small integers with #defines that begin with "TK_" 19 %token_prefix TK_ 20 21 // The type of the data attached to each token is Token. This is also the 22 // default type for non-terminals. 23 // 24 %token_type {Token} 25 %default_type {Token} 26 27 // An extra argument to the constructor for the parser, which is available 28 // to all actions. 29 %extra_context {Parse *pParse} 30 31 // This code runs whenever there is a syntax error 32 // 33 %syntax_error { 34 UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */ 35 if( TOKEN.z[0] ){ 36 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); 37 }else{ 38 sqlite3ErrorMsg(pParse, "incomplete input"); 39 } 40 } 41 %stack_overflow { 42 sqlite3ErrorMsg(pParse, "parser stack overflow"); 43 } 44 45 // The name of the generated procedure that implements the parser 46 // is as follows: 47 %name sqlite3Parser 48 49 // The following text is included near the beginning of the C source 50 // code file that implements the parser. 51 // 52 %include { 53 #include "sqliteInt.h" 54 55 /* 56 ** Disable all error recovery processing in the parser push-down 57 ** automaton. 58 */ 59 #define YYNOERRORRECOVERY 1 60 61 /* 62 ** Make yytestcase() the same as testcase() 63 */ 64 #define yytestcase(X) testcase(X) 65 66 /* 67 ** Indicate that sqlite3ParserFree() will never be called with a null 68 ** pointer. 69 */ 70 #define YYPARSEFREENEVERNULL 1 71 72 /* 73 ** In the amalgamation, the parse.c file generated by lemon and the 74 ** tokenize.c file are concatenated. In that case, sqlite3RunParser() 75 ** has access to the the size of the yyParser object and so the parser 76 ** engine can be allocated from stack. In that case, only the 77 ** sqlite3ParserInit() and sqlite3ParserFinalize() routines are invoked 78 ** and the sqlite3ParserAlloc() and sqlite3ParserFree() routines can be 79 ** omitted. 80 */ 81 #ifdef SQLITE_AMALGAMATION 82 # define sqlite3Parser_ENGINEALWAYSONSTACK 1 83 #endif 84 85 /* 86 ** Alternative datatype for the argument to the malloc() routine passed 87 ** into sqlite3ParserAlloc(). The default is size_t. 88 */ 89 #define YYMALLOCARGTYPE u64 90 91 /* 92 ** An instance of the following structure describes the event of a 93 ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, 94 ** TK_DELETE, or TK_INSTEAD. If the event is of the form 95 ** 96 ** UPDATE ON (a,b,c) 97 ** 98 ** Then the "b" IdList records the list "a,b,c". 99 */ 100 struct TrigEvent { int a; IdList * b; }; 101 102 struct FrameBound { int eType; Expr *pExpr; }; 103 104 /* 105 ** Disable lookaside memory allocation for objects that might be 106 ** shared across database connections. 107 */ 108 static void disableLookaside(Parse *pParse){ 109 sqlite3 *db = pParse->db; 110 pParse->disableLookaside++; 111 DisableLookaside; 112 } 113 114 #ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 115 /* 116 ** Issue an error message if an ORDER BY or LIMIT clause occurs on an 117 ** UPDATE or DELETE statement. 118 */ 119 static void updateDeleteLimitError( 120 Parse *pParse, 121 ExprList *pOrderBy, 122 Expr *pLimit 123 ){ 124 if( pOrderBy ){ 125 sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\""); 126 }else{ 127 sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\""); 128 } 129 sqlite3ExprListDelete(pParse->db, pOrderBy); 130 sqlite3ExprDelete(pParse->db, pLimit); 131 } 132 #endif /* SQLITE_ENABLE_UPDATE_DELETE_LIMIT */ 133 134 } // end %include 135 136 // Input is a single SQL command 137 input ::= cmdlist. 138 cmdlist ::= cmdlist ecmd. 139 cmdlist ::= ecmd. 140 ecmd ::= SEMI. 141 ecmd ::= cmdx SEMI. 142 %ifndef SQLITE_OMIT_EXPLAIN 143 ecmd ::= explain cmdx SEMI. {NEVER-REDUCE} 144 explain ::= EXPLAIN. { pParse->explain = 1; } 145 explain ::= EXPLAIN QUERY PLAN. { pParse->explain = 2; } 146 %endif SQLITE_OMIT_EXPLAIN 147 cmdx ::= cmd. { sqlite3FinishCoding(pParse); } 148 149 ///////////////////// Begin and end transactions. //////////////////////////// 150 // 151 152 cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);} 153 trans_opt ::= . 154 trans_opt ::= TRANSACTION. 155 trans_opt ::= TRANSACTION nm. 156 %type transtype {int} 157 transtype(A) ::= . {A = TK_DEFERRED;} 158 transtype(A) ::= DEFERRED(X). {A = @X; /*A-overwrites-X*/} 159 transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/} 160 transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/} 161 cmd ::= COMMIT|END(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} 162 cmd ::= ROLLBACK(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} 163 164 savepoint_opt ::= SAVEPOINT. 165 savepoint_opt ::= . 166 cmd ::= SAVEPOINT nm(X). { 167 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X); 168 } 169 cmd ::= RELEASE savepoint_opt nm(X). { 170 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X); 171 } 172 cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). { 173 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X); 174 } 175 176 ///////////////////// The CREATE TABLE statement //////////////////////////// 177 // 178 cmd ::= create_table create_table_args. 179 create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). { 180 sqlite3StartTable(pParse,&Y,&Z,T,0,0,E); 181 } 182 createkw(A) ::= CREATE(A). {disableLookaside(pParse);} 183 184 %type ifnotexists {int} 185 ifnotexists(A) ::= . {A = 0;} 186 ifnotexists(A) ::= IF NOT EXISTS. {A = 1;} 187 %type temp {int} 188 %ifndef SQLITE_OMIT_TEMPDB 189 temp(A) ::= TEMP. {A = 1;} 190 %endif SQLITE_OMIT_TEMPDB 191 temp(A) ::= . {A = 0;} 192 create_table_args ::= LP columnlist conslist_opt(X) RP(E) table_options(F). { 193 sqlite3EndTable(pParse,&X,&E,F,0); 194 } 195 create_table_args ::= AS select(S). { 196 sqlite3EndTable(pParse,0,0,0,S); 197 sqlite3SelectDelete(pParse->db, S); 198 } 199 %type table_options {int} 200 table_options(A) ::= . {A = 0;} 201 table_options(A) ::= WITHOUT nm(X). { 202 if( X.n==5 && sqlite3_strnicmp(X.z,"rowid",5)==0 ){ 203 A = TF_WithoutRowid | TF_NoVisibleRowid; 204 }else{ 205 A = 0; 206 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", X.n, X.z); 207 } 208 } 209 columnlist ::= columnlist COMMA columnname carglist. 210 columnlist ::= columnname carglist. 211 columnname(A) ::= nm(A) typetoken(Y). {sqlite3AddColumn(pParse,&A,&Y);} 212 213 // Declare some tokens early in order to influence their values, to 214 // improve performance and reduce the executable size. The goal here is 215 // to get the "jump" operations in ISNULL through ESCAPE to have numeric 216 // values that are early enough so that all jump operations are clustered 217 // at the beginning. 218 // 219 %token ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST. 220 %token CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL. 221 %token OR AND NOT IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ. 222 %token GT LE LT GE ESCAPE. 223 224 // The following directive causes tokens ABORT, AFTER, ASC, etc. to 225 // fallback to ID if they will not parse as their original value. 226 // This obviates the need for the "id" nonterminal. 227 // 228 %fallback ID 229 ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW 230 CONFLICT DATABASE DEFERRED DESC DETACH DO 231 EACH END EXCLUSIVE EXPLAIN FAIL FOR 232 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH NO PLAN 233 QUERY KEY OF OFFSET PRAGMA RAISE RECURSIVE RELEASE REPLACE RESTRICT ROW ROWS 234 ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT 235 NULLS FIRST LAST 236 %ifdef SQLITE_OMIT_COMPOUND_SELECT 237 EXCEPT INTERSECT UNION 238 %endif SQLITE_OMIT_COMPOUND_SELECT 239 %ifndef SQLITE_OMIT_WINDOWFUNC 240 CURRENT FOLLOWING PARTITION PRECEDING RANGE UNBOUNDED 241 EXCLUDE GROUPS OTHERS TIES 242 %endif SQLITE_OMIT_WINDOWFUNC 243 %ifndef SQLITE_OMIT_GENERATED_COLUMNS 244 GENERATED ALWAYS 245 %endif 246 REINDEX RENAME CTIME_KW IF 247 . 248 %wildcard ANY. 249 250 // Define operator precedence early so that this is the first occurrence 251 // of the operator tokens in the grammer. Keeping the operators together 252 // causes them to be assigned integer values that are close together, 253 // which keeps parser tables smaller. 254 // 255 // The token values assigned to these symbols is determined by the order 256 // in which lemon first sees them. It must be the case that ISNULL/NOTNULL, 257 // NE/EQ, GT/LE, and GE/LT are separated by only a single value. See 258 // the sqlite3ExprIfFalse() routine for additional information on this 259 // constraint. 260 // 261 %left OR. 262 %left AND. 263 %right NOT. 264 %left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ. 265 %left GT LE LT GE. 266 %right ESCAPE. 267 %left BITAND BITOR LSHIFT RSHIFT. 268 %left PLUS MINUS. 269 %left STAR SLASH REM. 270 %left CONCAT. 271 %left COLLATE. 272 %right BITNOT. 273 %nonassoc ON. 274 275 // An IDENTIFIER can be a generic identifier, or one of several 276 // keywords. Any non-standard keyword can also be an identifier. 277 // 278 %token_class id ID|INDEXED. 279 280 281 // And "ids" is an identifer-or-string. 282 // 283 %token_class ids ID|STRING. 284 285 // The name of a column or table can be any of the following: 286 // 287 %type nm {Token} 288 nm(A) ::= id(A). 289 nm(A) ::= STRING(A). 290 nm(A) ::= JOIN_KW(A). 291 292 // A typetoken is really zero or more tokens that form a type name such 293 // as can be found after the column name in a CREATE TABLE statement. 294 // Multiple tokens are concatenated to form the value of the typetoken. 295 // 296 %type typetoken {Token} 297 typetoken(A) ::= . {A.n = 0; A.z = 0;} 298 typetoken(A) ::= typename(A). 299 typetoken(A) ::= typename(A) LP signed RP(Y). { 300 A.n = (int)(&Y.z[Y.n] - A.z); 301 } 302 typetoken(A) ::= typename(A) LP signed COMMA signed RP(Y). { 303 A.n = (int)(&Y.z[Y.n] - A.z); 304 } 305 %type typename {Token} 306 typename(A) ::= ids(A). 307 typename(A) ::= typename(A) ids(Y). {A.n=Y.n+(int)(Y.z-A.z);} 308 signed ::= plus_num. 309 signed ::= minus_num. 310 311 // The scanpt non-terminal takes a value which is a pointer to the 312 // input text just past the last token that has been shifted into 313 // the parser. By surrounding some phrase in the grammar with two 314 // scanpt non-terminals, we can capture the input text for that phrase. 315 // For example: 316 // 317 // something ::= .... scanpt(A) phrase scanpt(Z). 318 // 319 // The text that is parsed as "phrase" is a string starting at A 320 // and containing (int)(Z-A) characters. There might be some extra 321 // whitespace on either end of the text, but that can be removed in 322 // post-processing, if needed. 323 // 324 %type scanpt {const char*} 325 scanpt(A) ::= . { 326 assert( yyLookahead!=YYNOCODE ); 327 A = yyLookaheadToken.z; 328 } 329 scantok(A) ::= . { 330 assert( yyLookahead!=YYNOCODE ); 331 A = yyLookaheadToken; 332 } 333 334 // "carglist" is a list of additional constraints that come after the 335 // column name and column type in a CREATE TABLE statement. 336 // 337 carglist ::= carglist ccons. 338 carglist ::= . 339 ccons ::= CONSTRAINT nm(X). {pParse->constraintName = X;} 340 ccons ::= DEFAULT scantok(A) term(X). 341 {sqlite3AddDefaultValue(pParse,X,A.z,&A.z[A.n]);} 342 ccons ::= DEFAULT LP(A) expr(X) RP(Z). 343 {sqlite3AddDefaultValue(pParse,X,A.z+1,Z.z);} 344 ccons ::= DEFAULT PLUS(A) scantok(Z) term(X). 345 {sqlite3AddDefaultValue(pParse,X,A.z,&Z.z[Z.n]);} 346 ccons ::= DEFAULT MINUS(A) scantok(Z) term(X). { 347 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0); 348 sqlite3AddDefaultValue(pParse,p,A.z,&Z.z[Z.n]); 349 } 350 ccons ::= DEFAULT scantok id(X). { 351 Expr *p = tokenExpr(pParse, TK_STRING, X); 352 if( p ){ 353 sqlite3ExprIdToTrueFalse(p); 354 testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) ); 355 } 356 sqlite3AddDefaultValue(pParse,p,X.z,X.z+X.n); 357 } 358 359 // In addition to the type name, we also care about the primary key and 360 // UNIQUE constraints. 361 // 362 ccons ::= NULL onconf. 363 ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);} 364 ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I). 365 {sqlite3AddPrimaryKey(pParse,0,R,I,Z);} 366 ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0, 367 SQLITE_IDXTYPE_UNIQUE);} 368 ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X);} 369 ccons ::= REFERENCES nm(T) eidlist_opt(TA) refargs(R). 370 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);} 371 ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);} 372 ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);} 373 ccons ::= GENERATED ALWAYS AS generated. 374 ccons ::= AS generated. 375 generated ::= LP expr(E) RP. {sqlite3AddGenerated(pParse,E,0);} 376 generated ::= LP expr(E) RP ID(TYPE). {sqlite3AddGenerated(pParse,E,&TYPE);} 377 378 // The optional AUTOINCREMENT keyword 379 %type autoinc {int} 380 autoinc(X) ::= . {X = 0;} 381 autoinc(X) ::= AUTOINCR. {X = 1;} 382 383 // The next group of rules parses the arguments to a REFERENCES clause 384 // that determine if the referential integrity checking is deferred or 385 // or immediate and which determine what action to take if a ref-integ 386 // check fails. 387 // 388 %type refargs {int} 389 refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */} 390 refargs(A) ::= refargs(A) refarg(Y). { A = (A & ~Y.mask) | Y.value; } 391 %type refarg {struct {int value; int mask;}} 392 refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; } 393 refarg(A) ::= ON INSERT refact. { A.value = 0; A.mask = 0x000000; } 394 refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; } 395 refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; } 396 %type refact {int} 397 refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */} 398 refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */} 399 refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */} 400 refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */} 401 refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */} 402 %type defer_subclause {int} 403 defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt. {A = 0;} 404 defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;} 405 %type init_deferred_pred_opt {int} 406 init_deferred_pred_opt(A) ::= . {A = 0;} 407 init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;} 408 init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;} 409 410 conslist_opt(A) ::= . {A.n = 0; A.z = 0;} 411 conslist_opt(A) ::= COMMA(A) conslist. 412 conslist ::= conslist tconscomma tcons. 413 conslist ::= tcons. 414 tconscomma ::= COMMA. {pParse->constraintName.n = 0;} 415 tconscomma ::= . 416 tcons ::= CONSTRAINT nm(X). {pParse->constraintName = X;} 417 tcons ::= PRIMARY KEY LP sortlist(X) autoinc(I) RP onconf(R). 418 {sqlite3AddPrimaryKey(pParse,X,R,I,0);} 419 tcons ::= UNIQUE LP sortlist(X) RP onconf(R). 420 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0, 421 SQLITE_IDXTYPE_UNIQUE);} 422 tcons ::= CHECK LP expr(E) RP onconf. 423 {sqlite3AddCheckConstraint(pParse,E);} 424 tcons ::= FOREIGN KEY LP eidlist(FA) RP 425 REFERENCES nm(T) eidlist_opt(TA) refargs(R) defer_subclause_opt(D). { 426 sqlite3CreateForeignKey(pParse, FA, &T, TA, R); 427 sqlite3DeferForeignKey(pParse, D); 428 } 429 %type defer_subclause_opt {int} 430 defer_subclause_opt(A) ::= . {A = 0;} 431 defer_subclause_opt(A) ::= defer_subclause(A). 432 433 // The following is a non-standard extension that allows us to declare the 434 // default behavior when there is a constraint conflict. 435 // 436 %type onconf {int} 437 %type orconf {int} 438 %type resolvetype {int} 439 onconf(A) ::= . {A = OE_Default;} 440 onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;} 441 orconf(A) ::= . {A = OE_Default;} 442 orconf(A) ::= OR resolvetype(X). {A = X;} 443 resolvetype(A) ::= raisetype(A). 444 resolvetype(A) ::= IGNORE. {A = OE_Ignore;} 445 resolvetype(A) ::= REPLACE. {A = OE_Replace;} 446 447 ////////////////////////// The DROP TABLE ///////////////////////////////////// 448 // 449 cmd ::= DROP TABLE ifexists(E) fullname(X). { 450 sqlite3DropTable(pParse, X, 0, E); 451 } 452 %type ifexists {int} 453 ifexists(A) ::= IF EXISTS. {A = 1;} 454 ifexists(A) ::= . {A = 0;} 455 456 ///////////////////// The CREATE VIEW statement ///////////////////////////// 457 // 458 %ifndef SQLITE_OMIT_VIEW 459 cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) eidlist_opt(C) 460 AS select(S). { 461 sqlite3CreateView(pParse, &X, &Y, &Z, C, S, T, E); 462 } 463 cmd ::= DROP VIEW ifexists(E) fullname(X). { 464 sqlite3DropTable(pParse, X, 1, E); 465 } 466 %endif SQLITE_OMIT_VIEW 467 468 //////////////////////// The SELECT statement ///////////////////////////////// 469 // 470 cmd ::= select(X). { 471 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0}; 472 sqlite3Select(pParse, X, &dest); 473 sqlite3SelectDelete(pParse->db, X); 474 } 475 476 %type select {Select*} 477 %destructor select {sqlite3SelectDelete(pParse->db, $$);} 478 %type selectnowith {Select*} 479 %destructor selectnowith {sqlite3SelectDelete(pParse->db, $$);} 480 %type oneselect {Select*} 481 %destructor oneselect {sqlite3SelectDelete(pParse->db, $$);} 482 483 %include { 484 /* 485 ** For a compound SELECT statement, make sure p->pPrior->pNext==p for 486 ** all elements in the list. And make sure list length does not exceed 487 ** SQLITE_LIMIT_COMPOUND_SELECT. 488 */ 489 static void parserDoubleLinkSelect(Parse *pParse, Select *p){ 490 assert( p!=0 ); 491 if( p->pPrior ){ 492 Select *pNext = 0, *pLoop; 493 int mxSelect, cnt = 0; 494 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){ 495 pLoop->pNext = pNext; 496 pLoop->selFlags |= SF_Compound; 497 } 498 if( (p->selFlags & SF_MultiValue)==0 && 499 (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && 500 cnt>mxSelect 501 ){ 502 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); 503 } 504 } 505 } 506 } 507 508 %ifndef SQLITE_OMIT_CTE 509 select(A) ::= WITH wqlist(W) selectnowith(X). { 510 Select *p = X; 511 if( p ){ 512 p->pWith = W; 513 parserDoubleLinkSelect(pParse, p); 514 }else{ 515 sqlite3WithDelete(pParse->db, W); 516 } 517 A = p; 518 } 519 select(A) ::= WITH RECURSIVE wqlist(W) selectnowith(X). { 520 Select *p = X; 521 if( p ){ 522 p->pWith = W; 523 parserDoubleLinkSelect(pParse, p); 524 }else{ 525 sqlite3WithDelete(pParse->db, W); 526 } 527 A = p; 528 } 529 %endif /* SQLITE_OMIT_CTE */ 530 select(A) ::= selectnowith(X). { 531 Select *p = X; 532 if( p ){ 533 parserDoubleLinkSelect(pParse, p); 534 } 535 A = p; /*A-overwrites-X*/ 536 } 537 538 selectnowith(A) ::= oneselect(A). 539 %ifndef SQLITE_OMIT_COMPOUND_SELECT 540 selectnowith(A) ::= selectnowith(A) multiselect_op(Y) oneselect(Z). { 541 Select *pRhs = Z; 542 Select *pLhs = A; 543 if( pRhs && pRhs->pPrior ){ 544 SrcList *pFrom; 545 Token x; 546 x.n = 0; 547 parserDoubleLinkSelect(pParse, pRhs); 548 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0); 549 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); 550 } 551 if( pRhs ){ 552 pRhs->op = (u8)Y; 553 pRhs->pPrior = pLhs; 554 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; 555 pRhs->selFlags &= ~SF_MultiValue; 556 if( Y!=TK_ALL ) pParse->hasCompound = 1; 557 }else{ 558 sqlite3SelectDelete(pParse->db, pLhs); 559 } 560 A = pRhs; 561 } 562 %type multiselect_op {int} 563 multiselect_op(A) ::= UNION(OP). {A = @OP; /*A-overwrites-OP*/} 564 multiselect_op(A) ::= UNION ALL. {A = TK_ALL;} 565 multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP; /*A-overwrites-OP*/} 566 %endif SQLITE_OMIT_COMPOUND_SELECT 567 568 oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y) 569 groupby_opt(P) having_opt(Q) 570 orderby_opt(Z) limit_opt(L). { 571 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L); 572 } 573 %ifndef SQLITE_OMIT_WINDOWFUNC 574 oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y) 575 groupby_opt(P) having_opt(Q) window_clause(R) 576 orderby_opt(Z) limit_opt(L). { 577 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L); 578 if( A ){ 579 A->pWinDefn = R; 580 }else{ 581 sqlite3WindowListDelete(pParse->db, R); 582 } 583 } 584 %endif 585 586 587 oneselect(A) ::= values(A). 588 589 %type values {Select*} 590 %destructor values {sqlite3SelectDelete(pParse->db, $$);} 591 values(A) ::= VALUES LP nexprlist(X) RP. { 592 A = sqlite3SelectNew(pParse,X,0,0,0,0,0,SF_Values,0); 593 } 594 values(A) ::= values(A) COMMA LP nexprlist(Y) RP. { 595 Select *pRight, *pLeft = A; 596 pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values|SF_MultiValue,0); 597 if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; 598 if( pRight ){ 599 pRight->op = TK_ALL; 600 pRight->pPrior = pLeft; 601 A = pRight; 602 }else{ 603 A = pLeft; 604 } 605 } 606 607 // The "distinct" nonterminal is true (1) if the DISTINCT keyword is 608 // present and false (0) if it is not. 609 // 610 %type distinct {int} 611 distinct(A) ::= DISTINCT. {A = SF_Distinct;} 612 distinct(A) ::= ALL. {A = SF_All;} 613 distinct(A) ::= . {A = 0;} 614 615 // selcollist is a list of expressions that are to become the return 616 // values of the SELECT statement. The "*" in statements like 617 // "SELECT * FROM ..." is encoded as a special expression with an 618 // opcode of TK_ASTERISK. 619 // 620 %type selcollist {ExprList*} 621 %destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);} 622 %type sclp {ExprList*} 623 %destructor sclp {sqlite3ExprListDelete(pParse->db, $$);} 624 sclp(A) ::= selcollist(A) COMMA. 625 sclp(A) ::= . {A = 0;} 626 selcollist(A) ::= sclp(A) scanpt(B) expr(X) scanpt(Z) as(Y). { 627 A = sqlite3ExprListAppend(pParse, A, X); 628 if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1); 629 sqlite3ExprListSetSpan(pParse,A,B,Z); 630 } 631 selcollist(A) ::= sclp(A) scanpt STAR. { 632 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); 633 A = sqlite3ExprListAppend(pParse, A, p); 634 } 635 selcollist(A) ::= sclp(A) scanpt nm(X) DOT STAR. { 636 Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); 637 Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 638 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); 639 A = sqlite3ExprListAppend(pParse,A, pDot); 640 } 641 642 // An option "AS <id>" phrase that can follow one of the expressions that 643 // define the result set, or one of the tables in the FROM clause. 644 // 645 %type as {Token} 646 as(X) ::= AS nm(Y). {X = Y;} 647 as(X) ::= ids(X). 648 as(X) ::= . {X.n = 0; X.z = 0;} 649 650 651 %type seltablist {SrcList*} 652 %destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);} 653 %type stl_prefix {SrcList*} 654 %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);} 655 %type from {SrcList*} 656 %destructor from {sqlite3SrcListDelete(pParse->db, $$);} 657 658 // A complete FROM clause. 659 // 660 from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));} 661 from(A) ::= FROM seltablist(X). { 662 A = X; 663 sqlite3SrcListShiftJoinType(A); 664 } 665 666 // "seltablist" is a "Select Table List" - the content of the FROM clause 667 // in a SELECT statement. "stl_prefix" is a prefix of this list. 668 // 669 stl_prefix(A) ::= seltablist(A) joinop(Y). { 670 if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].fg.jointype = (u8)Y; 671 } 672 stl_prefix(A) ::= . {A = 0;} 673 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) as(Z) indexed_opt(I) 674 on_opt(N) using_opt(U). { 675 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U); 676 sqlite3SrcListIndexedBy(pParse, A, &I); 677 } 678 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) LP exprlist(E) RP as(Z) 679 on_opt(N) using_opt(U). { 680 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U); 681 sqlite3SrcListFuncArgs(pParse, A, E); 682 } 683 %ifndef SQLITE_OMIT_SUBQUERY 684 seltablist(A) ::= stl_prefix(A) LP select(S) RP 685 as(Z) on_opt(N) using_opt(U). { 686 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,S,N,U); 687 } 688 seltablist(A) ::= stl_prefix(A) LP seltablist(F) RP 689 as(Z) on_opt(N) using_opt(U). { 690 if( A==0 && Z.n==0 && N==0 && U==0 ){ 691 A = F; 692 }else if( F->nSrc==1 ){ 693 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,0,N,U); 694 if( A ){ 695 struct SrcList_item *pNew = &A->a[A->nSrc-1]; 696 struct SrcList_item *pOld = F->a; 697 pNew->zName = pOld->zName; 698 pNew->zDatabase = pOld->zDatabase; 699 pNew->pSelect = pOld->pSelect; 700 if( pOld->fg.isTabFunc ){ 701 pNew->u1.pFuncArg = pOld->u1.pFuncArg; 702 pOld->u1.pFuncArg = 0; 703 pOld->fg.isTabFunc = 0; 704 pNew->fg.isTabFunc = 1; 705 } 706 pOld->zName = pOld->zDatabase = 0; 707 pOld->pSelect = 0; 708 } 709 sqlite3SrcListDelete(pParse->db, F); 710 }else{ 711 Select *pSubquery; 712 sqlite3SrcListShiftJoinType(F); 713 pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,SF_NestedFrom,0); 714 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,pSubquery,N,U); 715 } 716 } 717 %endif SQLITE_OMIT_SUBQUERY 718 719 %type dbnm {Token} 720 dbnm(A) ::= . {A.z=0; A.n=0;} 721 dbnm(A) ::= DOT nm(X). {A = X;} 722 723 %type fullname {SrcList*} 724 %destructor fullname {sqlite3SrcListDelete(pParse->db, $$);} 725 fullname(A) ::= nm(X). { 726 A = sqlite3SrcListAppend(pParse,0,&X,0); 727 if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &X); 728 } 729 fullname(A) ::= nm(X) DOT nm(Y). { 730 A = sqlite3SrcListAppend(pParse,0,&X,&Y); 731 if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &Y); 732 } 733 734 %type xfullname {SrcList*} 735 %destructor xfullname {sqlite3SrcListDelete(pParse->db, $$);} 736 xfullname(A) ::= nm(X). 737 {A = sqlite3SrcListAppend(pParse,0,&X,0); /*A-overwrites-X*/} 738 xfullname(A) ::= nm(X) DOT nm(Y). 739 {A = sqlite3SrcListAppend(pParse,0,&X,&Y); /*A-overwrites-X*/} 740 xfullname(A) ::= nm(X) DOT nm(Y) AS nm(Z). { 741 A = sqlite3SrcListAppend(pParse,0,&X,&Y); /*A-overwrites-X*/ 742 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z); 743 } 744 xfullname(A) ::= nm(X) AS nm(Z). { 745 A = sqlite3SrcListAppend(pParse,0,&X,0); /*A-overwrites-X*/ 746 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z); 747 } 748 749 %type joinop {int} 750 joinop(X) ::= COMMA|JOIN. { X = JT_INNER; } 751 joinop(X) ::= JOIN_KW(A) JOIN. 752 {X = sqlite3JoinType(pParse,&A,0,0); /*X-overwrites-A*/} 753 joinop(X) ::= JOIN_KW(A) nm(B) JOIN. 754 {X = sqlite3JoinType(pParse,&A,&B,0); /*X-overwrites-A*/} 755 joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN. 756 {X = sqlite3JoinType(pParse,&A,&B,&C);/*X-overwrites-A*/} 757 758 // There is a parsing abiguity in an upsert statement that uses a 759 // SELECT on the RHS of a the INSERT: 760 // 761 // INSERT INTO tab SELECT * FROM aaa JOIN bbb ON CONFLICT ... 762 // here ----^^ 763 // 764 // When the ON token is encountered, the parser does not know if it is 765 // the beginning of an ON CONFLICT clause, or the beginning of an ON 766 // clause associated with the JOIN. The conflict is resolved in favor 767 // of the JOIN. If an ON CONFLICT clause is intended, insert a dummy 768 // WHERE clause in between, like this: 769 // 770 // INSERT INTO tab SELECT * FROM aaa JOIN bbb WHERE true ON CONFLICT ... 771 // 772 // The [AND] and [OR] precedence marks in the rules for on_opt cause the 773 // ON in this context to always be interpreted as belonging to the JOIN. 774 // 775 %type on_opt {Expr*} 776 %destructor on_opt {sqlite3ExprDelete(pParse->db, $$);} 777 on_opt(N) ::= ON expr(E). {N = E;} 778 on_opt(N) ::= . [OR] {N = 0;} 779 780 // Note that this block abuses the Token type just a little. If there is 781 // no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If 782 // there is an INDEXED BY clause, then the token is populated as per normal, 783 // with z pointing to the token data and n containing the number of bytes 784 // in the token. 785 // 786 // If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is 787 // normally illegal. The sqlite3SrcListIndexedBy() function 788 // recognizes and interprets this as a special case. 789 // 790 %type indexed_opt {Token} 791 indexed_opt(A) ::= . {A.z=0; A.n=0;} 792 indexed_opt(A) ::= INDEXED BY nm(X). {A = X;} 793 indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;} 794 795 %type using_opt {IdList*} 796 %destructor using_opt {sqlite3IdListDelete(pParse->db, $$);} 797 using_opt(U) ::= USING LP idlist(L) RP. {U = L;} 798 using_opt(U) ::= . {U = 0;} 799 800 801 %type orderby_opt {ExprList*} 802 %destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);} 803 804 // the sortlist non-terminal stores a list of expression where each 805 // expression is optionally followed by ASC or DESC to indicate the 806 // sort order. 807 // 808 %type sortlist {ExprList*} 809 %destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);} 810 811 orderby_opt(A) ::= . {A = 0;} 812 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} 813 sortlist(A) ::= sortlist(A) COMMA expr(Y) sortorder(Z) nulls(X). { 814 A = sqlite3ExprListAppend(pParse,A,Y); 815 sqlite3ExprListSetSortOrder(A,Z,X); 816 } 817 sortlist(A) ::= expr(Y) sortorder(Z) nulls(X). { 818 A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/ 819 sqlite3ExprListSetSortOrder(A,Z,X); 820 } 821 822 %type sortorder {int} 823 824 sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;} 825 sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;} 826 sortorder(A) ::= . {A = SQLITE_SO_UNDEFINED;} 827 828 %type nulls {int} 829 nulls(A) ::= NULLS FIRST. {A = SQLITE_SO_ASC;} 830 nulls(A) ::= NULLS LAST. {A = SQLITE_SO_DESC;} 831 nulls(A) ::= . {A = SQLITE_SO_UNDEFINED;} 832 833 %type groupby_opt {ExprList*} 834 %destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);} 835 groupby_opt(A) ::= . {A = 0;} 836 groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;} 837 838 %type having_opt {Expr*} 839 %destructor having_opt {sqlite3ExprDelete(pParse->db, $$);} 840 having_opt(A) ::= . {A = 0;} 841 having_opt(A) ::= HAVING expr(X). {A = X;} 842 843 %type limit_opt {Expr*} 844 845 // The destructor for limit_opt will never fire in the current grammar. 846 // The limit_opt non-terminal only occurs at the end of a single production 847 // rule for SELECT statements. As soon as the rule that create the 848 // limit_opt non-terminal reduces, the SELECT statement rule will also 849 // reduce. So there is never a limit_opt non-terminal on the stack 850 // except as a transient. So there is never anything to destroy. 851 // 852 //%destructor limit_opt {sqlite3ExprDelete(pParse->db, $$);} 853 limit_opt(A) ::= . {A = 0;} 854 limit_opt(A) ::= LIMIT expr(X). 855 {A = sqlite3PExpr(pParse,TK_LIMIT,X,0);} 856 limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y). 857 {A = sqlite3PExpr(pParse,TK_LIMIT,X,Y);} 858 limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y). 859 {A = sqlite3PExpr(pParse,TK_LIMIT,Y,X);} 860 861 /////////////////////////// The DELETE statement ///////////////////////////// 862 // 863 %if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER 864 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W) 865 orderby_opt(O) limit_opt(L). { 866 sqlite3SrcListIndexedBy(pParse, X, &I); 867 #ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 868 if( O || L ){ 869 updateDeleteLimitError(pParse,O,L); 870 O = 0; 871 L = 0; 872 } 873 #endif 874 sqlite3DeleteFrom(pParse,X,W,O,L); 875 } 876 %else 877 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W). { 878 sqlite3SrcListIndexedBy(pParse, X, &I); 879 sqlite3DeleteFrom(pParse,X,W,0,0); 880 } 881 %endif 882 883 %type where_opt {Expr*} 884 %destructor where_opt {sqlite3ExprDelete(pParse->db, $$);} 885 886 where_opt(A) ::= . {A = 0;} 887 where_opt(A) ::= WHERE expr(X). {A = X;} 888 889 ////////////////////////// The UPDATE command //////////////////////////////// 890 // 891 %if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER 892 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) 893 where_opt(W) orderby_opt(O) limit_opt(L). { 894 sqlite3SrcListIndexedBy(pParse, X, &I); 895 sqlite3ExprListCheckLength(pParse,Y,"set list"); 896 #ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 897 if( O || L ){ 898 updateDeleteLimitError(pParse,O,L); 899 O = 0; 900 L = 0; 901 } 902 #endif 903 sqlite3Update(pParse,X,Y,W,R,O,L,0); 904 } 905 %else 906 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) 907 where_opt(W). { 908 sqlite3SrcListIndexedBy(pParse, X, &I); 909 sqlite3ExprListCheckLength(pParse,Y,"set list"); 910 sqlite3Update(pParse,X,Y,W,R,0,0,0); 911 } 912 %endif 913 914 915 916 %type setlist {ExprList*} 917 %destructor setlist {sqlite3ExprListDelete(pParse->db, $$);} 918 919 setlist(A) ::= setlist(A) COMMA nm(X) EQ expr(Y). { 920 A = sqlite3ExprListAppend(pParse, A, Y); 921 sqlite3ExprListSetName(pParse, A, &X, 1); 922 } 923 setlist(A) ::= setlist(A) COMMA LP idlist(X) RP EQ expr(Y). { 924 A = sqlite3ExprListAppendVector(pParse, A, X, Y); 925 } 926 setlist(A) ::= nm(X) EQ expr(Y). { 927 A = sqlite3ExprListAppend(pParse, 0, Y); 928 sqlite3ExprListSetName(pParse, A, &X, 1); 929 } 930 setlist(A) ::= LP idlist(X) RP EQ expr(Y). { 931 A = sqlite3ExprListAppendVector(pParse, 0, X, Y); 932 } 933 934 ////////////////////////// The INSERT command ///////////////////////////////// 935 // 936 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) select(S) 937 upsert(U). { 938 sqlite3Insert(pParse, X, S, F, R, U); 939 } 940 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) DEFAULT VALUES. 941 { 942 sqlite3Insert(pParse, X, 0, F, R, 0); 943 } 944 945 %type upsert {Upsert*} 946 947 // Because upsert only occurs at the tip end of the INSERT rule for cmd, 948 // there is never a case where the value of the upsert pointer will not 949 // be destroyed by the cmd action. So comment-out the destructor to 950 // avoid unreachable code. 951 //%destructor upsert {sqlite3UpsertDelete(pParse->db,$$);} 952 upsert(A) ::= . { A = 0; } 953 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW) 954 DO UPDATE SET setlist(Z) where_opt(W). 955 { A = sqlite3UpsertNew(pParse->db,T,TW,Z,W);} 956 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW) DO NOTHING. 957 { A = sqlite3UpsertNew(pParse->db,T,TW,0,0); } 958 upsert(A) ::= ON CONFLICT DO NOTHING. 959 { A = sqlite3UpsertNew(pParse->db,0,0,0,0); } 960 961 %type insert_cmd {int} 962 insert_cmd(A) ::= INSERT orconf(R). {A = R;} 963 insert_cmd(A) ::= REPLACE. {A = OE_Replace;} 964 965 %type idlist_opt {IdList*} 966 %destructor idlist_opt {sqlite3IdListDelete(pParse->db, $$);} 967 %type idlist {IdList*} 968 %destructor idlist {sqlite3IdListDelete(pParse->db, $$);} 969 970 idlist_opt(A) ::= . {A = 0;} 971 idlist_opt(A) ::= LP idlist(X) RP. {A = X;} 972 idlist(A) ::= idlist(A) COMMA nm(Y). 973 {A = sqlite3IdListAppend(pParse,A,&Y);} 974 idlist(A) ::= nm(Y). 975 {A = sqlite3IdListAppend(pParse,0,&Y); /*A-overwrites-Y*/} 976 977 /////////////////////////// Expression Processing ///////////////////////////// 978 // 979 980 %type expr {Expr*} 981 %destructor expr {sqlite3ExprDelete(pParse->db, $$);} 982 %type term {Expr*} 983 %destructor term {sqlite3ExprDelete(pParse->db, $$);} 984 985 %include { 986 987 /* Construct a new Expr object from a single identifier. Use the 988 ** new Expr to populate pOut. Set the span of pOut to be the identifier 989 ** that created the expression. 990 */ 991 static Expr *tokenExpr(Parse *pParse, int op, Token t){ 992 Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1); 993 if( p ){ 994 /* memset(p, 0, sizeof(Expr)); */ 995 p->op = (u8)op; 996 p->affExpr = 0; 997 p->flags = EP_Leaf; 998 ExprClearVVAProperties(p); 999 p->iAgg = -1; 1000 p->pLeft = p->pRight = 0; 1001 p->x.pList = 0; 1002 p->pAggInfo = 0; 1003 p->y.pTab = 0; 1004 p->op2 = 0; 1005 p->iTable = 0; 1006 p->iColumn = 0; 1007 p->u.zToken = (char*)&p[1]; 1008 memcpy(p->u.zToken, t.z, t.n); 1009 p->u.zToken[t.n] = 0; 1010 if( sqlite3Isquote(p->u.zToken[0]) ){ 1011 sqlite3DequoteExpr(p); 1012 } 1013 #if SQLITE_MAX_EXPR_DEPTH>0 1014 p->nHeight = 1; 1015 #endif 1016 if( IN_RENAME_OBJECT ){ 1017 return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t); 1018 } 1019 } 1020 return p; 1021 } 1022 1023 } 1024 1025 expr(A) ::= term(A). 1026 expr(A) ::= LP expr(X) RP. {A = X;} 1027 expr(A) ::= id(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/} 1028 expr(A) ::= JOIN_KW(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/} 1029 expr(A) ::= nm(X) DOT nm(Y). { 1030 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 1031 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1); 1032 if( IN_RENAME_OBJECT ){ 1033 sqlite3RenameTokenMap(pParse, (void*)temp2, &Y); 1034 sqlite3RenameTokenMap(pParse, (void*)temp1, &X); 1035 } 1036 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); 1037 } 1038 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). { 1039 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 1040 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1); 1041 Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &Z, 1); 1042 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); 1043 if( IN_RENAME_OBJECT ){ 1044 sqlite3RenameTokenMap(pParse, (void*)temp3, &Z); 1045 sqlite3RenameTokenMap(pParse, (void*)temp2, &Y); 1046 } 1047 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); 1048 } 1049 term(A) ::= NULL|FLOAT|BLOB(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/} 1050 term(A) ::= STRING(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/} 1051 term(A) ::= INTEGER(X). { 1052 A = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &X, 1); 1053 } 1054 expr(A) ::= VARIABLE(X). { 1055 if( !(X.z[0]=='#' && sqlite3Isdigit(X.z[1])) ){ 1056 u32 n = X.n; 1057 A = tokenExpr(pParse, TK_VARIABLE, X); 1058 sqlite3ExprAssignVarNumber(pParse, A, n); 1059 }else{ 1060 /* When doing a nested parse, one can include terms in an expression 1061 ** that look like this: #1 #2 ... These terms refer to registers 1062 ** in the virtual machine. #N is the N-th register. */ 1063 Token t = X; /*A-overwrites-X*/ 1064 assert( t.n>=2 ); 1065 if( pParse->nested==0 ){ 1066 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); 1067 A = 0; 1068 }else{ 1069 A = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); 1070 if( A ) sqlite3GetInt32(&t.z[1], &A->iTable); 1071 } 1072 } 1073 } 1074 expr(A) ::= expr(A) COLLATE ids(C). { 1075 A = sqlite3ExprAddCollateToken(pParse, A, &C, 1); 1076 } 1077 %ifndef SQLITE_OMIT_CAST 1078 expr(A) ::= CAST LP expr(E) AS typetoken(T) RP. { 1079 A = sqlite3ExprAlloc(pParse->db, TK_CAST, &T, 1); 1080 sqlite3ExprAttachSubtrees(pParse->db, A, E, 0); 1081 } 1082 %endif SQLITE_OMIT_CAST 1083 1084 1085 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP. { 1086 A = sqlite3ExprFunction(pParse, Y, &X, D); 1087 } 1088 expr(A) ::= id(X) LP STAR RP. { 1089 A = sqlite3ExprFunction(pParse, 0, &X, 0); 1090 } 1091 1092 %ifndef SQLITE_OMIT_WINDOWFUNC 1093 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP filter_over(Z). { 1094 A = sqlite3ExprFunction(pParse, Y, &X, D); 1095 sqlite3WindowAttach(pParse, A, Z); 1096 } 1097 expr(A) ::= id(X) LP STAR RP filter_over(Z). { 1098 A = sqlite3ExprFunction(pParse, 0, &X, 0); 1099 sqlite3WindowAttach(pParse, A, Z); 1100 } 1101 %endif 1102 1103 term(A) ::= CTIME_KW(OP). { 1104 A = sqlite3ExprFunction(pParse, 0, &OP, 0); 1105 } 1106 1107 expr(A) ::= LP nexprlist(X) COMMA expr(Y) RP. { 1108 ExprList *pList = sqlite3ExprListAppend(pParse, X, Y); 1109 A = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); 1110 if( A ){ 1111 A->x.pList = pList; 1112 if( ALWAYS(pList->nExpr) ){ 1113 A->flags |= pList->a[0].pExpr->flags & EP_Propagate; 1114 } 1115 }else{ 1116 sqlite3ExprListDelete(pParse->db, pList); 1117 } 1118 } 1119 1120 expr(A) ::= expr(A) AND expr(Y). {A=sqlite3ExprAnd(pParse,A,Y);} 1121 expr(A) ::= expr(A) OR(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1122 expr(A) ::= expr(A) LT|GT|GE|LE(OP) expr(Y). 1123 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1124 expr(A) ::= expr(A) EQ|NE(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1125 expr(A) ::= expr(A) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y). 1126 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1127 expr(A) ::= expr(A) PLUS|MINUS(OP) expr(Y). 1128 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1129 expr(A) ::= expr(A) STAR|SLASH|REM(OP) expr(Y). 1130 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1131 expr(A) ::= expr(A) CONCAT(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1132 %type likeop {Token} 1133 likeop(A) ::= LIKE_KW|MATCH(A). 1134 likeop(A) ::= NOT LIKE_KW|MATCH(X). {A=X; A.n|=0x80000000; /*A-overwrite-X*/} 1135 expr(A) ::= expr(A) likeop(OP) expr(Y). [LIKE_KW] { 1136 ExprList *pList; 1137 int bNot = OP.n & 0x80000000; 1138 OP.n &= 0x7fffffff; 1139 pList = sqlite3ExprListAppend(pParse,0, Y); 1140 pList = sqlite3ExprListAppend(pParse,pList, A); 1141 A = sqlite3ExprFunction(pParse, pList, &OP, 0); 1142 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1143 if( A ) A->flags |= EP_InfixFunc; 1144 } 1145 expr(A) ::= expr(A) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] { 1146 ExprList *pList; 1147 int bNot = OP.n & 0x80000000; 1148 OP.n &= 0x7fffffff; 1149 pList = sqlite3ExprListAppend(pParse,0, Y); 1150 pList = sqlite3ExprListAppend(pParse,pList, A); 1151 pList = sqlite3ExprListAppend(pParse,pList, E); 1152 A = sqlite3ExprFunction(pParse, pList, &OP, 0); 1153 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1154 if( A ) A->flags |= EP_InfixFunc; 1155 } 1156 1157 expr(A) ::= expr(A) ISNULL|NOTNULL(E). {A = sqlite3PExpr(pParse,@E,A,0);} 1158 expr(A) ::= expr(A) NOT NULL. {A = sqlite3PExpr(pParse,TK_NOTNULL,A,0);} 1159 1160 %include { 1161 /* A routine to convert a binary TK_IS or TK_ISNOT expression into a 1162 ** unary TK_ISNULL or TK_NOTNULL expression. */ 1163 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ 1164 sqlite3 *db = pParse->db; 1165 if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){ 1166 pA->op = (u8)op; 1167 sqlite3ExprDelete(db, pA->pRight); 1168 pA->pRight = 0; 1169 } 1170 } 1171 } 1172 1173 // expr1 IS expr2 1174 // expr1 IS NOT expr2 1175 // 1176 // If expr2 is NULL then code as TK_ISNULL or TK_NOTNULL. If expr2 1177 // is any other expression, code as TK_IS or TK_ISNOT. 1178 // 1179 expr(A) ::= expr(A) IS expr(Y). { 1180 A = sqlite3PExpr(pParse,TK_IS,A,Y); 1181 binaryToUnaryIfNull(pParse, Y, A, TK_ISNULL); 1182 } 1183 expr(A) ::= expr(A) IS NOT expr(Y). { 1184 A = sqlite3PExpr(pParse,TK_ISNOT,A,Y); 1185 binaryToUnaryIfNull(pParse, Y, A, TK_NOTNULL); 1186 } 1187 1188 expr(A) ::= NOT(B) expr(X). 1189 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/} 1190 expr(A) ::= BITNOT(B) expr(X). 1191 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/} 1192 expr(A) ::= PLUS|MINUS(B) expr(X). [BITNOT] { 1193 A = sqlite3PExpr(pParse, @B==TK_PLUS ? TK_UPLUS : TK_UMINUS, X, 0); 1194 /*A-overwrites-B*/ 1195 } 1196 1197 %type between_op {int} 1198 between_op(A) ::= BETWEEN. {A = 0;} 1199 between_op(A) ::= NOT BETWEEN. {A = 1;} 1200 expr(A) ::= expr(A) between_op(N) expr(X) AND expr(Y). [BETWEEN] { 1201 ExprList *pList = sqlite3ExprListAppend(pParse,0, X); 1202 pList = sqlite3ExprListAppend(pParse,pList, Y); 1203 A = sqlite3PExpr(pParse, TK_BETWEEN, A, 0); 1204 if( A ){ 1205 A->x.pList = pList; 1206 }else{ 1207 sqlite3ExprListDelete(pParse->db, pList); 1208 } 1209 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1210 } 1211 %ifndef SQLITE_OMIT_SUBQUERY 1212 %type in_op {int} 1213 in_op(A) ::= IN. {A = 0;} 1214 in_op(A) ::= NOT IN. {A = 1;} 1215 expr(A) ::= expr(A) in_op(N) LP exprlist(Y) RP. [IN] { 1216 if( Y==0 ){ 1217 /* Expressions of the form 1218 ** 1219 ** expr1 IN () 1220 ** expr1 NOT IN () 1221 ** 1222 ** simplify to constants 0 (false) and 1 (true), respectively, 1223 ** regardless of the value of expr1. 1224 */ 1225 sqlite3ExprUnmapAndDelete(pParse, A); 1226 A = sqlite3Expr(pParse->db, TK_INTEGER, N ? "1" : "0"); 1227 }else if( Y->nExpr==1 && sqlite3ExprIsConstant(Y->a[0].pExpr) ){ 1228 Expr *pRHS = Y->a[0].pExpr; 1229 Y->a[0].pExpr = 0; 1230 sqlite3ExprListDelete(pParse->db, Y); 1231 pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); 1232 A = sqlite3PExpr(pParse, TK_EQ, A, pRHS); 1233 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1234 }else{ 1235 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1236 if( A ){ 1237 A->x.pList = Y; 1238 sqlite3ExprSetHeightAndFlags(pParse, A); 1239 }else{ 1240 sqlite3ExprListDelete(pParse->db, Y); 1241 } 1242 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1243 } 1244 } 1245 expr(A) ::= LP select(X) RP. { 1246 A = sqlite3PExpr(pParse, TK_SELECT, 0, 0); 1247 sqlite3PExprAddSelect(pParse, A, X); 1248 } 1249 expr(A) ::= expr(A) in_op(N) LP select(Y) RP. [IN] { 1250 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1251 sqlite3PExprAddSelect(pParse, A, Y); 1252 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1253 } 1254 expr(A) ::= expr(A) in_op(N) nm(Y) dbnm(Z) paren_exprlist(E). [IN] { 1255 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&Y,&Z); 1256 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); 1257 if( E ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, E); 1258 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1259 sqlite3PExprAddSelect(pParse, A, pSelect); 1260 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1261 } 1262 expr(A) ::= EXISTS LP select(Y) RP. { 1263 Expr *p; 1264 p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); 1265 sqlite3PExprAddSelect(pParse, p, Y); 1266 } 1267 %endif SQLITE_OMIT_SUBQUERY 1268 1269 /* CASE expressions */ 1270 expr(A) ::= CASE case_operand(X) case_exprlist(Y) case_else(Z) END. { 1271 A = sqlite3PExpr(pParse, TK_CASE, X, 0); 1272 if( A ){ 1273 A->x.pList = Z ? sqlite3ExprListAppend(pParse,Y,Z) : Y; 1274 sqlite3ExprSetHeightAndFlags(pParse, A); 1275 }else{ 1276 sqlite3ExprListDelete(pParse->db, Y); 1277 sqlite3ExprDelete(pParse->db, Z); 1278 } 1279 } 1280 %type case_exprlist {ExprList*} 1281 %destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1282 case_exprlist(A) ::= case_exprlist(A) WHEN expr(Y) THEN expr(Z). { 1283 A = sqlite3ExprListAppend(pParse,A, Y); 1284 A = sqlite3ExprListAppend(pParse,A, Z); 1285 } 1286 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { 1287 A = sqlite3ExprListAppend(pParse,0, Y); 1288 A = sqlite3ExprListAppend(pParse,A, Z); 1289 } 1290 %type case_else {Expr*} 1291 %destructor case_else {sqlite3ExprDelete(pParse->db, $$);} 1292 case_else(A) ::= ELSE expr(X). {A = X;} 1293 case_else(A) ::= . {A = 0;} 1294 %type case_operand {Expr*} 1295 %destructor case_operand {sqlite3ExprDelete(pParse->db, $$);} 1296 case_operand(A) ::= expr(X). {A = X; /*A-overwrites-X*/} 1297 case_operand(A) ::= . {A = 0;} 1298 1299 %type exprlist {ExprList*} 1300 %destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1301 %type nexprlist {ExprList*} 1302 %destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);} 1303 1304 exprlist(A) ::= nexprlist(A). 1305 exprlist(A) ::= . {A = 0;} 1306 nexprlist(A) ::= nexprlist(A) COMMA expr(Y). 1307 {A = sqlite3ExprListAppend(pParse,A,Y);} 1308 nexprlist(A) ::= expr(Y). 1309 {A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/} 1310 1311 %ifndef SQLITE_OMIT_SUBQUERY 1312 /* A paren_exprlist is an optional expression list contained inside 1313 ** of parenthesis */ 1314 %type paren_exprlist {ExprList*} 1315 %destructor paren_exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1316 paren_exprlist(A) ::= . {A = 0;} 1317 paren_exprlist(A) ::= LP exprlist(X) RP. {A = X;} 1318 %endif SQLITE_OMIT_SUBQUERY 1319 1320 1321 ///////////////////////////// The CREATE INDEX command /////////////////////// 1322 // 1323 cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D) 1324 ON nm(Y) LP sortlist(Z) RP where_opt(W). { 1325 sqlite3CreateIndex(pParse, &X, &D, 1326 sqlite3SrcListAppend(pParse,0,&Y,0), Z, U, 1327 &S, W, SQLITE_SO_ASC, NE, SQLITE_IDXTYPE_APPDEF); 1328 if( IN_RENAME_OBJECT && pParse->pNewIndex ){ 1329 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &Y); 1330 } 1331 } 1332 1333 %type uniqueflag {int} 1334 uniqueflag(A) ::= UNIQUE. {A = OE_Abort;} 1335 uniqueflag(A) ::= . {A = OE_None;} 1336 1337 1338 // The eidlist non-terminal (Expression Id List) generates an ExprList 1339 // from a list of identifiers. The identifier names are in ExprList.a[].zName. 1340 // This list is stored in an ExprList rather than an IdList so that it 1341 // can be easily sent to sqlite3ColumnsExprList(). 1342 // 1343 // eidlist is grouped with CREATE INDEX because it used to be the non-terminal 1344 // used for the arguments to an index. That is just an historical accident. 1345 // 1346 // IMPORTANT COMPATIBILITY NOTE: Some prior versions of SQLite accepted 1347 // COLLATE clauses and ASC or DESC keywords on ID lists in inappropriate 1348 // places - places that might have been stored in the sqlite_schema table. 1349 // Those extra features were ignored. But because they might be in some 1350 // (busted) old databases, we need to continue parsing them when loading 1351 // historical schemas. 1352 // 1353 %type eidlist {ExprList*} 1354 %destructor eidlist {sqlite3ExprListDelete(pParse->db, $$);} 1355 %type eidlist_opt {ExprList*} 1356 %destructor eidlist_opt {sqlite3ExprListDelete(pParse->db, $$);} 1357 1358 %include { 1359 /* Add a single new term to an ExprList that is used to store a 1360 ** list of identifiers. Report an error if the ID list contains 1361 ** a COLLATE clause or an ASC or DESC keyword, except ignore the 1362 ** error while parsing a legacy schema. 1363 */ 1364 static ExprList *parserAddExprIdListTerm( 1365 Parse *pParse, 1366 ExprList *pPrior, 1367 Token *pIdToken, 1368 int hasCollate, 1369 int sortOrder 1370 ){ 1371 ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); 1372 if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED) 1373 && pParse->db->init.busy==0 1374 ){ 1375 sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"", 1376 pIdToken->n, pIdToken->z); 1377 } 1378 sqlite3ExprListSetName(pParse, p, pIdToken, 1); 1379 return p; 1380 } 1381 } // end %include 1382 1383 eidlist_opt(A) ::= . {A = 0;} 1384 eidlist_opt(A) ::= LP eidlist(X) RP. {A = X;} 1385 eidlist(A) ::= eidlist(A) COMMA nm(Y) collate(C) sortorder(Z). { 1386 A = parserAddExprIdListTerm(pParse, A, &Y, C, Z); 1387 } 1388 eidlist(A) ::= nm(Y) collate(C) sortorder(Z). { 1389 A = parserAddExprIdListTerm(pParse, 0, &Y, C, Z); /*A-overwrites-Y*/ 1390 } 1391 1392 %type collate {int} 1393 collate(C) ::= . {C = 0;} 1394 collate(C) ::= COLLATE ids. {C = 1;} 1395 1396 1397 ///////////////////////////// The DROP INDEX command ///////////////////////// 1398 // 1399 cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);} 1400 1401 ///////////////////////////// The VACUUM command ///////////////////////////// 1402 // 1403 %if !SQLITE_OMIT_VACUUM && !SQLITE_OMIT_ATTACH 1404 %type vinto {Expr*} 1405 %destructor vinto {sqlite3ExprDelete(pParse->db, $$);} 1406 cmd ::= VACUUM vinto(Y). {sqlite3Vacuum(pParse,0,Y);} 1407 cmd ::= VACUUM nm(X) vinto(Y). {sqlite3Vacuum(pParse,&X,Y);} 1408 vinto(A) ::= INTO expr(X). {A = X;} 1409 vinto(A) ::= . {A = 0;} 1410 %endif 1411 1412 ///////////////////////////// The PRAGMA command ///////////////////////////// 1413 // 1414 %ifndef SQLITE_OMIT_PRAGMA 1415 cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);} 1416 cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);} 1417 cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);} 1418 cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y). 1419 {sqlite3Pragma(pParse,&X,&Z,&Y,1);} 1420 cmd ::= PRAGMA nm(X) dbnm(Z) LP minus_num(Y) RP. 1421 {sqlite3Pragma(pParse,&X,&Z,&Y,1);} 1422 1423 nmnum(A) ::= plus_num(A). 1424 nmnum(A) ::= nm(A). 1425 nmnum(A) ::= ON(A). 1426 nmnum(A) ::= DELETE(A). 1427 nmnum(A) ::= DEFAULT(A). 1428 %endif SQLITE_OMIT_PRAGMA 1429 %token_class number INTEGER|FLOAT. 1430 plus_num(A) ::= PLUS number(X). {A = X;} 1431 plus_num(A) ::= number(A). 1432 minus_num(A) ::= MINUS number(X). {A = X;} 1433 //////////////////////////// The CREATE TRIGGER command ///////////////////// 1434 1435 %ifndef SQLITE_OMIT_TRIGGER 1436 1437 cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). { 1438 Token all; 1439 all.z = A.z; 1440 all.n = (int)(Z.z - A.z) + Z.n; 1441 sqlite3FinishTrigger(pParse, S, &all); 1442 } 1443 1444 trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z) 1445 trigger_time(C) trigger_event(D) 1446 ON fullname(E) foreach_clause when_clause(G). { 1447 sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR); 1448 A = (Z.n==0?B:Z); /*A-overwrites-T*/ 1449 } 1450 1451 %type trigger_time {int} 1452 trigger_time(A) ::= BEFORE|AFTER(X). { A = @X; /*A-overwrites-X*/ } 1453 trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;} 1454 trigger_time(A) ::= . { A = TK_BEFORE; } 1455 1456 %type trigger_event {struct TrigEvent} 1457 %destructor trigger_event {sqlite3IdListDelete(pParse->db, $$.b);} 1458 trigger_event(A) ::= DELETE|INSERT(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;} 1459 trigger_event(A) ::= UPDATE(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;} 1460 trigger_event(A) ::= UPDATE OF idlist(X).{A.a = TK_UPDATE; A.b = X;} 1461 1462 foreach_clause ::= . 1463 foreach_clause ::= FOR EACH ROW. 1464 1465 %type when_clause {Expr*} 1466 %destructor when_clause {sqlite3ExprDelete(pParse->db, $$);} 1467 when_clause(A) ::= . { A = 0; } 1468 when_clause(A) ::= WHEN expr(X). { A = X; } 1469 1470 %type trigger_cmd_list {TriggerStep*} 1471 %destructor trigger_cmd_list {sqlite3DeleteTriggerStep(pParse->db, $$);} 1472 trigger_cmd_list(A) ::= trigger_cmd_list(A) trigger_cmd(X) SEMI. { 1473 assert( A!=0 ); 1474 A->pLast->pNext = X; 1475 A->pLast = X; 1476 } 1477 trigger_cmd_list(A) ::= trigger_cmd(A) SEMI. { 1478 assert( A!=0 ); 1479 A->pLast = A; 1480 } 1481 1482 // Disallow qualified table names on INSERT, UPDATE, and DELETE statements 1483 // within a trigger. The table to INSERT, UPDATE, or DELETE is always in 1484 // the same database as the table that the trigger fires on. 1485 // 1486 %type trnm {Token} 1487 trnm(A) ::= nm(A). 1488 trnm(A) ::= nm DOT nm(X). { 1489 A = X; 1490 sqlite3ErrorMsg(pParse, 1491 "qualified table names are not allowed on INSERT, UPDATE, and DELETE " 1492 "statements within triggers"); 1493 } 1494 1495 // Disallow the INDEX BY and NOT INDEXED clauses on UPDATE and DELETE 1496 // statements within triggers. We make a specific error message for this 1497 // since it is an exception to the default grammar rules. 1498 // 1499 tridxby ::= . 1500 tridxby ::= INDEXED BY nm. { 1501 sqlite3ErrorMsg(pParse, 1502 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " 1503 "within triggers"); 1504 } 1505 tridxby ::= NOT INDEXED. { 1506 sqlite3ErrorMsg(pParse, 1507 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " 1508 "within triggers"); 1509 } 1510 1511 1512 1513 %type trigger_cmd {TriggerStep*} 1514 %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);} 1515 // UPDATE 1516 trigger_cmd(A) ::= 1517 UPDATE(B) orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z) scanpt(E). 1518 {A = sqlite3TriggerUpdateStep(pParse, &X, Y, Z, R, B.z, E);} 1519 1520 // INSERT 1521 trigger_cmd(A) ::= scanpt(B) insert_cmd(R) INTO 1522 trnm(X) idlist_opt(F) select(S) upsert(U) scanpt(Z). { 1523 A = sqlite3TriggerInsertStep(pParse,&X,F,S,R,U,B,Z);/*A-overwrites-R*/ 1524 } 1525 // DELETE 1526 trigger_cmd(A) ::= DELETE(B) FROM trnm(X) tridxby where_opt(Y) scanpt(E). 1527 {A = sqlite3TriggerDeleteStep(pParse, &X, Y, B.z, E);} 1528 1529 // SELECT 1530 trigger_cmd(A) ::= scanpt(B) select(X) scanpt(E). 1531 {A = sqlite3TriggerSelectStep(pParse->db, X, B, E); /*A-overwrites-X*/} 1532 1533 // The special RAISE expression that may occur in trigger programs 1534 expr(A) ::= RAISE LP IGNORE RP. { 1535 A = sqlite3PExpr(pParse, TK_RAISE, 0, 0); 1536 if( A ){ 1537 A->affExpr = OE_Ignore; 1538 } 1539 } 1540 expr(A) ::= RAISE LP raisetype(T) COMMA nm(Z) RP. { 1541 A = sqlite3ExprAlloc(pParse->db, TK_RAISE, &Z, 1); 1542 if( A ) { 1543 A->affExpr = (char)T; 1544 } 1545 } 1546 %endif !SQLITE_OMIT_TRIGGER 1547 1548 %type raisetype {int} 1549 raisetype(A) ::= ROLLBACK. {A = OE_Rollback;} 1550 raisetype(A) ::= ABORT. {A = OE_Abort;} 1551 raisetype(A) ::= FAIL. {A = OE_Fail;} 1552 1553 1554 //////////////////////// DROP TRIGGER statement ////////////////////////////// 1555 %ifndef SQLITE_OMIT_TRIGGER 1556 cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). { 1557 sqlite3DropTrigger(pParse,X,NOERR); 1558 } 1559 %endif !SQLITE_OMIT_TRIGGER 1560 1561 //////////////////////// ATTACH DATABASE file AS name ///////////////////////// 1562 %ifndef SQLITE_OMIT_ATTACH 1563 cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). { 1564 sqlite3Attach(pParse, F, D, K); 1565 } 1566 cmd ::= DETACH database_kw_opt expr(D). { 1567 sqlite3Detach(pParse, D); 1568 } 1569 1570 %type key_opt {Expr*} 1571 %destructor key_opt {sqlite3ExprDelete(pParse->db, $$);} 1572 key_opt(A) ::= . { A = 0; } 1573 key_opt(A) ::= KEY expr(X). { A = X; } 1574 1575 database_kw_opt ::= DATABASE. 1576 database_kw_opt ::= . 1577 %endif SQLITE_OMIT_ATTACH 1578 1579 ////////////////////////// REINDEX collation ////////////////////////////////// 1580 %ifndef SQLITE_OMIT_REINDEX 1581 cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);} 1582 cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);} 1583 %endif SQLITE_OMIT_REINDEX 1584 1585 /////////////////////////////////// ANALYZE /////////////////////////////////// 1586 %ifndef SQLITE_OMIT_ANALYZE 1587 cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);} 1588 cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);} 1589 %endif 1590 1591 //////////////////////// ALTER TABLE table ... //////////////////////////////// 1592 %ifndef SQLITE_OMIT_ALTERTABLE 1593 cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). { 1594 sqlite3AlterRenameTable(pParse,X,&Z); 1595 } 1596 cmd ::= ALTER TABLE add_column_fullname 1597 ADD kwcolumn_opt columnname(Y) carglist. { 1598 Y.n = (int)(pParse->sLastToken.z-Y.z) + pParse->sLastToken.n; 1599 sqlite3AlterFinishAddColumn(pParse, &Y); 1600 } 1601 add_column_fullname ::= fullname(X). { 1602 disableLookaside(pParse); 1603 sqlite3AlterBeginAddColumn(pParse, X); 1604 } 1605 cmd ::= ALTER TABLE fullname(X) RENAME kwcolumn_opt nm(Y) TO nm(Z). { 1606 sqlite3AlterRenameColumn(pParse, X, &Y, &Z); 1607 } 1608 1609 kwcolumn_opt ::= . 1610 kwcolumn_opt ::= COLUMNKW. 1611 1612 %endif SQLITE_OMIT_ALTERTABLE 1613 1614 //////////////////////// CREATE VIRTUAL TABLE ... ///////////////////////////// 1615 %ifndef SQLITE_OMIT_VIRTUALTABLE 1616 cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);} 1617 cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);} 1618 create_vtab ::= createkw VIRTUAL TABLE ifnotexists(E) 1619 nm(X) dbnm(Y) USING nm(Z). { 1620 sqlite3VtabBeginParse(pParse, &X, &Y, &Z, E); 1621 } 1622 vtabarglist ::= vtabarg. 1623 vtabarglist ::= vtabarglist COMMA vtabarg. 1624 vtabarg ::= . {sqlite3VtabArgInit(pParse);} 1625 vtabarg ::= vtabarg vtabargtoken. 1626 vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);} 1627 vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);} 1628 lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);} 1629 anylist ::= . 1630 anylist ::= anylist LP anylist RP. 1631 anylist ::= anylist ANY. 1632 %endif SQLITE_OMIT_VIRTUALTABLE 1633 1634 1635 //////////////////////// COMMON TABLE EXPRESSIONS //////////////////////////// 1636 %type wqlist {With*} 1637 %destructor wqlist {sqlite3WithDelete(pParse->db, $$);} 1638 1639 with ::= . 1640 %ifndef SQLITE_OMIT_CTE 1641 with ::= WITH wqlist(W). { sqlite3WithPush(pParse, W, 1); } 1642 with ::= WITH RECURSIVE wqlist(W). { sqlite3WithPush(pParse, W, 1); } 1643 1644 wqlist(A) ::= nm(X) eidlist_opt(Y) AS LP select(Z) RP. { 1645 A = sqlite3WithAdd(pParse, 0, &X, Y, Z); /*A-overwrites-X*/ 1646 } 1647 wqlist(A) ::= wqlist(A) COMMA nm(X) eidlist_opt(Y) AS LP select(Z) RP. { 1648 A = sqlite3WithAdd(pParse, A, &X, Y, Z); 1649 } 1650 %endif SQLITE_OMIT_CTE 1651 1652 //////////////////////// WINDOW FUNCTION EXPRESSIONS ///////////////////////// 1653 // These must be at the end of this file. Specifically, the rules that 1654 // introduce tokens WINDOW, OVER and FILTER must appear last. This causes 1655 // the integer values assigned to these tokens to be larger than all other 1656 // tokens that may be output by the tokenizer except TK_SPACE and TK_ILLEGAL. 1657 // 1658 %ifndef SQLITE_OMIT_WINDOWFUNC 1659 %type windowdefn_list {Window*} 1660 %destructor windowdefn_list {sqlite3WindowListDelete(pParse->db, $$);} 1661 windowdefn_list(A) ::= windowdefn(Z). { A = Z; } 1662 windowdefn_list(A) ::= windowdefn_list(Y) COMMA windowdefn(Z). { 1663 assert( Z!=0 ); 1664 sqlite3WindowChain(pParse, Z, Y); 1665 Z->pNextWin = Y; 1666 A = Z; 1667 } 1668 1669 %type windowdefn {Window*} 1670 %destructor windowdefn {sqlite3WindowDelete(pParse->db, $$);} 1671 windowdefn(A) ::= nm(X) AS LP window(Y) RP. { 1672 if( ALWAYS(Y) ){ 1673 Y->zName = sqlite3DbStrNDup(pParse->db, X.z, X.n); 1674 } 1675 A = Y; 1676 } 1677 1678 %type window {Window*} 1679 %destructor window {sqlite3WindowDelete(pParse->db, $$);} 1680 1681 %type frame_opt {Window*} 1682 %destructor frame_opt {sqlite3WindowDelete(pParse->db, $$);} 1683 1684 %type part_opt {ExprList*} 1685 %destructor part_opt {sqlite3ExprListDelete(pParse->db, $$);} 1686 1687 %type filter_clause {Expr*} 1688 %destructor filter_clause {sqlite3ExprDelete(pParse->db, $$);} 1689 1690 %type over_clause {Window*} 1691 %destructor over_clause {sqlite3WindowDelete(pParse->db, $$);} 1692 1693 %type filter_over {Window*} 1694 %destructor filter_over {sqlite3WindowDelete(pParse->db, $$);} 1695 1696 %type range_or_rows {int} 1697 1698 %type frame_bound {struct FrameBound} 1699 %destructor frame_bound {sqlite3ExprDelete(pParse->db, $$.pExpr);} 1700 %type frame_bound_s {struct FrameBound} 1701 %destructor frame_bound_s {sqlite3ExprDelete(pParse->db, $$.pExpr);} 1702 %type frame_bound_e {struct FrameBound} 1703 %destructor frame_bound_e {sqlite3ExprDelete(pParse->db, $$.pExpr);} 1704 1705 window(A) ::= PARTITION BY nexprlist(X) orderby_opt(Y) frame_opt(Z). { 1706 A = sqlite3WindowAssemble(pParse, Z, X, Y, 0); 1707 } 1708 window(A) ::= nm(W) PARTITION BY nexprlist(X) orderby_opt(Y) frame_opt(Z). { 1709 A = sqlite3WindowAssemble(pParse, Z, X, Y, &W); 1710 } 1711 window(A) ::= ORDER BY sortlist(Y) frame_opt(Z). { 1712 A = sqlite3WindowAssemble(pParse, Z, 0, Y, 0); 1713 } 1714 window(A) ::= nm(W) ORDER BY sortlist(Y) frame_opt(Z). { 1715 A = sqlite3WindowAssemble(pParse, Z, 0, Y, &W); 1716 } 1717 window(A) ::= frame_opt(Z). { 1718 A = Z; 1719 } 1720 window(A) ::= nm(W) frame_opt(Z). { 1721 A = sqlite3WindowAssemble(pParse, Z, 0, 0, &W); 1722 } 1723 1724 frame_opt(A) ::= . { 1725 A = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); 1726 } 1727 frame_opt(A) ::= range_or_rows(X) frame_bound_s(Y) frame_exclude_opt(Z). { 1728 A = sqlite3WindowAlloc(pParse, X, Y.eType, Y.pExpr, TK_CURRENT, 0, Z); 1729 } 1730 frame_opt(A) ::= range_or_rows(X) BETWEEN frame_bound_s(Y) AND 1731 frame_bound_e(Z) frame_exclude_opt(W). { 1732 A = sqlite3WindowAlloc(pParse, X, Y.eType, Y.pExpr, Z.eType, Z.pExpr, W); 1733 } 1734 1735 range_or_rows(A) ::= RANGE|ROWS|GROUPS(X). {A = @X; /*A-overwrites-X*/} 1736 1737 frame_bound_s(A) ::= frame_bound(X). {A = X;} 1738 frame_bound_s(A) ::= UNBOUNDED(X) PRECEDING. {A.eType = @X; A.pExpr = 0;} 1739 frame_bound_e(A) ::= frame_bound(X). {A = X;} 1740 frame_bound_e(A) ::= UNBOUNDED(X) FOLLOWING. {A.eType = @X; A.pExpr = 0;} 1741 1742 frame_bound(A) ::= expr(X) PRECEDING|FOLLOWING(Y). 1743 {A.eType = @Y; A.pExpr = X;} 1744 frame_bound(A) ::= CURRENT(X) ROW. {A.eType = @X; A.pExpr = 0;} 1745 1746 %type frame_exclude_opt {u8} 1747 frame_exclude_opt(A) ::= . {A = 0;} 1748 frame_exclude_opt(A) ::= EXCLUDE frame_exclude(X). {A = X;} 1749 1750 %type frame_exclude {u8} 1751 frame_exclude(A) ::= NO(X) OTHERS. {A = @X; /*A-overwrites-X*/} 1752 frame_exclude(A) ::= CURRENT(X) ROW. {A = @X; /*A-overwrites-X*/} 1753 frame_exclude(A) ::= GROUP|TIES(X). {A = @X; /*A-overwrites-X*/} 1754 1755 1756 %type window_clause {Window*} 1757 %destructor window_clause {sqlite3WindowListDelete(pParse->db, $$);} 1758 window_clause(A) ::= WINDOW windowdefn_list(B). { A = B; } 1759 1760 filter_over(A) ::= filter_clause(F) over_clause(O). { 1761 O->pFilter = F; 1762 A = O; 1763 } 1764 filter_over(A) ::= over_clause(O). { 1765 A = O; 1766 } 1767 filter_over(A) ::= filter_clause(F). { 1768 A = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); 1769 if( A ){ 1770 A->eFrmType = TK_FILTER; 1771 A->pFilter = F; 1772 }else{ 1773 sqlite3ExprDelete(pParse->db, F); 1774 } 1775 } 1776 1777 over_clause(A) ::= OVER LP window(Z) RP. { 1778 A = Z; 1779 assert( A!=0 ); 1780 } 1781 over_clause(A) ::= OVER nm(Z). { 1782 A = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); 1783 if( A ){ 1784 A->zName = sqlite3DbStrNDup(pParse->db, Z.z, Z.n); 1785 } 1786 } 1787 1788 filter_clause(A) ::= FILTER LP WHERE expr(X) RP. { A = X; } 1789 %endif /* SQLITE_OMIT_WINDOWFUNC */ 1790 1791 /* 1792 ** The code generator needs some extra TK_ token values for tokens that 1793 ** are synthesized and do not actually appear in the grammar: 1794 */ 1795 %token 1796 COLUMN /* Reference to a table column */ 1797 AGG_FUNCTION /* An aggregate function */ 1798 AGG_COLUMN /* An aggregated column */ 1799 TRUEFALSE /* True or false keyword */ 1800 ISNOT /* Combination of IS and NOT */ 1801 FUNCTION /* A function invocation */ 1802 UMINUS /* Unary minus */ 1803 UPLUS /* Unary plus */ 1804 TRUTH /* IS TRUE or IS FALSE or IS NOT TRUE or IS NOT FALSE */ 1805 REGISTER /* Reference to a VDBE register */ 1806 VECTOR /* Vector */ 1807 SELECT_COLUMN /* Choose a single column from a multi-column SELECT */ 1808 IF_NULL_ROW /* the if-null-row operator */ 1809 ASTERISK /* The "*" in count(*) and similar */ 1810 SPAN /* The span operator */ 1811 . 1812 /* There must be no more than 255 tokens defined above. If this grammar 1813 ** is extended with new rules and tokens, they must either be so few in 1814 ** number that TK_SPAN is no more than 255, or else the new tokens must 1815 ** appear after this line. 1816 */ 1817 %include { 1818 #if TK_SPAN>255 1819 # error too many tokens in the grammar 1820 #endif 1821 } 1822 1823 /* 1824 ** The TK_SPACE and TK_ILLEGAL tokens must be the last two tokens. The 1825 ** parser depends on this. Those tokens are not used in any grammar rule. 1826 ** They are only used by the tokenizer. Declare them last so that they 1827 ** are guaranteed to be the last two tokens 1828 */ 1829 %token SPACE ILLEGAL. 1830