Annotation of embedaddon/sqlite3/src/parse.y, revision 1.1.1.1
1.1 misho 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: ** An instance of this structure holds information about the
65: ** LIMIT clause of a SELECT statement.
66: */
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 */
70: };
71:
72: /*
73: ** An instance of this structure is used to store the LIKE,
74: ** GLOB, NOT LIKE, and NOT GLOB operators.
75: */
76: struct LikeOp {
77: Token eOperator; /* "like" or "glob" or "regexp" */
78: int not; /* True if the NOT keyword is present */
79: };
80:
81: /*
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
85: **
86: ** UPDATE ON (a,b,c)
87: **
88: ** Then the "b" IdList records the list "a,b,c".
89: */
90: struct TrigEvent { int a; IdList * b; };
91:
92: /*
93: ** An instance of this structure holds the ATTACH key and the key type.
94: */
95: struct AttachKey { int type; Token key; };
96:
97: } // end %include
98:
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); }
111:
112: ///////////////////// Begin and end transactions. ////////////////////////////
113: //
114:
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);}
127:
128: savepoint_opt ::= SAVEPOINT.
129: savepoint_opt ::= .
130: cmd ::= SAVEPOINT nm(X). {
131: sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X);
132: }
133: cmd ::= RELEASE savepoint_opt nm(X). {
134: sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X);
135: }
136: cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). {
137: sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X);
138: }
139:
140: ///////////////////// The CREATE TABLE statement ////////////////////////////
141: //
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);
145: }
146: createkw(A) ::= CREATE(X). {
147: pParse->db->lookaside.bEnabled = 0;
148: A = X;
149: }
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(Y). {
159: sqlite3EndTable(pParse,&X,&Y,0);
160: }
161: create_table_args ::= AS select(S). {
162: sqlite3EndTable(pParse,0,0,S);
163: sqlite3SelectDelete(pParse->db, S);
164: }
165: columnlist ::= columnlist COMMA column.
166: columnlist ::= column.
167:
168: // A "column" is a complete description of a single column in a
169: // CREATE TABLE statement. This includes the column name, its
170: // datatype, and other keywords such as PRIMARY KEY, UNIQUE, REFERENCES,
171: // NOT NULL and so forth.
172: //
173: column(A) ::= columnid(X) type carglist. {
174: A.z = X.z;
175: A.n = (int)(pParse->sLastToken.z-X.z) + pParse->sLastToken.n;
176: }
177: columnid(A) ::= nm(X). {
178: sqlite3AddColumn(pParse,&X);
179: A = X;
180: }
181:
182:
183: // An IDENTIFIER can be a generic identifier, or one of several
184: // keywords. Any non-standard keyword can also be an identifier.
185: //
186: %type id {Token}
187: id(A) ::= ID(X). {A = X;}
188: id(A) ::= INDEXED(X). {A = X;}
189:
190: // The following directive causes tokens ABORT, AFTER, ASC, etc. to
191: // fallback to ID if they will not parse as their original value.
192: // This obviates the need for the "id" nonterminal.
193: //
194: %fallback ID
195: ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW
196: CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR
197: IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH NO PLAN
198: QUERY KEY OF OFFSET PRAGMA RAISE RELEASE REPLACE RESTRICT ROW ROLLBACK
199: SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL
200: %ifdef SQLITE_OMIT_COMPOUND_SELECT
201: EXCEPT INTERSECT UNION
202: %endif SQLITE_OMIT_COMPOUND_SELECT
203: REINDEX RENAME CTIME_KW IF
204: .
205: %wildcard ANY.
206:
207: // Define operator precedence early so that this is the first occurance
208: // of the operator tokens in the grammer. Keeping the operators together
209: // causes them to be assigned integer values that are close together,
210: // which keeps parser tables smaller.
211: //
212: // The token values assigned to these symbols is determined by the order
213: // in which lemon first sees them. It must be the case that ISNULL/NOTNULL,
214: // NE/EQ, GT/LE, and GE/LT are separated by only a single value. See
215: // the sqlite3ExprIfFalse() routine for additional information on this
216: // constraint.
217: //
218: %left OR.
219: %left AND.
220: %right NOT.
221: %left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
222: %left GT LE LT GE.
223: %right ESCAPE.
224: %left BITAND BITOR LSHIFT RSHIFT.
225: %left PLUS MINUS.
226: %left STAR SLASH REM.
227: %left CONCAT.
228: %left COLLATE.
229: %right BITNOT.
230:
231: // And "ids" is an identifer-or-string.
232: //
233: %type ids {Token}
234: ids(A) ::= ID|STRING(X). {A = X;}
235:
236: // The name of a column or table can be any of the following:
237: //
238: %type nm {Token}
239: nm(A) ::= id(X). {A = X;}
240: nm(A) ::= STRING(X). {A = X;}
241: nm(A) ::= JOIN_KW(X). {A = X;}
242:
243: // A typetoken is really one or more tokens that form a type name such
244: // as can be found after the column name in a CREATE TABLE statement.
245: // Multiple tokens are concatenated to form the value of the typetoken.
246: //
247: %type typetoken {Token}
248: type ::= .
249: type ::= typetoken(X). {sqlite3AddColumnType(pParse,&X);}
250: typetoken(A) ::= typename(X). {A = X;}
251: typetoken(A) ::= typename(X) LP signed RP(Y). {
252: A.z = X.z;
253: A.n = (int)(&Y.z[Y.n] - X.z);
254: }
255: typetoken(A) ::= typename(X) LP signed COMMA signed RP(Y). {
256: A.z = X.z;
257: A.n = (int)(&Y.z[Y.n] - X.z);
258: }
259: %type typename {Token}
260: typename(A) ::= ids(X). {A = X;}
261: typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(int)(Y.z-X.z);}
262: signed ::= plus_num.
263: signed ::= minus_num.
264:
265: // "carglist" is a list of additional constraints that come after the
266: // column name and column type in a CREATE TABLE statement.
267: //
268: carglist ::= carglist carg.
269: carglist ::= .
270: carg ::= CONSTRAINT nm ccons.
271: carg ::= ccons.
272: ccons ::= DEFAULT term(X). {sqlite3AddDefaultValue(pParse,&X);}
273: ccons ::= DEFAULT LP expr(X) RP. {sqlite3AddDefaultValue(pParse,&X);}
274: ccons ::= DEFAULT PLUS term(X). {sqlite3AddDefaultValue(pParse,&X);}
275: ccons ::= DEFAULT MINUS(A) term(X). {
276: ExprSpan v;
277: v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, X.pExpr, 0, 0);
278: v.zStart = A.z;
279: v.zEnd = X.zEnd;
280: sqlite3AddDefaultValue(pParse,&v);
281: }
282: ccons ::= DEFAULT id(X). {
283: ExprSpan v;
284: spanExpr(&v, pParse, TK_STRING, &X);
285: sqlite3AddDefaultValue(pParse,&v);
286: }
287:
288: // In addition to the type name, we also care about the primary key and
289: // UNIQUE constraints.
290: //
291: ccons ::= NULL onconf.
292: ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);}
293: ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).
294: {sqlite3AddPrimaryKey(pParse,0,R,I,Z);}
295: ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0);}
296: ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X.pExpr);}
297: ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
298: {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
299: ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);}
300: ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);}
301:
302: // The optional AUTOINCREMENT keyword
303: %type autoinc {int}
304: autoinc(X) ::= . {X = 0;}
305: autoinc(X) ::= AUTOINCR. {X = 1;}
306:
307: // The next group of rules parses the arguments to a REFERENCES clause
308: // that determine if the referential integrity checking is deferred or
309: // or immediate and which determine what action to take if a ref-integ
310: // check fails.
311: //
312: %type refargs {int}
313: refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */}
314: refargs(A) ::= refargs(X) refarg(Y). { A = (X & ~Y.mask) | Y.value; }
315: %type refarg {struct {int value; int mask;}}
316: refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }
317: refarg(A) ::= ON INSERT refact. { A.value = 0; A.mask = 0x000000; }
318: refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }
319: refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }
320: %type refact {int}
321: refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */}
322: refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */}
323: refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */}
324: refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */}
325: refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */}
326: %type defer_subclause {int}
327: defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt. {A = 0;}
328: defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;}
329: %type init_deferred_pred_opt {int}
330: init_deferred_pred_opt(A) ::= . {A = 0;}
331: init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;}
332: init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;}
333:
334: // For the time being, the only constraint we care about is the primary
335: // key and UNIQUE. Both create indices.
336: //
337: conslist_opt(A) ::= . {A.n = 0; A.z = 0;}
338: conslist_opt(A) ::= COMMA(X) conslist. {A = X;}
339: conslist ::= conslist COMMA tcons.
340: conslist ::= conslist tcons.
341: conslist ::= tcons.
342: tcons ::= CONSTRAINT nm.
343: tcons ::= PRIMARY KEY LP idxlist(X) autoinc(I) RP onconf(R).
344: {sqlite3AddPrimaryKey(pParse,X,R,I,0);}
345: tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
346: {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0);}
347: tcons ::= CHECK LP expr(E) RP onconf.
348: {sqlite3AddCheckConstraint(pParse,E.pExpr);}
349: tcons ::= FOREIGN KEY LP idxlist(FA) RP
350: REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {
351: sqlite3CreateForeignKey(pParse, FA, &T, TA, R);
352: sqlite3DeferForeignKey(pParse, D);
353: }
354: %type defer_subclause_opt {int}
355: defer_subclause_opt(A) ::= . {A = 0;}
356: defer_subclause_opt(A) ::= defer_subclause(X). {A = X;}
357:
358: // The following is a non-standard extension that allows us to declare the
359: // default behavior when there is a constraint conflict.
360: //
361: %type onconf {int}
362: %type orconf {u8}
363: %type resolvetype {int}
364: onconf(A) ::= . {A = OE_Default;}
365: onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;}
366: orconf(A) ::= . {A = OE_Default;}
367: orconf(A) ::= OR resolvetype(X). {A = (u8)X;}
368: resolvetype(A) ::= raisetype(X). {A = X;}
369: resolvetype(A) ::= IGNORE. {A = OE_Ignore;}
370: resolvetype(A) ::= REPLACE. {A = OE_Replace;}
371:
372: ////////////////////////// The DROP TABLE /////////////////////////////////////
373: //
374: cmd ::= DROP TABLE ifexists(E) fullname(X). {
375: sqlite3DropTable(pParse, X, 0, E);
376: }
377: %type ifexists {int}
378: ifexists(A) ::= IF EXISTS. {A = 1;}
379: ifexists(A) ::= . {A = 0;}
380:
381: ///////////////////// The CREATE VIEW statement /////////////////////////////
382: //
383: %ifndef SQLITE_OMIT_VIEW
384: cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) AS select(S). {
385: sqlite3CreateView(pParse, &X, &Y, &Z, S, T, E);
386: }
387: cmd ::= DROP VIEW ifexists(E) fullname(X). {
388: sqlite3DropTable(pParse, X, 1, E);
389: }
390: %endif SQLITE_OMIT_VIEW
391:
392: //////////////////////// The SELECT statement /////////////////////////////////
393: //
394: cmd ::= select(X). {
395: SelectDest dest = {SRT_Output, 0, 0, 0, 0};
396: sqlite3Select(pParse, X, &dest);
397: sqlite3ExplainBegin(pParse->pVdbe);
398: sqlite3ExplainSelect(pParse->pVdbe, X);
399: sqlite3ExplainFinish(pParse->pVdbe);
400: sqlite3SelectDelete(pParse->db, X);
401: }
402:
403: %type select {Select*}
404: %destructor select {sqlite3SelectDelete(pParse->db, $$);}
405: %type oneselect {Select*}
406: %destructor oneselect {sqlite3SelectDelete(pParse->db, $$);}
407:
408: select(A) ::= oneselect(X). {A = X;}
409: %ifndef SQLITE_OMIT_COMPOUND_SELECT
410: select(A) ::= select(X) multiselect_op(Y) oneselect(Z). {
411: if( Z ){
412: Z->op = (u8)Y;
413: Z->pPrior = X;
414: }else{
415: sqlite3SelectDelete(pParse->db, X);
416: }
417: A = Z;
418: }
419: %type multiselect_op {int}
420: multiselect_op(A) ::= UNION(OP). {A = @OP;}
421: multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}
422: multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP;}
423: %endif SQLITE_OMIT_COMPOUND_SELECT
424: oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
425: groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
426: A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);
427: }
428:
429: // The "distinct" nonterminal is true (1) if the DISTINCT keyword is
430: // present and false (0) if it is not.
431: //
432: %type distinct {int}
433: distinct(A) ::= DISTINCT. {A = 1;}
434: distinct(A) ::= ALL. {A = 0;}
435: distinct(A) ::= . {A = 0;}
436:
437: // selcollist is a list of expressions that are to become the return
438: // values of the SELECT statement. The "*" in statements like
439: // "SELECT * FROM ..." is encoded as a special expression with an
440: // opcode of TK_ALL.
441: //
442: %type selcollist {ExprList*}
443: %destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);}
444: %type sclp {ExprList*}
445: %destructor sclp {sqlite3ExprListDelete(pParse->db, $$);}
446: sclp(A) ::= selcollist(X) COMMA. {A = X;}
447: sclp(A) ::= . {A = 0;}
448: selcollist(A) ::= sclp(P) expr(X) as(Y). {
449: A = sqlite3ExprListAppend(pParse, P, X.pExpr);
450: if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1);
451: sqlite3ExprListSetSpan(pParse,A,&X);
452: }
453: selcollist(A) ::= sclp(P) STAR. {
454: Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
455: A = sqlite3ExprListAppend(pParse, P, p);
456: }
457: selcollist(A) ::= sclp(P) nm(X) DOT STAR(Y). {
458: Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &Y);
459: Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
460: Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
461: A = sqlite3ExprListAppend(pParse,P, pDot);
462: }
463:
464: // An option "AS <id>" phrase that can follow one of the expressions that
465: // define the result set, or one of the tables in the FROM clause.
466: //
467: %type as {Token}
468: as(X) ::= AS nm(Y). {X = Y;}
469: as(X) ::= ids(Y). {X = Y;}
470: as(X) ::= . {X.n = 0;}
471:
472:
473: %type seltablist {SrcList*}
474: %destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);}
475: %type stl_prefix {SrcList*}
476: %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);}
477: %type from {SrcList*}
478: %destructor from {sqlite3SrcListDelete(pParse->db, $$);}
479:
480: // A complete FROM clause.
481: //
482: from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
483: from(A) ::= FROM seltablist(X). {
484: A = X;
485: sqlite3SrcListShiftJoinType(A);
486: }
487:
488: // "seltablist" is a "Select Table List" - the content of the FROM clause
489: // in a SELECT statement. "stl_prefix" is a prefix of this list.
490: //
491: stl_prefix(A) ::= seltablist(X) joinop(Y). {
492: A = X;
493: if( ALWAYS(A && A->nSrc>0) ) A->a[A->nSrc-1].jointype = (u8)Y;
494: }
495: stl_prefix(A) ::= . {A = 0;}
496: seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) indexed_opt(I) on_opt(N) using_opt(U). {
497: A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U);
498: sqlite3SrcListIndexedBy(pParse, A, &I);
499: }
500: %ifndef SQLITE_OMIT_SUBQUERY
501: seltablist(A) ::= stl_prefix(X) LP select(S) RP
502: as(Z) on_opt(N) using_opt(U). {
503: A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U);
504: }
505: seltablist(A) ::= stl_prefix(X) LP seltablist(F) RP
506: as(Z) on_opt(N) using_opt(U). {
507: if( X==0 && Z.n==0 && N==0 && U==0 ){
508: A = F;
509: }else{
510: Select *pSubquery;
511: sqlite3SrcListShiftJoinType(F);
512: pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);
513: A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,pSubquery,N,U);
514: }
515: }
516:
517: // A seltablist_paren nonterminal represents anything in a FROM that
518: // is contained inside parentheses. This can be either a subquery or
519: // a grouping of table and subqueries.
520: //
521: // %type seltablist_paren {Select*}
522: // %destructor seltablist_paren {sqlite3SelectDelete(pParse->db, $$);}
523: // seltablist_paren(A) ::= select(S). {A = S;}
524: // seltablist_paren(A) ::= seltablist(F). {
525: // sqlite3SrcListShiftJoinType(F);
526: // A = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);
527: // }
528: %endif SQLITE_OMIT_SUBQUERY
529:
530: %type dbnm {Token}
531: dbnm(A) ::= . {A.z=0; A.n=0;}
532: dbnm(A) ::= DOT nm(X). {A = X;}
533:
534: %type fullname {SrcList*}
535: %destructor fullname {sqlite3SrcListDelete(pParse->db, $$);}
536: fullname(A) ::= nm(X) dbnm(Y). {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y);}
537:
538: %type joinop {int}
539: %type joinop2 {int}
540: joinop(X) ::= COMMA|JOIN. { X = JT_INNER; }
541: joinop(X) ::= JOIN_KW(A) JOIN. { X = sqlite3JoinType(pParse,&A,0,0); }
542: joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqlite3JoinType(pParse,&A,&B,0); }
543: joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
544: { X = sqlite3JoinType(pParse,&A,&B,&C); }
545:
546: %type on_opt {Expr*}
547: %destructor on_opt {sqlite3ExprDelete(pParse->db, $$);}
548: on_opt(N) ::= ON expr(E). {N = E.pExpr;}
549: on_opt(N) ::= . {N = 0;}
550:
551: // Note that this block abuses the Token type just a little. If there is
552: // no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If
553: // there is an INDEXED BY clause, then the token is populated as per normal,
554: // with z pointing to the token data and n containing the number of bytes
555: // in the token.
556: //
557: // If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is
558: // normally illegal. The sqlite3SrcListIndexedBy() function
559: // recognizes and interprets this as a special case.
560: //
561: %type indexed_opt {Token}
562: indexed_opt(A) ::= . {A.z=0; A.n=0;}
563: indexed_opt(A) ::= INDEXED BY nm(X). {A = X;}
564: indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;}
565:
566: %type using_opt {IdList*}
567: %destructor using_opt {sqlite3IdListDelete(pParse->db, $$);}
568: using_opt(U) ::= USING LP inscollist(L) RP. {U = L;}
569: using_opt(U) ::= . {U = 0;}
570:
571:
572: %type orderby_opt {ExprList*}
573: %destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);}
574: %type sortlist {ExprList*}
575: %destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);}
576: %type sortitem {Expr*}
577: %destructor sortitem {sqlite3ExprDelete(pParse->db, $$);}
578:
579: orderby_opt(A) ::= . {A = 0;}
580: orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
581: sortlist(A) ::= sortlist(X) COMMA sortitem(Y) sortorder(Z). {
582: A = sqlite3ExprListAppend(pParse,X,Y);
583: if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
584: }
585: sortlist(A) ::= sortitem(Y) sortorder(Z). {
586: A = sqlite3ExprListAppend(pParse,0,Y);
587: if( A && ALWAYS(A->a) ) A->a[0].sortOrder = (u8)Z;
588: }
589: sortitem(A) ::= expr(X). {A = X.pExpr;}
590:
591: %type sortorder {int}
592:
593: sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}
594: sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}
595: sortorder(A) ::= . {A = SQLITE_SO_ASC;}
596:
597: %type groupby_opt {ExprList*}
598: %destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);}
599: groupby_opt(A) ::= . {A = 0;}
600: groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}
601:
602: %type having_opt {Expr*}
603: %destructor having_opt {sqlite3ExprDelete(pParse->db, $$);}
604: having_opt(A) ::= . {A = 0;}
605: having_opt(A) ::= HAVING expr(X). {A = X.pExpr;}
606:
607: %type limit_opt {struct LimitVal}
608:
609: // The destructor for limit_opt will never fire in the current grammar.
610: // The limit_opt non-terminal only occurs at the end of a single production
611: // rule for SELECT statements. As soon as the rule that create the
612: // limit_opt non-terminal reduces, the SELECT statement rule will also
613: // reduce. So there is never a limit_opt non-terminal on the stack
614: // except as a transient. So there is never anything to destroy.
615: //
616: //%destructor limit_opt {
617: // sqlite3ExprDelete(pParse->db, $$.pLimit);
618: // sqlite3ExprDelete(pParse->db, $$.pOffset);
619: //}
620: limit_opt(A) ::= . {A.pLimit = 0; A.pOffset = 0;}
621: limit_opt(A) ::= LIMIT expr(X). {A.pLimit = X.pExpr; A.pOffset = 0;}
622: limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).
623: {A.pLimit = X.pExpr; A.pOffset = Y.pExpr;}
624: limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).
625: {A.pOffset = X.pExpr; A.pLimit = Y.pExpr;}
626:
627: /////////////////////////// The DELETE statement /////////////////////////////
628: //
629: %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
630: cmd ::= DELETE FROM fullname(X) indexed_opt(I) where_opt(W)
631: orderby_opt(O) limit_opt(L). {
632: sqlite3SrcListIndexedBy(pParse, X, &I);
633: W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "DELETE");
634: sqlite3DeleteFrom(pParse,X,W);
635: }
636: %endif
637: %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
638: cmd ::= DELETE FROM fullname(X) indexed_opt(I) where_opt(W). {
639: sqlite3SrcListIndexedBy(pParse, X, &I);
640: sqlite3DeleteFrom(pParse,X,W);
641: }
642: %endif
643:
644: %type where_opt {Expr*}
645: %destructor where_opt {sqlite3ExprDelete(pParse->db, $$);}
646:
647: where_opt(A) ::= . {A = 0;}
648: where_opt(A) ::= WHERE expr(X). {A = X.pExpr;}
649:
650: ////////////////////////// The UPDATE command ////////////////////////////////
651: //
652: %ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
653: cmd ::= UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y) where_opt(W) orderby_opt(O) limit_opt(L). {
654: sqlite3SrcListIndexedBy(pParse, X, &I);
655: sqlite3ExprListCheckLength(pParse,Y,"set list");
656: W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "UPDATE");
657: sqlite3Update(pParse,X,Y,W,R);
658: }
659: %endif
660: %ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
661: cmd ::= UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y) where_opt(W). {
662: sqlite3SrcListIndexedBy(pParse, X, &I);
663: sqlite3ExprListCheckLength(pParse,Y,"set list");
664: sqlite3Update(pParse,X,Y,W,R);
665: }
666: %endif
667:
668: %type setlist {ExprList*}
669: %destructor setlist {sqlite3ExprListDelete(pParse->db, $$);}
670:
671: setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y). {
672: A = sqlite3ExprListAppend(pParse, Z, Y.pExpr);
673: sqlite3ExprListSetName(pParse, A, &X, 1);
674: }
675: setlist(A) ::= nm(X) EQ expr(Y). {
676: A = sqlite3ExprListAppend(pParse, 0, Y.pExpr);
677: sqlite3ExprListSetName(pParse, A, &X, 1);
678: }
679:
680: ////////////////////////// The INSERT command /////////////////////////////////
681: //
682: cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F)
683: VALUES LP itemlist(Y) RP.
684: {sqlite3Insert(pParse, X, Y, 0, F, R);}
685: cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) select(S).
686: {sqlite3Insert(pParse, X, 0, S, F, R);}
687: cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) DEFAULT VALUES.
688: {sqlite3Insert(pParse, X, 0, 0, F, R);}
689:
690: %type insert_cmd {u8}
691: insert_cmd(A) ::= INSERT orconf(R). {A = R;}
692: insert_cmd(A) ::= REPLACE. {A = OE_Replace;}
693:
694:
695: %type itemlist {ExprList*}
696: %destructor itemlist {sqlite3ExprListDelete(pParse->db, $$);}
697:
698: itemlist(A) ::= itemlist(X) COMMA expr(Y).
699: {A = sqlite3ExprListAppend(pParse,X,Y.pExpr);}
700: itemlist(A) ::= expr(X).
701: {A = sqlite3ExprListAppend(pParse,0,X.pExpr);}
702:
703: %type inscollist_opt {IdList*}
704: %destructor inscollist_opt {sqlite3IdListDelete(pParse->db, $$);}
705: %type inscollist {IdList*}
706: %destructor inscollist {sqlite3IdListDelete(pParse->db, $$);}
707:
708: inscollist_opt(A) ::= . {A = 0;}
709: inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;}
710: inscollist(A) ::= inscollist(X) COMMA nm(Y).
711: {A = sqlite3IdListAppend(pParse->db,X,&Y);}
712: inscollist(A) ::= nm(Y).
713: {A = sqlite3IdListAppend(pParse->db,0,&Y);}
714:
715: /////////////////////////// Expression Processing /////////////////////////////
716: //
717:
718: %type expr {ExprSpan}
719: %destructor expr {sqlite3ExprDelete(pParse->db, $$.pExpr);}
720: %type term {ExprSpan}
721: %destructor term {sqlite3ExprDelete(pParse->db, $$.pExpr);}
722:
723: %include {
724: /* This is a utility routine used to set the ExprSpan.zStart and
725: ** ExprSpan.zEnd values of pOut so that the span covers the complete
726: ** range of text beginning with pStart and going to the end of pEnd.
727: */
728: static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
729: pOut->zStart = pStart->z;
730: pOut->zEnd = &pEnd->z[pEnd->n];
731: }
732:
733: /* Construct a new Expr object from a single identifier. Use the
734: ** new Expr to populate pOut. Set the span of pOut to be the identifier
735: ** that created the expression.
736: */
737: static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
738: pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
739: pOut->zStart = pValue->z;
740: pOut->zEnd = &pValue->z[pValue->n];
741: }
742: }
743:
744: expr(A) ::= term(X). {A = X;}
745: expr(A) ::= LP(B) expr(X) RP(E). {A.pExpr = X.pExpr; spanSet(&A,&B,&E);}
746: term(A) ::= NULL(X). {spanExpr(&A, pParse, @X, &X);}
747: expr(A) ::= id(X). {spanExpr(&A, pParse, TK_ID, &X);}
748: expr(A) ::= JOIN_KW(X). {spanExpr(&A, pParse, TK_ID, &X);}
749: expr(A) ::= nm(X) DOT nm(Y). {
750: Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
751: Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
752: A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
753: spanSet(&A,&X,&Y);
754: }
755: expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
756: Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
757: Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
758: Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Z);
759: Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
760: A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
761: spanSet(&A,&X,&Z);
762: }
763: term(A) ::= INTEGER|FLOAT|BLOB(X). {spanExpr(&A, pParse, @X, &X);}
764: term(A) ::= STRING(X). {spanExpr(&A, pParse, @X, &X);}
765: expr(A) ::= REGISTER(X). {
766: /* When doing a nested parse, one can include terms in an expression
767: ** that look like this: #1 #2 ... These terms refer to registers
768: ** in the virtual machine. #N is the N-th register. */
769: if( pParse->nested==0 ){
770: sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &X);
771: A.pExpr = 0;
772: }else{
773: A.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &X);
774: if( A.pExpr ) sqlite3GetInt32(&X.z[1], &A.pExpr->iTable);
775: }
776: spanSet(&A, &X, &X);
777: }
778: expr(A) ::= VARIABLE(X). {
779: spanExpr(&A, pParse, TK_VARIABLE, &X);
780: sqlite3ExprAssignVarNumber(pParse, A.pExpr);
781: spanSet(&A, &X, &X);
782: }
783: expr(A) ::= expr(E) COLLATE ids(C). {
784: A.pExpr = sqlite3ExprSetCollByToken(pParse, E.pExpr, &C);
785: A.zStart = E.zStart;
786: A.zEnd = &C.z[C.n];
787: }
788: %ifndef SQLITE_OMIT_CAST
789: expr(A) ::= CAST(X) LP expr(E) AS typetoken(T) RP(Y). {
790: A.pExpr = sqlite3PExpr(pParse, TK_CAST, E.pExpr, 0, &T);
791: spanSet(&A,&X,&Y);
792: }
793: %endif SQLITE_OMIT_CAST
794: expr(A) ::= ID(X) LP distinct(D) exprlist(Y) RP(E). {
795: if( Y && Y->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
796: sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X);
797: }
798: A.pExpr = sqlite3ExprFunction(pParse, Y, &X);
799: spanSet(&A,&X,&E);
800: if( D && A.pExpr ){
801: A.pExpr->flags |= EP_Distinct;
802: }
803: }
804: expr(A) ::= ID(X) LP STAR RP(E). {
805: A.pExpr = sqlite3ExprFunction(pParse, 0, &X);
806: spanSet(&A,&X,&E);
807: }
808: term(A) ::= CTIME_KW(OP). {
809: /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
810: ** treated as functions that return constants */
811: A.pExpr = sqlite3ExprFunction(pParse, 0,&OP);
812: if( A.pExpr ){
813: A.pExpr->op = TK_CONST_FUNC;
814: }
815: spanSet(&A, &OP, &OP);
816: }
817:
818: %include {
819: /* This routine constructs a binary expression node out of two ExprSpan
820: ** objects and uses the result to populate a new ExprSpan object.
821: */
822: static void spanBinaryExpr(
823: ExprSpan *pOut, /* Write the result here */
824: Parse *pParse, /* The parsing context. Errors accumulate here */
825: int op, /* The binary operation */
826: ExprSpan *pLeft, /* The left operand */
827: ExprSpan *pRight /* The right operand */
828: ){
829: pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
830: pOut->zStart = pLeft->zStart;
831: pOut->zEnd = pRight->zEnd;
832: }
833: }
834:
835: expr(A) ::= expr(X) AND(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
836: expr(A) ::= expr(X) OR(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
837: expr(A) ::= expr(X) LT|GT|GE|LE(OP) expr(Y).
838: {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
839: expr(A) ::= expr(X) EQ|NE(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
840: expr(A) ::= expr(X) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).
841: {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
842: expr(A) ::= expr(X) PLUS|MINUS(OP) expr(Y).
843: {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
844: expr(A) ::= expr(X) STAR|SLASH|REM(OP) expr(Y).
845: {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
846: expr(A) ::= expr(X) CONCAT(OP) expr(Y). {spanBinaryExpr(&A,pParse,@OP,&X,&Y);}
847: %type likeop {struct LikeOp}
848: likeop(A) ::= LIKE_KW(X). {A.eOperator = X; A.not = 0;}
849: likeop(A) ::= NOT LIKE_KW(X). {A.eOperator = X; A.not = 1;}
850: likeop(A) ::= MATCH(X). {A.eOperator = X; A.not = 0;}
851: likeop(A) ::= NOT MATCH(X). {A.eOperator = X; A.not = 1;}
852: expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE_KW] {
853: ExprList *pList;
854: pList = sqlite3ExprListAppend(pParse,0, Y.pExpr);
855: pList = sqlite3ExprListAppend(pParse,pList, X.pExpr);
856: A.pExpr = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
857: if( OP.not ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
858: A.zStart = X.zStart;
859: A.zEnd = Y.zEnd;
860: if( A.pExpr ) A.pExpr->flags |= EP_InfixFunc;
861: }
862: expr(A) ::= expr(X) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] {
863: ExprList *pList;
864: pList = sqlite3ExprListAppend(pParse,0, Y.pExpr);
865: pList = sqlite3ExprListAppend(pParse,pList, X.pExpr);
866: pList = sqlite3ExprListAppend(pParse,pList, E.pExpr);
867: A.pExpr = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
868: if( OP.not ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
869: A.zStart = X.zStart;
870: A.zEnd = E.zEnd;
871: if( A.pExpr ) A.pExpr->flags |= EP_InfixFunc;
872: }
873:
874: %include {
875: /* Construct an expression node for a unary postfix operator
876: */
877: static void spanUnaryPostfix(
878: ExprSpan *pOut, /* Write the new expression node here */
879: Parse *pParse, /* Parsing context to record errors */
880: int op, /* The operator */
881: ExprSpan *pOperand, /* The operand */
882: Token *pPostOp /* The operand token for setting the span */
883: ){
884: pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
885: pOut->zStart = pOperand->zStart;
886: pOut->zEnd = &pPostOp->z[pPostOp->n];
887: }
888: }
889:
890: expr(A) ::= expr(X) ISNULL|NOTNULL(E). {spanUnaryPostfix(&A,pParse,@E,&X,&E);}
891: expr(A) ::= expr(X) NOT NULL(E). {spanUnaryPostfix(&A,pParse,TK_NOTNULL,&X,&E);}
892:
893: %include {
894: /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
895: ** unary TK_ISNULL or TK_NOTNULL expression. */
896: static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
897: sqlite3 *db = pParse->db;
898: if( db->mallocFailed==0 && pY->op==TK_NULL ){
899: pA->op = (u8)op;
900: sqlite3ExprDelete(db, pA->pRight);
901: pA->pRight = 0;
902: }
903: }
904: }
905:
906: // expr1 IS expr2
907: // expr1 IS NOT expr2
908: //
909: // If expr2 is NULL then code as TK_ISNULL or TK_NOTNULL. If expr2
910: // is any other expression, code as TK_IS or TK_ISNOT.
911: //
912: expr(A) ::= expr(X) IS expr(Y). {
913: spanBinaryExpr(&A,pParse,TK_IS,&X,&Y);
914: binaryToUnaryIfNull(pParse, Y.pExpr, A.pExpr, TK_ISNULL);
915: }
916: expr(A) ::= expr(X) IS NOT expr(Y). {
917: spanBinaryExpr(&A,pParse,TK_ISNOT,&X,&Y);
918: binaryToUnaryIfNull(pParse, Y.pExpr, A.pExpr, TK_NOTNULL);
919: }
920:
921: %include {
922: /* Construct an expression node for a unary prefix operator
923: */
924: static void spanUnaryPrefix(
925: ExprSpan *pOut, /* Write the new expression node here */
926: Parse *pParse, /* Parsing context to record errors */
927: int op, /* The operator */
928: ExprSpan *pOperand, /* The operand */
929: Token *pPreOp /* The operand token for setting the span */
930: ){
931: pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
932: pOut->zStart = pPreOp->z;
933: pOut->zEnd = pOperand->zEnd;
934: }
935: }
936:
937:
938:
939: expr(A) ::= NOT(B) expr(X). {spanUnaryPrefix(&A,pParse,@B,&X,&B);}
940: expr(A) ::= BITNOT(B) expr(X). {spanUnaryPrefix(&A,pParse,@B,&X,&B);}
941: expr(A) ::= MINUS(B) expr(X). [BITNOT]
942: {spanUnaryPrefix(&A,pParse,TK_UMINUS,&X,&B);}
943: expr(A) ::= PLUS(B) expr(X). [BITNOT]
944: {spanUnaryPrefix(&A,pParse,TK_UPLUS,&X,&B);}
945:
946: %type between_op {int}
947: between_op(A) ::= BETWEEN. {A = 0;}
948: between_op(A) ::= NOT BETWEEN. {A = 1;}
949: expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
950: ExprList *pList = sqlite3ExprListAppend(pParse,0, X.pExpr);
951: pList = sqlite3ExprListAppend(pParse,pList, Y.pExpr);
952: A.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, W.pExpr, 0, 0);
953: if( A.pExpr ){
954: A.pExpr->x.pList = pList;
955: }else{
956: sqlite3ExprListDelete(pParse->db, pList);
957: }
958: if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
959: A.zStart = W.zStart;
960: A.zEnd = Y.zEnd;
961: }
962: %ifndef SQLITE_OMIT_SUBQUERY
963: %type in_op {int}
964: in_op(A) ::= IN. {A = 0;}
965: in_op(A) ::= NOT IN. {A = 1;}
966: expr(A) ::= expr(X) in_op(N) LP exprlist(Y) RP(E). [IN] {
967: if( Y==0 ){
968: /* Expressions of the form
969: **
970: ** expr1 IN ()
971: ** expr1 NOT IN ()
972: **
973: ** simplify to constants 0 (false) and 1 (true), respectively,
974: ** regardless of the value of expr1.
975: */
976: A.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[N]);
977: sqlite3ExprDelete(pParse->db, X.pExpr);
978: }else{
979: A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
980: if( A.pExpr ){
981: A.pExpr->x.pList = Y;
982: sqlite3ExprSetHeight(pParse, A.pExpr);
983: }else{
984: sqlite3ExprListDelete(pParse->db, Y);
985: }
986: if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
987: }
988: A.zStart = X.zStart;
989: A.zEnd = &E.z[E.n];
990: }
991: expr(A) ::= LP(B) select(X) RP(E). {
992: A.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
993: if( A.pExpr ){
994: A.pExpr->x.pSelect = X;
995: ExprSetProperty(A.pExpr, EP_xIsSelect);
996: sqlite3ExprSetHeight(pParse, A.pExpr);
997: }else{
998: sqlite3SelectDelete(pParse->db, X);
999: }
1000: A.zStart = B.z;
1001: A.zEnd = &E.z[E.n];
1002: }
1003: expr(A) ::= expr(X) in_op(N) LP select(Y) RP(E). [IN] {
1004: A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
1005: if( A.pExpr ){
1006: A.pExpr->x.pSelect = Y;
1007: ExprSetProperty(A.pExpr, EP_xIsSelect);
1008: sqlite3ExprSetHeight(pParse, A.pExpr);
1009: }else{
1010: sqlite3SelectDelete(pParse->db, Y);
1011: }
1012: if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1013: A.zStart = X.zStart;
1014: A.zEnd = &E.z[E.n];
1015: }
1016: expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {
1017: SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
1018: A.pExpr = sqlite3PExpr(pParse, TK_IN, X.pExpr, 0, 0);
1019: if( A.pExpr ){
1020: A.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
1021: ExprSetProperty(A.pExpr, EP_xIsSelect);
1022: sqlite3ExprSetHeight(pParse, A.pExpr);
1023: }else{
1024: sqlite3SrcListDelete(pParse->db, pSrc);
1025: }
1026: if( N ) A.pExpr = sqlite3PExpr(pParse, TK_NOT, A.pExpr, 0, 0);
1027: A.zStart = X.zStart;
1028: A.zEnd = Z.z ? &Z.z[Z.n] : &Y.z[Y.n];
1029: }
1030: expr(A) ::= EXISTS(B) LP select(Y) RP(E). {
1031: Expr *p = A.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
1032: if( p ){
1033: p->x.pSelect = Y;
1034: ExprSetProperty(p, EP_xIsSelect);
1035: sqlite3ExprSetHeight(pParse, p);
1036: }else{
1037: sqlite3SelectDelete(pParse->db, Y);
1038: }
1039: A.zStart = B.z;
1040: A.zEnd = &E.z[E.n];
1041: }
1042: %endif SQLITE_OMIT_SUBQUERY
1043:
1044: /* CASE expressions */
1045: expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {
1046: A.pExpr = sqlite3PExpr(pParse, TK_CASE, X, Z, 0);
1047: if( A.pExpr ){
1048: A.pExpr->x.pList = Y;
1049: sqlite3ExprSetHeight(pParse, A.pExpr);
1050: }else{
1051: sqlite3ExprListDelete(pParse->db, Y);
1052: }
1053: A.zStart = C.z;
1054: A.zEnd = &E.z[E.n];
1055: }
1056: %type case_exprlist {ExprList*}
1057: %destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);}
1058: case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
1059: A = sqlite3ExprListAppend(pParse,X, Y.pExpr);
1060: A = sqlite3ExprListAppend(pParse,A, Z.pExpr);
1061: }
1062: case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
1063: A = sqlite3ExprListAppend(pParse,0, Y.pExpr);
1064: A = sqlite3ExprListAppend(pParse,A, Z.pExpr);
1065: }
1066: %type case_else {Expr*}
1067: %destructor case_else {sqlite3ExprDelete(pParse->db, $$);}
1068: case_else(A) ::= ELSE expr(X). {A = X.pExpr;}
1069: case_else(A) ::= . {A = 0;}
1070: %type case_operand {Expr*}
1071: %destructor case_operand {sqlite3ExprDelete(pParse->db, $$);}
1072: case_operand(A) ::= expr(X). {A = X.pExpr;}
1073: case_operand(A) ::= . {A = 0;}
1074:
1075: %type exprlist {ExprList*}
1076: %destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);}
1077: %type nexprlist {ExprList*}
1078: %destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);}
1079:
1080: exprlist(A) ::= nexprlist(X). {A = X;}
1081: exprlist(A) ::= . {A = 0;}
1082: nexprlist(A) ::= nexprlist(X) COMMA expr(Y).
1083: {A = sqlite3ExprListAppend(pParse,X,Y.pExpr);}
1084: nexprlist(A) ::= expr(Y).
1085: {A = sqlite3ExprListAppend(pParse,0,Y.pExpr);}
1086:
1087:
1088: ///////////////////////////// The CREATE INDEX command ///////////////////////
1089: //
1090: cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)
1091: ON nm(Y) LP idxlist(Z) RP(E). {
1092: sqlite3CreateIndex(pParse, &X, &D,
1093: sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U,
1094: &S, &E, SQLITE_SO_ASC, NE);
1095: }
1096:
1097: %type uniqueflag {int}
1098: uniqueflag(A) ::= UNIQUE. {A = OE_Abort;}
1099: uniqueflag(A) ::= . {A = OE_None;}
1100:
1101: %type idxlist {ExprList*}
1102: %destructor idxlist {sqlite3ExprListDelete(pParse->db, $$);}
1103: %type idxlist_opt {ExprList*}
1104: %destructor idxlist_opt {sqlite3ExprListDelete(pParse->db, $$);}
1105:
1106: idxlist_opt(A) ::= . {A = 0;}
1107: idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;}
1108: idxlist(A) ::= idxlist(X) COMMA nm(Y) collate(C) sortorder(Z). {
1109: Expr *p = 0;
1110: if( C.n>0 ){
1111: p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
1112: sqlite3ExprSetCollByToken(pParse, p, &C);
1113: }
1114: A = sqlite3ExprListAppend(pParse,X, p);
1115: sqlite3ExprListSetName(pParse,A,&Y,1);
1116: sqlite3ExprListCheckLength(pParse, A, "index");
1117: if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
1118: }
1119: idxlist(A) ::= nm(Y) collate(C) sortorder(Z). {
1120: Expr *p = 0;
1121: if( C.n>0 ){
1122: p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
1123: sqlite3ExprSetCollByToken(pParse, p, &C);
1124: }
1125: A = sqlite3ExprListAppend(pParse,0, p);
1126: sqlite3ExprListSetName(pParse, A, &Y, 1);
1127: sqlite3ExprListCheckLength(pParse, A, "index");
1128: if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;
1129: }
1130:
1131: %type collate {Token}
1132: collate(C) ::= . {C.z = 0; C.n = 0;}
1133: collate(C) ::= COLLATE ids(X). {C = X;}
1134:
1135:
1136: ///////////////////////////// The DROP INDEX command /////////////////////////
1137: //
1138: cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);}
1139:
1140: ///////////////////////////// The VACUUM command /////////////////////////////
1141: //
1142: %ifndef SQLITE_OMIT_VACUUM
1143: %ifndef SQLITE_OMIT_ATTACH
1144: cmd ::= VACUUM. {sqlite3Vacuum(pParse);}
1145: cmd ::= VACUUM nm. {sqlite3Vacuum(pParse);}
1146: %endif SQLITE_OMIT_ATTACH
1147: %endif SQLITE_OMIT_VACUUM
1148:
1149: ///////////////////////////// The PRAGMA command /////////////////////////////
1150: //
1151: %ifndef SQLITE_OMIT_PRAGMA
1152: cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);}
1153: cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
1154: cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
1155: cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y).
1156: {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
1157: cmd ::= PRAGMA nm(X) dbnm(Z) LP minus_num(Y) RP.
1158: {sqlite3Pragma(pParse,&X,&Z,&Y,1);}
1159:
1160: nmnum(A) ::= plus_num(X). {A = X;}
1161: nmnum(A) ::= nm(X). {A = X;}
1162: nmnum(A) ::= ON(X). {A = X;}
1163: nmnum(A) ::= DELETE(X). {A = X;}
1164: nmnum(A) ::= DEFAULT(X). {A = X;}
1165: %endif SQLITE_OMIT_PRAGMA
1166: plus_num(A) ::= plus_opt number(X). {A = X;}
1167: minus_num(A) ::= MINUS number(X). {A = X;}
1168: number(A) ::= INTEGER|FLOAT(X). {A = X;}
1169: plus_opt ::= PLUS.
1170: plus_opt ::= .
1171:
1172: //////////////////////////// The CREATE TRIGGER command /////////////////////
1173:
1174: %ifndef SQLITE_OMIT_TRIGGER
1175:
1176: cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
1177: Token all;
1178: all.z = A.z;
1179: all.n = (int)(Z.z - A.z) + Z.n;
1180: sqlite3FinishTrigger(pParse, S, &all);
1181: }
1182:
1183: trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z)
1184: trigger_time(C) trigger_event(D)
1185: ON fullname(E) foreach_clause when_clause(G). {
1186: sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR);
1187: A = (Z.n==0?B:Z);
1188: }
1189:
1190: %type trigger_time {int}
1191: trigger_time(A) ::= BEFORE. { A = TK_BEFORE; }
1192: trigger_time(A) ::= AFTER. { A = TK_AFTER; }
1193: trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
1194: trigger_time(A) ::= . { A = TK_BEFORE; }
1195:
1196: %type trigger_event {struct TrigEvent}
1197: %destructor trigger_event {sqlite3IdListDelete(pParse->db, $$.b);}
1198: trigger_event(A) ::= DELETE|INSERT(OP). {A.a = @OP; A.b = 0;}
1199: trigger_event(A) ::= UPDATE(OP). {A.a = @OP; A.b = 0;}
1200: trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X;}
1201:
1202: foreach_clause ::= .
1203: foreach_clause ::= FOR EACH ROW.
1204:
1205: %type when_clause {Expr*}
1206: %destructor when_clause {sqlite3ExprDelete(pParse->db, $$);}
1207: when_clause(A) ::= . { A = 0; }
1208: when_clause(A) ::= WHEN expr(X). { A = X.pExpr; }
1209:
1210: %type trigger_cmd_list {TriggerStep*}
1211: %destructor trigger_cmd_list {sqlite3DeleteTriggerStep(pParse->db, $$);}
1212: trigger_cmd_list(A) ::= trigger_cmd_list(Y) trigger_cmd(X) SEMI. {
1213: assert( Y!=0 );
1214: Y->pLast->pNext = X;
1215: Y->pLast = X;
1216: A = Y;
1217: }
1218: trigger_cmd_list(A) ::= trigger_cmd(X) SEMI. {
1219: assert( X!=0 );
1220: X->pLast = X;
1221: A = X;
1222: }
1223:
1224: // Disallow qualified table names on INSERT, UPDATE, and DELETE statements
1225: // within a trigger. The table to INSERT, UPDATE, or DELETE is always in
1226: // the same database as the table that the trigger fires on.
1227: //
1228: %type trnm {Token}
1229: trnm(A) ::= nm(X). {A = X;}
1230: trnm(A) ::= nm DOT nm(X). {
1231: A = X;
1232: sqlite3ErrorMsg(pParse,
1233: "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
1234: "statements within triggers");
1235: }
1236:
1237: // Disallow the INDEX BY and NOT INDEXED clauses on UPDATE and DELETE
1238: // statements within triggers. We make a specific error message for this
1239: // since it is an exception to the default grammar rules.
1240: //
1241: tridxby ::= .
1242: tridxby ::= INDEXED BY nm. {
1243: sqlite3ErrorMsg(pParse,
1244: "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
1245: "within triggers");
1246: }
1247: tridxby ::= NOT INDEXED. {
1248: sqlite3ErrorMsg(pParse,
1249: "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
1250: "within triggers");
1251: }
1252:
1253:
1254:
1255: %type trigger_cmd {TriggerStep*}
1256: %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);}
1257: // UPDATE
1258: trigger_cmd(A) ::=
1259: UPDATE orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z).
1260: { A = sqlite3TriggerUpdateStep(pParse->db, &X, Y, Z, R); }
1261:
1262: // INSERT
1263: trigger_cmd(A) ::=
1264: insert_cmd(R) INTO trnm(X) inscollist_opt(F) VALUES LP itemlist(Y) RP.
1265: {A = sqlite3TriggerInsertStep(pParse->db, &X, F, Y, 0, R);}
1266:
1267: trigger_cmd(A) ::= insert_cmd(R) INTO trnm(X) inscollist_opt(F) select(S).
1268: {A = sqlite3TriggerInsertStep(pParse->db, &X, F, 0, S, R);}
1269:
1270: // DELETE
1271: trigger_cmd(A) ::= DELETE FROM trnm(X) tridxby where_opt(Y).
1272: {A = sqlite3TriggerDeleteStep(pParse->db, &X, Y);}
1273:
1274: // SELECT
1275: trigger_cmd(A) ::= select(X). {A = sqlite3TriggerSelectStep(pParse->db, X); }
1276:
1277: // The special RAISE expression that may occur in trigger programs
1278: expr(A) ::= RAISE(X) LP IGNORE RP(Y). {
1279: A.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
1280: if( A.pExpr ){
1281: A.pExpr->affinity = OE_Ignore;
1282: }
1283: A.zStart = X.z;
1284: A.zEnd = &Y.z[Y.n];
1285: }
1286: expr(A) ::= RAISE(X) LP raisetype(T) COMMA nm(Z) RP(Y). {
1287: A.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &Z);
1288: if( A.pExpr ) {
1289: A.pExpr->affinity = (char)T;
1290: }
1291: A.zStart = X.z;
1292: A.zEnd = &Y.z[Y.n];
1293: }
1294: %endif !SQLITE_OMIT_TRIGGER
1295:
1296: %type raisetype {int}
1297: raisetype(A) ::= ROLLBACK. {A = OE_Rollback;}
1298: raisetype(A) ::= ABORT. {A = OE_Abort;}
1299: raisetype(A) ::= FAIL. {A = OE_Fail;}
1300:
1301:
1302: //////////////////////// DROP TRIGGER statement //////////////////////////////
1303: %ifndef SQLITE_OMIT_TRIGGER
1304: cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
1305: sqlite3DropTrigger(pParse,X,NOERR);
1306: }
1307: %endif !SQLITE_OMIT_TRIGGER
1308:
1309: //////////////////////// ATTACH DATABASE file AS name /////////////////////////
1310: %ifndef SQLITE_OMIT_ATTACH
1311: cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). {
1312: sqlite3Attach(pParse, F.pExpr, D.pExpr, K);
1313: }
1314: cmd ::= DETACH database_kw_opt expr(D). {
1315: sqlite3Detach(pParse, D.pExpr);
1316: }
1317:
1318: %type key_opt {Expr*}
1319: %destructor key_opt {sqlite3ExprDelete(pParse->db, $$);}
1320: key_opt(A) ::= . { A = 0; }
1321: key_opt(A) ::= KEY expr(X). { A = X.pExpr; }
1322:
1323: database_kw_opt ::= DATABASE.
1324: database_kw_opt ::= .
1325: %endif SQLITE_OMIT_ATTACH
1326:
1327: ////////////////////////// REINDEX collation //////////////////////////////////
1328: %ifndef SQLITE_OMIT_REINDEX
1329: cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);}
1330: cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);}
1331: %endif SQLITE_OMIT_REINDEX
1332:
1333: /////////////////////////////////// ANALYZE ///////////////////////////////////
1334: %ifndef SQLITE_OMIT_ANALYZE
1335: cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);}
1336: cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);}
1337: %endif
1338:
1339: //////////////////////// ALTER TABLE table ... ////////////////////////////////
1340: %ifndef SQLITE_OMIT_ALTERTABLE
1341: cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). {
1342: sqlite3AlterRenameTable(pParse,X,&Z);
1343: }
1344: cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column(Y). {
1345: sqlite3AlterFinishAddColumn(pParse, &Y);
1346: }
1347: add_column_fullname ::= fullname(X). {
1348: pParse->db->lookaside.bEnabled = 0;
1349: sqlite3AlterBeginAddColumn(pParse, X);
1350: }
1351: kwcolumn_opt ::= .
1352: kwcolumn_opt ::= COLUMNKW.
1353: %endif SQLITE_OMIT_ALTERTABLE
1354:
1355: //////////////////////// CREATE VIRTUAL TABLE ... /////////////////////////////
1356: %ifndef SQLITE_OMIT_VIRTUALTABLE
1357: cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);}
1358: cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);}
1359: create_vtab ::= createkw VIRTUAL TABLE nm(X) dbnm(Y) USING nm(Z). {
1360: sqlite3VtabBeginParse(pParse, &X, &Y, &Z);
1361: }
1362: vtabarglist ::= vtabarg.
1363: vtabarglist ::= vtabarglist COMMA vtabarg.
1364: vtabarg ::= . {sqlite3VtabArgInit(pParse);}
1365: vtabarg ::= vtabarg vtabargtoken.
1366: vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);}
1367: vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);}
1368: lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);}
1369: anylist ::= .
1370: anylist ::= anylist LP anylist RP.
1371: anylist ::= anylist ANY.
1372: %endif SQLITE_OMIT_VIRTUALTABLE
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.y CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src