%token_prefix TK_

%token_type {Token}

%default_type {Token}

%extra_argument {Parse *pParse}

%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);

}

%stack_overflow {

sqlite3ErrorMsg(pParse, "parser stack overflow");

}

%name sqlite3Parser

%include {

#include "sqliteInt.h"

#define YYNOERRORRECOVERY 1

#define yytestcase(X) testcase(X)

#define YYPARSEFREENEVERNULL 1

#ifdef SQLITE_AMALGAMATION

# define sqlite3Parser_ENGINEALWAYSONSTACK 1

#endif

#define YYMALLOCARGTYPE u64

struct LimitVal {

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

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

};

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

static void disableLookaside(Parse *pParse){

pParse->disableLookaside++;

pParse->db->lookaside.bDisable++;

}

} // end %include

input ::= cmdlist.

cmdlist ::= cmdlist ecmd.

cmdlist ::= ecmd.

ecmd ::= SEMI.

ecmd ::= explain cmdx SEMI.

explain ::= .

%ifndef SQLITE_OMIT_EXPLAIN

explain ::= EXPLAIN. { pParse->explain = 1; }

explain ::= EXPLAIN QUERY PLAN. { pParse->explain = 2; }

%endif SQLITE_OMIT_EXPLAIN

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

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; /*A-overwrites-X*/}

transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/}

transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/}

cmd ::= COMMIT|END(X) trans_opt. {sqlite3EndTransaction(pParse,@X);}

cmd ::= ROLLBACK(X) trans_opt. {sqlite3EndTransaction(pParse,@X);}

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);

}

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(A). {disableLookaside(pParse);}

%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(E) table_options(F). {

sqlite3EndTable(pParse,&X,&E,F,0);

}

create_table_args ::= AS select(S). {

sqlite3EndTable(pParse,0,0,0,S);

sqlite3SelectDelete(pParse->db, S);

}

%type table_options {int}

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

table_options(A) ::= WITHOUT nm(X). {

if( X.n==5 && sqlite3_strnicmp(X.z,"rowid",5)==0 ){

A = TF_WithoutRowid | TF_NoVisibleRowid;

}else{

A = 0;

sqlite3ErrorMsg(pParse, "unknown table option: %.*s", X.n, X.z);

}

}

columnlist ::= columnlist COMMA columnname carglist.

columnlist ::= columnname carglist.

columnname(A) ::= nm(A) typetoken(Y). {sqlite3AddColumn(pParse,&A,&Y);}

%fallback ID

ABORT ACTION 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 NO PLAN

QUERY KEY OF OFFSET PRAGMA RAISE RECURSIVE RELEASE REPLACE RESTRICT ROW

ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT

%ifdef SQLITE_OMIT_COMPOUND_SELECT

EXCEPT INTERSECT UNION

%endif SQLITE_OMIT_COMPOUND_SELECT

REINDEX RENAME CTIME_KW IF

.

%wildcard ANY.

%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 BITNOT.

%token_class id ID|INDEXED.

%token_class ids ID|STRING.

%type nm {Token}

nm(A) ::= id(A).

nm(A) ::= STRING(A).

nm(A) ::= JOIN_KW(A).

%type typetoken {Token}

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

typetoken(A) ::= typename(A).

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

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

}

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

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

}

%type typename {Token}

typename(A) ::= ids(A).

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

signed ::= plus_num.

signed ::= minus_num.

carglist ::= carglist ccons.

carglist ::= .

ccons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}

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). {

ExprSpan v;

v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, X.pExpr, 0);

v.zStart = A.z;

v.zEnd = X.zEnd;

sqlite3AddDefaultValue(pParse,&v);

}

ccons ::= DEFAULT id(X). {

ExprSpan v;

spanExpr(&v, pParse, TK_STRING, X);

sqlite3AddDefaultValue(pParse,&v);

}

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,

SQLITE_IDXTYPE_UNIQUE);}

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

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

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

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

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

%type autoinc {int}

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

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

%type refargs {int}

refargs(A) ::= . { A = OE_None*0x0101; /* EV: R-19803-45884 */}

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

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

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

refarg(A) ::= ON INSERT refact. { 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; }

%type refact {int}

refact(A) ::= SET NULL. { A = OE_SetNull; /* EV: R-33326-45252 */}

refact(A) ::= SET DEFAULT. { A = OE_SetDflt; /* EV: R-33326-45252 */}

refact(A) ::= CASCADE. { A = OE_Cascade; /* EV: R-33326-45252 */}

refact(A) ::= RESTRICT. { A = OE_Restrict; /* EV: R-33326-45252 */}

refact(A) ::= NO ACTION. { A = OE_None; /* EV: R-33326-45252 */}

%type defer_subclause {int}

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

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;}

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

conslist_opt(A) ::= COMMA(A) conslist.

