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 ** @(#) $Id: parse.y,v 1.112 2004/02/22 18:40:57 drh Exp $ 18 */ 19 %token_prefix TK_ 20 %token_type {Token} 21 %default_type {Token} 22 %extra_argument {Parse *pParse} 23 %syntax_error { 24 if( pParse->zErrMsg==0 ){ 25 if( TOKEN.z[0] ){ 26 sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); 27 }else{ 28 sqliteErrorMsg(pParse, "incomplete SQL statement"); 29 } 30 } 31 } 32 %name sqliteParser 33 %include { 34 35 #include "sqliteInt.h" 36 #include "parse.h" 37 38 /* 39 ** An instance of this structure holds information about the 40 ** LIMIT clause of a SELECT statement. 41 */ 42 struct LimitVal { 43 int limit; /* The LIMIT value. -1 if there is no limit */ 44 int offset; /* The OFFSET. 0 if there is none */ 45 }; 46 47 /* 48 ** An instance of the following structure describes the event of a 49 ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, 50 ** TK_DELETE, or TK_INSTEAD. If the event is of the form 51 ** 52 ** UPDATE ON (a,b,c) 53 ** 54 ** Then the "b" IdList records the list "a,b,c". 55 */ 56 struct TrigEvent { int a; IdList * b; }; 57 58 } // end %include 59 60 // These are extra tokens used by the lexer but never seen by the 61 // parser. We put them in a rule so that the parser generator will 62 // add them to the parse.h output file. 63 // 64 %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION 65 COLUMN AGG_FUNCTION. 66 67 // Input is a single SQL command 68 input ::= cmdlist. 69 cmdlist ::= cmdlist ecmd. 70 cmdlist ::= ecmd. 71 ecmd ::= explain cmdx SEMI. 72 ecmd ::= SEMI. 73 cmdx ::= cmd. { sqliteExec(pParse); } 74 explain ::= EXPLAIN. { sqliteBeginParse(pParse, 1); } 75 explain ::= . { sqliteBeginParse(pParse, 0); } 76 77 ///////////////////// Begin and end transactions. //////////////////////////// 78 // 79 80 cmd ::= BEGIN trans_opt onconf(R). {sqliteBeginTransaction(pParse,R);} 81 trans_opt ::= . 82 trans_opt ::= TRANSACTION. 83 trans_opt ::= TRANSACTION nm. 84 cmd ::= COMMIT trans_opt. {sqliteCommitTransaction(pParse);} 85 cmd ::= END trans_opt. {sqliteCommitTransaction(pParse);} 86 cmd ::= ROLLBACK trans_opt. {sqliteRollbackTransaction(pParse);} 87 88 ///////////////////// The CREATE TABLE statement //////////////////////////// 89 // 90 cmd ::= create_table create_table_args. 91 create_table ::= CREATE(X) temp(T) TABLE nm(Y). { 92 sqliteStartTable(pParse,&X,&Y,T,0); 93 } 94 %type temp {int} 95 temp(A) ::= TEMP. {A = 1;} 96 temp(A) ::= . {A = 0;} 97 create_table_args ::= LP columnlist conslist_opt RP(X). { 98 sqliteEndTable(pParse,&X,0); 99 } 100 create_table_args ::= AS select(S). { 101 sqliteEndTable(pParse,0,S); 102 sqliteSelectDelete(S); 103 } 104 columnlist ::= columnlist COMMA column. 105 columnlist ::= column. 106 107 // About the only information used for a column is the name of the 108 // column. The type is always just "text". But the code will accept 109 // an elaborate typename. Perhaps someday we'll do something with it. 110 // 111 column ::= columnid type carglist. 112 columnid ::= nm(X). {sqliteAddColumn(pParse,&X);} 113 114 // An IDENTIFIER can be a generic identifier, or one of several 115 // keywords. Any non-standard keyword can also be an identifier. 116 // 117 %type id {Token} 118 id(A) ::= ID(X). {A = X;} 119 120 // The following directive causes tokens ABORT, AFTER, ASC, etc. to 121 // fallback to ID if they will not parse as their original value. 122 // This obviates the need for the "id" nonterminal. 123 // 124 %fallback ID 125 ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT 126 COPY DATABASE DEFERRED DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR 127 GLOB IGNORE IMMEDIATE INITIALLY INSTEAD LIKE MATCH KEY 128 OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT 129 TEMP TRIGGER VACUUM VIEW. 130 131 // Define operator precedence early so that this is the first occurance 132 // of the operator tokens in the grammer. Keeping the operators together 133 // causes them to be assigned integer values that are close together, 134 // which keeps parser tables smaller. 135 // 136 %left OR. 137 %left AND. 138 %right NOT. 139 %left EQ NE ISNULL NOTNULL IS LIKE GLOB BETWEEN IN. 140 %left GT GE LT LE. 141 %left BITAND BITOR LSHIFT RSHIFT. 142 %left PLUS MINUS. 143 %left STAR SLASH REM. 144 %left CONCAT. 145 %right UMINUS UPLUS BITNOT. 146 147 // And "ids" is an identifer-or-string. 148 // 149 %type ids {Token} 150 ids(A) ::= ID(X). {A = X;} 151 ids(A) ::= STRING(X). {A = X;} 152 153 // The name of a column or table can be any of the following: 154 // 155 %type nm {Token} 156 nm(A) ::= ID(X). {A = X;} 157 nm(A) ::= STRING(X). {A = X;} 158 nm(A) ::= JOIN_KW(X). {A = X;} 159 160 type ::= . 161 type ::= typename(X). {sqliteAddColumnType(pParse,&X,&X);} 162 type ::= typename(X) LP signed RP(Y). {sqliteAddColumnType(pParse,&X,&Y);} 163 type ::= typename(X) LP signed COMMA signed RP(Y). 164 {sqliteAddColumnType(pParse,&X,&Y);} 165 %type typename {Token} 166 typename(A) ::= ids(X). {A = X;} 167 typename(A) ::= typename(X) ids. {A = X;} 168 %type signed {int} 169 signed(A) ::= INTEGER(X). { A = atoi(X.z); } 170 signed(A) ::= PLUS INTEGER(X). { A = atoi(X.z); } 171 signed(A) ::= MINUS INTEGER(X). { A = -atoi(X.z); } 172 carglist ::= carglist carg. 173 carglist ::= . 174 carg ::= CONSTRAINT nm ccons. 175 carg ::= ccons. 176 carg ::= DEFAULT STRING(X). {sqliteAddDefaultValue(pParse,&X,0);} 177 carg ::= DEFAULT ID(X). {sqliteAddDefaultValue(pParse,&X,0);} 178 carg ::= DEFAULT INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} 179 carg ::= DEFAULT PLUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} 180 carg ::= DEFAULT MINUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,1);} 181 carg ::= DEFAULT FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} 182 carg ::= DEFAULT PLUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} 183 carg ::= DEFAULT MINUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,1);} 184 carg ::= DEFAULT NULL. 185 186 // In addition to the type name, we also care about the primary key and 187 // UNIQUE constraints. 188 // 189 ccons ::= NULL onconf. 190 ccons ::= NOT NULL onconf(R). {sqliteAddNotNull(pParse, R);} 191 ccons ::= PRIMARY KEY sortorder onconf(R). {sqliteAddPrimaryKey(pParse,0,R);} 192 ccons ::= UNIQUE onconf(R). {sqliteCreateIndex(pParse,0,0,0,R,0,0);} 193 ccons ::= CHECK LP expr RP onconf. 194 ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R). 195 {sqliteCreateForeignKey(pParse,0,&T,TA,R);} 196 ccons ::= defer_subclause(D). {sqliteDeferForeignKey(pParse,D);} 197 ccons ::= COLLATE id(C). { 198 sqliteAddCollateType(pParse, sqliteCollateType(C.z, C.n)); 199 } 200 201 // The next group of rules parses the arguments to a REFERENCES clause 202 // that determine if the referential integrity checking is deferred or 203 // or immediate and which determine what action to take if a ref-integ 204 // check fails. 205 // 206 %type refargs {int} 207 refargs(A) ::= . { A = OE_Restrict * 0x010101; } 208 refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; } 209 %type refarg {struct {int value; int mask;}} 210 refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; } 211 refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; } 212 refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; } 213 refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; } 214 %type refact {int} 215 refact(A) ::= SET NULL. { A = OE_SetNull; } 216 refact(A) ::= SET DEFAULT. { A = OE_SetDflt; } 217 refact(A) ::= CASCADE. { A = OE_Cascade; } 218 refact(A) ::= RESTRICT. { A = OE_Restrict; } 219 %type defer_subclause {int} 220 defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X). {A = X;} 221 defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;} 222 %type init_deferred_pred_opt {int} 223 init_deferred_pred_opt(A) ::= . {A = 0;} 224 init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;} 225 init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;} 226 227 // For the time being, the only constraint we care about is the primary 228 // key and UNIQUE. Both create indices. 229 // 230 conslist_opt ::= . 231 conslist_opt ::= COMMA conslist. 232 conslist ::= conslist COMMA tcons. 233 conslist ::= conslist tcons. 234 conslist ::= tcons. 235 tcons ::= CONSTRAINT nm. 236 tcons ::= PRIMARY KEY LP idxlist(X) RP onconf(R). 237 {sqliteAddPrimaryKey(pParse,X,R);} 238 tcons ::= UNIQUE LP idxlist(X) RP onconf(R). 239 {sqliteCreateIndex(pParse,0,0,X,R,0,0);} 240 tcons ::= CHECK expr onconf. 241 tcons ::= FOREIGN KEY LP idxlist(FA) RP 242 REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). { 243 sqliteCreateForeignKey(pParse, FA, &T, TA, R); 244 sqliteDeferForeignKey(pParse, D); 245 } 246 %type defer_subclause_opt {int} 247 defer_subclause_opt(A) ::= . {A = 0;} 248 defer_subclause_opt(A) ::= defer_subclause(X). {A = X;} 249 250 // The following is a non-standard extension that allows us to declare the 251 // default behavior when there is a constraint conflict. 252 // 253 %type onconf {int} 254 %type orconf {int} 255 %type resolvetype {int} 256 onconf(A) ::= . { A = OE_Default; } 257 onconf(A) ::= ON CONFLICT resolvetype(X). { A = X; } 258 orconf(A) ::= . { A = OE_Default; } 259 orconf(A) ::= OR resolvetype(X). { A = X; } 260 resolvetype(A) ::= ROLLBACK. { A = OE_Rollback; } 261 resolvetype(A) ::= ABORT. { A = OE_Abort; } 262 resolvetype(A) ::= FAIL. { A = OE_Fail; } 263 resolvetype(A) ::= IGNORE. { A = OE_Ignore; } 264 resolvetype(A) ::= REPLACE. { A = OE_Replace; } 265 266 ////////////////////////// The DROP TABLE ///////////////////////////////////// 267 // 268 cmd ::= DROP TABLE nm(X). {sqliteDropTable(pParse,&X,0);} 269 270 ///////////////////// The CREATE VIEW statement ///////////////////////////// 271 // 272 cmd ::= CREATE(X) temp(T) VIEW nm(Y) AS select(S). { 273 sqliteCreateView(pParse, &X, &Y, S, T); 274 } 275 cmd ::= DROP VIEW nm(X). { 276 sqliteDropTable(pParse, &X, 1); 277 } 278 279 //////////////////////// The SELECT statement ///////////////////////////////// 280 // 281 cmd ::= select(X). { 282 sqliteSelect(pParse, X, SRT_Callback, 0, 0, 0, 0); 283 sqliteSelectDelete(X); 284 } 285 286 %type select {Select*} 287 %destructor select {sqliteSelectDelete($$);} 288 %type oneselect {Select*} 289 %destructor oneselect {sqliteSelectDelete($$);} 290 291 select(A) ::= oneselect(X). {A = X;} 292 select(A) ::= select(X) multiselect_op(Y) oneselect(Z). { 293 if( Z ){ 294 Z->op = Y; 295 Z->pPrior = X; 296 } 297 A = Z; 298 } 299 %type multiselect_op {int} 300 multiselect_op(A) ::= UNION. {A = TK_UNION;} 301 multiselect_op(A) ::= UNION ALL. {A = TK_ALL;} 302 multiselect_op(A) ::= INTERSECT. {A = TK_INTERSECT;} 303 multiselect_op(A) ::= EXCEPT. {A = TK_EXCEPT;} 304 oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y) 305 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). { 306 A = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset); 307 } 308 309 // The "distinct" nonterminal is true (1) if the DISTINCT keyword is 310 // present and false (0) if it is not. 311 // 312 %type distinct {int} 313 distinct(A) ::= DISTINCT. {A = 1;} 314 distinct(A) ::= ALL. {A = 0;} 315 distinct(A) ::= . {A = 0;} 316 317 // selcollist is a list of expressions that are to become the return 318 // values of the SELECT statement. The "*" in statements like 319 // "SELECT * FROM ..." is encoded as a special expression with an 320 // opcode of TK_ALL. 321 // 322 %type selcollist {ExprList*} 323 %destructor selcollist {sqliteExprListDelete($$);} 324 %type sclp {ExprList*} 325 %destructor sclp {sqliteExprListDelete($$);} 326 sclp(A) ::= selcollist(X) COMMA. {A = X;} 327 sclp(A) ::= . {A = 0;} 328 selcollist(A) ::= sclp(P) expr(X) as(Y). { 329 A = sqliteExprListAppend(P,X,Y.n?&Y:0); 330 } 331 selcollist(A) ::= sclp(P) STAR. { 332 A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0); 333 } 334 selcollist(A) ::= sclp(P) nm(X) DOT STAR. { 335 Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0); 336 Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X); 337 A = sqliteExprListAppend(P, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0); 338 } 339 340 // An option "AS <id>" phrase that can follow one of the expressions that 341 // define the result set, or one of the tables in the FROM clause. 342 // 343 %type as {Token} 344 as(X) ::= AS nm(Y). { X = Y; } 345 as(X) ::= ids(Y). { X = Y; } 346 as(X) ::= . { X.n = 0; } 347 348 349 %type seltablist {SrcList*} 350 %destructor seltablist {sqliteSrcListDelete($$);} 351 %type stl_prefix {SrcList*} 352 %destructor stl_prefix {sqliteSrcListDelete($$);} 353 %type from {SrcList*} 354 %destructor from {sqliteSrcListDelete($$);} 355 356 // A complete FROM clause. 357 // 358 from(A) ::= . {A = sqliteMalloc(sizeof(*A));} 359 from(A) ::= FROM seltablist(X). {A = X;} 360 361 // "seltablist" is a "Select Table List" - the content of the FROM clause 362 // in a SELECT statement. "stl_prefix" is a prefix of this list. 363 // 364 stl_prefix(A) ::= seltablist(X) joinop(Y). { 365 A = X; 366 if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y; 367 } 368 stl_prefix(A) ::= . {A = 0;} 369 seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). { 370 A = sqliteSrcListAppend(X,&Y,&D); 371 if( Z.n ) sqliteSrcListAddAlias(A,&Z); 372 if( N ){ 373 if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } 374 else { sqliteExprDelete(N); } 375 } 376 if( U ){ 377 if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } 378 else { sqliteIdListDelete(U); } 379 } 380 } 381 seltablist(A) ::= stl_prefix(X) LP seltablist_paren(S) RP 382 as(Z) on_opt(N) using_opt(U). { 383 A = sqliteSrcListAppend(X,0,0); 384 A->a[A->nSrc-1].pSelect = S; 385 if( Z.n ) sqliteSrcListAddAlias(A,&Z); 386 if( N ){ 387 if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } 388 else { sqliteExprDelete(N); } 389 } 390 if( U ){ 391 if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } 392 else { sqliteIdListDelete(U); } 393 } 394 } 395 396 // A seltablist_paren nonterminal represents anything in a FROM that 397 // is contained inside parentheses. This can be either a subquery or 398 // a grouping of table and subqueries. 399 // 400 %type seltablist_paren {Select*} 401 %destructor seltablist_paren {sqliteSelectDelete($$);} 402 seltablist_paren(A) ::= select(S). {A = S;} 403 seltablist_paren(A) ::= seltablist(F). { 404 A = sqliteSelectNew(0,F,0,0,0,0,0,-1,0); 405 } 406 407 %type dbnm {Token} 408 dbnm(A) ::= . {A.z=0; A.n=0;} 409 dbnm(A) ::= DOT nm(X). {A = X;} 410 411 %type joinop {int} 412 %type joinop2 {int} 413 joinop(X) ::= COMMA. { X = JT_INNER; } 414 joinop(X) ::= JOIN. { X = JT_INNER; } 415 joinop(X) ::= JOIN_KW(A) JOIN. { X = sqliteJoinType(pParse,&A,0,0); } 416 joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqliteJoinType(pParse,&A,&B,0); } 417 joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN. 418 { X = sqliteJoinType(pParse,&A,&B,&C); } 419 420 %type on_opt {Expr*} 421 %destructor on_opt {sqliteExprDelete($$);} 422 on_opt(N) ::= ON expr(E). {N = E;} 423 on_opt(N) ::= . {N = 0;} 424 425 %type using_opt {IdList*} 426 %destructor using_opt {sqliteIdListDelete($$);} 427 using_opt(U) ::= USING LP idxlist(L) RP. {U = L;} 428 using_opt(U) ::= . {U = 0;} 429 430 431 %type orderby_opt {ExprList*} 432 %destructor orderby_opt {sqliteExprListDelete($$);} 433 %type sortlist {ExprList*} 434 %destructor sortlist {sqliteExprListDelete($$);} 435 %type sortitem {Expr*} 436 %destructor sortitem {sqliteExprDelete($$);} 437 438 orderby_opt(A) ::= . {A = 0;} 439 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} 440 sortlist(A) ::= sortlist(X) COMMA sortitem(Y) collate(C) sortorder(Z). { 441 A = sqliteExprListAppend(X,Y,0); 442 if( A ) A->a[A->nExpr-1].sortOrder = C+Z; 443 } 444 sortlist(A) ::= sortitem(Y) collate(C) sortorder(Z). { 445 A = sqliteExprListAppend(0,Y,0); 446 if( A ) A->a[0].sortOrder = C+Z; 447 } 448 sortitem(A) ::= expr(X). {A = X;} 449 450 %type sortorder {int} 451 %type collate {int} 452 453 sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;} 454 sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;} 455 sortorder(A) ::= . {A = SQLITE_SO_ASC;} 456 collate(C) ::= . {C = SQLITE_SO_UNK;} 457 collate(C) ::= COLLATE id(X). {C = sqliteCollateType(X.z, X.n);} 458 459 %type groupby_opt {ExprList*} 460 %destructor groupby_opt {sqliteExprListDelete($$);} 461 groupby_opt(A) ::= . {A = 0;} 462 groupby_opt(A) ::= GROUP BY exprlist(X). {A = X;} 463 464 %type having_opt {Expr*} 465 %destructor having_opt {sqliteExprDelete($$);} 466 having_opt(A) ::= . {A = 0;} 467 having_opt(A) ::= HAVING expr(X). {A = X;} 468 469 %type limit_opt {struct LimitVal} 470 limit_opt(A) ::= . {A.limit = -1; A.offset = 0;} 471 limit_opt(A) ::= LIMIT signed(X). {A.limit = X; A.offset = 0;} 472 limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y). 473 {A.limit = X; A.offset = Y;} 474 limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y). 475 {A.limit = Y; A.offset = X;} 476 477 /////////////////////////// The DELETE statement ///////////////////////////// 478 // 479 cmd ::= DELETE FROM nm(X) dbnm(D) where_opt(Y). { 480 sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&X,&D), Y); 481 } 482 483 %type where_opt {Expr*} 484 %destructor where_opt {sqliteExprDelete($$);} 485 486 where_opt(A) ::= . {A = 0;} 487 where_opt(A) ::= WHERE expr(X). {A = X;} 488 489 %type setlist {ExprList*} 490 %destructor setlist {sqliteExprListDelete($$);} 491 492 ////////////////////////// The UPDATE command //////////////////////////////// 493 // 494 cmd ::= UPDATE orconf(R) nm(X) dbnm(D) SET setlist(Y) where_opt(Z). 495 {sqliteUpdate(pParse,sqliteSrcListAppend(0,&X,&D),Y,Z,R);} 496 497 setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y). 498 {A = sqliteExprListAppend(Z,Y,&X);} 499 setlist(A) ::= nm(X) EQ expr(Y). {A = sqliteExprListAppend(0,Y,&X);} 500 501 ////////////////////////// The INSERT command ///////////////////////////////// 502 // 503 cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) 504 VALUES LP itemlist(Y) RP. 505 {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), Y, 0, F, R);} 506 cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) select(S). 507 {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), 0, S, F, R);} 508 509 %type insert_cmd {int} 510 insert_cmd(A) ::= INSERT orconf(R). {A = R;} 511 insert_cmd(A) ::= REPLACE. {A = OE_Replace;} 512 513 514 %type itemlist {ExprList*} 515 %destructor itemlist {sqliteExprListDelete($$);} 516 517 itemlist(A) ::= itemlist(X) COMMA expr(Y). {A = sqliteExprListAppend(X,Y,0);} 518 itemlist(A) ::= expr(X). {A = sqliteExprListAppend(0,X,0);} 519 520 %type inscollist_opt {IdList*} 521 %destructor inscollist_opt {sqliteIdListDelete($$);} 522 %type inscollist {IdList*} 523 %destructor inscollist {sqliteIdListDelete($$);} 524 525 inscollist_opt(A) ::= . {A = 0;} 526 inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;} 527 inscollist(A) ::= inscollist(X) COMMA nm(Y). {A = sqliteIdListAppend(X,&Y);} 528 inscollist(A) ::= nm(Y). {A = sqliteIdListAppend(0,&Y);} 529 530 /////////////////////////// Expression Processing ///////////////////////////// 531 // 532 533 %type expr {Expr*} 534 %destructor expr {sqliteExprDelete($$);} 535 536 expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); } 537 expr(A) ::= NULL(X). {A = sqliteExpr(TK_NULL, 0, 0, &X);} 538 expr(A) ::= ID(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} 539 expr(A) ::= JOIN_KW(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} 540 expr(A) ::= nm(X) DOT nm(Y). { 541 Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); 542 Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); 543 A = sqliteExpr(TK_DOT, temp1, temp2, 0); 544 } 545 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). { 546 Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); 547 Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); 548 Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &Z); 549 Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0); 550 A = sqliteExpr(TK_DOT, temp1, temp4, 0); 551 } 552 expr(A) ::= INTEGER(X). {A = sqliteExpr(TK_INTEGER, 0, 0, &X);} 553 expr(A) ::= FLOAT(X). {A = sqliteExpr(TK_FLOAT, 0, 0, &X);} 554 expr(A) ::= STRING(X). {A = sqliteExpr(TK_STRING, 0, 0, &X);} 555 expr(A) ::= VARIABLE(X). { 556 A = sqliteExpr(TK_VARIABLE, 0, 0, &X); 557 if( A ) A->iTable = ++pParse->nVar; 558 } 559 expr(A) ::= ID(X) LP exprlist(Y) RP(E). { 560 A = sqliteExprFunction(Y, &X); 561 sqliteExprSpan(A,&X,&E); 562 } 563 expr(A) ::= ID(X) LP STAR RP(E). { 564 A = sqliteExprFunction(0, &X); 565 sqliteExprSpan(A,&X,&E); 566 } 567 expr(A) ::= expr(X) AND expr(Y). {A = sqliteExpr(TK_AND, X, Y, 0);} 568 expr(A) ::= expr(X) OR expr(Y). {A = sqliteExpr(TK_OR, X, Y, 0);} 569 expr(A) ::= expr(X) LT expr(Y). {A = sqliteExpr(TK_LT, X, Y, 0);} 570 expr(A) ::= expr(X) GT expr(Y). {A = sqliteExpr(TK_GT, X, Y, 0);} 571 expr(A) ::= expr(X) LE expr(Y). {A = sqliteExpr(TK_LE, X, Y, 0);} 572 expr(A) ::= expr(X) GE expr(Y). {A = sqliteExpr(TK_GE, X, Y, 0);} 573 expr(A) ::= expr(X) NE expr(Y). {A = sqliteExpr(TK_NE, X, Y, 0);} 574 expr(A) ::= expr(X) EQ expr(Y). {A = sqliteExpr(TK_EQ, X, Y, 0);} 575 expr(A) ::= expr(X) BITAND expr(Y). {A = sqliteExpr(TK_BITAND, X, Y, 0);} 576 expr(A) ::= expr(X) BITOR expr(Y). {A = sqliteExpr(TK_BITOR, X, Y, 0);} 577 expr(A) ::= expr(X) LSHIFT expr(Y). {A = sqliteExpr(TK_LSHIFT, X, Y, 0);} 578 expr(A) ::= expr(X) RSHIFT expr(Y). {A = sqliteExpr(TK_RSHIFT, X, Y, 0);} 579 expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE] { 580 ExprList *pList = sqliteExprListAppend(0, Y, 0); 581 pList = sqliteExprListAppend(pList, X, 0); 582 A = sqliteExprFunction(pList, 0); 583 if( A ) A->op = OP; 584 sqliteExprSpan(A, &X->span, &Y->span); 585 } 586 expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] { 587 ExprList *pList = sqliteExprListAppend(0, Y, 0); 588 pList = sqliteExprListAppend(pList, X, 0); 589 A = sqliteExprFunction(pList, 0); 590 if( A ) A->op = OP; 591 A = sqliteExpr(TK_NOT, A, 0, 0); 592 sqliteExprSpan(A,&X->span,&Y->span); 593 } 594 %type likeop {int} 595 likeop(A) ::= LIKE. {A = TK_LIKE;} 596 likeop(A) ::= GLOB. {A = TK_GLOB;} 597 expr(A) ::= expr(X) PLUS expr(Y). {A = sqliteExpr(TK_PLUS, X, Y, 0);} 598 expr(A) ::= expr(X) MINUS expr(Y). {A = sqliteExpr(TK_MINUS, X, Y, 0);} 599 expr(A) ::= expr(X) STAR expr(Y). {A = sqliteExpr(TK_STAR, X, Y, 0);} 600 expr(A) ::= expr(X) SLASH expr(Y). {A = sqliteExpr(TK_SLASH, X, Y, 0);} 601 expr(A) ::= expr(X) REM expr(Y). {A = sqliteExpr(TK_REM, X, Y, 0);} 602 expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);} 603 expr(A) ::= expr(X) ISNULL(E). { 604 A = sqliteExpr(TK_ISNULL, X, 0, 0); 605 sqliteExprSpan(A,&X->span,&E); 606 } 607 expr(A) ::= expr(X) IS NULL(E). { 608 A = sqliteExpr(TK_ISNULL, X, 0, 0); 609 sqliteExprSpan(A,&X->span,&E); 610 } 611 expr(A) ::= expr(X) NOTNULL(E). { 612 A = sqliteExpr(TK_NOTNULL, X, 0, 0); 613 sqliteExprSpan(A,&X->span,&E); 614 } 615 expr(A) ::= expr(X) NOT NULL(E). { 616 A = sqliteExpr(TK_NOTNULL, X, 0, 0); 617 sqliteExprSpan(A,&X->span,&E); 618 } 619 expr(A) ::= expr(X) IS NOT NULL(E). { 620 A = sqliteExpr(TK_NOTNULL, X, 0, 0); 621 sqliteExprSpan(A,&X->span,&E); 622 } 623 expr(A) ::= NOT(B) expr(X). { 624 A = sqliteExpr(TK_NOT, X, 0, 0); 625 sqliteExprSpan(A,&B,&X->span); 626 } 627 expr(A) ::= BITNOT(B) expr(X). { 628 A = sqliteExpr(TK_BITNOT, X, 0, 0); 629 sqliteExprSpan(A,&B,&X->span); 630 } 631 expr(A) ::= MINUS(B) expr(X). [UMINUS] { 632 A = sqliteExpr(TK_UMINUS, X, 0, 0); 633 sqliteExprSpan(A,&B,&X->span); 634 } 635 expr(A) ::= PLUS(B) expr(X). [UPLUS] { 636 A = sqliteExpr(TK_UPLUS, X, 0, 0); 637 sqliteExprSpan(A,&B,&X->span); 638 } 639 expr(A) ::= LP(B) select(X) RP(E). { 640 A = sqliteExpr(TK_SELECT, 0, 0, 0); 641 if( A ) A->pSelect = X; 642 sqliteExprSpan(A,&B,&E); 643 } 644 expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). { 645 ExprList *pList = sqliteExprListAppend(0, X, 0); 646 pList = sqliteExprListAppend(pList, Y, 0); 647 A = sqliteExpr(TK_BETWEEN, W, 0, 0); 648 if( A ) A->pList = pList; 649 sqliteExprSpan(A,&W->span,&Y->span); 650 } 651 expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). { 652 ExprList *pList = sqliteExprListAppend(0, X, 0); 653 pList = sqliteExprListAppend(pList, Y, 0); 654 A = sqliteExpr(TK_BETWEEN, W, 0, 0); 655 if( A ) A->pList = pList; 656 A = sqliteExpr(TK_NOT, A, 0, 0); 657 sqliteExprSpan(A,&W->span,&Y->span); 658 } 659 expr(A) ::= expr(X) IN LP exprlist(Y) RP(E). { 660 A = sqliteExpr(TK_IN, X, 0, 0); 661 if( A ) A->pList = Y; 662 sqliteExprSpan(A,&X->span,&E); 663 } 664 expr(A) ::= expr(X) IN LP select(Y) RP(E). { 665 A = sqliteExpr(TK_IN, X, 0, 0); 666 if( A ) A->pSelect = Y; 667 sqliteExprSpan(A,&X->span,&E); 668 } 669 expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E). { 670 A = sqliteExpr(TK_IN, X, 0, 0); 671 if( A ) A->pList = Y; 672 A = sqliteExpr(TK_NOT, A, 0, 0); 673 sqliteExprSpan(A,&X->span,&E); 674 } 675 expr(A) ::= expr(X) NOT IN LP select(Y) RP(E). { 676 A = sqliteExpr(TK_IN, X, 0, 0); 677 if( A ) A->pSelect = Y; 678 A = sqliteExpr(TK_NOT, A, 0, 0); 679 sqliteExprSpan(A,&X->span,&E); 680 } 681 expr(A) ::= expr(X) IN nm(Y) dbnm(D). { 682 SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); 683 A = sqliteExpr(TK_IN, X, 0, 0); 684 if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); 685 sqliteExprSpan(A,&X->span,D.z?&D:&Y); 686 } 687 expr(A) ::= expr(X) NOT IN nm(Y) dbnm(D). { 688 SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); 689 A = sqliteExpr(TK_IN, X, 0, 0); 690 if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); 691 A = sqliteExpr(TK_NOT, A, 0, 0); 692 sqliteExprSpan(A,&X->span,D.z?&D:&Y); 693 } 694 695 696 /* CASE expressions */ 697 expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). { 698 A = sqliteExpr(TK_CASE, X, Z, 0); 699 if( A ) A->pList = Y; 700 sqliteExprSpan(A, &C, &E); 701 } 702 %type case_exprlist {ExprList*} 703 %destructor case_exprlist {sqliteExprListDelete($$);} 704 case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). { 705 A = sqliteExprListAppend(X, Y, 0); 706 A = sqliteExprListAppend(A, Z, 0); 707 } 708 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { 709 A = sqliteExprListAppend(0, Y, 0); 710 A = sqliteExprListAppend(A, Z, 0); 711 } 712 %type case_else {Expr*} 713 case_else(A) ::= ELSE expr(X). {A = X;} 714 case_else(A) ::= . {A = 0;} 715 %type case_operand {Expr*} 716 case_operand(A) ::= expr(X). {A = X;} 717 case_operand(A) ::= . {A = 0;} 718 719 %type exprlist {ExprList*} 720 %destructor exprlist {sqliteExprListDelete($$);} 721 %type expritem {Expr*} 722 %destructor expritem {sqliteExprDelete($$);} 723 724 exprlist(A) ::= exprlist(X) COMMA expritem(Y). 725 {A = sqliteExprListAppend(X,Y,0);} 726 exprlist(A) ::= expritem(X). {A = sqliteExprListAppend(0,X,0);} 727 expritem(A) ::= expr(X). {A = X;} 728 expritem(A) ::= . {A = 0;} 729 730 ///////////////////////////// The CREATE INDEX command /////////////////////// 731 // 732 cmd ::= CREATE(S) uniqueflag(U) INDEX nm(X) 733 ON nm(Y) dbnm(D) LP idxlist(Z) RP(E) onconf(R). { 734 SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); 735 if( U!=OE_None ) U = R; 736 if( U==OE_Default) U = OE_Abort; 737 sqliteCreateIndex(pParse, &X, pSrc, Z, U, &S, &E); 738 } 739 740 %type uniqueflag {int} 741 uniqueflag(A) ::= UNIQUE. { A = OE_Abort; } 742 uniqueflag(A) ::= . { A = OE_None; } 743 744 %type idxlist {IdList*} 745 %destructor idxlist {sqliteIdListDelete($$);} 746 %type idxlist_opt {IdList*} 747 %destructor idxlist_opt {sqliteIdListDelete($$);} 748 %type idxitem {Token} 749 750 idxlist_opt(A) ::= . {A = 0;} 751 idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;} 752 idxlist(A) ::= idxlist(X) COMMA idxitem(Y). {A = sqliteIdListAppend(X,&Y);} 753 idxlist(A) ::= idxitem(Y). {A = sqliteIdListAppend(0,&Y);} 754 idxitem(A) ::= nm(X) sortorder. {A = X;} 755 756 ///////////////////////////// The DROP INDEX command ///////////////////////// 757 // 758 759 cmd ::= DROP INDEX nm(X) dbnm(Y). { 760 sqliteDropIndex(pParse, sqliteSrcListAppend(0,&X,&Y)); 761 } 762 763 764 ///////////////////////////// The COPY command /////////////////////////////// 765 // 766 cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y) USING DELIMITERS STRING(Z). 767 {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,&Z,R);} 768 cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y). 769 {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,0,R);} 770 771 ///////////////////////////// The VACUUM command ///////////////////////////// 772 // 773 cmd ::= VACUUM. {sqliteVacuum(pParse,0);} 774 cmd ::= VACUUM nm(X). {sqliteVacuum(pParse,&X);} 775 776 ///////////////////////////// The PRAGMA command ///////////////////////////// 777 // 778 cmd ::= PRAGMA ids(X) EQ nm(Y). {sqlitePragma(pParse,&X,&Y,0);} 779 cmd ::= PRAGMA ids(X) EQ ON(Y). {sqlitePragma(pParse,&X,&Y,0);} 780 cmd ::= PRAGMA ids(X) EQ plus_num(Y). {sqlitePragma(pParse,&X,&Y,0);} 781 cmd ::= PRAGMA ids(X) EQ minus_num(Y). {sqlitePragma(pParse,&X,&Y,1);} 782 cmd ::= PRAGMA ids(X) LP nm(Y) RP. {sqlitePragma(pParse,&X,&Y,0);} 783 cmd ::= PRAGMA ids(X). {sqlitePragma(pParse,&X,&X,0);} 784 plus_num(A) ::= plus_opt number(X). {A = X;} 785 minus_num(A) ::= MINUS number(X). {A = X;} 786 number(A) ::= INTEGER(X). {A = X;} 787 number(A) ::= FLOAT(X). {A = X;} 788 plus_opt ::= PLUS. 789 plus_opt ::= . 790 791 //////////////////////////// The CREATE TRIGGER command ///////////////////// 792 793 cmd ::= CREATE(A) trigger_decl BEGIN trigger_cmd_list(S) END(Z). { 794 Token all; 795 all.z = A.z; 796 all.n = (Z.z - A.z) + Z.n; 797 sqliteFinishTrigger(pParse, S, &all); 798 } 799 800 trigger_decl ::= temp(T) TRIGGER nm(B) trigger_time(C) trigger_event(D) 801 ON nm(E) dbnm(DB) foreach_clause(F) when_clause(G). { 802 SrcList *pTab = sqliteSrcListAppend(0, &E, &DB); 803 sqliteBeginTrigger(pParse, &B, C, D.a, D.b, pTab, F, G, T); 804 } 805 806 %type trigger_time {int} 807 trigger_time(A) ::= BEFORE. { A = TK_BEFORE; } 808 trigger_time(A) ::= AFTER. { A = TK_AFTER; } 809 trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;} 810 trigger_time(A) ::= . { A = TK_BEFORE; } 811 812 %type trigger_event {struct TrigEvent} 813 %destructor trigger_event {sqliteIdListDelete($$.b);} 814 trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; } 815 trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; } 816 trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;} 817 trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X; } 818 819 %type foreach_clause {int} 820 foreach_clause(A) ::= . { A = TK_ROW; } 821 foreach_clause(A) ::= FOR EACH ROW. { A = TK_ROW; } 822 foreach_clause(A) ::= FOR EACH STATEMENT. { A = TK_STATEMENT; } 823 824 %type when_clause {Expr *} 825 when_clause(A) ::= . { A = 0; } 826 when_clause(A) ::= WHEN expr(X). { A = X; } 827 828 %type trigger_cmd_list {TriggerStep *} 829 %destructor trigger_cmd_list {sqliteDeleteTriggerStep($$);} 830 trigger_cmd_list(A) ::= trigger_cmd(X) SEMI trigger_cmd_list(Y). { 831 X->pNext = Y; 832 A = X; 833 } 834 trigger_cmd_list(A) ::= . { A = 0; } 835 836 %type trigger_cmd {TriggerStep *} 837 %destructor trigger_cmd {sqliteDeleteTriggerStep($$);} 838 // UPDATE 839 trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z). 840 { A = sqliteTriggerUpdateStep(&X, Y, Z, R); } 841 842 // INSERT 843 trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) 844 VALUES LP itemlist(Y) RP. 845 {A = sqliteTriggerInsertStep(&X, F, Y, 0, R);} 846 847 trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S). 848 {A = sqliteTriggerInsertStep(&X, F, 0, S, R);} 849 850 // DELETE 851 trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y). 852 {A = sqliteTriggerDeleteStep(&X, Y);} 853 854 // SELECT 855 trigger_cmd(A) ::= select(X). {A = sqliteTriggerSelectStep(X); } 856 857 // The special RAISE expression that may occur in trigger programs 858 expr(A) ::= RAISE(X) LP IGNORE RP(Y). { 859 A = sqliteExpr(TK_RAISE, 0, 0, 0); 860 A->iColumn = OE_Ignore; 861 sqliteExprSpan(A, &X, &Y); 862 } 863 expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y). { 864 A = sqliteExpr(TK_RAISE, 0, 0, &Z); 865 A->iColumn = OE_Rollback; 866 sqliteExprSpan(A, &X, &Y); 867 } 868 expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y). { 869 A = sqliteExpr(TK_RAISE, 0, 0, &Z); 870 A->iColumn = OE_Abort; 871 sqliteExprSpan(A, &X, &Y); 872 } 873 expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y). { 874 A = sqliteExpr(TK_RAISE, 0, 0, &Z); 875 A->iColumn = OE_Fail; 876 sqliteExprSpan(A, &X, &Y); 877 } 878 879 //////////////////////// DROP TRIGGER statement ////////////////////////////// 880 cmd ::= DROP TRIGGER nm(X) dbnm(D). { 881 sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&X,&D)); 882 } 883 884 //////////////////////// ATTACH DATABASE file AS name ///////////////////////// 885 cmd ::= ATTACH database_kw_opt ids(F) AS nm(D) key_opt(K). { 886 sqliteAttach(pParse, &F, &D, &K); 887 } 888 %type key_opt {Token} 889 key_opt(A) ::= USING ids(X). { A = X; } 890 key_opt(A) ::= . { A.z = 0; A.n = 0; } 891 892 database_kw_opt ::= DATABASE. 893 database_kw_opt ::= . 894 895 //////////////////////// DETACH DATABASE name ///////////////////////////////// 896 cmd ::= DETACH database_kw_opt nm(D). { 897 sqliteDetach(pParse, &D); 898 } 899