Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / parse.y
blob877827e68d7c6478dd949ce1f84ed9ce6b84696c
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.
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.
18 // All token codes are small integers with #defines that begin with "TK_"
19 %token_prefix TK_
21 // The type of the data attached to each token is Token. This is also the
22 // default type for non-terminals.
24 %token_type {Token}
25 %default_type {Token}
27 // The generated parser function takes a 4th argument as follows:
28 %extra_argument {Parse *pParse}
30 // This code runs whenever there is a syntax error
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);
37 %stack_overflow {
38 UNUSED_PARAMETER(yypMinor); /* Silence some compiler warnings */
39 sqlite3ErrorMsg(pParse, "parser stack overflow");
42 // The name of the generated procedure that implements the parser
43 // is as follows:
44 %name sqlite3Parser
46 // The following text is included near the beginning of the C source
47 // code file that implements the parser.
49 %include {
50 #include "sqliteInt.h"
53 ** Disable all error recovery processing in the parser push-down
54 ** automaton.
56 #define YYNOERRORRECOVERY 1
59 ** Make yytestcase() the same as testcase()
61 #define yytestcase(X) testcase(X)
64 ** An instance of this structure holds information about the
65 ** LIMIT clause of a SELECT statement.
67 struct LimitVal {
68 Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */
69 Expr *pOffset; /* The OFFSET expression. NULL if there is none */
73 ** An instance of this structure is used to store the LIKE,
74 ** GLOB, NOT LIKE, and NOT GLOB operators.
76 struct LikeOp {
77 Token eOperator; /* "like" or "glob" or "regexp" */
78 int bNot; /* True if the NOT keyword is present */
82 ** An instance of the following structure describes the event of a
83 ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
84 ** TK_DELETE, or TK_INSTEAD. If the event is of the form
86 ** UPDATE ON (a,b,c)
88 ** Then the "b" IdList records the list "a,b,c".
90 struct TrigEvent { int a; IdList * b; };
93 ** An instance of this structure holds the ATTACH key and the key type.
95 struct AttachKey { int type; Token key; };
97 } // end %include
99 // Input is a single SQL command
100 input ::= cmdlist.
101 cmdlist ::= cmdlist ecmd.
102 cmdlist ::= ecmd.
103 ecmd ::= SEMI.
104 ecmd ::= explain cmdx SEMI.
105 explain ::= . { sqlite3BeginParse(pParse, 0); }
106 %ifndef SQLITE_OMIT_EXPLAIN
107 explain ::= EXPLAIN. { sqlite3BeginParse(pParse, 1); }
108 explain ::= EXPLAIN QUERY PLAN. { sqlite3BeginParse(pParse, 2); }
109 %endif SQLITE_OMIT_EXPLAIN
110 cmdx ::= cmd. { sqlite3FinishCoding(pParse); }
112 ///////////////////// Begin and end transactions. ////////////////////////////
115 cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);}
116 trans_opt ::= .
117 trans_opt ::= TRANSACTION.
118 trans_opt ::= TRANSACTION nm.
119 %type transtype {int}
120 transtype(A) ::= . {A = TK_DEFERRED;}
121 transtype(A) ::= DEFERRED(X). {A = @X;}
122 transtype(A) ::= IMMEDIATE(X). {A = @X;}
123 transtype(A) ::= EXCLUSIVE(X). {A = @X;}
124 cmd ::= COMMIT trans_opt. {sqlite3CommitTransaction(pParse);}
125 cmd ::= END trans_opt. {sqlite3CommitTransaction(pParse);}
126 cmd ::= ROLLBACK trans_opt. {sqlite3RollbackTransaction(pParse);}
128 savepoint_opt ::= SAVEPOINT.
129 savepoint_opt ::= .
130 cmd ::= SAVEPOINT nm(X). {
131 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X);
133 cmd ::= RELEASE savepoint_opt nm(X). {
134 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X);
136 cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). {
137 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X);
140 ///////////////////// The CREATE TABLE statement ////////////////////////////
142 cmd ::= create_table create_table_args.
143 create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {
144 sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);
146 createkw(A) ::= CREATE(X). {
147 pParse->db->lookaside.bEnabled = 0;
148 A = X;
150 %type ifnotexists {int}
151 ifnotexists(A) ::= . {A = 0;}
152 ifnotexists(A) ::= IF NOT EXISTS. {A = 1;}
153 %type temp {int}
154 %ifndef SQLITE_OMIT_TEMPDB
155 temp(A) ::= TEMP. {A = 1;}
156 %endif SQLITE_OMIT_TEMPDB
157 temp(A) ::= . {A = 0;}
158 create_table_args ::= LP columnlist conslist_opt(X) RP(E) table_options(F). {
159 sqlite3EndTable(pParse,&X,&E,F,0);
161 create_table_args ::= AS select(S). {
162 sqlite3EndTable(pParse,0,0,0,S);
163 sqlite3SelectDelete(pParse->db, S);
165 %type table_options {u8}
166 table_options(A) ::= . {A = 0;}
167 table_options(A) ::= WITHOUT nm(X). {
168 if( X.n==5 && sqlite3_strnicmp(X.z,"rowid",5)==0 ){
169 A = TF_WithoutRowid;
170 }else{
171 A = 0;
172 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", X.n, X.z);
175 columnlist ::= columnlist COMMA column.
176 columnlist ::= column.
178 // A "column" is a complete description of a single column in a
179 // CREATE TABLE statement. This includes the column name, its
180 // datatype, and other keywords such as PRIMARY KEY, UNIQUE, REFERENCES,
181 // NOT NULL and so forth.
183 column(A) ::= columnid(X) type carglist. {
184 A.z = X.z;
185 A.n = (int)(pParse->sLastToken.z-X.z) + pParse->sLastToken.n;
187 columnid(A) ::= nm(X). {
188 sqlite3AddColumn(pParse,&X);
189 A = X;
190 pParse->constraintName.n = 0;
194 // An IDENTIFIER can be a generic identifier, or one of several
195 // keywords. Any non-standard keyword can also be an identifier.
197 %token_class id ID|INDEXED.
199 // The following directive causes tokens ABORT, AFTER, ASC, etc. to
200 // fallback to ID if they will not parse as their original value.
201 // This obviates the need for the "id" nonterminal.
203 %fallback ID
204 ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW
205 CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR
206 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH NO PLAN
207 QUERY KEY OF OFFSET PRAGMA RAISE RECURSIVE RELEASE REPLACE RESTRICT ROW
208 ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT
209 %ifdef SQLITE_OMIT_COMPOUND_SELECT
210 EXCEPT INTERSECT UNION
211 %endif SQLITE_OMIT_COMPOUND_SELECT
212 REINDEX RENAME CTIME_KW IF
214 %wildcard ANY.
216 // Define operator precedence early so that this is the first occurrence
217 // of the operator tokens in the grammer. Keeping the operators together
218 // causes them to be assigned integer values that are close together,
219 // which keeps parser tables smaller.
221 // The token values assigned to these symbols is determined by the order
222 // in which lemon first sees them. It must be the case that ISNULL/NOTNULL,
223 // NE/EQ, GT/LE, and GE/LT are separated by only a single value. See
224 // the sqlite3ExprIfFalse() routine for additional information on this
225 // constraint.
227 %left OR.
228 %left AND.
229 %right NOT.
230 %left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
231 %left GT LE LT GE.
232 %right ESCAPE.
233 %left BITAND BITOR LSHIFT RSHIFT.
234 %left PLUS MINUS.
235 %left STAR SLASH REM.
236 %left CONCAT.
237 %left COLLATE.
238 %right BITNOT.
240 // And "ids" is an identifer-or-string.
242 %token_class ids ID|STRING.
244 // The name of a column or table can be any of the following:
246 %type nm {Token}
247 nm(A) ::= id(X). {A = X;}
248 nm(A) ::= STRING(X). {A = X;}
249 nm(A) ::= JOIN_KW(X). {A = X;}
251 // A typetoken is really one or more tokens that form a type name such
252 // as can be found after the column name in a CREATE TABLE statement.
253 // Multiple tokens are concatenated to form the value of the typetoken.
255 %type typetoken {Token}
256 type ::= .
257 type ::= typetoken(X). {sqlite3AddColumnType(pParse,&X);}
258 typetoken(A) ::= typename(X). {A = X;}
259 typetoken(A) ::= typename(X) LP signed RP(Y). {
260 A.z = X.z;
261 A.n = (int)(&Y.z[Y.n] - X.z);
263 typetoken(A) ::= typename(X) LP signed COMMA signed RP(Y). {
264 A.z = X.z;
265 A.n = (int)(&Y.z[Y.n] - X.z);
267 %type typename {Token}
268 typename(A) ::= ids(X). {A = X;}
269 typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(int)(Y.z-X.z);}
270 signed ::= plus_num.
271 signed ::= minus_num.
273 // "carglist" is a list of additional constraints that come after the
274 // column name and column type in a CREATE TABLE statement.
276 carglist ::= carglist ccons.
277 carglist ::= .
278 ccons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}
279 ccons ::= DEFAULT term(X). {sqlite3AddDefaultValue(pParse,&X);}
280 ccons ::= DEFAULT LP expr(X) RP. {sqlite3AddDefaultValue(pParse,&X);}
281 ccons ::= DEFAULT PLUS term(X). {sqlite3AddDefaultValue(pParse,&X);}
282 ccons ::= DEFAULT MINUS(A) term(X). {
283 ExprSpan v;
284 v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, X.pExpr, 0, 0);
285 v.zStart = A.z;
286 v.zEnd = X.zEnd;
287 sqlite3AddDefaultValue(pParse,&v);
289 ccons ::= DEFAULT id(X). {
290 ExprSpan v;
291 spanExpr(&v, pParse, TK_STRING, &X);
292 sqlite3AddDefaultValue(pParse,&v);
295 // In addition to the type name, we also care about the primary key and
296 // UNIQUE constraints.
298 ccons ::= NULL onconf.
299 ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);}
300 ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).
301 {sqlite3AddPrimaryKey(pParse,0,R,I,Z);}
302 ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0);}
303 ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X.pExpr);}
304 ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
305 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
306 ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);}
307 ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);}
309 // The optional AUTOINCREMENT keyword
310 %type autoinc {int}
311 autoinc(X) ::= . {X = 0;}
312 autoinc(X) ::= AUTOINCR. {X = 1;}
314 // The next group of rules parses the arguments to a REFERENCES clause
315 // that determine if the referential integrity checking is deferred or
316 // or immediate and which determine what action to take if a ref-integ
317 // check fails.
319 %type refargs {int}
320 refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */}
321 refargs(A) ::= refargs(X) refarg(Y). { A = (X & ~Y.mask) | Y.value; }
322 %type refarg {struct {int value; int mask;}}
323 refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }
324 refarg(A) ::= ON INSERT refact. { A.value = 0; A.mask = 0x000000; }
325 refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }
326 refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }
327 %type refact {int}
328 refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */}
329 refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */}
330 refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */}
331 refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */}
332 refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */}
333 %type defer_subclause {int}
334 defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt. {A = 0;}
335 defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;}
336 %type init_deferred_pred_opt {int}
337 init_deferred_pred_opt(A) ::= . {A = 0;}
338 init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;}
339 init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;}
341 conslist_opt(A) ::= . {A.n = 0; A.z = 0;}
342 conslist_opt(A) ::= COMMA(X) conslist. {A = X;}
343 conslist ::= conslist tconscomma tcons.
344 conslist ::= tcons.
345 tconscomma ::= COMMA. {pParse->constraintName.n = 0;}
346 tconscomma ::= .
347 tcons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}
348 tcons ::= PRIMARY KEY LP idxlist(X) autoinc(I) RP onconf(R).
349 {sqlite3AddPrimaryKey(pParse,X,R,I,0);}
350 tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
351 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0);}
352 tcons ::= CHECK LP expr(E) RP onconf.
353 {sqlite3AddCheckConstraint(pParse,E.pExpr);}
354 tcons ::= FOREIGN KEY LP idxlist(FA) RP
355 REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {
356 sqlite3CreateForeignKey(pParse, FA, &T, TA, R);
357 sqlite3DeferForeignKey(pParse, D);
359 %type defer_subclause_opt {int}
360 defer_subclause_opt(A) ::= . {A = 0;}
361 defer_subclause_opt(A) ::= defer_subclause(X). {A = X;}
363 // The following is a non-standard extension that allows us to declare the
364 // default behavior when there is a constraint conflict.
366 %type onconf {int}
367 %type orconf {u8}
368 %type resolvetype {int}
369 onconf(A) ::= . {A = OE_Default;}
370 onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;}
371 orconf(A) ::= . {A = OE_Default;}
372 orconf(A) ::= OR resolvetype(X). {A = (u8)X;}
373 resolvetype(A) ::= raisetype(X). {A = X;}
374 resolvetype(A) ::= IGNORE. {A = OE_Ignore;}
375 resolvetype(A) ::= REPLACE. {A = OE_Replace;}
377 ////////////////////////// The DROP TABLE /////////////////////////////////////
379 cmd ::= DROP TABLE ifexists(E) fullname(X). {
380 sqlite3DropTable(pParse, X, 0, E);
382 %type ifexists {int}
383 ifexists(A) ::= IF EXISTS. {A = 1;}
384 ifexists(A) ::= . {A = 0;}
386 ///////////////////// The CREATE VIEW statement /////////////////////////////
388 %ifndef SQLITE_OMIT_VIEW
389 cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) AS select(S). {
390 sqlite3CreateView(pParse, &X, &Y, &Z, S, T, E);
392 cmd ::= DROP VIEW ifexists(E) fullname(X). {
393 sqlite3DropTable(pParse, X, 1, E);
395 %endif SQLITE_OMIT_VIEW
397 //////////////////////// The SELECT statement /////////////////////////////////
399 cmd ::= select(X). {
400 SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0};
401 sqlite3Select(pParse, X, &dest);
402 sqlite3SelectDelete(pParse->db, X);
405 %type select {Select*}
406 %destructor select {sqlite3SelectDelete(pParse->db, $$);}
407 %type selectnowith {Select*}
408 %destructor selectnowith {sqlite3SelectDelete(pParse->db, $$);}
409 %type oneselect {Select*}
410 %destructor oneselect {sqlite3SelectDelete(pParse->db, $$);}
412 select(A) ::= with(W) selectnowith(X). {
413 Select *p = X, *pNext, *pLoop;
414 if( p ){
415 int cnt = 0, mxSelect;
416 p->pWith = W;
417 if( p->pPrior ){
418 pNext = 0;
419 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
420 pLoop->pNext = pNext;
421 pLoop->selFlags |= SF_Compound;
423 mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
424 if( mxSelect && cnt>mxSelect ){
425 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
428 }else{
429 sqlite3WithDelete(pParse->db, W);
431 A = p;
434 selectnowith(A) ::= oneselect(X). {A = X;}
435 %ifndef SQLITE_OMIT_COMPOUND_SELECT
436 selectnowith(A) ::= selectnowith(X) multiselect_op(Y) oneselect(Z). {
437 Select *pRhs = Z;
438 if( pRhs && pRhs->pPrior ){
439 SrcList *pFrom;
440 Token x;
441 x.n = 0;
442 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
443 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);
445 if( pRhs ){
446 pRhs->op = (u8)Y;
447 pRhs->pPrior = X;
448 if( Y!=TK_ALL ) pParse->hasCompound = 1;
449 }else{
450 sqlite3SelectDelete(pParse->db, X);
452 A = pRhs;
454 %type multiselect_op {int}
455 multiselect_op(A) ::= UNION(OP). {A = @OP;}
456 multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}
457 multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP;}
458 %endif SQLITE_OMIT_COMPOUND_SELECT
459 oneselect(A) ::= SELECT(S) distinct(D) selcollist(W) from(X) where_opt(Y)
460 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
461 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);
462 #if SELECTTRACE_ENABLED
463 /* Populate the Select.zSelName[] string that is used to help with
464 ** query planner debugging, to differentiate between multiple Select
465 ** objects in a complex query.
467 ** If the SELECT keyword is immediately followed by a C-style comment
468 ** then extract the first few alphanumeric characters from within that
469 ** comment to be the zSelName value. Otherwise, the label is #N where
470 ** is an integer that is incremented with each SELECT statement seen.
472 if( A!=0 ){
473 const char *z = S.z+6;
474 int i;
475 sqlite3_snprintf(sizeof(A->zSelName), A->zSelName, "#%d",
476 ++pParse->nSelect);
477 while( z[0]==' ' ) z++;
478 if( z[0]=='/' && z[1]=='*' ){
479 z += 2;
480 while( z[0]==' ' ) z++;
481 for(i=0; sqlite3Isalnum(z[i]); i++){}
482 sqlite3_snprintf(sizeof(A->zSelName), A->zSelName, "%.*s", i, z);
485 #endif /* SELECTRACE_ENABLED */
487 oneselect(A) ::= values(X). {A = X;}
489 %type values {Select*}
490 %destructor values {sqlite3SelectDelete(pParse->db, $$);}
491 values(A) ::= VALUES LP nexprlist(X) RP. {
492 A = sqlite3SelectNew(pParse,X,0,0,0,0,0,SF_Values,0,0);
494 values(A) ::= values(X) COMMA LP exprlist(Y) RP. {
495 Select *pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values,0,0);
496 if( pRight ){
497 pRight->op = TK_ALL;
498 pRight->pPrior = X;
499 A = pRight;
500 }else{
501 A = X;
505 // The "distinct" nonterminal is true (1) if the DISTINCT keyword is
506 // present and false (0) if it is not.
508 %type distinct {u16}
509 distinct(A) ::= DISTINCT. {A = SF_Distinct;}
510 distinct(A) ::= ALL. {A = 0;}
511 distinct(A) ::= . {A = 0;}
513 // selcollist is a list of expressions that are to become the return
514 // values of the SELECT statement. The "*" in statements like
515 // "SELECT * FROM ..." is encoded as a special expression with an
516 // opcode of TK_ALL.
518 %type selcollist {ExprList*}
519 %destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);}
520 %type sclp {ExprList*}
521 %destructor sclp {sqlite3ExprListDelete(pParse->db, $$);}
522 sclp(A) ::= selcollist(X) COMMA. {A = X;}
523 sclp(A) ::= . {A = 0;}
524 selcollist(A) ::= sclp(P) expr(X) as(Y). {
525 A = sqlite3ExprListAppend(pParse, P, X.pExpr);
526 if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1);
527 sqlite3ExprListSetSpan(pParse,A,&X);
529 selcollist(A) ::= sclp(P) STAR. {
530 Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
531 A = sqlite3ExprListAppend(pParse, P, p);
533 selcollist(A) ::= sclp(P) nm(X) DOT STAR(Y). {
534 Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &Y);
535 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
536 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
537 A = sqlite3ExprListAppend(pParse,P, pDot);
540 // An option "AS <id>" phrase that can follow one of the expressions that
541 // define the result set, or one of the tables in the FROM clause.
543 %type as {Token}
544 as(X) ::= AS nm(Y). {X = Y;}
545 as(X) ::= ids(Y). {X = Y;}
546 as(X) ::= . {X.n = 0;}
549 %type seltablist {SrcList*}
550 %destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);}
551 %type stl_prefix {SrcList*}
552 %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);}
553 %type from {SrcList*}
554 %destructor from {sqlite3SrcListDelete(pParse->db, $$);}
556 // A complete FROM clause.
558 from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
559 from(A) ::= FROM seltablist(X). {
560 A = X;
561 sqlite3SrcListShiftJoinType(A);
564 // "seltablist" is a "Select Table List" - the content of the FROM clause
565 // in a SELECT statement. "stl_prefix" is a prefix of this list.
567 stl_prefix(A) ::= seltablist(X) joinop(Y). {
568 A = X;
569 if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].jointype = (u8)Y;
571 stl_prefix(A) ::= . {A = 0;}
572 seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) indexed_opt(I)
573 on_opt(N) using_opt(U). {
574 A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U);
575 sqlite3SrcListIndexedBy(pParse, A, &I);
577 %ifndef SQLITE_OMIT_SUBQUERY
578 seltablist(A) ::= stl_prefix(X) LP select(S) RP
579 as(Z) on_opt(N) using_opt(U). {
580 A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U);
582 seltablist(A) ::= stl_prefix(X) LP seltablist(F) RP
583 as(Z) on_opt(N) using_opt(U). {
584 if( X==0 && Z.n==0 && N==0 && U==0 ){
585 A = F;
586 }else if( F->nSrc==1 ){
587 A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,0,N,U);
588 if( A ){
589 struct SrcList_item *pNew = &A->a[A->nSrc-1];
590 struct SrcList_item *pOld = F->a;
591 pNew->zName = pOld->zName;
592 pNew->zDatabase = pOld->zDatabase;
593 pNew->pSelect = pOld->pSelect;
594 pOld->zName = pOld->zDatabase = 0;
595 pOld->pSelect = 0;
597 sqlite3SrcListDelete(pParse->db, F);
598 }else{
599 Select *pSubquery;
600 sqlite3SrcListShiftJoinType(F);
601 pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,SF_NestedFrom,0,0);
602 A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,pSubquery,N,U);
605 %endif SQLITE_OMIT_SUBQUERY
607 %type dbnm {Token}
608 dbnm(A) ::= . {A.z=0; A.n=0;}
609 dbnm(A) ::= DOT nm(X). {A = X;}
611 %type fullname {SrcList*}
612 %destructor fullname {sqlite3SrcListDelete(pParse->db, $$);}
613 fullname(A) ::= nm(X) dbnm(Y). {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y);}
615 %type joinop {int}
616 %type joinop2 {int}
617 joinop(X) ::= COMMA|JOIN. { X = JT_INNER; }
618 joinop(X) ::= JOIN_KW(A) JOIN. { X = sqlite3JoinType(pParse,&A,0,0); }
619 joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqlite3JoinType(pParse,&A,&B,0); }
620 joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
621 { X = sqlite3JoinType(pParse,&A,&B,&C); }
623 %type on_opt {Expr*}
624 %destructor on_opt {sqlite3ExprDelete(pParse->db, $$);}
625 on_opt(N) ::= ON expr(E). {N = E.pExpr;}
626 on_opt(N) ::= . {N = 0;}
628 // Note that this block abuses the Token type just a little. If there is
629 // no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If
630 // there is an INDEXED BY clause, then the token is populated as per normal,
631 // with z pointing to the token data and n containing the number of bytes
632 // in the token.
634 // If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is
635 // normally illegal. The sqlite3SrcListIndexedBy() function
636 // recognizes and interprets this as a special case.
638 %type indexed_opt {Token}
639 indexed_opt(A) ::= . {A.z=0; A.n=0;}
640 indexed_opt(A) ::= INDEXED BY nm(X). {A = X;}
641 indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;}
643 %type using_opt {IdList*}
644 %destructor using_opt {sqlite3IdListDelete(pParse->db, $$);}
645 using_opt(U) ::= USING LP idlist(L) RP. {U = L;}
646 using_opt(U) ::= . {U = 0;}
649 %type orderby_opt {ExprList*}
650 %destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);}
651 %type sortlist {ExprList*}
652 %destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);}
654 orderby_opt(A) ::= . {A = 0;}
655 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
656 sortlist(A) ::= sortlist(X) COMMA expr(Y) sortorder(Z). {
657 A = sqlite3ExprListAppend(pParse,X,Y.pExpr);
658 if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
660 sortlist(A) ::= expr(Y) sortorder(Z). {
661 A = sqlite3ExprListAppend(pParse,0,Y.pExpr);
662 if( A && ALWAYS(A->a) ) A->a[0].sortOrder = (u8)Z;
665 %type sortorder {int}
667 sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}
668 sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}
669 sortorder(A) ::= . {A = SQLITE_SO_ASC;}
671 %type groupby_opt {ExprList*}
672 %destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);}
673 groupby_opt(A) ::= . {A = 0;}
674 groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}
676 %type having_opt {Expr*}
677 %destructor having_opt {sqlite3ExprDelete(pParse->db, $$);}
678 having_opt(A) ::= . {A = 0;}
679 having_opt(A) ::= HAVING expr(X). {A = X.pExpr;}
681 %type limit_opt {struct LimitVal}
683 // The destructor for limit_opt will never fire in the current grammar.
684 // The limit_opt non-terminal only occurs at the end of a single production
685 // rule for SELECT statements. As soon as the rule that create the
686 // limit_opt non-terminal reduces, the SELECT statement rule will also
687 // reduce. So there is never a limit_opt non-terminal on the stack
688 // except as a transient. So there is never anything to destroy.
690 //%destructor limit_opt {
691 // sqlite3ExprDelete(pParse->db, $$.pLimit);
692 // sqlite3ExprDelete(pParse->db, $$.pOffset);
694 limit_opt(A) ::= . {A.pLimit = 0; A.pOffset = 0;}
695 limit_opt(A) ::= LIMIT expr(X). {A.pLimit = X.pExpr; A.pOffset = 0;}
696 limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).
697 {A.pLimit = X.pExpr; A.pOffset = Y.pExpr;}
698 limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).
699 {A.pOffset = X.pExpr; A.pLimit = Y.pExpr;}
701 /////////////////////////// The DELETE statement /////////////////////////////
703 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
704 cmd ::= with(C) DELETE FROM fullname(X) indexed_opt(I) where_opt(W)
705 orderby_opt(O) limit_opt(L). {
706 sqlite3WithPush(pParse, C, 1);
707 sqlite3SrcListIndexedBy(pParse, X, &I);
708 W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "DELETE");
709 sqlite3DeleteFrom(pParse,X,W);
711 %endif
712 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
713 cmd ::= with(C) DELETE FROM fullname(X) indexed_opt(I) where_opt(W). {
714 sqlite3WithPush(pParse, C, 1);
715 sqlite3SrcListIndexedBy(pParse, X, &I);
716 sqlite3DeleteFrom(pParse,X,W);
718 %endif
720 %type where_opt {Expr*}
721 %destructor where_opt {sqlite3ExprDelete(pParse->db, $$);}
723 where_opt(A) ::= . {A = 0;}
724 where_opt(A) ::= WHERE expr(X). {A = X.pExpr;}
726 ////////////////////////// The UPDATE command ////////////////////////////////
728 %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
729 cmd ::= with(C) UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y)
730 where_opt(W) orderby_opt(O) limit_opt(L). {
731 sqlite3WithPush(pParse, C, 1);
732 sqlite3SrcListIndexedBy(pParse, X, &I);
733 sqlite3ExprListCheckLength(pParse,Y,"set list");
734 W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "UPDATE");
735 sqlite3Update(pParse,X,Y,W,R);
737 %endif
738 %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
739 cmd ::= with(C) UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y)
740 where_opt(W). {
741 sqlite3WithPush(pParse, C, 1);
742 sqlite3SrcListIndexedBy(pParse, X, &I);
743 sqlite3ExprListCheckLength(pParse,Y,"set list");
744 sqlite3Update(pParse,X,Y,W,R);
746 %endif
748 %type setlist {ExprList*}
749 %destructor setlist {sqlite3ExprListDelete(pParse->db, $$);}
751 setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y). {
752 A = sqlite3ExprListAppend(pParse, Z, Y.pExpr);
753 sqlite3ExprListSetName(pParse, A, &X, 1);
755 setlist(A) ::= nm(X) EQ expr(Y). {
756 A = sqlite3ExprListAppend(pParse, 0, Y.pExpr);
757 sqlite3ExprListSetName(pParse, A, &X, 1);
760 ////////////////////////// The INSERT command /////////////////////////////////
762 cmd ::= with(W) insert_cmd(R) INTO fullname(X) inscollist_opt(F) select(S). {
763 sqlite3WithPush(pParse, W, 1);
764 sqlite3Insert(pParse, X, S, F, R);
766 cmd ::= with(W) insert_cmd(R) INTO fullname(X) inscollist_opt(F) DEFAULT VALUES.
768 sqlite3WithPush(pParse, W, 1);
769 sqlite3Insert(pParse, X, 0, F, R);
772 %type insert_cmd {u8}
773 insert_cmd(A) ::= INSERT orconf(R). {A = R;}
774 insert_cmd(A) ::= REPLACE. {A = OE_Replace;}
776 %type inscollist_opt {IdList*}
777 %destructor inscollist_opt {sqlite3IdListDelete(pParse->db, $$);}
778 %type idlist {IdList*}
779 %destructor idlist {sqlite3IdListDelete(pParse->db, $$);}
781 inscollist_opt(A) ::= . {A = 0;}
782 inscollist_opt(A) ::= LP idlist(X) RP. {A = X;}
783 idlist(A) ::= idlist(X) COMMA nm(Y).
784 {A = sqlite3IdListAppend(pParse->db,X,&Y);}
785 idlist(A) ::= nm(Y).
786 {A = sqlite3IdListAppend(pParse->db,0,&Y);}
788 /////////////////////////// Expression Processing /////////////////////////////
791 %type expr {ExprSpan}
792 %destructor expr {sqlite3ExprDelete(pParse->db, $$.pExpr);}
793 %type term {ExprSpan}
794 %destructor term {sqlite3ExprDelete(pParse->db, $$.pExpr);}
796 %include {
797 /* This is a utility routine used to set the ExprSpan.zStart and
798 ** ExprSpan.zEnd values of pOut so that the span covers the complete
799 ** range of text beginning with pStart and going to the end of pEnd.
801 static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
802 pOut->zStart = pStart->z;
803 pOut->zEnd = &pEnd->z[pEnd->n];
806 /* Construct a new Expr object from a single identifier. Use the
807 ** new Expr to populate pOut. Set the span of pOut to be the identifier
808 ** that created the expression.
810 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
811 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
812 pOut->zStart = pValue->z;
813 pOut->zEnd = &pValue->z[pValue->n];
817 expr(A) ::= term(X). {A = X;}
818 expr(A) ::= LP(B) expr(X) RP(E). {A.pExpr = X.pExpr; spanSet(&A,&B,&E);}
819 term(A) ::= NULL(X). {spanExpr(&A, pParse, @X, &X);}
820 expr(A) ::= id(X). {spanExpr(&A, pParse, TK_ID, &X);}
821 expr(A) ::= JOIN_KW(X). {spanExpr(&A, pParse, TK_ID, &X);}
822 expr(A) ::= nm(X) DOT nm(Y). {
823 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
824 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
825 A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
826 spanSet(&A,&X,&Y);
828 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
829 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
830 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
831 Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Z);
832 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
833 A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
834 spanSet(&A,&X,&Z);
836 term(A) ::= INTEGER|FLOAT|BLOB(X). {spanExpr(&A, pParse, @X, &X);}
837 term(A) ::= STRING(X). {spanExpr(&A, pParse, @X, &X);}
838 expr(A) ::= VARIABLE(X). {
839 if( X.n>=2 && X.z[0]=='#' && sqlite3Isdigit(X.z[1]) ){
840 /* When doing a nested parse, one can include terms in an expression
841 ** that look like this: #1 #2 ... These terms refer to registers
842 ** in the virtual machine. #N is the N-th register. */
843 if( pParse->nested==0 ){
844 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &X);
845 A.pExpr = 0;
846 }else{
847 A.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &X);
848 if( A.pExpr ) sqlite3GetInt32(&X.z[1], &A.pExpr->iTable);
850 }else{
851 spanExpr(&A, pParse, TK_VARIABLE, &X);
852 sqlite3ExprAssignVarNumber(pParse, A.pExpr);
854 spanSet(&A, &X, &X);
856 expr(A) ::= expr(E) COLLATE ids(C). {
857 A.pExpr = sqlite3ExprAddCollateToken(pParse, E.pExpr, &C);
858 A.zStart = E.zStart;
859 A.zEnd = &C.z[C.n];
861 %ifndef SQLITE_OMIT_CAST
862 expr(A) ::= CAST(X) LP expr(E) AS typetoken(T) RP(Y). {
863 A.pExpr = sqlite3PExpr(pParse, TK_CAST, E.pExpr, 0, &T);
864 spanSet(&A,&X,&Y);
866 %endif SQLITE_OMIT_CAST
867 expr(A) ::= id(X) LP distinct(D) exprlist(Y) RP(E). {
868 if( Y && Y->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
869 sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X);
871 A.pExpr = sqlite3ExprFunction(pParse, Y, &X);
872 spanSet(&A,&X,&E);
873 if( D && A.pExpr ){
874 A.pExpr->flags |= EP_Distinct;
877 expr(A) ::= id(X) LP STAR RP(E). {
878 A.pExpr = sqlite3ExprFunction(pParse, 0, &X);
879 spanSet(&A,&X,&E);
881 term(A) ::= CTIME_KW(OP). {
882 A.pExpr = sqlite3ExprFunction(pParse, 0, &OP);
883 spanSet(&A, &OP, &OP);
886 %include {
887 /* This routine constructs a binary expression node out of two ExprSpan
888 ** objects and uses the result to populate a new ExprSpan object.
890 static void spanBinaryExpr(
891 ExprSpan *pOut, /* Write the result here */
892 Parse *pParse, /* The parsing context. Errors accumulate here */
893 int op, /* The binary operation */
894 ExprSpan *pLeft, /* The left operand */
895 ExprSpan *pRight /* The right operand */
897 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
898 pOut->zStart = pLeft->zStart;
899 pOut->zEnd = pRight->zEnd;
903 expr(A) ::= expr(X) AND(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
904 expr(A) ::= expr(X) OR(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
905 expr(A) ::= expr(X) LT|GT|GE|LE(OP) expr(Y).
906 {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
907 expr(A) ::= expr(X) EQ|NE(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
908 expr(A) ::= expr(X) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).
909 {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
910 expr(A) ::= expr(X) PLUS|MINUS(OP) expr(Y).
911 {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
912 expr(A) ::= expr(X) STAR|SLASH|REM(OP) expr(Y).
913 {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
914 expr(A) ::= expr(X) CONCAT(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
915 %type likeop {struct LikeOp}
916 likeop(A) ::= LIKE_KW|MATCH(X). {A.eOperator = X; A.bNot = 0;}
917 likeop(A) ::= NOT LIKE_KW|MATCH(X). {A.eOperator = X; A.bNot = 1;}
918 expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE_KW] {
919 ExprList *pList;
920 pList = sqlite3ExprListAppend(pParse,0, Y.pExpr);
921 pList = sqlite3ExprListAppend(pParse,pList, X.pExpr);
922 A.pExpr = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
923 if( OP.bNot ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
924 A.zStart = X.zStart;
925 A.zEnd = Y.zEnd;
926 if( A.pExpr ) A.pExpr->flags |= EP_InfixFunc;
928 expr(A) ::= expr(X) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] {
929 ExprList *pList;
930 pList = sqlite3ExprListAppend(pParse,0, Y.pExpr);
931 pList = sqlite3ExprListAppend(pParse,pList, X.pExpr);
932 pList = sqlite3ExprListAppend(pParse,pList, E.pExpr);
933 A.pExpr = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
934 if( OP.bNot ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
935 A.zStart = X.zStart;
936 A.zEnd = E.zEnd;
937 if( A.pExpr ) A.pExpr->flags |= EP_InfixFunc;
940 %include {
941 /* Construct an expression node for a unary postfix operator
943 static void spanUnaryPostfix(
944 ExprSpan *pOut, /* Write the new expression node here */
945 Parse *pParse, /* Parsing context to record errors */
946 int op, /* The operator */
947 ExprSpan *pOperand, /* The operand */
948 Token *pPostOp /* The operand token for setting the span */
950 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
951 pOut->zStart = pOperand->zStart;
952 pOut->zEnd = &pPostOp->z[pPostOp->n];
956 expr(A) ::= expr(X) ISNULL|NOTNULL(E). {spanUnaryPostfix(&A,pParse,@E,&X,&E);}
957 expr(A) ::= expr(X) NOT NULL(E). {spanUnaryPostfix(&A,pParse,TK_NOTNULL,&X,&E);}
959 %include {
960 /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
961 ** unary TK_ISNULL or TK_NOTNULL expression. */
962 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
963 sqlite3 *db = pParse->db;
964 if( pY && pA && pY->op==TK_NULL ){
965 pA->op = (u8)op;
966 sqlite3ExprDelete(db, pA->pRight);
967 pA->pRight = 0;
972 // expr1 IS expr2
973 // expr1 IS NOT expr2
975 // If expr2 is NULL then code as TK_ISNULL or TK_NOTNULL. If expr2
976 // is any other expression, code as TK_IS or TK_ISNOT.
978 expr(A) ::= expr(X) IS expr(Y). {
979 spanBinaryExpr(&A,pParse,TK_IS,&X,&Y);
980 binaryToUnaryIfNull(pParse, Y.pExpr, A.pExpr, TK_ISNULL);
982 expr(A) ::= expr(X) IS NOT expr(Y). {
983 spanBinaryExpr(&A,pParse,TK_ISNOT,&X,&Y);
984 binaryToUnaryIfNull(pParse, Y.pExpr, A.pExpr, TK_NOTNULL);
987 %include {
988 /* Construct an expression node for a unary prefix operator
990 static void spanUnaryPrefix(
991 ExprSpan *pOut, /* Write the new expression node here */
992 Parse *pParse, /* Parsing context to record errors */
993 int op, /* The operator */
994 ExprSpan *pOperand, /* The operand */
995 Token *pPreOp /* The operand token for setting the span */
997 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
998 pOut->zStart = pPreOp->z;
999 pOut->zEnd = pOperand->zEnd;
1005 expr(A) ::= NOT(B) expr(X). {spanUnaryPrefix(&A,pParse,@B,&X,&B);}
1006 expr(A) ::= BITNOT(B) expr(X). {spanUnaryPrefix(&A,pParse,@B,&X,&B);}
1007 expr(A) ::= MINUS(B) expr(X). [BITNOT]
1008 {spanUnaryPrefix(&A,pParse,TK_UMINUS,&X,&B);}
1009 expr(A) ::= PLUS(B) expr(X). [BITNOT]
1010 {spanUnaryPrefix(&A,pParse,TK_UPLUS,&X,&B);}
1012 %type between_op {int}
1013 between_op(A) ::= BETWEEN. {A = 0;}
1014 between_op(A) ::= NOT BETWEEN. {A = 1;}
1015 expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
1016 ExprList *pList = sqlite3ExprListAppend(pParse,0, X.pExpr);
1017 pList = sqlite3ExprListAppend(pParse,pList, Y.pExpr);
1018 A.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, W.pExpr, 0, 0);
1019 if( A.pExpr ){
1020 A.pExpr->x.pList = pList;
1021 }else{
1022 sqlite3ExprListDelete(pParse->db, pList);
1024 if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1025 A.zStart = W.zStart;
1026 A.zEnd = Y.zEnd;
1028 %ifndef SQLITE_OMIT_SUBQUERY
1029 %type in_op {int}
1030 in_op(A) ::= IN. {A = 0;}
1031 in_op(A) ::= NOT IN. {A = 1;}
1032 expr(A) ::= expr(X) in_op(N) LP exprlist(Y) RP(E). [IN] {
1033 if( Y==0 ){
1034 /* Expressions of the form
1036 ** expr1 IN ()
1037 ** expr1 NOT IN ()
1039 ** simplify to constants 0 (false) and 1 (true), respectively,
1040 ** regardless of the value of expr1.
1042 A.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[N]);
1043 sqlite3ExprDelete(pParse->db, X.pExpr);
1044 }else if( Y->nExpr==1 ){
1045 /* Expressions of the form:
1047 ** expr1 IN (?1)
1048 ** expr1 NOT IN (?2)
1050 ** with exactly one value on the RHS can be simplified to something
1051 ** like this:
1053 ** expr1 == ?1
1054 ** expr1 <> ?2
1056 ** But, the RHS of the == or <> is marked with the EP_Generic flag
1057 ** so that it may not contribute to the computation of comparison
1058 ** affinity or the collating sequence to use for comparison. Otherwise,
1059 ** the semantics would be subtly different from IN or NOT IN.
1061 Expr *pRHS = Y->a[0].pExpr;
1062 Y->a[0].pExpr = 0;
1063 sqlite3ExprListDelete(pParse->db, Y);
1064 /* pRHS cannot be NULL because a malloc error would have been detected
1065 ** before now and control would have never reached this point */
1066 if( ALWAYS(pRHS) ){
1067 pRHS->flags &= ~EP_Collate;
1068 pRHS->flags |= EP_Generic;
1070 A.pExpr = sqlite3PExpr(pParse, N ? TK_NE : TK_EQ, X.pExpr, pRHS, 0);
1071 }else{
1072 A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
1073 if( A.pExpr ){
1074 A.pExpr->x.pList = Y;
1075 sqlite3ExprSetHeight(pParse, A.pExpr);
1076 }else{
1077 sqlite3ExprListDelete(pParse->db, Y);
1079 if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1081 A.zStart = X.zStart;
1082 A.zEnd = &E.z[E.n];
1084 expr(A) ::= LP(B) select(X) RP(E). {
1085 A.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
1086 if( A.pExpr ){
1087 A.pExpr->x.pSelect = X;
1088 ExprSetProperty(A.pExpr, EP_xIsSelect);
1089 sqlite3ExprSetHeight(pParse, A.pExpr);
1090 }else{
1091 sqlite3SelectDelete(pParse->db, X);
1093 A.zStart = B.z;
1094 A.zEnd = &E.z[E.n];
1096 expr(A) ::= expr(X) in_op(N) LP select(Y) RP(E). [IN] {
1097 A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
1098 if( A.pExpr ){
1099 A.pExpr->x.pSelect = Y;
1100 ExprSetProperty(A.pExpr, EP_xIsSelect);
1101 sqlite3ExprSetHeight(pParse, A.pExpr);
1102 }else{
1103 sqlite3SelectDelete(pParse->db, Y);
1105 if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1106 A.zStart = X.zStart;
1107 A.zEnd = &E.z[E.n];
1109 expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {
1110 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
1111 A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
1112 if( A.pExpr ){
1113 A.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
1114 ExprSetProperty(A.pExpr, EP_xIsSelect);
1115 sqlite3ExprSetHeight(pParse, A.pExpr);
1116 }else{
1117 sqlite3SrcListDelete(pParse->db, pSrc);
1119 if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1120 A.zStart = X.zStart;
1121 A.zEnd = Z.z ? &Z.z[Z.n] : &Y.z[Y.n];
1123 expr(A) ::= EXISTS(B) LP select(Y) RP(E). {
1124 Expr *p = A.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
1125 if( p ){
1126 p->x.pSelect = Y;
1127 ExprSetProperty(p, EP_xIsSelect);
1128 sqlite3ExprSetHeight(pParse, p);
1129 }else{
1130 sqlite3SelectDelete(pParse->db, Y);
1132 A.zStart = B.z;
1133 A.zEnd = &E.z[E.n];
1135 %endif SQLITE_OMIT_SUBQUERY
1137 /* CASE expressions */
1138 expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {
1139 A.pExpr = sqlite3PExpr(pParse, TK_CASE, X, 0, 0);
1140 if( A.pExpr ){
1141 A.pExpr->x.pList = Z ? sqlite3ExprListAppend(pParse,Y,Z) : Y;
1142 sqlite3ExprSetHeight(pParse, A.pExpr);
1143 }else{
1144 sqlite3ExprListDelete(pParse->db, Y);
1145 sqlite3ExprDelete(pParse->db, Z);
1147 A.zStart = C.z;
1148 A.zEnd = &E.z[E.n];
1150 %type case_exprlist {ExprList*}
1151 %destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);}
1152 case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
1153 A = sqlite3ExprListAppend(pParse,X, Y.pExpr);
1154 A = sqlite3ExprListAppend(pParse,A, Z.pExpr);
1156 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
1157 A = sqlite3ExprListAppend(pParse,0, Y.pExpr);
1158 A = sqlite3ExprListAppend(pParse,A, Z.pExpr);
1160 %type case_else {Expr*}
1161 %destructor case_else {sqlite3ExprDelete(pParse->db, $$);}
1162 case_else(A) ::= ELSE expr(X). {A = X.pExpr;}
1163 case_else(A) ::= . {A = 0;}
1164 %type case_operand {Expr*}
1165 %destructor case_operand {sqlite3ExprDelete(pParse->db, $$);}
1166 case_operand(A) ::= expr(X). {A = X.pExpr;}
1167 case_operand(A) ::= . {A = 0;}
1169 %type exprlist {ExprList*}
1170 %destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);}
1171 %type nexprlist {ExprList*}
1172 %destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);}
1174 exprlist(A) ::= nexprlist(X). {A = X;}
1175 exprlist(A) ::= . {A = 0;}
1176 nexprlist(A) ::= nexprlist(X) COMMA expr(Y).
1177 {A = sqlite3ExprListAppend(pParse,X,Y.pExpr);}
1178 nexprlist(A) ::= expr(Y).
1179 {A = sqlite3ExprListAppend(pParse,0,Y.pExpr);}
1182 ///////////////////////////// The CREATE INDEX command ///////////////////////
1184 cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)
1185 ON nm(Y) LP idxlist(Z) RP where_opt(W). {
1186 sqlite3CreateIndex(pParse, &X, &D,
1187 sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U,
1188 &S, W, SQLITE_SO_ASC, NE);
1191 %type uniqueflag {int}
1192 uniqueflag(A) ::= UNIQUE. {A = OE_Abort;}
1193 uniqueflag(A) ::= . {A = OE_None;}
1195 %type idxlist {ExprList*}
1196 %destructor idxlist {sqlite3ExprListDelete(pParse->db, $$);}
1197 %type idxlist_opt {ExprList*}
1198 %destructor idxlist_opt {sqlite3ExprListDelete(pParse->db, $$);}
1200 idxlist_opt(A) ::= . {A = 0;}
1201 idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;}
1202 idxlist(A) ::= idxlist(X) COMMA nm(Y) collate(C) sortorder(Z). {
1203 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &C);
1204 A = sqlite3ExprListAppend(pParse,X, p);
1205 sqlite3ExprListSetName(pParse,A,&Y,1);
1206 sqlite3ExprListCheckLength(pParse, A, "index");
1207 if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
1209 idxlist(A) ::= nm(Y) collate(C) sortorder(Z). {
1210 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &C);
1211 A = sqlite3ExprListAppend(pParse,0, p);
1212 sqlite3ExprListSetName(pParse, A, &Y, 1);
1213 sqlite3ExprListCheckLength(pParse, A, "index");
1214 if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
1217 %type collate {Token}
1218 collate(C) ::= . {C.z = 0; C.n = 0;}
1219 collate(C) ::= COLLATE ids(X). {C = X;}
1222 ///////////////////////////// The DROP INDEX command /////////////////////////
1224 cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);}
1226 ///////////////////////////// The VACUUM command /////////////////////////////
1228 %ifndef SQLITE_OMIT_VACUUM
1229 %ifndef SQLITE_OMIT_ATTACH
1230 cmd ::= VACUUM. {sqlite3Vacuum(pParse);}
1231 cmd ::= VACUUM nm. {sqlite3Vacuum(pParse);}
1232 %endif SQLITE_OMIT_ATTACH
1233 %endif SQLITE_OMIT_VACUUM
1235 ///////////////////////////// The PRAGMA command /////////////////////////////
1237 %ifndef SQLITE_OMIT_PRAGMA
1238 cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);}
1239 cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
1240 cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
1241 cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y).
1242 {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
1243 cmd ::= PRAGMA nm(X) dbnm(Z) LP minus_num(Y) RP.
1244 {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
1246 nmnum(A) ::= plus_num(X). {A = X;}
1247 nmnum(A) ::= nm(X). {A = X;}
1248 nmnum(A) ::= ON(X). {A = X;}
1249 nmnum(A) ::= DELETE(X). {A = X;}
1250 nmnum(A) ::= DEFAULT(X). {A = X;}
1251 %endif SQLITE_OMIT_PRAGMA
1252 %token_class number INTEGER|FLOAT.
1253 plus_num(A) ::= PLUS number(X). {A = X;}
1254 plus_num(A) ::= number(X). {A = X;}
1255 minus_num(A) ::= MINUS number(X). {A = X;}
1256 //////////////////////////// The CREATE TRIGGER command /////////////////////
1258 %ifndef SQLITE_OMIT_TRIGGER
1260 cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
1261 Token all;
1262 all.z = A.z;
1263 all.n = (int)(Z.z - A.z) + Z.n;
1264 sqlite3FinishTrigger(pParse, S, &all);
1267 trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z)
1268 trigger_time(C) trigger_event(D)
1269 ON fullname(E) foreach_clause when_clause(G). {
1270 sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR);
1271 A = (Z.n==0?B:Z);
1274 %type trigger_time {int}
1275 trigger_time(A) ::= BEFORE. { A = TK_BEFORE; }
1276 trigger_time(A) ::= AFTER. { A = TK_AFTER; }
1277 trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
1278 trigger_time(A) ::= . { A = TK_BEFORE; }
1280 %type trigger_event {struct TrigEvent}
1281 %destructor trigger_event {sqlite3IdListDelete(pParse->db, $$.b);}
1282 trigger_event(A) ::= DELETE|INSERT(OP). {A.a = @OP; A.b = 0;}
1283 trigger_event(A) ::= UPDATE(OP). {A.a = @OP; A.b = 0;}
1284 trigger_event(A) ::= UPDATE OF idlist(X). {A.a = TK_UPDATE; A.b = X;}
1286 foreach_clause ::= .
1287 foreach_clause ::= FOR EACH ROW.
1289 %type when_clause {Expr*}
1290 %destructor when_clause {sqlite3ExprDelete(pParse->db, $$);}
1291 when_clause(A) ::= . { A = 0; }
1292 when_clause(A) ::= WHEN expr(X). { A = X.pExpr; }
1294 %type trigger_cmd_list {TriggerStep*}
1295 %destructor trigger_cmd_list {sqlite3DeleteTriggerStep(pParse->db, $$);}
1296 trigger_cmd_list(A) ::= trigger_cmd_list(Y) trigger_cmd(X) SEMI. {
1297 assert( Y!=0 );
1298 Y->pLast->pNext = X;
1299 Y->pLast = X;
1300 A = Y;
1302 trigger_cmd_list(A) ::= trigger_cmd(X) SEMI. {
1303 assert( X!=0 );
1304 X->pLast = X;
1305 A = X;
1308 // Disallow qualified table names on INSERT, UPDATE, and DELETE statements
1309 // within a trigger. The table to INSERT, UPDATE, or DELETE is always in
1310 // the same database as the table that the trigger fires on.
1312 %type trnm {Token}
1313 trnm(A) ::= nm(X). {A = X;}
1314 trnm(A) ::= nm DOT nm(X). {
1315 A = X;
1316 sqlite3ErrorMsg(pParse,
1317 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
1318 "statements within triggers");
1321 // Disallow the INDEX BY and NOT INDEXED clauses on UPDATE and DELETE
1322 // statements within triggers. We make a specific error message for this
1323 // since it is an exception to the default grammar rules.
1325 tridxby ::= .
1326 tridxby ::= INDEXED BY nm. {
1327 sqlite3ErrorMsg(pParse,
1328 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
1329 "within triggers");
1331 tridxby ::= NOT INDEXED. {
1332 sqlite3ErrorMsg(pParse,
1333 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
1334 "within triggers");
1339 %type trigger_cmd {TriggerStep*}
1340 %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);}
1341 // UPDATE
1342 trigger_cmd(A) ::=
1343 UPDATE orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z).
1344 { A = sqlite3TriggerUpdateStep(pParse->db, &X, Y, Z, R); }
1346 // INSERT
1347 trigger_cmd(A) ::= insert_cmd(R) INTO trnm(X) inscollist_opt(F) select(S).
1348 {A = sqlite3TriggerInsertStep(pParse->db, &X, F, S, R);}
1350 // DELETE
1351 trigger_cmd(A) ::= DELETE FROM trnm(X) tridxby where_opt(Y).
1352 {A = sqlite3TriggerDeleteStep(pParse->db, &X, Y);}
1354 // SELECT
1355 trigger_cmd(A) ::= select(X). {A = sqlite3TriggerSelectStep(pParse->db, X); }
1357 // The special RAISE expression that may occur in trigger programs
1358 expr(A) ::= RAISE(X) LP IGNORE RP(Y). {
1359 A.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
1360 if( A.pExpr ){
1361 A.pExpr->affinity = OE_Ignore;
1363 A.zStart = X.z;
1364 A.zEnd = &Y.z[Y.n];
1366 expr(A) ::= RAISE(X) LP raisetype(T) COMMA nm(Z) RP(Y). {
1367 A.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &Z);
1368 if( A.pExpr ) {
1369 A.pExpr->affinity = (char)T;
1371 A.zStart = X.z;
1372 A.zEnd = &Y.z[Y.n];
1374 %endif !SQLITE_OMIT_TRIGGER
1376 %type raisetype {int}
1377 raisetype(A) ::= ROLLBACK. {A = OE_Rollback;}
1378 raisetype(A) ::= ABORT. {A = OE_Abort;}
1379 raisetype(A) ::= FAIL. {A = OE_Fail;}
1382 //////////////////////// DROP TRIGGER statement //////////////////////////////
1383 %ifndef SQLITE_OMIT_TRIGGER
1384 cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
1385 sqlite3DropTrigger(pParse,X,NOERR);
1387 %endif !SQLITE_OMIT_TRIGGER
1389 //////////////////////// ATTACH DATABASE file AS name /////////////////////////
1390 %ifndef SQLITE_OMIT_ATTACH
1391 cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). {
1392 sqlite3Attach(pParse, F.pExpr, D.pExpr, K);
1394 cmd ::= DETACH database_kw_opt expr(D). {
1395 sqlite3Detach(pParse, D.pExpr);
1398 %type key_opt {Expr*}
1399 %destructor key_opt {sqlite3ExprDelete(pParse->db, $$);}
1400 key_opt(A) ::= . { A = 0; }
1401 key_opt(A) ::= KEY expr(X). { A = X.pExpr; }
1403 database_kw_opt ::= DATABASE.
1404 database_kw_opt ::= .
1405 %endif SQLITE_OMIT_ATTACH
1407 ////////////////////////// REINDEX collation //////////////////////////////////
1408 %ifndef SQLITE_OMIT_REINDEX
1409 cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);}
1410 cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);}
1411 %endif SQLITE_OMIT_REINDEX
1413 /////////////////////////////////// ANALYZE ///////////////////////////////////
1414 %ifndef SQLITE_OMIT_ANALYZE
1415 cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);}
1416 cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);}
1417 %endif
1419 //////////////////////// ALTER TABLE table ... ////////////////////////////////
1420 %ifndef SQLITE_OMIT_ALTERTABLE
1421 cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). {
1422 sqlite3AlterRenameTable(pParse,X,&Z);
1424 cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column(Y). {
1425 sqlite3AlterFinishAddColumn(pParse, &Y);
1427 add_column_fullname ::= fullname(X). {
1428 pParse->db->lookaside.bEnabled = 0;
1429 sqlite3AlterBeginAddColumn(pParse, X);
1431 kwcolumn_opt ::= .
1432 kwcolumn_opt ::= COLUMNKW.
1433 %endif SQLITE_OMIT_ALTERTABLE
1435 //////////////////////// CREATE VIRTUAL TABLE ... /////////////////////////////
1436 %ifndef SQLITE_OMIT_VIRTUALTABLE
1437 cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);}
1438 cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);}
1439 create_vtab ::= createkw VIRTUAL TABLE ifnotexists(E)
1440 nm(X) dbnm(Y) USING nm(Z). {
1441 sqlite3VtabBeginParse(pParse, &X, &Y, &Z, E);
1443 vtabarglist ::= vtabarg.
1444 vtabarglist ::= vtabarglist COMMA vtabarg.
1445 vtabarg ::= . {sqlite3VtabArgInit(pParse);}
1446 vtabarg ::= vtabarg vtabargtoken.
1447 vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);}
1448 vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);}
1449 lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);}
1450 anylist ::= .
1451 anylist ::= anylist LP anylist RP.
1452 anylist ::= anylist ANY.
1453 %endif SQLITE_OMIT_VIRTUALTABLE
1456 //////////////////////// COMMON TABLE EXPRESSIONS ////////////////////////////
1457 %type with {With*}
1458 %type wqlist {With*}
1459 %destructor with {sqlite3WithDelete(pParse->db, $$);}
1460 %destructor wqlist {sqlite3WithDelete(pParse->db, $$);}
1462 with(A) ::= . {A = 0;}
1463 %ifndef SQLITE_OMIT_CTE
1464 with(A) ::= WITH wqlist(W). { A = W; }
1465 with(A) ::= WITH RECURSIVE wqlist(W). { A = W; }
1467 wqlist(A) ::= nm(X) idxlist_opt(Y) AS LP select(Z) RP. {
1468 A = sqlite3WithAdd(pParse, 0, &X, Y, Z);
1470 wqlist(A) ::= wqlist(W) COMMA nm(X) idxlist_opt(Y) AS LP select(Z) RP. {
1471 A = sqlite3WithAdd(pParse, W, &X, Y, Z);
1473 %endif SQLITE_OMIT_CTE