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