Skip to content

P
Postgres FD Implementation
Commit ec438886 authored by Tom Lane's avatar Tom Lane
Browse files
Options

Allow TIMESTAMP, VARCHAR, et al to be used as unquoted column names, 

though alas not as unquoted function names.  De-reserve a bunch of
keywords that could have been in ColId rather than ColLabel all along.
Per recent proposal in pgsql-patches.
parent 26e8a4f3
Show whitespace changes
Inline Side-by-side
Showing with 533 additions and 478 deletions
src/backend/parser/gram.y
View file @ ec438886
......@@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.272 2001/11/05 05:00:14 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.273 2001/11/10 22:31:49 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
......@@ -257,8 +257,8 @@ static void doNegateFloat(Value *v);
%type <paramno> ParamNo
%type <typnam> Typename, SimpleTypename, ConstTypename
GenericType, Numeric, Geometric, Character, ConstDatetime, ConstInterval, Bit
%type <str> character, datetime, bit
GenericType, Numeric, Character, ConstDatetime, ConstInterval, Bit
%type <str> character, bit
%type <str> extract_arg
%type <str> opt_charset, opt_collate
%type <str> opt_float
......@@ -268,7 +268,7 @@ static void doNegateFloat(Value *v);
%type <ival> Iconst
%type <str> Sconst, comment_text
%type <str> UserId, opt_boolean, var_value, ColId_or_Sconst
%type <str> ColId, ColLabel, TokenId
%type <str> ColId, TypeFuncId, ColLabel
%type <node> zone_value
%type <node> TableConstraint
......@@ -1007,11 +1007,11 @@ constraints_set_list: ALL
;
constraints_set_namelist: IDENT
constraints_set_namelist: ColId
{
$$ = makeList1($1);
}
| constraints_set_namelist ',' IDENT
| constraints_set_namelist ',' ColId
{
$$ = lappend($1, $3);
}
......@@ -2007,8 +2007,8 @@ def_elem: ColLabel '=' def_arg
}
;
/* Note: any simple identifier will be returned as a type name! */
def_arg: func_return { $$ = (Node *)$1; }
| TokenId { $$ = (Node *)makeString($1); }
| all_Op { $$ = (Node *)makeString($1); }
| NumericOnly { $$ = (Node *)$1; }
| Sconst { $$ = (Node *)makeString($1); }
......@@ -2629,11 +2629,15 @@ func_return: func_type
}
;
/*
* We would like to make the second production here be ColId '.' ColId etc,
* but that causes reduce/reduce conflicts. TypeFuncId is next best choice.
*/
func_type: Typename
{
$$ = $1;
}
| IDENT '.' ColId '%' TYPE_P
| TypeFuncId '.' ColId '%' TYPE_P
{
$$ = makeNode(TypeName);
$$->name = $1;
......@@ -4064,13 +4068,12 @@ SimpleTypename: ConstTypename
ConstTypename: GenericType
| Numeric
| Geometric
| Bit
| Character
| ConstDatetime
;
GenericType: IDENT
GenericType: TypeFuncId
{
$$ = makeNode(TypeName);
$$->name = xlateSqlType($1);
......@@ -4086,7 +4089,7 @@ GenericType: IDENT
Numeric: FLOAT opt_float
{
$$ = makeNode(TypeName);
$$->name = xlateSqlType($2);
$$->name = $2; /* already xlated */
$$->typmod = -1;
}
| DOUBLE PRECISION
......@@ -4115,14 +4118,6 @@ Numeric: FLOAT opt_float
}
;
Geometric: PATH_P
{
$$ = makeNode(TypeName);
$$->name = xlateSqlType("path");
$$->typmod = -1;
}
;
opt_float: '(' Iconst ')'
{
if ($2 < 1)
......@@ -4299,13 +4294,7 @@ opt_collate: COLLATE ColId { $$ = $2; }
| /*EMPTY*/ { $$ = NULL; }
;
ConstDatetime: datetime
{
$$ = makeNode(TypeName);
$$->name = xlateSqlType($1);
$$->typmod = -1;
}
| TIMESTAMP '(' Iconst ')' opt_timezone_x
ConstDatetime: TIMESTAMP '(' Iconst ')' opt_timezone_x
{
$$ = makeNode(TypeName);
if ($5)
......@@ -4371,14 +4360,6 @@ ConstInterval: INTERVAL
}
;
datetime: YEAR_P { $$ = "year"; }
| MONTH_P { $$ = "month"; }
| DAY_P { $$ = "day"; }
| HOUR_P { $$ = "hour"; }
| MINUTE_P { $$ = "minute"; }
| SECOND_P { $$ = "second"; }
;
/* XXX Make the default be WITH TIME ZONE for 7.2 to help with database upgrades
* but revert this back to WITHOUT TIME ZONE for 7.3.
* Do this by simply reverting opt_timezone_x to opt_timezone - thomas 2001-09-06
......@@ -5270,9 +5251,14 @@ extract_list: extract_arg FROM a_expr
* - thomas 2001-04-12
*/
extract_arg: datetime { $$ = $1; }
extract_arg: IDENT { $$ = $1; }
| YEAR_P { $$ = "year"; }
| MONTH_P { $$ = "month"; }
| DAY_P { $$ = "day"; }
| HOUR_P { $$ = "hour"; }
| MINUTE_P { $$ = "minute"; }
| SECOND_P { $$ = "second"; }
| SCONST { $$ = $1; }
| IDENT { $$ = $1; }
;
/* position_list uses b_expr not a_expr to avoid conflict with general IN */
......@@ -5555,32 +5541,6 @@ access_method: ColId { $$ = $1; };
attr_name: ColId { $$ = $1; };
class: ColId { $$ = $1; };
index_name: ColId { $$ = $1; };
/* Functions
* Include date/time keywords as SQL92 extension.
* Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
* Any tokens which show up as operators will screw up the parsing if
* allowed as identifiers, but are acceptable as ColLabels:
* BETWEEN, IN, IS, ISNULL, NOTNULL, OVERLAPS
* Thanks to Tom Lane for pointing this out. - thomas 2000-03-29
* We need OVERLAPS allowed as a function name to enable the implementation
* of argument type variations on the underlying implementation. These
* variations are done as SQL-language entries in the pg_proc catalog.
* Do not include SUBSTRING here since it has explicit productions
* in a_expr to support the goofy SQL9x argument syntax.
* - thomas 2000-11-28
*/
func_name: ColId { $$ = xlateSqlFunc($1); }
| BETWEEN { $$ = xlateSqlFunc("between"); }
| ILIKE { $$ = xlateSqlFunc("ilike"); }
| IN { $$ = xlateSqlFunc("in"); }
| IS { $$ = xlateSqlFunc("is"); }
| ISNULL { $$ = xlateSqlFunc("isnull"); }
| LIKE { $$ = xlateSqlFunc("like"); }
| NOTNULL { $$ = xlateSqlFunc("notnull"); }
| OVERLAPS { $$ = xlateSqlFunc("overlaps"); }
;
file_name: Sconst { $$ = $1; };
/* Constants
......@@ -5692,27 +5652,23 @@ Iconst: ICONST { $$ = $1; };
Sconst: SCONST { $$ = $1; };
UserId: ColId { $$ = $1; };
/* Column identifier
* Include date/time keywords as SQL92 extension.
* Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
* Add other keywords. Note that as the syntax expands,
* some of these keywords will have to be removed from this
* list due to shift/reduce conflicts in yacc. If so, move
* down to the ColLabel entity. - thomas 1997-11-06
/*
* Keyword classification lists. Generally, every keyword present in
* the Postgres grammar should be in one of these lists. (Presently,
* "AS" is the sole exception: it is our only completely-reserved word.)
*
* Put a new keyword into the earliest list (of TypeFuncId, ColId, ColLabel)
* that it can go into without creating shift or reduce conflicts. The
* earlier lists define "less reserved" categories of keywords. Notice that
* each list includes by reference the ones before it.
*/
ColId: IDENT { $$ = $1; }
| datetime { $$ = $1; }
| TokenId { $$ = $1; }
| NATIONAL { $$ = "national"; }
| NONE { $$ = "none"; }
| PATH_P { $$ = "path"; }
;
/* Parser tokens to be used as identifiers.
* Tokens involving data types should appear in ColId only,
* since they will conflict with real TypeName productions.
/* Type/func identifier --- names that can be type and function names
* (as well as ColIds --- ie, these are completely unreserved keywords).
*/
TokenId: ABSOLUTE { $$ = "absolute"; }
TypeFuncId: IDENT { $$ = $1; }
| ABORT_TRANS { $$ = "abort"; }
| ABSOLUTE { $$ = "absolute"; }
| ACCESS { $$ = "access"; }
| ACTION { $$ = "action"; }
| ADD { $$ = "add"; }
......@@ -5731,16 +5687,19 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| CHARACTERISTICS { $$ = "characteristics"; }
| CHECKPOINT { $$ = "checkpoint"; }
| CLOSE { $$ = "close"; }
| CLUSTER { $$ = "cluster"; }
| COMMENT { $$ = "comment"; }
| COMMIT { $$ = "commit"; }
| COMMITTED { $$ = "committed"; }
| CONSTRAINTS { $$ = "constraints"; }
| COPY { $$ = "copy"; }
| CREATE { $$ = "create"; }
| CREATEDB { $$ = "createdb"; }
| CREATEUSER { $$ = "createuser"; }
| CURSOR { $$ = "cursor"; }
| CYCLE { $$ = "cycle"; }
| DATABASE { $$ = "database"; }
| DAY_P { $$ = "day"; }
| DECLARE { $$ = "declare"; }
| DEFERRED { $$ = "deferred"; }
| DELETE { $$ = "delete"; }
......@@ -5753,16 +5712,20 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| ESCAPE { $$ = "escape"; }
| EXCLUSIVE { $$ = "exclusive"; }
| EXECUTE { $$ = "execute"; }
| EXPLAIN { $$ = "explain"; }
| FETCH { $$ = "fetch"; }
| FORCE { $$ = "force"; }
| FORWARD { $$ = "forward"; }
| FUNCTION { $$ = "function"; }
| GLOBAL { $$ = "global"; }
| GRANT { $$ = "grant"; }
| HANDLER { $$ = "handler"; }
| HOUR_P { $$ = "hour"; }
| IMMEDIATE { $$ = "immediate"; }
| INCREMENT { $$ = "increment"; }
| INDEX { $$ = "index"; }
| INHERITS { $$ = "inherits"; }
| INOUT { $$ = "inout"; }
| INSENSITIVE { $$ = "insensitive"; }
| INSERT { $$ = "insert"; }
| INSTEAD { $$ = "instead"; }
......@@ -5771,12 +5734,20 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| LANGUAGE { $$ = "language"; }
| LANCOMPILER { $$ = "lancompiler"; }
| LEVEL { $$ = "level"; }
| LISTEN { $$ = "listen"; }
| LOAD { $$ = "load"; }
| LOCAL { $$ = "local"; }
| LOCATION { $$ = "location"; }
| LOCK_P { $$ = "lock"; }
| MATCH { $$ = "match"; }
| MAXVALUE { $$ = "maxvalue"; }
| MINUTE_P { $$ = "minute"; }
| MINVALUE { $$ = "minvalue"; }
| MODE { $$ = "mode"; }
| MONTH_P { $$ = "month"; }
| MOVE { $$ = "move"; }
| NAMES { $$ = "names"; }
| NATIONAL { $$ = "national"; }
| NEXT { $$ = "next"; }
| NO { $$ = "no"; }
| NOCREATEDB { $$ = "nocreatedb"; }
......@@ -5787,10 +5758,13 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| OIDS { $$ = "oids"; }
| OPERATOR { $$ = "operator"; }
| OPTION { $$ = "option"; }
| OUT { $$ = "out"; }
| OWNER { $$ = "owner"; }
| PARTIAL { $$ = "partial"; }
| PASSWORD { $$ = "password"; }
| PATH_P { $$ = "path"; }
| PENDANT { $$ = "pendant"; }
| PRECISION { $$ = "precision"; }
| PRIOR { $$ = "prior"; }
| PRIVILEGES { $$ = "privileges"; }
| PROCEDURAL { $$ = "procedural"; }
......@@ -5800,6 +5774,7 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| RELATIVE { $$ = "relative"; }
| RENAME { $$ = "rename"; }
| REPLACE { $$ = "replace"; }
| RESET { $$ = "reset"; }
| RESTRICT { $$ = "restrict"; }
| RETURNS { $$ = "returns"; }
| REVOKE { $$ = "revoke"; }
......@@ -5808,11 +5783,13 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| RULE { $$ = "rule"; }
| SCHEMA { $$ = "schema"; }
| SCROLL { $$ = "scroll"; }
| SECOND_P { $$ = "second"; }
| SESSION { $$ = "session"; }
| SEQUENCE { $$ = "sequence"; }
| SERIALIZABLE { $$ = "serializable"; }
| SET { $$ = "set"; }
| SHARE { $$ = "share"; }
| SHOW { $$ = "show"; }
| START { $$ = "start"; }
| STATEMENT { $$ = "statement"; }
| STATISTICS { $$ = "statistics"; }
......@@ -5823,14 +5800,17 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| TEMPLATE { $$ = "template"; }
| TEMPORARY { $$ = "temporary"; }
| TOAST { $$ = "toast"; }
| TRANSACTION { $$ = "transaction"; }
| TRIGGER { $$ = "trigger"; }
| TRUNCATE { $$ = "truncate"; }
| TRUSTED { $$ = "trusted"; }
| TYPE_P { $$ = "type"; }
| UNENCRYPTED { $$ = "unencrypted"; }
| UNKNOWN { $$ = "unknown"; }
| UNLISTEN { $$ = "unlisten"; }
| UNTIL { $$ = "until"; }
| UPDATE { $$ = "update"; }
| VACUUM { $$ = "vacuum"; }
| VALID { $$ = "valid"; }
| VALUES { $$ = "values"; }
| VARYING { $$ = "varying"; }
......@@ -5839,21 +5819,45 @@ TokenId: ABSOLUTE { $$ = "absolute"; }
| WITH { $$ = "with"; }
| WITHOUT { $$ = "without"; }
| WORK { $$ = "work"; }
| YEAR_P { $$ = "year"; }
| ZONE { $$ = "zone"; }
;
/* Column label
* Allowed labels in "AS" clauses.
* Include TRUE/FALSE SQL3 reserved words for Postgres backward
* compatibility. Cannot allow this for column names since the
* syntax would not distinguish between the constant value and
* a column name. - thomas 1997-10-24
* Add other keywords to this list. Note that they appear here
* rather than in ColId if there was a shift/reduce conflict
* when used as a full identifier. - thomas 1997-11-06
/* Column identifier --- names that can be column, table, etc names.
*
* This contains the TypeFuncId list plus those keywords that conflict
* only with typename productions, not with other uses. Note that
* most of these keywords will in fact be recognized as type names too;
* they just have to have special productions for the purpose.
*
* Most of these cannot be in TypeFuncId (ie, are not also usable as function
* names) because they can be followed by '(' in typename productions, which
* looks too much like a function call for a LALR(1) parser.
*/
ColId: TypeFuncId { $$ = $1; }
| BIT { $$ = "bit"; }
| CHAR { $$ = "char"; }
| CHARACTER { $$ = "character"; }
| DEC { $$ = "dec"; }
| DECIMAL { $$ = "decimal"; }
| FLOAT { $$ = "float"; }
| INTERVAL { $$ = "interval"; }
| NCHAR { $$ = "nchar"; }
| NONE { $$ = "none"; }
| NUMERIC { $$ = "numeric"; }
| SETOF { $$ = "setof"; }
| TIME { $$ = "time"; }
| TIMESTAMP { $$ = "timestamp"; }
| VARCHAR { $$ = "varchar"; }
;
/* Column label --- allowed labels in "AS" clauses.
*
* Keywords appear here if they could not be distinguished from variable,
* type, or function names in some contexts.
* When adding a ColLabel, consider whether it can be added to func_name.
*/
ColLabel: ColId { $$ = $1; }
| ABORT_TRANS { $$ = "abort"; }
| ALL { $$ = "all"; }
| ANALYSE { $$ = "analyse"; } /* British */
| ANALYZE { $$ = "analyze"; }
......@@ -5862,26 +5866,19 @@ ColLabel: ColId { $$ = $1; }
| ASC { $$ = "asc"; }
| BETWEEN { $$ = "between"; }
| BINARY { $$ = "binary"; }
| BIT { $$ = "bit"; }
| BOTH { $$ = "both"; }
| CASE { $$ = "case"; }
| CAST { $$ = "cast"; }
| CHAR { $$ = "char"; }
| CHARACTER { $$ = "character"; }
| CHECK { $$ = "check"; }
| CLUSTER { $$ = "cluster"; }
| COALESCE { $$ = "coalesce"; }
| COLLATE { $$ = "collate"; }
| COLUMN { $$ = "column"; }
| CONSTRAINT { $$ = "constraint"; }
| COPY { $$ = "copy"; }
| CROSS { $$ = "cross"; }
| CURRENT_DATE { $$ = "current_date"; }
| CURRENT_TIME { $$ = "current_time"; }
| CURRENT_TIMESTAMP { $$ = "current_timestamp"; }
| CURRENT_USER { $$ = "current_user"; }
| DEC { $$ = "dec"; }
| DECIMAL { $$ = "decimal"; }
| DEFAULT { $$ = "default"; }
| DEFERRABLE { $$ = "deferrable"; }
| DESC { $$ = "desc"; }
......@@ -5891,25 +5888,20 @@ ColLabel: ColId { $$ = $1; }
| END_TRANS { $$ = "end"; }
| EXCEPT { $$ = "except"; }
| EXISTS { $$ = "exists"; }
| EXPLAIN { $$ = "explain"; }
| EXTRACT { $$ = "extract"; }
| FALSE_P { $$ = "false"; }
| FLOAT { $$ = "float"; }
| FOR { $$ = "for"; }
| FOREIGN { $$ = "foreign"; }
| FREEZE { $$ = "freeze"; }
| FROM { $$ = "from"; }
| FULL { $$ = "full"; }
| GLOBAL { $$ = "global"; }
| GROUP { $$ = "group"; }
| HAVING { $$ = "having"; }
| ILIKE { $$ = "ilike"; }
| IN { $$ = "in"; }
| INITIALLY { $$ = "initially"; }
| INNER_P { $$ = "inner"; }
| INOUT { $$ = "inout"; }
| INTERSECT { $$ = "intersect"; }
| INTERVAL { $$ = "interval"; }
| INTO { $$ = "into"; }
| IS { $$ = "is"; }
| ISNULL { $$ = "isnull"; }
......@@ -5918,19 +5910,12 @@ ColLabel: ColId { $$ = $1; }
| LEFT { $$ = "left"; }
| LIKE { $$ = "like"; }
| LIMIT { $$ = "limit"; }
| LISTEN { $$ = "listen"; }
| LOAD { $$ = "load"; }
| LOCAL { $$ = "local"; }
| LOCK_P { $$ = "lock"; }
| MOVE { $$ = "move"; }
| NATURAL { $$ = "natural"; }
| NCHAR { $$ = "nchar"; }
| NEW { $$ = "new"; }
| NOT { $$ = "not"; }
| NOTNULL { $$ = "notnull"; }
| NULLIF { $$ = "nullif"; }
| NULL_P { $$ = "null"; }
| NUMERIC { $$ = "numeric"; }
| OFF { $$ = "off"; }
| OFFSET { $$ = "offset"; }
| OLD { $$ = "old"; }
......@@ -5938,43 +5923,66 @@ ColLabel: ColId { $$ = $1; }
| ONLY { $$ = "only"; }
| OR { $$ = "or"; }
| ORDER { $$ = "order"; }
| OUT { $$ = "out"; }
| OUTER_P { $$ = "outer"; }
| OVERLAPS { $$ = "overlaps"; }
| POSITION { $$ = "position"; }
| PRECISION { $$ = "precision"; }
| PRIMARY { $$ = "primary"; }
| PUBLIC { $$ = "public"; }
| REFERENCES { $$ = "references"; }
| RESET { $$ = "reset"; }
| RIGHT { $$ = "right"; }
| SELECT { $$ = "select"; }
| SESSION_USER { $$ = "session_user"; }
| SETOF { $$ = "setof"; }
| SHOW { $$ = "show"; }
| SOME { $$ = "some"; }
| SUBSTRING { $$ = "substring"; }
| TABLE { $$ = "table"; }
| THEN { $$ = "then"; }
| TIME { $$ = "time"; }
| TIMESTAMP { $$ = "timestamp"; }
| TO { $$ = "to"; }
| TRAILING { $$ = "trailing"; }
| TRANSACTION { $$ = "transaction"; }
| TRIM { $$ = "trim"; }
| TRUE_P { $$ = "true"; }
| UNION { $$ = "union"; }
| UNIQUE { $$ = "unique"; }
| UNKNOWN { $$ = "unknown"; }
| USER { $$ = "user"; }
| USING { $$ = "using"; }
| VACUUM { $$ = "vacuum"; }
| VARCHAR { $$ = "varchar"; }
| VERBOSE { $$ = "verbose"; }
| WHEN { $$ = "when"; }
| WHERE { $$ = "where"; }
;
/* Function identifier --- names that can be function names.
*
* This contains the TypeFuncId list plus some ColLabel keywords
* that are used as operators in expressions; in general such keywords
* can't be ColId because they would be ambiguous with variable names,
* but they are unambiguous as function identifiers.
*
* Do not include POSITION, SUBSTRING, etc here since they have explicit
* productions in a_expr to support the goofy SQL9x argument syntax.
* - thomas 2000-11-28
*/
func_name: TypeFuncId { $$ = xlateSqlFunc($1); }
| BETWEEN { $$ = xlateSqlFunc("between"); }
| BINARY { $$ = xlateSqlFunc("binary"); }
| CROSS { $$ = xlateSqlFunc("cross"); }
| FREEZE { $$ = xlateSqlFunc("freeze"); }
| FULL { $$ = xlateSqlFunc("full"); }
| ILIKE { $$ = xlateSqlFunc("ilike"); }
| IN { $$ = xlateSqlFunc("in"); }
| INNER_P { $$ = xlateSqlFunc("inner"); }
| IS { $$ = xlateSqlFunc("is"); }
| ISNULL { $$ = xlateSqlFunc("isnull"); }
| JOIN { $$ = xlateSqlFunc("join"); }
| LEFT { $$ = xlateSqlFunc("left"); }
| LIKE { $$ = xlateSqlFunc("like"); }
| NATURAL { $$ = xlateSqlFunc("natural"); }
| NOTNULL { $$ = xlateSqlFunc("notnull"); }
| OUTER_P { $$ = xlateSqlFunc("outer"); }
| OVERLAPS { $$ = xlateSqlFunc("overlaps"); }
| PUBLIC { $$ = xlateSqlFunc("public"); }
| RIGHT { $$ = xlateSqlFunc("right"); }
| VERBOSE { $$ = xlateSqlFunc("verbose"); }
;
SpecialRuleRelation: OLD
{
if (QueryIsRule)
......
src/interfaces/ecpg/preproc/preproc.y
View file @ ec438886
......@@ -279,7 +279,7 @@ make_name(void)
%type <str> key_match ColLabel SpecialRuleRelation ColId columnDef
%type <str> ColConstraint ColConstraintElem drop_type Bitconst
%type <str> OptTableElementList OptTableElement TableConstraint
%type <str> ConstraintElem key_actions ColQualList TokenId DropSchemaStmt
%type <str> ConstraintElem key_actions ColQualList TypeFuncId DropSchemaStmt
%type <str> target_list target_el update_target_list alias_clause
%type <str> update_target_el opt_id relation_name database_name
%type <str> access_method attr_name class index_name name func_name
......@@ -288,9 +288,9 @@ make_name(void)
%type <str> opt_indirection expr_list extract_list extract_arg
%type <str> position_list substr_list substr_from alter_column_default
%type <str> trim_list in_expr substr_for attr attrs drop_behavior
%type <str> Typename SimpleTypename Generic Numeric generic opt_float opt_numeric
%type <str> Typename SimpleTypename Generic Numeric opt_float opt_numeric
%type <str> opt_decimal Character character opt_varying opt_charset
%type <str> opt_collate datetime opt_timezone opt_interval table_ref
%type <str> opt_collate opt_timezone opt_interval table_ref
%type <str> row_expr row_descriptor row_list ConstDatetime opt_chain
%type <str> SelectStmt into_clause OptTemp ConstraintAttributeSpec
%type <str> opt_table opt_all sort_clause sortby_list ConstraintAttr
......@@ -324,7 +324,7 @@ make_name(void)
%type <str> TriggerActionTime CreateTrigStmt DropPLangStmt
%type <str> CreatePLangStmt TriggerFuncArgs TriggerFuncArg simple_select
%type <str> ViewStmt LoadStmt CreatedbStmt createdb_opt_item
%type <str> createdb_opt_list opt_encoding OptInherit Geometric
%type <str> createdb_opt_list opt_encoding OptInherit
%type <str> DropdbStmt ClusterStmt grantee RevokeStmt Bit bit
%type <str> GrantStmt privileges operation_commalist operation PosAllConst
%type <str> opt_with_grant opt_cursor ConstraintsSetStmt AllConst
......@@ -357,12 +357,12 @@ make_name(void)
%type <str> struct_type s_struct declaration declarations variable_declarations
%type <str> s_union union_type ECPGSetAutocommit on_off
%type <str> ECPGAllocateDescr ECPGDeallocateDescr symbol opt_symbol
%type <str> ECPGGetDescriptorHeader ECPGColLabel ECPGTypeName
%type <str> ECPGLabelTypeName ECPGColId variablelist cvariable
%type <str> ECPGGetDescriptorHeader ECPGTypeFuncId ECPGColId ECPGColLabel
%type <str> ECPGTypeName variablelist cvariable
%type <descriptor> ECPGGetDescriptor
%type <type_enum> simple_type signed_type unsigned_type varchar_type
%type <type_enum> simple_type signed_type unsigned_type
%type <dtype_enum> descriptor_item desc_header_item
......@@ -913,11 +913,11 @@ constraints_set_list: ALL
;
constraints_set_namelist: IDENT
constraints_set_namelist: ColId
{
$$ = $1;
}
| constraints_set_namelist ',' IDENT
| constraints_set_namelist ',' ColId
{
$$ = cat_str(3, $1, make_str(","), $3);
}
......@@ -1529,8 +1529,8 @@ def_elem: ColLabel '=' def_arg {
}
;
/* Note: any simple identifier will be returned as a type name! */
def_arg: func_return { $$ = $1; }
| TokenId { $$ = $1; }
| all_Op { $$ = $1; }
| AllConst { $$ = $1; }
;
......@@ -1964,7 +1964,7 @@ func_type: Typename
{
$$ = $1;
}
| IDENT '.' ColId '%' TYPE_P
| TypeFuncId '.' ColId '%' TYPE_P
{
$$ = cat_str(4, $1, make_str("."), $3, make_str("% type"));
}
......@@ -2974,20 +2974,11 @@ SimpleTypename: ConstTypename { $$ = $1; }
ConstTypename: Generic { $$ = $1; }
| ConstDatetime { $$ = $1; }
| Numeric { $$ = $1; }
| Geometric { $$ = $1; }
| Bit { $$ = $1; }
| Character { $$ = $1; }
;
Generic: generic
{
$$ = $1;
}
;
generic: ident { $$ = $1; }
| TYPE_P { $$ = make_str("type"); }
| ECPGKeywords { $$ = $1; }
Generic: TypeFuncId { $$ = $1; }
| ECPGTypeName { $$ = $1; }
;
......@@ -3018,8 +3009,6 @@ Numeric: FLOAT opt_float
}
;
Geometric: PATH_P { $$ = make_str("path"); };
opt_float: '(' PosIntConst ')'
{
$$ = cat_str(3, make_str("("), $2, make_str(")"));
......@@ -3115,11 +3104,7 @@ opt_collate: COLLATE ColId { $$ = cat2_str(make_str("collate"), $2); }
| /*EMPTY*/ { $$ = EMPTY; }
;
ConstDatetime: datetime
{
$$ = $1;
}
| TIMESTAMP '(' PosIntConst ')' opt_timezone
ConstDatetime: TIMESTAMP '(' PosIntConst ')' opt_timezone
{
$$ = cat_str(4, make_str("timestamp("), $3, make_str(")"), $5);
}
......@@ -3143,14 +3128,6 @@ ConstInterval: INTERVAL
}
;
datetime: YEAR_P { $$ = make_str("year"); }
| MONTH_P { $$ = make_str("month"); }
| DAY_P { $$ = make_str("day"); }
| HOUR_P { $$ = make_str("hour"); }
| MINUTE_P { $$ = make_str("minute"); }
| SECOND_P { $$ = make_str("second"); }
;
opt_timezone: WITH TIME ZONE { $$ = make_str("with time zone"); }
| WITHOUT TIME ZONE { $$ = make_str("without time zone"); }
| /*EMPTY*/ { $$ = EMPTY; }
......@@ -3544,9 +3521,14 @@ extract_list: extract_arg FROM a_expr
* - thomas 2001-04-12
*/
extract_arg: datetime { $$ = $1; }
extract_arg: IDENT { $$ = $1; }
| YEAR_P { $$ = make_str("year"); }
| MONTH_P { $$ = make_str("month"); }
| DAY_P { $$ = make_str("day"); }
| HOUR_P { $$ = make_str("hour"); }
| MINUTE_P { $$ = make_str("minute"); }
| SECOND_P { $$ = make_str("second"); }
| StringConst { $$ = $1; }
| IDENT { $$ = $1; }
;
/* position_list uses b_expr not a_expr to avoid conflict with general IN */
......@@ -3750,22 +3732,6 @@ attr_name: ColId { $$ = $1; };
class: ColId { $$ = $1; };
index_name: ColId { $$ = $1; };
/* Functions
* Include date/time keywords as SQL92 extension.
* Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
*/
func_name: ColId { $$ = $1; };
| BETWEEN { $$ = make_str("between");}
| ILIKE { $$ = make_str("ilike");}
| IN { $$ = make_str("in");}
| IS { $$ = make_str("is");}
| ISNULL { $$ = make_str("isnull");}
| LIKE { $$ = make_str("like");}
| NOTNULL { $$ = make_str("notnull");}
| OVERLAPS { $$ = make_str("overlaps");}
;
file_name: StringConst { $$ = $1; };
/* Constants
......@@ -3859,26 +3825,6 @@ PosAllConst: Sconst { $$ = $1; }
UserId: ColId { $$ = $1;};
/* Column identifier
*/
ColId: ECPGColId { $$ = $1; }
/* | ECPGTypeName { $$ = $1; }*/
;
/* Column label
* Allowed labels in "AS" clauses.
* Include TRUE/FALSE SQL3 reserved words for Postgres backward
* compatibility. Cannot allow this for column names since the
* syntax would not distinguish between the constant value and
* a column name. - thomas 1997-10-24
* Add other keywords to this list. Note that they appear here
* rather than in ColId if there was a shift/reduce conflict
* when used as a full identifier. - thomas 1997-11-06
*/
ColLabel: ECPGLabelTypeName { $$ = $1; }
| ECPGColLabel { $$ = $1; }
;
SpecialRuleRelation: OLD
{
if (!QueryIsRule)
......@@ -4220,13 +4166,6 @@ type: simple_type
$$.type_dimension = -1;
$$.type_index = -1;
}
| varchar_type
{
$$.type_enum = ECPGt_varchar;
$$.type_str = make_str("varchar");;
$$.type_dimension = -1;
$$.type_index = -1;
}
| struct_type
{
$$.type_enum = ECPGt_struct;
......@@ -4249,6 +4188,33 @@ type: simple_type
$$.type_index = -1;
}
| ECPGColLabel
{
/*
* Check for type names that the SQL grammar treats as
* unreserved keywords
*/
if (strcmp($1, "varchar") == 0)
{
$$.type_enum = ECPGt_varchar;
$$.type_str = make_str("varchar");
$$.type_dimension = -1;
$$.type_index = -1;
}
else if (strcmp($1, "float") == 0)
{
$$.type_enum = ECPGt_float;
$$.type_str = make_str("float");
$$.type_dimension = -1;
$$.type_index = -1;
}
else if (strcmp($1, "double") == 0)
{
$$.type_enum = ECPGt_double;
$$.type_str = make_str("double");
$$.type_dimension = -1;
$$.type_index = -1;
}
else
{
/* this is for typedef'ed types */
struct typedefs *this = get_typedef($1);
......@@ -4259,6 +4225,7 @@ type: simple_type
$$.type_index = this->type->type_index;
struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
}
}
;
enum_type: SQL_ENUM opt_symbol enum_definition
......@@ -4359,9 +4326,7 @@ signed_type: SQL_SHORT { $$ = ECPGt_short; }
$$ = ECPGt_long;
#endif
}
| SQL_BOOL { $$ = ECPGt_bool; };
| FLOAT { $$ = ECPGt_float; }
| DOUBLE { $$ = ECPGt_double; }
| SQL_BOOL { $$ = ECPGt_bool; }
| CHAR { $$ = ECPGt_char; }
;
......@@ -4369,8 +4334,6 @@ opt_signed: SQL_SIGNED
| /* EMPTY */
;
varchar_type: VARCHAR { $$ = ECPGt_varchar; };
variable_list: variable
{
$$ = $1;
......@@ -4686,7 +4649,7 @@ ECPGSetConnection: SET SQL_CONNECTION to_equal connection_object
/*
* define a new type for embedded SQL
*/
ECPGTypedef: TYPE_P ECPGColLabel IS type opt_type_array_bounds opt_reference
ECPGTypedef: TYPE_P ColLabel IS type opt_type_array_bounds opt_reference
{
/* add entry to list */
struct typedefs *ptr, *this;
......@@ -4779,7 +4742,7 @@ opt_reference: SQL_REFERENCE { $$ = make_str("reference"); }
/*
* define the type of one variable for embedded SQL
*/
ECPGVar: SQL_VAR ECPGColLabel IS type opt_type_array_bounds opt_reference
ECPGVar: SQL_VAR ColLabel IS type opt_type_array_bounds opt_reference
{
struct variable *p = find_variable($2);
int dimension = $5.index1;
......@@ -4956,16 +4919,6 @@ ECPGTypeName: SQL_BOOL { $$ = make_str("bool"); }
| SQL_STRUCT { $$ = make_str("struct"); }
| SQL_SIGNED { $$ = make_str("signed"); }
| SQL_UNSIGNED { $$ = make_str("unsigned"); }
| DOUBLE { $$ = make_str("double"); }
;
/* not needed at the moment
* | UNION { $$ = make_str("union"); }
*/
ECPGLabelTypeName: CHAR { $$ = make_str("char"); }
| FLOAT { $$ = make_str("float"); }
| VARCHAR { $$ = make_str("varchar"); }
/* | ECPGTypeName { $$ = $1; }*/
;
opt_symbol: symbol { $$ = $1; }
......@@ -4974,11 +4927,27 @@ opt_symbol: symbol { $$ = $1; }
symbol: ColLabel { $$ = $1; };
/* Parser tokens to be used as identifiers.
* Tokens involving data types should appear in ColId only,
* since they will conflict with real TypeName productions.
/*
* Keyword classification lists. Generally, every keyword present in
* the Postgres grammar should be in one of these lists. (Presently,
* "AS" is the sole exception: it is our only completely-reserved word.)
*
* Put a new keyword into the earliest list (of TypeFuncId, ColId, ColLabel)
* that it can go into without creating shift or reduce conflicts. The
* earlier lists define "less reserved" categories of keywords. Notice that
* each list includes by reference the ones before it.
*/
/* Type/func identifier --- names that can be type and function names
* (as well as ColIds --- ie, these are completely unreserved keywords).
*/
TokenId: ABSOLUTE { $$ = make_str("absolute"); }
TypeFuncId: ECPGTypeFuncId { $$ = $1; }
| ECPGKeywords { $$ = $1; }
;
ECPGTypeFuncId: ident { $$ = $1; }
| ABORT_TRANS { $$ = make_str("abort"); }
| ABSOLUTE { $$ = make_str("absolute"); }
| ACCESS { $$ = make_str("access"); }
| ACTION { $$ = make_str("action"); }
| ADD { $$ = make_str("add"); }
......@@ -4990,24 +4959,31 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| BACKWARD { $$ = make_str("backward"); }
| BEFORE { $$ = make_str("before"); }
| BEGIN_TRANS { $$ = make_str("begin"); }
| BY { $$ = make_str("by"); }
| CACHE { $$ = make_str("cache"); }
| CASCADE { $$ = make_str("cascade"); }
| CHAIN { $$ = make_str("chain"); }
| CHARACTERISTICS { $$ = make_str("characteristics"); }
| CHECKPOINT { $$ = make_str("checkpoint"); }
| CLOSE { $$ = make_str("close"); }
| CLUSTER { $$ = make_str("cluster"); }
| COMMENT { $$ = make_str("comment"); }
| COMMIT { $$ = make_str("commit"); }
| COMMITTED { $$ = make_str("committed"); }
| CONSTRAINTS { $$ = make_str("constraints"); }
| COPY { $$ = make_str("copy"); }
| CREATE { $$ = make_str("create"); }
| CREATEDB { $$ = make_str("createdb"); }
| CREATEUSER { $$ = make_str("createuser"); }
| CURSOR { $$ = make_str("cursor"); }
| CYCLE { $$ = make_str("cycle"); }
| DATABASE { $$ = make_str("database"); }
| DAY_P { $$ = make_str("day"); }
| DECLARE { $$ = make_str("declare"); }
| DEFERRED { $$ = make_str("deferred"); }
| DELETE { $$ = make_str("delete"); }
| DELIMITERS { $$ = make_str("delimiters"); }
| DOUBLE { $$ = make_str("double"); }
| DROP { $$ = make_str("drop"); }
| EACH { $$ = make_str("each"); }
| ENCODING { $$ = make_str("encoding"); }
......@@ -5015,16 +4991,20 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| ESCAPE { $$ = make_str("escape"); }
| EXCLUSIVE { $$ = make_str("exclusive"); }
| EXECUTE { $$ = make_str("execute"); }
| EXPLAIN { $$ = make_str("explain"); }
| FETCH { $$ = make_str("fetch"); }
| FORCE { $$ = make_str("force"); }
| FORWARD { $$ = make_str("forward"); }
| FUNCTION { $$ = make_str("function"); }
| GLOBAL { $$ = make_str("global"); }
| GRANT { $$ = make_str("grant"); }
| HANDLER { $$ = make_str("handler"); }
| HOUR_P { $$ = make_str("hour"); }
| IMMEDIATE { $$ = make_str("immediate"); }
| INCREMENT { $$ = make_str("increment"); }
| INDEX { $$ = make_str("index"); }
| INHERITS { $$ = make_str("inherits"); }
| INOUT { $$ = make_str("inout"); }
| INSENSITIVE { $$ = make_str("insensitive"); }
| INSERT { $$ = make_str("insert"); }
| INSTEAD { $$ = make_str("instead"); }
......@@ -5033,12 +5013,20 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| LANGUAGE { $$ = make_str("language"); }
| LANCOMPILER { $$ = make_str("lancompiler"); }
| LEVEL { $$ = make_str("level"); }
| LISTEN { $$ = make_str("listen"); }
| LOAD { $$ = make_str("load"); }
| LOCAL { $$ = make_str("local"); }
| LOCATION { $$ = make_str("location"); }
| LOCK_P { $$ = make_str("lock"); }
| MATCH { $$ = make_str("match"); }
| MAXVALUE { $$ = make_str("maxvalue"); }
| MINUTE_P { $$ = make_str("minute"); }
| MINVALUE { $$ = make_str("minvalue"); }
| MODE { $$ = make_str("mode"); }
| MONTH_P { $$ = make_str("month"); }
| MOVE { $$ = make_str("move"); }
| NAMES { $$ = make_str("names"); }
| NATIONAL { $$ = make_str("national"); }
| NEXT { $$ = make_str("next"); }
| NO { $$ = make_str("no"); }
| NOCREATEDB { $$ = make_str("nocreatedb"); }
......@@ -5049,10 +5037,13 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| OIDS { $$ = make_str("oids"); }
| OPERATOR { $$ = make_str("operator"); }
| OPTION { $$ = make_str("option"); }
| OUT { $$ = make_str("out"); }
| OWNER { $$ = make_str("owner"); }
| PARTIAL { $$ = make_str("partial"); }
| PASSWORD { $$ = make_str("password"); }
| PATH_P { $$ = make_str("path"); }
| PENDANT { $$ = make_str("pendant"); }
| PRECISION { $$ = make_str("precision"); }
| PRIOR { $$ = make_str("prior"); }
| PRIVILEGES { $$ = make_str("privileges"); }
| PROCEDURAL { $$ = make_str("procedural"); }
......@@ -5062,6 +5053,7 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| RELATIVE { $$ = make_str("relative"); }
| RENAME { $$ = make_str("rename"); }
| REPLACE { $$ = make_str("replace"); }
| RESET { $$ = make_str("reset"); }
| RESTRICT { $$ = make_str("restrict"); }
| RETURNS { $$ = make_str("returns"); }
| REVOKE { $$ = make_str("revoke"); }
......@@ -5070,11 +5062,13 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| RULE { $$ = make_str("rule"); }
| SCHEMA { $$ = make_str("schema"); }
| SCROLL { $$ = make_str("scroll"); }
| SECOND_P { $$ = make_str("second"); }
| SESSION { $$ = make_str("session"); }
| SEQUENCE { $$ = make_str("sequence"); }
| SERIALIZABLE { $$ = make_str("serializable"); }
| SET { $$ = make_str("set"); }
| SHARE { $$ = make_str("share"); }
| SHOW { $$ = make_str("show"); }
| START { $$ = make_str("start"); }
| STATEMENT { $$ = make_str("statement"); }
| STATISTICS { $$ = make_str("statistics"); }
......@@ -5085,13 +5079,17 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| TEMPLATE { $$ = make_str("template"); }
| TEMPORARY { $$ = make_str("temporary"); }
| TOAST { $$ = make_str("toast"); }
| TRANSACTION { $$ = make_str("transaction"); }
| TRIGGER { $$ = make_str("trigger"); }
| TRUNCATE { $$ = make_str("truncate"); }
| TRUSTED { $$ = make_str("trusted"); }
| TYPE_P { $$ = make_str("type"); }
| UNENCRYPTED { $$ = make_str("unencrypted"); }
| UNKNOWN { $$ = make_str("unknown"); }
| UNLISTEN { $$ = make_str("unlisten"); }
| UNTIL { $$ = make_str("until"); }
| UPDATE { $$ = make_str("update"); }
| VACUUM { $$ = make_str("vacuum"); }
| VALID { $$ = make_str("valid"); }
| VALUES { $$ = make_str("values"); }
| VARYING { $$ = make_str("varying"); }
......@@ -5100,47 +5098,77 @@ TokenId: ABSOLUTE { $$ = make_str("absolute"); }
| WITH { $$ = make_str("with"); }
| WITHOUT { $$ = make_str("without"); }
| WORK { $$ = make_str("work"); }
| YEAR_P { $$ = make_str("year"); }
| ZONE { $$ = make_str("zone"); }
;
ECPGColId: ident { $$ = $1; }
| TYPE_P { $$ = make_str("type"); }
| datetime { $$ = $1; }
| TokenId { $$ = $1; }
| NATIONAL { $$ = make_str("national"); }
/* Column identifier --- names that can be column, table, etc names.
*
* This contains the TypeFuncId list plus those keywords that conflict
* only with typename productions, not with other uses. Note that
* most of these keywords will in fact be recognized as type names too;
* they just have to have special productions for the purpose.
*
* Most of these cannot be in TypeFuncId (ie, are not also usable as function
* names) because they can be followed by '(' in typename productions, which
* looks too much like a function call for a LALR(1) parser.
*/
ColId: ECPGColId { $$ = $1; }
| CHAR { $$ = make_str("char"); }
;
ECPGColId: TypeFuncId { $$ = $1; }
| BIT { $$ = make_str("bit"); }
/* CHAR must be excluded from ECPGColLabel because of conflict with UNSIGNED
| CHAR { $$ = make_str("char"); }
*/
| CHARACTER { $$ = make_str("character"); }
| DEC { $$ = make_str("dec"); }
| DECIMAL { $$ = make_str("decimal"); }
| FLOAT { $$ = make_str("float"); }
| INTERVAL { $$ = make_str("interval"); }
| NCHAR { $$ = make_str("nchar"); }
| NONE { $$ = make_str("none"); }
| PATH_P { $$ = make_str("path_p"); }
| ECPGKeywords { $$ = $1; }
| NUMERIC { $$ = make_str("numeric"); }
| SETOF { $$ = make_str("setof"); }
| TIME { $$ = make_str("time"); }
| TIMESTAMP { $$ = make_str("timestamp"); }
| VARCHAR { $$ = make_str("varchar"); }
;
/* Column label --- allowed labels in "AS" clauses.
*
* Keywords appear here if they could not be distinguished from variable,
* type, or function names in some contexts.
* When adding a ColLabel, consider whether it can be added to func_name.
*/
ColLabel: ECPGColLabel { $$ = $1; }
| CHAR { $$ = make_str("char"); }
| UNION { $$ = make_str("union"); }
;
ECPGColLabel: ECPGColId { $$ = $1; }
| ABORT_TRANS { $$ = make_str("abort"); }
| ALL { $$ = make_str("all"); }
| ANALYSE { $$ = make_str("analyse"); }
| ANALYSE { $$ = make_str("analyse"); } /* British */
| ANALYZE { $$ = make_str("analyze"); }
| AND { $$ = make_str("and"); }
| ANY { $$ = make_str("any"); }
| ASC { $$ = make_str("asc"); }
| BETWEEN { $$ = make_str("between"); }
| BINARY { $$ = make_str("binary"); }
| BIT { $$ = make_str("bit"); }
| BOTH { $$ = make_str("both"); }
| CASE { $$ = make_str("case"); }
| CAST { $$ = make_str("cast"); }
| CHARACTER { $$ = make_str("character"); }
| CHECK { $$ = make_str("check"); }
| CLUSTER { $$ = make_str("cluster"); }
| COALESCE { $$ = make_str("coalesce"); }
| COLLATE { $$ = make_str("collate"); }
| COLUMN { $$ = make_str("column"); }
| CONSTRAINT { $$ = make_str("constraint"); }
| COPY { $$ = make_str("copy"); }
| CROSS { $$ = make_str("cross"); }
| CURRENT_DATE { $$ = make_str("current_date"); }
| CURRENT_TIME { $$ = make_str("current_time"); }
| CURRENT_TIMESTAMP { $$ = make_str("current_timestamp"); }
| CURRENT_USER { $$ = make_str("current_user"); }
| DEC { $$ = make_str("dec"); }
| DECIMAL { $$ = make_str("decimal"); }
| DEFAULT { $$ = make_str("default"); }
| DEFERRABLE { $$ = make_str("deferrable"); }
| DESC { $$ = make_str("desc"); }
......@@ -5150,7 +5178,6 @@ ECPGColLabel: ECPGColId { $$ = $1; }
| END_TRANS { $$ = make_str("end"); }
| EXCEPT { $$ = make_str("except"); }
| EXISTS { $$ = make_str("exists"); }
| EXPLAIN { $$ = make_str("explain"); }
| EXTRACT { $$ = make_str("extract"); }
| FALSE_P { $$ = make_str("false"); }
| FOR { $$ = make_str("for"); }
......@@ -5158,16 +5185,13 @@ ECPGColLabel: ECPGColId { $$ = $1; }
| FREEZE { $$ = make_str("freeze"); }
| FROM { $$ = make_str("from"); }
| FULL { $$ = make_str("full"); }
| GLOBAL { $$ = make_str("global"); }
| GROUP { $$ = make_str("group"); }
| HAVING { $$ = make_str("having"); }
| ILIKE { $$ = make_str("ilike"); }
| IN { $$ = make_str("in"); }
| INITIALLY { $$ = make_str("initially"); }
| INNER_P { $$ = make_str("inner"); }
| INOUT { $$ = make_str("inout"); }
| INTERSECT { $$ = make_str("intersect"); }
| INTERVAL { $$ = make_str("interval"); }
| INTO { $$ = make_str("into"); }
| IS { $$ = make_str("is"); }
| ISNULL { $$ = make_str("isnull"); }
......@@ -5176,18 +5200,12 @@ ECPGColLabel: ECPGColId { $$ = $1; }
| LEFT { $$ = make_str("left"); }
| LIKE { $$ = make_str("like"); }
| LIMIT { $$ = make_str("limit"); }
| LISTEN { $$ = make_str("listen"); }
| LOAD { $$ = make_str("load"); }
| LOCK_P { $$ = make_str("lock"); }
| MOVE { $$ = make_str("move"); }
| NATURAL { $$ = make_str("natural"); }
| NCHAR { $$ = make_str("nchar"); }
| NEW { $$ = make_str("new"); }
| NOT { $$ = make_str("not"); }
| NOTNULL { $$ = make_str("notnull"); }
| NULLIF { $$ = make_str("nullif"); }
| NULL_P { $$ = make_str("null"); }
| NUMERIC { $$ = make_str("numeric"); }
| OFF { $$ = make_str("off"); }
| OFFSET { $$ = make_str("offset"); }
| OLD { $$ = make_str("old"); }
......@@ -5195,39 +5213,68 @@ ECPGColLabel: ECPGColId { $$ = $1; }
| ONLY { $$ = make_str("only"); }
| OR { $$ = make_str("or"); }
| ORDER { $$ = make_str("order"); }
| OUT { $$ = make_str("out"); }
| OUTER_P { $$ = make_str("outer"); }
| OVERLAPS { $$ = make_str("overlaps"); }
| POSITION { $$ = make_str("position"); }
| PRECISION { $$ = make_str("precision"); }
| PRIMARY { $$ = make_str("primary"); }
| PUBLIC { $$ = make_str("public"); }
| REFERENCES { $$ = make_str("references"); }
| RESET { $$ = make_str("reset"); }
| RIGHT { $$ = make_str("right"); }
| SELECT { $$ = make_str("select"); }
| SESSION_USER { $$ = make_str("session_user"); }
| SETOF { $$ = make_str("setof"); }
| SHOW { $$ = make_str("show"); }
| SOME { $$ = make_str("some"); }
| SUBSTRING { $$ = make_str("substring"); }
| TABLE { $$ = make_str("table"); }
| THEN { $$ = make_str("then"); }
| TIME { $$ = make_str("time"); }
| TIMESTAMP { $$ = make_str("timestamp"); }
| TO { $$ = make_str("to"); }
| TRANSACTION { $$ = make_str("transaction"); }
| TRAILING { $$ = make_str("trailing"); }
| TRIM { $$ = make_str("trim"); }
| TRUE_P { $$ = make_str("true"); }
/* UNION must be excluded from ECPGColLabel because of conflict with s_union
| UNION { $$ = make_str("union"); }
*/
| UNIQUE { $$ = make_str("unique"); }
| UNKNOWN { $$ = make_str("unknown"); }
| USER { $$ = make_str("user"); }
| USING { $$ = make_str("using"); }
| VACUUM { $$ = make_str("vacuum"); }
| VERBOSE { $$ = make_str("verbose"); }
| WHEN { $$ = make_str("when"); }
| WHERE { $$ = make_str("where"); }
;
/* Function identifier --- names that can be function names.
*
* This contains the TypeFuncId list plus some ColLabel keywords
* that are used as operators in expressions; in general such keywords
* can't be ColId because they would be ambiguous with variable names,
* but they are unambiguous as function identifiers.
*
* Do not include POSITION, SUBSTRING, etc here since they have explicit
* productions in a_expr to support the goofy SQL9x argument syntax.
* - thomas 2000-11-28
*/
func_name: TypeFuncId { $$ = $1; }
| BETWEEN { $$ = make_str("between"); }
| BINARY { $$ = make_str("binary"); }
| CROSS { $$ = make_str("cross"); }
| FREEZE { $$ = make_str("freeze"); }
| FULL { $$ = make_str("full"); }
| ILIKE { $$ = make_str("ilike"); }
| IN { $$ = make_str("in"); }
| INNER_P { $$ = make_str("inner"); }
| IS { $$ = make_str("is"); }
| ISNULL { $$ = make_str("isnull"); }
| JOIN { $$ = make_str("join"); }
| LEFT { $$ = make_str("left"); }
| LIKE { $$ = make_str("like"); }
| NATURAL { $$ = make_str("natural"); }
| NOTNULL { $$ = make_str("notnull"); }
| OUTER_P { $$ = make_str("outer"); }
| OVERLAPS { $$ = make_str("overlaps"); }
| PUBLIC { $$ = make_str("public"); }
| RIGHT { $$ = make_str("right"); }
| VERBOSE { $$ = make_str("verbose"); }
;
into_list : coutputvariable | into_list ',' coutputvariable;
ecpgstart: SQL_START { reset_variables(); };
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment