/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** This file contains SQLite's grammar for SQL. Process this file

** using the lemon parser generator to generate C code that runs

** the parser. Lemon will also generate a header file containing

** numeric codes for all of the tokens.

**

** @(#) $Id: parse.y,v 1.275 2009/05/01 21:13:37 drh Exp $

*/

// All token codes are small integers with #defines that begin with "TK_"

%token_prefix TK_

// The type of the data attached to each token is Token. This is also the

// default type for non-terminals.

//

%token_type {Token}

%default_type {Token}

// The generated parser function takes a 4th argument as follows:

%extra_argument {Parse *pParse}

// This code runs whenever there is a syntax error

//

%syntax_error {

UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */

assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */

sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);

pParse->parseError = 1;

}

%stack_overflow {

UNUSED_PARAMETER(yypMinor); /* Silence some compiler warnings */

sqlite3ErrorMsg(pParse, "parser stack overflow");

pParse->parseError = 1;

}

// The name of the generated procedure that implements the parser

// is as follows:

%name sqlite3Parser

// The following text is included near the beginning of the C source

// code file that implements the parser.

//

%include {

#include "sqliteInt.h"

/*

** An instance of this structure holds information about the

** LIMIT clause of a SELECT statement.

*/

struct LimitVal {

Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */

Expr *pOffset; /* The OFFSET expression. NULL if there is none */

};

/*

** An instance of this structure is used to store the LIKE,

** GLOB, NOT LIKE, and NOT GLOB operators.

*/

struct LikeOp {

Token eOperator; /* "like" or "glob" or "regexp" */

int not; /* True if the NOT keyword is present */

};

/*

** An instance of the following structure describes the event of a

** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,

** TK_DELETE, or TK_INSTEAD. If the event is of the form

**

** UPDATE ON (a,b,c)

**

** Then the "b" IdList records the list "a,b,c".

*/

struct TrigEvent { int a; IdList * b; };

/*

** An instance of this structure holds the ATTACH key and the key type.

*/

struct AttachKey { int type; Token key; };

} // end %include

// Input is a single SQL command

input ::= cmdlist.

cmdlist ::= cmdlist ecmd.

cmdlist ::= ecmd.

ecmd ::= SEMI.

ecmd ::= explain cmdx SEMI.

explain ::= . { sqlite3BeginParse(pParse, 0); }

%ifndef SQLITE_OMIT_EXPLAIN

explain ::= EXPLAIN. { sqlite3BeginParse(pParse, 1); }

explain ::= EXPLAIN QUERY PLAN. { sqlite3BeginParse(pParse, 2); }

%endif SQLITE_OMIT_EXPLAIN

cmdx ::= cmd. { sqlite3FinishCoding(pParse); }

///////////////////// Begin and end transactions. ////////////////////////////

//

cmd ::= BEGIN transtype(Y) trans_opt. {sqlite3BeginTransaction(pParse, Y);}

trans_opt ::= .

trans_opt ::= TRANSACTION.

trans_opt ::= TRANSACTION nm.

%type transtype {int}

transtype(A) ::= . {A = TK_DEFERRED;}

transtype(A) ::= DEFERRED(X). {A = @X;}

transtype(A) ::= IMMEDIATE(X). {A = @X;}

transtype(A) ::= EXCLUSIVE(X). {A = @X;}

cmd ::= COMMIT trans_opt. {sqlite3CommitTransaction(pParse);}

cmd ::= END trans_opt. {sqlite3CommitTransaction(pParse);}

cmd ::= ROLLBACK trans_opt. {sqlite3RollbackTransaction(pParse);}

savepoint_opt ::= SAVEPOINT.

savepoint_opt ::= .

cmd ::= SAVEPOINT nm(X). {

sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X);

}

cmd ::= RELEASE savepoint_opt nm(X). {

sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &X);

}

cmd ::= ROLLBACK trans_opt TO savepoint_opt nm(X). {

sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &X);

}

///////////////////// The CREATE TABLE statement ////////////////////////////

//

cmd ::= create_table create_table_args.

create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {

sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);

}

createkw(A) ::= CREATE(X). {

pParse->db->lookaside.bEnabled = 0;

A = X;

}

%type ifnotexists {int}

ifnotexists(A) ::= . {A = 0;}

ifnotexists(A) ::= IF NOT EXISTS. {A = 1;}

%type temp {int}

%ifndef SQLITE_OMIT_TEMPDB

temp(A) ::= TEMP. {A = 1;}

%endif SQLITE_OMIT_TEMPDB

temp(A) ::= . {A = 0;}

create_table_args ::= LP columnlist conslist_opt(X) RP(Y). {

sqlite3EndTable(pParse,&X,&Y,0);

}

