%include {

}

%token_prefix TK_

%token_type {Token}

%default_type {Token}

%extra_context {Parse *pParse}

%syntax_error {

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

if( TOKEN.z[0] ){

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

}else{

sqlite3ErrorMsg(pParse, "incomplete input");

}

}

%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 TrigEvent { int a; IdList * b; };

struct FrameBound { int eType; Expr *pExpr; };

static void disableLookaside(Parse *pParse){

sqlite3 *db = pParse->db;

pParse->disableLookaside++;

DisableLookaside;

}

#if !defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) \

&& defined(SQLITE_UDL_CAPABLE_PARSER)

static void updateDeleteLimitError(

Parse *pParse,

ExprList *pOrderBy,

Expr *pLimit

){

if( pOrderBy ){

sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\"");

}else{

sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\"");

}

sqlite3ExprListDelete(pParse->db, pOrderBy);

sqlite3ExprDelete(pParse->db, pLimit);

}

#endif /* SQLITE_ENABLE_UPDATE_DELETE_LIMIT */

} // end %include

input ::= cmdlist.

cmdlist ::= cmdlist ecmd.

cmdlist ::= ecmd.

ecmd ::= SEMI.

ecmd ::= cmdx SEMI.

%ifndef SQLITE_OMIT_EXPLAIN

ecmd ::= explain cmdx SEMI. {NEVER-REDUCE}

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 = pParse->db->init.busy==0;}

%endif SQLITE_OMIT_TEMPDB

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

create_table_args ::= LP columnlist conslist_opt(X) RP(E) table_option_set(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_option_set {u32}

%type table_option {u32}

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

table_option_set(A) ::= table_option(A).

table_option_set(A) ::= table_option_set(X) COMMA table_option(Y). {A = X|Y;}

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

}

}

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

if( X.n==6 && sqlite3_strnicmp(X.z,"strict",6)==0 ){

A = TF_Strict;

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

%token ABORT ACTION AFTER ANALYZE ASC ATTACH BEFORE BEGIN BY CASCADE CAST.

%token CONFLICT DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL.

%token OR AND NOT IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.

%token GT LE LT GE ESCAPE.

%fallback ID

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

CONFLICT DATABASE DEFERRED DESC DETACH DO

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 ROWS

ROLLBACK SAVEPOINT TEMP TRIGGER VACUUM VIEW VIRTUAL WITH WITHOUT

NULLS FIRST LAST

%ifdef SQLITE_OMIT_COMPOUND_SELECT

EXCEPT INTERSECT UNION

%endif SQLITE_OMIT_COMPOUND_SELECT

%ifndef SQLITE_OMIT_WINDOWFUNC

CURRENT FOLLOWING PARTITION PRECEDING RANGE UNBOUNDED

EXCLUDE GROUPS OTHERS TIES

%endif SQLITE_OMIT_WINDOWFUNC

%ifndef SQLITE_OMIT_GENERATED_COLUMNS

GENERATED ALWAYS

%endif

MATERIALIZED

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 PTR.

%left COLLATE.

%right BITNOT.

%nonassoc ON.

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

%type scanpt {const char*}

scanpt(A) ::= . {

assert( yyLookahead!=YYNOCODE );

A = yyLookaheadToken.z;

}

scantok(A) ::= . {

assert( yyLookahead!=YYNOCODE );

A = yyLookaheadToken;

}

carglist ::= carglist ccons.

carglist ::= .

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

ccons ::= DEFAULT scantok(A) term(X).

{sqlite3AddDefaultValue(pParse,X,A.z,&A.z[A.n]);}

ccons ::= DEFAULT LP(A) expr(X) RP(Z).

{sqlite3AddDefaultValue(pParse,X,A.z+1,Z.z);}

ccons ::= DEFAULT PLUS(A) scantok(Z) term(X).

{sqlite3AddDefaultValue(pParse,X,A.z,&Z.z[Z.n]);}

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

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

sqlite3AddDefaultValue(pParse,p,A.z,&Z.z[Z.n]);

}

ccons ::= DEFAULT scantok id(X). {

Expr *p = tokenExpr(pParse, TK_STRING, X);

if( p ){

sqlite3ExprIdToTrueFalse(p);

testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );

}

sqlite3AddDefaultValue(pParse,p,X.z,X.z+X.n);

}

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(A) expr(X) RP(B). {sqlite3AddCheckConstraint(pParse,X,A.z,B.z);}

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

