Annotation of embedaddon/php/ext/sqlite/libsqlite/src/parse.y, revision 1.1

1.1     ! misho       1: /*
        !             2: ** 2001 September 15
        !             3: **
        !             4: ** The author disclaims copyright to this source code.  In place of
        !             5: ** a legal notice, here is a blessing:
        !             6: **
        !             7: **    May you do good and not evil.
        !             8: **    May you find forgiveness for yourself and forgive others.
        !             9: **    May you share freely, never taking more than you give.
        !            10: **
        !            11: *************************************************************************
        !            12: ** This file contains SQLite's grammar for SQL.  Process this file
        !            13: ** using the lemon parser generator to generate C code that runs
        !            14: ** the parser.  Lemon will also generate a header file containing
        !            15: ** numeric codes for all of the tokens.
        !            16: **
        !            17: ** @(#) $Id: parse.y 195361 2005-09-07 15:11:33Z iliaa $
        !            18: */
        !            19: %token_prefix TK_
        !            20: %token_type {Token}
        !            21: %default_type {Token}
        !            22: %extra_argument {Parse *pParse}
        !            23: %syntax_error {
        !            24:   if( pParse->zErrMsg==0 ){
        !            25:     if( TOKEN.z[0] ){
        !            26:       sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
        !            27:     }else{
        !            28:       sqliteErrorMsg(pParse, "incomplete SQL statement");
        !            29:     }
        !            30:   }
        !            31: }
        !            32: %name sqliteParser
        !            33: %include {
        !            34: #include "sqliteInt.h"
        !            35: #include "parse.h"
        !            36: 
        !            37: /*
        !            38: ** An instance of this structure holds information about the
        !            39: ** LIMIT clause of a SELECT statement.
        !            40: */
        !            41: struct LimitVal {
        !            42:   int limit;    /* The LIMIT value.  -1 if there is no limit */
        !            43:   int offset;   /* The OFFSET.  0 if there is none */
        !            44: };
        !            45: 
        !            46: /*
        !            47: ** An instance of the following structure describes the event of a
        !            48: ** TRIGGER.  "a" is the event type, one of TK_UPDATE, TK_INSERT,
        !            49: ** TK_DELETE, or TK_INSTEAD.  If the event is of the form
        !            50: **
        !            51: **      UPDATE ON (a,b,c)
        !            52: **
        !            53: ** Then the "b" IdList records the list "a,b,c".
        !            54: */
        !            55: struct TrigEvent { int a; IdList * b; };
        !            56: 
        !            57: } // end %include
        !            58: 
        !            59: // These are extra tokens used by the lexer but never seen by the
        !            60: // parser.  We put them in a rule so that the parser generator will
        !            61: // add them to the parse.h output file.
        !            62: //
        !            63: %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
        !            64:           COLUMN AGG_FUNCTION.
        !            65: 
        !            66: // Input is a single SQL command
        !            67: input ::= cmdlist.
        !            68: cmdlist ::= cmdlist ecmd.
        !            69: cmdlist ::= ecmd.
        !            70: ecmd ::= explain cmdx SEMI.
        !            71: ecmd ::= SEMI.
        !            72: cmdx ::= cmd.           { sqliteExec(pParse); }
        !            73: explain ::= EXPLAIN.    { sqliteBeginParse(pParse, 1); }
        !            74: explain ::= .           { sqliteBeginParse(pParse, 0); }
        !            75: 
        !            76: ///////////////////// Begin and end transactions. ////////////////////////////
        !            77: //
        !            78: 
        !            79: cmd ::= BEGIN trans_opt onconf(R).  {sqliteBeginTransaction(pParse,R);}
        !            80: trans_opt ::= .
        !            81: trans_opt ::= TRANSACTION.
        !            82: trans_opt ::= TRANSACTION nm.
        !            83: cmd ::= COMMIT trans_opt.      {sqliteCommitTransaction(pParse);}
        !            84: cmd ::= END trans_opt.         {sqliteCommitTransaction(pParse);}
        !            85: cmd ::= ROLLBACK trans_opt.    {sqliteRollbackTransaction(pParse);}
        !            86: 
        !            87: ///////////////////// The CREATE TABLE statement ////////////////////////////
        !            88: //
        !            89: cmd ::= create_table create_table_args.
        !            90: create_table ::= CREATE(X) temp(T) TABLE nm(Y). {
        !            91:    sqliteStartTable(pParse,&X,&Y,T,0);
        !            92: }
        !            93: %type temp {int}
        !            94: temp(A) ::= TEMP.  {A = 1;}
        !            95: temp(A) ::= .      {A = 0;}
        !            96: create_table_args ::= LP columnlist conslist_opt RP(X). {
        !            97:   sqliteEndTable(pParse,&X,0);
        !            98: }
        !            99: create_table_args ::= AS select(S). {
        !           100:   sqliteEndTable(pParse,0,S);
        !           101:   sqliteSelectDelete(S);
        !           102: }
        !           103: columnlist ::= columnlist COMMA column.
        !           104: columnlist ::= column.
        !           105: 
        !           106: // About the only information used for a column is the name of the
        !           107: // column.  The type is always just "text".  But the code will accept
        !           108: // an elaborate typename.  Perhaps someday we'll do something with it.
        !           109: //
        !           110: column ::= columnid type carglist. 
        !           111: columnid ::= nm(X).                {sqliteAddColumn(pParse,&X);}
        !           112: 
        !           113: // An IDENTIFIER can be a generic identifier, or one of several
        !           114: // keywords.  Any non-standard keyword can also be an identifier.
        !           115: //
        !           116: %type id {Token}
        !           117: id(A) ::= ID(X).         {A = X;}
        !           118: 
        !           119: // The following directive causes tokens ABORT, AFTER, ASC, etc. to
        !           120: // fallback to ID if they will not parse as their original value.
        !           121: // This obviates the need for the "id" nonterminal.
        !           122: //
        !           123: %fallback ID
        !           124:   ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT
        !           125:   COPY DATABASE DEFERRED DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR
        !           126:   GLOB IGNORE IMMEDIATE INITIALLY INSTEAD LIKE MATCH KEY
        !           127:   OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT
        !           128:   TEMP TRIGGER VACUUM VIEW.
        !           129: 
        !           130: // Define operator precedence early so that this is the first occurance
        !           131: // of the operator tokens in the grammer.  Keeping the operators together
        !           132: // causes them to be assigned integer values that are close together,
        !           133: // which keeps parser tables smaller.
        !           134: //
        !           135: %left OR.
        !           136: %left AND.
        !           137: %right NOT.
        !           138: %left EQ NE ISNULL NOTNULL IS LIKE GLOB BETWEEN IN.
        !           139: %left GT GE LT LE.
        !           140: %left BITAND BITOR LSHIFT RSHIFT.
        !           141: %left PLUS MINUS.
        !           142: %left STAR SLASH REM.
        !           143: %left CONCAT.
        !           144: %right UMINUS UPLUS BITNOT.
        !           145: 
        !           146: // And "ids" is an identifer-or-string.
        !           147: //
        !           148: %type ids {Token}
        !           149: ids(A) ::= ID(X).        {A = X;}
        !           150: ids(A) ::= STRING(X).    {A = X;}
        !           151: 
        !           152: // The name of a column or table can be any of the following:
        !           153: //
        !           154: %type nm {Token}
        !           155: nm(A) ::= ID(X).         {A = X;}
        !           156: nm(A) ::= STRING(X).     {A = X;}
        !           157: nm(A) ::= JOIN_KW(X).    {A = X;}
        !           158: 
        !           159: type ::= .
        !           160: type ::= typename(X).                    {sqliteAddColumnType(pParse,&X,&X);}
        !           161: type ::= typename(X) LP signed RP(Y).    {sqliteAddColumnType(pParse,&X,&Y);}
        !           162: type ::= typename(X) LP signed COMMA signed RP(Y).
        !           163:                                          {sqliteAddColumnType(pParse,&X,&Y);}
        !           164: %type typename {Token}
        !           165: typename(A) ::= ids(X).           {A = X;}
        !           166: typename(A) ::= typename(X) ids.  {A = X;}
        !           167: %type signed {int}
        !           168: signed(A) ::= INTEGER(X).         { A = atoi(X.z); }
        !           169: signed(A) ::= PLUS INTEGER(X).    { A = atoi(X.z); }
        !           170: signed(A) ::= MINUS INTEGER(X).   { A = -atoi(X.z); }
        !           171: carglist ::= carglist carg.
        !           172: carglist ::= .
        !           173: carg ::= CONSTRAINT nm ccons.
        !           174: carg ::= ccons.
        !           175: carg ::= DEFAULT STRING(X).          {sqliteAddDefaultValue(pParse,&X,0);}
        !           176: carg ::= DEFAULT ID(X).              {sqliteAddDefaultValue(pParse,&X,0);}
        !           177: carg ::= DEFAULT INTEGER(X).         {sqliteAddDefaultValue(pParse,&X,0);}
        !           178: carg ::= DEFAULT PLUS INTEGER(X).    {sqliteAddDefaultValue(pParse,&X,0);}
        !           179: carg ::= DEFAULT MINUS INTEGER(X).   {sqliteAddDefaultValue(pParse,&X,1);}
        !           180: carg ::= DEFAULT FLOAT(X).           {sqliteAddDefaultValue(pParse,&X,0);}
        !           181: carg ::= DEFAULT PLUS FLOAT(X).      {sqliteAddDefaultValue(pParse,&X,0);}
        !           182: carg ::= DEFAULT MINUS FLOAT(X).     {sqliteAddDefaultValue(pParse,&X,1);}
        !           183: carg ::= DEFAULT NULL. 
        !           184: 
        !           185: // In addition to the type name, we also care about the primary key and
        !           186: // UNIQUE constraints.
        !           187: //
        !           188: ccons ::= NULL onconf.
        !           189: ccons ::= NOT NULL onconf(R).               {sqliteAddNotNull(pParse, R);}
        !           190: ccons ::= PRIMARY KEY sortorder onconf(R).  {sqliteAddPrimaryKey(pParse,0,R);}
        !           191: ccons ::= UNIQUE onconf(R).           {sqliteCreateIndex(pParse,0,0,0,R,0,0);}
        !           192: ccons ::= CHECK LP expr RP onconf.
        !           193: ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
        !           194:                                 {sqliteCreateForeignKey(pParse,0,&T,TA,R);}
        !           195: ccons ::= defer_subclause(D).   {sqliteDeferForeignKey(pParse,D);}
        !           196: ccons ::= COLLATE id(C).  {
        !           197:    sqliteAddCollateType(pParse, sqliteCollateType(C.z, C.n));
        !           198: }
        !           199: 
        !           200: // The next group of rules parses the arguments to a REFERENCES clause
        !           201: // that determine if the referential integrity checking is deferred or
        !           202: // or immediate and which determine what action to take if a ref-integ
        !           203: // check fails.
        !           204: //
        !           205: %type refargs {int}
        !           206: refargs(A) ::= .                     { A = OE_Restrict * 0x010101; }
        !           207: refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; }
        !           208: %type refarg {struct {int value; int mask;}}
        !           209: refarg(A) ::= MATCH nm.              { A.value = 0;     A.mask = 0x000000; }
        !           210: refarg(A) ::= ON DELETE refact(X).   { A.value = X;     A.mask = 0x0000ff; }
        !           211: refarg(A) ::= ON UPDATE refact(X).   { A.value = X<<8;  A.mask = 0x00ff00; }
        !           212: refarg(A) ::= ON INSERT refact(X).   { A.value = X<<16; A.mask = 0xff0000; }
        !           213: %type refact {int}
        !           214: refact(A) ::= SET NULL.              { A = OE_SetNull; }
        !           215: refact(A) ::= SET DEFAULT.           { A = OE_SetDflt; }
        !           216: refact(A) ::= CASCADE.               { A = OE_Cascade; }
        !           217: refact(A) ::= RESTRICT.              { A = OE_Restrict; }
        !           218: %type defer_subclause {int}
        !           219: defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X).  {A = X;}
        !           220: defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X).      {A = X;}
        !           221: %type init_deferred_pred_opt {int}
        !           222: init_deferred_pred_opt(A) ::= .                       {A = 0;}
        !           223: init_deferred_pred_opt(A) ::= INITIALLY DEFERRED.     {A = 1;}
        !           224: init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE.    {A = 0;}
        !           225: 
        !           226: // For the time being, the only constraint we care about is the primary
        !           227: // key and UNIQUE.  Both create indices.
        !           228: //
        !           229: conslist_opt ::= .
        !           230: conslist_opt ::= COMMA conslist.
        !           231: conslist ::= conslist COMMA tcons.
        !           232: conslist ::= conslist tcons.
        !           233: conslist ::= tcons.
        !           234: tcons ::= CONSTRAINT nm.
        !           235: tcons ::= PRIMARY KEY LP idxlist(X) RP onconf(R).
        !           236:                                              {sqliteAddPrimaryKey(pParse,X,R);}
        !           237: tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
        !           238:                                        {sqliteCreateIndex(pParse,0,0,X,R,0,0);}
        !           239: tcons ::= CHECK expr onconf.
        !           240: tcons ::= FOREIGN KEY LP idxlist(FA) RP
        !           241:           REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {
        !           242:     sqliteCreateForeignKey(pParse, FA, &T, TA, R);
        !           243:     sqliteDeferForeignKey(pParse, D);
        !           244: }
        !           245: %type defer_subclause_opt {int}
        !           246: defer_subclause_opt(A) ::= .                    {A = 0;}
        !           247: defer_subclause_opt(A) ::= defer_subclause(X).  {A = X;}
        !           248: 
        !           249: // The following is a non-standard extension that allows us to declare the
        !           250: // default behavior when there is a constraint conflict.
        !           251: //
        !           252: %type onconf {int}
        !           253: %type orconf {int}
        !           254: %type resolvetype {int}
        !           255: onconf(A) ::= .                              { A = OE_Default; }
        !           256: onconf(A) ::= ON CONFLICT resolvetype(X).    { A = X; }
        !           257: orconf(A) ::= .                              { A = OE_Default; }
        !           258: orconf(A) ::= OR resolvetype(X).             { A = X; }
        !           259: resolvetype(A) ::= ROLLBACK.                 { A = OE_Rollback; }
        !           260: resolvetype(A) ::= ABORT.                    { A = OE_Abort; }
        !           261: resolvetype(A) ::= FAIL.                     { A = OE_Fail; }
        !           262: resolvetype(A) ::= IGNORE.                   { A = OE_Ignore; }
        !           263: resolvetype(A) ::= REPLACE.                  { A = OE_Replace; }
        !           264: 
        !           265: ////////////////////////// The DROP TABLE /////////////////////////////////////
        !           266: //
        !           267: cmd ::= DROP TABLE nm(X).          {sqliteDropTable(pParse,&X,0);}
        !           268: 
        !           269: ///////////////////// The CREATE VIEW statement /////////////////////////////
        !           270: //
        !           271: cmd ::= CREATE(X) temp(T) VIEW nm(Y) AS select(S). {
        !           272:   sqliteCreateView(pParse, &X, &Y, S, T);
        !           273: }
        !           274: cmd ::= DROP VIEW nm(X). {
        !           275:   sqliteDropTable(pParse, &X, 1);
        !           276: }
        !           277: 
        !           278: //////////////////////// The SELECT statement /////////////////////////////////
        !           279: //
        !           280: cmd ::= select(X).  {
        !           281:   sqliteSelect(pParse, X, SRT_Callback, 0, 0, 0, 0);
        !           282:   sqliteSelectDelete(X);
        !           283: }
        !           284: 
        !           285: %type select {Select*}
        !           286: %destructor select {sqliteSelectDelete($$);}
        !           287: %type oneselect {Select*}
        !           288: %destructor oneselect {sqliteSelectDelete($$);}
        !           289: 
        !           290: select(A) ::= oneselect(X).                      {A = X;}
        !           291: select(A) ::= select(X) multiselect_op(Y) oneselect(Z).  {
        !           292:   if( Z ){
        !           293:     Z->op = Y;
        !           294:     Z->pPrior = X;
        !           295:   }
        !           296:   A = Z;
        !           297: }
        !           298: %type multiselect_op {int}
        !           299: multiselect_op(A) ::= UNION.      {A = TK_UNION;}
        !           300: multiselect_op(A) ::= UNION ALL.  {A = TK_ALL;}
        !           301: multiselect_op(A) ::= INTERSECT.  {A = TK_INTERSECT;}
        !           302: multiselect_op(A) ::= EXCEPT.     {A = TK_EXCEPT;}
        !           303: oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
        !           304:                  groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
        !           305:   A = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset);
        !           306: }
        !           307: 
        !           308: // The "distinct" nonterminal is true (1) if the DISTINCT keyword is
        !           309: // present and false (0) if it is not.
        !           310: //
        !           311: %type distinct {int}
        !           312: distinct(A) ::= DISTINCT.   {A = 1;}
        !           313: distinct(A) ::= ALL.        {A = 0;}
        !           314: distinct(A) ::= .           {A = 0;}
        !           315: 
        !           316: // selcollist is a list of expressions that are to become the return
        !           317: // values of the SELECT statement.  The "*" in statements like
        !           318: // "SELECT * FROM ..." is encoded as a special expression with an
        !           319: // opcode of TK_ALL.
        !           320: //
        !           321: %type selcollist {ExprList*}
        !           322: %destructor selcollist {sqliteExprListDelete($$);}
        !           323: %type sclp {ExprList*}
        !           324: %destructor sclp {sqliteExprListDelete($$);}
        !           325: sclp(A) ::= selcollist(X) COMMA.             {A = X;}
        !           326: sclp(A) ::= .                                {A = 0;}
        !           327: selcollist(A) ::= sclp(P) expr(X) as(Y).     {
        !           328:    A = sqliteExprListAppend(P,X,Y.n?&Y:0);
        !           329: }
        !           330: selcollist(A) ::= sclp(P) STAR. {
        !           331:   A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0);
        !           332: }
        !           333: selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
        !           334:   Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0);
        !           335:   Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X);
        !           336:   A = sqliteExprListAppend(P, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0);
        !           337: }
        !           338: 
        !           339: // An option "AS <id>" phrase that can follow one of the expressions that
        !           340: // define the result set, or one of the tables in the FROM clause.
        !           341: //
        !           342: %type as {Token}
        !           343: as(X) ::= AS nm(Y).    { X = Y; }
        !           344: as(X) ::= ids(Y).      { X = Y; }
        !           345: as(X) ::= .            { X.n = 0; }
        !           346: 
        !           347: 
        !           348: %type seltablist {SrcList*}
        !           349: %destructor seltablist {sqliteSrcListDelete($$);}
        !           350: %type stl_prefix {SrcList*}
        !           351: %destructor stl_prefix {sqliteSrcListDelete($$);}
        !           352: %type from {SrcList*}
        !           353: %destructor from {sqliteSrcListDelete($$);}
        !           354: 
        !           355: // A complete FROM clause.
        !           356: //
        !           357: from(A) ::= .                                 {A = sqliteMalloc(sizeof(*A));}
        !           358: from(A) ::= FROM seltablist(X).               {A = X;}
        !           359: 
        !           360: // "seltablist" is a "Select Table List" - the content of the FROM clause
        !           361: // in a SELECT statement.  "stl_prefix" is a prefix of this list.
        !           362: //
        !           363: stl_prefix(A) ::= seltablist(X) joinop(Y).    {
        !           364:    A = X;
        !           365:    if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y;
        !           366: }
        !           367: stl_prefix(A) ::= .                           {A = 0;}
        !           368: seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). {
        !           369:   A = sqliteSrcListAppend(X,&Y,&D);
        !           370:   if( Z.n ) sqliteSrcListAddAlias(A,&Z);
        !           371:   if( N ){
        !           372:     if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; }
        !           373:     else { sqliteExprDelete(N); }
        !           374:   }
        !           375:   if( U ){
        !           376:     if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; }
        !           377:     else { sqliteIdListDelete(U); }
        !           378:   }
        !           379: }
        !           380: seltablist(A) ::= stl_prefix(X) LP seltablist_paren(S) RP
        !           381:                   as(Z) on_opt(N) using_opt(U). {
        !           382:   A = sqliteSrcListAppend(X,0,0);
        !           383:   A->a[A->nSrc-1].pSelect = S;
        !           384:   if( Z.n ) sqliteSrcListAddAlias(A,&Z);
        !           385:   if( N ){
        !           386:     if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; }
        !           387:     else { sqliteExprDelete(N); }
        !           388:   }
        !           389:   if( U ){
        !           390:     if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; }
        !           391:     else { sqliteIdListDelete(U); }
        !           392:   }
        !           393: }
        !           394: 
        !           395: // A seltablist_paren nonterminal represents anything in a FROM that
        !           396: // is contained inside parentheses.  This can be either a subquery or
        !           397: // a grouping of table and subqueries.
        !           398: //
        !           399: %type seltablist_paren {Select*}
        !           400: %destructor seltablist_paren {sqliteSelectDelete($$);}
        !           401: seltablist_paren(A) ::= select(S).      {A = S;}
        !           402: seltablist_paren(A) ::= seltablist(F).  {
        !           403:    A = sqliteSelectNew(0,F,0,0,0,0,0,-1,0);
        !           404: }
        !           405: 
        !           406: %type dbnm {Token}
        !           407: dbnm(A) ::= .          {A.z=0; A.n=0;}
        !           408: dbnm(A) ::= DOT nm(X). {A = X;}
        !           409: 
        !           410: %type joinop {int}
        !           411: %type joinop2 {int}
        !           412: joinop(X) ::= COMMA.                   { X = JT_INNER; }
        !           413: joinop(X) ::= JOIN.                    { X = JT_INNER; }
        !           414: joinop(X) ::= JOIN_KW(A) JOIN.         { X = sqliteJoinType(pParse,&A,0,0); }
        !           415: joinop(X) ::= JOIN_KW(A) nm(B) JOIN.   { X = sqliteJoinType(pParse,&A,&B,0); }
        !           416: joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
        !           417:                                        { X = sqliteJoinType(pParse,&A,&B,&C); }
        !           418: 
        !           419: %type on_opt {Expr*}
        !           420: %destructor on_opt {sqliteExprDelete($$);}
        !           421: on_opt(N) ::= ON expr(E).   {N = E;}
        !           422: on_opt(N) ::= .             {N = 0;}
        !           423: 
        !           424: %type using_opt {IdList*}
        !           425: %destructor using_opt {sqliteIdListDelete($$);}
        !           426: using_opt(U) ::= USING LP idxlist(L) RP.  {U = L;}
        !           427: using_opt(U) ::= .                        {U = 0;}
        !           428: 
        !           429: 
        !           430: %type orderby_opt {ExprList*}
        !           431: %destructor orderby_opt {sqliteExprListDelete($$);}
        !           432: %type sortlist {ExprList*}
        !           433: %destructor sortlist {sqliteExprListDelete($$);}
        !           434: %type sortitem {Expr*}
        !           435: %destructor sortitem {sqliteExprDelete($$);}
        !           436: 
        !           437: orderby_opt(A) ::= .                          {A = 0;}
        !           438: orderby_opt(A) ::= ORDER BY sortlist(X).      {A = X;}
        !           439: sortlist(A) ::= sortlist(X) COMMA sortitem(Y) collate(C) sortorder(Z). {
        !           440:   A = sqliteExprListAppend(X,Y,0);
        !           441:   if( A ) A->a[A->nExpr-1].sortOrder = C+Z;
        !           442: }
        !           443: sortlist(A) ::= sortitem(Y) collate(C) sortorder(Z). {
        !           444:   A = sqliteExprListAppend(0,Y,0);
        !           445:   if( A ) A->a[0].sortOrder = C+Z;
        !           446: }
        !           447: sortitem(A) ::= expr(X).   {A = X;}
        !           448: 
        !           449: %type sortorder {int}
        !           450: %type collate {int}
        !           451: 
        !           452: sortorder(A) ::= ASC.           {A = SQLITE_SO_ASC;}
        !           453: sortorder(A) ::= DESC.          {A = SQLITE_SO_DESC;}
        !           454: sortorder(A) ::= .              {A = SQLITE_SO_ASC;}
        !           455: collate(C) ::= .                {C = SQLITE_SO_UNK;}
        !           456: collate(C) ::= COLLATE id(X).   {C = sqliteCollateType(X.z, X.n);}
        !           457: 
        !           458: %type groupby_opt {ExprList*}
        !           459: %destructor groupby_opt {sqliteExprListDelete($$);}
        !           460: groupby_opt(A) ::= .                      {A = 0;}
        !           461: groupby_opt(A) ::= GROUP BY exprlist(X).  {A = X;}
        !           462: 
        !           463: %type having_opt {Expr*}
        !           464: %destructor having_opt {sqliteExprDelete($$);}
        !           465: having_opt(A) ::= .                {A = 0;}
        !           466: having_opt(A) ::= HAVING expr(X).  {A = X;}
        !           467: 
        !           468: %type limit_opt {struct LimitVal}
        !           469: limit_opt(A) ::= .                     {A.limit = -1; A.offset = 0;}
        !           470: limit_opt(A) ::= LIMIT signed(X).      {A.limit = X; A.offset = 0;}
        !           471: limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y). 
        !           472:                                        {A.limit = X; A.offset = Y;}
        !           473: limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y). 
        !           474:                                        {A.limit = Y; A.offset = X;}
        !           475: 
        !           476: /////////////////////////// The DELETE statement /////////////////////////////
        !           477: //
        !           478: cmd ::= DELETE FROM nm(X) dbnm(D) where_opt(Y). {
        !           479:    sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&X,&D), Y);
        !           480: }
        !           481: 
        !           482: %type where_opt {Expr*}
        !           483: %destructor where_opt {sqliteExprDelete($$);}
        !           484: 
        !           485: where_opt(A) ::= .                    {A = 0;}
        !           486: where_opt(A) ::= WHERE expr(X).       {A = X;}
        !           487: 
        !           488: %type setlist {ExprList*}
        !           489: %destructor setlist {sqliteExprListDelete($$);}
        !           490: 
        !           491: ////////////////////////// The UPDATE command ////////////////////////////////
        !           492: //
        !           493: cmd ::= UPDATE orconf(R) nm(X) dbnm(D) SET setlist(Y) where_opt(Z).
        !           494:     {sqliteUpdate(pParse,sqliteSrcListAppend(0,&X,&D),Y,Z,R);}
        !           495: 
        !           496: setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).
        !           497:     {A = sqliteExprListAppend(Z,Y,&X);}
        !           498: setlist(A) ::= nm(X) EQ expr(Y).   {A = sqliteExprListAppend(0,Y,&X);}
        !           499: 
        !           500: ////////////////////////// The INSERT command /////////////////////////////////
        !           501: //
        !           502: cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) 
        !           503:         VALUES LP itemlist(Y) RP.
        !           504:             {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), Y, 0, F, R);}
        !           505: cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) select(S).
        !           506:             {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), 0, S, F, R);}
        !           507: 
        !           508: %type insert_cmd {int}
        !           509: insert_cmd(A) ::= INSERT orconf(R).   {A = R;}
        !           510: insert_cmd(A) ::= REPLACE.            {A = OE_Replace;}
        !           511: 
        !           512: 
        !           513: %type itemlist {ExprList*}
        !           514: %destructor itemlist {sqliteExprListDelete($$);}
        !           515: 
        !           516: itemlist(A) ::= itemlist(X) COMMA expr(Y).  {A = sqliteExprListAppend(X,Y,0);}
        !           517: itemlist(A) ::= expr(X).                    {A = sqliteExprListAppend(0,X,0);}
        !           518: 
        !           519: %type inscollist_opt {IdList*}
        !           520: %destructor inscollist_opt {sqliteIdListDelete($$);}
        !           521: %type inscollist {IdList*}
        !           522: %destructor inscollist {sqliteIdListDelete($$);}
        !           523: 
        !           524: inscollist_opt(A) ::= .                       {A = 0;}
        !           525: inscollist_opt(A) ::= LP inscollist(X) RP.    {A = X;}
        !           526: inscollist(A) ::= inscollist(X) COMMA nm(Y).  {A = sqliteIdListAppend(X,&Y);}
        !           527: inscollist(A) ::= nm(Y).                      {A = sqliteIdListAppend(0,&Y);}
        !           528: 
        !           529: /////////////////////////// Expression Processing /////////////////////////////
        !           530: //
        !           531: 
        !           532: %type expr {Expr*}
        !           533: %destructor expr {sqliteExprDelete($$);}
        !           534: 
        !           535: expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); }
        !           536: expr(A) ::= NULL(X).             {A = sqliteExpr(TK_NULL, 0, 0, &X);}
        !           537: expr(A) ::= ID(X).               {A = sqliteExpr(TK_ID, 0, 0, &X);}
        !           538: expr(A) ::= JOIN_KW(X).          {A = sqliteExpr(TK_ID, 0, 0, &X);}
        !           539: expr(A) ::= nm(X) DOT nm(Y). {
        !           540:   Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X);
        !           541:   Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y);
        !           542:   A = sqliteExpr(TK_DOT, temp1, temp2, 0);
        !           543: }
        !           544: expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
        !           545:   Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X);
        !           546:   Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y);
        !           547:   Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &Z);
        !           548:   Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0);
        !           549:   A = sqliteExpr(TK_DOT, temp1, temp4, 0);
        !           550: }
        !           551: expr(A) ::= INTEGER(X).      {A = sqliteExpr(TK_INTEGER, 0, 0, &X);}
        !           552: expr(A) ::= FLOAT(X).        {A = sqliteExpr(TK_FLOAT, 0, 0, &X);}
        !           553: expr(A) ::= STRING(X).       {A = sqliteExpr(TK_STRING, 0, 0, &X);}
        !           554: expr(A) ::= VARIABLE(X).     {
        !           555:   A = sqliteExpr(TK_VARIABLE, 0, 0, &X);
        !           556:   if( A ) A->iTable = ++pParse->nVar;
        !           557: }
        !           558: expr(A) ::= ID(X) LP exprlist(Y) RP(E). {
        !           559:   A = sqliteExprFunction(Y, &X);
        !           560:   sqliteExprSpan(A,&X,&E);
        !           561: }
        !           562: expr(A) ::= ID(X) LP STAR RP(E). {
        !           563:   A = sqliteExprFunction(0, &X);
        !           564:   sqliteExprSpan(A,&X,&E);
        !           565: }
        !           566: expr(A) ::= expr(X) AND expr(Y).   {A = sqliteExpr(TK_AND, X, Y, 0);}
        !           567: expr(A) ::= expr(X) OR expr(Y).    {A = sqliteExpr(TK_OR, X, Y, 0);}
        !           568: expr(A) ::= expr(X) LT expr(Y).    {A = sqliteExpr(TK_LT, X, Y, 0);}
        !           569: expr(A) ::= expr(X) GT expr(Y).    {A = sqliteExpr(TK_GT, X, Y, 0);}
        !           570: expr(A) ::= expr(X) LE expr(Y).    {A = sqliteExpr(TK_LE, X, Y, 0);}
        !           571: expr(A) ::= expr(X) GE expr(Y).    {A = sqliteExpr(TK_GE, X, Y, 0);}
        !           572: expr(A) ::= expr(X) NE expr(Y).    {A = sqliteExpr(TK_NE, X, Y, 0);}
        !           573: expr(A) ::= expr(X) EQ expr(Y).    {A = sqliteExpr(TK_EQ, X, Y, 0);}
        !           574: expr(A) ::= expr(X) BITAND expr(Y). {A = sqliteExpr(TK_BITAND, X, Y, 0);}
        !           575: expr(A) ::= expr(X) BITOR expr(Y).  {A = sqliteExpr(TK_BITOR, X, Y, 0);}
        !           576: expr(A) ::= expr(X) LSHIFT expr(Y). {A = sqliteExpr(TK_LSHIFT, X, Y, 0);}
        !           577: expr(A) ::= expr(X) RSHIFT expr(Y). {A = sqliteExpr(TK_RSHIFT, X, Y, 0);}
        !           578: expr(A) ::= expr(X) likeop(OP) expr(Y).  [LIKE]  {
        !           579:   ExprList *pList = sqliteExprListAppend(0, Y, 0);
        !           580:   pList = sqliteExprListAppend(pList, X, 0);
        !           581:   A = sqliteExprFunction(pList, 0);
        !           582:   if( A ) A->op = OP;
        !           583:   sqliteExprSpan(A, &X->span, &Y->span);
        !           584: }
        !           585: expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] {
        !           586:   ExprList *pList = sqliteExprListAppend(0, Y, 0);
        !           587:   pList = sqliteExprListAppend(pList, X, 0);
        !           588:   A = sqliteExprFunction(pList, 0);
        !           589:   if( A ) A->op = OP;
        !           590:   A = sqliteExpr(TK_NOT, A, 0, 0);
        !           591:   sqliteExprSpan(A,&X->span,&Y->span);
        !           592: }
        !           593: %type likeop {int}
        !           594: likeop(A) ::= LIKE. {A = TK_LIKE;}
        !           595: likeop(A) ::= GLOB. {A = TK_GLOB;}
        !           596: expr(A) ::= expr(X) PLUS expr(Y).  {A = sqliteExpr(TK_PLUS, X, Y, 0);}
        !           597: expr(A) ::= expr(X) MINUS expr(Y). {A = sqliteExpr(TK_MINUS, X, Y, 0);}
        !           598: expr(A) ::= expr(X) STAR expr(Y).  {A = sqliteExpr(TK_STAR, X, Y, 0);}
        !           599: expr(A) ::= expr(X) SLASH expr(Y). {A = sqliteExpr(TK_SLASH, X, Y, 0);}
        !           600: expr(A) ::= expr(X) REM expr(Y).   {A = sqliteExpr(TK_REM, X, Y, 0);}
        !           601: expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);}
        !           602: expr(A) ::= expr(X) ISNULL(E). {
        !           603:   A = sqliteExpr(TK_ISNULL, X, 0, 0);
        !           604:   sqliteExprSpan(A,&X->span,&E);
        !           605: }
        !           606: expr(A) ::= expr(X) IS NULL(E). {
        !           607:   A = sqliteExpr(TK_ISNULL, X, 0, 0);
        !           608:   sqliteExprSpan(A,&X->span,&E);
        !           609: }
        !           610: expr(A) ::= expr(X) NOTNULL(E). {
        !           611:   A = sqliteExpr(TK_NOTNULL, X, 0, 0);
        !           612:   sqliteExprSpan(A,&X->span,&E);
        !           613: }
        !           614: expr(A) ::= expr(X) NOT NULL(E). {
        !           615:   A = sqliteExpr(TK_NOTNULL, X, 0, 0);
        !           616:   sqliteExprSpan(A,&X->span,&E);
        !           617: }
        !           618: expr(A) ::= expr(X) IS NOT NULL(E). {
        !           619:   A = sqliteExpr(TK_NOTNULL, X, 0, 0);
        !           620:   sqliteExprSpan(A,&X->span,&E);
        !           621: }
        !           622: expr(A) ::= NOT(B) expr(X). {
        !           623:   A = sqliteExpr(TK_NOT, X, 0, 0);
        !           624:   sqliteExprSpan(A,&B,&X->span);
        !           625: }
        !           626: expr(A) ::= BITNOT(B) expr(X). {
        !           627:   A = sqliteExpr(TK_BITNOT, X, 0, 0);
        !           628:   sqliteExprSpan(A,&B,&X->span);
        !           629: }
        !           630: expr(A) ::= MINUS(B) expr(X). [UMINUS] {
        !           631:   A = sqliteExpr(TK_UMINUS, X, 0, 0);
        !           632:   sqliteExprSpan(A,&B,&X->span);
        !           633: }
        !           634: expr(A) ::= PLUS(B) expr(X). [UPLUS] {
        !           635:   A = sqliteExpr(TK_UPLUS, X, 0, 0);
        !           636:   sqliteExprSpan(A,&B,&X->span);
        !           637: }
        !           638: expr(A) ::= LP(B) select(X) RP(E). {
        !           639:   A = sqliteExpr(TK_SELECT, 0, 0, 0);
        !           640:   if( A ) A->pSelect = X;
        !           641:   sqliteExprSpan(A,&B,&E);
        !           642: }
        !           643: expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). {
        !           644:   ExprList *pList = sqliteExprListAppend(0, X, 0);
        !           645:   pList = sqliteExprListAppend(pList, Y, 0);
        !           646:   A = sqliteExpr(TK_BETWEEN, W, 0, 0);
        !           647:   if( A ) A->pList = pList;
        !           648:   sqliteExprSpan(A,&W->span,&Y->span);
        !           649: }
        !           650: expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). {
        !           651:   ExprList *pList = sqliteExprListAppend(0, X, 0);
        !           652:   pList = sqliteExprListAppend(pList, Y, 0);
        !           653:   A = sqliteExpr(TK_BETWEEN, W, 0, 0);
        !           654:   if( A ) A->pList = pList;
        !           655:   A = sqliteExpr(TK_NOT, A, 0, 0);
        !           656:   sqliteExprSpan(A,&W->span,&Y->span);
        !           657: }
        !           658: expr(A) ::= expr(X) IN LP exprlist(Y) RP(E).  {
        !           659:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           660:   if( A ) A->pList = Y;
        !           661:   sqliteExprSpan(A,&X->span,&E);
        !           662: }
        !           663: expr(A) ::= expr(X) IN LP select(Y) RP(E).  {
        !           664:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           665:   if( A ) A->pSelect = Y;
        !           666:   sqliteExprSpan(A,&X->span,&E);
        !           667: }
        !           668: expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E).  {
        !           669:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           670:   if( A ) A->pList = Y;
        !           671:   A = sqliteExpr(TK_NOT, A, 0, 0);
        !           672:   sqliteExprSpan(A,&X->span,&E);
        !           673: }
        !           674: expr(A) ::= expr(X) NOT IN LP select(Y) RP(E).  {
        !           675:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           676:   if( A ) A->pSelect = Y;
        !           677:   A = sqliteExpr(TK_NOT, A, 0, 0);
        !           678:   sqliteExprSpan(A,&X->span,&E);
        !           679: }
        !           680: expr(A) ::= expr(X) IN nm(Y) dbnm(D). {
        !           681:   SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
        !           682:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           683:   if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0);
        !           684:   sqliteExprSpan(A,&X->span,D.z?&D:&Y);
        !           685: }
        !           686: expr(A) ::= expr(X) NOT IN nm(Y) dbnm(D). {
        !           687:   SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
        !           688:   A = sqliteExpr(TK_IN, X, 0, 0);
        !           689:   if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0);
        !           690:   A = sqliteExpr(TK_NOT, A, 0, 0);
        !           691:   sqliteExprSpan(A,&X->span,D.z?&D:&Y);
        !           692: }
        !           693: 
        !           694: 
        !           695: /* CASE expressions */
        !           696: expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {
        !           697:   A = sqliteExpr(TK_CASE, X, Z, 0);
        !           698:   if( A ) A->pList = Y;
        !           699:   sqliteExprSpan(A, &C, &E);
        !           700: }
        !           701: %type case_exprlist {ExprList*}
        !           702: %destructor case_exprlist {sqliteExprListDelete($$);}
        !           703: case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
        !           704:   A = sqliteExprListAppend(X, Y, 0);
        !           705:   A = sqliteExprListAppend(A, Z, 0);
        !           706: }
        !           707: case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
        !           708:   A = sqliteExprListAppend(0, Y, 0);
        !           709:   A = sqliteExprListAppend(A, Z, 0);
        !           710: }
        !           711: %type case_else {Expr*}
        !           712: case_else(A) ::=  ELSE expr(X).         {A = X;}
        !           713: case_else(A) ::=  .                     {A = 0;} 
        !           714: %type case_operand {Expr*}
        !           715: case_operand(A) ::= expr(X).            {A = X;} 
        !           716: case_operand(A) ::= .                   {A = 0;} 
        !           717: 
        !           718: %type exprlist {ExprList*}
        !           719: %destructor exprlist {sqliteExprListDelete($$);}
        !           720: %type expritem {Expr*}
        !           721: %destructor expritem {sqliteExprDelete($$);}
        !           722: 
        !           723: exprlist(A) ::= exprlist(X) COMMA expritem(Y). 
        !           724:    {A = sqliteExprListAppend(X,Y,0);}
        !           725: exprlist(A) ::= expritem(X).            {A = sqliteExprListAppend(0,X,0);}
        !           726: expritem(A) ::= expr(X).                {A = X;}
        !           727: expritem(A) ::= .                       {A = 0;}
        !           728: 
        !           729: ///////////////////////////// The CREATE INDEX command ///////////////////////
        !           730: //
        !           731: cmd ::= CREATE(S) uniqueflag(U) INDEX nm(X)
        !           732:         ON nm(Y) dbnm(D) LP idxlist(Z) RP(E) onconf(R). {
        !           733:   SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D);
        !           734:   if( U!=OE_None ) U = R;
        !           735:   if( U==OE_Default) U = OE_Abort;
        !           736:   sqliteCreateIndex(pParse, &X, pSrc, Z, U, &S, &E);
        !           737: }
        !           738: 
        !           739: %type uniqueflag {int}
        !           740: uniqueflag(A) ::= UNIQUE.  { A = OE_Abort; }
        !           741: uniqueflag(A) ::= .        { A = OE_None; }
        !           742: 
        !           743: %type idxlist {IdList*}
        !           744: %destructor idxlist {sqliteIdListDelete($$);}
        !           745: %type idxlist_opt {IdList*}
        !           746: %destructor idxlist_opt {sqliteIdListDelete($$);}
        !           747: %type idxitem {Token}
        !           748: 
        !           749: idxlist_opt(A) ::= .                         {A = 0;}
        !           750: idxlist_opt(A) ::= LP idxlist(X) RP.         {A = X;}
        !           751: idxlist(A) ::= idxlist(X) COMMA idxitem(Y).  {A = sqliteIdListAppend(X,&Y);}
        !           752: idxlist(A) ::= idxitem(Y).                   {A = sqliteIdListAppend(0,&Y);}
        !           753: idxitem(A) ::= nm(X) sortorder.              {A = X;}
        !           754: 
        !           755: ///////////////////////////// The DROP INDEX command /////////////////////////
        !           756: //
        !           757: 
        !           758: cmd ::= DROP INDEX nm(X) dbnm(Y).   {
        !           759:   sqliteDropIndex(pParse, sqliteSrcListAppend(0,&X,&Y));
        !           760: }
        !           761: 
        !           762: 
        !           763: ///////////////////////////// The COPY command ///////////////////////////////
        !           764: //
        !           765: cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y) USING DELIMITERS STRING(Z).
        !           766:     {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,&Z,R);}
        !           767: cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y).
        !           768:     {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,0,R);}
        !           769: 
        !           770: ///////////////////////////// The VACUUM command /////////////////////////////
        !           771: //
        !           772: cmd ::= VACUUM.                {sqliteVacuum(pParse,0);}
        !           773: cmd ::= VACUUM nm(X).         {sqliteVacuum(pParse,&X);}
        !           774: 
        !           775: ///////////////////////////// The PRAGMA command /////////////////////////////
        !           776: //
        !           777: cmd ::= PRAGMA ids(X) EQ nm(Y).         {sqlitePragma(pParse,&X,&Y,0);}
        !           778: cmd ::= PRAGMA ids(X) EQ ON(Y).          {sqlitePragma(pParse,&X,&Y,0);}
        !           779: cmd ::= PRAGMA ids(X) EQ plus_num(Y).    {sqlitePragma(pParse,&X,&Y,0);}
        !           780: cmd ::= PRAGMA ids(X) EQ minus_num(Y).   {sqlitePragma(pParse,&X,&Y,1);}
        !           781: cmd ::= PRAGMA ids(X) LP nm(Y) RP.      {sqlitePragma(pParse,&X,&Y,0);}
        !           782: cmd ::= PRAGMA ids(X).                   {sqlitePragma(pParse,&X,&X,0);}
        !           783: plus_num(A) ::= plus_opt number(X).   {A = X;}
        !           784: minus_num(A) ::= MINUS number(X).     {A = X;}
        !           785: number(A) ::= INTEGER(X).  {A = X;}
        !           786: number(A) ::= FLOAT(X).    {A = X;}
        !           787: plus_opt ::= PLUS.
        !           788: plus_opt ::= .
        !           789: 
        !           790: //////////////////////////// The CREATE TRIGGER command /////////////////////
        !           791: 
        !           792: cmd ::= CREATE(A) trigger_decl BEGIN trigger_cmd_list(S) END(Z). {
        !           793:   Token all;
        !           794:   all.z = A.z;
        !           795:   all.n = (Z.z - A.z) + Z.n;
        !           796:   sqliteFinishTrigger(pParse, S, &all);
        !           797: }
        !           798: 
        !           799: trigger_decl ::= temp(T) TRIGGER nm(B) trigger_time(C) trigger_event(D)
        !           800:                  ON nm(E) dbnm(DB) foreach_clause(F) when_clause(G). {
        !           801:   SrcList *pTab = sqliteSrcListAppend(0, &E, &DB);
        !           802:   sqliteBeginTrigger(pParse, &B, C, D.a, D.b, pTab, F, G, T);
        !           803: }
        !           804: 
        !           805: %type trigger_time  {int}
        !           806: trigger_time(A) ::= BEFORE.      { A = TK_BEFORE; }
        !           807: trigger_time(A) ::= AFTER.       { A = TK_AFTER;  }
        !           808: trigger_time(A) ::= INSTEAD OF.  { A = TK_INSTEAD;}
        !           809: trigger_time(A) ::= .            { A = TK_BEFORE; }
        !           810: 
        !           811: %type trigger_event {struct TrigEvent}
        !           812: %destructor trigger_event {sqliteIdListDelete($$.b);}
        !           813: trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; }
        !           814: trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; }
        !           815: trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;}
        !           816: trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X; }
        !           817: 
        !           818: %type foreach_clause {int}
        !           819: foreach_clause(A) ::= .                   { A = TK_ROW; }
        !           820: foreach_clause(A) ::= FOR EACH ROW.       { A = TK_ROW; }
        !           821: foreach_clause(A) ::= FOR EACH STATEMENT. { A = TK_STATEMENT; }
        !           822: 
        !           823: %type when_clause {Expr *}
        !           824: when_clause(A) ::= .             { A = 0; }
        !           825: when_clause(A) ::= WHEN expr(X). { A = X; }
        !           826: 
        !           827: %type trigger_cmd_list {TriggerStep *}
        !           828: %destructor trigger_cmd_list {sqliteDeleteTriggerStep($$);}
        !           829: trigger_cmd_list(A) ::= trigger_cmd(X) SEMI trigger_cmd_list(Y). {
        !           830:   X->pNext = Y;
        !           831:   A = X;
        !           832: }
        !           833: trigger_cmd_list(A) ::= . { A = 0; }
        !           834: 
        !           835: %type trigger_cmd {TriggerStep *}
        !           836: %destructor trigger_cmd {sqliteDeleteTriggerStep($$);}
        !           837: // UPDATE 
        !           838: trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z).  
        !           839:                { A = sqliteTriggerUpdateStep(&X, Y, Z, R); }
        !           840: 
        !           841: // INSERT
        !           842: trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) 
        !           843:   VALUES LP itemlist(Y) RP.  
        !           844: {A = sqliteTriggerInsertStep(&X, F, Y, 0, R);}
        !           845: 
        !           846: trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S).
        !           847:                {A = sqliteTriggerInsertStep(&X, F, 0, S, R);}
        !           848: 
        !           849: // DELETE
        !           850: trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y).
        !           851:                {A = sqliteTriggerDeleteStep(&X, Y);}
        !           852: 
        !           853: // SELECT
        !           854: trigger_cmd(A) ::= select(X).  {A = sqliteTriggerSelectStep(X); }
        !           855: 
        !           856: // The special RAISE expression that may occur in trigger programs
        !           857: expr(A) ::= RAISE(X) LP IGNORE RP(Y).  {
        !           858:   A = sqliteExpr(TK_RAISE, 0, 0, 0); 
        !           859:   A->iColumn = OE_Ignore;
        !           860:   sqliteExprSpan(A, &X, &Y);
        !           861: }
        !           862: expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y).  {
        !           863:   A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
        !           864:   A->iColumn = OE_Rollback;
        !           865:   sqliteExprSpan(A, &X, &Y);
        !           866: }
        !           867: expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y).  {
        !           868:   A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
        !           869:   A->iColumn = OE_Abort;
        !           870:   sqliteExprSpan(A, &X, &Y);
        !           871: }
        !           872: expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y).  {
        !           873:   A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
        !           874:   A->iColumn = OE_Fail;
        !           875:   sqliteExprSpan(A, &X, &Y);
        !           876: }
        !           877: 
        !           878: ////////////////////////  DROP TRIGGER statement //////////////////////////////
        !           879: cmd ::= DROP TRIGGER nm(X) dbnm(D). {
        !           880:   sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&X,&D));
        !           881: }
        !           882: 
        !           883: //////////////////////// ATTACH DATABASE file AS name /////////////////////////
        !           884: cmd ::= ATTACH database_kw_opt ids(F) AS nm(D) key_opt(K). {
        !           885:   sqliteAttach(pParse, &F, &D, &K);
        !           886: }
        !           887: %type key_opt {Token}
        !           888: key_opt(A) ::= USING ids(X).  { A = X; }
        !           889: key_opt(A) ::= .              { A.z = 0; A.n = 0; }
        !           890: 
        !           891: database_kw_opt ::= DATABASE.
        !           892: database_kw_opt ::= .
        !           893: 
        !           894: //////////////////////// DETACH DATABASE name /////////////////////////////////
        !           895: cmd ::= DETACH database_kw_opt nm(D). {
        !           896:   sqliteDetach(pParse, &D);
        !           897: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>