create_table_args ::= AS select(S). {

sqlite3EndTable(pParse,0,0,S);

sqlite3SelectDelete(pParse->db, S);

}

columnlist ::= columnlist COMMA column.

columnlist ::= column.

// A "column" is a complete description of a single column in a

// CREATE TABLE statement. This includes the column name, its

// datatype, and other keywords such as PRIMARY KEY, UNIQUE, REFERENCES,

// NOT NULL and so forth.

//

column(A) ::= columnid(X) type carglist. {

A.z = X.z;

A.n = (int)(pParse->sLastToken.z-X.z) + pParse->sLastToken.n;

A.quoted = 0;

A.dyn = 0;

}

columnid(A) ::= nm(X). {

sqlite3AddColumn(pParse,&X);

A = X;

}

// An IDENTIFIER can be a generic identifier, or one of several

// keywords. Any non-standard keyword can also be an identifier.

//

%type id {Token}

id(A) ::= ID(X). {A = X;}

id(A) ::= INDEXED(X). {A = X;}

// The following directive causes tokens ABORT, AFTER, ASC, etc. to

// fallback to ID if they will not parse as their original value.

// This obviates the need for the "id" nonterminal.

//

%fallback ID

ABORT AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST COLUMNKW CONFLICT

DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR

IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH PLAN

QUERY KEY OF OFFSET PRAGMA RAISE RELEASE REPLACE RESTRICT ROW ROLLBACK

SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL

%ifdef SQLITE_OMIT_COMPOUND_SELECT

EXCEPT INTERSECT UNION

%endif SQLITE_OMIT_COMPOUND_SELECT

REINDEX RENAME CTIME_KW IF

.

%wildcard ANY.

// Define operator precedence early so that this is the first occurance

// of the operator tokens in the grammer. Keeping the operators together

// causes them to be assigned integer values that are close together,

// which keeps parser tables smaller.

//

// The token values assigned to these symbols is determined by the order

// in which lemon first sees them. It must be the case that ISNULL/NOTNULL,

// NE/EQ, GT/LE, and GE/LT are separated by only a single value. See

// the sqlite3ExprIfFalse() routine for additional information on this

// constraint.

//

%left OR.

%left AND.

%right NOT.

%left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.

%left GT LE LT GE.

%right ESCAPE.

%left BITAND BITOR LSHIFT RSHIFT.

%left PLUS MINUS.

%left STAR SLASH REM.

%left CONCAT.

%left COLLATE.

%right UMINUS UPLUS BITNOT.

// And "ids" is an identifer-or-string.

//

%type ids {Token}

ids(A) ::= ID|STRING(X). {A = X;}

// The name of a column or table can be any of the following:

//

%type nm {Token}

nm(A) ::= id(X). {A = X;}

nm(A) ::= STRING(X). {A = X;}

nm(A) ::= JOIN_KW(X). {A = X;}

// A typetoken is really one or more tokens that form a type name such

// as can be found after the column name in a CREATE TABLE statement.

// Multiple tokens are concatenated to form the value of the typetoken.

//

%type typetoken {Token}

type ::= .

type ::= typetoken(X). {sqlite3AddColumnType(pParse,&X);}

typetoken(A) ::= typename(X). {A = X;}

typetoken(A) ::= typename(X) LP signed RP(Y). {

A.z = X.z;

A.n = (int)(&Y.z[Y.n] - X.z);

}

typetoken(A) ::= typename(X) LP signed COMMA signed RP(Y). {

A.z = X.z;

A.n = (int)(&Y.z[Y.n] - X.z);

}

%type typename {Token}

typename(A) ::= ids(X). {A = X;}

typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(int)(Y.z-X.z);}

signed ::= plus_num.

signed ::= minus_num.

// "carglist" is a list of additional constraints that come after the

// column name and column type in a CREATE TABLE statement.

//

carglist ::= carglist carg.

carglist ::= .

carg ::= CONSTRAINT nm ccons.

carg ::= ccons.

ccons ::= DEFAULT term(X). {sqlite3AddDefaultValue(pParse,X);}

ccons ::= DEFAULT LP expr(X) RP. {sqlite3AddDefaultValue(pParse,X);}

ccons ::= DEFAULT PLUS term(X). {sqlite3AddDefaultValue(pParse,X);}

ccons ::= DEFAULT MINUS(A) term(X). {

Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);

sqlite3ExprSpan(p,&A,&X->span);

sqlite3AddDefaultValue(pParse,p);

}

ccons ::= DEFAULT id(X). {

Expr *p = sqlite3PExpr(pParse, TK_STRING, 0, 0, &X);

sqlite3AddDefaultValue(pParse,p);

}

