Fix for tickets #90 and #89: Make the AS keyword optional again. (CVS 654)

FossilOrigin-Name: 1f8a73b1c3833e3924196458d4c1ecca90f63662

diff --git a/manifest b/manifest
index ca3eea071de4fdf1ee6b7f84d9e9225064114010..204c5ae0f917cd8f3e8a620e54403c52eda25be3 100644 (file)
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Added\sadditional\stests.\s\sNo\snew\serrors\sfound.\s(CVS\s653)
-D 2002-07-01T00:31:36
+C Fix\sfor\stickets\s#90\sand\s#89:\sMake\sthe\sAS\skeyword\soptional\sagain.\s(CVS\s654)
+D 2002-07-01T12:27:09
 F Makefile.in 6291a33b87d2a395aafd7646ee1ed562c6f2c28c
 F Makefile.template 4e11752e0b5c7a043ca50af4296ec562857ba495
 F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0
@@ -34,7 +34,7 @@ F src/os.c 9cc40c5384baba4a85e160e67807645ca98ba3cc
 F src/os.h 4a361fccfbc4e7609b3e1557f604f94c1e96ad10
 F src/pager.c 58ae9f569b3c664ea9205c6f6da432e3ae180f56
 F src/pager.h 6fddfddd3b73aa8abc081b973886320e3c614f0e
-F src/parse.y c75ea2580de675bcb80ff8b7c10c0a15e02a21ab
+F src/parse.y dcaf21965b6cba956d1ad014b87d849cee52af13
 F src/printf.c 236ed7a79386feed4456fa728fff8be793f1547c
 F src/random.c 19e8e00fe0df32a742f115773f57651be327cabe
 F src/select.c 63a10ea636c8ac8cdf2fbb804fbfcfd372150717
@@ -48,7 +48,7 @@ F src/test1.c a2f2b6b1df07d4e8b380323896c3ed34442cea91
 F src/test2.c 669cc22781c6461a273416ec1a7414d25c081730
 F src/test3.c 72ac6a9017a70e542954907a1dfd87ab6f7824e3
 F src/threadtest.c 81f0598e0f031c1bd506af337fdc1b7e8dff263f
-F src/tokenize.c ac4c46f190346b87da54ec3e2605d160af80c619
+F src/tokenize.c b5500e193a82b5b9888fbf947efd90d3b4858178
 F src/trigger.c d88ab4d68d68955c217b38fb6717e090fbbf54a4
 F src/update.c 06303bf3895032c7eccb748927f650ed02b9f0cf
 F src/util.c 876b259f9186e84b944b72e793dd3dad50e63e95
@@ -71,7 +71,7 @@ F test/insert.test a122afb86911e77c181d912348866a5b1a61eeab
 F test/insert2.test c288375a64dad3295044714f0dfed4a193cf067f
 F test/intpkey.test 69a6a9b41e541f27a2ffcd20264fb35adc3c2680
 F test/ioerr.test 57d9bffaca18b34f9e976f786eadc2591d6efc6a
-F test/join.test 89bd99545094c51a04c2582b014c4527c4d90119
+F test/join.test 75561ec0e5fdde381a3e31317ebe4d6d9474bb71
 F test/limit.test 49b44e027a002c0ba336d723b448f07e05b04466
 F test/lock.test f1b55dc61632e99d241643cc8e7c03774f09f623
 F test/main.test c66b564554b770ee7fdbf6a66c0cd90329bc2c85
@@ -137,7 +137,7 @@ F www/speed.tcl da8afcc1d3ccc5696cfb388a68982bc3d9f7f00f
 F www/sqlite.tcl ae3dcfb077e53833b59d4fcc94d8a12c50a44098
 F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
 F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
-P 91c0db66c86facb21b5b522afadd83d91a488256
-R 7d04cf3eef7b325f91f0693158023bcb
+P 8924a7f5bab790ab552332d6359028d0d1825e4a
+R ad6a9eb588fa8773b80d0e8d3383a433
 U drh
-Z e9235d5a107811a531de8a11c88a7168
+Z b747e9af845dbd1dc48cbbd19d5e8f64