ccons ::= GENERATED ALWAYS AS generated.

ccons ::= AS generated.

generated ::= LP expr(E) RP. {sqlite3AddGenerated(pParse,E,0);}

generated ::= LP expr(E) RP ID(TYPE). {sqlite3AddGenerated(pParse,E,&TYPE);}

%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(A) expr(E) RP(B) onconf.

{sqlite3AddCheckConstraint(pParse,E,A.z,B.z);}

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

assert( p!=0 );

if( p->pPrior ){

Select *pNext = 0, *pLoop = p;

int mxSelect, cnt = 1;

while(1){

pLoop->pNext = pNext;

pLoop->selFlags |= SF_Compound;

pNext = pLoop;

pLoop = pLoop->pPrior;

if( pLoop==0 ) break;

cnt++;

if( pLoop->pOrderBy || pLoop->pLimit ){

sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",

pLoop->pOrderBy!=0 ? "ORDER BY" : "LIMIT",

sqlite3SelectOpName(pNext->op));

break;

}

}

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

}

}

}

/* Attach a With object describing the WITH clause to a Select

static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){

if( pSelect ){

pSelect->pWith = pWith;

parserDoubleLinkSelect(pParse, pSelect);

}else{

sqlite3WithDelete(pParse->db, pWith);

}

return pSelect;

}

}

%ifndef SQLITE_OMIT_CTE

select(A) ::= WITH wqlist(W) selectnowith(X). {A = attachWithToSelect(pParse,X,W);}

select(A) ::= WITH RECURSIVE wqlist(W) selectnowith(X).

{A = attachWithToSelect(pParse,X,W);}

%endif /* SQLITE_OMIT_CTE */

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

Select *p = X;

if( p ){

parserDoubleLinkSelect(pParse, p);

}

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

}

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

pRhs = sqlite3SelectNew(pParse,0,pFrom,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 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);

}

%ifndef SQLITE_OMIT_WINDOWFUNC

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

groupby_opt(P) having_opt(Q) window_clause(R)

orderby_opt(Z) limit_opt(L). {

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

if( A ){

A->pWinDefn = R;

}else{

sqlite3WindowListDelete(pParse->db, R);

}

}

%endif

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

}

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

Select *pRight, *pLeft = A;

pRight = sqlite3SelectNew(pParse,Y,0,0,0,0,0,SF_Values|SF_MultiValue,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) scanpt(B) expr(X) scanpt(Z) as(Y). {

A = sqlite3ExprListAppend(pParse, A, X);

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

sqlite3ExprListSetSpan(pParse,A,B,Z);

}

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

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

A = sqlite3ExprListAppend(pParse, A, p);

}

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

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

Expr *pLeft = tokenExpr(pParse, TK_ID, X);

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

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

A = X;

sqlite3SrcListShiftJoinType(pParse,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) on_using(N). {

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

}

seltablist(A) ::= stl_prefix(A) nm(Y) dbnm(D) as(Z) indexed_by(I) on_using(N). {

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

sqlite3SrcListIndexedBy(pParse, A, &I);

}

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

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

sqlite3SrcListFuncArgs(pParse, A, E);

}

%ifndef SQLITE_OMIT_SUBQUERY

seltablist(A) ::= stl_prefix(A) LP select(S) RP as(Z) on_using(N). {

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

}

seltablist(A) ::= stl_prefix(A) LP seltablist(F) RP as(Z) on_using(N). {

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

A = F;

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

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

if( A ){

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

SrcItem *pOld = F->a;

pNew->zName = pOld->zName;

pNew->zDatabase = pOld->zDatabase;

pNew->pSelect = pOld->pSelect;

if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){

pNew->fg.isNestedFrom = 1;

}

if( pOld->fg.isTabFunc ){

pNew->u1.pFuncArg = pOld->u1.pFuncArg;

pOld->u1.pFuncArg = 0;

pOld->fg.isTabFunc = 0;

pNew->fg.isTabFunc = 1;

}

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

pOld->pSelect = 0;

}

sqlite3SrcListDelete(pParse->db, F);

}else{

Select *pSubquery;

sqlite3SrcListShiftJoinType(pParse,F);

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

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

}

}

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

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

if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &X);

}

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