// In addition to the type name, we also care about the primary key and

// UNIQUE constraints.

//

ccons ::= NULL onconf.

ccons ::= NOT NULL onconf(R). {sqlite3AddNotNull(pParse, R);}

ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).

{sqlite3AddPrimaryKey(pParse,0,R,I,Z);}

ccons ::= UNIQUE onconf(R). {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0);}

ccons ::= CHECK LP expr(X) RP. {sqlite3AddCheckConstraint(pParse,X);}

ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).

{sqlite3CreateForeignKey(pParse,0,&T,TA,R);}

ccons ::= defer_subclause(D). {sqlite3DeferForeignKey(pParse,D);}

ccons ::= COLLATE ids(C). {sqlite3AddCollateType(pParse, &C);}

// The optional AUTOINCREMENT keyword

%type autoinc {int}

autoinc(X) ::= . {X = 0;}

autoinc(X) ::= AUTOINCR. {X = 1;}

// The next group of rules parses the arguments to a REFERENCES clause

// that determine if the referential integrity checking is deferred or

// or immediate and which determine what action to take if a ref-integ

// check fails.

//

%type refargs {int}

refargs(A) ::= . { A = OE_Restrict * 0x010101; }

refargs(A) ::= refargs(X) refarg(Y). { A = (X & ~Y.mask) | Y.value; }

%type refarg {struct {int value; int mask;}}

refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; }

refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; }

refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; }

refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; }

%type refact {int}

refact(A) ::= SET NULL. { A = OE_SetNull; }

refact(A) ::= SET DEFAULT. { A = OE_SetDflt; }

refact(A) ::= CASCADE. { A = OE_Cascade; }

refact(A) ::= RESTRICT. { A = OE_Restrict; }

%type defer_subclause {int}

defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X). {A = X;}

defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;}

%type init_deferred_pred_opt {int}

init_deferred_pred_opt(A) ::= . {A = 0;}

init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;}

init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;}

// For the time being, the only constraint we care about is the primary

// key and UNIQUE. Both create indices.

//

conslist_opt(A) ::= . {A.n = 0; A.z = 0;}

conslist_opt(A) ::= COMMA(X) conslist. {A = X;}

conslist ::= conslist COMMA tcons.

conslist ::= conslist tcons.

conslist ::= tcons.

tcons ::= CONSTRAINT nm.

tcons ::= PRIMARY KEY LP idxlist(X) autoinc(I) RP onconf(R).

{sqlite3AddPrimaryKey(pParse,X,R,I,0);}

tcons ::= UNIQUE LP idxlist(X) RP onconf(R).

{sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0);}

tcons ::= CHECK LP expr(E) RP onconf. {sqlite3AddCheckConstraint(pParse,E);}

tcons ::= FOREIGN KEY LP idxlist(FA) RP

REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {

sqlite3CreateForeignKey(pParse, FA, &T, TA, R);

sqlite3DeferForeignKey(pParse, D);

}

%type defer_subclause_opt {int}

defer_subclause_opt(A) ::= . {A = 0;}

defer_subclause_opt(A) ::= defer_subclause(X). {A = X;}

// The following is a non-standard extension that allows us to declare the

// default behavior when there is a constraint conflict.

//

%type onconf {int}

%type orconf {int}

%type resolvetype {int}

onconf(A) ::= . {A = OE_Default;}

onconf(A) ::= ON CONFLICT resolvetype(X). {A = X;}

orconf(A) ::= . {A = OE_Default;}

orconf(A) ::= OR resolvetype(X). {A = X;}

resolvetype(A) ::= raisetype(X). {A = X;}

resolvetype(A) ::= IGNORE. {A = OE_Ignore;}

resolvetype(A) ::= REPLACE. {A = OE_Replace;}

////////////////////////// The DROP TABLE /////////////////////////////////////

//

cmd ::= DROP TABLE ifexists(E) fullname(X). {

sqlite3DropTable(pParse, X, 0, E);

}

%type ifexists {int}

ifexists(A) ::= IF EXISTS. {A = 1;}

ifexists(A) ::= . {A = 0;}

///////////////////// The CREATE VIEW statement /////////////////////////////

//

%ifndef SQLITE_OMIT_VIEW

cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) AS select(S). {

sqlite3CreateView(pParse, &X, &Y, &Z, S, T, E);

}

cmd ::= DROP VIEW ifexists(E) fullname(X). {

sqlite3DropTable(pParse, X, 1, E);

}

%endif SQLITE_OMIT_VIEW

//////////////////////// The SELECT statement /////////////////////////////////

//

