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 5 : if( pParse->zErrMsg==0 ){
25 3 : if( TOKEN.z[0] ){
26 3 : sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
27 : }else{
28 0 : 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 1496 : cmdx ::= cmd. { sqliteExec(pParse); }
73 0 : explain ::= EXPLAIN. { sqliteBeginParse(pParse, 1); }
74 1501 : explain ::= . { sqliteBeginParse(pParse, 0); }
75 :
76 : ///////////////////// Begin and end transactions. ////////////////////////////
77 : //
78 :
79 3 : cmd ::= BEGIN trans_opt onconf(R). {sqliteBeginTransaction(pParse,R);}
80 : trans_opt ::= .
81 : trans_opt ::= TRANSACTION.
82 : trans_opt ::= TRANSACTION nm.
83 1 : cmd ::= COMMIT trans_opt. {sqliteCommitTransaction(pParse);}
84 : cmd ::= END trans_opt. {sqliteCommitTransaction(pParse);}
85 2 : 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 398 : sqliteStartTable(pParse,&X,&Y,T,0);
92 : }
93 : %type temp {int}
94 151 : temp(A) ::= TEMP. {A = 1;}
95 772 : temp(A) ::= . {A = 0;}
96 : create_table_args ::= LP columnlist conslist_opt RP(X). {
97 398 : sqliteEndTable(pParse,&X,0);
98 : }
99 : create_table_args ::= AS select(S). {
100 0 : sqliteEndTable(pParse,0,S);
101 0 : 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 1716 : 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 5400 : 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 1619 : type ::= typename(X). {sqliteAddColumnType(pParse,&X,&X);}
161 83 : type ::= typename(X) LP signed RP(Y). {sqliteAddColumnType(pParse,&X,&Y);}
162 : type ::= typename(X) LP signed COMMA signed RP(Y).
163 0 : {sqliteAddColumnType(pParse,&X,&Y);}
164 : %type typename {Token}
165 2004 : typename(A) ::= ids(X). {A = X;}
166 2 : typename(A) ::= typename(X) ids. {A = X;}
167 : %type signed {int}
168 85 : signed(A) ::= INTEGER(X). { A = atoi(X.z); }
169 : signed(A) ::= PLUS INTEGER(X). { A = atoi(X.z); }
170 0 : signed(A) ::= MINUS INTEGER(X). { A = -atoi(X.z); }
171 : carglist ::= carglist carg.
172 : carglist ::= .
173 : carg ::= CONSTRAINT nm ccons.
174 : carg ::= ccons.
175 0 : 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 0 : 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 42 : ccons ::= NOT NULL onconf(R). {sqliteAddNotNull(pParse, R);}
190 43 : ccons ::= PRIMARY KEY sortorder onconf(R). {sqliteAddPrimaryKey(pParse,0,R);}
191 5 : 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 0 : {sqliteCreateForeignKey(pParse,0,&T,TA,R);}
195 0 : ccons ::= defer_subclause(D). {sqliteDeferForeignKey(pParse,D);}
196 : ccons ::= COLLATE id(C). {
197 0 : 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 0 : refargs(A) ::= . { A = OE_Restrict * 0x010101; }
207 0 : refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; }
208 : %type refarg {struct {int value; int mask;}}
209 0 : refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }
210 0 : refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }
211 0 : refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }
212 0 : refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; }
213 : %type refact {int}
214 0 : refact(A) ::= SET NULL. { A = OE_SetNull; }
215 0 : refact(A) ::= SET DEFAULT. { A = OE_SetDflt; }
216 0 : refact(A) ::= CASCADE. { A = OE_Cascade; }
217 0 : refact(A) ::= RESTRICT. { A = OE_Restrict; }
218 : %type defer_subclause {int}
219 261 : 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 2 : {sqliteAddPrimaryKey(pParse,X,R);}
237 : tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
238 0 : {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 0 : sqliteCreateForeignKey(pParse, FA, &T, TA, R);
243 0 : 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 358 : onconf(A) ::= . { A = OE_Default; }
256 0 : onconf(A) ::= ON CONFLICT resolvetype(X). { A = X; }
257 : orconf(A) ::= . { A = OE_Default; }
258 : orconf(A) ::= OR resolvetype(X). { A = X; }
259 0 : resolvetype(A) ::= ROLLBACK. { A = OE_Rollback; }
260 0 : resolvetype(A) ::= ABORT. { A = OE_Abort; }
261 0 : resolvetype(A) ::= FAIL. { A = OE_Fail; }
262 0 : resolvetype(A) ::= IGNORE. { A = OE_Ignore; }
263 0 : resolvetype(A) ::= REPLACE. { A = OE_Replace; }
264 :
265 : ////////////////////////// The DROP TABLE /////////////////////////////////////
266 : //
267 297 : 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 0 : sqliteCreateView(pParse, &X, &Y, S, T);
273 : }
274 : cmd ::= DROP VIEW nm(X). {
275 0 : sqliteDropTable(pParse, &X, 1);
276 : }
277 :
278 : //////////////////////// The SELECT statement /////////////////////////////////
279 : //
280 : cmd ::= select(X). {
281 525 : sqliteSelect(pParse, X, SRT_Callback, 0, 0, 0, 0);
282 525 : sqliteSelectDelete(X);
283 : }
284 :
285 : %type select {Select*}
286 0 : %destructor select {sqliteSelectDelete($$);}
287 : %type oneselect {Select*}
288 : %destructor oneselect {sqliteSelectDelete($$);}
289 :
290 525 : select(A) ::= oneselect(X). {A = X;}
291 : select(A) ::= select(X) multiselect_op(Y) oneselect(Z). {
292 0 : if( Z ){
293 0 : Z->op = Y;
294 0 : Z->pPrior = X;
295 : }
296 0 : A = Z;
297 : }
298 : %type multiselect_op {int}
299 0 : multiselect_op(A) ::= UNION. {A = TK_UNION;}
300 0 : multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}
301 0 : multiselect_op(A) ::= INTERSECT. {A = TK_INTERSECT;}
302 0 : 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 525 : 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 0 : %destructor selcollist {sqliteExprListDelete($$);}
323 : %type sclp {ExprList*}
324 : %destructor sclp {sqliteExprListDelete($$);}
325 1290 : sclp(A) ::= selcollist(X) COMMA. {A = X;}
326 1566 : sclp(A) ::= . {A = 0;}
327 : selcollist(A) ::= sclp(P) expr(X) as(Y). {
328 1750 : A = sqliteExprListAppend(P,X,Y.n?&Y:0);
329 : }
330 : selcollist(A) ::= sclp(P) STAR. {
331 65 : A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0);
332 : }
333 : selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
334 0 : Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0);
335 0 : Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X);
336 0 : 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 22 : as(X) ::= AS nm(Y). { X = Y; }
344 : as(X) ::= ids(Y). { X = Y; }
345 2255 : 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 0 : %destructor from {sqliteSrcListDelete($$);}
354 :
355 : // A complete FROM clause.
356 : //
357 8 : from(A) ::= . {A = sqliteMalloc(sizeof(*A));}
358 517 : 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 10 : A = X;
365 10 : if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y;
366 : }
367 517 : stl_prefix(A) ::= . {A = 0;}
368 : seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). {
369 527 : A = sqliteSrcListAppend(X,&Y,&D);
370 527 : if( Z.n ) sqliteSrcListAddAlias(A,&Z);
371 527 : if( N ){
372 8 : if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; }
373 0 : else { sqliteExprDelete(N); }
374 : }
375 527 : if( U ){
376 0 : if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; }
377 0 : 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 0 : A = sqliteSrcListAppend(X,0,0);
383 0 : A->a[A->nSrc-1].pSelect = S;
384 0 : if( Z.n ) sqliteSrcListAddAlias(A,&Z);
385 0 : if( N ){
386 0 : if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; }
387 0 : else { sqliteExprDelete(N); }
388 : }
389 0 : if( U ){
390 0 : if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; }
391 0 : 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 0 : A = sqliteSelectNew(0,F,0,0,0,0,0,-1,0);
404 : }
405 :
406 : %type dbnm {Token}
407 491 : 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 2 : joinop(X) ::= COMMA. { X = JT_INNER; }
413 : joinop(X) ::= JOIN. { X = JT_INNER; }
414 8 : joinop(X) ::= JOIN_KW(A) JOIN. { X = sqliteJoinType(pParse,&A,0,0); }
415 0 : 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 0 : { X = sqliteJoinType(pParse,&A,&B,&C); }
418 :
419 : %type on_opt {Expr*}
420 : %destructor on_opt {sqliteExprDelete($$);}
421 104 : on_opt(N) ::= ON expr(E). {N = E;}
422 1507 : on_opt(N) ::= . {N = 0;}
423 :
424 : %type using_opt {IdList*}
425 : %destructor using_opt {sqliteIdListDelete($$);}
426 45 : using_opt(U) ::= USING LP idxlist(L) RP. {U = L;}
427 743 : 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 9 : orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
439 : sortlist(A) ::= sortlist(X) COMMA sortitem(Y) collate(C) sortorder(Z). {
440 0 : A = sqliteExprListAppend(X,Y,0);
441 0 : if( A ) A->a[A->nExpr-1].sortOrder = C+Z;
442 : }
443 : sortlist(A) ::= sortitem(Y) collate(C) sortorder(Z). {
444 9 : A = sqliteExprListAppend(0,Y,0);
445 9 : 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 54 : sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}
453 0 : sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}
454 : sortorder(A) ::= . {A = SQLITE_SO_ASC;}
455 9 : collate(C) ::= . {C = SQLITE_SO_UNK;}
456 0 : 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 523 : limit_opt(A) ::= . {A.limit = -1; A.offset = 0;}
470 2 : limit_opt(A) ::= LIMIT signed(X). {A.limit = X; A.offset = 0;}
471 : limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y).
472 0 : {A.limit = X; A.offset = Y;}
473 : limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y).
474 0 : {A.limit = Y; A.offset = X;}
475 :
476 : /////////////////////////// The DELETE statement /////////////////////////////
477 : //
478 : cmd ::= DELETE FROM nm(X) dbnm(D) where_opt(Y). {
479 3 : 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 2 : {sqliteUpdate(pParse,sqliteSrcListAppend(0,&X,&D),Y,Z,R);}
495 :
496 : setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).
497 0 : {A = sqliteExprListAppend(Z,Y,&X);}
498 2 : 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 261 : {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 0 : {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 0 : insert_cmd(A) ::= REPLACE. {A = OE_Replace;}
511 :
512 :
513 : %type itemlist {ExprList*}
514 : %destructor itemlist {sqliteExprListDelete($$);}
515 :
516 275 : itemlist(A) ::= itemlist(X) COMMA expr(Y). {A = sqliteExprListAppend(X,Y,0);}
517 275 : 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 29 : inscollist(A) ::= inscollist(X) COMMA nm(Y). {A = sqliteIdListAppend(X,&Y);}
527 47 : inscollist(A) ::= nm(Y). {A = sqliteIdListAppend(0,&Y);}
528 :
529 : /////////////////////////// Expression Processing /////////////////////////////
530 : //
531 :
532 : %type expr {Expr*}
533 0 : %destructor expr {sqliteExprDelete($$);}
534 :
535 3 : expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); }
536 9 : expr(A) ::= NULL(X). {A = sqliteExpr(TK_NULL, 0, 0, &X);}
537 1480 : 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 43 : Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X);
541 43 : Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y);
542 43 : A = sqliteExpr(TK_DOT, temp1, temp2, 0);
543 : }
544 : expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
545 0 : Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X);
546 0 : Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y);
547 0 : Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &Z);
548 0 : Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0);
549 0 : A = sqliteExpr(TK_DOT, temp1, temp4, 0);
550 : }
551 470 : expr(A) ::= INTEGER(X). {A = sqliteExpr(TK_INTEGER, 0, 0, &X);}
552 0 : expr(A) ::= FLOAT(X). {A = sqliteExpr(TK_FLOAT, 0, 0, &X);}
553 438 : expr(A) ::= STRING(X). {A = sqliteExpr(TK_STRING, 0, 0, &X);}
554 : expr(A) ::= VARIABLE(X). {
555 0 : A = sqliteExpr(TK_VARIABLE, 0, 0, &X);
556 0 : if( A ) A->iTable = ++pParse->nVar;
557 : }
558 : expr(A) ::= ID(X) LP exprlist(Y) RP(E). {
559 14 : A = sqliteExprFunction(Y, &X);
560 14 : sqliteExprSpan(A,&X,&E);
561 : }
562 : expr(A) ::= ID(X) LP STAR RP(E). {
563 9 : A = sqliteExprFunction(0, &X);
564 9 : sqliteExprSpan(A,&X,&E);
565 : }
566 0 : expr(A) ::= expr(X) AND expr(Y). {A = sqliteExpr(TK_AND, X, Y, 0);}
567 3 : expr(A) ::= expr(X) OR expr(Y). {A = sqliteExpr(TK_OR, X, Y, 0);}
568 4 : expr(A) ::= expr(X) LT expr(Y). {A = sqliteExpr(TK_LT, X, Y, 0);}
569 3 : expr(A) ::= expr(X) GT expr(Y). {A = sqliteExpr(TK_GT, X, Y, 0);}
570 0 : expr(A) ::= expr(X) LE expr(Y). {A = sqliteExpr(TK_LE, X, Y, 0);}
571 0 : expr(A) ::= expr(X) GE expr(Y). {A = sqliteExpr(TK_GE, X, Y, 0);}
572 1 : expr(A) ::= expr(X) NE expr(Y). {A = sqliteExpr(TK_NE, X, Y, 0);}
573 66 : expr(A) ::= expr(X) EQ expr(Y). {A = sqliteExpr(TK_EQ, X, Y, 0);}
574 0 : expr(A) ::= expr(X) BITAND expr(Y). {A = sqliteExpr(TK_BITAND, X, Y, 0);}
575 0 : expr(A) ::= expr(X) BITOR expr(Y). {A = sqliteExpr(TK_BITOR, X, Y, 0);}
576 0 : expr(A) ::= expr(X) LSHIFT expr(Y). {A = sqliteExpr(TK_LSHIFT, X, Y, 0);}
577 0 : 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 0 : ExprList *pList = sqliteExprListAppend(0, Y, 0);
580 0 : pList = sqliteExprListAppend(pList, X, 0);
581 0 : A = sqliteExprFunction(pList, 0);
582 0 : if( A ) A->op = OP;
583 0 : sqliteExprSpan(A, &X->span, &Y->span);
584 : }
585 : expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] {
586 0 : ExprList *pList = sqliteExprListAppend(0, Y, 0);
587 0 : pList = sqliteExprListAppend(pList, X, 0);
588 0 : A = sqliteExprFunction(pList, 0);
589 0 : if( A ) A->op = OP;
590 0 : A = sqliteExpr(TK_NOT, A, 0, 0);
591 0 : sqliteExprSpan(A,&X->span,&Y->span);
592 : }
593 : %type likeop {int}
594 0 : likeop(A) ::= LIKE. {A = TK_LIKE;}
595 0 : likeop(A) ::= GLOB. {A = TK_GLOB;}
596 0 : expr(A) ::= expr(X) PLUS expr(Y). {A = sqliteExpr(TK_PLUS, X, Y, 0);}
597 0 : expr(A) ::= expr(X) MINUS expr(Y). {A = sqliteExpr(TK_MINUS, X, Y, 0);}
598 0 : expr(A) ::= expr(X) STAR expr(Y). {A = sqliteExpr(TK_STAR, X, Y, 0);}
599 0 : expr(A) ::= expr(X) SLASH expr(Y). {A = sqliteExpr(TK_SLASH, X, Y, 0);}
600 0 : expr(A) ::= expr(X) REM expr(Y). {A = sqliteExpr(TK_REM, X, Y, 0);}
601 0 : expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);}
602 : expr(A) ::= expr(X) ISNULL(E). {
603 0 : A = sqliteExpr(TK_ISNULL, X, 0, 0);
604 0 : sqliteExprSpan(A,&X->span,&E);
605 : }
606 : expr(A) ::= expr(X) IS NULL(E). {
607 3 : A = sqliteExpr(TK_ISNULL, X, 0, 0);
608 3 : sqliteExprSpan(A,&X->span,&E);
609 : }
610 : expr(A) ::= expr(X) NOTNULL(E). {
611 0 : A = sqliteExpr(TK_NOTNULL, X, 0, 0);
612 0 : sqliteExprSpan(A,&X->span,&E);
613 : }
614 : expr(A) ::= expr(X) NOT NULL(E). {
615 0 : A = sqliteExpr(TK_NOTNULL, X, 0, 0);
616 0 : sqliteExprSpan(A,&X->span,&E);
617 : }
618 : expr(A) ::= expr(X) IS NOT NULL(E). {
619 0 : A = sqliteExpr(TK_NOTNULL, X, 0, 0);
620 0 : sqliteExprSpan(A,&X->span,&E);
621 : }
622 : expr(A) ::= NOT(B) expr(X). {
623 0 : A = sqliteExpr(TK_NOT, X, 0, 0);
624 0 : sqliteExprSpan(A,&B,&X->span);
625 : }
626 : expr(A) ::= BITNOT(B) expr(X). {
627 0 : A = sqliteExpr(TK_BITNOT, X, 0, 0);
628 0 : sqliteExprSpan(A,&B,&X->span);
629 : }
630 : expr(A) ::= MINUS(B) expr(X). [UMINUS] {
631 0 : A = sqliteExpr(TK_UMINUS, X, 0, 0);
632 0 : sqliteExprSpan(A,&B,&X->span);
633 : }
634 : expr(A) ::= PLUS(B) expr(X). [UPLUS] {
635 0 : A = sqliteExpr(TK_UPLUS, X, 0, 0);
636 0 : sqliteExprSpan(A,&B,&X->span);
637 : }
638 : expr(A) ::= LP(B) select(X) RP(E). {
639 0 : A = sqliteExpr(TK_SELECT, 0, 0, 0);
640 0 : if( A ) A->pSelect = X;
641 0 : sqliteExprSpan(A,&B,&E);
642 : }
643 : expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). {
644 0 : ExprList *pList = sqliteExprListAppend(0, X, 0);
645 0 : pList = sqliteExprListAppend(pList, Y, 0);
646 0 : A = sqliteExpr(TK_BETWEEN, W, 0, 0);
647 0 : if( A ) A->pList = pList;
648 0 : sqliteExprSpan(A,&W->span,&Y->span);
649 : }
650 : expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). {
651 0 : ExprList *pList = sqliteExprListAppend(0, X, 0);
652 0 : pList = sqliteExprListAppend(pList, Y, 0);
653 0 : A = sqliteExpr(TK_BETWEEN, W, 0, 0);
654 0 : if( A ) A->pList = pList;
655 0 : A = sqliteExpr(TK_NOT, A, 0, 0);
656 0 : sqliteExprSpan(A,&W->span,&Y->span);
657 : }
658 : expr(A) ::= expr(X) IN LP exprlist(Y) RP(E). {
659 0 : A = sqliteExpr(TK_IN, X, 0, 0);
660 0 : if( A ) A->pList = Y;
661 0 : sqliteExprSpan(A,&X->span,&E);
662 : }
663 : expr(A) ::= expr(X) IN LP select(Y) RP(E). {
664 0 : A = sqliteExpr(TK_IN, X, 0, 0);
665 0 : if( A ) A->pSelect = Y;
666 0 : sqliteExprSpan(A,&X->span,&E);
667 : }
668 : expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E). {
669 0 : A = sqliteExpr(TK_IN, X, 0, 0);
670 0 : if( A ) A->pList = Y;
671 0 : A = sqliteExpr(TK_NOT, A, 0, 0);
672 0 : sqliteExprSpan(A,&X->span,&E);
673 : }
674 : expr(A) ::= expr(X) NOT IN LP select(Y) RP(E). {
675 0 : A = sqliteExpr(TK_IN, X, 0, 0);
676 0 : if( A ) A->pSelect = Y;
677 0 : A = sqliteExpr(TK_NOT, A, 0, 0);
678 0 : sqliteExprSpan(A,&X->span,&E);
679 : }
680 : expr(A) ::= expr(X) IN nm(Y) dbnm(D). {
681 0 : SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
682 0 : A = sqliteExpr(TK_IN, X, 0, 0);
683 0 : if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0);
684 0 : sqliteExprSpan(A,&X->span,D.z?&D:&Y);
685 : }
686 : expr(A) ::= expr(X) NOT IN nm(Y) dbnm(D). {
687 0 : SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
688 0 : A = sqliteExpr(TK_IN, X, 0, 0);
689 0 : if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0);
690 0 : A = sqliteExpr(TK_NOT, A, 0, 0);
691 0 : 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 0 : A = sqliteExpr(TK_CASE, X, Z, 0);
698 0 : if( A ) A->pList = Y;
699 0 : 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 0 : A = sqliteExprListAppend(X, Y, 0);
705 0 : A = sqliteExprListAppend(A, Z, 0);
706 : }
707 : case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
708 0 : A = sqliteExprListAppend(0, Y, 0);
709 0 : 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 0 : SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
734 0 : if( U!=OE_None ) U = R;
735 0 : if( U==OE_Default) U = OE_Abort;
736 0 : sqliteCreateIndex(pParse, &X, pSrc, Z, U, &S, &E);
737 : }
738 :
739 : %type uniqueflag {int}
740 : uniqueflag(A) ::= UNIQUE. { A = OE_Abort; }
741 0 : uniqueflag(A) ::= . { A = OE_None; }
742 :
743 : %type idxlist {IdList*}
744 : %destructor idxlist {sqliteIdListDelete($$);}
745 : %type idxlist_opt {IdList*}
746 0 : %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 0 : 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 0 : {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,&Z,R);}
767 : cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y).
768 0 : {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,0,R);}
769 :
770 : ///////////////////////////// The VACUUM command /////////////////////////////
771 : //
772 0 : cmd ::= VACUUM. {sqliteVacuum(pParse,0);}
773 0 : cmd ::= VACUUM nm(X). {sqliteVacuum(pParse,&X);}
774 :
775 : ///////////////////////////// The PRAGMA command /////////////////////////////
776 : //
777 2 : cmd ::= PRAGMA ids(X) EQ nm(Y). {sqlitePragma(pParse,&X,&Y,0);}
778 2 : 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 0 : cmd ::= PRAGMA ids(X) EQ minus_num(Y). {sqlitePragma(pParse,&X,&Y,1);}
781 0 : cmd ::= PRAGMA ids(X) LP nm(Y) RP. {sqlitePragma(pParse,&X,&Y,0);}
782 0 : 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 0 : all.z = A.z;
795 0 : all.n = (Z.z - A.z) + Z.n;
796 0 : 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 0 : SrcList *pTab = sqliteSrcListAppend(0, &E, &DB);
802 0 : sqliteBeginTrigger(pParse, &B, C, D.a, D.b, pTab, F, G, T);
803 : }
804 :
805 : %type trigger_time {int}
806 0 : trigger_time(A) ::= BEFORE. { A = TK_BEFORE; }
807 0 : trigger_time(A) ::= AFTER. { A = TK_AFTER; }
808 0 : trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
809 : trigger_time(A) ::= . { A = TK_BEFORE; }
810 :
811 : %type trigger_event {struct TrigEvent}
812 0 : %destructor trigger_event {sqliteIdListDelete($$.b);}
813 0 : trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; }
814 0 : trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; }
815 0 : trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;}
816 0 : trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X; }
817 :
818 : %type foreach_clause {int}
819 0 : foreach_clause(A) ::= . { A = TK_ROW; }
820 : foreach_clause(A) ::= FOR EACH ROW. { A = TK_ROW; }
821 0 : foreach_clause(A) ::= FOR EACH STATEMENT. { A = TK_STATEMENT; }
822 :
823 : %type when_clause {Expr *}
824 0 : when_clause(A) ::= . { A = 0; }
825 0 : when_clause(A) ::= WHEN expr(X). { A = X; }
826 :
827 : %type trigger_cmd_list {TriggerStep *}
828 0 : %destructor trigger_cmd_list {sqliteDeleteTriggerStep($$);}
829 : trigger_cmd_list(A) ::= trigger_cmd(X) SEMI trigger_cmd_list(Y). {
830 0 : X->pNext = Y;
831 0 : A = X;
832 : }
833 0 : 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 0 : { 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 0 : {A = sqliteTriggerInsertStep(&X, F, Y, 0, R);}
845 :
846 : trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S).
847 0 : {A = sqliteTriggerInsertStep(&X, F, 0, S, R);}
848 :
849 : // DELETE
850 : trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y).
851 0 : {A = sqliteTriggerDeleteStep(&X, Y);}
852 :
853 : // SELECT
854 0 : 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 0 : A = sqliteExpr(TK_RAISE, 0, 0, 0);
859 0 : A->iColumn = OE_Ignore;
860 0 : sqliteExprSpan(A, &X, &Y);
861 : }
862 : expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y). {
863 0 : A = sqliteExpr(TK_RAISE, 0, 0, &Z);
864 0 : A->iColumn = OE_Rollback;
865 0 : sqliteExprSpan(A, &X, &Y);
866 : }
867 : expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y). {
868 0 : A = sqliteExpr(TK_RAISE, 0, 0, &Z);
869 0 : A->iColumn = OE_Abort;
870 0 : sqliteExprSpan(A, &X, &Y);
871 : }
872 : expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y). {
873 0 : A = sqliteExpr(TK_RAISE, 0, 0, &Z);
874 0 : A->iColumn = OE_Fail;
875 0 : sqliteExprSpan(A, &X, &Y);
876 : }
877 :
878 : //////////////////////// DROP TRIGGER statement //////////////////////////////
879 : cmd ::= DROP TRIGGER nm(X) dbnm(D). {
880 0 : 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 0 : sqliteAttach(pParse, &F, &D, &K);
886 : }
887 : %type key_opt {Token}
888 : key_opt(A) ::= USING ids(X). { A = X; }
889 0 : 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 0 : sqliteDetach(pParse, &D);
897 : }
|
