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 /* 103 ** Disable lookaside memory allocation for objects that might be 104 ** shared across database connections. 105 */ 106 static void disableLookaside(Parse *pParse){ 107 pParse->disableLookaside++; 108 pParse->db->lookaside.bDisable++; 109 } 110 111 } // end %include 112 113 // Input is a single SQL command 114 input ::= cmdlist. 115 cmdlist ::= cmdlist ecmd. 116 cmdlist ::= ecmd. 117 ecmd ::= SEMI. 118 ecmd ::= cmdx SEMI. 119 %ifndef SQLITE_OMIT_EXPLAIN 120 ecmd ::= explain cmdx. 121 explain ::= EXPLAIN. { pParse->explain = 1; } 122 explain ::= EXPLAIN QUERY PLAN. { pParse->explain = 2; } 123 %endif SQLITE_OMIT_EXPLAIN 124 cmdx ::= cmd. { sqlite3FinishCoding(pParse); } 125 126 ///////////////////// Begin and end transactions. //////////////////////////// 127 // 128 129 cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);} 130 trans_opt ::= . 131 trans_opt ::= TRANSACTION. 132 trans_opt ::= TRANSACTION nm. 133 %type transtype {int} 134 transtype(A) ::= . {A = TK_DEFERRED;} 135 transtype(A) ::= DEFERRED(X). {A = @X; /*A-overwrites-X*/} 136 transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/} 137 transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/} 138 cmd ::= COMMIT|END(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} 139 cmd ::= ROLLBACK(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} 140 141 savepoint_opt ::= SAVEPOINT. 142 savepoint_opt ::= . 143 cmd ::= SAVEPOINT nm(X). { 144 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X); 145 } 146 cmd ::= RELEASE savepoint_opt nm(X). { 147 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X); 148 } 149 cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). { 150 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X); 151 } 152 153 ///////////////////// The CREATE TABLE statement //////////////////////////// 154 // 155 cmd ::= create_table create_table_args. 156 create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). { 157 sqlite3StartTable(pParse,&Y,&Z,T,0,0,E); 158 } 159 createkw(A) ::= CREATE(A). {disableLookaside(pParse);} 160 161 %type ifnotexists {int} 162 ifnotexists(A) ::= . {A = 0;} 163 ifnotexists(A) ::= IF NOT EXISTS. {A = 1;} 164 %type temp {int} 165 %ifndef SQLITE_OMIT_TEMPDB 166 temp(A) ::= TEMP. {A = 1;} 167 %endif SQLITE_OMIT_TEMPDB 168 temp(A) ::= . {A = 0;} 169 create_table_args ::= LP columnlist conslist_opt(X) RP(E) table_options(F). { 170 sqlite3EndTable(pParse,&X,&E,F,0); 171 } 172 create_table_args ::= AS select(S). { 173 sqlite3EndTable(pParse,0,0,0,S); 174 sqlite3SelectDelete(pParse->db, S); 175 } 176 %type table_options {int} 177 table_options(A) ::= . {A = 0;} 178 table_options(A) ::= WITHOUT nm(X). { 179 if( X.n==5 && sqlite3_strnicmp(X.z,"rowid",5)==0 ){ 180 A = TF_WithoutRowid | TF_NoVisibleRowid; 181 }else{ 182 A = 0; 183 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", X.n, X.z); 184 } 185 } 186 columnlist ::= columnlist COMMA columnname carglist. 187 columnlist ::= columnname carglist. 188 columnname(A) ::= nm(A) typetoken(Y). {sqlite3AddColumn(pParse,&A,&Y);} 189 190 // Declare some tokens early in order to influence their values, to 191 // improve performance and reduce the executable size. The goal here is 192 // to get the "jump" operations in ISNULL through ESCAPE to have numeric 193 // values that are early enough so that all jump operations are clustered 194 // at the beginning, but also so that the comparison tokens NE through GE 195 // are as large as possible so that they are near to FUNCTION, which is a 196 // token synthesized by addopcodes.tcl. 197 // 198 %token ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST. 199 %token CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL. 200 %token OR AND NOT IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ. 201 %token GT LE LT GE ESCAPE. 202 203 // The following directive causes tokens ABORT, AFTER, ASC, etc. to 204 // fallback to ID if they will not parse as their original value. 205 // This obviates the need for the "id" nonterminal. 206 // 207 %fallback ID 208 ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW 209 CONFLICT DATABASE DEFERRED DESC DETACH DO 210 EACH END EXCLUSIVE EXPLAIN FAIL FOR 211 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH NO PLAN 212 QUERY KEY OF OFFSET PRAGMA RAISE RECURSIVE RELEASE REPLACE RESTRICT ROW 213 ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT 214 %ifdef SQLITE_OMIT_COMPOUND_SELECT 215 EXCEPT INTERSECT UNION 216 %endif SQLITE_OMIT_COMPOUND_SELECT 217 REINDEX RENAME CTIME_KW IF 218 . 219 %wildcard ANY. 220 221 // Define operator precedence early so that this is the first occurrence 222 // of the operator tokens in the grammer. Keeping the operators together 223 // causes them to be assigned integer values that are close together, 224 // which keeps parser tables smaller. 225 // 226 // The token values assigned to these symbols is determined by the order 227 // in which lemon first sees them. It must be the case that ISNULL/NOTNULL, 228 // NE/EQ, GT/LE, and GE/LT are separated by only a single value. See 229 // the sqlite3ExprIfFalse() routine for additional information on this 230 // constraint. 231 // 232 %left OR. 233 %left AND. 234 %right NOT. 235 %left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ. 236 %left GT LE LT GE. 237 %right ESCAPE. 238 %left BITAND BITOR LSHIFT RSHIFT. 239 %left PLUS MINUS. 240 %left STAR SLASH REM. 241 %left CONCAT. 242 %left COLLATE. 243 %right BITNOT. 244 %nonassoc ON. 245 246 // An IDENTIFIER can be a generic identifier, or one of several 247 // keywords. Any non-standard keyword can also be an identifier. 248 // 249 %token_class id ID|INDEXED. 250 251 252 // And "ids" is an identifer-or-string. 253 // 254 %token_class ids ID|STRING. 255 256 // The name of a column or table can be any of the following: 257 // 258 %type nm {Token} 259 nm(A) ::= id(A). 260 nm(A) ::= STRING(A). 261 nm(A) ::= JOIN_KW(A). 262 263 // A typetoken is really zero or more tokens that form a type name such 264 // as can be found after the column name in a CREATE TABLE statement. 265 // Multiple tokens are concatenated to form the value of the typetoken. 266 // 267 %type typetoken {Token} 268 typetoken(A) ::= . {A.n = 0; A.z = 0;} 269 typetoken(A) ::= typename(A). 270 typetoken(A) ::= typename(A) LP signed RP(Y). { 271 A.n = (int)(&Y.z[Y.n] - A.z); 272 } 273 typetoken(A) ::= typename(A) LP signed COMMA signed RP(Y). { 274 A.n = (int)(&Y.z[Y.n] - A.z); 275 } 276 %type typename {Token} 277 typename(A) ::= ids(A). 278 typename(A) ::= typename(A) ids(Y). {A.n=Y.n+(int)(Y.z-A.z);} 279 signed ::= plus_num. 280 signed ::= minus_num. 281 282 // The scanpt non-terminal takes a value which is a pointer to the 283 // input text just past the last token that has been shifted into 284 // the parser. By surrounding some phrase in the grammar with two 285 // scanpt non-terminals, we can capture the input text for that phrase. 286 // For example: 287 // 288 // something ::= .... scanpt(A) phrase scanpt(Z). 289 // 290 // The text that is parsed as "phrase" is a string starting at A 291 // and containing (int)(Z-A) characters. There might be some extra 292 // whitespace on either end of the text, but that can be removed in 293 // post-processing, if needed. 294 // 295 %type scanpt {const char*} 296 scanpt(A) ::= . { 297 assert( yyLookahead!=YYNOCODE ); 298 A = yyLookaheadToken.z; 299 } 300 301 // "carglist" is a list of additional constraints that come after the 302 // column name and column type in a CREATE TABLE statement. 303 // 304 carglist ::= carglist ccons. 305 carglist ::= . 306 ccons ::= CONSTRAINT nm(X). {pParse->constraintName = X;} 307 ccons ::= DEFAULT scanpt(A) term(X) scanpt(Z). 308 {sqlite3AddDefaultValue(pParse,X,A,Z);} 309 ccons ::= DEFAULT LP(A) expr(X) RP(Z). 310 {sqlite3AddDefaultValue(pParse,X,A.z+1,Z.z);} 311 ccons ::= DEFAULT PLUS(A) term(X) scanpt(Z). 312 {sqlite3AddDefaultValue(pParse,X,A.z,Z);} 313 ccons ::= DEFAULT MINUS(A) term(X) scanpt(Z). { 314 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0); 315 sqlite3AddDefaultValue(pParse,p,A.z,Z); 316 } 317 ccons ::= DEFAULT scanpt id(X). { 318 Expr *p = tokenExpr(pParse, TK_STRING, X); 319 if( p ){ 320 sqlite3ExprIdToTrueFalse(p); 321 testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) ); 322 } 323 sqlite3AddDefaultValue(pParse,p,X.z,X.z+X.n); 324 } 325 326 // In addition to the type name, we also care about the primary key and 327 // UNIQUE constraints. 328 // 329 ccons ::= NULL onconf. 330 ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);} 331 ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I). 332 {sqlite3AddPrimaryKey(pParse,0,R,I,Z);} 333 ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0, 334 SQLITE_IDXTYPE_UNIQUE);} 335 ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X);} 336 ccons ::= REFERENCES nm(T) eidlist_opt(TA) refargs(R). 337 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);} 338 ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);} 339 ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);} 340 341 // The optional AUTOINCREMENT keyword 342 %type autoinc {int} 343 autoinc(X) ::= . {X = 0;} 344 autoinc(X) ::= AUTOINCR. {X = 1;} 345 346 // The next group of rules parses the arguments to a REFERENCES clause 347 // that determine if the referential integrity checking is deferred or 348 // or immediate and which determine what action to take if a ref-integ 349 // check fails. 350 // 351 %type refargs {int} 352 refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */} 353 refargs(A) ::= refargs(A) refarg(Y). { A = (A & ~Y.mask) | Y.value; } 354 %type refarg {struct {int value; int mask;}} 355 refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; } 356 refarg(A) ::= ON INSERT refact. { A.value = 0; A.mask = 0x000000; } 357 refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; } 358 refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; } 359 %type refact {int} 360 refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */} 361 refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */} 362 refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */} 363 refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */} 364 refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */} 365 %type defer_subclause {int} 366 defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt. {A = 0;} 367 defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;} 368 %type init_deferred_pred_opt {int} 369 init_deferred_pred_opt(A) ::= . {A = 0;} 370 init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;} 371 init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;} 372 373 conslist_opt(A) ::= . {A.n = 0; A.z = 0;} 374 conslist_opt(A) ::= COMMA(A) conslist. 375 conslist ::= conslist tconscomma tcons. 376 conslist ::= tcons. 377 tconscomma ::= COMMA. {pParse->constraintName.n = 0;} 378 tconscomma ::= . 379 tcons ::= CONSTRAINT nm(X). {pParse->constraintName = X;} 380 tcons ::= PRIMARY KEY LP sortlist(X) autoinc(I) RP onconf(R). 381 {sqlite3AddPrimaryKey(pParse,X,R,I,0);} 382 tcons ::= UNIQUE LP sortlist(X) RP onconf(R). 383 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0, 384 SQLITE_IDXTYPE_UNIQUE);} 385 tcons ::= CHECK LP expr(E) RP onconf. 386 {sqlite3AddCheckConstraint(pParse,E);} 387 tcons ::= FOREIGN KEY LP eidlist(FA) RP 388 REFERENCES nm(T) eidlist_opt(TA) refargs(R) defer_subclause_opt(D). { 389 sqlite3CreateForeignKey(pParse, FA, &T, TA, R); 390 sqlite3DeferForeignKey(pParse, D); 391 } 392 %type defer_subclause_opt {int} 393 defer_subclause_opt(A) ::= . {A = 0;} 394 defer_subclause_opt(A) ::= defer_subclause(A). 395 396 // The following is a non-standard extension that allows us to declare the 397 // default behavior when there is a constraint conflict. 398 // 399 %type onconf {int} 400 %type orconf {int} 401 %type resolvetype {int} 402 onconf(A) ::= . {A = OE_Default;} 403 onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;} 404 orconf(A) ::= . {A = OE_Default;} 405 orconf(A) ::= OR resolvetype(X). {A = X;} 406 resolvetype(A) ::= raisetype(A). 407 resolvetype(A) ::= IGNORE. {A = OE_Ignore;} 408 resolvetype(A) ::= REPLACE. {A = OE_Replace;} 409 410 ////////////////////////// The DROP TABLE ///////////////////////////////////// 411 // 412 cmd ::= DROP TABLE ifexists(E) fullname(X). { 413 sqlite3DropTable(pParse, X, 0, E); 414 } 415 %type ifexists {int} 416 ifexists(A) ::= IF EXISTS. {A = 1;} 417 ifexists(A) ::= . {A = 0;} 418 419 ///////////////////// The CREATE VIEW statement ///////////////////////////// 420 // 421 %ifndef SQLITE_OMIT_VIEW 422 cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) eidlist_opt(C) 423 AS select(S). { 424 sqlite3CreateView(pParse, &X, &Y, &Z, C, S, T, E); 425 } 426 cmd ::= DROP VIEW ifexists(E) fullname(X). { 427 sqlite3DropTable(pParse, X, 1, E); 428 } 429 %endif SQLITE_OMIT_VIEW 430 431 //////////////////////// The SELECT statement ///////////////////////////////// 432 // 433 cmd ::= select(X). { 434 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0}; 435 sqlite3Select(pParse, X, &dest); 436 sqlite3SelectDelete(pParse->db, X); 437 } 438 439 %type select {Select*} 440 %destructor select {sqlite3SelectDelete(pParse->db, $$);} 441 %type selectnowith {Select*} 442 %destructor selectnowith {sqlite3SelectDelete(pParse->db, $$);} 443 %type oneselect {Select*} 444 %destructor oneselect {sqlite3SelectDelete(pParse->db, $$);} 445 446 %include { 447 /* 448 ** For a compound SELECT statement, make sure p->pPrior->pNext==p for 449 ** all elements in the list. And make sure list length does not exceed 450 ** SQLITE_LIMIT_COMPOUND_SELECT. 451 */ 452 static void parserDoubleLinkSelect(Parse *pParse, Select *p){ 453 if( p->pPrior ){ 454 Select *pNext = 0, *pLoop; 455 int mxSelect, cnt = 0; 456 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){ 457 pLoop->pNext = pNext; 458 pLoop->selFlags |= SF_Compound; 459 } 460 if( (p->selFlags & SF_MultiValue)==0 && 461 (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && 462 cnt>mxSelect 463 ){ 464 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); 465 } 466 } 467 } 468 } 469 470 %ifndef SQLITE_OMIT_CTE 471 select(A) ::= WITH wqlist(W) selectnowith(X). { 472 Select *p = X; 473 if( p ){ 474 p->pWith = W; 475 parserDoubleLinkSelect(pParse, p); 476 }else{ 477 sqlite3WithDelete(pParse->db, W); 478 } 479 A = p; 480 } 481 select(A) ::= WITH RECURSIVE wqlist(W) selectnowith(X). { 482 Select *p = X; 483 if( p ){ 484 p->pWith = W; 485 parserDoubleLinkSelect(pParse, p); 486 }else{ 487 sqlite3WithDelete(pParse->db, W); 488 } 489 A = p; 490 } 491 %endif /* SQLITE_OMIT_CTE */ 492 select(A) ::= selectnowith(X). { 493 Select *p = X; 494 if( p ){ 495 parserDoubleLinkSelect(pParse, p); 496 } 497 A = p; /*A-overwrites-X*/ 498 } 499 500 selectnowith(A) ::= oneselect(A). 501 %ifndef SQLITE_OMIT_COMPOUND_SELECT 502 selectnowith(A) ::= selectnowith(A) multiselect_op(Y) oneselect(Z). { 503 Select *pRhs = Z; 504 Select *pLhs = A; 505 if( pRhs && pRhs->pPrior ){ 506 SrcList *pFrom; 507 Token x; 508 x.n = 0; 509 parserDoubleLinkSelect(pParse, pRhs); 510 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0); 511 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); 512 } 513 if( pRhs ){ 514 pRhs->op = (u8)Y; 515 pRhs->pPrior = pLhs; 516 if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; 517 pRhs->selFlags &= ~SF_MultiValue; 518 if( Y!=TK_ALL ) pParse->hasCompound = 1; 519 }else{ 520 sqlite3SelectDelete(pParse->db, pLhs); 521 } 522 A = pRhs; 523 } 524 %type multiselect_op {int} 525 multiselect_op(A) ::= UNION(OP). {A = @OP; /*A-overwrites-OP*/} 526 multiselect_op(A) ::= UNION ALL. {A = TK_ALL;} 527 multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP; /*A-overwrites-OP*/} 528 %endif SQLITE_OMIT_COMPOUND_SELECT 529 oneselect(A) ::= SELECT(S) distinct(D) selcollist(W) from(X) where_opt(Y) 530 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). { 531 #if SELECTTRACE_ENABLED 532 Token s = S; /*A-overwrites-S*/ 533 #endif 534 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L); 535 #if SELECTTRACE_ENABLED 536 /* Populate the Select.zSelName[] string that is used to help with 537 ** query planner debugging, to differentiate between multiple Select 538 ** objects in a complex query. 539 ** 540 ** If the SELECT keyword is immediately followed by a C-style comment 541 ** then extract the first few alphanumeric characters from within that 542 ** comment to be the zSelName value. Otherwise, the label is #N where 543 ** is an integer that is incremented with each SELECT statement seen. 544 */ 545 if( A!=0 ){ 546 const char *z = s.z+6; 547 int i; 548 sqlite3_snprintf(sizeof(A->zSelName), A->zSelName,"#%d",++pParse->nSelect); 549 while( z[0]==' ' ) z++; 550 if( z[0]=='/' && z[1]=='*' ){ 551 z += 2; 552 while( z[0]==' ' ) z++; 553 for(i=0; sqlite3Isalnum(z[i]); i++){} 554 sqlite3_snprintf(sizeof(A->zSelName), A->zSelName, "%.*s", i, z); 555 } 556 } 557 #endif /* SELECTRACE_ENABLED */ 558 } 559 oneselect(A) ::= values(A). 560 561 %type values {Select*} 562 %destructor values {sqlite3SelectDelete(pParse->db, $$);} 563 values(A) ::= VALUES LP nexprlist(X) RP. { 564 A = sqlite3SelectNew(pParse,X,0,0,0,0,0,SF_Values,0); 565 } 566 values(A) ::= values(A) COMMA LP exprlist(Y) RP. { 567 Select *pRight, *pLeft = A; 568 pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values|SF_MultiValue,0); 569 if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; 570 if( pRight ){ 571 pRight->op = TK_ALL; 572 pRight->pPrior = pLeft; 573 A = pRight; 574 }else{ 575 A = pLeft; 576 } 577 } 578 579 // The "distinct" nonterminal is true (1) if the DISTINCT keyword is 580 // present and false (0) if it is not. 581 // 582 %type distinct {int} 583 distinct(A) ::= DISTINCT. {A = SF_Distinct;} 584 distinct(A) ::= ALL. {A = SF_All;} 585 distinct(A) ::= . {A = 0;} 586 587 // selcollist is a list of expressions that are to become the return 588 // values of the SELECT statement. The "*" in statements like 589 // "SELECT * FROM ..." is encoded as a special expression with an 590 // opcode of TK_ASTERISK. 591 // 592 %type selcollist {ExprList*} 593 %destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);} 594 %type sclp {ExprList*} 595 %destructor sclp {sqlite3ExprListDelete(pParse->db, $$);} 596 sclp(A) ::= selcollist(A) COMMA. 597 sclp(A) ::= . {A = 0;} 598 selcollist(A) ::= sclp(A) scanpt(B) expr(X) scanpt(Z) as(Y). { 599 A = sqlite3ExprListAppend(pParse, A, X); 600 if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1); 601 sqlite3ExprListSetSpan(pParse,A,B,Z); 602 } 603 selcollist(A) ::= sclp(A) scanpt STAR. { 604 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); 605 A = sqlite3ExprListAppend(pParse, A, p); 606 } 607 selcollist(A) ::= sclp(A) scanpt nm(X) DOT STAR. { 608 Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); 609 Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 610 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); 611 A = sqlite3ExprListAppend(pParse,A, pDot); 612 } 613 614 // An option "AS <id>" phrase that can follow one of the expressions that 615 // define the result set, or one of the tables in the FROM clause. 616 // 617 %type as {Token} 618 as(X) ::= AS nm(Y). {X = Y;} 619 as(X) ::= ids(X). 620 as(X) ::= . {X.n = 0; X.z = 0;} 621 622 623 %type seltablist {SrcList*} 624 %destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);} 625 %type stl_prefix {SrcList*} 626 %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);} 627 %type from {SrcList*} 628 %destructor from {sqlite3SrcListDelete(pParse->db, $$);} 629 630 // A complete FROM clause. 631 // 632 from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));} 633 from(A) ::= FROM seltablist(X). { 634 A = X; 635 sqlite3SrcListShiftJoinType(A); 636 } 637 638 // "seltablist" is a "Select Table List" - the content of the FROM clause 639 // in a SELECT statement. "stl_prefix" is a prefix of this list. 640 // 641 stl_prefix(A) ::= seltablist(A) joinop(Y). { 642 if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].fg.jointype = (u8)Y; 643 } 644 stl_prefix(A) ::= . {A = 0;} 645 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) as(Z) indexed_opt(I) 646 on_opt(N) using_opt(U). { 647 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U); 648 sqlite3SrcListIndexedBy(pParse, A, &I); 649 } 650 seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) LP exprlist(E) RP as(Z) 651 on_opt(N) using_opt(U). { 652 A = sqlite3SrcListAppendFromTerm(pParse,A,&Y,&D,&Z,0,N,U); 653 sqlite3SrcListFuncArgs(pParse, A, E); 654 } 655 %ifndef SQLITE_OMIT_SUBQUERY 656 seltablist(A) ::= stl_prefix(A) LP select(S) RP 657 as(Z) on_opt(N) using_opt(U). { 658 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,S,N,U); 659 } 660 seltablist(A) ::= stl_prefix(A) LP seltablist(F) RP 661 as(Z) on_opt(N) using_opt(U). { 662 if( A==0 && Z.n==0 && N==0 && U==0 ){ 663 A = F; 664 }else if( F->nSrc==1 ){ 665 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,0,N,U); 666 if( A ){ 667 struct SrcList_item *pNew = &A->a[A->nSrc-1]; 668 struct SrcList_item *pOld = F->a; 669 pNew->zName = pOld->zName; 670 pNew->zDatabase = pOld->zDatabase; 671 pNew->pSelect = pOld->pSelect; 672 pOld->zName = pOld->zDatabase = 0; 673 pOld->pSelect = 0; 674 } 675 sqlite3SrcListDelete(pParse->db, F); 676 }else{ 677 Select *pSubquery; 678 sqlite3SrcListShiftJoinType(F); 679 pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,SF_NestedFrom,0); 680 A = sqlite3SrcListAppendFromTerm(pParse,A,0,0,&Z,pSubquery,N,U); 681 } 682 } 683 %endif SQLITE_OMIT_SUBQUERY 684 685 %type dbnm {Token} 686 dbnm(A) ::= . {A.z=0; A.n=0;} 687 dbnm(A) ::= DOT nm(X). {A = X;} 688 689 %type fullname {SrcList*} 690 %destructor fullname {sqlite3SrcListDelete(pParse->db, $$);} 691 fullname(A) ::= nm(X). 692 {A = sqlite3SrcListAppend(pParse->db,0,&X,0); /*A-overwrites-X*/} 693 fullname(A) ::= nm(X) DOT nm(Y). 694 {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y); /*A-overwrites-X*/} 695 696 %type xfullname {SrcList*} 697 %destructor xfullname {sqlite3SrcListDelete(pParse->db, $$);} 698 xfullname(A) ::= nm(X). 699 {A = sqlite3SrcListAppend(pParse->db,0,&X,0); /*A-overwrites-X*/} 700 xfullname(A) ::= nm(X) DOT nm(Y). 701 {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y); /*A-overwrites-X*/} 702 xfullname(A) ::= nm(X) DOT nm(Y) AS nm(Z). { 703 A = sqlite3SrcListAppend(pParse->db,0,&X,&Y); /*A-overwrites-X*/ 704 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z); 705 } 706 xfullname(A) ::= nm(X) AS nm(Z). { 707 A = sqlite3SrcListAppend(pParse->db,0,&X,0); /*A-overwrites-X*/ 708 if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z); 709 } 710 711 %type joinop {int} 712 joinop(X) ::= COMMA|JOIN. { X = JT_INNER; } 713 joinop(X) ::= JOIN_KW(A) JOIN. 714 {X = sqlite3JoinType(pParse,&A,0,0); /*X-overwrites-A*/} 715 joinop(X) ::= JOIN_KW(A) nm(B) JOIN. 716 {X = sqlite3JoinType(pParse,&A,&B,0); /*X-overwrites-A*/} 717 joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN. 718 {X = sqlite3JoinType(pParse,&A,&B,&C);/*X-overwrites-A*/} 719 720 // There is a parsing abiguity in an upsert statement that uses a 721 // SELECT on the RHS of a the INSERT: 722 // 723 // INSERT INTO tab SELECT * FROM aaa JOIN bbb ON CONFLICT ... 724 // here ----^^ 725 // 726 // When the ON token is encountered, the parser does not know if it is 727 // the beginning of an ON CONFLICT clause, or the beginning of an ON 728 // clause associated with the JOIN. The conflict is resolved in favor 729 // of the JOIN. If an ON CONFLICT clause is intended, insert a dummy 730 // WHERE clause in between, like this: 731 // 732 // INSERT INTO tab SELECT * FROM aaa JOIN bbb WHERE true ON CONFLICT ... 733 // 734 // The [AND] and [OR] precedence marks in the rules for on_opt cause the 735 // ON in this context to always be interpreted as belonging to the JOIN. 736 // 737 %type on_opt {Expr*} 738 %destructor on_opt {sqlite3ExprDelete(pParse->db, $$);} 739 on_opt(N) ::= ON expr(E). {N = E;} 740 on_opt(N) ::= . [OR] {N = 0;} 741 742 // Note that this block abuses the Token type just a little. If there is 743 // no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If 744 // there is an INDEXED BY clause, then the token is populated as per normal, 745 // with z pointing to the token data and n containing the number of bytes 746 // in the token. 747 // 748 // If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is 749 // normally illegal. The sqlite3SrcListIndexedBy() function 750 // recognizes and interprets this as a special case. 751 // 752 %type indexed_opt {Token} 753 indexed_opt(A) ::= . {A.z=0; A.n=0;} 754 indexed_opt(A) ::= INDEXED BY nm(X). {A = X;} 755 indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;} 756 757 %type using_opt {IdList*} 758 %destructor using_opt {sqlite3IdListDelete(pParse->db, $$);} 759 using_opt(U) ::= USING LP idlist(L) RP. {U = L;} 760 using_opt(U) ::= . {U = 0;} 761 762 763 %type orderby_opt {ExprList*} 764 %destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);} 765 766 // the sortlist non-terminal stores a list of expression where each 767 // expression is optionally followed by ASC or DESC to indicate the 768 // sort order. 769 // 770 %type sortlist {ExprList*} 771 %destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);} 772 773 orderby_opt(A) ::= . {A = 0;} 774 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} 775 sortlist(A) ::= sortlist(A) COMMA expr(Y) sortorder(Z). { 776 A = sqlite3ExprListAppend(pParse,A,Y); 777 sqlite3ExprListSetSortOrder(A,Z); 778 } 779 sortlist(A) ::= expr(Y) sortorder(Z). { 780 A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/ 781 sqlite3ExprListSetSortOrder(A,Z); 782 } 783 784 %type sortorder {int} 785 786 sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;} 787 sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;} 788 sortorder(A) ::= . {A = SQLITE_SO_UNDEFINED;} 789 790 %type groupby_opt {ExprList*} 791 %destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);} 792 groupby_opt(A) ::= . {A = 0;} 793 groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;} 794 795 %type having_opt {Expr*} 796 %destructor having_opt {sqlite3ExprDelete(pParse->db, $$);} 797 having_opt(A) ::= . {A = 0;} 798 having_opt(A) ::= HAVING expr(X). {A = X;} 799 800 %type limit_opt {Expr*} 801 802 // The destructor for limit_opt will never fire in the current grammar. 803 // The limit_opt non-terminal only occurs at the end of a single production 804 // rule for SELECT statements. As soon as the rule that create the 805 // limit_opt non-terminal reduces, the SELECT statement rule will also 806 // reduce. So there is never a limit_opt non-terminal on the stack 807 // except as a transient. So there is never anything to destroy. 808 // 809 //%destructor limit_opt {sqlite3ExprDelete(pParse->db, $$);} 810 limit_opt(A) ::= . {A = 0;} 811 limit_opt(A) ::= LIMIT expr(X). 812 {A = sqlite3PExpr(pParse,TK_LIMIT,X,0);} 813 limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y). 814 {A = sqlite3PExpr(pParse,TK_LIMIT,X,Y);} 815 limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y). 816 {A = sqlite3PExpr(pParse,TK_LIMIT,Y,X);} 817 818 /////////////////////////// The DELETE statement ///////////////////////////// 819 // 820 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 821 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W) 822 orderby_opt(O) limit_opt(L). { 823 sqlite3SrcListIndexedBy(pParse, X, &I); 824 sqlite3DeleteFrom(pParse,X,W,O,L); 825 } 826 %endif 827 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 828 cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt(W). { 829 sqlite3SrcListIndexedBy(pParse, X, &I); 830 sqlite3DeleteFrom(pParse,X,W,0,0); 831 } 832 %endif 833 834 %type where_opt {Expr*} 835 %destructor where_opt {sqlite3ExprDelete(pParse->db, $$);} 836 837 where_opt(A) ::= . {A = 0;} 838 where_opt(A) ::= WHERE expr(X). {A = X;} 839 840 ////////////////////////// The UPDATE command //////////////////////////////// 841 // 842 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 843 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) 844 where_opt(W) orderby_opt(O) limit_opt(L). { 845 sqlite3SrcListIndexedBy(pParse, X, &I); 846 sqlite3ExprListCheckLength(pParse,Y,"set list"); 847 sqlite3Update(pParse,X,Y,W,R,O,L,0); 848 } 849 %endif 850 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 851 cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) 852 where_opt(W). { 853 sqlite3SrcListIndexedBy(pParse, X, &I); 854 sqlite3ExprListCheckLength(pParse,Y,"set list"); 855 sqlite3Update(pParse,X,Y,W,R,0,0,0); 856 } 857 %endif 858 859 %type setlist {ExprList*} 860 %destructor setlist {sqlite3ExprListDelete(pParse->db, $$);} 861 862 setlist(A) ::= setlist(A) COMMA nm(X) EQ expr(Y). { 863 A = sqlite3ExprListAppend(pParse, A, Y); 864 sqlite3ExprListSetName(pParse, A, &X, 1); 865 } 866 setlist(A) ::= setlist(A) COMMA LP idlist(X) RP EQ expr(Y). { 867 A = sqlite3ExprListAppendVector(pParse, A, X, Y); 868 } 869 setlist(A) ::= nm(X) EQ expr(Y). { 870 A = sqlite3ExprListAppend(pParse, 0, Y); 871 sqlite3ExprListSetName(pParse, A, &X, 1); 872 } 873 setlist(A) ::= LP idlist(X) RP EQ expr(Y). { 874 A = sqlite3ExprListAppendVector(pParse, 0, X, Y); 875 } 876 877 ////////////////////////// The INSERT command ///////////////////////////////// 878 // 879 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) select(S) 880 upsert(U). { 881 sqlite3Insert(pParse, X, S, F, R, U); 882 } 883 cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) DEFAULT VALUES. 884 { 885 sqlite3Insert(pParse, X, 0, F, R, 0); 886 } 887 888 %type upsert {Upsert*} 889 890 // Because upsert only occurs at the tip end of the INSERT rule for cmd, 891 // there is never a case where the value of the upsert pointer will not 892 // be destroyed by the cmd action. So comment-out the destructor to 893 // avoid unreachable code. 894 //%destructor upsert {sqlite3UpsertDelete(pParse->db,$$);} 895 upsert(A) ::= . { A = 0; } 896 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW) 897 DO UPDATE SET setlist(Z) where_opt(W). 898 { A = sqlite3UpsertNew(pParse->db,T,TW,Z,W);} 899 upsert(A) ::= ON CONFLICT LP sortlist(T) RP where_opt(TW) DO NOTHING. 900 { A = sqlite3UpsertNew(pParse->db,T,TW,0,0); } 901 upsert(A) ::= ON CONFLICT DO NOTHING. 902 { A = sqlite3UpsertNew(pParse->db,0,0,0,0); } 903 904 %type insert_cmd {int} 905 insert_cmd(A) ::= INSERT orconf(R). {A = R;} 906 insert_cmd(A) ::= REPLACE. {A = OE_Replace;} 907 908 %type idlist_opt {IdList*} 909 %destructor idlist_opt {sqlite3IdListDelete(pParse->db, $$);} 910 %type idlist {IdList*} 911 %destructor idlist {sqlite3IdListDelete(pParse->db, $$);} 912 913 idlist_opt(A) ::= . {A = 0;} 914 idlist_opt(A) ::= LP idlist(X) RP. {A = X;} 915 idlist(A) ::= idlist(A) COMMA nm(Y). 916 {A = sqlite3IdListAppend(pParse->db,A,&Y);} 917 idlist(A) ::= nm(Y). 918 {A = sqlite3IdListAppend(pParse->db,0,&Y); /*A-overwrites-Y*/} 919 920 /////////////////////////// Expression Processing ///////////////////////////// 921 // 922 923 %type expr {Expr*} 924 %destructor expr {sqlite3ExprDelete(pParse->db, $$);} 925 %type term {Expr*} 926 %destructor term {sqlite3ExprDelete(pParse->db, $$);} 927 928 %include { 929 930 /* Construct a new Expr object from a single identifier. Use the 931 ** new Expr to populate pOut. Set the span of pOut to be the identifier 932 ** that created the expression. 933 */ 934 static Expr *tokenExpr(Parse *pParse, int op, Token t){ 935 Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1); 936 if( p ){ 937 memset(p, 0, sizeof(Expr)); 938 p->op = (u8)op; 939 p->flags = EP_Leaf; 940 p->iAgg = -1; 941 p->u.zToken = (char*)&p[1]; 942 memcpy(p->u.zToken, t.z, t.n); 943 p->u.zToken[t.n] = 0; 944 if( sqlite3Isquote(p->u.zToken[0]) ){ 945 if( p->u.zToken[0]=='"' ) p->flags |= EP_DblQuoted; 946 sqlite3Dequote(p->u.zToken); 947 } 948 #if SQLITE_MAX_EXPR_DEPTH>0 949 p->nHeight = 1; 950 #endif 951 } 952 return p; 953 } 954 } 955 956 expr(A) ::= term(A). 957 expr(A) ::= LP expr(X) RP. {A = X;} 958 expr(A) ::= id(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/} 959 expr(A) ::= JOIN_KW(X). {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/} 960 expr(A) ::= nm(X) DOT nm(Y). { 961 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 962 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1); 963 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); 964 } 965 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). { 966 Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); 967 Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1); 968 Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &Z, 1); 969 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); 970 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); 971 } 972 term(A) ::= NULL|FLOAT|BLOB(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/} 973 term(A) ::= STRING(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/} 974 term(A) ::= INTEGER(X). { 975 A = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &X, 1); 976 } 977 expr(A) ::= VARIABLE(X). { 978 if( !(X.z[0]=='#' && sqlite3Isdigit(X.z[1])) ){ 979 u32 n = X.n; 980 A = tokenExpr(pParse, TK_VARIABLE, X); 981 sqlite3ExprAssignVarNumber(pParse, A, n); 982 }else{ 983 /* When doing a nested parse, one can include terms in an expression 984 ** that look like this: #1 #2 ... These terms refer to registers 985 ** in the virtual machine. #N is the N-th register. */ 986 Token t = X; /*A-overwrites-X*/ 987 assert( t.n>=2 ); 988 if( pParse->nested==0 ){ 989 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); 990 A = 0; 991 }else{ 992 A = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); 993 if( A ) sqlite3GetInt32(&t.z[1], &A->iTable); 994 } 995 } 996 } 997 expr(A) ::= expr(A) COLLATE ids(C). { 998 A = sqlite3ExprAddCollateToken(pParse, A, &C, 1); 999 } 1000 %ifndef SQLITE_OMIT_CAST 1001 expr(A) ::= CAST LP expr(E) AS typetoken(T) RP. { 1002 A = sqlite3ExprAlloc(pParse->db, TK_CAST, &T, 1); 1003 sqlite3ExprAttachSubtrees(pParse->db, A, E, 0); 1004 } 1005 %endif SQLITE_OMIT_CAST 1006 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP. { 1007 if( Y && Y->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){ 1008 sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X); 1009 } 1010 A = sqlite3ExprFunction(pParse, Y, &X); 1011 if( D==SF_Distinct && A ){ 1012 A->flags |= EP_Distinct; 1013 } 1014 } 1015 expr(A) ::= id(X) LP STAR RP. { 1016 A = sqlite3ExprFunction(pParse, 0, &X); 1017 } 1018 term(A) ::= CTIME_KW(OP). { 1019 A = sqlite3ExprFunction(pParse, 0, &OP); 1020 } 1021 1022 expr(A) ::= LP nexprlist(X) COMMA expr(Y) RP. { 1023 ExprList *pList = sqlite3ExprListAppend(pParse, X, Y); 1024 A = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); 1025 if( A ){ 1026 A->x.pList = pList; 1027 }else{ 1028 sqlite3ExprListDelete(pParse->db, pList); 1029 } 1030 } 1031 1032 expr(A) ::= expr(A) AND(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1033 expr(A) ::= expr(A) OR(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1034 expr(A) ::= expr(A) LT|GT|GE|LE(OP) expr(Y). 1035 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1036 expr(A) ::= expr(A) EQ|NE(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1037 expr(A) ::= expr(A) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y). 1038 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1039 expr(A) ::= expr(A) PLUS|MINUS(OP) expr(Y). 1040 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1041 expr(A) ::= expr(A) STAR|SLASH|REM(OP) expr(Y). 1042 {A=sqlite3PExpr(pParse,@OP,A,Y);} 1043 expr(A) ::= expr(A) CONCAT(OP) expr(Y). {A=sqlite3PExpr(pParse,@OP,A,Y);} 1044 %type likeop {Token} 1045 likeop(A) ::= LIKE_KW|MATCH(A). 1046 likeop(A) ::= NOT LIKE_KW|MATCH(X). {A=X; A.n|=0x80000000; /*A-overwrite-X*/} 1047 expr(A) ::= expr(A) likeop(OP) expr(Y). [LIKE_KW] { 1048 ExprList *pList; 1049 int bNot = OP.n & 0x80000000; 1050 OP.n &= 0x7fffffff; 1051 pList = sqlite3ExprListAppend(pParse,0, Y); 1052 pList = sqlite3ExprListAppend(pParse,pList, A); 1053 A = sqlite3ExprFunction(pParse, pList, &OP); 1054 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1055 if( A ) A->flags |= EP_InfixFunc; 1056 } 1057 expr(A) ::= expr(A) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] { 1058 ExprList *pList; 1059 int bNot = OP.n & 0x80000000; 1060 OP.n &= 0x7fffffff; 1061 pList = sqlite3ExprListAppend(pParse,0, Y); 1062 pList = sqlite3ExprListAppend(pParse,pList, A); 1063 pList = sqlite3ExprListAppend(pParse,pList, E); 1064 A = sqlite3ExprFunction(pParse, pList, &OP); 1065 if( bNot ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1066 if( A ) A->flags |= EP_InfixFunc; 1067 } 1068 1069 expr(A) ::= expr(A) ISNULL|NOTNULL(E). {A = sqlite3PExpr(pParse,@E,A,0);} 1070 expr(A) ::= expr(A) NOT NULL. {A = sqlite3PExpr(pParse,TK_NOTNULL,A,0);} 1071 1072 %include { 1073 /* A routine to convert a binary TK_IS or TK_ISNOT expression into a 1074 ** unary TK_ISNULL or TK_NOTNULL expression. */ 1075 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ 1076 sqlite3 *db = pParse->db; 1077 if( pA && pY && pY->op==TK_NULL ){ 1078 pA->op = (u8)op; 1079 sqlite3ExprDelete(db, pA->pRight); 1080 pA->pRight = 0; 1081 } 1082 } 1083 } 1084 1085 // expr1 IS expr2 1086 // expr1 IS NOT expr2 1087 // 1088 // If expr2 is NULL then code as TK_ISNULL or TK_NOTNULL. If expr2 1089 // is any other expression, code as TK_IS or TK_ISNOT. 1090 // 1091 expr(A) ::= expr(A) IS expr(Y). { 1092 A = sqlite3PExpr(pParse,TK_IS,A,Y); 1093 binaryToUnaryIfNull(pParse, Y, A, TK_ISNULL); 1094 } 1095 expr(A) ::= expr(A) IS NOT expr(Y). { 1096 A = sqlite3PExpr(pParse,TK_ISNOT,A,Y); 1097 binaryToUnaryIfNull(pParse, Y, A, TK_NOTNULL); 1098 } 1099 1100 expr(A) ::= NOT(B) expr(X). 1101 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/} 1102 expr(A) ::= BITNOT(B) expr(X). 1103 {A = sqlite3PExpr(pParse, @B, X, 0);/*A-overwrites-B*/} 1104 expr(A) ::= MINUS expr(X). [BITNOT] 1105 {A = sqlite3PExpr(pParse, TK_UMINUS, X, 0);} 1106 expr(A) ::= PLUS expr(X). [BITNOT] 1107 {A = sqlite3PExpr(pParse, TK_UPLUS, X, 0);} 1108 1109 %type between_op {int} 1110 between_op(A) ::= BETWEEN. {A = 0;} 1111 between_op(A) ::= NOT BETWEEN. {A = 1;} 1112 expr(A) ::= expr(A) between_op(N) expr(X) AND expr(Y). [BETWEEN] { 1113 ExprList *pList = sqlite3ExprListAppend(pParse,0, X); 1114 pList = sqlite3ExprListAppend(pParse,pList, Y); 1115 A = sqlite3PExpr(pParse, TK_BETWEEN, A, 0); 1116 if( A ){ 1117 A->x.pList = pList; 1118 }else{ 1119 sqlite3ExprListDelete(pParse->db, pList); 1120 } 1121 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1122 } 1123 %ifndef SQLITE_OMIT_SUBQUERY 1124 %type in_op {int} 1125 in_op(A) ::= IN. {A = 0;} 1126 in_op(A) ::= NOT IN. {A = 1;} 1127 expr(A) ::= expr(A) in_op(N) LP exprlist(Y) RP. [IN] { 1128 if( Y==0 ){ 1129 /* Expressions of the form 1130 ** 1131 ** expr1 IN () 1132 ** expr1 NOT IN () 1133 ** 1134 ** simplify to constants 0 (false) and 1 (true), respectively, 1135 ** regardless of the value of expr1. 1136 */ 1137 sqlite3ExprDelete(pParse->db, A); 1138 A = sqlite3ExprAlloc(pParse->db, TK_INTEGER,&sqlite3IntTokens[N],1); 1139 }else if( Y->nExpr==1 ){ 1140 /* Expressions of the form: 1141 ** 1142 ** expr1 IN (?1) 1143 ** expr1 NOT IN (?2) 1144 ** 1145 ** with exactly one value on the RHS can be simplified to something 1146 ** like this: 1147 ** 1148 ** expr1 == ?1 1149 ** expr1 <> ?2 1150 ** 1151 ** But, the RHS of the == or <> is marked with the EP_Generic flag 1152 ** so that it may not contribute to the computation of comparison 1153 ** affinity or the collating sequence to use for comparison. Otherwise, 1154 ** the semantics would be subtly different from IN or NOT IN. 1155 */ 1156 Expr *pRHS = Y->a[0].pExpr; 1157 Y->a[0].pExpr = 0; 1158 sqlite3ExprListDelete(pParse->db, Y); 1159 /* pRHS cannot be NULL because a malloc error would have been detected 1160 ** before now and control would have never reached this point */ 1161 if( ALWAYS(pRHS) ){ 1162 pRHS->flags &= ~EP_Collate; 1163 pRHS->flags |= EP_Generic; 1164 } 1165 A = sqlite3PExpr(pParse, N ? TK_NE : TK_EQ, A, pRHS); 1166 }else{ 1167 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1168 if( A ){ 1169 A->x.pList = Y; 1170 sqlite3ExprSetHeightAndFlags(pParse, A); 1171 }else{ 1172 sqlite3ExprListDelete(pParse->db, Y); 1173 } 1174 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1175 } 1176 } 1177 expr(A) ::= LP select(X) RP. { 1178 A = sqlite3PExpr(pParse, TK_SELECT, 0, 0); 1179 sqlite3PExprAddSelect(pParse, A, X); 1180 } 1181 expr(A) ::= expr(A) in_op(N) LP select(Y) RP. [IN] { 1182 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1183 sqlite3PExprAddSelect(pParse, A, Y); 1184 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1185 } 1186 expr(A) ::= expr(A) in_op(N) nm(Y) dbnm(Z) paren_exprlist(E). [IN] { 1187 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z); 1188 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); 1189 if( E ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, E); 1190 A = sqlite3PExpr(pParse, TK_IN, A, 0); 1191 sqlite3PExprAddSelect(pParse, A, pSelect); 1192 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0); 1193 } 1194 expr(A) ::= EXISTS LP select(Y) RP. { 1195 Expr *p; 1196 p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); 1197 sqlite3PExprAddSelect(pParse, p, Y); 1198 } 1199 %endif SQLITE_OMIT_SUBQUERY 1200 1201 /* CASE expressions */ 1202 expr(A) ::= CASE case_operand(X) case_exprlist(Y) case_else(Z) END. { 1203 A = sqlite3PExpr(pParse, TK_CASE, X, 0); 1204 if( A ){ 1205 A->x.pList = Z ? sqlite3ExprListAppend(pParse,Y,Z) : Y; 1206 sqlite3ExprSetHeightAndFlags(pParse, A); 1207 }else{ 1208 sqlite3ExprListDelete(pParse->db, Y); 1209 sqlite3ExprDelete(pParse->db, Z); 1210 } 1211 } 1212 %type case_exprlist {ExprList*} 1213 %destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1214 case_exprlist(A) ::= case_exprlist(A) WHEN expr(Y) THEN expr(Z). { 1215 A = sqlite3ExprListAppend(pParse,A, Y); 1216 A = sqlite3ExprListAppend(pParse,A, Z); 1217 } 1218 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { 1219 A = sqlite3ExprListAppend(pParse,0, Y); 1220 A = sqlite3ExprListAppend(pParse,A, Z); 1221 } 1222 %type case_else {Expr*} 1223 %destructor case_else {sqlite3ExprDelete(pParse->db, $$);} 1224 case_else(A) ::= ELSE expr(X). {A = X;} 1225 case_else(A) ::= . {A = 0;} 1226 %type case_operand {Expr*} 1227 %destructor case_operand {sqlite3ExprDelete(pParse->db, $$);} 1228 case_operand(A) ::= expr(X). {A = X; /*A-overwrites-X*/} 1229 case_operand(A) ::= . {A = 0;} 1230 1231 %type exprlist {ExprList*} 1232 %destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1233 %type nexprlist {ExprList*} 1234 %destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);} 1235 1236 exprlist(A) ::= nexprlist(A). 1237 exprlist(A) ::= . {A = 0;} 1238 nexprlist(A) ::= nexprlist(A) COMMA expr(Y). 1239 {A = sqlite3ExprListAppend(pParse,A,Y);} 1240 nexprlist(A) ::= expr(Y). 1241 {A = sqlite3ExprListAppend(pParse,0,Y); /*A-overwrites-Y*/} 1242 1243 %ifndef SQLITE_OMIT_SUBQUERY 1244 /* A paren_exprlist is an optional expression list contained inside 1245 ** of parenthesis */ 1246 %type paren_exprlist {ExprList*} 1247 %destructor paren_exprlist {sqlite3ExprListDelete(pParse->db, $$);} 1248 paren_exprlist(A) ::= . {A = 0;} 1249 paren_exprlist(A) ::= LP exprlist(X) RP. {A = X;} 1250 %endif SQLITE_OMIT_SUBQUERY 1251 1252 1253 ///////////////////////////// The CREATE INDEX command /////////////////////// 1254 // 1255 cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D) 1256 ON nm(Y) LP sortlist(Z) RP where_opt(W). { 1257 sqlite3CreateIndex(pParse, &X, &D, 1258 sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U, 1259 &S, W, SQLITE_SO_ASC, NE, SQLITE_IDXTYPE_APPDEF); 1260 } 1261 1262 %type uniqueflag {int} 1263 uniqueflag(A) ::= UNIQUE. {A = OE_Abort;} 1264 uniqueflag(A) ::= . {A = OE_None;} 1265 1266 1267 // The eidlist non-terminal (Expression Id List) generates an ExprList 1268 // from a list of identifiers. The identifier names are in ExprList.a[].zName. 1269 // This list is stored in an ExprList rather than an IdList so that it 1270 // can be easily sent to sqlite3ColumnsExprList(). 1271 // 1272 // eidlist is grouped with CREATE INDEX because it used to be the non-terminal 1273 // used for the arguments to an index. That is just an historical accident. 1274 // 1275 // IMPORTANT COMPATIBILITY NOTE: Some prior versions of SQLite accepted 1276 // COLLATE clauses and ASC or DESC keywords on ID lists in inappropriate 1277 // places - places that might have been stored in the sqlite_master schema. 1278 // Those extra features were ignored. But because they might be in some 1279 // (busted) old databases, we need to continue parsing them when loading 1280 // historical schemas. 1281 // 1282 %type eidlist {ExprList*} 1283 %destructor eidlist {sqlite3ExprListDelete(pParse->db, $$);} 1284 %type eidlist_opt {ExprList*} 1285 %destructor eidlist_opt {sqlite3ExprListDelete(pParse->db, $$);} 1286 1287 %include { 1288 /* Add a single new term to an ExprList that is used to store a 1289 ** list of identifiers. Report an error if the ID list contains 1290 ** a COLLATE clause or an ASC or DESC keyword, except ignore the 1291 ** error while parsing a legacy schema. 1292 */ 1293 static ExprList *parserAddExprIdListTerm( 1294 Parse *pParse, 1295 ExprList *pPrior, 1296 Token *pIdToken, 1297 int hasCollate, 1298 int sortOrder 1299 ){ 1300 ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); 1301 if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED) 1302 && pParse->db->init.busy==0 1303 ){ 1304 sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"", 1305 pIdToken->n, pIdToken->z); 1306 } 1307 sqlite3ExprListSetName(pParse, p, pIdToken, 1); 1308 return p; 1309 } 1310 } // end %include 1311 1312 eidlist_opt(A) ::= . {A = 0;} 1313 eidlist_opt(A) ::= LP eidlist(X) RP. {A = X;} 1314 eidlist(A) ::= eidlist(A) COMMA nm(Y) collate(C) sortorder(Z). { 1315 A = parserAddExprIdListTerm(pParse, A, &Y, C, Z); 1316 } 1317 eidlist(A) ::= nm(Y) collate(C) sortorder(Z). { 1318 A = parserAddExprIdListTerm(pParse, 0, &Y, C, Z); /*A-overwrites-Y*/ 1319 } 1320 1321 %type collate {int} 1322 collate(C) ::= . {C = 0;} 1323 collate(C) ::= COLLATE ids. {C = 1;} 1324 1325 1326 ///////////////////////////// The DROP INDEX command ///////////////////////// 1327 // 1328 cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);} 1329 1330 ///////////////////////////// The VACUUM command ///////////////////////////// 1331 // 1332 %ifndef SQLITE_OMIT_VACUUM 1333 %ifndef SQLITE_OMIT_ATTACH 1334 cmd ::= VACUUM. {sqlite3Vacuum(pParse,0);} 1335 cmd ::= VACUUM nm(X). {sqlite3Vacuum(pParse,&X);} 1336 %endif SQLITE_OMIT_ATTACH 1337 %endif SQLITE_OMIT_VACUUM 1338 1339 ///////////////////////////// The PRAGMA command ///////////////////////////// 1340 // 1341 %ifndef SQLITE_OMIT_PRAGMA 1342 cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);} 1343 cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);} 1344 cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);} 1345 cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y). 1346 {sqlite3Pragma(pParse,&X,&Z,&Y,1);} 1347 cmd ::= PRAGMA nm(X) dbnm(Z) LP minus_num(Y) RP. 1348 {sqlite3Pragma(pParse,&X,&Z,&Y,1);} 1349 1350 nmnum(A) ::= plus_num(A). 1351 nmnum(A) ::= nm(A). 1352 nmnum(A) ::= ON(A). 1353 nmnum(A) ::= DELETE(A). 1354 nmnum(A) ::= DEFAULT(A). 1355 %endif SQLITE_OMIT_PRAGMA 1356 %token_class number INTEGER|FLOAT. 1357 plus_num(A) ::= PLUS number(X). {A = X;} 1358 plus_num(A) ::= number(A). 1359 minus_num(A) ::= MINUS number(X). {A = X;} 1360 //////////////////////////// The CREATE TRIGGER command ///////////////////// 1361 1362 %ifndef SQLITE_OMIT_TRIGGER 1363 1364 cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). { 1365 Token all; 1366 all.z = A.z; 1367 all.n = (int)(Z.z - A.z) + Z.n; 1368 sqlite3FinishTrigger(pParse, S, &all); 1369 } 1370 1371 trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z) 1372 trigger_time(C) trigger_event(D) 1373 ON fullname(E) foreach_clause when_clause(G). { 1374 sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR); 1375 A = (Z.n==0?B:Z); /*A-overwrites-T*/ 1376 } 1377 1378 %type trigger_time {int} 1379 trigger_time(A) ::= BEFORE|AFTER(X). { A = @X; /*A-overwrites-X*/ } 1380 trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;} 1381 trigger_time(A) ::= . { A = TK_BEFORE; } 1382 1383 %type trigger_event {struct TrigEvent} 1384 %destructor trigger_event {sqlite3IdListDelete(pParse->db, $$.b);} 1385 trigger_event(A) ::= DELETE|INSERT(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;} 1386 trigger_event(A) ::= UPDATE(X). {A.a = @X; /*A-overwrites-X*/ A.b = 0;} 1387 trigger_event(A) ::= UPDATE OF idlist(X).{A.a = TK_UPDATE; A.b = X;} 1388 1389 foreach_clause ::= . 1390 foreach_clause ::= FOR EACH ROW. 1391 1392 %type when_clause {Expr*} 1393 %destructor when_clause {sqlite3ExprDelete(pParse->db, $$);} 1394 when_clause(A) ::= . { A = 0; } 1395 when_clause(A) ::= WHEN expr(X). { A = X; } 1396 1397 %type trigger_cmd_list {TriggerStep*} 1398 %destructor trigger_cmd_list {sqlite3DeleteTriggerStep(pParse->db, $$);} 1399 trigger_cmd_list(A) ::= trigger_cmd_list(A) trigger_cmd(X) SEMI. { 1400 assert( A!=0 ); 1401 A->pLast->pNext = X; 1402 A->pLast = X; 1403 } 1404 trigger_cmd_list(A) ::= trigger_cmd(A) SEMI. { 1405 assert( A!=0 ); 1406 A->pLast = A; 1407 } 1408 1409 // Disallow qualified table names on INSERT, UPDATE, and DELETE statements 1410 // within a trigger. The table to INSERT, UPDATE, or DELETE is always in 1411 // the same database as the table that the trigger fires on. 1412 // 1413 %type trnm {Token} 1414 trnm(A) ::= nm(A). 1415 trnm(A) ::= nm DOT nm(X). { 1416 A = X; 1417 sqlite3ErrorMsg(pParse, 1418 "qualified table names are not allowed on INSERT, UPDATE, and DELETE " 1419 "statements within triggers"); 1420 } 1421 1422 // Disallow the INDEX BY and NOT INDEXED clauses on UPDATE and DELETE 1423 // statements within triggers. We make a specific error message for this 1424 // since it is an exception to the default grammar rules. 1425 // 1426 tridxby ::= . 1427 tridxby ::= INDEXED BY nm. { 1428 sqlite3ErrorMsg(pParse, 1429 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " 1430 "within triggers"); 1431 } 1432 tridxby ::= NOT INDEXED. { 1433 sqlite3ErrorMsg(pParse, 1434 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " 1435 "within triggers"); 1436 } 1437 1438 1439 1440 %type trigger_cmd {TriggerStep*} 1441 %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);} 1442 // UPDATE 1443 trigger_cmd(A) ::= 1444 UPDATE(B) orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z) scanpt(E). 1445 {A = sqlite3TriggerUpdateStep(pParse->db, &X, Y, Z, R, B.z, E);} 1446 1447 // INSERT 1448 trigger_cmd(A) ::= scanpt(B) insert_cmd(R) INTO 1449 trnm(X) idlist_opt(F) select(S) upsert(U) scanpt(Z). { 1450 A = sqlite3TriggerInsertStep(pParse->db,&X,F,S,R,U,B,Z);/*A-overwrites-R*/ 1451 } 1452 // DELETE 1453 trigger_cmd(A) ::= DELETE(B) FROM trnm(X) tridxby where_opt(Y) scanpt(E). 1454 {A = sqlite3TriggerDeleteStep(pParse->db, &X, Y, B.z, E);} 1455 1456 // SELECT 1457 trigger_cmd(A) ::= scanpt(B) select(X) scanpt(E). 1458 {A = sqlite3TriggerSelectStep(pParse->db, X, B, E); /*A-overwrites-X*/} 1459 1460 // The special RAISE expression that may occur in trigger programs 1461 expr(A) ::= RAISE LP IGNORE RP. { 1462 A = sqlite3PExpr(pParse, TK_RAISE, 0, 0); 1463 if( A ){ 1464 A->affinity = OE_Ignore; 1465 } 1466 } 1467 expr(A) ::= RAISE LP raisetype(T) COMMA nm(Z) RP. { 1468 A = sqlite3ExprAlloc(pParse->db, TK_RAISE, &Z, 1); 1469 if( A ) { 1470 A->affinity = (char)T; 1471 } 1472 } 1473 %endif !SQLITE_OMIT_TRIGGER 1474 1475 %type raisetype {int} 1476 raisetype(A) ::= ROLLBACK. {A = OE_Rollback;} 1477 raisetype(A) ::= ABORT. {A = OE_Abort;} 1478 raisetype(A) ::= FAIL. {A = OE_Fail;} 1479 1480 1481 //////////////////////// DROP TRIGGER statement ////////////////////////////// 1482 %ifndef SQLITE_OMIT_TRIGGER 1483 cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). { 1484 sqlite3DropTrigger(pParse,X,NOERR); 1485 } 1486 %endif !SQLITE_OMIT_TRIGGER 1487 1488 //////////////////////// ATTACH DATABASE file AS name ///////////////////////// 1489 %ifndef SQLITE_OMIT_ATTACH 1490 cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). { 1491 sqlite3Attach(pParse, F, D, K); 1492 } 1493 cmd ::= DETACH database_kw_opt expr(D). { 1494 sqlite3Detach(pParse, D); 1495 } 1496 1497 %type key_opt {Expr*} 1498 %destructor key_opt {sqlite3ExprDelete(pParse->db, $$);} 1499 key_opt(A) ::= . { A = 0; } 1500 key_opt(A) ::= KEY expr(X). { A = X; } 1501 1502 database_kw_opt ::= DATABASE. 1503 database_kw_opt ::= . 1504 %endif SQLITE_OMIT_ATTACH 1505 1506 ////////////////////////// REINDEX collation ////////////////////////////////// 1507 %ifndef SQLITE_OMIT_REINDEX 1508 cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);} 1509 cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);} 1510 %endif SQLITE_OMIT_REINDEX 1511 1512 /////////////////////////////////// ANALYZE /////////////////////////////////// 1513 %ifndef SQLITE_OMIT_ANALYZE 1514 cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);} 1515 cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);} 1516 %endif 1517 1518 //////////////////////// ALTER TABLE table ... //////////////////////////////// 1519 %ifndef SQLITE_OMIT_ALTERTABLE 1520 cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). { 1521 sqlite3AlterRenameTable(pParse,X,&Z); 1522 } 1523 cmd ::= ALTER TABLE add_column_fullname 1524 ADD kwcolumn_opt columnname(Y) carglist. { 1525 Y.n = (int)(pParse->sLastToken.z-Y.z) + pParse->sLastToken.n; 1526 sqlite3AlterFinishAddColumn(pParse, &Y); 1527 } 1528 add_column_fullname ::= fullname(X). { 1529 disableLookaside(pParse); 1530 sqlite3AlterBeginAddColumn(pParse, X); 1531 } 1532 kwcolumn_opt ::= . 1533 kwcolumn_opt ::= COLUMNKW. 1534 %endif SQLITE_OMIT_ALTERTABLE 1535 1536 //////////////////////// CREATE VIRTUAL TABLE ... ///////////////////////////// 1537 %ifndef SQLITE_OMIT_VIRTUALTABLE 1538 cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);} 1539 cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);} 1540 create_vtab ::= createkw VIRTUAL TABLE ifnotexists(E) 1541 nm(X) dbnm(Y) USING nm(Z). { 1542 sqlite3VtabBeginParse(pParse, &X, &Y, &Z, E); 1543 } 1544 vtabarglist ::= vtabarg. 1545 vtabarglist ::= vtabarglist COMMA vtabarg. 1546 vtabarg ::= . {sqlite3VtabArgInit(pParse);} 1547 vtabarg ::= vtabarg vtabargtoken. 1548 vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);} 1549 vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);} 1550 lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);} 1551 anylist ::= . 1552 anylist ::= anylist LP anylist RP. 1553 anylist ::= anylist ANY. 1554 %endif SQLITE_OMIT_VIRTUALTABLE 1555 1556 1557 //////////////////////// COMMON TABLE EXPRESSIONS //////////////////////////// 1558 %type wqlist {With*} 1559 %destructor wqlist {sqlite3WithDelete(pParse->db, $$);} 1560 1561 with ::= . 1562 %ifndef SQLITE_OMIT_CTE 1563 with ::= WITH wqlist(W). { sqlite3WithPush(pParse, W, 1); } 1564 with ::= WITH RECURSIVE wqlist(W). { sqlite3WithPush(pParse, W, 1); } 1565 1566 wqlist(A) ::= nm(X) eidlist_opt(Y) AS LP select(Z) RP. { 1567 A = sqlite3WithAdd(pParse, 0, &X, Y, Z); /*A-overwrites-X*/ 1568 } 1569 wqlist(A) ::= wqlist(A) COMMA nm(X) eidlist_opt(Y) AS LP select(Z) RP. { 1570 A = sqlite3WithAdd(pParse, A, &X, Y, Z); 1571 } 1572 %endif SQLITE_OMIT_CTE 1573