cmd ::= select(X). {

SelectDest dest = {SRT_Output, 0, 0, 0, 0};

sqlite3Select(pParse, X, &dest);

sqlite3SelectDelete(pParse->db, X);

}

%type select {Select*}

%destructor select {sqlite3SelectDelete(pParse->db, $$);}

%type oneselect {Select*}

%destructor oneselect {sqlite3SelectDelete(pParse->db, $$);}

select(A) ::= oneselect(X). {A = X;}

%ifndef SQLITE_OMIT_COMPOUND_SELECT

select(A) ::= select(X) multiselect_op(Y) oneselect(Z). {

if( Z ){

Z->op = (u8)Y;

Z->pPrior = X;

}else{

sqlite3SelectDelete(pParse->db, X);

}

A = Z;

}

%type multiselect_op {int}

multiselect_op(A) ::= UNION(OP). {A = @OP;}

multiselect_op(A) ::= UNION ALL. {A = TK_ALL;}

multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP;}

%endif SQLITE_OMIT_COMPOUND_SELECT

oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)

groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {

A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);

}

// The "distinct" nonterminal is true (1) if the DISTINCT keyword is

// present and false (0) if it is not.

//

%type distinct {int}

distinct(A) ::= DISTINCT. {A = 1;}

distinct(A) ::= ALL. {A = 0;}

distinct(A) ::= . {A = 0;}

// selcollist is a list of expressions that are to become the return

// values of the SELECT statement. The "*" in statements like

// "SELECT * FROM ..." is encoded as a special expression with an

// opcode of TK_ALL.

//

%type selcollist {ExprList*}

%destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);}

%type sclp {ExprList*}

%destructor sclp {sqlite3ExprListDelete(pParse->db, $$);}

sclp(A) ::= selcollist(X) COMMA. {A = X;}

sclp(A) ::= . {A = 0;}

selcollist(A) ::= sclp(P) expr(X) as(Y). {

A = sqlite3ExprListAppend(pParse,P,X,Y.n?&Y:0);

}

selcollist(A) ::= sclp(P) STAR. {

Expr *p = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);

A = sqlite3ExprListAppend(pParse, P, p, 0);

}

selcollist(A) ::= sclp(P) nm(X) DOT STAR(Y). {

Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &Y);

Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);

Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);

A = sqlite3ExprListAppend(pParse,P, pDot, 0);

}

// An option "AS <id>" phrase that can follow one of the expressions that

// define the result set, or one of the tables in the FROM clause.

//

%type as {Token}

as(X) ::= AS nm(Y). {X = Y;}

as(X) ::= ids(Y). {X = Y;}

as(X) ::= . {X.n = 0;}

%type seltablist {SrcList*}

%destructor seltablist {sqlite3SrcListDelete(pParse->db, $$);}

%type stl_prefix {SrcList*}

%destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);}

%type from {SrcList*}

%destructor from {sqlite3SrcListDelete(pParse->db, $$);}

// A complete FROM clause.

//

from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}

from(A) ::= FROM seltablist(X). {

A = X;

sqlite3SrcListShiftJoinType(A);

}

// "seltablist" is a "Select Table List" - the content of the FROM clause

// in a SELECT statement. "stl_prefix" is a prefix of this list.

//

stl_prefix(A) ::= seltablist(X) joinop(Y). {

A = X;

if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = (u8)Y;

}

stl_prefix(A) ::= . {A = 0;}

seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) indexed_opt(I) on_opt(N) using_opt(U). {

A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U);

sqlite3SrcListIndexedBy(pParse, A, &I);

}

%ifndef SQLITE_OMIT_SUBQUERY

seltablist(A) ::= stl_prefix(X) LP select(S) RP

as(Z) on_opt(N) using_opt(U). {

A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U);

}

seltablist(A) ::= stl_prefix(X) LP seltablist(F) RP

as(Z) on_opt(N) using_opt(U). {

if( X==0 && Z.n==0 && N==0 && U==0 ){

A = F;

}else{

Select *pSubquery;

sqlite3SrcListShiftJoinType(F);

pSubquery = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);

A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,pSubquery,N,U);

}

}

// A seltablist_paren nonterminal represents anything in a FROM that

// is contained inside parentheses. This can be either a subquery or

// a grouping of table and subqueries.

//

// %type seltablist_paren {Select*}

// %destructor seltablist_paren {sqlite3SelectDelete(pParse->db, $$);}

// seltablist_paren(A) ::= select(S). {A = S;}

// seltablist_paren(A) ::= seltablist(F). {

// sqlite3SrcListShiftJoinType(F);

// A = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);

// }

%endif SQLITE_OMIT_SUBQUERY

%type dbnm {Token}