A = sqlite3SrcListAppend(pParse,0,&X,&Y);

if( IN_RENAME_OBJECT && A ) sqlite3RenameTokenMap(pParse, A->a[0].zName, &Y);

}

%type xfullname {SrcList*}

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

xfullname(A) ::= nm(X).

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

xfullname(A) ::= nm(X) DOT nm(Y).

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

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

A = sqlite3SrcListAppend(pParse,0,&X,&Y); /*A-overwrites-X*/

if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z);

}

xfullname(A) ::= nm(X) AS nm(Z). {

A = sqlite3SrcListAppend(pParse,0,&X,0); /*A-overwrites-X*/

if( A ) A->a[0].zAlias = sqlite3NameFromToken(pParse->db, &Z);

}

%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_using {OnOrUsing}

on_using(N) ::= ON expr(E). {N.pOn = E; N.pUsing = 0;}

on_using(N) ::= USING LP idlist(L) RP. {N.pOn = 0; N.pUsing = L;}

on_using(N) ::= . [OR] {N.pOn = 0; N.pUsing = 0;}

%type indexed_opt {Token}

%type indexed_by {Token}

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

indexed_opt(A) ::= indexed_by(A).

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

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

%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) nulls(X). {

A = sqlite3ExprListAppend(pParse,A,Y);

sqlite3ExprListSetSortOrder(A,Z,X);

}

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

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

sqlite3ExprListSetSortOrder(A,Z,X);

}

%type sortorder {int}

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

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

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

%type nulls {int}

nulls(A) ::= NULLS FIRST. {A = SQLITE_SO_ASC;}

nulls(A) ::= NULLS LAST. {A = SQLITE_SO_DESC;}

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

%type limit_opt {Expr*}

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

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

{A = sqlite3PExpr(pParse,TK_LIMIT,X,0);}

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

{A = sqlite3PExpr(pParse,TK_LIMIT,X,Y);}

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

{A = sqlite3PExpr(pParse,TK_LIMIT,Y,X);}

%if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER

cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt_ret(W)

orderby_opt(O) limit_opt(L). {

sqlite3SrcListIndexedBy(pParse, X, &I);

#ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

if( O || L ){

updateDeleteLimitError(pParse,O,L);

O = 0;

L = 0;

}

#endif

sqlite3DeleteFrom(pParse,X,W,O,L);

}

%else

cmd ::= with DELETE FROM xfullname(X) indexed_opt(I) where_opt_ret(W). {

sqlite3SrcListIndexedBy(pParse, X, &I);

sqlite3DeleteFrom(pParse,X,W,0,0);

}

%endif

%type where_opt {Expr*}

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

%type where_opt_ret {Expr*}

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

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

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

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

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

where_opt_ret(A) ::= RETURNING selcollist(X).

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

where_opt_ret(A) ::= WHERE expr(X) RETURNING selcollist(Y).

{sqlite3AddReturning(pParse,Y); A = X;}

%if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER

cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) from(F)

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

sqlite3SrcListIndexedBy(pParse, X, &I);

if( F ){

SrcList *pFromClause = F;

if( pFromClause->nSrc>1 ){

Select *pSubquery;

Token as;

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

as.n = 0;

as.z = 0;

pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);

}

X = sqlite3SrcListAppendList(pParse, X, pFromClause);

}

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

#ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT

if( O || L ){

updateDeleteLimitError(pParse,O,L);

O = 0;

L = 0;

}

#endif

sqlite3Update(pParse,X,Y,W,R,O,L,0);

}

%else

cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) from(F)

where_opt_ret(W). {

sqlite3SrcListIndexedBy(pParse, X, &I);

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

if( F ){

SrcList *pFromClause = F;

if( pFromClause->nSrc>1 ){

Select *pSubquery;

Token as;

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

as.n = 0;

as.z = 0;

pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);

}

X = sqlite3SrcListAppendList(pParse, X, pFromClause);

}

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

}

%endif

%type setlist {ExprList*}

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

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

A = sqlite3ExprListAppend(pParse, A, Y);

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

}

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

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

}

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

A = sqlite3ExprListAppend(pParse, 0, Y);

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

}

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

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

}

cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) select(S)

upsert(U). {

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

}

cmd ::= with insert_cmd(R) INTO xfullname(X) idlist_opt(F) DEFAULT VALUES returning.

{

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

}