Annotation of embedaddon/php/ext/sqlite/libsqlite/src/parse.y, revision 1.1.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>