dbnm(A) ::= . {A.z=0; A.n=0;}

dbnm(A) ::= DOT nm(X). {A = X;}

%type fullname {SrcList*}

%destructor fullname {sqlite3SrcListDelete(pParse->db, $$);}

fullname(A) ::= nm(X) dbnm(Y). {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y);}

%type joinop {int}

%type joinop2 {int}

joinop(X) ::= COMMA|JOIN. { X = JT_INNER; }

joinop(X) ::= JOIN_KW(A) JOIN. { X = sqlite3JoinType(pParse,&A,0,0); }

joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqlite3JoinType(pParse,&A,&B,0); }

joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.

{ X = sqlite3JoinType(pParse,&A,&B,&C); }

%type on_opt {Expr*}

%destructor on_opt {sqlite3ExprDelete(pParse->db, $$);}

on_opt(N) ::= ON expr(E). {N = E;}

on_opt(N) ::= . {N = 0;}

// Note that this block abuses the Token type just a little. If there is

// no "INDEXED BY" clause, the returned token is empty (z==0 && n==0). If

// there is an INDEXED BY clause, then the token is populated as per normal,

// with z pointing to the token data and n containing the number of bytes

// in the token.

//

// If there is a "NOT INDEXED" clause, then (z==0 && n==1), which is

// normally illegal. The sqlite3SrcListIndexedBy() function

// recognizes and interprets this as a special case.

//

%type indexed_opt {Token}

indexed_opt(A) ::= . {A.z=0; A.n=0;}

indexed_opt(A) ::= INDEXED BY nm(X). {A = X;}

indexed_opt(A) ::= NOT INDEXED. {A.z=0; A.n=1;}

%type using_opt {IdList*}

%destructor using_opt {sqlite3IdListDelete(pParse->db, $$);}

using_opt(U) ::= USING LP inscollist(L) RP. {U = L;}

using_opt(U) ::= . {U = 0;}

%type orderby_opt {ExprList*}

%destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);}

%type sortlist {ExprList*}

%destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);}

%type sortitem {Expr*}

%destructor sortitem {sqlite3ExprDelete(pParse->db, $$);}

orderby_opt(A) ::= . {A = 0;}

orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}

sortlist(A) ::= sortlist(X) COMMA sortitem(Y) sortorder(Z). {

A = sqlite3ExprListAppend(pParse,X,Y,0);

if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;

}

sortlist(A) ::= sortitem(Y) sortorder(Z). {

A = sqlite3ExprListAppend(pParse,0,Y,0);

if( A && A->a ) A->a[0].sortOrder = (u8)Z;

}

sortitem(A) ::= expr(X). {A = X;}

%type sortorder {int}

sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;}

sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;}

sortorder(A) ::= . {A = SQLITE_SO_ASC;}

%type groupby_opt {ExprList*}

%destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);}

groupby_opt(A) ::= . {A = 0;}

groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}

%type having_opt {Expr*}

%destructor having_opt {sqlite3ExprDelete(pParse->db, $$);}

having_opt(A) ::= . {A = 0;}

having_opt(A) ::= HAVING expr(X). {A = X;}

%type limit_opt {struct LimitVal}

// The destructor for limit_opt will never fire in the current grammar.

// The limit_opt non-terminal only occurs at the end of a single production

// rule for SELECT statements. As soon as the rule that create the

// limit_opt non-terminal reduces, the SELECT statement rule will also

// reduce. So there is never a limit_opt non-terminal on the stack

// except as a transient. So there is never anything to destroy.

//

//%destructor limit_opt {

// sqlite3ExprDelete(pParse->db, $$.pLimit);

// sqlite3ExprDelete(pParse->db, $$.pOffset);

//}

limit_opt(A) ::= . {A.pLimit = 0; A.pOffset = 0;}

limit_opt(A) ::= LIMIT expr(X). {A.pLimit = X; A.pOffset = 0;}

limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y).

{A.pLimit = X; A.pOffset = Y;}

limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y).

{A.pOffset = X; A.pLimit = Y;}

/////////////////////////// The DELETE statement /////////////////////////////

//

%ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

cmd ::= DELETE FROM fullname(X) indexed_opt(I) where_opt(W)

orderby_opt(O) limit_opt(L). {

sqlite3SrcListIndexedBy(pParse, X, &I);

W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "DELETE");

sqlite3DeleteFrom(pParse,X,W);

}

%endif

%ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

cmd ::= DELETE FROM fullname(X) indexed_opt(I) where_opt(W). {

sqlite3SrcListIndexedBy(pParse, X, &I);

sqlite3DeleteFrom(pParse,X,W);

}

%endif

