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$
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
onconf(R)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.
CREATE(X)90 create_table ::= CREATE(X) temp(T) TABLE nm(Y). {
91 sqliteStartTable(pParse,&X,&Y,T,0);
92 }
93 %type temp {int}
temp(A)94 temp(A) ::= TEMP. {A = 1;}
temp(A)95 temp(A) ::= . {A = 0;}
RP(X)96 create_table_args ::= LP columnlist conslist_opt RP(X). {
97 sqliteEndTable(pParse,&X,0);
98 }
select(S)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.
nm(X)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}
id(A)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}
ids(A)149 ids(A) ::= ID(X). {A = X;}
ids(A)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}
nm(A)155 nm(A) ::= ID(X). {A = X;}
nm(A)156 nm(A) ::= STRING(X). {A = X;}
nm(A)157 nm(A) ::= JOIN_KW(X). {A = X;}
158
159 type ::= .
typename(X)160 type ::= typename(X). {sqliteAddColumnType(pParse,&X,&X);}
typename(X)161 type ::= typename(X) LP signed RP(Y). {sqliteAddColumnType(pParse,&X,&Y);}
typename(X)162 type ::= typename(X) LP signed COMMA signed RP(Y).
163 {sqliteAddColumnType(pParse,&X,&Y);}
164 %type typename {Token}
typename(A)165 typename(A) ::= ids(X). {A = X;}
typename(A)166 typename(A) ::= typename(X) ids. {A = X;}
167 %type signed {int}
INTEGER(X)168 signed(A) ::= INTEGER(X). { A = atoi(X.z); }
INTEGER(X)169 signed(A) ::= PLUS INTEGER(X). { A = atoi(X.z); }
INTEGER(X)170 signed(A) ::= MINUS INTEGER(X). { A = -atoi(X.z); }
171 carglist ::= carglist carg.
172 carglist ::= .
173 carg ::= CONSTRAINT nm ccons.
174 carg ::= ccons.
STRING(X)175 carg ::= DEFAULT STRING(X). {sqliteAddDefaultValue(pParse,&X,0);}
ID(X)176 carg ::= DEFAULT ID(X). {sqliteAddDefaultValue(pParse,&X,0);}
INTEGER(X)177 carg ::= DEFAULT INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);}
INTEGER(X)178 carg ::= DEFAULT PLUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);}
INTEGER(X)179 carg ::= DEFAULT MINUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,1);}
FLOAT(X)180 carg ::= DEFAULT FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);}
FLOAT(X)181 carg ::= DEFAULT PLUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);}
FLOAT(X)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.
onconf(R)189 ccons ::= NOT NULL onconf(R). {sqliteAddNotNull(pParse, R);}
onconf(R)190 ccons ::= PRIMARY KEY sortorder onconf(R). {sqliteAddPrimaryKey(pParse,0,R);}
onconf(R)191 ccons ::= UNIQUE onconf(R). {sqliteCreateIndex(pParse,0,0,0,R,0,0);}
192 ccons ::= CHECK LP expr RP onconf.
nm(T)193 ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
194 {sqliteCreateForeignKey(pParse,0,&T,TA,R);}
defer_subclause(D)195 ccons ::= defer_subclause(D). {sqliteDeferForeignKey(pParse,D);}
id(C)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}
refargs(A)206 refargs(A) ::= . { A = OE_Restrict * 0x010101; }
refargs(A)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 }
898
