/* Private struct for the result of opt_select_limit production */
typedef struct SelectLimit
{
- Node *limitOffset;
- Node *limitCount;
+ Node *limitOffset;
+ Node *limitCount;
LimitOption limitOption;
} SelectLimit;
/* Private struct for the result of group_clause production */
typedef struct GroupClause
{
- bool distinct;
- List *list;
+ bool distinct;
+ List *list;
} GroupClause;
/* Private structs for the result of key_actions and key_action productions */
typedef struct KeyAction
{
- char action;
- List *cols;
+ char action;
+ List *cols;
} KeyAction;
typedef struct KeyActions
%union
{
- core_YYSTYPE core_yystype;
+ core_YYSTYPE core_yystype;
/* these fields must match core_YYSTYPE: */
- int ival;
- char *str;
- const char *keyword;
-
- char chr;
- bool boolean;
- JoinType jtype;
- DropBehavior dbehavior;
- OnCommitAction oncommit;
- List *list;
- Node *node;
- ObjectType objtype;
- TypeName *typnam;
- FunctionParameter *fun_param;
+ int ival;
+ char *str;
+ const char *keyword;
+
+ char chr;
+ bool boolean;
+ JoinType jtype;
+ DropBehavior dbehavior;
+ OnCommitAction oncommit;
+ List *list;
+ Node *node;
+ ObjectType objtype;
+ TypeName *typnam;
+ FunctionParameter *fun_param;
FunctionParameterMode fun_param_mode;
- ObjectWithArgs *objwithargs;
- DefElem *defelt;
- SortBy *sortby;
- WindowDef *windef;
- JoinExpr *jexpr;
- IndexElem *ielem;
- StatsElem *selem;
- Alias *alias;
- RangeVar *range;
- IntoClause *into;
- WithClause *with;
- InferClause *infer;
- OnConflictClause *onconflict;
- A_Indices *aind;
- ResTarget *target;
- struct PrivTarget *privtarget;
- AccessPriv *accesspriv;
- struct ImportQual *importqual;
- InsertStmt *istmt;
- VariableSetStmt *vsetstmt;
- PartitionElem *partelem;
- PartitionSpec *partspec;
- PartitionBoundSpec *partboundspec;
- RoleSpec *rolespec;
- PublicationObjSpec *publicationobjectspec;
- struct SelectLimit *selectlimit;
- SetQuantifier setquantifier;
- struct GroupClause *groupclause;
- MergeWhenClause *mergewhen;
- struct KeyActions *keyactions;
- struct KeyAction *keyaction;
- JsonBehavior *jsbehavior;
+ ObjectWithArgs *objwithargs;
+ DefElem *defelt;
+ SortBy *sortby;
+ WindowDef *windef;
+ JoinExpr *jexpr;
+ IndexElem *ielem;
+ StatsElem *selem;
+ Alias *alias;
+ RangeVar *range;
+ IntoClause *into;
+ WithClause *with;
+ InferClause *infer;
+ OnConflictClause *onconflict;
+ A_Indices *aind;
+ ResTarget *target;
+ struct PrivTarget *privtarget;
+ AccessPriv *accesspriv;
+ struct ImportQual *importqual;
+ InsertStmt *istmt;
+ VariableSetStmt *vsetstmt;
+ PartitionElem *partelem;
+ PartitionSpec *partspec;
+ PartitionBoundSpec *partboundspec;
+ RoleSpec *rolespec;
+ PublicationObjSpec *publicationobjectspec;
+ struct SelectLimit *selectlimit;
+ SetQuantifier setquantifier;
+ struct GroupClause *groupclause;
+ MergeWhenClause *mergewhen;
+ struct KeyActions *keyactions;
+ struct KeyAction *keyaction;
+ JsonBehavior *jsbehavior;
struct
{
- JsonBehavior *on_empty;
- JsonBehavior *on_error;
- } on_behavior;
- JsonQuotes js_quotes;
+ JsonBehavior *on_empty;
+ JsonBehavior *on_error;
+ } on_behavior;
+ JsonQuotes js_quotes;
}
%type stmt toplevel_stmt schema_stmt routine_body_stmt
| MODE_PLPGSQL_ASSIGN1 PLAssignStmt
{
PLAssignStmt *n = (PLAssignStmt *) $2;
+
n->nnames = 1;
pg_yyget_extra(yyscanner)->parsetree =
list_make1(makeRawStmt((Node *) n, 0));
| MODE_PLPGSQL_ASSIGN2 PLAssignStmt
{
PLAssignStmt *n = (PLAssignStmt *) $2;
+
n->nnames = 2;
pg_yyget_extra(yyscanner)->parsetree =
list_make1(makeRawStmt((Node *) n, 0));
| MODE_PLPGSQL_ASSIGN3 PLAssignStmt
{
PLAssignStmt *n = (PLAssignStmt *) $2;
+
n->nnames = 3;
pg_yyget_extra(yyscanner)->parsetree =
list_make1(makeRawStmt((Node *) n, 0));
CallStmt: CALL func_application
{
- CallStmt *n = makeNode(CallStmt);
+ CallStmt *n = makeNode(CallStmt);
+
n->funccall = castNode(FuncCall, $2);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE ROLE RoleId opt_with OptRoleList
{
CreateRoleStmt *n = makeNode(CreateRoleStmt);
+
n->stmt_type = ROLESTMT_ROLE;
n->role = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
PASSWORD Sconst
{
$$ = makeDefElem("password",
- (Node *)makeString($2), @1);
+ (Node *) makeString($2), @1);
}
| PASSWORD NULL_P
{
* ENCRYPTED PASSWORD.
*/
$$ = makeDefElem("password",
- (Node *)makeString($3), @1);
+ (Node *) makeString($3), @1);
}
| UNENCRYPTED PASSWORD Sconst
{
}
| INHERIT
{
- $$ = makeDefElem("inherit", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("inherit", (Node *) makeBoolean(true), @1);
}
| CONNECTION LIMIT SignedIconst
{
- $$ = makeDefElem("connectionlimit", (Node *)makeInteger($3), @1);
+ $$ = makeDefElem("connectionlimit", (Node *) makeInteger($3), @1);
}
| VALID UNTIL Sconst
{
- $$ = makeDefElem("validUntil", (Node *)makeString($3), @1);
+ $$ = makeDefElem("validUntil", (Node *) makeString($3), @1);
}
/* Supported but not documented for roles, for use by ALTER GROUP. */
| USER role_list
{
- $$ = makeDefElem("rolemembers", (Node *)$2, @1);
+ $$ = makeDefElem("rolemembers", (Node *) $2, @1);
}
| IDENT
{
* size of the main parser.
*/
if (strcmp($1, "superuser") == 0)
- $$ = makeDefElem("superuser", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("superuser", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "nosuperuser") == 0)
- $$ = makeDefElem("superuser", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("superuser", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "createrole") == 0)
- $$ = makeDefElem("createrole", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("createrole", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "nocreaterole") == 0)
- $$ = makeDefElem("createrole", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("createrole", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "replication") == 0)
- $$ = makeDefElem("isreplication", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("isreplication", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "noreplication") == 0)
- $$ = makeDefElem("isreplication", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("isreplication", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "createdb") == 0)
- $$ = makeDefElem("createdb", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("createdb", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "nocreatedb") == 0)
- $$ = makeDefElem("createdb", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("createdb", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "login") == 0)
- $$ = makeDefElem("canlogin", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("canlogin", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "nologin") == 0)
- $$ = makeDefElem("canlogin", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("canlogin", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "bypassrls") == 0)
- $$ = makeDefElem("bypassrls", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("bypassrls", (Node *) makeBoolean(true), @1);
else if (strcmp($1, "nobypassrls") == 0)
- $$ = makeDefElem("bypassrls", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("bypassrls", (Node *) makeBoolean(false), @1);
else if (strcmp($1, "noinherit") == 0)
{
/*
* Note that INHERIT is a keyword, so it's handled by main parser, but
* NOINHERIT is handled here.
*/
- $$ = makeDefElem("inherit", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("inherit", (Node *) makeBoolean(false), @1);
}
else
ereport(ERROR,
/* The following are not supported by ALTER ROLE/USER/GROUP */
| SYSID Iconst
{
- $$ = makeDefElem("sysid", (Node *)makeInteger($2), @1);
+ $$ = makeDefElem("sysid", (Node *) makeInteger($2), @1);
}
| ADMIN role_list
{
- $$ = makeDefElem("adminmembers", (Node *)$2, @1);
+ $$ = makeDefElem("adminmembers", (Node *) $2, @1);
}
| ROLE role_list
{
- $$ = makeDefElem("rolemembers", (Node *)$2, @1);
+ $$ = makeDefElem("rolemembers", (Node *) $2, @1);
}
| IN_P ROLE role_list
{
- $$ = makeDefElem("addroleto", (Node *)$3, @1);
+ $$ = makeDefElem("addroleto", (Node *) $3, @1);
}
| IN_P GROUP_P role_list
{
- $$ = makeDefElem("addroleto", (Node *)$3, @1);
+ $$ = makeDefElem("addroleto", (Node *) $3, @1);
}
;
CREATE USER RoleId opt_with OptRoleList
{
CreateRoleStmt *n = makeNode(CreateRoleStmt);
+
n->stmt_type = ROLESTMT_USER;
n->role = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER ROLE RoleSpec opt_with AlterOptRoleList
{
AlterRoleStmt *n = makeNode(AlterRoleStmt);
+
n->role = $3;
n->action = +1; /* add, if there are members */
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER USER RoleSpec opt_with AlterOptRoleList
{
AlterRoleStmt *n = makeNode(AlterRoleStmt);
+
n->role = $3;
n->action = +1; /* add, if there are members */
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER ROLE RoleSpec opt_in_database SetResetClause
{
AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
+
n->role = $3;
n->database = $4;
n->setstmt = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROLE ALL opt_in_database SetResetClause
{
AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
+
n->role = NULL;
n->database = $4;
n->setstmt = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER USER RoleSpec opt_in_database SetResetClause
{
AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
+
n->role = $3;
n->database = $4;
n->setstmt = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER USER ALL opt_in_database SetResetClause
{
AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
+
n->role = NULL;
n->database = $4;
n->setstmt = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DROP ROLE role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->missing_ok = false;
n->roles = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP ROLE IF_P EXISTS role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->missing_ok = true;
n->roles = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP USER role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->missing_ok = false;
n->roles = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP USER IF_P EXISTS role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->roles = $5;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP GROUP_P role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->missing_ok = false;
n->roles = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP GROUP_P IF_P EXISTS role_list
{
DropRoleStmt *n = makeNode(DropRoleStmt);
+
n->missing_ok = true;
n->roles = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE GROUP_P RoleId opt_with OptRoleList
{
CreateRoleStmt *n = makeNode(CreateRoleStmt);
+
n->stmt_type = ROLESTMT_GROUP;
n->role = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER GROUP_P RoleSpec add_drop USER role_list
{
AlterRoleStmt *n = makeNode(AlterRoleStmt);
+
n->role = $3;
n->action = $4;
n->options = list_make1(makeDefElem("rolemembers",
- (Node *)$6, @6));
- $$ = (Node *)n;
+ (Node *) $6, @6));
+ $$ = (Node *) n;
}
;
CREATE SCHEMA OptSchemaName AUTHORIZATION RoleSpec OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
+
/* One can omit the schema name or the authorization id. */
n->schemaname = $3;
n->authrole = $5;
n->schemaElts = $6;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE SCHEMA ColId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
+
/* ...but not both */
n->schemaname = $3;
n->authrole = NULL;
n->schemaElts = $4;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE SCHEMA IF_P NOT EXISTS OptSchemaName AUTHORIZATION RoleSpec OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
+
/* schema name can be omitted here, too */
n->schemaname = $6;
n->authrole = $8;
parser_errposition(@9)));
n->schemaElts = $9;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE SCHEMA IF_P NOT EXISTS ColId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
+
/* ...but not here */
n->schemaname = $6;
n->authrole = NULL;
parser_errposition(@7)));
n->schemaElts = $7;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
SET set_rest
{
VariableSetStmt *n = $2;
+
n->is_local = false;
$$ = (Node *) n;
}
| SET LOCAL set_rest
{
VariableSetStmt *n = $3;
+
n->is_local = true;
$$ = (Node *) n;
}
| SET SESSION set_rest
{
VariableSetStmt *n = $3;
+
n->is_local = false;
$$ = (Node *) n;
}
TRANSACTION transaction_mode_list
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_MULTI;
n->name = "TRANSACTION";
n->args = $2;
| SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_MULTI;
n->name = "SESSION CHARACTERISTICS";
n->args = $5;
var_name TO var_list
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = $1;
n->args = $3;
| var_name '=' var_list
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = $1;
n->args = $3;
| var_name TO DEFAULT
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_DEFAULT;
n->name = $1;
$$ = n;
| var_name '=' DEFAULT
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_DEFAULT;
n->name = $1;
$$ = n;
| var_name FROM CURRENT_P
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_CURRENT;
n->name = $1;
$$ = n;
| TIME ZONE zone_value
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "timezone";
if ($3 != NULL)
| SCHEMA Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "search_path";
n->args = list_make1(makeStringConst($2, @2));
| NAMES opt_encoding
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "client_encoding";
if ($2 != NULL)
| ROLE NonReservedWord_or_Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "role";
n->args = list_make1(makeStringConst($2, @2));
| SESSION AUTHORIZATION NonReservedWord_or_Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "session_authorization";
n->args = list_make1(makeStringConst($3, @3));
| SESSION AUTHORIZATION DEFAULT
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_DEFAULT;
n->name = "session_authorization";
$$ = n;
| XML_P OPTION document_or_content
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_VALUE;
n->name = "xmloption";
n->args = list_make1(makeStringConst($3 == XMLOPTION_DOCUMENT ? "DOCUMENT" : "CONTENT", @3));
| TRANSACTION SNAPSHOT Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_SET_MULTI;
n->name = "TRANSACTION SNAPSHOT";
n->args = list_make1(makeStringConst($3, @3));
}
| ConstInterval Sconst opt_interval
{
- TypeName *t = $1;
+ TypeName *t = $1;
+
if ($3 != NIL)
{
- A_Const *n = (A_Const *) linitial($3);
+ A_Const *n = (A_Const *) linitial($3);
+
if ((n->val.ival.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
}
| ConstInterval '(' Iconst ')' Sconst
{
- TypeName *t = $1;
+ TypeName *t = $1;
+
t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
makeIntConst($3, @3));
$$ = makeStringConstCast($5, @5, t);
| TIME ZONE
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_RESET;
n->name = "timezone";
$$ = n;
| TRANSACTION ISOLATION LEVEL
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_RESET;
n->name = "transaction_isolation";
$$ = n;
| SESSION AUTHORIZATION
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_RESET;
n->name = "session_authorization";
$$ = n;
var_name
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_RESET;
n->name = $1;
$$ = n;
| ALL
{
VariableSetStmt *n = makeNode(VariableSetStmt);
+
n->kind = VAR_RESET_ALL;
$$ = n;
}
SHOW var_name
{
VariableShowStmt *n = makeNode(VariableShowStmt);
+
n->name = $2;
$$ = (Node *) n;
}
| SHOW TIME ZONE
{
VariableShowStmt *n = makeNode(VariableShowStmt);
+
n->name = "timezone";
$$ = (Node *) n;
}
| SHOW TRANSACTION ISOLATION LEVEL
{
VariableShowStmt *n = makeNode(VariableShowStmt);
+
n->name = "transaction_isolation";
$$ = (Node *) n;
}
| SHOW SESSION AUTHORIZATION
{
VariableShowStmt *n = makeNode(VariableShowStmt);
+
n->name = "session_authorization";
$$ = (Node *) n;
}
| SHOW ALL
{
VariableShowStmt *n = makeNode(VariableShowStmt);
+
n->name = "all";
$$ = (Node *) n;
}
SET CONSTRAINTS constraints_set_list constraints_set_mode
{
ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt);
+
n->constraints = $3;
n->deferred = $4;
$$ = (Node *) n;
CHECKPOINT
{
CheckPointStmt *n = makeNode(CheckPointStmt);
- $$ = (Node *)n;
+
+ $$ = (Node *) n;
}
;
DISCARD ALL
{
DiscardStmt *n = makeNode(DiscardStmt);
+
n->target = DISCARD_ALL;
$$ = (Node *) n;
}
| DISCARD TEMP
{
DiscardStmt *n = makeNode(DiscardStmt);
+
n->target = DISCARD_TEMP;
$$ = (Node *) n;
}
| DISCARD TEMPORARY
{
DiscardStmt *n = makeNode(DiscardStmt);
+
n->target = DISCARD_TEMP;
$$ = (Node *) n;
}
| DISCARD PLANS
{
DiscardStmt *n = makeNode(DiscardStmt);
+
n->target = DISCARD_PLANS;
$$ = (Node *) n;
}
| DISCARD SEQUENCES
{
DiscardStmt *n = makeNode(DiscardStmt);
+
n->target = DISCARD_SEQUENCES;
$$ = (Node *) n;
}
ALTER TABLE relation_expr alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = $4;
n->objtype = OBJECT_TABLE;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $5;
n->cmds = $6;
n->objtype = OBJECT_TABLE;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE relation_expr partition_cmd
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = list_make1($4);
n->objtype = OBJECT_TABLE;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr partition_cmd
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $5;
n->cmds = list_make1($6);
n->objtype = OBJECT_TABLE;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $6;
n->objtype = OBJECT_TABLE;
n->roles = NIL;
n->new_tablespacename = $9;
n->nowait = $10;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $6;
n->objtype = OBJECT_TABLE;
n->roles = $9;
n->new_tablespacename = $12;
n->nowait = $13;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = $4;
n->objtype = OBJECT_INDEX;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $5;
n->cmds = $6;
n->objtype = OBJECT_INDEX;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX qualified_name index_partition_cmd
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = list_make1($4);
n->objtype = OBJECT_INDEX;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $6;
n->objtype = OBJECT_INDEX;
n->roles = NIL;
n->new_tablespacename = $9;
n->nowait = $10;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $6;
n->objtype = OBJECT_INDEX;
n->roles = $9;
n->new_tablespacename = $12;
n->nowait = $13;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = $4;
n->objtype = OBJECT_SEQUENCE;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $5;
n->cmds = $6;
n->objtype = OBJECT_SEQUENCE;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $3;
n->cmds = $4;
n->objtype = OBJECT_VIEW;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $5;
n->cmds = $6;
n->objtype = OBJECT_VIEW;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $4;
n->cmds = $5;
n->objtype = OBJECT_MATVIEW;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $6;
n->cmds = $7;
n->objtype = OBJECT_MATVIEW;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $7;
n->objtype = OBJECT_MATVIEW;
n->roles = NIL;
n->new_tablespacename = $10;
n->nowait = $11;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
{
AlterTableMoveAllStmt *n =
makeNode(AlterTableMoveAllStmt);
+
n->orig_tablespacename = $7;
n->objtype = OBJECT_MATVIEW;
n->roles = $10;
n->new_tablespacename = $13;
n->nowait = $14;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE relation_expr alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $4;
n->cmds = $5;
n->objtype = OBJECT_FOREIGN_TABLE;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE IF_P EXISTS relation_expr alter_table_cmds
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+
n->relation = $6;
n->cmds = $7;
n->objtype = OBJECT_FOREIGN_TABLE;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ADD_P columnDef
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddColumn;
n->def = $2;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ADD IF NOT EXISTS */
| ADD_P IF_P NOT EXISTS columnDef
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddColumn;
n->def = $5;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ADD COLUMN */
| ADD_P COLUMN columnDef
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddColumn;
n->def = $3;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ADD COLUMN IF NOT EXISTS */
| ADD_P COLUMN IF_P NOT EXISTS columnDef
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddColumn;
n->def = $6;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] {SET DEFAULT |DROP DEFAULT} */
| ALTER opt_column ColId alter_column_default
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ColumnDefault;
n->name = $3;
n->def = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] DROP NOT NULL */
| ALTER opt_column ColId DROP NOT NULL_P
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropNotNull;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET NOT NULL */
| ALTER opt_column ColId SET NOT NULL_P
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetNotNull;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] DROP EXPRESSION */
| ALTER opt_column ColId DROP EXPRESSION
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropExpression;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] DROP EXPRESSION IF EXISTS */
| ALTER opt_column ColId DROP EXPRESSION IF_P EXISTS
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropExpression;
n->name = $3;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET STATISTICS */
| ALTER opt_column ColId SET STATISTICS SignedIconst
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetStatistics;
n->name = $3;
n->def = (Node *) makeInteger($6);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET STATISTICS */
| ALTER opt_column Iconst SET STATISTICS SignedIconst
n->subtype = AT_SetStatistics;
n->num = (int16) $3;
n->def = (Node *) makeInteger($6);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET ( column_parameter = value [, ... ] ) */
| ALTER opt_column ColId SET reloptions
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetOptions;
n->name = $3;
n->def = (Node *) $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] RESET ( column_parameter [, ... ] ) */
| ALTER opt_column ColId RESET reloptions
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ResetOptions;
n->name = $3;
n->def = (Node *) $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET STORAGE */
| ALTER opt_column ColId SET STORAGE ColId
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetStorage;
n->name = $3;
n->def = (Node *) makeString($6);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET COMPRESSION */
| ALTER opt_column ColId SET column_compression
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetCompression;
n->name = $3;
n->def = (Node *) makeString($5);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] ADD GENERATED ... AS IDENTITY ... */
| ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
n->name = $3;
n->def = (Node *) c;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] SET /RESET */
| ALTER opt_column ColId alter_identity_column_option_list
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetIdentity;
n->name = $3;
n->def = (Node *) $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] DROP IDENTITY */
| ALTER opt_column ColId DROP IDENTITY_P
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropIdentity;
n->name = $3;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER [COLUMN] DROP IDENTITY IF EXISTS */
| ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropIdentity;
n->name = $3;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DROP [COLUMN] IF EXISTS [RESTRICT|CASCADE] */
| DROP opt_column IF_P EXISTS ColId opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropColumn;
n->name = $5;
n->behavior = $6;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DROP [COLUMN] [RESTRICT|CASCADE] */
| DROP opt_column ColId opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropColumn;
n->name = $3;
n->behavior = $4;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/*
* ALTER TABLE ALTER [COLUMN] [SET DATA] TYPE
{
AlterTableCmd *n = makeNode(AlterTableCmd);
ColumnDef *def = makeNode(ColumnDef);
+
n->subtype = AT_AlterColumnType;
n->name = $3;
n->def = (Node *) def;
def->collClause = (CollateClause *) $7;
def->raw_default = $8;
def->location = @3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER FOREIGN TABLE ALTER [COLUMN] OPTIONS */
| ALTER opt_column ColId alter_generic_options
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AlterColumnGenericOptions;
n->name = $3;
n->def = (Node *) $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ADD CONSTRAINT ... */
| ADD_P TableConstraint
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddConstraint;
n->def = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ALTER CONSTRAINT ... */
| ALTER CONSTRAINT name ConstraintAttributeSpec
{
AlterTableCmd *n = makeNode(AlterTableCmd);
Constraint *c = makeNode(Constraint);
+
n->subtype = AT_AlterConstraint;
n->def = (Node *) c;
c->contype = CONSTR_FOREIGN; /* others not supported, yet */
&c->deferrable,
&c->initdeferred,
NULL, NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE VALIDATE CONSTRAINT ... */
| VALIDATE CONSTRAINT name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ValidateConstraint;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DROP CONSTRAINT IF EXISTS [RESTRICT|CASCADE] */
| DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropConstraint;
n->name = $5;
n->behavior = $6;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DROP CONSTRAINT [RESTRICT|CASCADE] */
| DROP CONSTRAINT name opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropConstraint;
n->name = $3;
n->behavior = $4;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE SET WITHOUT OIDS, for backward compat */
| SET WITHOUT OIDS
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropOids;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE CLUSTER ON */
| CLUSTER ON name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ClusterOn;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE SET WITHOUT CLUSTER */
| SET WITHOUT CLUSTER
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropCluster;
n->name = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE SET LOGGED */
| SET LOGGED
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetLogged;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE SET UNLOGGED */
| SET UNLOGGED
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetUnLogged;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE TRIGGER */
| ENABLE_P TRIGGER name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableTrig;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE ALWAYS TRIGGER */
| ENABLE_P ALWAYS TRIGGER name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableAlwaysTrig;
n->name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE REPLICA TRIGGER */
| ENABLE_P REPLICA TRIGGER name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableReplicaTrig;
n->name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE TRIGGER ALL */
| ENABLE_P TRIGGER ALL
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableTrigAll;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE TRIGGER USER */
| ENABLE_P TRIGGER USER
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableTrigUser;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DISABLE TRIGGER */
| DISABLE_P TRIGGER name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DisableTrig;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DISABLE TRIGGER ALL */
| DISABLE_P TRIGGER ALL
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DisableTrigAll;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DISABLE TRIGGER USER */
| DISABLE_P TRIGGER USER
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DisableTrigUser;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE RULE */
| ENABLE_P RULE name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableRule;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE ALWAYS RULE */
| ENABLE_P ALWAYS RULE name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableAlwaysRule;
n->name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE REPLICA RULE */
| ENABLE_P REPLICA RULE name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableReplicaRule;
n->name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DISABLE RULE */
| DISABLE_P RULE name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DisableRule;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE
INHERIT */ | INHERIT qualified_name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddInherit;
n->def = (Node *) $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE
NO INHERIT */ | NO INHERIT qualified_name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropInherit;
n->def = (Node *) $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE OF */
| OF any_name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
- TypeName *def = makeTypeNameFromNameList($2);
+ TypeName *def = makeTypeNameFromNameList($2);
+
def->location = @2;
n->subtype = AT_AddOf;
n->def = (Node *) def;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE NOT OF */
| NOT OF
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropOf;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE OWNER TO RoleSpec */
| OWNER TO RoleSpec
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ChangeOwner;
n->newowner = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE
SET ACCESS METHOD */ | SET ACCESS METHOD name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetAccessMethod;
n->name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE
SET TABLESPACE */ | SET TABLESPACE name
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetTableSpace;
n->name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE SET (...) */
| SET reloptions
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_SetRelOptions;
- n->def = (Node *)$2;
- $$ = (Node *)n;
+ n->def = (Node *) $2;
+ $$ = (Node *) n;
}
/* ALTER TABLE RESET (...) */
| RESET reloptions
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ResetRelOptions;
- n->def = (Node *)$2;
- $$ = (Node *)n;
+ n->def = (Node *) $2;
+ $$ = (Node *) n;
}
/* ALTER TABLE REPLICA IDENTITY */
| REPLICA IDENTITY_P replica_identity
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ReplicaIdentity;
n->def = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE ENABLE ROW LEVEL SECURITY */
| ENABLE_P ROW LEVEL SECURITY
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_EnableRowSecurity;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE DISABLE ROW LEVEL SECURITY */
| DISABLE_P ROW LEVEL SECURITY
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DisableRowSecurity;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE FORCE ROW LEVEL SECURITY */
| FORCE ROW LEVEL SECURITY
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_ForceRowSecurity;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TABLE NO FORCE ROW LEVEL SECURITY */
| NO FORCE ROW LEVEL SECURITY
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_NoForceRowSecurity;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| alter_generic_options
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_GenericOptions;
- n->def = (Node *)$1;
+ n->def = (Node *) $1;
$$ = (Node *) n;
}
;
COLLATE any_name
{
CollateClause *n = makeNode(CollateClause);
+
n->arg = NULL;
n->collname = $2;
n->location = @1;
NOTHING
{
ReplicaIdentityStmt *n = makeNode(ReplicaIdentityStmt);
+
n->identity_type = REPLICA_IDENTITY_NOTHING;
n->name = NULL;
$$ = (Node *) n;
| FULL
{
ReplicaIdentityStmt *n = makeNode(ReplicaIdentityStmt);
+
n->identity_type = REPLICA_IDENTITY_FULL;
n->name = NULL;
$$ = (Node *) n;
| DEFAULT
{
ReplicaIdentityStmt *n = makeNode(ReplicaIdentityStmt);
+
n->identity_type = REPLICA_IDENTITY_DEFAULT;
n->name = NULL;
$$ = (Node *) n;
| USING INDEX name
{
ReplicaIdentityStmt *n = makeNode(ReplicaIdentityStmt);
+
n->identity_type = REPLICA_IDENTITY_INDEX;
n->name = $3;
$$ = (Node *) n;
}
| RESTART opt_with NumericOnly
{
- $$ = makeDefElem("restart", (Node *)$3, @1);
+ $$ = makeDefElem("restart", (Node *) $3, @1);
}
| SET SeqOptElem
{
hash_partbound_elem:
NonReservedWord Iconst
{
- $$ = makeDefElem($1, (Node *)makeInteger($2), @1);
+ $$ = makeDefElem($1, (Node *) makeInteger($2), @1);
}
;
n->relation = makeRangeVarFromAnyName($3, @3, yyscanner);
n->cmds = $4;
n->objtype = OBJECT_TYPE;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ADD_P ATTRIBUTE TableFuncElement opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_AddColumn;
n->def = $3;
n->behavior = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TYPE
DROP ATTRIBUTE IF EXISTS [RESTRICT|CASCADE] */ | DROP ATTRIBUTE IF_P EXISTS ColId opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropColumn;
n->name = $5;
n->behavior = $6;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TYPE
DROP ATTRIBUTE [RESTRICT|CASCADE] */ | DROP ATTRIBUTE ColId opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
+
n->subtype = AT_DropColumn;
n->name = $3;
n->behavior = $4;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER TYPE
ALTER ATTRIBUTE [SET DATA] TYPE [RESTRICT|CASCADE] */ | ALTER ATTRIBUTE ColId opt_set_data TYPE_P Typename opt_collate_clause opt_drop_behavior
{
AlterTableCmd *n = makeNode(AlterTableCmd);
ColumnDef *def = makeNode(ColumnDef);
+
n->subtype = AT_AlterColumnType;
n->name = $3;
n->def = (Node *) def;
def->collClause = (CollateClause *) $7;
def->raw_default = NULL;
def->location = @3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CLOSE cursor_name
{
ClosePortalStmt *n = makeNode(ClosePortalStmt);
+
n->portalname = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CLOSE ALL
{
ClosePortalStmt *n = makeNode(ClosePortalStmt);
+
n->portalname = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
copy_options where_clause
{
CopyStmt *n = makeNode(CopyStmt);
+
n->relation = $3;
n->query = NULL;
n->attlist = $4;
n->options = lappend(n->options, $8);
if ($10)
n->options = list_concat(n->options, $10);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| COPY '(' PreparableStmt ')' TO opt_program copy_file_name opt_with copy_options
{
CopyStmt *n = makeNode(CopyStmt);
+
n->relation = NULL;
n->query = $3;
n->attlist = NIL;
errmsg("STDIN/STDOUT not allowed with PROGRAM"),
parser_errposition(@5)));
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
copy_opt_item:
BINARY
{
- $$ = makeDefElem("format", (Node *)makeString("binary"), @1);
+ $$ = makeDefElem("format", (Node *) makeString("binary"), @1);
}
| FREEZE
{
- $$ = makeDefElem("freeze", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("freeze", (Node *) makeBoolean(true), @1);
}
| DELIMITER opt_as Sconst
{
- $$ = makeDefElem("delimiter", (Node *)makeString($3), @1);
+ $$ = makeDefElem("delimiter", (Node *) makeString($3), @1);
}
| NULL_P opt_as Sconst
{
- $$ = makeDefElem("null", (Node *)makeString($3), @1);
+ $$ = makeDefElem("null", (Node *) makeString($3), @1);
}
| CSV
{
- $$ = makeDefElem("format", (Node *)makeString("csv"), @1);
+ $$ = makeDefElem("format", (Node *) makeString("csv"), @1);
}
| HEADER_P
{
- $$ = makeDefElem("header", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("header", (Node *) makeBoolean(true), @1);
}
| QUOTE opt_as Sconst
{
- $$ = makeDefElem("quote", (Node *)makeString($3), @1);
+ $$ = makeDefElem("quote", (Node *) makeString($3), @1);
}
| ESCAPE opt_as Sconst
{
- $$ = makeDefElem("escape", (Node *)makeString($3), @1);
+ $$ = makeDefElem("escape", (Node *) makeString($3), @1);
}
| FORCE QUOTE columnList
{
- $$ = makeDefElem("force_quote", (Node *)$3, @1);
+ $$ = makeDefElem("force_quote", (Node *) $3, @1);
}
| FORCE QUOTE '*'
{
- $$ = makeDefElem("force_quote", (Node *)makeNode(A_Star), @1);
+ $$ = makeDefElem("force_quote", (Node *) makeNode(A_Star), @1);
}
| FORCE NOT NULL_P columnList
{
- $$ = makeDefElem("force_not_null", (Node *)$4, @1);
+ $$ = makeDefElem("force_not_null", (Node *) $4, @1);
}
| FORCE NULL_P columnList
{
- $$ = makeDefElem("force_null", (Node *)$3, @1);
+ $$ = makeDefElem("force_null", (Node *) $3, @1);
}
| ENCODING Sconst
{
- $$ = makeDefElem("encoding", (Node *)makeString($2), @1);
+ $$ = makeDefElem("encoding", (Node *) makeString($2), @1);
}
;
opt_binary:
BINARY
{
- $$ = makeDefElem("format", (Node *)makeString("binary"), @1);
+ $$ = makeDefElem("format", (Node *) makeString("binary"), @1);
}
| /*EMPTY*/ { $$ = NULL; }
;
copy_delimiter:
opt_using DELIMITERS Sconst
{
- $$ = makeDefElem("delimiter", (Node *)makeString($3), @2);
+ $$ = makeDefElem("delimiter", (Node *) makeString($3), @2);
}
| /*EMPTY*/ { $$ = NULL; }
;
OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$4->relpersistence = $2;
n->relation = $4;
n->tableElts = $6;
n->oncommit = $12;
n->tablespacename = $13;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name '('
OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause
OptWith OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$7->relpersistence = $2;
n->relation = $7;
n->tableElts = $9;
n->oncommit = $15;
n->tablespacename = $16;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp TABLE qualified_name OF any_name
OptTypedTableElementList OptPartitionSpec table_access_method_clause
OptWith OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$4->relpersistence = $2;
n->relation = $4;
n->tableElts = $7;
n->oncommit = $11;
n->tablespacename = $12;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name OF any_name
OptTypedTableElementList OptPartitionSpec table_access_method_clause
OptWith OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$7->relpersistence = $2;
n->relation = $7;
n->tableElts = $10;
n->oncommit = $14;
n->tablespacename = $15;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp TABLE qualified_name PARTITION OF qualified_name
OptTypedTableElementList PartitionBoundSpec OptPartitionSpec
table_access_method_clause OptWith OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$4->relpersistence = $2;
n->relation = $4;
n->tableElts = $8;
n->oncommit = $13;
n->tablespacename = $14;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name PARTITION OF
qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec
table_access_method_clause OptWith OnCommitOption OptTableSpace
{
CreateStmt *n = makeNode(CreateStmt);
+
$7->relpersistence = $2;
n->relation = $7;
n->tableElts = $11;
n->oncommit = $16;
n->tablespacename = $17;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
columnDef: ColId Typename opt_column_compression create_generic_options ColQualList
{
ColumnDef *n = makeNode(ColumnDef);
+
n->colname = $1;
n->typeName = $2;
n->compression = $3;
SplitColQualList($5, &n->constraints, &n->collClause,
yyscanner);
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
columnOptions: ColId ColQualList
{
ColumnDef *n = makeNode(ColumnDef);
+
n->colname = $1;
n->typeName = NULL;
n->inhcount = 0;
SplitColQualList($2, &n->constraints, &n->collClause,
yyscanner);
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ColId WITH OPTIONS ColQualList
{
ColumnDef *n = makeNode(ColumnDef);
+
n->colname = $1;
n->typeName = NULL;
n->inhcount = 0;
SplitColQualList($4, &n->constraints, &n->collClause,
yyscanner);
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CONSTRAINT name ColConstraintElem
{
Constraint *n = castNode(Constraint, $3);
+
n->conname = $2;
n->location = @1;
$$ = (Node *) n;
* again in SplitColQualList.
*/
CollateClause *n = makeNode(CollateClause);
+
n->arg = NULL;
n->collname = $2;
n->location = @1;
NOT NULL_P
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_NOTNULL;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| NULL_P
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_NULL;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| UNIQUE opt_unique_null_treatment opt_definition OptConsTableSpace
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_UNIQUE;
n->location = @1;
n->nulls_not_distinct = !$2;
n->options = $3;
n->indexname = NULL;
n->indexspace = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| PRIMARY KEY opt_definition OptConsTableSpace
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_PRIMARY;
n->location = @1;
n->keys = NULL;
n->options = $3;
n->indexname = NULL;
n->indexspace = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CHECK '(' a_expr ')' opt_no_inherit
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_CHECK;
n->location = @1;
n->is_no_inherit = $5;
n->cooked_expr = NULL;
n->skip_validation = false;
n->initially_valid = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DEFAULT b_expr
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_DEFAULT;
n->location = @1;
n->raw_expr = $2;
n->cooked_expr = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_IDENTITY;
n->generated_when = $2;
n->options = $5;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| GENERATED generated_when AS '(' a_expr ')' STORED
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_GENERATED;
n->generated_when = $2;
n->raw_expr = $5;
errmsg("for a generated column, GENERATED ALWAYS must be specified"),
parser_errposition(@2)));
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| REFERENCES qualified_name opt_column_list key_match key_actions
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_FOREIGN;
n->location = @1;
n->pktable = $2;
n->fk_del_set_cols = ($5)->deleteAction->cols;
n->skip_validation = false;
n->initially_valid = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DEFERRABLE
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_ATTR_DEFERRABLE;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| NOT DEFERRABLE
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_ATTR_NOT_DEFERRABLE;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| INITIALLY DEFERRED
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_ATTR_DEFERRED;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| INITIALLY IMMEDIATE
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_ATTR_IMMEDIATE;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
LIKE qualified_name TableLikeOptionList
{
TableLikeClause *n = makeNode(TableLikeClause);
+
n->relation = $2;
n->options = $3;
n->relationOid = InvalidOid;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CONSTRAINT name ConstraintElem
{
Constraint *n = castNode(Constraint, $3);
+
n->conname = $2;
n->location = @1;
$$ = (Node *) n;
CHECK '(' a_expr ')' ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_CHECK;
n->location = @1;
n->raw_expr = $3;
NULL, NULL, &n->skip_validation,
&n->is_no_inherit, yyscanner);
n->initially_valid = !n->skip_validation;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| UNIQUE opt_unique_null_treatment '(' columnList ')' opt_c_include opt_definition OptConsTableSpace
ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_UNIQUE;
n->location = @1;
n->nulls_not_distinct = !$2;
processCASbits($9, @9, "UNIQUE",
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| UNIQUE ExistingIndex ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_UNIQUE;
n->location = @1;
n->keys = NIL;
processCASbits($3, @3, "UNIQUE",
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| PRIMARY KEY '(' columnList ')' opt_c_include opt_definition OptConsTableSpace
ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_PRIMARY;
n->location = @1;
n->keys = $4;
processCASbits($9, @9, "PRIMARY KEY",
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| PRIMARY KEY ExistingIndex ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_PRIMARY;
n->location = @1;
n->keys = NIL;
processCASbits($4, @4, "PRIMARY KEY",
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| EXCLUDE access_method_clause '(' ExclusionConstraintList ')'
opt_c_include opt_definition OptConsTableSpace OptWhereClause
ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_EXCLUSION;
n->location = @1;
n->access_method = $2;
processCASbits($10, @10, "EXCLUDE",
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| FOREIGN KEY '(' columnList ')' REFERENCES qualified_name
opt_column_list key_match key_actions ConstraintAttributeSpec
{
Constraint *n = makeNode(Constraint);
+
n->contype = CONSTR_FOREIGN;
n->location = @1;
n->pktable = $7;
&n->skip_validation, NULL,
yyscanner);
n->initially_valid = !n->skip_validation;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
key_update
{
KeyActions *n = palloc(sizeof(KeyActions));
+
n->updateAction = $1;
n->deleteAction = palloc(sizeof(KeyAction));
n->deleteAction->action = FKCONSTR_ACTION_NOACTION;
| key_delete
{
KeyActions *n = palloc(sizeof(KeyActions));
+
n->updateAction = palloc(sizeof(KeyAction));
n->updateAction->action = FKCONSTR_ACTION_NOACTION;
n->updateAction->cols = NIL;
| key_update key_delete
{
KeyActions *n = palloc(sizeof(KeyActions));
+
n->updateAction = $1;
n->deleteAction = $2;
$$ = n;
| key_delete key_update
{
KeyActions *n = palloc(sizeof(KeyActions));
+
n->updateAction = $2;
n->deleteAction = $1;
$$ = n;
| /*EMPTY*/
{
KeyActions *n = palloc(sizeof(KeyActions));
+
n->updateAction = palloc(sizeof(KeyAction));
n->updateAction->action = FKCONSTR_ACTION_NOACTION;
n->updateAction->cols = NIL;
NO ACTION
{
KeyAction *n = palloc(sizeof(KeyAction));
+
n->action = FKCONSTR_ACTION_NOACTION;
n->cols = NIL;
$$ = n;
| RESTRICT
{
KeyAction *n = palloc(sizeof(KeyAction));
+
n->action = FKCONSTR_ACTION_RESTRICT;
n->cols = NIL;
$$ = n;
| CASCADE
{
KeyAction *n = palloc(sizeof(KeyAction));
+
n->action = FKCONSTR_ACTION_CASCADE;
n->cols = NIL;
$$ = n;
| SET NULL_P opt_column_list
{
KeyAction *n = palloc(sizeof(KeyAction));
+
n->action = FKCONSTR_ACTION_SETNULL;
n->cols = $3;
$$ = n;
| SET DEFAULT opt_column_list
{
KeyAction *n = palloc(sizeof(KeyAction));
+
n->action = FKCONSTR_ACTION_SETDEFAULT;
n->cols = $3;
$$ = n;
opt_name_list ON stats_params FROM from_list
{
CreateStatsStmt *n = makeNode(CreateStatsStmt);
+
n->defnames = $3;
n->stat_types = $4;
n->exprs = $6;
n->relations = $8;
n->stxcomment = NULL;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE STATISTICS IF_P NOT EXISTS any_name
opt_name_list ON stats_params FROM from_list
{
CreateStatsStmt *n = makeNode(CreateStatsStmt);
+
n->defnames = $6;
n->stat_types = $7;
n->exprs = $9;
n->relations = $11;
n->stxcomment = NULL;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER STATISTICS any_name SET STATISTICS SignedIconst
{
AlterStatsStmt *n = makeNode(AlterStatsStmt);
+
n->defnames = $3;
n->missing_ok = false;
n->stxstattarget = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER STATISTICS IF_P EXISTS any_name SET STATISTICS SignedIconst
{
AlterStatsStmt *n = makeNode(AlterStatsStmt);
+
n->defnames = $5;
n->missing_ok = true;
n->stxstattarget = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
+
ctas->query = $6;
ctas->into = $4;
ctas->objtype = OBJECT_TABLE;
| CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS SelectStmt opt_with_data
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
+
ctas->query = $9;
ctas->into = $7;
ctas->objtype = OBJECT_TABLE;
CREATE OptNoLog MATERIALIZED VIEW create_mv_target AS SelectStmt opt_with_data
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
+
ctas->query = $7;
ctas->into = $5;
ctas->objtype = OBJECT_MATVIEW;
| CREATE OptNoLog MATERIALIZED VIEW IF_P NOT EXISTS create_mv_target AS SelectStmt opt_with_data
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
+
ctas->query = $10;
ctas->into = $8;
ctas->objtype = OBJECT_MATVIEW;
REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data
{
RefreshMatViewStmt *n = makeNode(RefreshMatViewStmt);
+
n->concurrent = $4;
n->relation = $5;
n->skipData = !($6);
CREATE OptTemp SEQUENCE qualified_name OptSeqOptList
{
CreateSeqStmt *n = makeNode(CreateSeqStmt);
+
$4->relpersistence = $2;
n->sequence = $4;
n->options = $5;
n->ownerId = InvalidOid;
n->if_not_exists = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList
{
CreateSeqStmt *n = makeNode(CreateSeqStmt);
+
$7->relpersistence = $2;
n->sequence = $7;
n->options = $8;
n->ownerId = InvalidOid;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER SEQUENCE qualified_name SeqOptList
{
AlterSeqStmt *n = makeNode(AlterSeqStmt);
+
n->sequence = $3;
n->options = $4;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList
{
AlterSeqStmt *n = makeNode(AlterSeqStmt);
+
n->sequence = $5;
n->options = $6;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
SeqOptElem: AS SimpleTypename
{
- $$ = makeDefElem("as", (Node *)$2, @1);
+ $$ = makeDefElem("as", (Node *) $2, @1);
}
| CACHE NumericOnly
{
- $$ = makeDefElem("cache", (Node *)$2, @1);
+ $$ = makeDefElem("cache", (Node *) $2, @1);
}
| CYCLE
{
- $$ = makeDefElem("cycle", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("cycle", (Node *) makeBoolean(true), @1);
}
| NO CYCLE
{
- $$ = makeDefElem("cycle", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("cycle", (Node *) makeBoolean(false), @1);
}
| INCREMENT opt_by NumericOnly
{
- $$ = makeDefElem("increment", (Node *)$3, @1);
+ $$ = makeDefElem("increment", (Node *) $3, @1);
}
| MAXVALUE NumericOnly
{
- $$ = makeDefElem("maxvalue", (Node *)$2, @1);
+ $$ = makeDefElem("maxvalue", (Node *) $2, @1);
}
| MINVALUE NumericOnly
{
- $$ = makeDefElem("minvalue", (Node *)$2, @1);
+ $$ = makeDefElem("minvalue", (Node *) $2, @1);
}
| NO MAXVALUE
{
}
| OWNED BY any_name
{
- $$ = makeDefElem("owned_by", (Node *)$3, @1);
+ $$ = makeDefElem("owned_by", (Node *) $3, @1);
}
| SEQUENCE NAME_P any_name
{
/* not documented, only used by pg_dump */
- $$ = makeDefElem("sequence_name", (Node *)$3, @1);
+ $$ = makeDefElem("sequence_name", (Node *) $3, @1);
}
| START opt_with NumericOnly
{
- $$ = makeDefElem("start", (Node *)$3, @1);
+ $$ = makeDefElem("start", (Node *) $3, @1);
}
| RESTART
{
}
| RESTART opt_with NumericOnly
{
- $$ = makeDefElem("restart", (Node *)$3, @1);
+ $$ = makeDefElem("restart", (Node *) $3, @1);
}
;
| '+' FCONST { $$ = (Node *) makeFloat($2); }
| '-' FCONST
{
- Float *f = makeFloat($2);
+ Float *f = makeFloat($2);
+
doNegateFloat(f);
$$ = (Node *) f;
}
* ignore TRUSTED, as the previous code would have too.
*/
CreateExtensionStmt *n = makeNode(CreateExtensionStmt);
+
n->if_not_exists = $2;
n->extname = $6;
n->options = NIL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name
HANDLER handler_name opt_inline_handler opt_validator
{
CreatePLangStmt *n = makeNode(CreatePLangStmt);
+
n->replace = $2;
n->plname = $6;
n->plhandler = $8;
n->plinline = $9;
n->plvalidator = $10;
n->pltrusted = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CreateTableSpaceStmt: CREATE TABLESPACE name OptTableSpaceOwner LOCATION Sconst opt_reloptions
{
CreateTableSpaceStmt *n = makeNode(CreateTableSpaceStmt);
+
n->tablespacename = $3;
n->owner = $4;
n->location = $6;
DropTableSpaceStmt: DROP TABLESPACE name
{
DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt);
+
n->tablespacename = $3;
n->missing_ok = false;
$$ = (Node *) n;
| DROP TABLESPACE IF_P EXISTS name
{
DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt);
+
n->tablespacename = $5;
n->missing_ok = true;
$$ = (Node *) n;
CreateExtensionStmt: CREATE EXTENSION name opt_with create_extension_opt_list
{
CreateExtensionStmt *n = makeNode(CreateExtensionStmt);
+
n->extname = $3;
n->if_not_exists = false;
n->options = $5;
| CREATE EXTENSION IF_P NOT EXISTS name opt_with create_extension_opt_list
{
CreateExtensionStmt *n = makeNode(CreateExtensionStmt);
+
n->extname = $6;
n->if_not_exists = true;
n->options = $8;
create_extension_opt_item:
SCHEMA name
{
- $$ = makeDefElem("schema", (Node *)makeString($2), @1);
+ $$ = makeDefElem("schema", (Node *) makeString($2), @1);
}
| VERSION_P NonReservedWord_or_Sconst
{
- $$ = makeDefElem("new_version", (Node *)makeString($2), @1);
+ $$ = makeDefElem("new_version", (Node *) makeString($2), @1);
}
| FROM NonReservedWord_or_Sconst
{
}
| CASCADE
{
- $$ = makeDefElem("cascade", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("cascade", (Node *) makeBoolean(true), @1);
}
;
AlterExtensionStmt: ALTER EXTENSION name UPDATE alter_extension_opt_list
{
AlterExtensionStmt *n = makeNode(AlterExtensionStmt);
+
n->extname = $3;
n->options = $5;
$$ = (Node *) n;
alter_extension_opt_item:
TO NonReservedWord_or_Sconst
{
- $$ = makeDefElem("new_version", (Node *)makeString($2), @1);
+ $$ = makeDefElem("new_version", (Node *) makeString($2), @1);
}
;
ALTER EXTENSION name add_drop object_type_name name
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = $5;
n->object = (Node *) makeString($6);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop object_type_any_name any_name
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = $5;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_AGGREGATE;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop CAST '(' Typename AS Typename ')'
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_CAST;
| ALTER EXTENSION name add_drop DOMAIN_P Typename
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_DOMAIN;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop FUNCTION function_with_argtypes
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_FUNCTION;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_OPERATOR;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_OPCLASS;
n->object = (Node *) lcons(makeString($9), $7);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_OPFAMILY;
n->object = (Node *) lcons(makeString($9), $7);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_PROCEDURE;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop ROUTINE function_with_argtypes
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_ROUTINE;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop TRANSFORM FOR Typename LANGUAGE name
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_TRANSFORM;
n->object = (Node *) list_make2($7, makeString($9));
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name add_drop TYPE_P Typename
{
AlterExtensionContentsStmt *n = makeNode(AlterExtensionContentsStmt);
+
n->extname = $3;
n->action = $4;
n->objtype = OBJECT_TYPE;
n->object = (Node *) $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CreateFdwStmt: CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options
{
CreateFdwStmt *n = makeNode(CreateFdwStmt);
+
n->fdwname = $5;
n->func_options = $6;
n->options = $7;
;
fdw_option:
- HANDLER handler_name { $$ = makeDefElem("handler", (Node *)$2, @1); }
+ HANDLER handler_name { $$ = makeDefElem("handler", (Node *) $2, @1); }
| NO HANDLER { $$ = makeDefElem("handler", NULL, @1); }
- | VALIDATOR handler_name { $$ = makeDefElem("validator", (Node *)$2, @1); }
+ | VALIDATOR handler_name { $$ = makeDefElem("validator", (Node *) $2, @1); }
| NO VALIDATOR { $$ = makeDefElem("validator", NULL, @1); }
;
AlterFdwStmt: ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options
{
AlterFdwStmt *n = makeNode(AlterFdwStmt);
+
n->fdwname = $5;
n->func_options = $6;
n->options = $7;
| ALTER FOREIGN DATA_P WRAPPER name fdw_options
{
AlterFdwStmt *n = makeNode(AlterFdwStmt);
+
n->fdwname = $5;
n->func_options = $6;
n->options = NIL;
FOREIGN DATA_P WRAPPER name create_generic_options
{
CreateForeignServerStmt *n = makeNode(CreateForeignServerStmt);
+
n->servername = $3;
n->servertype = $4;
n->version = $5;
FOREIGN DATA_P WRAPPER name create_generic_options
{
CreateForeignServerStmt *n = makeNode(CreateForeignServerStmt);
+
n->servername = $6;
n->servertype = $7;
n->version = $8;
AlterForeignServerStmt: ALTER SERVER name foreign_server_version alter_generic_options
{
AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+
n->servername = $3;
n->version = $4;
n->options = $5;
| ALTER SERVER name foreign_server_version
{
AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+
n->servername = $3;
n->version = $4;
n->has_version = true;
| ALTER SERVER name alter_generic_options
{
AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+
n->servername = $3;
n->options = $4;
$$ = (Node *) n;
OptInherit SERVER name create_generic_options
{
CreateForeignTableStmt *n = makeNode(CreateForeignTableStmt);
+
$4->relpersistence = RELPERSISTENCE_PERMANENT;
n->base.relation = $4;
n->base.tableElts = $6;
OptInherit SERVER name create_generic_options
{
CreateForeignTableStmt *n = makeNode(CreateForeignTableStmt);
+
$7->relpersistence = RELPERSISTENCE_PERMANENT;
n->base.relation = $7;
n->base.tableElts = $9;
SERVER name create_generic_options
{
CreateForeignTableStmt *n = makeNode(CreateForeignTableStmt);
+
$4->relpersistence = RELPERSISTENCE_PERMANENT;
n->base.relation = $4;
n->base.inhRelations = list_make1($7);
SERVER name create_generic_options
{
CreateForeignTableStmt *n = makeNode(CreateForeignTableStmt);
+
$7->relpersistence = RELPERSISTENCE_PERMANENT;
n->base.relation = $7;
n->base.inhRelations = list_make1($10);
FROM SERVER name INTO name create_generic_options
{
ImportForeignSchemaStmt *n = makeNode(ImportForeignSchemaStmt);
+
n->server_name = $8;
n->remote_schema = $4;
n->local_schema = $10;
import_qualification_type '(' relation_expr_list ')'
{
ImportQual *n = (ImportQual *) palloc(sizeof(ImportQual));
+
n->type = $1;
n->table_names = $3;
$$ = n;
CreateUserMappingStmt: CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
{
CreateUserMappingStmt *n = makeNode(CreateUserMappingStmt);
+
n->user = $5;
n->servername = $7;
n->options = $8;
| CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options
{
CreateUserMappingStmt *n = makeNode(CreateUserMappingStmt);
+
n->user = $8;
n->servername = $10;
n->options = $11;
DropUserMappingStmt: DROP USER MAPPING FOR auth_ident SERVER name
{
DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
+
n->user = $5;
n->servername = $7;
n->missing_ok = false;
| DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
{
DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
+
n->user = $7;
n->servername = $9;
n->missing_ok = true;
AlterUserMappingStmt: ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
{
AlterUserMappingStmt *n = makeNode(AlterUserMappingStmt);
+
n->user = $5;
n->servername = $7;
n->options = $8;
RowSecurityOptionalExpr RowSecurityOptionalWithCheck
{
CreatePolicyStmt *n = makeNode(CreatePolicyStmt);
+
n->policy_name = $3;
n->table = $5;
n->permissive = $6;
RowSecurityOptionalExpr RowSecurityOptionalWithCheck
{
AlterPolicyStmt *n = makeNode(AlterPolicyStmt);
+
n->policy_name = $3;
n->table = $5;
n->roles = $6;
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("unrecognized row security option \"%s\"", $2),
+ errmsg("unrecognized row security option \"%s\"", $2),
errhint("Only PERMISSIVE or RESTRICTIVE policies are supported currently."),
- parser_errposition(@2)));
+ parser_errposition(@2)));
}
| /* EMPTY */ { $$ = true; }
CreateAmStmt: CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name
{
CreateAmStmt *n = makeNode(CreateAmStmt);
+
n->amname = $4;
n->handler_name = $8;
n->amtype = $6;
EXECUTE FUNCTION_or_PROCEDURE func_name '(' TriggerFuncArgs ')'
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
+
n->replace = $2;
n->isconstraint = false;
n->trigname = $4;
n->deferrable = false;
n->initdeferred = false;
n->constrrel = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace CONSTRAINT TRIGGER name AFTER TriggerEvents ON
qualified_name OptConstrFromTable ConstraintAttributeSpec
EXECUTE FUNCTION_or_PROCEDURE func_name '(' TriggerFuncArgs ')'
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
+
n->replace = $2;
if (n->replace) /* not supported, see CreateTrigger */
ereport(ERROR,
&n->deferrable, &n->initdeferred, NULL,
NULL, yyscanner);
n->constrrel = $10;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
{ $$ = $1; }
| TriggerEvents OR TriggerOneEvent
{
- int events1 = intVal(linitial($1));
- int events2 = intVal(linitial($3));
- List *columns1 = (List *) lsecond($1);
- List *columns2 = (List *) lsecond($3);
+ int events1 = intVal(linitial($1));
+ int events2 = intVal(linitial($3));
+ List *columns1 = (List *) lsecond($1);
+ List *columns2 = (List *) lsecond($3);
if (events1 & events2)
parser_yyerror("duplicate trigger events specified");
TransitionOldOrNew TransitionRowOrTable opt_as TransitionRelName
{
TriggerTransition *n = makeNode(TriggerTransition);
+
n->name = $4;
n->isNew = $1;
n->isTable = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
{
CreateEventTrigStmt *n = makeNode(CreateEventTrigStmt);
+
n->trigname = $4;
n->eventname = $6;
n->whenclause = NULL;
n->funcname = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE EVENT TRIGGER name ON ColLabel
WHEN event_trigger_when_list
EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
{
CreateEventTrigStmt *n = makeNode(CreateEventTrigStmt);
+
n->trigname = $4;
n->eventname = $6;
n->whenclause = $8;
n->funcname = $11;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER EVENT TRIGGER name enable_trigger
{
AlterEventTrigStmt *n = makeNode(AlterEventTrigStmt);
+
n->trigname = $4;
n->tgenabled = $5;
$$ = (Node *) n;
CREATE opt_or_replace AGGREGATE func_name aggr_args definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_AGGREGATE;
n->oldstyle = false;
n->replace = $2;
n->defnames = $4;
n->args = $5;
n->definition = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace AGGREGATE func_name old_aggr_definition
{
/* old-style (pre-8.2) syntax for CREATE AGGREGATE */
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_AGGREGATE;
n->oldstyle = true;
n->replace = $2;
n->defnames = $4;
n->args = NIL;
n->definition = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE OPERATOR any_operator definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_OPERATOR;
n->oldstyle = false;
n->defnames = $3;
n->args = NIL;
n->definition = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TYPE_P any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TYPE;
n->oldstyle = false;
n->defnames = $3;
n->args = NIL;
n->definition = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TYPE_P any_name
{
/* Shell type (identified by lack of definition) */
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TYPE;
n->oldstyle = false;
n->defnames = $3;
n->args = NIL;
n->definition = NIL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TYPE_P any_name AS '(' OptTableFuncElementList ')'
{
/* can't use qualified_name, sigh */
n->typevar = makeRangeVarFromAnyName($3, @3, yyscanner);
n->coldeflist = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TYPE_P any_name AS ENUM_P '(' opt_enum_val_list ')'
{
CreateEnumStmt *n = makeNode(CreateEnumStmt);
+
n->typeName = $3;
n->vals = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TYPE_P any_name AS RANGE definition
{
CreateRangeStmt *n = makeNode(CreateRangeStmt);
+
n->typeName = $3;
n->params = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TEXT_P SEARCH PARSER any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TSPARSER;
n->args = NIL;
n->defnames = $5;
n->definition = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TEXT_P SEARCH DICTIONARY any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TSDICTIONARY;
n->args = NIL;
n->defnames = $5;
n->definition = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TEXT_P SEARCH TEMPLATE any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TSTEMPLATE;
n->args = NIL;
n->defnames = $5;
n->definition = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE TEXT_P SEARCH CONFIGURATION any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_TSCONFIGURATION;
n->args = NIL;
n->defnames = $5;
n->definition = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE COLLATION any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_COLLATION;
n->args = NIL;
n->defnames = $3;
n->definition = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE COLLATION IF_P NOT EXISTS any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_COLLATION;
n->args = NIL;
n->defnames = $6;
n->definition = $7;
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE COLLATION any_name FROM any_name
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_COLLATION;
n->args = NIL;
n->defnames = $3;
n->definition = list_make1(makeDefElem("from", (Node *) $5, @5));
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name
{
DefineStmt *n = makeNode(DefineStmt);
+
n->kind = OBJECT_COLLATION;
n->args = NIL;
n->defnames = $6;
n->definition = list_make1(makeDefElem("from", (Node *) $8, @8));
n->if_not_exists = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
;
/* Note: any simple identifier will be returned as a type name! */
-def_arg: func_type { $$ = (Node *)$1; }
- | reserved_keyword { $$ = (Node *)makeString(pstrdup($1)); }
- | qual_all_Op { $$ = (Node *)$1; }
- | NumericOnly { $$ = (Node *)$1; }
- | Sconst { $$ = (Node *)makeString($1); }
- | NONE { $$ = (Node *)makeString(pstrdup($1)); }
+def_arg: func_type { $$ = (Node *) $1; }
+ | reserved_keyword { $$ = (Node *) makeString(pstrdup($1)); }
+ | qual_all_Op { $$ = (Node *) $1; }
+ | NumericOnly { $$ = (Node *) $1; }
+ | Sconst { $$ = (Node *) makeString($1); }
+ | NONE { $$ = (Node *) makeString(pstrdup($1)); }
;
old_aggr_definition: '(' old_aggr_list ')' { $$ = $2; }
*/
old_aggr_elem: IDENT '=' def_arg
{
- $$ = makeDefElem($1, (Node *)$3, @1);
+ $$ = makeDefElem($1, (Node *) $3, @1);
}
;
ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst
{
AlterEnumStmt *n = makeNode(AlterEnumStmt);
+
n->typeName = $3;
n->oldVal = NULL;
n->newVal = $7;
| ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst BEFORE Sconst
{
AlterEnumStmt *n = makeNode(AlterEnumStmt);
+
n->typeName = $3;
n->oldVal = NULL;
n->newVal = $7;
| ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst AFTER Sconst
{
AlterEnumStmt *n = makeNode(AlterEnumStmt);
+
n->typeName = $3;
n->oldVal = NULL;
n->newVal = $7;
| ALTER TYPE_P any_name RENAME VALUE_P Sconst TO Sconst
{
AlterEnumStmt *n = makeNode(AlterEnumStmt);
+
n->typeName = $3;
n->oldVal = $6;
n->newVal = $8;
USING name opt_opfamily AS opclass_item_list
{
CreateOpClassStmt *n = makeNode(CreateOpClassStmt);
+
n->opclassname = $4;
n->isDefault = $5;
n->datatype = $8;
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
ObjectWithArgs *owa = makeNode(ObjectWithArgs);
+
owa->objname = $3;
owa->objargs = NIL;
n->itemtype = OPCLASS_ITEM_OPERATOR;
opt_recheck
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_OPERATOR;
n->name = $3;
n->number = $2;
| FUNCTION Iconst function_with_argtypes
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_FUNCTION;
n->name = $3;
n->number = $2;
| FUNCTION Iconst '(' type_list ')' function_with_argtypes
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_FUNCTION;
n->name = $6;
n->number = $2;
| STORAGE Typename
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_STORAGETYPE;
n->storedtype = $2;
$$ = (Node *) n;
CREATE OPERATOR FAMILY any_name USING name
{
CreateOpFamilyStmt *n = makeNode(CreateOpFamilyStmt);
+
n->opfamilyname = $4;
n->amname = $6;
$$ = (Node *) n;
ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list
{
AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt);
+
n->opfamilyname = $4;
n->amname = $6;
n->isDrop = false;
| ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list
{
AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt);
+
n->opfamilyname = $4;
n->amname = $6;
n->isDrop = true;
OPERATOR Iconst '(' type_list ')'
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_OPERATOR;
n->number = $2;
n->class_args = $4;
| FUNCTION Iconst '(' type_list ')'
{
CreateOpClassItem *n = makeNode(CreateOpClassItem);
+
n->itemtype = OPCLASS_ITEM_FUNCTION;
n->number = $2;
n->class_args = $4;
DROP OPERATOR CLASS any_name USING name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->objects = list_make1(lcons(makeString($6), $4));
n->removeType = OBJECT_OPCLASS;
n->behavior = $7;
| DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->objects = list_make1(lcons(makeString($8), $6));
n->removeType = OBJECT_OPCLASS;
n->behavior = $9;
DROP OPERATOR FAMILY any_name USING name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->objects = list_make1(lcons(makeString($6), $4));
n->removeType = OBJECT_OPFAMILY;
n->behavior = $7;
| DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->objects = list_make1(lcons(makeString($8), $6));
n->removeType = OBJECT_OPFAMILY;
n->behavior = $9;
DROP OWNED BY role_list opt_drop_behavior
{
DropOwnedStmt *n = makeNode(DropOwnedStmt);
+
n->roles = $4;
n->behavior = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
REASSIGN OWNED BY role_list TO RoleSpec
{
ReassignOwnedStmt *n = makeNode(ReassignOwnedStmt);
+
n->roles = $4;
n->newrole = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DropStmt: DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->missing_ok = true;
n->objects = $5;
n->behavior = $6;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP object_type_any_name any_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->missing_ok = false;
n->objects = $3;
n->behavior = $4;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->missing_ok = true;
n->objects = $5;
n->behavior = $6;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP drop_type_name name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->missing_ok = false;
n->objects = $3;
n->behavior = $4;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP object_type_name_on_any_name name ON any_name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->objects = list_make1(lappend($5, makeString($3)));
n->behavior = $6;
| DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = $2;
n->objects = list_make1(lappend($7, makeString($5)));
n->behavior = $8;
| DROP TYPE_P type_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_TYPE;
n->missing_ok = false;
n->objects = $3;
| DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_TYPE;
n->missing_ok = true;
n->objects = $5;
| DROP DOMAIN_P type_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_DOMAIN;
n->missing_ok = false;
n->objects = $3;
| DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_DOMAIN;
n->missing_ok = true;
n->objects = $5;
| DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_INDEX;
n->missing_ok = false;
n->objects = $4;
n->behavior = $5;
n->concurrent = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_INDEX;
n->missing_ok = true;
n->objects = $6;
n->behavior = $7;
n->concurrent = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior
{
TruncateStmt *n = makeNode(TruncateStmt);
+
n->relations = $3;
n->restart_seqs = $4;
n->behavior = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
COMMENT ON object_type_any_name any_name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = $3;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON COLUMN any_name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_COLUMN;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON object_type_name name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = $3;
n->object = (Node *) makeString($4);
n->comment = $6;
| COMMENT ON TYPE_P Typename IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_TYPE;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON DOMAIN_P Typename IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_DOMAIN;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_AGGREGATE;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON FUNCTION function_with_argtypes IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_FUNCTION;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON OPERATOR operator_with_argtypes IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_OPERATOR;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON CONSTRAINT name ON any_name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_TABCONSTRAINT;
n->object = (Node *) lappend($6, makeString($4));
n->comment = $8;
| COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_DOMCONSTRAINT;
/*
* should use Typename not any_name in the production, but
| COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = $3;
n->object = (Node *) lappend($6, makeString($4));
n->comment = $8;
| COMMENT ON PROCEDURE function_with_argtypes IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_PROCEDURE;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON ROUTINE function_with_argtypes IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_ROUTINE;
n->object = (Node *) $4;
n->comment = $6;
| COMMENT ON TRANSFORM FOR Typename LANGUAGE name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_TRANSFORM;
n->object = (Node *) list_make2($5, makeString($7));
n->comment = $9;
| COMMENT ON OPERATOR CLASS any_name USING name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_OPCLASS;
n->object = (Node *) lcons(makeString($7), $5);
n->comment = $9;
| COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_OPFAMILY;
n->object = (Node *) lcons(makeString($7), $5);
n->comment = $9;
| COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_LARGEOBJECT;
n->object = (Node *) $5;
n->comment = $7;
| COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
+
n->objtype = OBJECT_CAST;
n->object = (Node *) list_make2($5, $7);
n->comment = $10;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = $5;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_COLUMN;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = $5;
n->object = (Node *) makeString($6);
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_TYPE;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_DOMAIN;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_AGGREGATE;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_FUNCTION;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_LARGEOBJECT;
n->object = (Node *) $7;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_PROCEDURE;
n->object = (Node *) $6;
IS security_label
{
SecLabelStmt *n = makeNode(SecLabelStmt);
+
n->provider = $3;
n->objtype = OBJECT_ROUTINE;
n->object = (Node *) $6;
FetchStmt: FETCH fetch_args
{
FetchStmt *n = (FetchStmt *) $2;
+
n->ismove = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| MOVE fetch_args
{
FetchStmt *n = (FetchStmt *) $2;
+
n->ismove = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
fetch_args: cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $1;
n->direction = FETCH_FORWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $2;
n->direction = FETCH_FORWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| NEXT opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_FORWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| PRIOR opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_BACKWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| FIRST_P opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_ABSOLUTE;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| LAST_P opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_ABSOLUTE;
n->howMany = -1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ABSOLUTE_P SignedIconst opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_ABSOLUTE;
n->howMany = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| RELATIVE_P SignedIconst opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_RELATIVE;
n->howMany = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| SignedIconst opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_FORWARD;
n->howMany = $1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALL opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_FORWARD;
n->howMany = FETCH_ALL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| FORWARD opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_FORWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| FORWARD SignedIconst opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_FORWARD;
n->howMany = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| FORWARD ALL opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_FORWARD;
n->howMany = FETCH_ALL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| BACKWARD opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $3;
n->direction = FETCH_BACKWARD;
n->howMany = 1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| BACKWARD SignedIconst opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_BACKWARD;
n->howMany = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| BACKWARD ALL opt_from_in cursor_name
{
FetchStmt *n = makeNode(FetchStmt);
+
n->portalname = $4;
n->direction = FETCH_BACKWARD;
n->howMany = FETCH_ALL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
opt_grant_grant_option opt_granted_by
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = true;
n->privileges = $2;
n->targtype = ($4)->targtype;
n->grantees = $6;
n->grant_option = $7;
n->grantor = $8;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
FROM grantee_list opt_granted_by opt_drop_behavior
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = false;
n->grant_option = false;
n->privileges = $2;
n->grantees = $6;
n->grantor = $7;
n->behavior = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| REVOKE GRANT OPTION FOR privileges ON privilege_target
FROM grantee_list opt_granted_by opt_drop_behavior
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = false;
n->grant_option = true;
n->privileges = $5;
n->grantees = $9;
n->grantor = $10;
n->behavior = $11;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
| ALL '(' columnList ')'
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = NULL;
n->cols = $3;
$$ = list_make1(n);
| ALL PRIVILEGES '(' columnList ')'
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = NULL;
n->cols = $4;
$$ = list_make1(n);
privilege: SELECT opt_column_list
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = pstrdup($1);
n->cols = $2;
$$ = n;
| REFERENCES opt_column_list
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = pstrdup($1);
n->cols = $2;
$$ = n;
| CREATE opt_column_list
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = pstrdup($1);
n->cols = $2;
$$ = n;
| ColId opt_column_list
{
AccessPriv *n = makeNode(AccessPriv);
+
n->priv_name = $1;
n->cols = $2;
$$ = n;
qualified_name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_TABLE;
n->objs = $1;
| TABLE qualified_name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_TABLE;
n->objs = $2;
| SEQUENCE qualified_name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_SEQUENCE;
n->objs = $2;
| FOREIGN DATA_P WRAPPER name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_FDW;
n->objs = $4;
| FOREIGN SERVER name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_FOREIGN_SERVER;
n->objs = $3;
| FUNCTION function_with_argtypes_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_FUNCTION;
n->objs = $2;
| PROCEDURE function_with_argtypes_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_PROCEDURE;
n->objs = $2;
| ROUTINE function_with_argtypes_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_ROUTINE;
n->objs = $2;
| DATABASE name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_DATABASE;
n->objs = $2;
| DOMAIN_P any_name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_DOMAIN;
n->objs = $2;
| LANGUAGE name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_LANGUAGE;
n->objs = $2;
| LARGE_P OBJECT_P NumericOnly_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_LARGEOBJECT;
n->objs = $3;
| SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_SCHEMA;
n->objs = $2;
| TABLESPACE name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_TABLESPACE;
n->objs = $2;
| TYPE_P any_name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_OBJECT;
n->objtype = OBJECT_TYPE;
n->objs = $2;
| ALL TABLES IN_P SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
n->objtype = OBJECT_TABLE;
n->objs = $5;
| ALL SEQUENCES IN_P SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
n->objtype = OBJECT_SEQUENCE;
n->objs = $5;
| ALL FUNCTIONS IN_P SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
n->objtype = OBJECT_FUNCTION;
n->objs = $5;
| ALL PROCEDURES IN_P SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
n->objtype = OBJECT_PROCEDURE;
n->objs = $5;
| ALL ROUTINES IN_P SCHEMA name_list
{
PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
+
n->targtype = ACL_TARGET_ALL_IN_SCHEMA;
n->objtype = OBJECT_ROUTINE;
n->objs = $5;
GRANT privilege_list TO role_list opt_grant_admin_option opt_granted_by
{
GrantRoleStmt *n = makeNode(GrantRoleStmt);
+
n->is_grant = true;
n->granted_roles = $2;
n->grantee_roles = $4;
n->admin_opt = $5;
n->grantor = $6;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior
{
GrantRoleStmt *n = makeNode(GrantRoleStmt);
+
n->is_grant = false;
n->admin_opt = false;
n->granted_roles = $2;
n->grantee_roles = $4;
n->behavior = $6;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| REVOKE ADMIN OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior
{
GrantRoleStmt *n = makeNode(GrantRoleStmt);
+
n->is_grant = false;
n->admin_opt = true;
n->granted_roles = $5;
n->grantee_roles = $7;
n->behavior = $9;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
ALTER DEFAULT PRIVILEGES DefACLOptionList DefACLAction
{
AlterDefaultPrivilegesStmt *n = makeNode(AlterDefaultPrivilegesStmt);
+
n->options = $4;
n->action = (GrantStmt *) $5;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
DefACLOption:
IN_P SCHEMA name_list
{
- $$ = makeDefElem("schemas", (Node *)$3, @1);
+ $$ = makeDefElem("schemas", (Node *) $3, @1);
}
| FOR ROLE role_list
{
- $$ = makeDefElem("roles", (Node *)$3, @1);
+ $$ = makeDefElem("roles", (Node *) $3, @1);
}
| FOR USER role_list
{
- $$ = makeDefElem("roles", (Node *)$3, @1);
+ $$ = makeDefElem("roles", (Node *) $3, @1);
}
;
opt_grant_grant_option
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = true;
n->privileges = $2;
n->targtype = ACL_TARGET_DEFAULTS;
n->objects = NIL;
n->grantees = $6;
n->grant_option = $7;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| REVOKE privileges ON defacl_privilege_target
FROM grantee_list opt_drop_behavior
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = false;
n->grant_option = false;
n->privileges = $2;
n->objects = NIL;
n->grantees = $6;
n->behavior = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target
FROM grantee_list opt_drop_behavior
{
GrantStmt *n = makeNode(GrantStmt);
+
n->is_grant = false;
n->grant_option = true;
n->privileges = $5;
n->objects = NIL;
n->grantees = $9;
n->behavior = $10;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
{
IndexStmt *n = makeNode(IndexStmt);
+
n->unique = $2;
n->concurrent = $4;
n->idxname = $5;
n->transformed = false;
n->if_not_exists = false;
n->reset_default_tblspc = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name
ON relation_expr access_method_clause '(' index_params ')'
opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
{
IndexStmt *n = makeNode(IndexStmt);
+
n->unique = $2;
n->concurrent = $4;
n->idxname = $8;
n->transformed = false;
n->if_not_exists = true;
n->reset_default_tblspc = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
RETURNS func_return opt_createfunc_opt_list opt_routine_body
{
CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
+
n->is_procedure = false;
n->replace = $2;
n->funcname = $4;
n->returnType = $7;
n->options = $8;
n->sql_body = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
RETURNS TABLE '(' table_func_column_list ')' opt_createfunc_opt_list opt_routine_body
{
CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
+
n->is_procedure = false;
n->replace = $2;
n->funcname = $4;
n->returnType->location = @7;
n->options = $11;
n->sql_body = $12;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
opt_createfunc_opt_list opt_routine_body
{
CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
+
n->is_procedure = false;
n->replace = $2;
n->funcname = $4;
n->returnType = NULL;
n->options = $6;
n->sql_body = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE opt_or_replace PROCEDURE func_name func_args_with_defaults
opt_createfunc_opt_list opt_routine_body
{
CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
+
n->is_procedure = true;
n->replace = $2;
n->funcname = $4;
n->returnType = NULL;
n->options = $6;
n->sql_body = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
func_name func_args
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = $1;
n->objargs = extractArgTypes($2);
n->objfuncargs = $2;
| type_func_name_keyword
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = list_make1(makeString(pstrdup($1)));
n->args_unspecified = true;
$$ = n;
| ColId
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = list_make1(makeString($1));
n->args_unspecified = true;
$$ = n;
| ColId indirection
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = check_func_name(lcons(makeString($1), $2),
yyscanner);
n->args_unspecified = true;
arg_class param_name func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = $2;
n->argType = $3;
n->mode = $1;
| param_name arg_class func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = $1;
n->argType = $3;
n->mode = $2;
| param_name func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = $1;
n->argType = $2;
n->mode = FUNC_PARAM_DEFAULT;
| arg_class func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = NULL;
n->argType = $2;
n->mode = $1;
| func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = NULL;
n->argType = $1;
n->mode = FUNC_PARAM_DEFAULT;
func_name aggr_args
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = $1;
n->objargs = extractAggrArgTypes($2);
n->objfuncargs = (List *) linitial($2);
common_func_opt_item:
CALLED ON NULL_P INPUT_P
{
- $$ = makeDefElem("strict", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("strict", (Node *) makeBoolean(false), @1);
}
| RETURNS NULL_P ON NULL_P INPUT_P
{
- $$ = makeDefElem("strict", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("strict", (Node *) makeBoolean(true), @1);
}
| STRICT_P
{
- $$ = makeDefElem("strict", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("strict", (Node *) makeBoolean(true), @1);
}
| IMMUTABLE
{
- $$ = makeDefElem("volatility", (Node *)makeString("immutable"), @1);
+ $$ = makeDefElem("volatility", (Node *) makeString("immutable"), @1);
}
| STABLE
{
- $$ = makeDefElem("volatility", (Node *)makeString("stable"), @1);
+ $$ = makeDefElem("volatility", (Node *) makeString("stable"), @1);
}
| VOLATILE
{
- $$ = makeDefElem("volatility", (Node *)makeString("volatile"), @1);
+ $$ = makeDefElem("volatility", (Node *) makeString("volatile"), @1);
}
| EXTERNAL SECURITY DEFINER
{
- $$ = makeDefElem("security", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("security", (Node *) makeBoolean(true), @1);
}
| EXTERNAL SECURITY INVOKER
{
- $$ = makeDefElem("security", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("security", (Node *) makeBoolean(false), @1);
}
| SECURITY DEFINER
{
- $$ = makeDefElem("security", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("security", (Node *) makeBoolean(true), @1);
}
| SECURITY INVOKER
{
- $$ = makeDefElem("security", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("security", (Node *) makeBoolean(false), @1);
}
| LEAKPROOF
{
- $$ = makeDefElem("leakproof", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("leakproof", (Node *) makeBoolean(true), @1);
}
| NOT LEAKPROOF
{
- $$ = makeDefElem("leakproof", (Node *)makeBoolean(false), @1);
+ $$ = makeDefElem("leakproof", (Node *) makeBoolean(false), @1);
}
| COST NumericOnly
{
- $$ = makeDefElem("cost", (Node *)$2, @1);
+ $$ = makeDefElem("cost", (Node *) $2, @1);
}
| ROWS NumericOnly
{
- $$ = makeDefElem("rows", (Node *)$2, @1);
+ $$ = makeDefElem("rows", (Node *) $2, @1);
}
| SUPPORT any_name
{
- $$ = makeDefElem("support", (Node *)$2, @1);
+ $$ = makeDefElem("support", (Node *) $2, @1);
}
| FunctionSetResetClause
{
/* we abuse the normal content of a DefElem here */
- $$ = makeDefElem("set", (Node *)$1, @1);
+ $$ = makeDefElem("set", (Node *) $1, @1);
}
| PARALLEL ColId
{
- $$ = makeDefElem("parallel", (Node *)makeString($2), @1);
+ $$ = makeDefElem("parallel", (Node *) makeString($2), @1);
}
;
createfunc_opt_item:
AS func_as
{
- $$ = makeDefElem("as", (Node *)$2, @1);
+ $$ = makeDefElem("as", (Node *) $2, @1);
}
| LANGUAGE NonReservedWord_or_Sconst
{
- $$ = makeDefElem("language", (Node *)makeString($2), @1);
+ $$ = makeDefElem("language", (Node *) makeString($2), @1);
}
| TRANSFORM transform_type_list
{
- $$ = makeDefElem("transform", (Node *)$2, @1);
+ $$ = makeDefElem("transform", (Node *) $2, @1);
}
| WINDOW
{
- $$ = makeDefElem("window", (Node *)makeBoolean(true), @1);
+ $$ = makeDefElem("window", (Node *) makeBoolean(true), @1);
}
| common_func_opt_item
{
ReturnStmt: RETURN a_expr
{
ReturnStmt *r = makeNode(ReturnStmt);
+
r->returnval = (Node *) $2;
$$ = (Node *) r;
}
table_func_column: param_name func_type
{
FunctionParameter *n = makeNode(FunctionParameter);
+
n->name = $1;
n->argType = $2;
n->mode = FUNC_PARAM_TABLE;
ALTER FUNCTION function_with_argtypes alterfunc_opt_list opt_restrict
{
AlterFunctionStmt *n = makeNode(AlterFunctionStmt);
+
n->objtype = OBJECT_FUNCTION;
n->func = $3;
n->actions = $4;
| ALTER PROCEDURE function_with_argtypes alterfunc_opt_list opt_restrict
{
AlterFunctionStmt *n = makeNode(AlterFunctionStmt);
+
n->objtype = OBJECT_PROCEDURE;
n->func = $3;
n->actions = $4;
| ALTER ROUTINE function_with_argtypes alterfunc_opt_list opt_restrict
{
AlterFunctionStmt *n = makeNode(AlterFunctionStmt);
+
n->objtype = OBJECT_ROUTINE;
n->func = $3;
n->actions = $4;
DROP FUNCTION function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_FUNCTION;
n->objects = $3;
n->behavior = $4;
n->missing_ok = false;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_FUNCTION;
n->objects = $5;
n->behavior = $6;
n->missing_ok = true;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP PROCEDURE function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_PROCEDURE;
n->objects = $3;
n->behavior = $4;
n->missing_ok = false;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_PROCEDURE;
n->objects = $5;
n->behavior = $6;
n->missing_ok = true;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP ROUTINE function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_ROUTINE;
n->objects = $3;
n->behavior = $4;
n->missing_ok = false;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_ROUTINE;
n->objects = $5;
n->behavior = $6;
n->missing_ok = true;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_AGGREGATE;
n->objects = $3;
n->behavior = $4;
n->missing_ok = false;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_AGGREGATE;
n->objects = $5;
n->behavior = $6;
n->missing_ok = true;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DROP OPERATOR operator_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_OPERATOR;
n->objects = $3;
n->behavior = $4;
n->missing_ok = false;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_OPERATOR;
n->objects = $5;
n->behavior = $6;
n->missing_ok = true;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
any_operator oper_argtypes
{
ObjectWithArgs *n = makeNode(ObjectWithArgs);
+
n->objname = $1;
n->objargs = $2;
$$ = n;
DoStmt: DO dostmt_opt_list
{
DoStmt *n = makeNode(DoStmt);
+
n->args = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
dostmt_opt_item:
Sconst
{
- $$ = makeDefElem("as", (Node *)makeString($1), @1);
+ $$ = makeDefElem("as", (Node *) makeString($1), @1);
}
| LANGUAGE NonReservedWord_or_Sconst
{
- $$ = makeDefElem("language", (Node *)makeString($2), @1);
+ $$ = makeDefElem("language", (Node *) makeString($2), @1);
}
;
WITH FUNCTION function_with_argtypes cast_context
{
CreateCastStmt *n = makeNode(CreateCastStmt);
+
n->sourcetype = $4;
n->targettype = $6;
n->func = $10;
n->context = (CoercionContext) $11;
n->inout = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE CAST '(' Typename AS Typename ')'
WITHOUT FUNCTION cast_context
{
CreateCastStmt *n = makeNode(CreateCastStmt);
+
n->sourcetype = $4;
n->targettype = $6;
n->func = NULL;
n->context = (CoercionContext) $10;
n->inout = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE CAST '(' Typename AS Typename ')'
WITH INOUT cast_context
{
CreateCastStmt *n = makeNode(CreateCastStmt);
+
n->sourcetype = $4;
n->targettype = $6;
n->func = NULL;
n->context = (CoercionContext) $10;
n->inout = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DropCastStmt: DROP CAST opt_if_exists '(' Typename AS Typename ')' opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_CAST;
n->objects = list_make1(list_make2($5, $7));
n->behavior = $9;
n->missing_ok = $3;
n->concurrent = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CreateTransformStmt: CREATE opt_or_replace TRANSFORM FOR Typename LANGUAGE name '(' transform_element_list ')'
{
CreateTransformStmt *n = makeNode(CreateTransformStmt);
+
n->replace = $2;
n->type_name = $5;
n->lang = $7;
n->fromsql = linitial($9);
n->tosql = lsecond($9);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DropTransformStmt: DROP TRANSFORM opt_if_exists FOR Typename LANGUAGE name opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
+
n->removeType = OBJECT_TRANSFORM;
n->objects = list_make1(list_make2($5, makeString($7)));
n->behavior = $8;
n->missing_ok = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
REINDEX reindex_target_type opt_concurrently qualified_name
{
ReindexStmt *n = makeNode(ReindexStmt);
+
n->kind = $2;
n->relation = $4;
n->name = NULL;
n->params = NIL;
if ($3)
n->params = lappend(n->params,
- makeDefElem("concurrently", NULL, @3));
- $$ = (Node *)n;
+ makeDefElem("concurrently", NULL, @3));
+ $$ = (Node *) n;
}
| REINDEX reindex_target_multitable opt_concurrently name
{
ReindexStmt *n = makeNode(ReindexStmt);
+
n->kind = $2;
n->name = $4;
n->relation = NULL;
n->params = NIL;
if ($3)
n->params = lappend(n->params,
- makeDefElem("concurrently", NULL, @3));
- $$ = (Node *)n;
+ makeDefElem("concurrently", NULL, @3));
+ $$ = (Node *) n;
}
| REINDEX '(' utility_option_list ')' reindex_target_type opt_concurrently qualified_name
{
ReindexStmt *n = makeNode(ReindexStmt);
+
n->kind = $5;
n->relation = $7;
n->name = NULL;
n->params = $3;
if ($6)
n->params = lappend(n->params,
- makeDefElem("concurrently", NULL, @6));
- $$ = (Node *)n;
+ makeDefElem("concurrently", NULL, @6));
+ $$ = (Node *) n;
}
| REINDEX '(' utility_option_list ')' reindex_target_multitable opt_concurrently name
{
ReindexStmt *n = makeNode(ReindexStmt);
+
n->kind = $5;
n->name = $7;
n->relation = NULL;
n->params = $3;
if ($6)
n->params = lappend(n->params,
- makeDefElem("concurrently", NULL, @6));
- $$ = (Node *)n;
+ makeDefElem("concurrently", NULL, @6));
+ $$ = (Node *) n;
}
;
reindex_target_type:
{
AlterTableSpaceOptionsStmt *n =
makeNode(AlterTableSpaceOptionsStmt);
+
n->tablespacename = $3;
n->options = $5;
n->isReset = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLESPACE name RESET reloptions
{
AlterTableSpaceOptionsStmt *n =
makeNode(AlterTableSpaceOptionsStmt);
+
n->tablespacename = $3;
n->options = $5;
n->isReset = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
RenameStmt: ALTER AGGREGATE aggregate_with_argtypes RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_AGGREGATE;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER COLLATION any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLLATION;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER CONVERSION_P any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_CONVERSION;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DATABASE name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_DATABASE;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DOMAIN_P any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_DOMAIN;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_DOMCONSTRAINT;
n->object = (Node *) $3;
n->subname = $6;
n->newname = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN DATA_P WRAPPER name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_FDW;
n->object = (Node *) makeString($5);
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FUNCTION function_with_argtypes RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_FUNCTION;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER GROUP_P RoleId RENAME TO RoleId
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_ROLE;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER opt_procedural LANGUAGE name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_LANGUAGE;
n->object = (Node *) makeString($4);
n->newname = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR CLASS any_name USING name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_OPCLASS;
n->object = (Node *) lcons(makeString($6), $4);
n->newname = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR FAMILY any_name USING name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_OPFAMILY;
n->object = (Node *) lcons(makeString($6), $4);
n->newname = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER POLICY name ON qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_POLICY;
n->relation = $5;
n->subname = $3;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_POLICY;
n->relation = $7;
n->subname = $5;
n->newname = $10;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PROCEDURE function_with_argtypes RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_PROCEDURE;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PUBLICATION name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_PUBLICATION;
n->object = (Node *) makeString($3);
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROUTINE function_with_argtypes RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_ROUTINE;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SCHEMA name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_SCHEMA;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SERVER name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_FOREIGN_SERVER;
n->object = (Node *) makeString($3);
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_SUBSCRIPTION;
n->object = (Node *) makeString($3);
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE relation_expr RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TABLE;
n->relation = $3;
n->subname = NULL;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TABLE;
n->relation = $5;
n->subname = NULL;
n->newname = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_SEQUENCE;
n->relation = $3;
n->subname = NULL;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_SEQUENCE;
n->relation = $5;
n->subname = NULL;
n->newname = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_VIEW;
n->relation = $3;
n->subname = NULL;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW IF_P EXISTS qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_VIEW;
n->relation = $5;
n->subname = NULL;
n->newname = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_MATVIEW;
n->relation = $4;
n->subname = NULL;
n->newname = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_MATVIEW;
n->relation = $6;
n->subname = NULL;
n->newname = $9;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_INDEX;
n->relation = $3;
n->subname = NULL;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX IF_P EXISTS qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_INDEX;
n->relation = $5;
n->subname = NULL;
n->newname = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE relation_expr RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_FOREIGN_TABLE;
n->relation = $4;
n->subname = NULL;
n->newname = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_FOREIGN_TABLE;
n->relation = $6;
n->subname = NULL;
n->newname = $9;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE relation_expr RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_TABLE;
n->relation = $3;
n->subname = $6;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_TABLE;
n->relation = $5;
n->subname = $8;
n->newname = $10;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW qualified_name RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_VIEW;
n->relation = $3;
n->subname = $6;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_VIEW;
n->relation = $5;
n->subname = $8;
n->newname = $10;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_MATVIEW;
n->relation = $4;
n->subname = $7;
n->newname = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_MATVIEW;
n->relation = $6;
n->subname = $9;
n->newname = $11;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE relation_expr RENAME CONSTRAINT name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TABCONSTRAINT;
n->relation = $3;
n->subname = $6;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TABCONSTRAINT;
n->relation = $5;
n->subname = $8;
n->newname = $10;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_FOREIGN_TABLE;
n->relation = $4;
n->subname = $7;
n->newname = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_COLUMN;
n->relationType = OBJECT_FOREIGN_TABLE;
n->relation = $6;
n->subname = $9;
n->newname = $11;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER RULE name ON qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_RULE;
n->relation = $5;
n->subname = $3;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TRIGGER name ON qualified_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TRIGGER;
n->relation = $5;
n->subname = $3;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EVENT TRIGGER name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_EVENT_TRIGGER;
n->object = (Node *) makeString($4);
n->newname = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROLE RoleId RENAME TO RoleId
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_ROLE;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER USER RoleId RENAME TO RoleId
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_ROLE;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLESPACE name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TABLESPACE;
n->subname = $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER STATISTICS any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_STATISTIC_EXT;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH PARSER any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TSPARSER;
n->object = (Node *) $5;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TSDICTIONARY;
n->object = (Node *) $5;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TSTEMPLATE;
n->object = (Node *) $5;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TSCONFIGURATION;
n->object = (Node *) $5;
n->newname = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TYPE_P any_name RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_TYPE;
n->object = (Node *) $3;
n->newname = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior
{
RenameStmt *n = makeNode(RenameStmt);
+
n->renameType = OBJECT_ATTRIBUTE;
n->relationType = OBJECT_TYPE;
n->relation = makeRangeVarFromAnyName($3, @3, yyscanner);
n->newname = $8;
n->behavior = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_FUNCTION;
n->object = (Node *) $3;
n->extname = makeString($8);
n->remove = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PROCEDURE function_with_argtypes opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_PROCEDURE;
n->object = (Node *) $3;
n->extname = makeString($8);
n->remove = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROUTINE function_with_argtypes opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_ROUTINE;
n->object = (Node *) $3;
n->extname = makeString($8);
n->remove = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_TRIGGER;
n->relation = $5;
n->object = (Node *) list_make1(makeString($3));
n->extname = makeString($10);
n->remove = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_MATVIEW;
n->relation = $4;
n->extname = makeString($9);
n->remove = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name
{
AlterObjectDependsStmt *n = makeNode(AlterObjectDependsStmt);
+
n->objectType = OBJECT_INDEX;
n->relation = $3;
n->extname = makeString($8);
n->remove = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_AGGREGATE;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER COLLATION any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_COLLATION;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER CONVERSION_P any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_CONVERSION;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DOMAIN_P any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_DOMAIN;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EXTENSION name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_EXTENSION;
n->object = (Node *) makeString($3);
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FUNCTION function_with_argtypes SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_FUNCTION;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR operator_with_argtypes SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_OPERATOR;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR CLASS any_name USING name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_OPCLASS;
n->object = (Node *) lcons(makeString($6), $4);
n->newschema = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_OPFAMILY;
n->object = (Node *) lcons(makeString($6), $4);
n->newschema = $9;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PROCEDURE function_with_argtypes SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_PROCEDURE;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROUTINE function_with_argtypes SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_ROUTINE;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE relation_expr SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TABLE;
n->relation = $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TABLE;
n->relation = $5;
n->newschema = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER STATISTICS any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_STATISTIC_EXT;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TSPARSER;
n->object = (Node *) $5;
n->newschema = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TSDICTIONARY;
n->object = (Node *) $5;
n->newschema = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TSTEMPLATE;
n->object = (Node *) $5;
n->newschema = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TSCONFIGURATION;
n->object = (Node *) $5;
n->newschema = $8;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_SEQUENCE;
n->relation = $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_SEQUENCE;
n->relation = $5;
n->newschema = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_VIEW;
n->relation = $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_VIEW;
n->relation = $5;
n->newschema = $8;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_MATVIEW;
n->relation = $4;
n->newschema = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_MATVIEW;
n->relation = $6;
n->newschema = $9;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE relation_expr SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_FOREIGN_TABLE;
n->relation = $4;
n->newschema = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_FOREIGN_TABLE;
n->relation = $6;
n->newschema = $9;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TYPE_P any_name SET SCHEMA name
{
AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+
n->objectType = OBJECT_TYPE;
n->object = (Node *) $3;
n->newschema = $6;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER OPERATOR operator_with_argtypes SET '(' operator_def_list ')'
{
AlterOperatorStmt *n = makeNode(AlterOperatorStmt);
+
n->opername = $3;
n->options = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
/* must be similar enough to def_arg to avoid reduce/reduce conflicts */
operator_def_arg:
- func_type { $$ = (Node *)$1; }
- | reserved_keyword { $$ = (Node *)makeString(pstrdup($1)); }
- | qual_all_Op { $$ = (Node *)$1; }
- | NumericOnly { $$ = (Node *)$1; }
- | Sconst { $$ = (Node *)makeString($1); }
+ func_type { $$ = (Node *) $1; }
+ | reserved_keyword { $$ = (Node *) makeString(pstrdup($1)); }
+ | qual_all_Op { $$ = (Node *) $1; }
+ | NumericOnly { $$ = (Node *) $1; }
+ | Sconst { $$ = (Node *) makeString($1); }
;
/*****************************************************************************
ALTER TYPE_P any_name SET '(' operator_def_list ')'
{
AlterTypeStmt *n = makeNode(AlterTypeStmt);
+
n->typeName = $3;
n->options = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
AlterOwnerStmt: ALTER AGGREGATE aggregate_with_argtypes OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_AGGREGATE;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER COLLATION any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_COLLATION;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER CONVERSION_P any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_CONVERSION;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DATABASE name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_DATABASE;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DOMAIN_P any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_DOMAIN;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FUNCTION function_with_argtypes OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_FUNCTION;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER opt_procedural LANGUAGE name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_LANGUAGE;
n->object = (Node *) makeString($4);
n->newowner = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER LARGE_P OBJECT_P NumericOnly OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_LARGEOBJECT;
n->object = (Node *) $4;
n->newowner = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR operator_with_argtypes OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_OPERATOR;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR CLASS any_name USING name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_OPCLASS;
n->object = (Node *) lcons(makeString($6), $4);
n->newowner = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER OPERATOR FAMILY any_name USING name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_OPFAMILY;
n->object = (Node *) lcons(makeString($6), $4);
n->newowner = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PROCEDURE function_with_argtypes OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_PROCEDURE;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER ROUTINE function_with_argtypes OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_ROUTINE;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SCHEMA name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_SCHEMA;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TYPE_P any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_TYPE;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TABLESPACE name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_TABLESPACE;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER STATISTICS any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_STATISTIC_EXT;
n->object = (Node *) $3;
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_TSDICTIONARY;
n->object = (Node *) $5;
n->newowner = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_TSCONFIGURATION;
n->object = (Node *) $5;
n->newowner = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_FDW;
n->object = (Node *) makeString($5);
n->newowner = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SERVER name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_FOREIGN_SERVER;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER EVENT TRIGGER name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_EVENT_TRIGGER;
n->object = (Node *) makeString($4);
n->newowner = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PUBLICATION name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_PUBLICATION;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name OWNER TO RoleSpec
{
AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+
n->objectType = OBJECT_SUBSCRIPTION;
n->object = (Node *) makeString($3);
n->newowner = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE PUBLICATION name opt_definition
{
CreatePublicationStmt *n = makeNode(CreatePublicationStmt);
+
n->pubname = $3;
n->options = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE PUBLICATION name FOR ALL TABLES opt_definition
{
CreatePublicationStmt *n = makeNode(CreatePublicationStmt);
+
n->pubname = $3;
n->options = $7;
n->for_all_tables = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| CREATE PUBLICATION name FOR pub_obj_list opt_definition
{
CreatePublicationStmt *n = makeNode(CreatePublicationStmt);
+
n->pubname = $3;
n->options = $6;
- n->pubobjects = (List *)$5;
+ n->pubobjects = (List *) $5;
preprocess_pubobj_list(n->pubobjects, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
}
;
-pub_obj_list: PublicationObjSpec
+pub_obj_list: PublicationObjSpec
{ $$ = list_make1($1); }
| pub_obj_list ',' PublicationObjSpec
{ $$ = lappend($1, $3); }
ALTER PUBLICATION name SET definition
{
AlterPublicationStmt *n = makeNode(AlterPublicationStmt);
+
n->pubname = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PUBLICATION name ADD_P pub_obj_list
{
AlterPublicationStmt *n = makeNode(AlterPublicationStmt);
+
n->pubname = $3;
n->pubobjects = $5;
preprocess_pubobj_list(n->pubobjects, yyscanner);
n->action = AP_AddObjects;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PUBLICATION name SET pub_obj_list
{
AlterPublicationStmt *n = makeNode(AlterPublicationStmt);
+
n->pubname = $3;
n->pubobjects = $5;
preprocess_pubobj_list(n->pubobjects, yyscanner);
n->action = AP_SetObjects;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER PUBLICATION name DROP pub_obj_list
{
AlterPublicationStmt *n = makeNode(AlterPublicationStmt);
+
n->pubname = $3;
n->pubobjects = $5;
preprocess_pubobj_list(n->pubobjects, yyscanner);
n->action = AP_DropObjects;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
n->conninfo = $5;
n->publication = $7;
n->options = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_OPTIONS;
n->subname = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name CONNECTION Sconst
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_CONNECTION;
n->subname = $3;
n->conninfo = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_REFRESH;
n->subname = $3;
n->options = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name ADD_P PUBLICATION name_list opt_definition
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_ADD_PUBLICATION;
n->subname = $3;
n->publication = $6;
n->options = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name DROP PUBLICATION name_list opt_definition
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_DROP_PUBLICATION;
n->subname = $3;
n->publication = $6;
n->options = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name SET PUBLICATION name_list opt_definition
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_SET_PUBLICATION;
n->subname = $3;
n->publication = $6;
n->options = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name ENABLE_P
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_ENABLED;
n->subname = $3;
n->options = list_make1(makeDefElem("enabled",
- (Node *)makeBoolean(true), @1));
- $$ = (Node *)n;
+ (Node *) makeBoolean(true), @1));
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name DISABLE_P
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_ENABLED;
n->subname = $3;
n->options = list_make1(makeDefElem("enabled",
- (Node *)makeBoolean(false), @1));
- $$ = (Node *)n;
+ (Node *) makeBoolean(false), @1));
+ $$ = (Node *) n;
}
| ALTER SUBSCRIPTION name SKIP definition
{
AlterSubscriptionStmt *n =
makeNode(AlterSubscriptionStmt);
+
n->kind = ALTER_SUBSCRIPTION_SKIP;
n->subname = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DropSubscriptionStmt: DROP SUBSCRIPTION name opt_drop_behavior
{
DropSubscriptionStmt *n = makeNode(DropSubscriptionStmt);
+
n->subname = $3;
n->missing_ok = false;
n->behavior = $4;
| DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior
{
DropSubscriptionStmt *n = makeNode(DropSubscriptionStmt);
+
n->subname = $5;
n->missing_ok = true;
n->behavior = $6;
ON event TO qualified_name where_clause
DO opt_instead RuleActionList
{
- RuleStmt *n = makeNode(RuleStmt);
+ RuleStmt *n = makeNode(RuleStmt);
+
n->replace = $2;
n->relation = $9;
n->rulename = $4;
n->event = $7;
n->instead = $12;
n->actions = $13;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
NotifyStmt: NOTIFY ColId notify_payload
{
NotifyStmt *n = makeNode(NotifyStmt);
+
n->conditionname = $2;
n->payload = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ListenStmt: LISTEN ColId
{
ListenStmt *n = makeNode(ListenStmt);
+
n->conditionname = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
UNLISTEN ColId
{
UnlistenStmt *n = makeNode(UnlistenStmt);
+
n->conditionname = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| UNLISTEN '*'
{
UnlistenStmt *n = makeNode(UnlistenStmt);
+
n->conditionname = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ABORT_P opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_ROLLBACK;
n->options = NIL;
n->chain = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| START TRANSACTION transaction_mode_list_or_empty
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_START;
n->options = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| COMMIT opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_COMMIT;
n->options = NIL;
n->chain = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ROLLBACK opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_ROLLBACK;
n->options = NIL;
n->chain = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| SAVEPOINT ColId
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_SAVEPOINT;
n->savepoint_name = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| RELEASE SAVEPOINT ColId
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_RELEASE;
n->savepoint_name = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| RELEASE ColId
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_RELEASE;
n->savepoint_name = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ROLLBACK opt_transaction TO SAVEPOINT ColId
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_ROLLBACK_TO;
n->savepoint_name = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ROLLBACK opt_transaction TO ColId
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_ROLLBACK_TO;
n->savepoint_name = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| PREPARE TRANSACTION Sconst
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_PREPARE;
n->gid = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| COMMIT PREPARED Sconst
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_COMMIT_PREPARED;
n->gid = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ROLLBACK PREPARED Sconst
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_ROLLBACK_PREPARED;
n->gid = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
BEGIN_P opt_transaction transaction_mode_list_or_empty
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_BEGIN;
n->options = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| END_P opt_transaction opt_transaction_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
+
n->kind = TRANS_STMT_COMMIT;
n->options = NIL;
n->chain = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ViewStmt: CREATE OptTemp VIEW qualified_name opt_column_list opt_reloptions
AS SelectStmt opt_check_option
{
- ViewStmt *n = makeNode(ViewStmt);
+ ViewStmt *n = makeNode(ViewStmt);
+
n->view = $4;
n->view->relpersistence = $2;
n->aliases = $5;
| CREATE OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions
AS SelectStmt opt_check_option
{
- ViewStmt *n = makeNode(ViewStmt);
+ ViewStmt *n = makeNode(ViewStmt);
+
n->view = $6;
n->view->relpersistence = $4;
n->aliases = $7;
| CREATE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions
AS SelectStmt opt_check_option
{
- ViewStmt *n = makeNode(ViewStmt);
+ ViewStmt *n = makeNode(ViewStmt);
+
n->view = $5;
n->view->relpersistence = $2;
n->aliases = $7;
| CREATE OR REPLACE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions
AS SelectStmt opt_check_option
{
- ViewStmt *n = makeNode(ViewStmt);
+ ViewStmt *n = makeNode(ViewStmt);
+
n->view = $7;
n->view->relpersistence = $4;
n->aliases = $9;
LoadStmt: LOAD file_name
{
- LoadStmt *n = makeNode(LoadStmt);
+ LoadStmt *n = makeNode(LoadStmt);
+
n->filename = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE DATABASE name opt_with createdb_opt_list
{
CreatedbStmt *n = makeNode(CreatedbStmt);
+
n->dbname = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
createdb_opt_item:
createdb_opt_name opt_equal SignedIconst
{
- $$ = makeDefElem($1, (Node *)makeInteger($3), @1);
+ $$ = makeDefElem($1, (Node *) makeInteger($3), @1);
}
| createdb_opt_name opt_equal opt_boolean_or_string
{
- $$ = makeDefElem($1, (Node *)makeString($3), @1);
+ $$ = makeDefElem($1, (Node *) makeString($3), @1);
}
| createdb_opt_name opt_equal DEFAULT
{
ALTER DATABASE name WITH createdb_opt_list
{
AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
+
n->dbname = $3;
n->options = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DATABASE name createdb_opt_list
{
AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
+
n->dbname = $3;
n->options = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER DATABASE name SET TABLESPACE name
{
AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
+
n->dbname = $3;
n->options = list_make1(makeDefElem("tablespace",
- (Node *)makeString($6), @6));
- $$ = (Node *)n;
+ (Node *) makeString($6), @6));
+ $$ = (Node *) n;
}
| ALTER DATABASE name REFRESH COLLATION VERSION_P
{
AlterDatabaseRefreshCollStmt *n = makeNode(AlterDatabaseRefreshCollStmt);
+
n->dbname = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER DATABASE name SetResetClause
{
AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
+
n->dbname = $3;
n->setstmt = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
DropdbStmt: DROP DATABASE name
{
DropdbStmt *n = makeNode(DropdbStmt);
+
n->dbname = $3;
n->missing_ok = false;
n->options = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP DATABASE IF_P EXISTS name
{
DropdbStmt *n = makeNode(DropdbStmt);
+
n->dbname = $5;
n->missing_ok = true;
n->options = NULL;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP DATABASE name opt_with '(' drop_option_list ')'
{
DropdbStmt *n = makeNode(DropdbStmt);
+
n->dbname = $3;
n->missing_ok = false;
n->options = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| DROP DATABASE IF_P EXISTS name opt_with '(' drop_option_list ')'
{
DropdbStmt *n = makeNode(DropdbStmt);
+
n->dbname = $5;
n->missing_ok = true;
n->options = $8;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
AlterCollationStmt: ALTER COLLATION any_name REFRESH VERSION_P
{
AlterCollationStmt *n = makeNode(AlterCollationStmt);
+
n->collname = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER SYSTEM_P SET generic_set
{
AlterSystemStmt *n = makeNode(AlterSystemStmt);
+
n->setstmt = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ALTER SYSTEM_P RESET generic_reset
{
AlterSystemStmt *n = makeNode(AlterSystemStmt);
+
n->setstmt = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CREATE DOMAIN_P any_name opt_as Typename ColQualList
{
CreateDomainStmt *n = makeNode(CreateDomainStmt);
+
n->domainname = $3;
n->typeName = $5;
SplitColQualList($6, &n->constraints, &n->collClause,
yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER DOMAIN_P any_name alter_column_default
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'T';
n->typeName = $3;
n->def = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN DROP NOT NULL */
| ALTER DOMAIN_P any_name DROP NOT NULL_P
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'N';
n->typeName = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN SET NOT NULL */
| ALTER DOMAIN_P any_name SET NOT NULL_P
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'O';
n->typeName = $3;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN ADD CONSTRAINT ... */
| ALTER DOMAIN_P any_name ADD_P TableConstraint
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'C';
n->typeName = $3;
n->def = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN DROP CONSTRAINT [RESTRICT|CASCADE] */
| ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'X';
n->typeName = $3;
n->name = $6;
n->behavior = $7;
n->missing_ok = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN DROP CONSTRAINT IF EXISTS [RESTRICT|CASCADE] */
| ALTER DOMAIN_P any_name DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'X';
n->typeName = $3;
n->name = $8;
n->behavior = $9;
n->missing_ok = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
/* ALTER DOMAIN VALIDATE CONSTRAINT */
| ALTER DOMAIN_P any_name VALIDATE CONSTRAINT name
{
AlterDomainStmt *n = makeNode(AlterDomainStmt);
+
n->subtype = 'V';
n->typeName = $3;
n->name = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER TEXT_P SEARCH DICTIONARY any_name definition
{
AlterTSDictionaryStmt *n = makeNode(AlterTSDictionaryStmt);
+
n->dictname = $5;
n->options = $6;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_ADD_MAPPING;
n->cfgname = $5;
n->tokentype = $9;
n->dicts = $11;
n->override = false;
n->replace = false;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN;
n->cfgname = $5;
n->tokentype = $9;
n->dicts = $11;
n->override = true;
n->replace = false;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_REPLACE_DICT;
n->cfgname = $5;
n->tokentype = NIL;
n->dicts = list_make2($9,$11);
n->override = false;
n->replace = true;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN;
n->cfgname = $5;
n->tokentype = $9;
n->dicts = list_make2($11,$13);
n->override = false;
n->replace = true;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_DROP_MAPPING;
n->cfgname = $5;
n->tokentype = $9;
n->missing_ok = false;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
+
n->kind = ALTER_TSCONFIG_DROP_MAPPING;
n->cfgname = $5;
n->tokentype = $11;
n->missing_ok = true;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
TO Sconst FROM any_name
{
CreateConversionStmt *n = makeNode(CreateConversionStmt);
+
n->conversion_name = $4;
n->for_encoding_name = $6;
n->to_encoding_name = $8;
n->func_name = $10;
n->def = $2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
CLUSTER opt_verbose qualified_name cluster_index_specification
{
ClusterStmt *n = makeNode(ClusterStmt);
+
n->relation = $3;
n->indexname = $4;
n->params = NIL;
if ($2)
n->params = lappend(n->params, makeDefElem("verbose", NULL, @2));
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| CLUSTER '(' utility_option_list ')' qualified_name cluster_index_specification
{
ClusterStmt *n = makeNode(ClusterStmt);
+
n->relation = $5;
n->indexname = $6;
n->params = $3;
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
| CLUSTER opt_verbose
{
ClusterStmt *n = makeNode(ClusterStmt);
+
n->relation = NULL;
n->indexname = NULL;
n->params = NIL;
if ($2)
n->params = lappend(n->params, makeDefElem("verbose", NULL, @2));
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
/* kept for pre-8.3 compatibility */
| CLUSTER opt_verbose name ON qualified_name
{
ClusterStmt *n = makeNode(ClusterStmt);
+
n->relation = $5;
n->indexname = $3;
n->params = NIL;
if ($2)
n->params = lappend(n->params, makeDefElem("verbose", NULL, @2));
- $$ = (Node*)n;
+ $$ = (Node *) n;
}
;
VacuumStmt: VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list
{
VacuumStmt *n = makeNode(VacuumStmt);
+
n->options = NIL;
if ($2)
n->options = lappend(n->options,
makeDefElem("analyze", NULL, @5));
n->rels = $6;
n->is_vacuumcmd = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| VACUUM '(' utility_option_list ')' opt_vacuum_relation_list
{
VacuumStmt *n = makeNode(VacuumStmt);
+
n->options = $3;
n->rels = $5;
n->is_vacuumcmd = true;
AnalyzeStmt: analyze_keyword opt_verbose opt_vacuum_relation_list
{
VacuumStmt *n = makeNode(VacuumStmt);
+
n->options = NIL;
if ($2)
n->options = lappend(n->options,
makeDefElem("verbose", NULL, @2));
n->rels = $3;
n->is_vacuumcmd = false;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| analyze_keyword '(' utility_option_list ')' opt_vacuum_relation_list
{
VacuumStmt *n = makeNode(VacuumStmt);
+
n->options = $3;
n->rels = $5;
n->is_vacuumcmd = false;
EXPLAIN ExplainableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
+
n->query = $2;
n->options = NIL;
$$ = (Node *) n;
| EXPLAIN analyze_keyword opt_verbose ExplainableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
+
n->query = $4;
n->options = list_make1(makeDefElem("analyze", NULL, @2));
if ($3)
| EXPLAIN VERBOSE ExplainableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
+
n->query = $3;
n->options = list_make1(makeDefElem("verbose", NULL, @2));
$$ = (Node *) n;
| EXPLAIN '(' utility_option_list ')' ExplainableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
+
n->query = $5;
n->options = $3;
$$ = (Node *) n;
PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt
{
PrepareStmt *n = makeNode(PrepareStmt);
+
n->name = $2;
n->argtypes = $3;
n->query = $5;
ExecuteStmt: EXECUTE name execute_param_clause
{
ExecuteStmt *n = makeNode(ExecuteStmt);
+
n->name = $2;
n->params = $3;
$$ = (Node *) n;
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
ExecuteStmt *n = makeNode(ExecuteStmt);
+
n->name = $7;
n->params = $8;
ctas->query = (Node *) n;
{
CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
ExecuteStmt *n = makeNode(ExecuteStmt);
+
n->name = $10;
n->params = $11;
ctas->query = (Node *) n;
DeallocateStmt: DEALLOCATE name
{
DeallocateStmt *n = makeNode(DeallocateStmt);
+
n->name = $2;
$$ = (Node *) n;
}
| DEALLOCATE PREPARE name
{
DeallocateStmt *n = makeNode(DeallocateStmt);
+
n->name = $3;
$$ = (Node *) n;
}
| DEALLOCATE ALL
{
DeallocateStmt *n = makeNode(DeallocateStmt);
+
n->name = NULL;
$$ = (Node *) n;
}
| DEALLOCATE PREPARE ALL
{
DeallocateStmt *n = makeNode(DeallocateStmt);
+
n->name = NULL;
$$ = (Node *) n;
}
using_clause where_or_current_clause returning_clause
{
DeleteStmt *n = makeNode(DeleteStmt);
+
n->relation = $4;
n->usingClause = $5;
n->whereClause = $6;
n->returningList = $7;
n->withClause = $1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
LockStmt: LOCK_P opt_table relation_expr_list opt_lock opt_nowait
{
- LockStmt *n = makeNode(LockStmt);
+ LockStmt *n = makeNode(LockStmt);
n->relations = $3;
n->mode = $4;
n->nowait = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
returning_clause
{
UpdateStmt *n = makeNode(UpdateStmt);
+
n->relation = $3;
n->targetList = $5;
n->fromClause = $6;
n->whereClause = $7;
n->returningList = $8;
n->withClause = $1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
}
| '(' set_target_list ')' '=' a_expr
{
- int ncolumns = list_length($2);
- int i = 1;
- ListCell *col_cell;
+ int ncolumns = list_length($2);
+ int i = 1;
+ ListCell *col_cell;
/* Create a MultiAssignRef source for each target */
foreach(col_cell, $2)
{
- ResTarget *res_col = (ResTarget *) lfirst(col_cell);
+ ResTarget *res_col = (ResTarget *) lfirst(col_cell);
MultiAssignRef *r = makeNode(MultiAssignRef);
r->source = (Node *) $5;
ON a_expr
merge_when_list
{
- MergeStmt *m = makeNode(MergeStmt);
+ MergeStmt *m = makeNode(MergeStmt);
m->withClause = $1;
m->relation = $4;
m->joinCondition = $8;
m->mergeWhenClauses = $9;
- $$ = (Node *)m;
+ $$ = (Node *) m;
}
;
m->commandType = CMD_NOTHING;
m->condition = $3;
- $$ = (Node *)m;
+ $$ = (Node *) m;
}
| WHEN NOT MATCHED opt_merge_when_condition THEN DO NOTHING
{
m->commandType = CMD_NOTHING;
m->condition = $4;
- $$ = (Node *)m;
+ $$ = (Node *) m;
}
;
DeclareCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR SelectStmt
{
DeclareCursorStmt *n = makeNode(DeclareCursorStmt);
+
n->portalname = $2;
/* currently we always set FAST_PLAN option */
n->options = $3 | $5 | CURSOR_OPT_FAST_PLAN;
n->query = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
group_clause having_clause window_clause
{
SelectStmt *n = makeNode(SelectStmt);
+
n->targetList = $3;
n->intoClause = $4;
n->fromClause = $5;
n->groupDistinct = ($7)->distinct;
n->havingClause = $8;
n->windowClause = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| SELECT distinct_clause target_list
into_clause from_clause where_clause
group_clause having_clause window_clause
{
SelectStmt *n = makeNode(SelectStmt);
+
n->distinctClause = $2;
n->targetList = $3;
n->intoClause = $4;
n->groupDistinct = ($7)->distinct;
n->havingClause = $8;
n->windowClause = $9;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| values_clause { $$ = $1; }
| TABLE relation_expr
{
/* same as SELECT * FROM relation_expr */
- ColumnRef *cr = makeNode(ColumnRef);
- ResTarget *rt = makeNode(ResTarget);
+ ColumnRef *cr = makeNode(ColumnRef);
+ ResTarget *rt = makeNode(ResTarget);
SelectStmt *n = makeNode(SelectStmt);
cr->fields = list_make1(makeNode(A_Star));
rt->name = NULL;
rt->indirection = NIL;
- rt->val = (Node *)cr;
+ rt->val = (Node *) cr;
rt->location = -1;
n->targetList = list_make1(rt);
n->fromClause = list_make1($2);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| select_clause UNION set_quantifier select_clause
{
common_table_expr: name opt_name_list AS opt_materialized '(' PreparableStmt ')' opt_search_clause opt_cycle_clause
{
CommonTableExpr *n = makeNode(CommonTableExpr);
+
n->ctename = $1;
n->aliascolnames = $2;
n->ctematerialized = $4;
SEARCH DEPTH FIRST_P BY columnList SET ColId
{
CTESearchClause *n = makeNode(CTESearchClause);
+
n->search_col_list = $5;
n->search_breadth_first = false;
n->search_seq_column = $7;
| SEARCH BREADTH FIRST_P BY columnList SET ColId
{
CTESearchClause *n = makeNode(CTESearchClause);
+
n->search_col_list = $5;
n->search_breadth_first = true;
n->search_seq_column = $7;
CYCLE columnList SET ColId TO AexprConst DEFAULT AexprConst USING ColId
{
CTECycleClause *n = makeNode(CTECycleClause);
+
n->cycle_col_list = $2;
n->cycle_mark_column = $4;
n->cycle_mark_value = $6;
| CYCLE columnList SET ColId USING ColId
{
CTECycleClause *n = makeNode(CTECycleClause);
+
n->cycle_col_list = $2;
n->cycle_mark_column = $4;
n->cycle_mark_value = makeBoolAConst(true, -1);
| offset_clause
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = $1;
n->limitCount = NULL;
n->limitOption = LIMIT_OPTION_COUNT;
LIMIT select_limit_value
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = NULL;
n->limitCount = $2;
n->limitOption = LIMIT_OPTION_COUNT;
| FETCH first_or_next select_fetch_first_value row_or_rows ONLY
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = NULL;
n->limitCount = $3;
n->limitOption = LIMIT_OPTION_COUNT;
| FETCH first_or_next select_fetch_first_value row_or_rows WITH TIES
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = NULL;
n->limitCount = $3;
n->limitOption = LIMIT_OPTION_WITH_TIES;
| FETCH first_or_next row_or_rows ONLY
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = NULL;
n->limitCount = makeIntConst(1, -1);
n->limitOption = LIMIT_OPTION_COUNT;
| FETCH first_or_next row_or_rows WITH TIES
{
SelectLimit *n = (SelectLimit *) palloc(sizeof(SelectLimit));
+
n->limitOffset = NULL;
n->limitCount = makeIntConst(1, -1);
n->limitOption = LIMIT_OPTION_WITH_TIES;
GROUP_P BY set_quantifier group_by_list
{
GroupClause *n = (GroupClause *) palloc(sizeof(GroupClause));
+
n->distinct = $3 == SET_QUANTIFIER_DISTINCT;
n->list = $4;
$$ = n;
| /*EMPTY*/
{
GroupClause *n = (GroupClause *) palloc(sizeof(GroupClause));
+
n->distinct = false;
n->list = NIL;
$$ = n;
for_locking_strength locked_rels_list opt_nowait_or_skip
{
LockingClause *n = makeNode(LockingClause);
+
n->lockedRels = $2;
n->strength = $1;
n->waitPolicy = $3;
VALUES '(' expr_list ')'
{
SelectStmt *n = makeNode(SelectStmt);
+
n->valuesLists = list_make1($3);
$$ = (Node *) n;
}
| values_clause ',' '(' expr_list ')'
{
SelectStmt *n = (SelectStmt *) $1;
+
n->valuesLists = lappend(n->valuesLists, $4);
$$ = (Node *) n;
}
| relation_expr opt_alias_clause tablesample_clause
{
RangeTableSample *n = (RangeTableSample *) $3;
+
$1->alias = $2;
/* relation_expr goes inside the RangeTableSample node */
n->relation = (Node *) $1;
| func_table func_alias_clause
{
RangeFunction *n = (RangeFunction *) $1;
+
n->alias = linitial($2);
n->coldeflist = lsecond($2);
$$ = (Node *) n;
| LATERAL_P func_table func_alias_clause
{
RangeFunction *n = (RangeFunction *) $2;
+
n->lateral = true;
n->alias = linitial($3);
n->coldeflist = lsecond($3);
| xmltable opt_alias_clause
{
RangeTableFunc *n = (RangeTableFunc *) $1;
+
n->alias = $2;
$$ = (Node *) n;
}
| LATERAL_P xmltable opt_alias_clause
{
RangeTableFunc *n = (RangeTableFunc *) $2;
+
n->lateral = true;
n->alias = $3;
$$ = (Node *) n;
| select_with_parens opt_alias_clause
{
RangeSubselect *n = makeNode(RangeSubselect);
+
n->lateral = false;
n->subquery = $1;
n->alias = $2;
| LATERAL_P select_with_parens opt_alias_clause
{
RangeSubselect *n = makeNode(RangeSubselect);
+
n->lateral = true;
n->subquery = $2;
n->alias = $3;
}
| json_table opt_alias_clause
{
- JsonTable *jt = castNode(JsonTable, $1);
+ JsonTable *jt = castNode(JsonTable, $1);
+
jt->alias = $2;
$$ = (Node *) jt;
}
| LATERAL_P json_table opt_alias_clause
{
- JsonTable *jt = castNode(JsonTable, $2);
+ JsonTable *jt = castNode(JsonTable, $2);
+
jt->alias = $3;
jt->lateral = true;
$$ = (Node *) jt;
| table_ref CROSS JOIN table_ref
{
/* CROSS JOIN is same as unqualified inner join */
- JoinExpr *n = makeNode(JoinExpr);
+ JoinExpr *n = makeNode(JoinExpr);
+
n->jointype = JOIN_INNER;
n->isNatural = false;
n->larg = $1;
}
| table_ref join_type JOIN table_ref join_qual
{
- JoinExpr *n = makeNode(JoinExpr);
+ JoinExpr *n = makeNode(JoinExpr);
+
n->jointype = $2;
n->isNatural = false;
n->larg = $1;
| table_ref JOIN table_ref join_qual
{
/* letting join_type reduce to empty doesn't work */
- JoinExpr *n = makeNode(JoinExpr);
+ JoinExpr *n = makeNode(JoinExpr);
+
n->jointype = JOIN_INNER;
n->isNatural = false;
n->larg = $1;
}
| table_ref NATURAL join_type JOIN table_ref
{
- JoinExpr *n = makeNode(JoinExpr);
+ JoinExpr *n = makeNode(JoinExpr);
+
n->jointype = $3;
n->isNatural = true;
n->larg = $1;
| table_ref NATURAL JOIN table_ref
{
/* letting join_type reduce to empty doesn't work */
- JoinExpr *n = makeNode(JoinExpr);
+ JoinExpr *n = makeNode(JoinExpr);
+
n->jointype = JOIN_INNER;
n->isNatural = true;
n->larg = $1;
}
| AS ColId '(' TableFuncElementList ')'
{
- Alias *a = makeNode(Alias);
+ Alias *a = makeNode(Alias);
+
a->aliasname = $2;
$$ = list_make2(a, $4);
}
| ColId '(' TableFuncElementList ')'
{
- Alias *a = makeNode(Alias);
+ Alias *a = makeNode(Alias);
+
a->aliasname = $1;
$$ = list_make2(a, $3);
}
}
| relation_expr ColId
{
- Alias *alias = makeNode(Alias);
+ Alias *alias = makeNode(Alias);
+
alias->aliasname = $2;
$1->alias = alias;
$$ = $1;
}
| relation_expr AS ColId
{
- Alias *alias = makeNode(Alias);
+ Alias *alias = makeNode(Alias);
+
alias->aliasname = $3;
$1->alias = alias;
$$ = $1;
TABLESAMPLE func_name '(' expr_list ')' opt_repeatable_clause
{
RangeTableSample *n = makeNode(RangeTableSample);
+
/* n->relation will be filled in later */
n->method = $2;
n->args = $4;
func_table: func_expr_windowless opt_ordinality
{
RangeFunction *n = makeNode(RangeFunction);
+
n->lateral = false;
n->ordinality = $2;
n->is_rowsfrom = false;
| ROWS FROM '(' rowsfrom_list ')' opt_ordinality
{
RangeFunction *n = makeNode(RangeFunction);
+
n->lateral = false;
n->ordinality = $6;
n->is_rowsfrom = true;
| WHERE CURRENT_P OF cursor_name
{
CurrentOfExpr *n = makeNode(CurrentOfExpr);
+
/* cvarno is filled in by parse analysis */
n->cursor_name = $4;
n->cursor_param = 0;
TableFuncElement: ColId Typename opt_collate_clause
{
ColumnDef *n = makeNode(ColumnDef);
+
n->colname = $1;
n->typeName = $2;
n->inhcount = 0;
n->collOid = InvalidOid;
n->constraints = NIL;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
XMLTABLE '(' c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
{
RangeTableFunc *n = makeNode(RangeTableFunc);
+
n->rowexpr = $3;
n->docexpr = $4;
n->columns = $6;
n->namespaces = NIL;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| XMLTABLE '(' XMLNAMESPACES '(' xml_namespace_list ')' ','
c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
{
RangeTableFunc *n = makeNode(RangeTableFunc);
+
n->rowexpr = $8;
n->docexpr = $9;
n->columns = $11;
n->namespaces = $5;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
xmltable_column_el:
ColId Typename
{
- RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
+ RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
fc->colname = $1;
fc->for_ordinality = false;
}
| ColId Typename xmltable_column_option_list
{
- RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
- ListCell *option;
- bool nullability_seen = false;
+ RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
+ ListCell *option;
+ bool nullability_seen = false;
fc->colname = $1;
fc->typeName = $2;
}
| ColId FOR ORDINALITY
{
- RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
+ RangeTableFuncCol *fc = makeNode(RangeTableFuncCol);
fc->colname = $1;
fc->for_ordinality = true;
| a_expr COLLATE any_name
{
CollateClause *n = makeNode(CollateClause);
+
n->arg = $1;
n->collname = $3;
n->location = @2;
}
| a_expr LIKE a_expr ESCAPE a_expr %prec LIKE
{
- FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
- list_make2($3, $5),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
+ list_make2($3, $5),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_LIKE, "~~",
$1, (Node *) n, @2);
}
}
| a_expr NOT_LA LIKE a_expr ESCAPE a_expr %prec NOT_LA
{
- FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
- list_make2($4, $6),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
+ list_make2($4, $6),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_LIKE, "!~~",
$1, (Node *) n, @2);
}
}
| a_expr ILIKE a_expr ESCAPE a_expr %prec ILIKE
{
- FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
- list_make2($3, $5),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
+ list_make2($3, $5),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_ILIKE, "~~*",
$1, (Node *) n, @2);
}
}
| a_expr NOT_LA ILIKE a_expr ESCAPE a_expr %prec NOT_LA
{
- FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
- list_make2($4, $6),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
+ list_make2($4, $6),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_ILIKE, "!~~*",
$1, (Node *) n, @2);
}
| a_expr SIMILAR TO a_expr %prec SIMILAR
{
- FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
- list_make1($4),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
+ list_make1($4),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_SIMILAR, "~",
$1, (Node *) n, @2);
}
| a_expr SIMILAR TO a_expr ESCAPE a_expr %prec SIMILAR
{
- FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
- list_make2($4, $6),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
+ list_make2($4, $6),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_SIMILAR, "~",
$1, (Node *) n, @2);
}
| a_expr NOT_LA SIMILAR TO a_expr %prec NOT_LA
{
- FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
- list_make1($5),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
+ list_make1($5),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_SIMILAR, "!~",
$1, (Node *) n, @2);
}
| a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr %prec NOT_LA
{
- FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
- list_make2($5, $7),
- COERCE_EXPLICIT_CALL,
- @2);
+ FuncCall *n = makeFuncCall(SystemFuncName("similar_to_escape"),
+ list_make2($5, $7),
+ COERCE_EXPLICIT_CALL,
+ @2);
$$ = (Node *) makeSimpleA_Expr(AEXPR_SIMILAR, "!~",
$1, (Node *) n, @2);
}
*/
| a_expr IS NULL_P %prec IS
{
- NullTest *n = makeNode(NullTest);
+ NullTest *n = makeNode(NullTest);
+
n->arg = (Expr *) $1;
n->nulltesttype = IS_NULL;
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| a_expr ISNULL
{
- NullTest *n = makeNode(NullTest);
+ NullTest *n = makeNode(NullTest);
+
n->arg = (Expr *) $1;
n->nulltesttype = IS_NULL;
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| a_expr IS NOT NULL_P %prec IS
{
- NullTest *n = makeNode(NullTest);
+ NullTest *n = makeNode(NullTest);
+
n->arg = (Expr *) $1;
n->nulltesttype = IS_NOT_NULL;
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| a_expr NOTNULL
{
- NullTest *n = makeNode(NullTest);
+ NullTest *n = makeNode(NullTest);
+
n->arg = (Expr *) $1;
n->nulltesttype = IS_NOT_NULL;
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| row OVERLAPS row
{
| a_expr IS TRUE_P %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_TRUE;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS NOT TRUE_P %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_NOT_TRUE;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS FALSE_P %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_FALSE;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS NOT FALSE_P %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_NOT_FALSE;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS UNKNOWN %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_UNKNOWN;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS NOT UNKNOWN %prec IS
{
BooleanTest *b = makeNode(BooleanTest);
+
b->arg = (Expr *) $1;
b->booltesttype = IS_NOT_UNKNOWN;
b->location = @2;
- $$ = (Node *)b;
+ $$ = (Node *) b;
}
| a_expr IS DISTINCT FROM a_expr %prec IS
{
if (IsA($3, SubLink))
{
/* generate foo = ANY (subquery) */
- SubLink *n = (SubLink *) $3;
+ SubLink *n = (SubLink *) $3;
+
n->subLinkType = ANY_SUBLINK;
n->subLinkId = 0;
n->testexpr = $1;
n->operName = NIL; /* show it's IN not = ANY */
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
else
{
{
/* generate NOT (foo = ANY (subquery)) */
/* Make an = ANY node */
- SubLink *n = (SubLink *) $4;
+ SubLink *n = (SubLink *) $4;
+
n->subLinkType = ANY_SUBLINK;
n->subLinkId = 0;
n->testexpr = $1;
}
| a_expr subquery_Op sub_type select_with_parens %prec Op
{
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
+
n->subLinkType = $3;
n->subLinkId = 0;
n->testexpr = $1;
n->operName = $2;
n->subselect = $4;
n->location = @2;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| a_expr subquery_Op sub_type '(' a_expr ')' %prec Op
{
json_key_uniqueness_constraint_opt %prec IS
{
JsonFormat *format = makeJsonFormat(JS_FORMAT_DEFAULT, JS_ENC_DEFAULT, -1);
+
$$ = makeNotExpr(makeJsonIsPredicate($1, format, $4, $5, @1), @1);
}
/*
* lets us say something smarter than "syntax error".
*/
SetToDefault *n = makeNode(SetToDefault);
+
/* parse analysis will fill in the rest */
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
| AexprConst { $$ = $1; }
| PARAM opt_indirection
{
- ParamRef *p = makeNode(ParamRef);
+ ParamRef *p = makeNode(ParamRef);
+
p->number = $1;
p->location = @1;
if ($2)
{
A_Indirection *n = makeNode(A_Indirection);
+
n->arg = (Node *) p;
n->indirection = check_indirection($2, yyscanner);
$$ = (Node *) n;
if ($4)
{
A_Indirection *n = makeNode(A_Indirection);
+
n->arg = $2;
n->indirection = check_indirection($4, yyscanner);
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
else
$$ = $2;
{ $$ = $1; }
| select_with_parens %prec UMINUS
{
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
+
n->subLinkType = EXPR_SUBLINK;
n->subLinkId = 0;
n->testexpr = NULL;
n->operName = NIL;
n->subselect = $1;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| select_with_parens indirection
{
* subscripting or field selection to a sub-SELECT result,
* we need this redundant-looking production.
*/
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
A_Indirection *a = makeNode(A_Indirection);
+
n->subLinkType = EXPR_SUBLINK;
n->subLinkId = 0;
n->testexpr = NULL;
n->operName = NIL;
n->subselect = $1;
n->location = @1;
- a->arg = (Node *)n;
+ a->arg = (Node *) n;
a->indirection = check_indirection($2, yyscanner);
- $$ = (Node *)a;
+ $$ = (Node *) a;
}
| EXISTS select_with_parens
{
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
+
n->subLinkType = EXISTS_SUBLINK;
n->subLinkId = 0;
n->testexpr = NULL;
n->operName = NIL;
n->subselect = $2;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ARRAY select_with_parens
{
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
+
n->subLinkType = ARRAY_SUBLINK;
n->subLinkId = 0;
n->testexpr = NULL;
n->operName = NIL;
n->subselect = $2;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| ARRAY array_expr
{
A_ArrayExpr *n = castNode(A_ArrayExpr, $2);
+
/* point outermost A_ArrayExpr to the ARRAY keyword */
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| explicit_row
{
- RowExpr *r = makeNode(RowExpr);
+ RowExpr *r = makeNode(RowExpr);
+
r->args = $1;
r->row_typeid = InvalidOid; /* not analyzed yet */
r->colnames = NIL; /* to be filled in during analysis */
r->row_format = COERCE_EXPLICIT_CALL; /* abuse */
r->location = @1;
- $$ = (Node *)r;
+ $$ = (Node *) r;
}
| implicit_row
{
- RowExpr *r = makeNode(RowExpr);
+ RowExpr *r = makeNode(RowExpr);
+
r->args = $1;
r->row_typeid = InvalidOid; /* not analyzed yet */
r->colnames = NIL; /* to be filled in during analysis */
r->row_format = COERCE_IMPLICIT_CAST; /* abuse */
r->location = @1;
- $$ = (Node *)r;
+ $$ = (Node *) r;
}
| GROUPING '(' expr_list ')'
{
GroupingFunc *g = makeNode(GroupingFunc);
+
g->args = $3;
g->location = @1;
- $$ = (Node *)g;
+ $$ = (Node *) g;
}
;
}
| func_name '(' func_arg_list opt_sort_clause ')'
{
- FuncCall *n = makeFuncCall($1, $3,
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, $3,
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->agg_order = $4;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| func_name '(' VARIADIC func_arg_expr opt_sort_clause ')'
{
- FuncCall *n = makeFuncCall($1, list_make1($4),
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, list_make1($4),
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->func_variadic = true;
n->agg_order = $5;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause ')'
{
- FuncCall *n = makeFuncCall($1, lappend($3, $6),
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, lappend($3, $6),
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->func_variadic = true;
n->agg_order = $7;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| func_name '(' ALL func_arg_list opt_sort_clause ')'
{
- FuncCall *n = makeFuncCall($1, $4,
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, $4,
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->agg_order = $5;
/* Ideally we'd mark the FuncCall node to indicate
* "must be an aggregate", but there's no provision
* for that in FuncCall at the moment.
*/
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| func_name '(' DISTINCT func_arg_list opt_sort_clause ')'
{
- FuncCall *n = makeFuncCall($1, $4,
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, $4,
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->agg_order = $5;
n->agg_distinct = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| func_name '(' '*' ')'
{
* so that later processing can detect what the argument
* really was.
*/
- FuncCall *n = makeFuncCall($1, NIL,
- COERCE_EXPLICIT_CALL,
- @1);
+ FuncCall *n = makeFuncCall($1, NIL,
+ COERCE_EXPLICIT_CALL,
+ @1);
+
n->agg_star = true;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
;
*/
func_expr: func_application within_group_clause filter_clause over_clause
{
- FuncCall *n = (FuncCall *) $1;
+ FuncCall *n = (FuncCall *) $1;
+
/*
* The order clause for WITHIN GROUP and the one for
* plain-aggregate ORDER BY share a field, so we have to
JsonAggConstructor *n = IsA($1, JsonObjectAgg) ?
((JsonObjectAgg *) $1)->constructor :
((JsonArrayAgg *) $1)->constructor;
+
n->agg_filter = $2;
n->over = $3;
$$ = (Node *) $1;
| COALESCE '(' expr_list ')'
{
CoalesceExpr *c = makeNode(CoalesceExpr);
+
c->args = $3;
c->location = @1;
- $$ = (Node *)c;
+ $$ = (Node *) c;
}
| GREATEST '(' expr_list ')'
{
MinMaxExpr *v = makeNode(MinMaxExpr);
+
v->args = $3;
v->op = IS_GREATEST;
v->location = @1;
- $$ = (Node *)v;
+ $$ = (Node *) v;
}
| LEAST '(' expr_list ')'
{
MinMaxExpr *v = makeNode(MinMaxExpr);
+
v->args = $3;
v->op = IS_LEAST;
v->location = @1;
- $$ = (Node *)v;
+ $$ = (Node *) v;
}
| XMLCONCAT '(' expr_list ')'
{
makeXmlExpr(IS_XMLPARSE, NULL, NIL,
list_make2($4, makeBoolAConst($5, -1)),
@1);
+
x->xmloption = $3;
- $$ = (Node *)x;
+ $$ = (Node *) x;
}
| XMLPI '(' NAME_P ColLabel ')'
{
| XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename ')'
{
XmlSerialize *n = makeNode(XmlSerialize);
+
n->xmloption = $3;
n->expr = $4;
n->typeName = $6;
n->location = @1;
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
| json_func_expr
{ $$ = $1; }
window_definition:
ColId AS window_specification
{
- WindowDef *n = $3;
+ WindowDef *n = $3;
+
n->name = $1;
$$ = n;
}
{ $$ = $2; }
| OVER ColId
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->name = $2;
n->refname = NULL;
n->partitionClause = NIL;
window_specification: '(' opt_existing_window_name opt_partition_clause
opt_sort_clause opt_frame_clause ')'
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->name = NULL;
n->refname = $2;
n->partitionClause = $3;
opt_frame_clause:
RANGE frame_extent opt_window_exclusion_clause
{
- WindowDef *n = $2;
+ WindowDef *n = $2;
+
n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_RANGE;
n->frameOptions |= $3;
$$ = n;
}
| ROWS frame_extent opt_window_exclusion_clause
{
- WindowDef *n = $2;
+ WindowDef *n = $2;
+
n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_ROWS;
n->frameOptions |= $3;
$$ = n;
}
| GROUPS frame_extent opt_window_exclusion_clause
{
- WindowDef *n = $2;
+ WindowDef *n = $2;
+
n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_GROUPS;
n->frameOptions |= $3;
$$ = n;
}
| /*EMPTY*/
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_DEFAULTS;
n->startOffset = NULL;
n->endOffset = NULL;
frame_extent: frame_bound
{
- WindowDef *n = $1;
+ WindowDef *n = $1;
+
/* reject invalid cases */
if (n->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
ereport(ERROR,
}
| BETWEEN frame_bound AND frame_bound
{
- WindowDef *n1 = $2;
- WindowDef *n2 = $4;
+ WindowDef *n1 = $2;
+ WindowDef *n2 = $4;
+
/* form merged options */
int frameOptions = n1->frameOptions;
/* shift converts START_ options to END_ options */
frame_bound:
UNBOUNDED PRECEDING
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_START_UNBOUNDED_PRECEDING;
n->startOffset = NULL;
n->endOffset = NULL;
}
| UNBOUNDED FOLLOWING
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_START_UNBOUNDED_FOLLOWING;
n->startOffset = NULL;
n->endOffset = NULL;
}
| CURRENT_P ROW
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_START_CURRENT_ROW;
n->startOffset = NULL;
n->endOffset = NULL;
}
| a_expr PRECEDING
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_START_OFFSET_PRECEDING;
n->startOffset = $1;
n->endOffset = NULL;
}
| a_expr FOLLOWING
{
- WindowDef *n = makeNode(WindowDef);
+ WindowDef *n = makeNode(WindowDef);
+
n->frameOptions = FRAMEOPTION_START_OFFSET_FOLLOWING;
n->startOffset = $1;
n->endOffset = NULL;
| param_name COLON_EQUALS a_expr
{
NamedArgExpr *na = makeNode(NamedArgExpr);
+
na->name = $1;
na->arg = (Expr *) $3;
na->argnumber = -1; /* until determined */
| param_name EQUALS_GREATER a_expr
{
NamedArgExpr *na = makeNode(NamedArgExpr);
+
na->name = $1;
na->arg = (Expr *) $3;
na->argnumber = -1; /* until determined */
in_expr: select_with_parens
{
- SubLink *n = makeNode(SubLink);
+ SubLink *n = makeNode(SubLink);
+
n->subselect = $1;
/* other fields will be filled later */
- $$ = (Node *)n;
+ $$ = (Node *) n;
}
- | '(' expr_list ')' { $$ = (Node *)$2; }
+ | '(' expr_list ')' { $$ = (Node *) $2; }
;
/*
*/
case_expr: CASE case_arg when_clause_list case_default END_P
{
- CaseExpr *c = makeNode(CaseExpr);
+ CaseExpr *c = makeNode(CaseExpr);
+
c->casetype = InvalidOid; /* not analyzed yet */
c->arg = (Expr *) $2;
c->args = $3;
c->defresult = (Expr *) $4;
c->location = @1;
- $$ = (Node *)c;
+ $$ = (Node *) c;
}
;
when_clause:
WHEN a_expr THEN a_expr
{
- CaseWhen *w = makeNode(CaseWhen);
+ CaseWhen *w = makeNode(CaseWhen);
+
w->expr = (Expr *) $2;
w->result = (Expr *) $4;
w->location = @1;
- $$ = (Node *)w;
+ $$ = (Node *) w;
}
;
| '[' a_expr ']'
{
A_Indices *ai = makeNode(A_Indices);
+
ai->is_slice = false;
ai->lidx = NULL;
ai->uidx = $2;
| '[' opt_slice_bound ':' opt_slice_bound ']'
{
A_Indices *ai = makeNode(A_Indices);
+
ai->is_slice = true;
ai->lidx = $2;
ai->uidx = $4;
json_returning_clause_opt ')'
{
JsonParseExpr *n = makeNode(JsonParseExpr);
+
n->expr = (JsonValueExpr *) $3;
n->unique_keys = $4;
n->output = (JsonOutput *) $5;
JSON_SCALAR '(' a_expr json_returning_clause_opt ')'
{
JsonScalarExpr *n = makeNode(JsonScalarExpr);
+
n->expr = (Expr *) $3;
n->output = (JsonOutput *) $4;
n->location = @1;
JSON_SERIALIZE '(' json_value_expr json_output_clause_opt ')'
{
JsonSerializeExpr *n = makeNode(JsonSerializeExpr);
+
n->expr = (JsonValueExpr *) $3;
n->output = (JsonOutput *) $4;
n->location = @1;
')'
{
JsonFuncExpr *n = makeNode(JsonFuncExpr);
+
n->op = JSON_VALUE_OP;
n->common = (JsonCommon *) $3;
n->output = (JsonOutput *) $4;
json_passing_clause_opt
{
JsonCommon *n = makeNode(JsonCommon);
+
n->expr = (JsonValueExpr *) $1;
n->pathspec = $3;
n->pathname = $4;
json_value_expr AS ColLabel
{
JsonArgument *n = makeNode(JsonArgument);
+
n->val = (JsonValueExpr *) $1;
n->name = $3;
$$ = (Node *) n;
json_behavior_empty_array:
EMPTY_P ARRAY { $$ = makeJsonBehavior(JSON_BEHAVIOR_EMPTY_ARRAY, NULL); }
/* non-standard, for Oracle compatibility only */
- | EMPTY_P { $$ = makeJsonBehavior(JSON_BEHAVIOR_EMPTY_ARRAY, NULL); }
+ | EMPTY_P { $$ = makeJsonBehavior(JSON_BEHAVIOR_EMPTY_ARRAY, NULL); }
;
json_behavior_empty_object:
')'
{
JsonFuncExpr *n = makeNode(JsonFuncExpr);
+
n->op = JSON_QUERY_OP;
n->common = (JsonCommon *) $3;
n->output = (JsonOutput *) $4;
')'
{
JsonTable *n = makeNode(JsonTable);
+
n->common = (JsonCommon *) $3;
n->columns = $4;
n->plan = (JsonTablePlan *) $5;
json_table_column_definition:
json_table_ordinality_column_definition %prec json_table_column
- | json_table_regular_column_definition %prec json_table_column
+ | json_table_regular_column_definition %prec json_table_column
| json_table_formatted_column_definition %prec json_table_column
| json_table_exists_column_definition %prec json_table_column
| json_table_nested_columns
ColId FOR ORDINALITY
{
JsonTableColumn *n = makeNode(JsonTableColumn);
+
n->coltype = JTC_FOR_ORDINALITY;
n->name = $1;
n->location = @1;
json_value_on_behavior_clause_opt
{
JsonTableColumn *n = makeNode(JsonTableColumn);
+
n->coltype = JTC_REGULAR;
n->name = $1;
n->typeName = $2;
json_exists_error_clause_opt
{
JsonTableColumn *n = makeNode(JsonTableColumn);
+
n->coltype = JTC_EXISTS;
n->name = $1;
n->typeName = $2;
json_query_on_behavior_clause_opt
{
JsonTableColumn *n = makeNode(JsonTableColumn);
+
n->coltype = JTC_FORMATTED;
n->name = $1;
n->typeName = $2;
json_table_columns_clause
{
JsonTableColumn *n = makeNode(JsonTableColumn);
+
n->coltype = JTC_NESTED;
n->pathspec = $3;
n->pathname = $4;
json_table_path_name
{
JsonTablePlan *n = makeNode(JsonTablePlan);
+
n->plan_type = JSTP_SIMPLE;
n->pathname = $1;
n->location = @1;
PLAN DEFAULT '(' json_table_default_plan_choices ')'
{
JsonTablePlan *n = makeNode(JsonTablePlan);
+
n->plan_type = JSTP_DEFAULT;
n->join_type = $4;
n->location = @1;
RETURNING Typename
{
JsonOutput *n = makeNode(JsonOutput);
+
n->typeName = $2;
n->returning = makeNode(JsonReturning);
n->returning->format =
RETURNING Typename json_format_clause_opt
{
JsonOutput *n = makeNode(JsonOutput);
+
n->typeName = $2;
n->returning = makeNode(JsonReturning);
n->returning->format = (JsonFormat *) $3;
')'
{
JsonFuncExpr *p = makeNode(JsonFuncExpr);
+
p->op = JSON_EXISTS_OP;
p->common = (JsonCommon *) $3;
p->output = (JsonOutput *) $4;
json_object_func_args:
func_arg_list
{
- List *func = list_make1(makeString("json_object"));
+ List *func = list_make1(makeString("json_object"));
+
$$ = (Node *) makeFuncCall(func, $1, COERCE_EXPLICIT_CALL, @1);
}
;
json_object_constructor_args_opt json_output_clause_opt
{
JsonObjectConstructor *n = (JsonObjectConstructor *) $1;
+
n->output = (JsonOutput *) $2;
n->location = @1;
$$ = (Node *) n;
json_key_uniqueness_constraint_opt
{
JsonObjectConstructor *n = makeNode(JsonObjectConstructor);
+
n->exprs = $1;
n->absent_on_null = $2;
n->unique = $3;
| /* EMPTY */
{
JsonObjectConstructor *n = makeNode(JsonObjectConstructor);
+
n->exprs = NULL;
n->absent_on_null = false;
n->unique = false;
')'
{
JsonArrayConstructor *n = makeNode(JsonArrayConstructor);
+
n->exprs = $3;
n->absent_on_null = $4;
n->output = (JsonOutput *) $5;
')'
{
JsonArrayQueryConstructor *n = makeNode(JsonArrayQueryConstructor);
+
n->query = $3;
n->format = makeJsonFormat(JS_FORMAT_DEFAULT, JS_ENC_DEFAULT, -1);
/* n->format = $4; */
')'
{
JsonArrayConstructor *n = makeNode(JsonArrayConstructor);
+
n->exprs = NIL;
n->absent_on_null = true;
n->output = (JsonOutput *) $3;
')'
{
JsonObjectAgg *n = makeNode(JsonObjectAgg);
+
n->arg = (JsonKeyValue *) $3;
n->absent_on_null = $4;
n->unique = $5;
')'
{
JsonArrayAgg *n = makeNode(JsonArrayAgg);
+
n->arg = (JsonValueExpr *) $3;
n->absent_on_null = $5;
n->constructor = makeNode(JsonAggConstructor);
$$ = makeNode(ResTarget);
$$->name = $3;
$$->indirection = NIL;
- $$->val = (Node *)$1;
+ $$->val = (Node *) $1;
$$->location = @1;
}
| a_expr BareColLabel
$$ = makeNode(ResTarget);
$$->name = $2;
$$->indirection = NIL;
- $$->val = (Node *)$1;
+ $$->val = (Node *) $1;
$$->location = @1;
}
| a_expr
$$ = makeNode(ResTarget);
$$->name = NULL;
$$->indirection = NIL;
- $$->val = (Node *)$1;
+ $$->val = (Node *) $1;
$$->location = @1;
}
| '*'
{
- ColumnRef *n = makeNode(ColumnRef);
+ ColumnRef *n = makeNode(ColumnRef);
+
n->fields = list_make1(makeNode(A_Star));
n->location = @1;
$$ = makeNode(ResTarget);
$$->name = NULL;
$$->indirection = NIL;
- $$->val = (Node *)n;
+ $$->val = (Node *) n;
$$->location = @1;
}
;
| func_name Sconst
{
/* generic type 'literal' syntax */
- TypeName *t = makeTypeNameFromNameList($1);
+ TypeName *t = makeTypeNameFromNameList($1);
+
t->location = @1;
$$ = makeStringConstCast($2, @2, t);
}
| func_name '(' func_arg_list opt_sort_clause ')' Sconst
{
/* generic syntax with a type modifier */
- TypeName *t = makeTypeNameFromNameList($1);
- ListCell *lc;
+ TypeName *t = makeTypeNameFromNameList($1);
+ ListCell *lc;
/*
* We must use func_arg_list and opt_sort_clause in the
}
| ConstInterval Sconst opt_interval
{
- TypeName *t = $1;
+ TypeName *t = $1;
+
t->typmods = $3;
$$ = makeStringConstCast($2, @2, t);
}
| ConstInterval '(' Iconst ')' Sconst
{
- TypeName *t = $1;
+ TypeName *t = $1;
+
t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
makeIntConst($3, @3));
$$ = makeStringConstCast($5, @5, t);
/* Role specifications */
RoleId: RoleSpec
{
- RoleSpec *spc = (RoleSpec *) $1;
+ RoleSpec *spc = (RoleSpec *) $1;
+
switch (spc->roletype)
{
case ROLESPEC_CSTRING:
;
RoleSpec: NonReservedWord
+ {
+ /*
+ * "public" and "none" are not keywords, but they must
+ * be treated specially here.
+ */
+ RoleSpec *n;
+
+ if (strcmp($1, "public") == 0)
{
- /*
- * "public" and "none" are not keywords, but they must
- * be treated specially here.
- */
- RoleSpec *n;
- if (strcmp($1, "public") == 0)
- {
- n = (RoleSpec *) makeRoleSpec(ROLESPEC_PUBLIC, @1);
- n->roletype = ROLESPEC_PUBLIC;
- }
- else if (strcmp($1, "none") == 0)
- {
- ereport(ERROR,
- (errcode(ERRCODE_RESERVED_NAME),
- errmsg("role name \"%s\" is reserved",
- "none"),
- parser_errposition(@1)));
- }
- else
- {
- n = makeRoleSpec(ROLESPEC_CSTRING, @1);
- n->rolename = pstrdup($1);
- }
- $$ = n;
+ n = (RoleSpec *) makeRoleSpec(ROLESPEC_PUBLIC, @1);
+ n->roletype = ROLESPEC_PUBLIC;
}
- | CURRENT_ROLE
+ else if (strcmp($1, "none") == 0)
{
- $$ = makeRoleSpec(ROLESPEC_CURRENT_ROLE, @1);
+ ereport(ERROR,
+ (errcode(ERRCODE_RESERVED_NAME),
+ errmsg("role name \"%s\" is reserved",
+ "none"),
+ parser_errposition(@1)));
}
- | CURRENT_USER
+ else
{
- $$ = makeRoleSpec(ROLESPEC_CURRENT_USER, @1);
+ n = makeRoleSpec(ROLESPEC_CSTRING, @1);
+ n->rolename = pstrdup($1);
}
+ $$ = n;
+ }
+ | CURRENT_ROLE
+ {
+ $$ = makeRoleSpec(ROLESPEC_CURRENT_ROLE, @1);
+ }
+ | CURRENT_USER
+ {
+ $$ = makeRoleSpec(ROLESPEC_CURRENT_USER, @1);
+ }
| SESSION_USER
- {
- $$ = makeRoleSpec(ROLESPEC_SESSION_USER, @1);
- }
+ {
+ $$ = makeRoleSpec(ROLESPEC_SESSION_USER, @1);
+ }
;
role_list: RoleSpec
- { $$ = list_make1($1); }
+ { $$ = list_make1($1); }
| role_list ',' RoleSpec
- { $$ = lappend($1, $3); }
+ { $$ = lappend($1, $3); }
;
* transposed into the "fields" part of the ColumnRef node.
*/
ColumnRef *c = makeNode(ColumnRef);
- int nfields = 0;
- ListCell *l;
+ int nfields = 0;
+ ListCell *l;
c->location = location;
foreach(l, indirection)
static Node *
makeTypeCast(Node *arg, TypeName *typename, int location)
{
- TypeCast *n = makeNode(TypeCast);
+ TypeCast *n = makeNode(TypeCast);
+
n->arg = arg;
n->typeName = typename;
n->location = location;
static Node *
makeStringConst(char *str, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.sval.type = T_String;
n->val.sval.sval = str;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeStringConstCast(char *str, int location, TypeName *typename)
{
- Node *s = makeStringConst(str, location);
+ Node *s = makeStringConst(str, location);
return makeTypeCast(s, typename, -1);
}
static Node *
makeIntConst(int val, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.ival.type = T_Integer;
n->val.ival.ival = val;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeFloatConst(char *str, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.fval.type = T_Float;
n->val.fval.fval = str;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeBoolAConst(bool state, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.boolval.type = T_Boolean;
n->val.boolval.boolval = state;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeBitStringConst(char *str, int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->val.bsval.type = T_BitString;
n->val.bsval.bsval = str;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeNullAConst(int location)
{
- A_Const *n = makeNode(A_Const);
+ A_Const *n = makeNode(A_Const);
n->isnull = true;
n->location = location;
- return (Node *)n;
+ return (Node *) n;
}
static Node *
makeAConst(Node *v, int location)
{
- Node *n;
+ Node *n;
switch (v->type)
{
static RoleSpec *
makeRoleSpec(RoleSpecType type, int location)
{
- RoleSpec *spec = makeNode(RoleSpec);
+ RoleSpec *spec = makeNode(RoleSpec);
spec->roletype = type;
spec->location = location;
{
if (IsA(n, A_Const))
{
- A_Const *con = (A_Const *)n;
+ A_Const *con = (A_Const *) n;
/* report the constant's location as that of the '-' sign */
con->location = location;
static void
doNegateFloat(Float *v)
{
- char *oldval = v->fval;
+ char *oldval = v->fval;
if (*oldval == '+')
oldval++;
/* Flatten "a AND b AND c ..." to a single BoolExpr on sight */
if (IsA(lexpr, BoolExpr))
{
- BoolExpr *blexpr = (BoolExpr *) lexpr;
+ BoolExpr *blexpr = (BoolExpr *) lexpr;
if (blexpr->boolop == AND_EXPR)
{
/* Flatten "a OR b OR c ..." to a single BoolExpr on sight */
if (IsA(lexpr, BoolExpr))
{
- BoolExpr *blexpr = (BoolExpr *) lexpr;
+ BoolExpr *blexpr = (BoolExpr *) lexpr;
if (blexpr->boolop == OR_EXPR)
{
static TypeName *
TableFuncTypeName(List *columns)
{
- TypeName *result;
+ TypeName *result;
if (list_length(columns) == 1)
{
static RangeVar *
makeRangeVarFromAnyName(List *names, int position, core_yyscan_t yyscanner)
{
- RangeVar *r = makeNode(RangeVar);
+ RangeVar *r = makeNode(RangeVar);
switch (list_length(names))
{
makeRangeVarFromQualifiedName(char *name, List *namelist, int location,
core_yyscan_t yyscanner)
{
- RangeVar *r;
+ RangeVar *r;
check_qualified_name(namelist, yyscanner);
r = makeRangeVar(NULL, NULL, location);
*collClause = NULL;
foreach(cell, qualList)
{
- Node *n = (Node *) lfirst(cell);
+ Node *n = (Node *) lfirst(cell);
if (IsA(n, Constraint))
{
projects / postgresql.git / commitdiff