%type where_opt {Expr*}

%destructor where_opt {sqlite3ExprDelete(pParse->db, $$);}

where_opt(A) ::= . {A = 0;}

where_opt(A) ::= WHERE expr(X). {A = X;}

////////////////////////// The UPDATE command ////////////////////////////////

//

%ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

cmd ::= UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y) where_opt(W) orderby_opt(O) limit_opt(L). {

sqlite3SrcListIndexedBy(pParse, X, &I);

sqlite3ExprListCheckLength(pParse,Y,"set list");

W = sqlite3LimitWhere(pParse, X, W, O, L.pLimit, L.pOffset, "UPDATE");

sqlite3Update(pParse,X,Y,W,R);

}

%endif

%ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

cmd ::= UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y) where_opt(W). {

sqlite3SrcListIndexedBy(pParse, X, &I);

sqlite3ExprListCheckLength(pParse,Y,"set list");

sqlite3Update(pParse,X,Y,W,R);

}

%endif

%type setlist {ExprList*}

%destructor setlist {sqlite3ExprListDelete(pParse->db, $$);}

setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).

{A = sqlite3ExprListAppend(pParse,Z,Y,&X);}

setlist(A) ::= nm(X) EQ expr(Y).

{A = sqlite3ExprListAppend(pParse,0,Y,&X);}

////////////////////////// The INSERT command /////////////////////////////////

//

cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F)

VALUES LP itemlist(Y) RP.

{sqlite3Insert(pParse, X, Y, 0, F, R);}

cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) select(S).

{sqlite3Insert(pParse, X, 0, S, F, R);}

cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) DEFAULT VALUES.

{sqlite3Insert(pParse, X, 0, 0, F, R);}

%type insert_cmd {int}

insert_cmd(A) ::= INSERT orconf(R). {A = R;}

insert_cmd(A) ::= REPLACE. {A = OE_Replace;}

%type itemlist {ExprList*}

%destructor itemlist {sqlite3ExprListDelete(pParse->db, $$);}

itemlist(A) ::= itemlist(X) COMMA expr(Y).

{A = sqlite3ExprListAppend(pParse,X,Y,0);}

itemlist(A) ::= expr(X).

{A = sqlite3ExprListAppend(pParse,0,X,0);}

%type inscollist_opt {IdList*}

%destructor inscollist_opt {sqlite3IdListDelete(pParse->db, $$);}

%type inscollist {IdList*}

%destructor inscollist {sqlite3IdListDelete(pParse->db, $$);}

inscollist_opt(A) ::= . {A = 0;}

inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;}

inscollist(A) ::= inscollist(X) COMMA nm(Y).

{A = sqlite3IdListAppend(pParse->db,X,&Y);}

inscollist(A) ::= nm(Y).

{A = sqlite3IdListAppend(pParse->db,0,&Y);}

/////////////////////////// Expression Processing /////////////////////////////

//

%type expr {Expr*}

%destructor expr {sqlite3ExprDelete(pParse->db, $$);}

%type term {Expr*}

%destructor term {sqlite3ExprDelete(pParse->db, $$);}

expr(A) ::= term(X). {A = X;}

expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqlite3ExprSpan(A,&B,&E); }

term(A) ::= NULL(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}

expr(A) ::= id(X). {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}

expr(A) ::= JOIN_KW(X). {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}

expr(A) ::= nm(X) DOT nm(Y). {

Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);

Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);

A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);

}

expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {

Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);

Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);

Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Z);

Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);

A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);

}

term(A) ::= INTEGER|FLOAT|BLOB(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}

term(A) ::= STRING(X). {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}

expr(A) ::= REGISTER(X). {A = sqlite3RegisterExpr(pParse, &X);}

expr(A) ::= VARIABLE(X). {

Token *pToken = &X;

Expr *pExpr = A = sqlite3PExpr(pParse, TK_VARIABLE, 0, 0, pToken);

sqlite3ExprAssignVarNumber(pParse, pExpr);

}

expr(A) ::= expr(E) COLLATE ids(C). {

A = sqlite3ExprSetColl(pParse, E, &C);

}

%ifndef SQLITE_OMIT_CAST

expr(A) ::= CAST(X) LP expr(E) AS typetoken(T) RP(Y). {

A = sqlite3PExpr(pParse, TK_CAST, E, 0, &T);

sqlite3ExprSpan(A,&X,&Y);

}

%endif SQLITE_OMIT_CAST

expr(A) ::= ID(X) LP distinct(D) exprlist(Y) RP(E). {

if( Y && Y->nExpr>SQLITE_MAX_FUNCTION_ARG ){

sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X);

}

A = sqlite3ExprFunction(pParse, Y, &X);

