blob: 0e7aaf397d9472e20115de5229cb0cc16e52b33c [file] [log] [blame]
drh348784e2000-05-29 20:41:49 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh348784e2000-05-29 20:41:49 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh348784e2000-05-29 20:41:49 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drh348784e2000-05-29 20:41:49 +000010**
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**
drh55176252008-01-22 14:50:16 +000017** @(#) $Id: parse.y,v 1.239 2008/01/22 14:50:17 drh Exp $
drh348784e2000-05-29 20:41:49 +000018*/
drh487e2622005-06-25 18:42:14 +000019
20// All token codes are small integers with #defines that begin with "TK_"
drh348784e2000-05-29 20:41:49 +000021%token_prefix TK_
drh487e2622005-06-25 18:42:14 +000022
23// The type of the data attached to each token is Token. This is also the
24// default type for non-terminals.
25//
drh348784e2000-05-29 20:41:49 +000026%token_type {Token}
drhf57b14a2001-09-14 18:54:08 +000027%default_type {Token}
drh487e2622005-06-25 18:42:14 +000028
29// The generated parser function takes a 4th argument as follows:
drh348784e2000-05-29 20:41:49 +000030%extra_argument {Parse *pParse}
drh487e2622005-06-25 18:42:14 +000031
32// This code runs whenever there is a syntax error
33//
drh348784e2000-05-29 20:41:49 +000034%syntax_error {
drh86dac2b2006-05-25 12:17:31 +000035 if( !pParse->parseError ){
drh55176252008-01-22 14:50:16 +000036 assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */
37 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
drh86dac2b2006-05-25 12:17:31 +000038 pParse->parseError = 1;
drhb86ccfb2003-01-28 23:13:10 +000039 }
drh348784e2000-05-29 20:41:49 +000040}
drh8fc33452006-02-27 21:58:07 +000041%stack_overflow {
42 sqlite3ErrorMsg(pParse, "parser stack overflow");
drh86dac2b2006-05-25 12:17:31 +000043 pParse->parseError = 1;
drh8fc33452006-02-27 21:58:07 +000044}
drh487e2622005-06-25 18:42:14 +000045
46// The name of the generated procedure that implements the parser
47// is as follows:
danielk19774adee202004-05-08 08:23:19 +000048%name sqlite3Parser
drh487e2622005-06-25 18:42:14 +000049
50// The following text is included near the beginning of the C source
51// code file that implements the parser.
52//
drh348784e2000-05-29 20:41:49 +000053%include {
54#include "sqliteInt.h"
drh9bbca4c2001-11-06 04:00:18 +000055
56/*
drhad3cab52002-05-24 02:04:32 +000057** An instance of this structure holds information about the
58** LIMIT clause of a SELECT statement.
drh9bbca4c2001-11-06 04:00:18 +000059*/
drhad3cab52002-05-24 02:04:32 +000060struct LimitVal {
danielk1977a2dc3b12005-02-05 12:48:48 +000061 Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */
62 Expr *pOffset; /* The OFFSET expression. NULL if there is none */
drhad3cab52002-05-24 02:04:32 +000063};
danielk1977c3f9bad2002-05-15 08:30:12 +000064
65/*
drh2e3a1f12004-10-06 14:39:28 +000066** An instance of this structure is used to store the LIKE,
67** GLOB, NOT LIKE, and NOT GLOB operators.
68*/
69struct LikeOp {
drhb52076c2006-01-23 13:22:09 +000070 Token eOperator; /* "like" or "glob" or "regexp" */
drhb71090f2005-05-23 17:26:51 +000071 int not; /* True if the NOT keyword is present */
drh2e3a1f12004-10-06 14:39:28 +000072};
73
74/*
drhad3cab52002-05-24 02:04:32 +000075** An instance of the following structure describes the event of a
76** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
77** TK_DELETE, or TK_INSTEAD. If the event is of the form
78**
79** UPDATE ON (a,b,c)
80**
81** Then the "b" IdList records the list "a,b,c".
danielk1977c3f9bad2002-05-15 08:30:12 +000082*/
drhad3cab52002-05-24 02:04:32 +000083struct TrigEvent { int a; IdList * b; };
drhcaec2f12003-01-07 02:47:47 +000084
drh25d65432004-07-22 15:02:25 +000085/*
86** An instance of this structure holds the ATTACH key and the key type.
87*/
88struct AttachKey { int type; Token key; };
89
drhcaec2f12003-01-07 02:47:47 +000090} // end %include
drh348784e2000-05-29 20:41:49 +000091
drh826fb5a2004-02-14 23:59:57 +000092// Input is a single SQL command
drhc4a3c772001-04-04 11:48:57 +000093input ::= cmdlist.
drh094b2bb2002-03-13 18:54:07 +000094cmdlist ::= cmdlist ecmd.
drh826fb5a2004-02-14 23:59:57 +000095cmdlist ::= ecmd.
drh80242052004-06-09 00:48:12 +000096cmdx ::= cmd. { sqlite3FinishCoding(pParse); }
drhb7f91642004-10-31 02:22:47 +000097ecmd ::= SEMI.
98ecmd ::= explain cmdx SEMI.
danielk19774adee202004-05-08 08:23:19 +000099explain ::= . { sqlite3BeginParse(pParse, 0); }
drhb7f91642004-10-31 02:22:47 +0000100%ifndef SQLITE_OMIT_EXPLAIN
drhecc92422005-09-10 16:46:12 +0000101explain ::= EXPLAIN. { sqlite3BeginParse(pParse, 1); }
102explain ::= EXPLAIN QUERY PLAN. { sqlite3BeginParse(pParse, 2); }
drh154d4b22006-09-21 11:02:16 +0000103%endif SQLITE_OMIT_EXPLAIN
drh348784e2000-05-29 20:41:49 +0000104
drh382c0242001-10-06 16:33:02 +0000105///////////////////// Begin and end transactions. ////////////////////////////
drhc4a3c772001-04-04 11:48:57 +0000106//
drhfa86c412002-02-02 15:01:15 +0000107
drh684917c2004-10-05 02:41:42 +0000108cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);}
drhc4a3c772001-04-04 11:48:57 +0000109trans_opt ::= .
110trans_opt ::= TRANSACTION.
drh5ad1a6c2002-07-01 12:27:09 +0000111trans_opt ::= TRANSACTION nm.
drh684917c2004-10-05 02:41:42 +0000112%type transtype {int}
113transtype(A) ::= . {A = TK_DEFERRED;}
114transtype(A) ::= DEFERRED(X). {A = @X;}
115transtype(A) ::= IMMEDIATE(X). {A = @X;}
116transtype(A) ::= EXCLUSIVE(X). {A = @X;}
danielk19774adee202004-05-08 08:23:19 +0000117cmd ::= COMMIT trans_opt. {sqlite3CommitTransaction(pParse);}
118cmd ::= END trans_opt. {sqlite3CommitTransaction(pParse);}
119cmd ::= ROLLBACK trans_opt. {sqlite3RollbackTransaction(pParse);}
drhc4a3c772001-04-04 11:48:57 +0000120
drh382c0242001-10-06 16:33:02 +0000121///////////////////// The CREATE TABLE statement ////////////////////////////
drh348784e2000-05-29 20:41:49 +0000122//
123cmd ::= create_table create_table_args.
drh74161702006-02-24 02:53:49 +0000124create_table ::= CREATE temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {
danielk1977f1a381e2006-06-16 08:01:02 +0000125 sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);
drh969fa7c2002-02-18 18:30:32 +0000126}
drhfaa59552005-12-29 23:33:54 +0000127%type ifnotexists {int}
128ifnotexists(A) ::= . {A = 0;}
129ifnotexists(A) ::= IF NOT EXISTS. {A = 1;}
drhf57b3392001-10-08 13:22:32 +0000130%type temp {int}
danielk197753c0f742005-03-29 03:10:59 +0000131%ifndef SQLITE_OMIT_TEMPDB
drhd24cc422003-03-27 12:51:24 +0000132temp(A) ::= TEMP. {A = 1;}
drh154d4b22006-09-21 11:02:16 +0000133%endif SQLITE_OMIT_TEMPDB
drhd24cc422003-03-27 12:51:24 +0000134temp(A) ::= . {A = 0;}
danielk197719a8e7e2005-03-17 05:03:38 +0000135create_table_args ::= LP columnlist conslist_opt(X) RP(Y). {
136 sqlite3EndTable(pParse,&X,&Y,0);
drh969fa7c2002-02-18 18:30:32 +0000137}
138create_table_args ::= AS select(S). {
danielk197719a8e7e2005-03-17 05:03:38 +0000139 sqlite3EndTable(pParse,0,0,S);
danielk19774adee202004-05-08 08:23:19 +0000140 sqlite3SelectDelete(S);
drh969fa7c2002-02-18 18:30:32 +0000141}
drh348784e2000-05-29 20:41:49 +0000142columnlist ::= columnlist COMMA column.
143columnlist ::= column.
144
drh487e2622005-06-25 18:42:14 +0000145// A "column" is a complete description of a single column in a
146// CREATE TABLE statement. This includes the column name, its
147// datatype, and other keywords such as PRIMARY KEY, UNIQUE, REFERENCES,
148// NOT NULL and so forth.
drh348784e2000-05-29 20:41:49 +0000149//
danielk197719a8e7e2005-03-17 05:03:38 +0000150column(A) ::= columnid(X) type carglist. {
151 A.z = X.z;
152 A.n = (pParse->sLastToken.z-X.z) + pParse->sLastToken.n;
153}
154columnid(A) ::= nm(X). {
155 sqlite3AddColumn(pParse,&X);
156 A = X;
157}
158
drhc4a3c772001-04-04 11:48:57 +0000159
160// An IDENTIFIER can be a generic identifier, or one of several
161// keywords. Any non-standard keyword can also be an identifier.
drhc4a3c772001-04-04 11:48:57 +0000162//
drh982cef72000-05-30 16:27:03 +0000163%type id {Token}
drhf18543c2002-03-30 15:26:50 +0000164id(A) ::= ID(X). {A = X;}
drh0bd1f4e2002-06-06 18:54:39 +0000165
drh34e33bb2002-06-06 19:04:16 +0000166// The following directive causes tokens ABORT, AFTER, ASC, etc. to
167// fallback to ID if they will not parse as their original value.
168// This obviates the need for the "id" nonterminal.
169//
drh319e4e72003-09-30 01:54:13 +0000170%fallback ID
drh9f18e8a2005-07-08 12:13:04 +0000171 ABORT AFTER ANALYZE ASC ATTACH BEFORE BEGIN CASCADE CAST CONFLICT
drh684917c2004-10-05 02:41:42 +0000172 DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR
drhca5557f2007-05-04 18:30:40 +0000173 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH PLAN
drh4f5c74e2007-05-04 14:14:45 +0000174 QUERY KEY OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW
drhe09daa92006-06-10 13:29:31 +0000175 TEMP TRIGGER VACUUM VIEW VIRTUAL
drhb7f91642004-10-31 02:22:47 +0000176%ifdef SQLITE_OMIT_COMPOUND_SELECT
177 EXCEPT INTERSECT UNION
drh154d4b22006-09-21 11:02:16 +0000178%endif SQLITE_OMIT_COMPOUND_SELECT
drha0733842005-12-29 01:11:36 +0000179 REINDEX RENAME CTIME_KW IF
drhb7f91642004-10-31 02:22:47 +0000180 .
drhe09daa92006-06-10 13:29:31 +0000181%wildcard ANY.
drhc4a3c772001-04-04 11:48:57 +0000182
drh2d3917d2004-02-22 16:27:00 +0000183// Define operator precedence early so that this is the first occurance
184// of the operator tokens in the grammer. Keeping the operators together
185// causes them to be assigned integer values that are close together,
186// which keeps parser tables smaller.
187//
drhf2bc0132004-10-04 13:19:23 +0000188// The token values assigned to these symbols is determined by the order
189// in which lemon first sees them. It must be the case that ISNULL/NOTNULL,
190// NE/EQ, GT/LE, and GE/LT are separated by only a single value. See
191// the sqlite3ExprIfFalse() routine for additional information on this
192// constraint.
193//
drh2d3917d2004-02-22 16:27:00 +0000194%left OR.
195%left AND.
196%right NOT.
drh03bea702006-06-13 15:37:26 +0000197%left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
drh9a432672004-10-04 13:38:09 +0000198%left GT LE LT GE.
danielk19777c6303c2004-11-17 16:41:29 +0000199%right ESCAPE.
drh2d3917d2004-02-22 16:27:00 +0000200%left BITAND BITOR LSHIFT RSHIFT.
201%left PLUS MINUS.
202%left STAR SLASH REM.
drha34001c2007-02-02 12:44:37 +0000203%left CONCAT.
204%left COLLATE.
drh2d3917d2004-02-22 16:27:00 +0000205%right UMINUS UPLUS BITNOT.
206
drhc4a3c772001-04-04 11:48:57 +0000207// And "ids" is an identifer-or-string.
208//
209%type ids {Token}
drhfd405312005-11-06 04:06:59 +0000210ids(A) ::= ID|STRING(X). {A = X;}
drhc4a3c772001-04-04 11:48:57 +0000211
drh5ad1a6c2002-07-01 12:27:09 +0000212// The name of a column or table can be any of the following:
213//
214%type nm {Token}
215nm(A) ::= ID(X). {A = X;}
216nm(A) ::= STRING(X). {A = X;}
217nm(A) ::= JOIN_KW(X). {A = X;}
218
drh487e2622005-06-25 18:42:14 +0000219// A typetoken is really one or more tokens that form a type name such
220// as can be found after the column name in a CREATE TABLE statement.
221// Multiple tokens are concatenated to form the value of the typetoken.
222//
223%type typetoken {Token}
drh382c0242001-10-06 16:33:02 +0000224type ::= .
drh487e2622005-06-25 18:42:14 +0000225type ::= typetoken(X). {sqlite3AddColumnType(pParse,&X);}
226typetoken(A) ::= typename(X). {A = X;}
227typetoken(A) ::= typename(X) LP signed RP(Y). {
228 A.z = X.z;
229 A.n = &Y.z[Y.n] - X.z;
230}
231typetoken(A) ::= typename(X) LP signed COMMA signed RP(Y). {
232 A.z = X.z;
233 A.n = &Y.z[Y.n] - X.z;
234}
drh382c0242001-10-06 16:33:02 +0000235%type typename {Token}
drhe2ea40d2004-05-20 12:41:19 +0000236typename(A) ::= ids(X). {A = X;}
drh596bd232004-09-30 14:22:47 +0000237typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(Y.z-X.z);}
drh60218d22007-04-06 11:26:00 +0000238signed ::= plus_num.
239signed ::= minus_num.
drh487e2622005-06-25 18:42:14 +0000240
241// "carglist" is a list of additional constraints that come after the
242// column name and column type in a CREATE TABLE statement.
243//
drh348784e2000-05-29 20:41:49 +0000244carglist ::= carglist carg.
245carglist ::= .
drh5ad1a6c2002-07-01 12:27:09 +0000246carg ::= CONSTRAINT nm ccons.
drh348784e2000-05-29 20:41:49 +0000247carg ::= ccons.
drh2b7acc32006-12-20 02:15:00 +0000248ccons ::= DEFAULT term(X). {sqlite3AddDefaultValue(pParse,X);}
249ccons ::= DEFAULT LP expr(X) RP. {sqlite3AddDefaultValue(pParse,X);}
250ccons ::= DEFAULT PLUS term(X). {sqlite3AddDefaultValue(pParse,X);}
251ccons ::= DEFAULT MINUS term(X). {
drh17435752007-08-16 04:30:38 +0000252 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);
danielk19777977a172004-11-09 12:44:37 +0000253 sqlite3AddDefaultValue(pParse,p);
254}
drh2b7acc32006-12-20 02:15:00 +0000255ccons ::= DEFAULT id(X). {
drh17435752007-08-16 04:30:38 +0000256 Expr *p = sqlite3PExpr(pParse, TK_STRING, 0, 0, &X);
danielk19777977a172004-11-09 12:44:37 +0000257 sqlite3AddDefaultValue(pParse,p);
258}
drh348784e2000-05-29 20:41:49 +0000259
drh382c0242001-10-06 16:33:02 +0000260// In addition to the type name, we also care about the primary key and
261// UNIQUE constraints.
drh348784e2000-05-29 20:41:49 +0000262//
drh0d316a42002-08-11 20:10:47 +0000263ccons ::= NULL onconf.
danielk19774adee202004-05-08 08:23:19 +0000264ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);}
drhfdd6e852005-12-16 01:06:16 +0000265ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).
266 {sqlite3AddPrimaryKey(pParse,0,R,I,Z);}
drh4d91a702006-01-04 15:54:36 +0000267ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0);}
drh06f65412005-11-03 02:03:13 +0000268ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X);}
drhc2eef3b2002-08-31 18:53:06 +0000269ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
danielk19774adee202004-05-08 08:23:19 +0000270 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
271ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);}
danielk197739002502007-11-12 09:50:26 +0000272ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);}
drh04738cb2002-06-02 18:19:00 +0000273
drh205f48e2004-11-05 00:43:11 +0000274// The optional AUTOINCREMENT keyword
275%type autoinc {int}
drh2958a4e2004-11-12 03:56:15 +0000276autoinc(X) ::= . {X = 0;}
277autoinc(X) ::= AUTOINCR. {X = 1;}
drh205f48e2004-11-05 00:43:11 +0000278
drhc2eef3b2002-08-31 18:53:06 +0000279// The next group of rules parses the arguments to a REFERENCES clause
280// that determine if the referential integrity checking is deferred or
281// or immediate and which determine what action to take if a ref-integ
282// check fails.
drh04738cb2002-06-02 18:19:00 +0000283//
drhc2eef3b2002-08-31 18:53:06 +0000284%type refargs {int}
285refargs(A) ::= . { A = OE_Restrict * 0x010101; }
286refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; }
287%type refarg {struct {int value; int mask;}}
288refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }
289refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }
290refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }
291refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; }
292%type refact {int}
293refact(A) ::= SET NULL. { A = OE_SetNull; }
294refact(A) ::= SET DEFAULT. { A = OE_SetDflt; }
295refact(A) ::= CASCADE. { A = OE_Cascade; }
296refact(A) ::= RESTRICT. { A = OE_Restrict; }
297%type defer_subclause {int}
298defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X). {A = X;}
299defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;}
300%type init_deferred_pred_opt {int}
301init_deferred_pred_opt(A) ::= . {A = 0;}
302init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;}
303init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;}
drh348784e2000-05-29 20:41:49 +0000304
305// For the time being, the only constraint we care about is the primary
drh382c0242001-10-06 16:33:02 +0000306// key and UNIQUE. Both create indices.
drh348784e2000-05-29 20:41:49 +0000307//
danielk197719a8e7e2005-03-17 05:03:38 +0000308conslist_opt(A) ::= . {A.n = 0; A.z = 0;}
309conslist_opt(A) ::= COMMA(X) conslist. {A = X;}
drh348784e2000-05-29 20:41:49 +0000310conslist ::= conslist COMMA tcons.
drha2e1bb52001-01-04 14:20:18 +0000311conslist ::= conslist tcons.
drh348784e2000-05-29 20:41:49 +0000312conslist ::= tcons.
drh5ad1a6c2002-07-01 12:27:09 +0000313tcons ::= CONSTRAINT nm.
drhf3388142004-11-13 03:48:06 +0000314tcons ::= PRIMARY KEY LP idxlist(X) autoinc(I) RP onconf(R).
drhfdd6e852005-12-16 01:06:16 +0000315 {sqlite3AddPrimaryKey(pParse,X,R,I,0);}
drh9cfcf5d2002-01-29 18:41:24 +0000316tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
drh4d91a702006-01-04 15:54:36 +0000317 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0);}
drh06f65412005-11-03 02:03:13 +0000318tcons ::= CHECK LP expr(E) RP onconf. {sqlite3AddCheckConstraint(pParse,E);}
drhc2eef3b2002-08-31 18:53:06 +0000319tcons ::= FOREIGN KEY LP idxlist(FA) RP
320 REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {
danielk19774adee202004-05-08 08:23:19 +0000321 sqlite3CreateForeignKey(pParse, FA, &T, TA, R);
322 sqlite3DeferForeignKey(pParse, D);
drhc2eef3b2002-08-31 18:53:06 +0000323}
324%type defer_subclause_opt {int}
325defer_subclause_opt(A) ::= . {A = 0;}
326defer_subclause_opt(A) ::= defer_subclause(X). {A = X;}
drh9cfcf5d2002-01-29 18:41:24 +0000327
328// The following is a non-standard extension that allows us to declare the
329// default behavior when there is a constraint conflict.
330//
331%type onconf {int}
drh1c928532002-01-31 15:54:21 +0000332%type orconf {int}
333%type resolvetype {int}
drh74ad7fe2004-10-07 03:06:28 +0000334onconf(A) ::= . {A = OE_Default;}
335onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;}
336orconf(A) ::= . {A = OE_Default;}
337orconf(A) ::= OR resolvetype(X). {A = X;}
338resolvetype(A) ::= raisetype(X). {A = X;}
339resolvetype(A) ::= IGNORE. {A = OE_Ignore;}
340resolvetype(A) ::= REPLACE. {A = OE_Replace;}
drh348784e2000-05-29 20:41:49 +0000341
drh382c0242001-10-06 16:33:02 +0000342////////////////////////// The DROP TABLE /////////////////////////////////////
drh348784e2000-05-29 20:41:49 +0000343//
drha0733842005-12-29 01:11:36 +0000344cmd ::= DROP TABLE ifexists(E) fullname(X). {
345 sqlite3DropTable(pParse, X, 0, E);
danielk1977a8858102004-05-28 12:11:21 +0000346}
drha0733842005-12-29 01:11:36 +0000347%type ifexists {int}
348ifexists(A) ::= IF EXISTS. {A = 1;}
349ifexists(A) ::= . {A = 0;}
drh348784e2000-05-29 20:41:49 +0000350
drha76b5df2002-02-23 02:32:10 +0000351///////////////////// The CREATE VIEW statement /////////////////////////////
352//
drhb7f91642004-10-31 02:22:47 +0000353%ifndef SQLITE_OMIT_VIEW
drhfdd48a72006-09-11 23:45:48 +0000354cmd ::= CREATE(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) AS select(S). {
355 sqlite3CreateView(pParse, &X, &Y, &Z, S, T, E);
drha76b5df2002-02-23 02:32:10 +0000356}
drha0733842005-12-29 01:11:36 +0000357cmd ::= DROP VIEW ifexists(E) fullname(X). {
358 sqlite3DropTable(pParse, X, 1, E);
drha76b5df2002-02-23 02:32:10 +0000359}
drh154d4b22006-09-21 11:02:16 +0000360%endif SQLITE_OMIT_VIEW
drha76b5df2002-02-23 02:32:10 +0000361
drh382c0242001-10-06 16:33:02 +0000362//////////////////////// The SELECT statement /////////////////////////////////
drh348784e2000-05-29 20:41:49 +0000363//
drh9bb61fe2000-06-05 16:01:39 +0000364cmd ::= select(X). {
danielk19776c8c8ce2008-01-02 16:27:09 +0000365 SelectDest dest = {SRT_Callback, 0, 0};
366 sqlite3Select(pParse, X, &dest, 0, 0, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000367 sqlite3SelectDelete(X);
drh9bb61fe2000-06-05 16:01:39 +0000368}
drhefb72512000-05-31 20:00:52 +0000369
drh9bb61fe2000-06-05 16:01:39 +0000370%type select {Select*}
danielk19774adee202004-05-08 08:23:19 +0000371%destructor select {sqlite3SelectDelete($$);}
drh82c3d632000-06-06 21:56:07 +0000372%type oneselect {Select*}
danielk19774adee202004-05-08 08:23:19 +0000373%destructor oneselect {sqlite3SelectDelete($$);}
drh9bb61fe2000-06-05 16:01:39 +0000374
drh82c3d632000-06-06 21:56:07 +0000375select(A) ::= oneselect(X). {A = X;}
drhb7f91642004-10-31 02:22:47 +0000376%ifndef SQLITE_OMIT_COMPOUND_SELECT
drh0a36c572002-02-18 22:49:59 +0000377select(A) ::= select(X) multiselect_op(Y) oneselect(Z). {
drhdaffd0e2001-04-11 14:28:42 +0000378 if( Z ){
drh82c3d632000-06-06 21:56:07 +0000379 Z->op = Y;
380 Z->pPrior = X;
drh43b78822007-06-15 17:03:14 +0000381 }else{
382 sqlite3SelectDelete(X);
drhdaffd0e2001-04-11 14:28:42 +0000383 }
384 A = Z;
drh82c3d632000-06-06 21:56:07 +0000385}
drh0a36c572002-02-18 22:49:59 +0000386%type multiselect_op {int}
drhfd405312005-11-06 04:06:59 +0000387multiselect_op(A) ::= UNION(OP). {A = @OP;}
388multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}
389multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP;}
drh154d4b22006-09-21 11:02:16 +0000390%endif SQLITE_OMIT_COMPOUND_SELECT
drh82c3d632000-06-06 21:56:07 +0000391oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
drh9bbca4c2001-11-06 04:00:18 +0000392 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
drh17435752007-08-16 04:30:38 +0000393 A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);
drh9bb61fe2000-06-05 16:01:39 +0000394}
395
396// The "distinct" nonterminal is true (1) if the DISTINCT keyword is
397// present and false (0) if it is not.
398//
drhefb72512000-05-31 20:00:52 +0000399%type distinct {int}
drhefb72512000-05-31 20:00:52 +0000400distinct(A) ::= DISTINCT. {A = 1;}
drhfef52082000-06-06 01:50:43 +0000401distinct(A) ::= ALL. {A = 0;}
drhefb72512000-05-31 20:00:52 +0000402distinct(A) ::= . {A = 0;}
drh348784e2000-05-29 20:41:49 +0000403
drh9bb61fe2000-06-05 16:01:39 +0000404// selcollist is a list of expressions that are to become the return
drh7c917d12001-12-16 20:05:05 +0000405// values of the SELECT statement. The "*" in statements like
406// "SELECT * FROM ..." is encoded as a special expression with an
407// opcode of TK_ALL.
drh9bb61fe2000-06-05 16:01:39 +0000408//
drh348784e2000-05-29 20:41:49 +0000409%type selcollist {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000410%destructor selcollist {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000411%type sclp {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000412%destructor sclp {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000413sclp(A) ::= selcollist(X) COMMA. {A = X;}
414sclp(A) ::= . {A = 0;}
drh01f3f252002-05-24 16:14:15 +0000415selcollist(A) ::= sclp(P) expr(X) as(Y). {
drh17435752007-08-16 04:30:38 +0000416 A = sqlite3ExprListAppend(pParse,P,X,Y.n?&Y:0);
drh01f3f252002-05-24 16:14:15 +0000417}
drh7c917d12001-12-16 20:05:05 +0000418selcollist(A) ::= sclp(P) STAR. {
danielk19771e536952007-08-16 10:09:01 +0000419 Expr *p = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);
drh17435752007-08-16 04:30:38 +0000420 A = sqlite3ExprListAppend(pParse, P, p, 0);
drh7c917d12001-12-16 20:05:05 +0000421}
drh5ad1a6c2002-07-01 12:27:09 +0000422selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
drh17435752007-08-16 04:30:38 +0000423 Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);
424 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
425 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
426 A = sqlite3ExprListAppend(pParse,P, pDot, 0);
drh54473222002-04-04 02:10:55 +0000427}
drh01f3f252002-05-24 16:14:15 +0000428
429// An option "AS <id>" phrase that can follow one of the expressions that
430// define the result set, or one of the tables in the FROM clause.
431//
432%type as {Token}
drh74ad7fe2004-10-07 03:06:28 +0000433as(X) ::= AS nm(Y). {X = Y;}
434as(X) ::= ids(Y). {X = Y;}
435as(X) ::= . {X.n = 0;}
drh9bb61fe2000-06-05 16:01:39 +0000436
drh348784e2000-05-29 20:41:49 +0000437
drhad3cab52002-05-24 02:04:32 +0000438%type seltablist {SrcList*}
danielk19774adee202004-05-08 08:23:19 +0000439%destructor seltablist {sqlite3SrcListDelete($$);}
drhad3cab52002-05-24 02:04:32 +0000440%type stl_prefix {SrcList*}
danielk19774adee202004-05-08 08:23:19 +0000441%destructor stl_prefix {sqlite3SrcListDelete($$);}
drhad3cab52002-05-24 02:04:32 +0000442%type from {SrcList*}
danielk19774adee202004-05-08 08:23:19 +0000443%destructor from {sqlite3SrcListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000444
drh01f3f252002-05-24 16:14:15 +0000445// A complete FROM clause.
446//
drh17435752007-08-16 04:30:38 +0000447from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
448from(A) ::= FROM seltablist(X). {
drh61dfc312006-12-16 16:25:15 +0000449 A = X;
450 sqlite3SrcListShiftJoinType(A);
451}
drh01f3f252002-05-24 16:14:15 +0000452
453// "seltablist" is a "Select Table List" - the content of the FROM clause
454// in a SELECT statement. "stl_prefix" is a prefix of this list.
455//
456stl_prefix(A) ::= seltablist(X) joinop(Y). {
457 A = X;
458 if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y;
459}
drh348784e2000-05-29 20:41:49 +0000460stl_prefix(A) ::= . {A = 0;}
drh113088e2003-03-20 01:16:58 +0000461seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). {
drh17435752007-08-16 04:30:38 +0000462 A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U);
drhc4a3c772001-04-04 11:48:57 +0000463}
drh51522cd2005-01-20 13:36:19 +0000464%ifndef SQLITE_OMIT_SUBQUERY
465 seltablist(A) ::= stl_prefix(X) LP seltablist_paren(S) RP
466 as(Z) on_opt(N) using_opt(U). {
drh17435752007-08-16 04:30:38 +0000467 A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U);
drhd5feede2002-05-08 21:46:14 +0000468 }
drh51522cd2005-01-20 13:36:19 +0000469
danielk1977955de522006-02-10 02:27:42 +0000470 // A seltablist_paren nonterminal represents anything in a FROM that
drh51522cd2005-01-20 13:36:19 +0000471 // is contained inside parentheses. This can be either a subquery or
472 // a grouping of table and subqueries.
473 //
474 %type seltablist_paren {Select*}
475 %destructor seltablist_paren {sqlite3SelectDelete($$);}
476 seltablist_paren(A) ::= select(S). {A = S;}
477 seltablist_paren(A) ::= seltablist(F). {
drh61dfc312006-12-16 16:25:15 +0000478 sqlite3SrcListShiftJoinType(F);
drh17435752007-08-16 04:30:38 +0000479 A = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);
drh01f3f252002-05-24 16:14:15 +0000480 }
drh154d4b22006-09-21 11:02:16 +0000481%endif SQLITE_OMIT_SUBQUERY
drhb733d032004-01-24 20:18:12 +0000482
drh113088e2003-03-20 01:16:58 +0000483%type dbnm {Token}
484dbnm(A) ::= . {A.z=0; A.n=0;}
485dbnm(A) ::= DOT nm(X). {A = X;}
486
drh74ad7fe2004-10-07 03:06:28 +0000487%type fullname {SrcList*}
488%destructor fullname {sqlite3SrcListDelete($$);}
drh17435752007-08-16 04:30:38 +0000489fullname(A) ::= nm(X) dbnm(Y). {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y);}
drh74ad7fe2004-10-07 03:06:28 +0000490
drh01f3f252002-05-24 16:14:15 +0000491%type joinop {int}
492%type joinop2 {int}
drhfd405312005-11-06 04:06:59 +0000493joinop(X) ::= COMMA|JOIN. { X = JT_INNER; }
danielk19774adee202004-05-08 08:23:19 +0000494joinop(X) ::= JOIN_KW(A) JOIN. { X = sqlite3JoinType(pParse,&A,0,0); }
495joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqlite3JoinType(pParse,&A,&B,0); }
drh5ad1a6c2002-07-01 12:27:09 +0000496joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
danielk19774adee202004-05-08 08:23:19 +0000497 { X = sqlite3JoinType(pParse,&A,&B,&C); }
drh01f3f252002-05-24 16:14:15 +0000498
499%type on_opt {Expr*}
danielk19774adee202004-05-08 08:23:19 +0000500%destructor on_opt {sqlite3ExprDelete($$);}
drh01f3f252002-05-24 16:14:15 +0000501on_opt(N) ::= ON expr(E). {N = E;}
502on_opt(N) ::= . {N = 0;}
503
504%type using_opt {IdList*}
danielk19774adee202004-05-08 08:23:19 +0000505%destructor using_opt {sqlite3IdListDelete($$);}
danielk19770202b292004-06-09 09:55:16 +0000506using_opt(U) ::= USING LP inscollist(L) RP. {U = L;}
drh01f3f252002-05-24 16:14:15 +0000507using_opt(U) ::= . {U = 0;}
508
509
drh348784e2000-05-29 20:41:49 +0000510%type orderby_opt {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000511%destructor orderby_opt {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000512%type sortlist {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000513%destructor sortlist {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000514%type sortitem {Expr*}
danielk19774adee202004-05-08 08:23:19 +0000515%destructor sortitem {sqlite3ExprDelete($$);}
drh348784e2000-05-29 20:41:49 +0000516
517orderby_opt(A) ::= . {A = 0;}
518orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
drh8b4c40d2007-02-01 23:02:45 +0000519sortlist(A) ::= sortlist(X) COMMA sortitem(Y) sortorder(Z). {
drh17435752007-08-16 04:30:38 +0000520 A = sqlite3ExprListAppend(pParse,X,Y,0);
drhd3d39e92004-05-20 22:16:29 +0000521 if( A ) A->a[A->nExpr-1].sortOrder = Z;
drh9bb61fe2000-06-05 16:01:39 +0000522}
drh8b4c40d2007-02-01 23:02:45 +0000523sortlist(A) ::= sortitem(Y) sortorder(Z). {
drh17435752007-08-16 04:30:38 +0000524 A = sqlite3ExprListAppend(pParse,0,Y,0);
danielk197796fb0dd2004-06-30 09:49:22 +0000525 if( A && A->a ) A->a[0].sortOrder = Z;
drh9bb61fe2000-06-05 16:01:39 +0000526}
drhda9d6c42000-05-31 18:20:14 +0000527sortitem(A) ::= expr(X). {A = X;}
drh348784e2000-05-29 20:41:49 +0000528
529%type sortorder {int}
530
drh8e2ca022002-06-17 17:07:19 +0000531sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}
532sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}
533sortorder(A) ::= . {A = SQLITE_SO_ASC;}
drh348784e2000-05-29 20:41:49 +0000534
drh22827922000-06-06 17:27:05 +0000535%type groupby_opt {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000536%destructor groupby_opt {sqlite3ExprListDelete($$);}
drh6206d502000-06-19 19:09:08 +0000537groupby_opt(A) ::= . {A = 0;}
drh9245c242007-06-20 12:18:31 +0000538groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}
drh22827922000-06-06 17:27:05 +0000539
540%type having_opt {Expr*}
danielk19774adee202004-05-08 08:23:19 +0000541%destructor having_opt {sqlite3ExprDelete($$);}
drh6206d502000-06-19 19:09:08 +0000542having_opt(A) ::= . {A = 0;}
drh22827922000-06-06 17:27:05 +0000543having_opt(A) ::= HAVING expr(X). {A = X;}
544
drhad3cab52002-05-24 02:04:32 +0000545%type limit_opt {struct LimitVal}
drh15926592007-04-06 15:02:13 +0000546
547// The destructor for limit_opt will never fire in the current grammar.
548// The limit_opt non-terminal only occurs at the end of a single production
549// rule for SELECT statements. As soon as the rule that create the
550// limit_opt non-terminal reduces, the SELECT statement rule will also
551// reduce. So there is never a limit_opt non-terminal on the stack
552// except as a transient. So there is never anything to destroy.
553//
554//%destructor limit_opt {
555// sqlite3ExprDelete($$.pLimit);
556// sqlite3ExprDelete($$.pOffset);
557//}
danielk1977a2dc3b12005-02-05 12:48:48 +0000558limit_opt(A) ::= . {A.pLimit = 0; A.pOffset = 0;}
559limit_opt(A) ::= LIMIT expr(X). {A.pLimit = X; A.pOffset = 0;}
560limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).
561 {A.pLimit = X; A.pOffset = Y;}
562limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).
563 {A.pOffset = X; A.pLimit = Y;}
drh9bbca4c2001-11-06 04:00:18 +0000564
drh382c0242001-10-06 16:33:02 +0000565/////////////////////////// The DELETE statement /////////////////////////////
566//
drh74ad7fe2004-10-07 03:06:28 +0000567cmd ::= DELETE FROM fullname(X) where_opt(Y). {sqlite3DeleteFrom(pParse,X,Y);}
drh348784e2000-05-29 20:41:49 +0000568
569%type where_opt {Expr*}
danielk19774adee202004-05-08 08:23:19 +0000570%destructor where_opt {sqlite3ExprDelete($$);}
drh348784e2000-05-29 20:41:49 +0000571
572where_opt(A) ::= . {A = 0;}
573where_opt(A) ::= WHERE expr(X). {A = X;}
574
drh382c0242001-10-06 16:33:02 +0000575////////////////////////// The UPDATE command ////////////////////////////////
576//
danielk19777a15a4b2007-05-08 17:54:43 +0000577cmd ::= UPDATE orconf(R) fullname(X) SET setlist(Y) where_opt(Z). {
578 sqlite3ExprListCheckLength(pParse,Y,SQLITE_MAX_COLUMN,"set list");
579 sqlite3Update(pParse,X,Y,Z,R);
580}
drh348784e2000-05-29 20:41:49 +0000581
drhf8db1bc2005-04-22 02:38:37 +0000582%type setlist {ExprList*}
583%destructor setlist {sqlite3ExprListDelete($$);}
584
drh5ad1a6c2002-07-01 12:27:09 +0000585setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).
drh17435752007-08-16 04:30:38 +0000586 {A = sqlite3ExprListAppend(pParse,Z,Y,&X);}
587setlist(A) ::= nm(X) EQ expr(Y).
588 {A = sqlite3ExprListAppend(pParse,0,Y,&X);}
drh348784e2000-05-29 20:41:49 +0000589
drh382c0242001-10-06 16:33:02 +0000590////////////////////////// The INSERT command /////////////////////////////////
591//
drh74ad7fe2004-10-07 03:06:28 +0000592cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F)
drh113088e2003-03-20 01:16:58 +0000593 VALUES LP itemlist(Y) RP.
drh74ad7fe2004-10-07 03:06:28 +0000594 {sqlite3Insert(pParse, X, Y, 0, F, R);}
595cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) select(S).
596 {sqlite3Insert(pParse, X, 0, S, F, R);}
drh147d0cc2006-08-25 23:42:53 +0000597cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) DEFAULT VALUES.
598 {sqlite3Insert(pParse, X, 0, 0, F, R);}
drh348784e2000-05-29 20:41:49 +0000599
drhfa86c412002-02-02 15:01:15 +0000600%type insert_cmd {int}
601insert_cmd(A) ::= INSERT orconf(R). {A = R;}
602insert_cmd(A) ::= REPLACE. {A = OE_Replace;}
603
drh348784e2000-05-29 20:41:49 +0000604
605%type itemlist {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000606%destructor itemlist {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000607
drh17435752007-08-16 04:30:38 +0000608itemlist(A) ::= itemlist(X) COMMA expr(Y).
609 {A = sqlite3ExprListAppend(pParse,X,Y,0);}
610itemlist(A) ::= expr(X).
611 {A = sqlite3ExprListAppend(pParse,0,X,0);}
drh348784e2000-05-29 20:41:49 +0000612
drh967e8b72000-06-21 13:59:10 +0000613%type inscollist_opt {IdList*}
danielk19774adee202004-05-08 08:23:19 +0000614%destructor inscollist_opt {sqlite3IdListDelete($$);}
drh967e8b72000-06-21 13:59:10 +0000615%type inscollist {IdList*}
danielk19774adee202004-05-08 08:23:19 +0000616%destructor inscollist {sqlite3IdListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000617
drhc4a3c772001-04-04 11:48:57 +0000618inscollist_opt(A) ::= . {A = 0;}
619inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;}
drh17435752007-08-16 04:30:38 +0000620inscollist(A) ::= inscollist(X) COMMA nm(Y).
621 {A = sqlite3IdListAppend(pParse->db,X,&Y);}
622inscollist(A) ::= nm(Y).
623 {A = sqlite3IdListAppend(pParse->db,0,&Y);}
drh348784e2000-05-29 20:41:49 +0000624
drh382c0242001-10-06 16:33:02 +0000625/////////////////////////// Expression Processing /////////////////////////////
626//
drh348784e2000-05-29 20:41:49 +0000627
628%type expr {Expr*}
danielk19774adee202004-05-08 08:23:19 +0000629%destructor expr {sqlite3ExprDelete($$);}
danielk19777977a172004-11-09 12:44:37 +0000630%type term {Expr*}
631%destructor term {sqlite3ExprDelete($$);}
drh348784e2000-05-29 20:41:49 +0000632
danielk19777977a172004-11-09 12:44:37 +0000633expr(A) ::= term(X). {A = X;}
danielk1977752e6792004-11-09 16:13:33 +0000634expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqlite3ExprSpan(A,&B,&E); }
drh17435752007-08-16 04:30:38 +0000635term(A) ::= NULL(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
636expr(A) ::= ID(X). {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}
637expr(A) ::= JOIN_KW(X). {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}
drh5ad1a6c2002-07-01 12:27:09 +0000638expr(A) ::= nm(X) DOT nm(Y). {
drh17435752007-08-16 04:30:38 +0000639 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
640 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
641 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
drhe1b6a5b2000-07-29 13:06:59 +0000642}
drhd24cc422003-03-27 12:51:24 +0000643expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
drh17435752007-08-16 04:30:38 +0000644 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
645 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
646 Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Z);
647 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
648 A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
drhd24cc422003-03-27 12:51:24 +0000649}
drhe9cf59e2007-11-17 22:23:27 +0000650term(A) ::= INTEGER|FLOAT|BLOB(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
drh17435752007-08-16 04:30:38 +0000651term(A) ::= STRING(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
drh4e0cff62004-11-05 05:10:28 +0000652expr(A) ::= REGISTER(X). {A = sqlite3RegisterExpr(pParse, &X);}
drh7c972de2003-09-06 22:18:07 +0000653expr(A) ::= VARIABLE(X). {
drh895d7472004-08-20 16:02:39 +0000654 Token *pToken = &X;
drh17435752007-08-16 04:30:38 +0000655 Expr *pExpr = A = sqlite3PExpr(pParse, TK_VARIABLE, 0, 0, pToken);
drhfa6bc002004-09-07 16:19:52 +0000656 sqlite3ExprAssignVarNumber(pParse, pExpr);
drh7c972de2003-09-06 22:18:07 +0000657}
danielk197739002502007-11-12 09:50:26 +0000658expr(A) ::= expr(E) COLLATE ids(C). {
drh8b4c40d2007-02-01 23:02:45 +0000659 A = sqlite3ExprSetColl(pParse, E, &C);
660}
drh487e2622005-06-25 18:42:14 +0000661%ifndef SQLITE_OMIT_CAST
662expr(A) ::= CAST(X) LP expr(E) AS typetoken(T) RP(Y). {
drh17435752007-08-16 04:30:38 +0000663 A = sqlite3PExpr(pParse, TK_CAST, E, 0, &T);
drh487e2622005-06-25 18:42:14 +0000664 sqlite3ExprSpan(A,&X,&Y);
665}
drh154d4b22006-09-21 11:02:16 +0000666%endif SQLITE_OMIT_CAST
drhfd357972005-09-09 01:33:19 +0000667expr(A) ::= ID(X) LP distinct(D) exprlist(Y) RP(E). {
danielk1977c9cf9012007-05-30 10:36:47 +0000668 if( Y && Y->nExpr>SQLITE_MAX_FUNCTION_ARG ){
drhe5c941b2007-05-08 13:58:26 +0000669 sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X);
drh4e05c832007-05-11 01:44:50 +0000670 }
drh17435752007-08-16 04:30:38 +0000671 A = sqlite3ExprFunction(pParse, Y, &X);
drh4e05c832007-05-11 01:44:50 +0000672 sqlite3ExprSpan(A,&X,&E);
673 if( D && A ){
674 A->flags |= EP_Distinct;
drhfd357972005-09-09 01:33:19 +0000675 }
drhe1b6a5b2000-07-29 13:06:59 +0000676}
677expr(A) ::= ID(X) LP STAR RP(E). {
drh17435752007-08-16 04:30:38 +0000678 A = sqlite3ExprFunction(pParse, 0, &X);
danielk19774adee202004-05-08 08:23:19 +0000679 sqlite3ExprSpan(A,&X,&E);
drhe1b6a5b2000-07-29 13:06:59 +0000680}
drhb71090f2005-05-23 17:26:51 +0000681term(A) ::= CTIME_KW(OP). {
682 /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
683 ** treated as functions that return constants */
drh17435752007-08-16 04:30:38 +0000684 A = sqlite3ExprFunction(pParse, 0,&OP);
drh417ec632006-08-14 14:23:41 +0000685 if( A ){
686 A->op = TK_CONST_FUNC;
687 A->span = OP;
688 }
drhb71090f2005-05-23 17:26:51 +0000689}
drh17435752007-08-16 04:30:38 +0000690expr(A) ::= expr(X) AND(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
691expr(A) ::= expr(X) OR(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
692expr(A) ::= expr(X) LT|GT|GE|LE(OP) expr(Y).
693 {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
694expr(A) ::= expr(X) EQ|NE(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
drhfd405312005-11-06 04:06:59 +0000695expr(A) ::= expr(X) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).
drh17435752007-08-16 04:30:38 +0000696 {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
697expr(A) ::= expr(X) PLUS|MINUS(OP) expr(Y).{A = sqlite3PExpr(pParse,@OP,X,Y,0);}
698expr(A) ::= expr(X) STAR|SLASH|REM(OP) expr(Y).
699 {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
700expr(A) ::= expr(X) CONCAT(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
drh74ad7fe2004-10-07 03:06:28 +0000701%type likeop {struct LikeOp}
drhb52076c2006-01-23 13:22:09 +0000702likeop(A) ::= LIKE_KW(X). {A.eOperator = X; A.not = 0;}
703likeop(A) ::= NOT LIKE_KW(X). {A.eOperator = X; A.not = 1;}
drh03bea702006-06-13 15:37:26 +0000704likeop(A) ::= MATCH(X). {A.eOperator = X; A.not = 0;}
705likeop(A) ::= NOT MATCH(X). {A.eOperator = X; A.not = 1;}
danielk19777c6303c2004-11-17 16:41:29 +0000706%type escape {Expr*}
danielk1977dba99bc2006-01-07 14:02:26 +0000707%destructor escape {sqlite3ExprDelete($$);}
danielk19777c6303c2004-11-17 16:41:29 +0000708escape(X) ::= ESCAPE expr(A). [ESCAPE] {X = A;}
709escape(X) ::= . [ESCAPE] {X = 0;}
drhb71090f2005-05-23 17:26:51 +0000710expr(A) ::= expr(X) likeop(OP) expr(Y) escape(E). [LIKE_KW] {
drh8aa34ae2006-03-13 12:54:09 +0000711 ExprList *pList;
drh17435752007-08-16 04:30:38 +0000712 pList = sqlite3ExprListAppend(pParse,0, Y, 0);
713 pList = sqlite3ExprListAppend(pParse,pList, X, 0);
danielk19777c6303c2004-11-17 16:41:29 +0000714 if( E ){
drh17435752007-08-16 04:30:38 +0000715 pList = sqlite3ExprListAppend(pParse,pList, E, 0);
danielk19777c6303c2004-11-17 16:41:29 +0000716 }
drh17435752007-08-16 04:30:38 +0000717 A = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
718 if( OP.not ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000719 sqlite3ExprSpan(A, &X->span, &Y->span);
drh6a03a1c2006-07-08 18:34:59 +0000720 if( A ) A->flags |= EP_InfixFunc;
drh0ac65892002-04-20 14:24:41 +0000721}
danielk19777c6303c2004-11-17 16:41:29 +0000722
drhfd405312005-11-06 04:06:59 +0000723expr(A) ::= expr(X) ISNULL|NOTNULL(E). {
drh17435752007-08-16 04:30:38 +0000724 A = sqlite3PExpr(pParse, @E, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000725 sqlite3ExprSpan(A,&X->span,&E);
drhe1b6a5b2000-07-29 13:06:59 +0000726}
drh33048c02001-10-01 14:29:22 +0000727expr(A) ::= expr(X) IS NULL(E). {
drh17435752007-08-16 04:30:38 +0000728 A = sqlite3PExpr(pParse, TK_ISNULL, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000729 sqlite3ExprSpan(A,&X->span,&E);
drh33048c02001-10-01 14:29:22 +0000730}
drh33048c02001-10-01 14:29:22 +0000731expr(A) ::= expr(X) NOT NULL(E). {
drh17435752007-08-16 04:30:38 +0000732 A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000733 sqlite3ExprSpan(A,&X->span,&E);
drh33048c02001-10-01 14:29:22 +0000734}
drh81a20f22001-10-12 17:30:04 +0000735expr(A) ::= expr(X) IS NOT NULL(E). {
drh17435752007-08-16 04:30:38 +0000736 A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000737 sqlite3ExprSpan(A,&X->span,&E);
drh81a20f22001-10-12 17:30:04 +0000738}
drhe9cf59e2007-11-17 22:23:27 +0000739expr(A) ::= NOT(B) expr(X). {
740 A = sqlite3PExpr(pParse, @B, X, 0, 0);
741 sqlite3ExprSpan(A,&B,&X->span);
742}
743expr(A) ::= BITNOT(B) expr(X). {
drh17435752007-08-16 04:30:38 +0000744 A = sqlite3PExpr(pParse, @B, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000745 sqlite3ExprSpan(A,&B,&X->span);
drh81a20f22001-10-12 17:30:04 +0000746}
drhe1b6a5b2000-07-29 13:06:59 +0000747expr(A) ::= MINUS(B) expr(X). [UMINUS] {
drh17435752007-08-16 04:30:38 +0000748 A = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000749 sqlite3ExprSpan(A,&B,&X->span);
drhe1b6a5b2000-07-29 13:06:59 +0000750}
drh4b59ab52002-08-24 18:24:51 +0000751expr(A) ::= PLUS(B) expr(X). [UPLUS] {
drh17435752007-08-16 04:30:38 +0000752 A = sqlite3PExpr(pParse, TK_UPLUS, X, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000753 sqlite3ExprSpan(A,&B,&X->span);
drhe1b6a5b2000-07-29 13:06:59 +0000754}
drh2e3a1f12004-10-06 14:39:28 +0000755%type between_op {int}
756between_op(A) ::= BETWEEN. {A = 0;}
757between_op(A) ::= NOT BETWEEN. {A = 1;}
758expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
drh17435752007-08-16 04:30:38 +0000759 ExprList *pList = sqlite3ExprListAppend(pParse,0, X, 0);
760 pList = sqlite3ExprListAppend(pParse,pList, Y, 0);
761 A = sqlite3PExpr(pParse, TK_BETWEEN, W, 0, 0);
drh53f733c2005-09-16 02:38:09 +0000762 if( A ){
763 A->pList = pList;
764 }else{
765 sqlite3ExprListDelete(pList);
766 }
drh17435752007-08-16 04:30:38 +0000767 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
danielk19774adee202004-05-08 08:23:19 +0000768 sqlite3ExprSpan(A,&W->span,&Y->span);
drhfef52082000-06-06 01:50:43 +0000769}
drh51522cd2005-01-20 13:36:19 +0000770%ifndef SQLITE_OMIT_SUBQUERY
danielk19773e8c37e2005-01-21 03:12:14 +0000771 %type in_op {int}
772 in_op(A) ::= IN. {A = 0;}
773 in_op(A) ::= NOT IN. {A = 1;}
774 expr(A) ::= expr(X) in_op(N) LP exprlist(Y) RP(E). [IN] {
drh17435752007-08-16 04:30:38 +0000775 A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
danielk1977d5d56522005-03-16 12:15:20 +0000776 if( A ){
777 A->pList = Y;
danielk1977fc976062007-05-10 10:46:56 +0000778 sqlite3ExprSetHeight(A);
danielk1977d5d56522005-03-16 12:15:20 +0000779 }else{
780 sqlite3ExprListDelete(Y);
781 }
drh17435752007-08-16 04:30:38 +0000782 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
danielk19773e8c37e2005-01-21 03:12:14 +0000783 sqlite3ExprSpan(A,&X->span,&E);
784 }
drh51522cd2005-01-20 13:36:19 +0000785 expr(A) ::= LP(B) select(X) RP(E). {
drh17435752007-08-16 04:30:38 +0000786 A = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
drh53f733c2005-09-16 02:38:09 +0000787 if( A ){
788 A->pSelect = X;
danielk1977fc976062007-05-10 10:46:56 +0000789 sqlite3ExprSetHeight(A);
drh53f733c2005-09-16 02:38:09 +0000790 }else{
791 sqlite3SelectDelete(X);
792 }
drh51522cd2005-01-20 13:36:19 +0000793 sqlite3ExprSpan(A,&B,&E);
794 }
795 expr(A) ::= expr(X) in_op(N) LP select(Y) RP(E). [IN] {
drh17435752007-08-16 04:30:38 +0000796 A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
drh53f733c2005-09-16 02:38:09 +0000797 if( A ){
798 A->pSelect = Y;
danielk1977fc976062007-05-10 10:46:56 +0000799 sqlite3ExprSetHeight(A);
drh53f733c2005-09-16 02:38:09 +0000800 }else{
801 sqlite3SelectDelete(Y);
802 }
drh17435752007-08-16 04:30:38 +0000803 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
drh51522cd2005-01-20 13:36:19 +0000804 sqlite3ExprSpan(A,&X->span,&E);
805 }
806 expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {
drh17435752007-08-16 04:30:38 +0000807 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
808 A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
drh53f733c2005-09-16 02:38:09 +0000809 if( A ){
danielk19771e536952007-08-16 10:09:01 +0000810 A->pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
danielk1977fc976062007-05-10 10:46:56 +0000811 sqlite3ExprSetHeight(A);
drh53f733c2005-09-16 02:38:09 +0000812 }else{
813 sqlite3SrcListDelete(pSrc);
814 }
drh17435752007-08-16 04:30:38 +0000815 if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
drh51522cd2005-01-20 13:36:19 +0000816 sqlite3ExprSpan(A,&X->span,Z.z?&Z:&Y);
817 }
818 expr(A) ::= EXISTS(B) LP select(Y) RP(E). {
drh17435752007-08-16 04:30:38 +0000819 Expr *p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
drh51522cd2005-01-20 13:36:19 +0000820 if( p ){
821 p->pSelect = Y;
822 sqlite3ExprSpan(p,&B,&E);
danielk1977fc976062007-05-10 10:46:56 +0000823 sqlite3ExprSetHeight(A);
drh53f733c2005-09-16 02:38:09 +0000824 }else{
825 sqlite3SelectDelete(Y);
drh51522cd2005-01-20 13:36:19 +0000826 }
827 }
drh154d4b22006-09-21 11:02:16 +0000828%endif SQLITE_OMIT_SUBQUERY
drhfef52082000-06-06 01:50:43 +0000829
drh17a7f8d2002-03-24 13:13:27 +0000830/* CASE expressions */
831expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {
drh17435752007-08-16 04:30:38 +0000832 A = sqlite3PExpr(pParse, TK_CASE, X, Z, 0);
drh53f733c2005-09-16 02:38:09 +0000833 if( A ){
834 A->pList = Y;
danielk1977fc976062007-05-10 10:46:56 +0000835 sqlite3ExprSetHeight(A);
drh53f733c2005-09-16 02:38:09 +0000836 }else{
837 sqlite3ExprListDelete(Y);
838 }
danielk19774adee202004-05-08 08:23:19 +0000839 sqlite3ExprSpan(A, &C, &E);
drh17a7f8d2002-03-24 13:13:27 +0000840}
841%type case_exprlist {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000842%destructor case_exprlist {sqlite3ExprListDelete($$);}
drh17a7f8d2002-03-24 13:13:27 +0000843case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
drh17435752007-08-16 04:30:38 +0000844 A = sqlite3ExprListAppend(pParse,X, Y, 0);
845 A = sqlite3ExprListAppend(pParse,A, Z, 0);
drh17a7f8d2002-03-24 13:13:27 +0000846}
847case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
drh17435752007-08-16 04:30:38 +0000848 A = sqlite3ExprListAppend(pParse,0, Y, 0);
849 A = sqlite3ExprListAppend(pParse,A, Z, 0);
drh17a7f8d2002-03-24 13:13:27 +0000850}
851%type case_else {Expr*}
danielk1977dba99bc2006-01-07 14:02:26 +0000852%destructor case_else {sqlite3ExprDelete($$);}
drh17a7f8d2002-03-24 13:13:27 +0000853case_else(A) ::= ELSE expr(X). {A = X;}
854case_else(A) ::= . {A = 0;}
855%type case_operand {Expr*}
danielk1977dba99bc2006-01-07 14:02:26 +0000856%destructor case_operand {sqlite3ExprDelete($$);}
drh17a7f8d2002-03-24 13:13:27 +0000857case_operand(A) ::= expr(X). {A = X;}
858case_operand(A) ::= . {A = 0;}
drh348784e2000-05-29 20:41:49 +0000859
860%type exprlist {ExprList*}
danielk19774adee202004-05-08 08:23:19 +0000861%destructor exprlist {sqlite3ExprListDelete($$);}
drh9245c242007-06-20 12:18:31 +0000862%type nexprlist {ExprList*}
863%destructor nexprlist {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000864
drh9245c242007-06-20 12:18:31 +0000865exprlist(A) ::= nexprlist(X). {A = X;}
866exprlist(A) ::= . {A = 0;}
drh17435752007-08-16 04:30:38 +0000867nexprlist(A) ::= nexprlist(X) COMMA expr(Y).
868 {A = sqlite3ExprListAppend(pParse,X,Y,0);}
869nexprlist(A) ::= expr(Y).
870 {A = sqlite3ExprListAppend(pParse,0,Y,0);}
drh9245c242007-06-20 12:18:31 +0000871
drhcce7d172000-05-31 15:34:51 +0000872
drh382c0242001-10-06 16:33:02 +0000873///////////////////////////// The CREATE INDEX command ///////////////////////
874//
drh4d91a702006-01-04 15:54:36 +0000875cmd ::= CREATE(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)
drh77e96d12006-01-30 23:04:51 +0000876 ON nm(Y) LP idxlist(Z) RP(E). {
drh17435752007-08-16 04:30:38 +0000877 sqlite3CreateIndex(pParse, &X, &D,
878 sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U,
drh4d91a702006-01-04 15:54:36 +0000879 &S, &E, SQLITE_SO_ASC, NE);
drh9cfcf5d2002-01-29 18:41:24 +0000880}
drh717e6402001-09-27 03:22:32 +0000881
882%type uniqueflag {int}
drh74ad7fe2004-10-07 03:06:28 +0000883uniqueflag(A) ::= UNIQUE. {A = OE_Abort;}
884uniqueflag(A) ::= . {A = OE_None;}
drh348784e2000-05-29 20:41:49 +0000885
danielk19770202b292004-06-09 09:55:16 +0000886%type idxlist {ExprList*}
887%destructor idxlist {sqlite3ExprListDelete($$);}
888%type idxlist_opt {ExprList*}
889%destructor idxlist_opt {sqlite3ExprListDelete($$);}
drh348784e2000-05-29 20:41:49 +0000890%type idxitem {Token}
891
drhc2eef3b2002-08-31 18:53:06 +0000892idxlist_opt(A) ::= . {A = 0;}
893idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;}
drhfdd6e852005-12-16 01:06:16 +0000894idxlist(A) ::= idxlist(X) COMMA idxitem(Y) collate(C) sortorder(Z). {
danielk19770202b292004-06-09 09:55:16 +0000895 Expr *p = 0;
896 if( C.n>0 ){
drh17435752007-08-16 04:30:38 +0000897 p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
danielk197739002502007-11-12 09:50:26 +0000898 sqlite3ExprSetColl(pParse, p, &C);
danielk19770202b292004-06-09 09:55:16 +0000899 }
drh17435752007-08-16 04:30:38 +0000900 A = sqlite3ExprListAppend(pParse,X, p, &Y);
danielk19777a15a4b2007-05-08 17:54:43 +0000901 sqlite3ExprListCheckLength(pParse, A, SQLITE_MAX_COLUMN, "index");
drhfdd6e852005-12-16 01:06:16 +0000902 if( A ) A->a[A->nExpr-1].sortOrder = Z;
danielk19770202b292004-06-09 09:55:16 +0000903}
drhfdd6e852005-12-16 01:06:16 +0000904idxlist(A) ::= idxitem(Y) collate(C) sortorder(Z). {
danielk19770202b292004-06-09 09:55:16 +0000905 Expr *p = 0;
906 if( C.n>0 ){
drh17435752007-08-16 04:30:38 +0000907 p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
danielk197739002502007-11-12 09:50:26 +0000908 sqlite3ExprSetColl(pParse, p, &C);
danielk19770202b292004-06-09 09:55:16 +0000909 }
drh17435752007-08-16 04:30:38 +0000910 A = sqlite3ExprListAppend(pParse,0, p, &Y);
danielk19777a15a4b2007-05-08 17:54:43 +0000911 sqlite3ExprListCheckLength(pParse, A, SQLITE_MAX_COLUMN, "index");
drhfdd6e852005-12-16 01:06:16 +0000912 if( A ) A->a[A->nExpr-1].sortOrder = Z;
danielk19770202b292004-06-09 09:55:16 +0000913}
914idxitem(A) ::= nm(X). {A = X;}
915
drha34001c2007-02-02 12:44:37 +0000916%type collate {Token}
917collate(C) ::= . {C.z = 0; C.n = 0;}
danielk197739002502007-11-12 09:50:26 +0000918collate(C) ::= COLLATE ids(X). {C = X;}
drha34001c2007-02-02 12:44:37 +0000919
drh348784e2000-05-29 20:41:49 +0000920
drh8aff1012001-12-22 14:49:24 +0000921///////////////////////////// The DROP INDEX command /////////////////////////
drh382c0242001-10-06 16:33:02 +0000922//
drh4d91a702006-01-04 15:54:36 +0000923cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);}
drh982cef72000-05-30 16:27:03 +0000924
drh382c0242001-10-06 16:33:02 +0000925///////////////////////////// The VACUUM command /////////////////////////////
926//
drh154d4b22006-09-21 11:02:16 +0000927%ifndef SQLITE_OMIT_VACUUM
drhfdbcdee2007-03-27 14:44:50 +0000928%ifndef SQLITE_OMIT_ATTACH
drh74161702006-02-24 02:53:49 +0000929cmd ::= VACUUM. {sqlite3Vacuum(pParse);}
930cmd ::= VACUUM nm. {sqlite3Vacuum(pParse);}
drhfdbcdee2007-03-27 14:44:50 +0000931%endif SQLITE_OMIT_ATTACH
drh154d4b22006-09-21 11:02:16 +0000932%endif SQLITE_OMIT_VACUUM
drhf57b14a2001-09-14 18:54:08 +0000933
drh382c0242001-10-06 16:33:02 +0000934///////////////////////////// The PRAGMA command /////////////////////////////
935//
drh13d70422004-11-13 15:59:14 +0000936%ifndef SQLITE_OMIT_PRAGMA
drha3eb4b42007-01-27 02:38:29 +0000937cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
danielk197791cf71b2004-06-26 06:37:06 +0000938cmd ::= PRAGMA nm(X) dbnm(Z) EQ ON(Y). {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
danielk197791cf71b2004-06-26 06:37:06 +0000939cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y). {
940 sqlite3Pragma(pParse,&X,&Z,&Y,1);
941}
drha3eb4b42007-01-27 02:38:29 +0000942cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
drh74ad7fe2004-10-07 03:06:28 +0000943cmd ::= PRAGMA nm(X) dbnm(Z). {sqlite3Pragma(pParse,&X,&Z,0,0);}
drha3eb4b42007-01-27 02:38:29 +0000944nmnum(A) ::= plus_num(X). {A = X;}
945nmnum(A) ::= nm(X). {A = X;}
drh154d4b22006-09-21 11:02:16 +0000946%endif SQLITE_OMIT_PRAGMA
drhf57b14a2001-09-14 18:54:08 +0000947plus_num(A) ::= plus_opt number(X). {A = X;}
948minus_num(A) ::= MINUS number(X). {A = X;}
drhfd405312005-11-06 04:06:59 +0000949number(A) ::= INTEGER|FLOAT(X). {A = X;}
drhf57b14a2001-09-14 18:54:08 +0000950plus_opt ::= PLUS.
951plus_opt ::= .
danielk1977c3f9bad2002-05-15 08:30:12 +0000952
953//////////////////////////// The CREATE TRIGGER command /////////////////////
drhf0f258b2003-04-21 18:48:45 +0000954
drhb7f91642004-10-31 02:22:47 +0000955%ifndef SQLITE_OMIT_TRIGGER
956
danielk19773df6b252004-05-29 10:23:19 +0000957cmd ::= CREATE trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
drh4b59ab52002-08-24 18:24:51 +0000958 Token all;
959 all.z = A.z;
960 all.n = (Z.z - A.z) + Z.n;
danielk19774adee202004-05-08 08:23:19 +0000961 sqlite3FinishTrigger(pParse, S, &all);
drhf0f258b2003-04-21 18:48:45 +0000962}
963
drhfdd48a72006-09-11 23:45:48 +0000964trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z)
965 trigger_time(C) trigger_event(D)
drh60218d22007-04-06 11:26:00 +0000966 ON fullname(E) foreach_clause when_clause(G). {
967 sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR);
danielk19773df6b252004-05-29 10:23:19 +0000968 A = (Z.n==0?B:Z);
danielk1977c3f9bad2002-05-15 08:30:12 +0000969}
970
drhc4dd3fd2008-01-22 01:48:05 +0000971%type trigger_time {int}
danielk1977c3f9bad2002-05-15 08:30:12 +0000972trigger_time(A) ::= BEFORE. { A = TK_BEFORE; }
973trigger_time(A) ::= AFTER. { A = TK_AFTER; }
974trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;}
975trigger_time(A) ::= . { A = TK_BEFORE; }
976
drhad3cab52002-05-24 02:04:32 +0000977%type trigger_event {struct TrigEvent}
danielk19774adee202004-05-08 08:23:19 +0000978%destructor trigger_event {sqlite3IdListDelete($$.b);}
drhfd405312005-11-06 04:06:59 +0000979trigger_event(A) ::= DELETE|INSERT(OP). {A.a = @OP; A.b = 0;}
drh74ad7fe2004-10-07 03:06:28 +0000980trigger_event(A) ::= UPDATE(OP). {A.a = @OP; A.b = 0;}
981trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X;}
danielk1977c3f9bad2002-05-15 08:30:12 +0000982
drh60218d22007-04-06 11:26:00 +0000983foreach_clause ::= .
984foreach_clause ::= FOR EACH ROW.
danielk1977c3f9bad2002-05-15 08:30:12 +0000985
drh0bb132b2004-07-20 14:06:51 +0000986%type when_clause {Expr*}
danielk1977dba99bc2006-01-07 14:02:26 +0000987%destructor when_clause {sqlite3ExprDelete($$);}
danielk1977c3f9bad2002-05-15 08:30:12 +0000988when_clause(A) ::= . { A = 0; }
989when_clause(A) ::= WHEN expr(X). { A = X; }
990
drh0bb132b2004-07-20 14:06:51 +0000991%type trigger_cmd_list {TriggerStep*}
danielk19774adee202004-05-08 08:23:19 +0000992%destructor trigger_cmd_list {sqlite3DeleteTriggerStep($$);}
drh187e4c62006-02-27 22:22:27 +0000993trigger_cmd_list(A) ::= trigger_cmd_list(Y) trigger_cmd(X) SEMI. {
994 if( Y ){
995 Y->pLast->pNext = X;
996 }else{
997 Y = X;
998 }
999 Y->pLast = X;
1000 A = Y;
drha69d9162003-04-17 22:57:53 +00001001}
danielk1977c3f9bad2002-05-15 08:30:12 +00001002trigger_cmd_list(A) ::= . { A = 0; }
1003
drh0bb132b2004-07-20 14:06:51 +00001004%type trigger_cmd {TriggerStep*}
danielk19774adee202004-05-08 08:23:19 +00001005%destructor trigger_cmd {sqlite3DeleteTriggerStep($$);}
danielk1977c3f9bad2002-05-15 08:30:12 +00001006// UPDATE
drh5ad1a6c2002-07-01 12:27:09 +00001007trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z).
drh17435752007-08-16 04:30:38 +00001008 { A = sqlite3TriggerUpdateStep(pParse->db, &X, Y, Z, R); }
danielk1977c3f9bad2002-05-15 08:30:12 +00001009
1010// INSERT
drh3054efe2004-02-12 17:28:13 +00001011trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F)
drh74ad7fe2004-10-07 03:06:28 +00001012 VALUES LP itemlist(Y) RP.
drh17435752007-08-16 04:30:38 +00001013 {A = sqlite3TriggerInsertStep(pParse->db, &X, F, Y, 0, R);}
danielk1977c3f9bad2002-05-15 08:30:12 +00001014
drh3054efe2004-02-12 17:28:13 +00001015trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S).
drh17435752007-08-16 04:30:38 +00001016 {A = sqlite3TriggerInsertStep(pParse->db, &X, F, 0, S, R);}
danielk1977c3f9bad2002-05-15 08:30:12 +00001017
1018// DELETE
drh5ad1a6c2002-07-01 12:27:09 +00001019trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y).
drh17435752007-08-16 04:30:38 +00001020 {A = sqlite3TriggerDeleteStep(pParse->db, &X, Y);}
danielk1977c3f9bad2002-05-15 08:30:12 +00001021
1022// SELECT
drh17435752007-08-16 04:30:38 +00001023trigger_cmd(A) ::= select(X). {A = sqlite3TriggerSelectStep(pParse->db, X); }
danielk1977c3f9bad2002-05-15 08:30:12 +00001024
danielk19776f349032002-06-11 02:25:40 +00001025// The special RAISE expression that may occur in trigger programs
drh4b59ab52002-08-24 18:24:51 +00001026expr(A) ::= RAISE(X) LP IGNORE RP(Y). {
drh17435752007-08-16 04:30:38 +00001027 A = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
drh8aa34ae2006-03-13 12:54:09 +00001028 if( A ){
1029 A->iColumn = OE_Ignore;
1030 sqlite3ExprSpan(A, &X, &Y);
1031 }
drh4b59ab52002-08-24 18:24:51 +00001032}
drh74ad7fe2004-10-07 03:06:28 +00001033expr(A) ::= RAISE(X) LP raisetype(T) COMMA nm(Z) RP(Y). {
drh17435752007-08-16 04:30:38 +00001034 A = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &Z);
drh8aa34ae2006-03-13 12:54:09 +00001035 if( A ) {
1036 A->iColumn = T;
1037 sqlite3ExprSpan(A, &X, &Y);
1038 }
drh4b59ab52002-08-24 18:24:51 +00001039}
drh154d4b22006-09-21 11:02:16 +00001040%endif !SQLITE_OMIT_TRIGGER
drhb7f91642004-10-31 02:22:47 +00001041
drh74ad7fe2004-10-07 03:06:28 +00001042%type raisetype {int}
1043raisetype(A) ::= ROLLBACK. {A = OE_Rollback;}
1044raisetype(A) ::= ABORT. {A = OE_Abort;}
1045raisetype(A) ::= FAIL. {A = OE_Fail;}
1046
danielk19776f349032002-06-11 02:25:40 +00001047
danielk1977c3f9bad2002-05-15 08:30:12 +00001048//////////////////////// DROP TRIGGER statement //////////////////////////////
drhb7f91642004-10-31 02:22:47 +00001049%ifndef SQLITE_OMIT_TRIGGER
drhfdd48a72006-09-11 23:45:48 +00001050cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
1051 sqlite3DropTrigger(pParse,X,NOERR);
danielk1977c3f9bad2002-05-15 08:30:12 +00001052}
drh154d4b22006-09-21 11:02:16 +00001053%endif !SQLITE_OMIT_TRIGGER
drh113088e2003-03-20 01:16:58 +00001054
1055//////////////////////// ATTACH DATABASE file AS name /////////////////////////
drhfdbcdee2007-03-27 14:44:50 +00001056%ifndef SQLITE_OMIT_ATTACH
danielk1977f744bb52005-12-06 17:19:11 +00001057cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). {
1058 sqlite3Attach(pParse, F, D, K);
drh1c2d8412003-03-31 00:30:47 +00001059}
drhfdbcdee2007-03-27 14:44:50 +00001060cmd ::= DETACH database_kw_opt expr(D). {
1061 sqlite3Detach(pParse, D);
1062}
1063
drhc4dd3fd2008-01-22 01:48:05 +00001064%type key_opt {Expr*}
danielk1977dba99bc2006-01-07 14:02:26 +00001065%destructor key_opt {sqlite3ExprDelete($$);}
danielk1977f744bb52005-12-06 17:19:11 +00001066key_opt(A) ::= . { A = 0; }
1067key_opt(A) ::= KEY expr(X). { A = X; }
drh113088e2003-03-20 01:16:58 +00001068
1069database_kw_opt ::= DATABASE.
1070database_kw_opt ::= .
drhfdbcdee2007-03-27 14:44:50 +00001071%endif SQLITE_OMIT_ATTACH
drh4343fea2004-11-05 23:46:15 +00001072
1073////////////////////////// REINDEX collation //////////////////////////////////
1074%ifndef SQLITE_OMIT_REINDEX
1075cmd ::= REINDEX. {sqlite3Reindex(pParse, 0, 0);}
1076cmd ::= REINDEX nm(X) dbnm(Y). {sqlite3Reindex(pParse, &X, &Y);}
drh154d4b22006-09-21 11:02:16 +00001077%endif SQLITE_OMIT_REINDEX
danielk19779fd2a9a2004-11-12 13:42:30 +00001078
drh9f18e8a2005-07-08 12:13:04 +00001079/////////////////////////////////// ANALYZE ///////////////////////////////////
1080%ifndef SQLITE_OMIT_ANALYZE
1081cmd ::= ANALYZE. {sqlite3Analyze(pParse, 0, 0);}
1082cmd ::= ANALYZE nm(X) dbnm(Y). {sqlite3Analyze(pParse, &X, &Y);}
1083%endif
1084
danielk19779fd2a9a2004-11-12 13:42:30 +00001085//////////////////////// ALTER TABLE table ... ////////////////////////////////
1086%ifndef SQLITE_OMIT_ALTERTABLE
1087cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). {
1088 sqlite3AlterRenameTable(pParse,X,&Z);
1089}
danielk197719a8e7e2005-03-17 05:03:38 +00001090cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column(Y). {
1091 sqlite3AlterFinishAddColumn(pParse, &Y);
1092}
1093add_column_fullname ::= fullname(X). {
1094 sqlite3AlterBeginAddColumn(pParse, X);
1095}
1096kwcolumn_opt ::= .
1097kwcolumn_opt ::= COLUMNKW.
drh154d4b22006-09-21 11:02:16 +00001098%endif SQLITE_OMIT_ALTERTABLE
drhe09daa92006-06-10 13:29:31 +00001099
1100//////////////////////// CREATE VIRTUAL TABLE ... /////////////////////////////
1101%ifndef SQLITE_OMIT_VIRTUALTABLE
drhb9bb7c12006-06-11 23:41:55 +00001102cmd ::= create_vtab. {sqlite3VtabFinishParse(pParse,0);}
1103cmd ::= create_vtab LP vtabarglist RP(X). {sqlite3VtabFinishParse(pParse,&X);}
1104create_vtab ::= CREATE VIRTUAL TABLE nm(X) dbnm(Y) USING nm(Z). {
1105 sqlite3VtabBeginParse(pParse, &X, &Y, &Z);
1106}
drhe09daa92006-06-10 13:29:31 +00001107vtabarglist ::= vtabarg.
1108vtabarglist ::= vtabarglist COMMA vtabarg.
drhb9bb7c12006-06-11 23:41:55 +00001109vtabarg ::= . {sqlite3VtabArgInit(pParse);}
1110vtabarg ::= vtabarg vtabargtoken.
1111vtabargtoken ::= ANY(X). {sqlite3VtabArgExtend(pParse,&X);}
1112vtabargtoken ::= lp anylist RP(X). {sqlite3VtabArgExtend(pParse,&X);}
1113lp ::= LP(X). {sqlite3VtabArgExtend(pParse,&X);}
1114anylist ::= .
1115anylist ::= anylist ANY(X). {sqlite3VtabArgExtend(pParse,&X);}
drh154d4b22006-09-21 11:02:16 +00001116%endif SQLITE_OMIT_VIRTUALTABLE