diff --git a/manifest.uuid b/manifest.uuid
index 60e6e273eca58f76734e2216b6899ec44d8ccda1..9047ba673f5898c7ea7fc395e69eab03879faf5d 100644 (file)
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-8924a7f5bab790ab552332d6359028d0d1825e4a
\ No newline at end of file
+1f8a73b1c3833e3924196458d4c1ecca90f63662
\ No newline at end of file

diff --git a/src/parse.y b/src/parse.y
index 5ea48dfe3ab00b3c504953db0e8b35b2f57b4f5c..0eadf3570cf86067873e9165cbfccf51327601de 100644 (file)
--- a/src/parse.y
+++ b/src/parse.y
@@ -14,7 +14,7 @@
 ** the parser.  Lemon will also generate a header file containing
 ** numeric codes for all of the tokens.
 **
-** @(#) $Id: parse.y,v 1.75 2002/06/25 01:09:12 drh Exp $
+** @(#) $Id: parse.y,v 1.76 2002/07/01 12:27:09 drh Exp $
 */
 %token_prefix TK_
 %token_type {Token}
@@ -75,7 +75,7 @@ explain ::= .           { sqliteBeginParse(pParse, 0); }
 cmd ::= BEGIN trans_opt onconf(R).  {sqliteBeginTransaction(pParse,R);}
 trans_opt ::= .
 trans_opt ::= TRANSACTION.
-trans_opt ::= TRANSACTION ids.
+trans_opt ::= TRANSACTION nm.
 cmd ::= COMMIT trans_opt.      {sqliteCommitTransaction(pParse);}
 cmd ::= END trans_opt.         {sqliteCommitTransaction(pParse);}
 cmd ::= ROLLBACK trans_opt.    {sqliteRollbackTransaction(pParse);}
@@ -83,7 +83,7 @@ cmd ::= ROLLBACK trans_opt.    {sqliteRollbackTransaction(pParse);}
 ///////////////////// The CREATE TABLE statement ////////////////////////////
 //
 cmd ::= create_table create_table_args.
-create_table ::= CREATE(X) temp(T) TABLE ids(Y). {
+create_table ::= CREATE(X) temp(T) TABLE nm(Y). {
    sqliteStartTable(pParse,&X,&Y,T);
 }
 %type temp {int}
@@ -104,7 +104,7 @@ columnlist ::= column.
 // an elaborate typename.  Perhaps someday we'll do something with it.
 //
 column ::= columnid type carglist. 
-columnid ::= ids(X).                {sqliteAddColumn(pParse,&X);}
+columnid ::= nm(X).                {sqliteAddColumn(pParse,&X);}
 
 // An IDENTIFIER can be a generic identifier, or one of several
 // keywords.  Any non-standard keyword can also be an identifier.
@@ -119,16 +119,23 @@ id(A) ::= ID(X).         {A = X;}
 %fallback ID 
   ABORT AFTER ASC BEFORE BEGIN CASCADE CLUSTER COLLATE CONFLICT
   COPY DEFERRED DELIMITERS DESC EACH END EXPLAIN FAIL FOR
-  FULL IGNORE IMMEDIATE INITIALLY INSTEAD MATCH JOIN KEY
-  OF OFFSET PARTIAL PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT
+  IGNORE IMMEDIATE INITIALLY INSTEAD MATCH KEY
+  OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT
   TEMP TRIGGER VACUUM VIEW.
 
 // And "ids" is an identifer-or-string.
 //
 %type ids {Token}
-ids(A) ::= id(X).        {A = X;}
+ids(A) ::= ID(X).        {A = X;}
 ids(A) ::= STRING(X).    {A = X;}
 
+// The name of a column or table can be any of the following:
+//
+%type nm {Token}
+nm(A) ::= ID(X).         {A = X;}
+nm(A) ::= STRING(X).     {A = X;}
+nm(A) ::= JOIN_KW(X).    {A = X;}
+
 type ::= .
 type ::= typename(X).                    {sqliteAddColumnType(pParse,&X,&X);}
 type ::= typename(X) LP signed RP(Y).    {sqliteAddColumnType(pParse,&X,&Y);}
@@ -142,7 +149,7 @@ signed ::= PLUS INTEGER.
 signed ::= MINUS INTEGER.
 carglist ::= carglist carg.
 carglist ::= .
-carg ::= CONSTRAINT ids ccons.
+carg ::= CONSTRAINT nm ccons.
 carg ::= ccons.
 carg ::= DEFAULT STRING(X).          {sqliteAddDefaultValue(pParse,&X,0);}
 carg ::= DEFAULT ID(X).              {sqliteAddDefaultValue(pParse,&X,0);}
@@ -170,12 +177,11 @@ ccons ::= COLLATE id(C).  {
 // A REFERENCES clause is parsed but the current implementation does not
 // do anything with it.
 //
-references ::= REFERENCES ids LP idxlist RP refargs.
-references ::= REFERENCES ids refargs.
+references ::= REFERENCES nm LP idxlist RP refargs.
+references ::= REFERENCES nm refargs.
 refargs ::= .
 refargs ::= refargs refarg.
-refarg ::= MATCH FULL.
-refarg ::= MATCH PARTIAL.
+refarg ::= MATCH nm.
 refarg ::= ON DELETE refact.
 refarg ::= ON UPDATE refact.
 refact ::= SET NULL.
@@ -196,7 +202,7 @@ conslist_opt ::= COMMA conslist.
 conslist ::= conslist COMMA tcons.
 conslist ::= conslist tcons.
 conslist ::= tcons.
-tcons ::= CONSTRAINT ids.
+tcons ::= CONSTRAINT nm.
 tcons ::= PRIMARY KEY LP idxlist(X) RP onconf(R).
                                              {sqliteAddPrimaryKey(pParse,X,R);}
 tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
@@ -224,14 +230,14 @@ resolvetype(A) ::= REPLACE.                  { A = OE_Replace; }
 
 ////////////////////////// The DROP TABLE /////////////////////////////////////
 //
-cmd ::= DROP TABLE ids(X).          {sqliteDropTable(pParse,&X,0);}
+cmd ::= DROP TABLE nm(X).          {sqliteDropTable(pParse,&X,0);}
 
 ///////////////////// The CREATE VIEW statement /////////////////////////////
 //
-cmd ::= CREATE(X) VIEW ids(Y) AS select(S). {
+cmd ::= CREATE(X) VIEW nm(Y) AS select(S). {
   sqliteCreateView(pParse, &X, &Y, S);
 }
-cmd ::= DROP VIEW ids(X). {
+cmd ::= DROP VIEW nm(X). {
   sqliteDropTable(pParse, &X, 1);
 }
 
@@ -290,7 +296,7 @@ selcollist(A) ::= sclp(P) expr(X) as(Y).     {
 selcollist(A) ::= sclp(P) STAR. {
   A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0);
 }
-selcollist(A) ::= sclp(P) ids(X) DOT STAR. {
+selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
   Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0);
   Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X);
   A = sqliteExprListAppend(P, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0);
@@ -300,8 +306,9 @@ selcollist(A) ::= sclp(P) ids(X) DOT STAR. {
 // define the result set, or one of the tables in the FROM clause.
 //
 %type as {Token}
-as(X) ::= AS ids(Y).    { X = Y; }
-as(X) ::= .             { X.n = 0; }
+as(X) ::= AS nm(Y).    { X = Y; }
+as(X) ::= ids(Y).      { X = Y; }
+as(X) ::= .            { X.n = 0; }
 
 
 %type seltablist {SrcList*}
@@ -324,7 +331,7 @@ stl_prefix(A) ::= seltablist(X) joinop(Y).    {
    if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y;
 }
 stl_prefix(A) ::= .                           {A = 0;}
-seltablist(A) ::= stl_prefix(X) ids(Y) as(Z) on_opt(N) using_opt(U). {
+seltablist(A) ::= stl_prefix(X) nm(Y) as(Z) on_opt(N) using_opt(U). {
   A = sqliteSrcListAppend(X,&Y);
   if( Z.n ) sqliteSrcListAddAlias(A,&Z);
   if( N ){
@@ -358,9 +365,10 @@ seltablist(A) ::= stl_prefix(X) LP select(S) RP as(Z) on_opt(N) using_opt(U). {
 %type joinop2 {int}
 joinop(X) ::= COMMA.                   { X = JT_INNER; }
 joinop(X) ::= JOIN.                    { X = JT_INNER; }
-joinop(X) ::= ID(A) JOIN.              { X = sqliteJoinType(pParse,&A,0,0); }
-joinop(X) ::= ID(A) ID(B) JOIN.        { X = sqliteJoinType(pParse,&A,&B,0); }
-joinop(X) ::= ID(A) ID(B) ID(C) JOIN.  { X = sqliteJoinType(pParse,&A,&B,&C); }
+joinop(X) ::= JOIN_KW(A) JOIN.         { X = sqliteJoinType(pParse,&A,0,0); }
+joinop(X) ::= JOIN_KW(A) nm(B) JOIN.   { X = sqliteJoinType(pParse,&A,&B,0); }
+joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
+                                       { X = sqliteJoinType(pParse,&A,&B,&C); }
 
 %type on_opt {Expr*}
 %destructor on_opt {sqliteExprDelete($$);}
@@ -421,7 +429,7 @@ limit_sep ::= COMMA.
 
 /////////////////////////// The DELETE statement /////////////////////////////
 //
-cmd ::= DELETE FROM ids(X) where_opt(Y).
+cmd ::= DELETE FROM nm(X) where_opt(Y).
     {sqliteDeleteFrom(pParse, &X, Y);}
 
 %type where_opt {Expr*}
@@ -435,18 +443,18 @@ where_opt(A) ::= WHERE expr(X).       {A = X;}
 
 ////////////////////////// The UPDATE command ////////////////////////////////
 //
-cmd ::= UPDATE orconf(R) ids(X) SET setlist(Y) where_opt(Z).
+cmd ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z).
     {sqliteUpdate(pParse,&X,Y,Z,R);}
 
-setlist(A) ::= setlist(Z) COMMA ids(X) EQ expr(Y).
+setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).
     {A = sqliteExprListAppend(Z,Y,&X);}
-setlist(A) ::= ids(X) EQ expr(Y).   {A = sqliteExprListAppend(0,Y,&X);}
+setlist(A) ::= nm(X) EQ expr(Y).   {A = sqliteExprListAppend(0,Y,&X);}
 
 ////////////////////////// The INSERT command /////////////////////////////////
 //
-cmd ::= insert_cmd(R) INTO ids(X) inscollist_opt(F) VALUES LP itemlist(Y) RP.
+cmd ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) VALUES LP itemlist(Y) RP.
                {sqliteInsert(pParse, &X, Y, 0, F, R);}
-cmd ::= insert_cmd(R) INTO ids(X) inscollist_opt(F) select(S).
+cmd ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S).
                {sqliteInsert(pParse, &X, 0, S, F, R);}
 
 %type insert_cmd {int}
@@ -467,8 +475,8 @@ itemlist(A) ::= expr(X).                    {A = sqliteExprListAppend(0,X,0);}
 
 inscollist_opt(A) ::= .                       {A = 0;}
 inscollist_opt(A) ::= LP inscollist(X) RP.    {A = X;}
-inscollist(A) ::= inscollist(X) COMMA ids(Y). {A = sqliteIdListAppend(X,&Y);}
-inscollist(A) ::= ids(Y).                     {A = sqliteIdListAppend(0,&Y);}
+inscollist(A) ::= inscollist(X) COMMA nm(Y).  {A = sqliteIdListAppend(X,&Y);}
+inscollist(A) ::= nm(Y).                      {A = sqliteIdListAppend(0,&Y);}
 
 /////////////////////////// Expression Processing /////////////////////////////
 //
@@ -488,8 +496,9 @@ inscollist(A) ::= ids(Y).                     {A = sqliteIdListAppend(0,&Y);}
 
 expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E);}
 expr(A) ::= NULL(X).             {A = sqliteExpr(TK_NULL, 0, 0, &X);}
-expr(A) ::= id(X).               {A = sqliteExpr(TK_ID, 0, 0, &X);}
-expr(A) ::= ids(X) DOT ids(Y). {
+expr(A) ::= ID(X).               {A = sqliteExpr(TK_ID, 0, 0, &X);}
+expr(A) ::= JOIN_KW(X).          {A = sqliteExpr(TK_ID, 0, 0, &X);}
+expr(A) ::= nm(X) DOT nm(Y). {
   Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X);
   Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y);
   A = sqliteExpr(TK_DOT, temp1, temp2, 0);
@@ -653,8 +662,8 @@ expritem(A) ::= .                       {A = 0;}
 
 ///////////////////////////// The CREATE INDEX command ///////////////////////
 //
-cmd ::= CREATE(S) uniqueflag(U) INDEX ids(X)
-        ON ids(Y) LP idxlist(Z) RP(E) onconf(R). {
+cmd ::= CREATE(S) uniqueflag(U) INDEX nm(X)
+        ON nm(Y) LP idxlist(Z) RP(E) onconf(R). {
   if( U!=OE_None ) U = R;
   if( U==OE_Default) U = OE_Abort;
   sqliteCreateIndex(pParse, &X, &Y, Z, U, &S, &E);
@@ -672,33 +681,33 @@ idxlist(A) ::= idxlist(X) COMMA idxitem(Y).
      {A = sqliteIdListAppend(X,&Y);}
 idxlist(A) ::= idxitem(Y).
      {A = sqliteIdListAppend(0,&Y);}
-idxitem(A) ::= ids(X).          {A = X;}
+idxitem(A) ::= nm(X).          {A = X;}
 
 ///////////////////////////// The DROP INDEX command /////////////////////////
 //
 
-cmd ::= DROP INDEX ids(X).      {sqliteDropIndex(pParse, &X);}
+cmd ::= DROP INDEX nm(X).      {sqliteDropIndex(pParse, &X);}
 
 
 ///////////////////////////// The COPY command ///////////////////////////////
 //
-cmd ::= COPY orconf(R) ids(X) FROM ids(Y) USING DELIMITERS STRING(Z).
+cmd ::= COPY orconf(R) nm(X) FROM nm(Y) USING DELIMITERS STRING(Z).
     {sqliteCopy(pParse,&X,&Y,&Z,R);}
-cmd ::= COPY orconf(R) ids(X) FROM ids(Y).
+cmd ::= COPY orconf(R) nm(X) FROM nm(Y).
     {sqliteCopy(pParse,&X,&Y,0,R);}
 
 ///////////////////////////// The VACUUM command /////////////////////////////
 //
 cmd ::= VACUUM.                {sqliteVacuum(pParse,0);}
-cmd ::= VACUUM ids(X).         {sqliteVacuum(pParse,&X);}
+cmd ::= VACUUM nm(X).         {sqliteVacuum(pParse,&X);}
 
 ///////////////////////////// The PRAGMA command /////////////////////////////
 //
-cmd ::= PRAGMA ids(X) EQ ids(Y).         {sqlitePragma(pParse,&X,&Y,0);}
+cmd ::= PRAGMA ids(X) EQ nm(Y).         {sqlitePragma(pParse,&X,&Y,0);}
 cmd ::= PRAGMA ids(X) EQ ON(Y).          {sqlitePragma(pParse,&X,&Y,0);}
 cmd ::= PRAGMA ids(X) EQ plus_num(Y).    {sqlitePragma(pParse,&X,&Y,0);}
 cmd ::= PRAGMA ids(X) EQ minus_num(Y).   {sqlitePragma(pParse,&X,&Y,1);}
-cmd ::= PRAGMA ids(X) LP ids(Y) RP.      {sqlitePragma(pParse,&X,&Y,0);}
+cmd ::= PRAGMA ids(X) LP nm(Y) RP.      {sqlitePragma(pParse,&X,&Y,0);}
 cmd ::= PRAGMA ids(X).                   {sqlitePragma(pParse,&X,&X,0);}
 plus_num(A) ::= plus_opt number(X).   {A = X;}
 minus_num(A) ::= MINUS number(X).     {A = X;}
@@ -708,7 +717,7 @@ plus_opt ::= PLUS.
 plus_opt ::= .
 
 //////////////////////////// The CREATE TRIGGER command /////////////////////
-cmd ::= CREATE(A) TRIGGER ids(B) trigger_time(C) trigger_event(D) ON ids(E) 
+cmd ::= CREATE(A) TRIGGER nm(B) trigger_time(C) trigger_event(D) ON nm(E) 
                   foreach_clause(F) when_clause(G)
                   BEGIN trigger_cmd_list(S) END(Z). {
   sqliteCreateTrigger(pParse, &B, C, D.a, D.b, &E, F, G, S, 
@@ -744,19 +753,19 @@ trigger_cmd_list(A) ::= . { A = 0; }
 
 %type trigger_cmd {TriggerStep *}
 // UPDATE 
-trigger_cmd(A) ::= UPDATE orconf(R) ids(X) SET setlist(Y) where_opt(Z).  
+trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z).  
                { A = sqliteTriggerUpdateStep(&X, Y, Z, R); }
 
 // INSERT
-trigger_cmd(A) ::= INSERT orconf(R) INTO ids(X) inscollist_opt(F) 
+trigger_cmd(A) ::= INSERT orconf(R) INTO nm(X) inscollist_opt(F) 
   VALUES LP itemlist(Y) RP.  
 {A = sqliteTriggerInsertStep(&X, F, Y, 0, R);}
 
-trigger_cmd(A) ::= INSERT orconf(R) INTO ids(X) inscollist_opt(F) select(S).
+trigger_cmd(A) ::= INSERT orconf(R) INTO nm(X) inscollist_opt(F) select(S).
                {A = sqliteTriggerInsertStep(&X, F, 0, S, R);}
 
 // DELETE
-trigger_cmd(A) ::= DELETE FROM ids(X) where_opt(Y).
+trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y).
                {A = sqliteTriggerDeleteStep(&X, Y);}
 
 // SELECT
@@ -765,17 +774,17 @@ trigger_cmd(A) ::= select(X).  {A = sqliteTriggerSelectStep(X); }
 // The special RAISE expression that may occur in trigger programs
 expr(A) ::= RAISE(X) LP IGNORE RP(Y).  { A = sqliteExpr(TK_RAISE, 0, 0, 0); 
     A->iColumn = OE_Ignore; sqliteExprSpan(A, &X, &Y);}
-expr(A) ::= RAISE(X) LP ROLLBACK COMMA ids(Z) RP(Y).  
+expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y).  
 { A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
     A->iColumn = OE_Rollback; sqliteExprSpan(A, &X, &Y);}
-expr(A) ::= RAISE(X) LP ABORT COMMA ids(Z) RP(Y).  
+expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y).  
 { A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
     A->iColumn = OE_Abort; sqliteExprSpan(A, &X, &Y);}
-expr(A) ::= RAISE(X) LP FAIL COMMA ids(Z) RP(Y).  
+expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y).  
 { A = sqliteExpr(TK_RAISE, 0, 0, &Z); 
     A->iColumn = OE_Fail; sqliteExprSpan(A, &X, &Y);}
 
 ////////////////////////  DROP TRIGGER statement //////////////////////////////
-cmd ::= DROP TRIGGER ids(X). {
+cmd ::= DROP TRIGGER nm(X). {
     sqliteDropTrigger(pParse,&X,0);
 }

diff --git a/src/tokenize.c b/src/tokenize.c
index 7090c7c5764a50290b00a23b0ea02106b14d4766..ed2329c04d5c19a57304a8b4513ae1e7a1faae82 100644 (file)
--- a/src/tokenize.c
+++ b/src/tokenize.c
@@ -15,7 +15,7 @@
 ** individual tokens and sends those tokens one-by-one over to the
 ** parser for analysis.
 **
-** $Id: tokenize.c,v 1.46 2002/06/17 17:07:20 drh Exp $
+** $Id: tokenize.c,v 1.47 2002/07/01 12:27:09 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
@@ -58,6 +58,7 @@ static Keyword aKeywordTable[] = {
   { "CONSTRAINT",        0, TK_CONSTRAINT,       0 },
   { "COPY",              0, TK_COPY,             0 },
   { "CREATE",            0, TK_CREATE,           0 },
+  { "CROSS",             0, TK_JOIN_KW,          0 },
   { "DEFAULT",           0, TK_DEFAULT,          0 },
   { "DEFERRED",          0, TK_DEFERRED,         0 },
   { "DEFERRABLE",        0, TK_DEFERRABLE,       0 },
@@ -75,7 +76,7 @@ static Keyword aKeywordTable[] = {
   { "FOR",               0, TK_FOR,              0 },
   { "FOREIGN",           0, TK_FOREIGN,          0 },
   { "FROM",              0, TK_FROM,             0 },
-  { "FULL",              0, TK_FULL,             0 },
+  { "FULL",              0, TK_JOIN_KW,          0 },
   { "GLOB",              0, TK_GLOB,             0 },
   { "GROUP",             0, TK_GROUP,            0 },
   { "HAVING",            0, TK_HAVING,           0 },
@@ -84,6 +85,7 @@ static Keyword aKeywordTable[] = {
   { "IN",                0, TK_IN,               0 },
   { "INDEX",             0, TK_INDEX,            0 },
   { "INITIALLY",         0, TK_INITIALLY,        0 },
+  { "INNER",             0, TK_JOIN_KW,          0 },
   { "INSERT",            0, TK_INSERT,           0 },
   { "INSTEAD",           0, TK_INSTEAD,          0 },
   { "INTERSECT",         0, TK_INTERSECT,        0 },
@@ -92,9 +94,11 @@ static Keyword aKeywordTable[] = {
   { "ISNULL",            0, TK_ISNULL,           0 },
   { "JOIN",              0, TK_JOIN,             0 },
   { "KEY",               0, TK_KEY,              0 },
+  { "LEFT",              0, TK_JOIN_KW,          0 },
   { "LIKE",              0, TK_LIKE,             0 },
   { "LIMIT",             0, TK_LIMIT,            0 },
   { "MATCH",             0, TK_MATCH,            0 },
+  { "NATURAL",           0, TK_JOIN_KW,          0 },
   { "NOT",               0, TK_NOT,              0 },
   { "NOTNULL",           0, TK_NOTNULL,          0 },
   { "NULL",              0, TK_NULL,             0 },
@@ -103,13 +107,14 @@ static Keyword aKeywordTable[] = {
   { "ON",                0, TK_ON,               0 },
   { "OR",                0, TK_OR,               0 },
   { "ORDER",             0, TK_ORDER,            0 },
-  { "PARTIAL",           0, TK_PARTIAL,          0 },
+  { "OUTER",             0, TK_JOIN_KW,          0 },
   { "PRAGMA",            0, TK_PRAGMA,           0 },
   { "PRIMARY",           0, TK_PRIMARY,          0 },
   { "RAISE",             0, TK_RAISE,            0 },
   { "REFERENCES",        0, TK_REFERENCES,       0 },
   { "REPLACE",           0, TK_REPLACE,          0 },
   { "RESTRICT",          0, TK_RESTRICT,         0 },
+  { "RIGHT",             0, TK_JOIN_KW,          0 },
   { "ROLLBACK",          0, TK_ROLLBACK,         0 },
   { "ROW",               0, TK_ROW,              0 },
   { "SELECT",            0, TK_SELECT,           0 },

diff --git a/test/join.test b/test/join.test
index 3dcd7ab33f496b4f7659cb21a48e8e624f351563..ee91d5f4c9fa3305d6b9169922577bdf8ce23b82 100644 (file)
--- a/test/join.test
+++ b/test/join.test
@@ -12,7 +12,7 @@
 #
 # This file implements tests for joins, including outer joins.
 #
-# $Id: join.test,v 1.3 2002/06/28 12:18:48 drh Exp $
+# $Id: join.test,v 1.4 2002/07/01 12:27:09 drh Exp $
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
@@ -217,9 +217,9 @@ do_test join-3.7 {
 } {1 {unknown or unsupported join type: INNER OUTER}}
 do_test join-3.7 {
   catchsql {
-    SELECT * FROM t1 BOGUS JOIN t2;
+    SELECT * FROM t1 LEFT BOGUS JOIN t2;
   }
-} {1 {unknown or unsupported join type: BOGUS}}
+} {1 {unknown or unsupported join type: LEFT BOGUS}}
 
 
 finish_test