sqlite3ExprSpan(A,&X,&E);

if( D && A ){

A->flags |= EP_Distinct;

}

}

expr(A) ::= ID(X) LP STAR RP(E). {

A = sqlite3ExprFunction(pParse, 0, &X);

sqlite3ExprSpan(A,&X,&E);

}

term(A) ::= CTIME_KW(OP). {

/* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are

** treated as functions that return constants */

A = sqlite3ExprFunction(pParse, 0,&OP);

if( A ){

A->op = TK_CONST_FUNC;

A->span = OP;

}

}

expr(A) ::= expr(X) AND(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) OR(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) LT|GT|GE|LE(OP) expr(Y).

{A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) EQ|NE(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).

{A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) PLUS|MINUS(OP) expr(Y).{A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) STAR|SLASH|REM(OP) expr(Y).

{A = sqlite3PExpr(pParse,@OP,X,Y,0);}

expr(A) ::= expr(X) CONCAT(OP) expr(Y). {A = sqlite3PExpr(pParse,@OP,X,Y,0);}

%type likeop {struct LikeOp}

likeop(A) ::= LIKE_KW(X). {A.eOperator = X; A.not = 0;}

likeop(A) ::= NOT LIKE_KW(X). {A.eOperator = X; A.not = 1;}

likeop(A) ::= MATCH(X). {A.eOperator = X; A.not = 0;}

likeop(A) ::= NOT MATCH(X). {A.eOperator = X; A.not = 1;}

%type escape {Expr*}

%destructor escape {sqlite3ExprDelete(pParse->db, $$);}

escape(X) ::= ESCAPE expr(A). [ESCAPE] {X = A;}

escape(X) ::= . [ESCAPE] {X = 0;}

expr(A) ::= expr(X) likeop(OP) expr(Y) escape(E). [LIKE_KW] {

ExprList *pList;

pList = sqlite3ExprListAppend(pParse,0, Y, 0);

pList = sqlite3ExprListAppend(pParse,pList, X, 0);

if( E ){

pList = sqlite3ExprListAppend(pParse,pList, E, 0);

}

A = sqlite3ExprFunction(pParse, pList, &OP.eOperator);

if( OP.not ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);

sqlite3ExprSpan(A, &X->span, &Y->span);

if( A ) A->flags |= EP_InfixFunc;

}

expr(A) ::= expr(X) ISNULL|NOTNULL(E). {

A = sqlite3PExpr(pParse, @E, X, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= expr(X) IS NULL(E). {

A = sqlite3PExpr(pParse, TK_ISNULL, X, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= expr(X) NOT NULL(E). {

A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= expr(X) IS NOT NULL(E). {

A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= NOT(B) expr(X). {

A = sqlite3PExpr(pParse, @B, X, 0, 0);

sqlite3ExprSpan(A,&B,&X->span);

}

expr(A) ::= BITNOT(B) expr(X). {

A = sqlite3PExpr(pParse, @B, X, 0, 0);

sqlite3ExprSpan(A,&B,&X->span);

}

expr(A) ::= MINUS(B) expr(X). [UMINUS] {

A = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);

sqlite3ExprSpan(A,&B,&X->span);

}

expr(A) ::= PLUS(B) expr(X). [UPLUS] {

A = sqlite3PExpr(pParse, TK_UPLUS, X, 0, 0);

sqlite3ExprSpan(A,&B,&X->span);

}

%type between_op {int}

between_op(A) ::= BETWEEN. {A = 0;}

between_op(A) ::= NOT BETWEEN. {A = 1;}

expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {

ExprList *pList = sqlite3ExprListAppend(pParse,0, X, 0);

pList = sqlite3ExprListAppend(pParse,pList, Y, 0);

A = sqlite3PExpr(pParse, TK_BETWEEN, W, 0, 0);

if( A ){

A->x.pList = pList;

}else{

sqlite3ExprListDelete(pParse->db, pList);

}

if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);

sqlite3ExprSpan(A,&W->span,&Y->span);

}

%ifndef SQLITE_OMIT_SUBQUERY

%type in_op {int}

in_op(A) ::= IN. {A = 0;}

in_op(A) ::= NOT IN. {A = 1;}

expr(A) ::= expr(X) in_op(N) LP exprlist(Y) RP(E). [IN] {

A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);

if( A ){

A->x.pList = Y;

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3ExprListDelete(pParse->db, Y);

}

if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= LP(B) select(X) RP(E). {

A = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);

if( A ){

A->x.pSelect = X;

ExprSetProperty(A, EP_xIsSelect);

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3SelectDelete(pParse->db, X);

}

sqlite3ExprSpan(A,&B,&E);

}

expr(A) ::= expr(X) in_op(N) LP select(Y) RP(E). [IN] {

A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);

if( A ){

A->x.pSelect = Y;

ExprSetProperty(A, EP_xIsSelect);

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3SelectDelete(pParse->db, Y);

}

if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);

sqlite3ExprSpan(A,&X->span,&E);

}

expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {

SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);

A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);