conslist ::= conslist tconscomma tcons.

conslist ::= tcons.

tconscomma ::= COMMA. {pParse->constraintName.n = 0;}

tconscomma ::= .

tcons ::= CONSTRAINT nm(X). {pParse->constraintName = X;}

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

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

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

{sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0,

SQLITE_IDXTYPE_UNIQUE);}

tcons ::= CHECK LP expr(E) RP onconf.

{sqlite3AddCheckConstraint(pParse,E.pExpr);}

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

REFERENCES nm(T) eidlist_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(A).

%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(A).

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

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

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;}

%ifndef SQLITE_OMIT_VIEW

cmd ::= createkw(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) eidlist_opt(C)

AS select(S). {

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

}

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

sqlite3DropTable(pParse, X, 1, E);

}

%endif SQLITE_OMIT_VIEW

cmd ::= select(X). {

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

sqlite3Select(pParse, X, &dest);

sqlite3SelectDelete(pParse->db, X);

}

%type select {Select*}

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

%type selectnowith {Select*}

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

%type oneselect {Select*}

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

%include {

/*

static void parserDoubleLinkSelect(Parse *pParse, Select *p){

if( p->pPrior ){

Select *pNext = 0, *pLoop;

int mxSelect, cnt = 0;

for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){

pLoop->pNext = pNext;

pLoop->selFlags |= SF_Compound;

}

if( (p->selFlags & SF_MultiValue)==0 &&

(mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&

cnt>mxSelect

){

sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");

}

}

}

}

select(A) ::= with(W) selectnowith(X). {

Select *p = X;

if( p ){

p->pWith = W;

parserDoubleLinkSelect(pParse, p);

}else{

sqlite3WithDelete(pParse->db, W);

}

A = p; /*A-overwrites-W*/

}

selectnowith(A) ::= oneselect(A).

%ifndef SQLITE_OMIT_COMPOUND_SELECT

selectnowith(A) ::= selectnowith(A) multiselect_op(Y) oneselect(Z). {

Select *pRhs = Z;

Select *pLhs = A;

if( pRhs && pRhs->pPrior ){

SrcList *pFrom;

Token x;

x.n = 0;

parserDoubleLinkSelect(pParse, pRhs);

pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);

pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);

}

if( pRhs ){

pRhs->op = (u8)Y;

pRhs->pPrior = pLhs;

if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;

pRhs->selFlags &= ~SF_MultiValue;

if( Y!=TK_ALL ) pParse->hasCompound = 1;

}else{

sqlite3SelectDelete(pParse->db, pLhs);

}

A = pRhs;

}

%type multiselect_op {int}

multiselect_op(A) ::= UNION(OP). {A = @OP; /*A-overwrites-OP*/}

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

multiselect_op(A) ::= EXCEPT|INTERSECT(OP). {A = @OP; /*A-overwrites-OP*/}

%endif SQLITE_OMIT_COMPOUND_SELECT

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

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

#if SELECTTRACE_ENABLED

Token s = S; /*A-overwrites-S*/

#endif

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

#if SELECTTRACE_ENABLED

/* Populate the Select.zSelName[] string that is used to help with

if( A!=0 ){

const char *z = s.z+6;

int i;

sqlite3_snprintf(sizeof(A->zSelName), A->zSelName, "#%d",

++pParse->nSelect);

while( z[0]==' ' ) z++;

if( z[0]=='/' && z[1]=='*' ){

z += 2;

while( z[0]==' ' ) z++;

for(i=0; sqlite3Isalnum(z[i]); i++){}

sqlite3_snprintf(sizeof(A->zSelName), A->zSelName, "%.*s", i, z);

}

}

#endif /* SELECTRACE_ENABLED */

}

oneselect(A) ::= values(A).

%type values {Select*}

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

values(A) ::= VALUES LP nexprlist(X) RP. {

A = sqlite3SelectNew(pParse,X,0,0,0,0,0,SF_Values,0,0);

}

values(A) ::= values(A) COMMA LP exprlist(Y) RP. {

Select *pRight, *pLeft = A;

pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values|SF_MultiValue,0,0);

if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;

if( pRight ){

pRight->op = TK_ALL;

pRight->pPrior = pLeft;

A = pRight;

}else{

A = pLeft;

}

}

%type distinct {int}

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

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

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

%type selcollist {ExprList*}

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

%type sclp {ExprList*}

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

sclp(A) ::= selcollist(A) COMMA.

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

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

A = sqlite3ExprListAppend(pParse, A, X.pExpr);

if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1);

sqlite3ExprListSetSpan(pParse,A,&X);

}

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

Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);

A = sqlite3ExprListAppend(pParse, A, p);

}

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

Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);

Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);

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

A = sqlite3ExprListAppend(pParse,A, pDot);

}

