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