if( A ){

A->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);

ExprSetProperty(A, EP_xIsSelect);

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3SrcListDelete(pParse->db, pSrc);

}

if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);

sqlite3ExprSpan(A,&X->span,Z.z?&Z:&Y);

}

expr(A) ::= EXISTS(B) LP select(Y) RP(E). {

Expr *p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);

if( p ){

p->x.pSelect = Y;

ExprSetProperty(A, EP_xIsSelect);

sqlite3ExprSpan(p,&B,&E);

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3SelectDelete(pParse->db, Y);

}

}

%endif SQLITE_OMIT_SUBQUERY

/* CASE expressions */

expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {

A = sqlite3PExpr(pParse, TK_CASE, X, Z, 0);

if( A ){

A->x.pList = Y;

sqlite3ExprSetHeight(pParse, A);

}else{

sqlite3ExprListDelete(pParse->db, Y);

}

sqlite3ExprSpan(A, &C, &E);

}

%type case_exprlist {ExprList*}

%destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);}

case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {

A = sqlite3ExprListAppend(pParse,X, Y, 0);

A = sqlite3ExprListAppend(pParse,A, Z, 0);

}

case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {

A = sqlite3ExprListAppend(pParse,0, Y, 0);

A = sqlite3ExprListAppend(pParse,A, Z, 0);

}

%type case_else {Expr*}

%destructor case_else {sqlite3ExprDelete(pParse->db, $$);}

case_else(A) ::= ELSE expr(X). {A = X;}

case_else(A) ::= . {A = 0;}

%type case_operand {Expr*}

%destructor case_operand {sqlite3ExprDelete(pParse->db, $$);}

case_operand(A) ::= expr(X). {A = X;}

case_operand(A) ::= . {A = 0;}

%type exprlist {ExprList*}

%destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);}

%type nexprlist {ExprList*}

%destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);}

exprlist(A) ::= nexprlist(X). {A = X;}

exprlist(A) ::= . {A = 0;}

nexprlist(A) ::= nexprlist(X) COMMA expr(Y).

{A = sqlite3ExprListAppend(pParse,X,Y,0);}

nexprlist(A) ::= expr(Y).

{A = sqlite3ExprListAppend(pParse,0,Y,0);}

///////////////////////////// The CREATE INDEX command ///////////////////////

//

cmd ::= createkw(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)

ON nm(Y) LP idxlist(Z) RP(E). {

sqlite3CreateIndex(pParse, &X, &D,

sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U,

&S, &E, SQLITE_SO_ASC, NE);

}

%type uniqueflag {int}

uniqueflag(A) ::= UNIQUE. {A = OE_Abort;}

uniqueflag(A) ::= . {A = OE_None;}

%type idxlist {ExprList*}

%destructor idxlist {sqlite3ExprListDelete(pParse->db, $$);}

%type idxlist_opt {ExprList*}

%destructor idxlist_opt {sqlite3ExprListDelete(pParse->db, $$);}

idxlist_opt(A) ::= . {A = 0;}

idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;}

idxlist(A) ::= idxlist(X) COMMA nm(Y) collate(C) sortorder(Z). {

Expr *p = 0;

if( C.n>0 ){

p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);

sqlite3ExprSetColl(pParse, p, &C);

}

A = sqlite3ExprListAppend(pParse,X, p, &Y);

sqlite3ExprListCheckLength(pParse, A, "index");

if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;

}

idxlist(A) ::= nm(Y) collate(C) sortorder(Z). {

Expr *p = 0;

if( C.n>0 ){

p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);

sqlite3ExprSetColl(pParse, p, &C);

}

A = sqlite3ExprListAppend(pParse,0, p, &Y);

sqlite3ExprListCheckLength(pParse, A, "index");

if( A ) A->a[A->nExpr-1].sortOrder = (u8)Z;

}

%type collate {Token}

collate(C) ::= . {C.z = 0; C.n = 0;}

collate(C) ::= COLLATE ids(X). {C = X;}

///////////////////////////// The DROP INDEX command /////////////////////////

//

cmd ::= DROP INDEX ifexists(E) fullname(X). {sqlite3DropIndex(pParse, X, E);}

///////////////////////////// The VACUUM command /////////////////////////////

//

%ifndef SQLITE_OMIT_VACUUM