%type as {Token}

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

as(X) ::= ids(X).

as(X) ::= . {X.n = 0; X.z = 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, $$);}

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

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

A = X;

sqlite3SrcListShiftJoinType(A);

}

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

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

}

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

seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) as(Z) indexed_opt(I)

on_opt(N) using_opt(U). {

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

sqlite3SrcListIndexedBy(pParse, A, &I);

}

seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) LP exprlist(E) RP as(Z)

on_opt(N) using_opt(U). {

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

sqlite3SrcListFuncArgs(pParse, A, E);

}

%ifndef SQLITE_OMIT_SUBQUERY

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

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

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

}

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

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

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

A = F;

}else if( F->nSrc==1 ){

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

if( A ){

struct SrcList_item *pNew = &A->a[A->nSrc-1];

struct SrcList_item *pOld = F->a;

pNew->zName = pOld->zName;

pNew->zDatabase = pOld->zDatabase;

pNew->pSelect = pOld->pSelect;

pOld->zName = pOld->zDatabase = 0;

pOld->pSelect = 0;

}

sqlite3SrcListDelete(pParse->db, F);

}else{

Select *pSubquery;

sqlite3SrcListShiftJoinType(F);

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

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

}

}

%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); /*A-overwrites-X*/}

%type joinop {int}

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

joinop(X) ::= JOIN_KW(A) JOIN.

{X = sqlite3JoinType(pParse,&A,0,0); /*X-overwrites-A*/}

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

{X = sqlite3JoinType(pParse,&A,&B,0); /*X-overwrites-A*/}

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

{X = sqlite3JoinType(pParse,&A,&B,&C);/*X-overwrites-A*/}

%type on_opt {Expr*}

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

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

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

%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 idlist(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, $$);}

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

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

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

A = sqlite3ExprListAppend(pParse,A,Y.pExpr);

sqlite3ExprListSetSortOrder(A,Z);

}

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

A = sqlite3ExprListAppend(pParse,0,Y.pExpr); /*A-overwrites-Y*/

sqlite3ExprListSetSortOrder(A,Z);

}

%type sortorder {int}

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

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

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

%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.pExpr;}

%type limit_opt {struct LimitVal}

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

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

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

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

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

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

%ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

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

orderby_opt(O) limit_opt(L). {

sqlite3WithPush(pParse, C, 1);

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 ::= with(C) DELETE FROM fullname(X) indexed_opt(I) where_opt(W). {

sqlite3WithPush(pParse, C, 1);

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.pExpr;}

%ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

cmd ::= with(C) UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y)

where_opt(W) orderby_opt(O) limit_opt(L). {

sqlite3WithPush(pParse, C, 1);

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 ::= with(C) UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y)

where_opt(W). {

sqlite3WithPush(pParse, C, 1);

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(A) COMMA nm(X) EQ expr(Y). {

A = sqlite3ExprListAppend(pParse, A, Y.pExpr);

sqlite3ExprListSetName(pParse, A, &X, 1);

}

setlist(A) ::= setlist(A) COMMA LP idlist(X) RP EQ expr(Y). {

A = sqlite3ExprListAppendVector(pParse, A, X, Y.pExpr);

}

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

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

sqlite3ExprListSetName(pParse, A, &X, 1);

}

setlist(A) ::= LP idlist(X) RP EQ expr(Y). {

A = sqlite3ExprListAppendVector(pParse, 0, X, Y.pExpr);

}

cmd ::= with(W) insert_cmd(R) INTO fullname(X) idlist_opt(F) select(S). {

sqlite3WithPush(pParse, W, 1);

sqlite3Insert(pParse, X, S, F, R);

}

cmd ::= with(W) insert_cmd(R) INTO fullname(X) idlist_opt(F) DEFAULT VALUES.

{

sqlite3WithPush(pParse, W, 1);

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

}

%type insert_cmd {int}

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

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

%type idlist_opt {IdList*}

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

%type idlist {IdList*}

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

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

idlist_opt(A) ::= LP idlist(X) RP. {A = X;}

idlist(A) ::= idlist(A) COMMA nm(Y).

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

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

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

%type expr {ExprSpan}

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

%type term {ExprSpan}

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

%include {

/* This is a utility routine used to set the ExprSpan.zStart and

static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){

pOut->zStart = pStart->z;

pOut->zEnd = &pEnd->z[pEnd->n];

}

/* Construct a new Expr object from a single identifier. Use the

static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token t){

Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);

if( p ){

memset(p, 0, sizeof(Expr));

p->op = (u8)op;

p->flags = EP_Leaf;

p->iAgg = -1;

p->u.zToken = (char*)&p[1];

memcpy(p->u.zToken, t.z, t.n);

p->u.zToken[t.n] = 0;

if( sqlite3Isquote(p->u.zToken[0]) ){

if( p->u.zToken[0]=='"' ) p->flags |= EP_DblQuoted;

sqlite3Dequote(p->u.zToken);

}

#if SQLITE_MAX_EXPR_DEPTH>0

p->nHeight = 1;

#endif

}

pOut->pExpr = p;

pOut->zStart = t.z;

pOut->zEnd = &t.z[t.n];

}

}

expr(A) ::= term(A).

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

{spanSet(&A,&B,&E); /*A-overwrites-B*/ A.pExpr = X.pExpr;}

