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