expr(A) ::= id(X). {spanExpr(&A,pParse,TK_ID,X); /*A-overwrites-X*/}

expr(A) ::= JOIN_KW(X). {spanExpr(&A,pParse,TK_ID,X); /*A-overwrites-X*/}

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

Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);

Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);

spanSet(&A,&X,&Y); /*A-overwrites-X*/

A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);

}

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

Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);

Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);

Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &Z, 1);

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

spanSet(&A,&X,&Z); /*A-overwrites-X*/

A.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);

}

term(A) ::= NULL|FLOAT|BLOB(X). {spanExpr(&A,pParse,@X,X); /*A-overwrites-X*/}

term(A) ::= STRING(X). {spanExpr(&A,pParse,@X,X); /*A-overwrites-X*/}

term(A) ::= INTEGER(X). {

A.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &X, 1);

A.zStart = X.z;

A.zEnd = X.z + X.n;

}

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

if( !(X.z[0]=='#' && sqlite3Isdigit(X.z[1])) ){

u32 n = X.n;

spanExpr(&A, pParse, TK_VARIABLE, X);

sqlite3ExprAssignVarNumber(pParse, A.pExpr, n);

}else{

/* When doing a nested parse, one can include terms in an expression

Token t = X; /*A-overwrites-X*/

assert( t.n>=2 );

spanSet(&A, &t, &t);

if( pParse->nested==0 ){

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

A.pExpr = 0;

}else{

A.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);

if( A.pExpr ) sqlite3GetInt32(&t.z[1], &A.pExpr->iTable);

}

}

}

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

A.pExpr = sqlite3ExprAddCollateToken(pParse, A.pExpr, &C, 1);

A.zEnd = &C.z[C.n];

}

%ifndef SQLITE_OMIT_CAST

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

spanSet(&A,&X,&Y); /*A-overwrites-X*/

A.pExpr = sqlite3ExprAlloc(pParse->db, TK_CAST, &T, 1);

sqlite3ExprAttachSubtrees(pParse->db, A.pExpr, E.pExpr, 0);

}

%endif SQLITE_OMIT_CAST

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

if( Y && Y->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){

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

}

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

spanSet(&A,&X,&E);

if( D==SF_Distinct && A.pExpr ){

A.pExpr->flags |= EP_Distinct;

}

}

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

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

spanSet(&A,&X,&E);

}

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

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

spanSet(&A, &OP, &OP);

}

%include {

/* This routine constructs a binary expression node out of two ExprSpan

static void spanBinaryExpr(

Parse *pParse, /* The parsing context. Errors accumulate here */

int op, /* The binary operation */

ExprSpan *pLeft, /* The left operand, and output */

ExprSpan *pRight /* The right operand */

){

pLeft->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr);

pLeft->zEnd = pRight->zEnd;

}

/* If doNot is true, then add a TK_NOT Expr-node wrapper around the

static void exprNot(Parse *pParse, int doNot, ExprSpan *pSpan){

if( doNot ){

pSpan->pExpr = sqlite3PExpr(pParse, TK_NOT, pSpan->pExpr, 0);

}

}

}

expr(A) ::= LP(L) nexprlist(X) COMMA expr(Y) RP(R). {

ExprList *pList = sqlite3ExprListAppend(pParse, X, Y.pExpr);

A.pExpr = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);

if( A.pExpr ){

A.pExpr->x.pList = pList;

spanSet(&A, &L, &R);

}else{

sqlite3ExprListDelete(pParse->db, pList);

}

}

expr(A) ::= expr(A) AND(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}

expr(A) ::= expr(A) OR(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}

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

{spanBinaryExpr(pParse,@OP,&A,&Y);}

expr(A) ::= expr(A) EQ|NE(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}

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

{spanBinaryExpr(pParse,@OP,&A,&Y);}

expr(A) ::= expr(A) PLUS|MINUS(OP) expr(Y).

{spanBinaryExpr(pParse,@OP,&A,&Y);}

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

{spanBinaryExpr(pParse,@OP,&A,&Y);}

expr(A) ::= expr(A) CONCAT(OP) expr(Y). {spanBinaryExpr(pParse,@OP,&A,&Y);}

%type likeop {Token}

likeop(A) ::= LIKE_KW|MATCH(A).