/*
* Now apply the core COPY code's validation logic for more checks.
*/
- ProcessCopyOptions(NULL, true, other_options);
+ ProcessCopyOptions(NULL, NULL, true, other_options);
/*
* Filename option is required for file_fdw foreign tables.
* force_null options set
*/
if (fnncolumns != NIL)
- options = lappend(options, makeDefElem("force_not_null", (Node *) fnncolumns));
+ options = lappend(options, makeDefElem("force_not_null", (Node *) fnncolumns, -1));
if (fncolumns != NIL)
- options = lappend(options, makeDefElem("force_null", (Node *) fncolumns));
+ options = lappend(options, makeDefElem("force_null", (Node *) fncolumns, -1));
return options;
}
foreigntableid,
&columns))
coptions = list_make1(makeDefElem("convert_selectively",
- (Node *) columns));
+ (Node *) columns, -1));
/* Estimate costs */
estimate_costs(root, baserel, fdw_private,
* Create CopyState from FDW options. We always acquire all columns, so
* as to match the expected ScanTupleSlot signature.
*/
- cstate = BeginCopyFrom(node->ss.ss_currentRelation,
+ cstate = BeginCopyFrom(NULL,
+ node->ss.ss_currentRelation,
filename,
false,
NIL,
EndCopyFrom(festate->cstate);
- festate->cstate = BeginCopyFrom(node->ss.ss_currentRelation,
+ festate->cstate = BeginCopyFrom(NULL,
+ node->ss.ss_currentRelation,
festate->filename,
false,
NIL,
/*
* Create CopyState from FDW options.
*/
- cstate = BeginCopyFrom(onerel, filename, false, NIL, options);
+ cstate = BeginCopyFrom(NULL, onerel, filename, false, NIL, options);
/*
* Use per-tuple memory context to prevent leak of memory used to read
*p++ = '\0';
val = (Node *) makeString(pstrdup(p));
}
- result = lappend(result, makeDefElem(pstrdup(s), val));
+ result = lappend(result, makeDefElem(pstrdup(s), val, -1));
}
return result;
* ALTER DEFAULT PRIVILEGES statement
*/
void
-ExecAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *stmt)
+ExecAlterDefaultPrivilegesStmt(ParseState *pstate, AlterDefaultPrivilegesStmt *stmt)
{
GrantStmt *action = stmt->action;
InternalDefaultACL iacls;
if (dnspnames)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dnspnames = defel;
}
else if (strcmp(defel->defname, "roles") == 0)
if (drolespecs)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
drolespecs = defel;
}
else
* "parameters" is a list of DefElem representing the agg's definition clauses.
*/
ObjectAddress
-DefineAggregate(List *name, List *args, bool oldstyle, List *parameters,
- const char *queryString)
+DefineAggregate(ParseState *pstate, List *name, List *args, bool oldstyle, List *parameters)
{
char *aggName;
Oid aggNamespace;
errmsg("basetype is redundant with aggregate input type specification")));
numArgs = list_length(args);
- interpret_function_parameter_list(args,
+ interpret_function_parameter_list(pstate,
+ args,
InvalidOid,
true, /* is an aggregate */
- queryString,
¶meterTypes,
&allParameterTypes,
¶meterModes,
* CREATE COLLATION
*/
ObjectAddress
-DefineCollation(List *names, List *parameters)
+DefineCollation(ParseState *pstate, List *names, List *parameters)
{
char *collName;
Oid collNamespace;
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("collation attribute \"%s\" not recognized",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
break;
}
/* non-export function prototypes */
-static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
- const char *queryString, const Oid queryRelId, List *attnamelist,
+static CopyState BeginCopy(ParseState *pstate, bool is_from, Relation rel, Node *raw_query,
+ const Oid queryRelId, List *attnamelist,
List *options);
static void EndCopy(CopyState cstate);
static void ClosePipeToProgram(CopyState cstate);
-static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
+static CopyState BeginCopyTo(ParseState *pstate, Relation rel, Node *query,
const Oid queryRelId, const char *filename, bool is_program,
List *attnamelist, List *options);
static void EndCopyTo(CopyState cstate);
* the table or the specifically requested columns.
*/
Oid
-DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
+DoCopy(ParseState *pstate, const CopyStmt *stmt, uint64 *processed)
{
CopyState cstate;
bool is_from = stmt->is_from;
PreventCommandIfReadOnly("COPY FROM");
PreventCommandIfParallelMode("COPY FROM");
- cstate = BeginCopyFrom(rel, stmt->filename, stmt->is_program,
+ cstate = BeginCopyFrom(pstate, rel, stmt->filename, stmt->is_program,
stmt->attlist, stmt->options);
cstate->range_table = range_table;
*processed = CopyFrom(cstate); /* copy from file to database */
}
else
{
- cstate = BeginCopyTo(rel, query, queryString, relid,
+ cstate = BeginCopyTo(pstate, rel, query, relid,
stmt->filename, stmt->is_program,
stmt->attlist, stmt->options);
*processed = DoCopyTo(cstate); /* copy from database to file */
* self-consistency of the options list.
*/
void
-ProcessCopyOptions(CopyState cstate,
+ProcessCopyOptions(ParseState *pstate,
+ CopyState cstate,
bool is_from,
List *options)
{
if (format_specified)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
format_specified = true;
if (strcmp(fmt, "text") == 0)
/* default format */ ;
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("COPY format \"%s\" not recognized", fmt)));
+ errmsg("COPY format \"%s\" not recognized", fmt),
+ parser_errposition(pstate, defel->location)));
}
else if (strcmp(defel->defname, "oids") == 0)
{
if (cstate->oids)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->oids = defGetBoolean(defel);
}
else if (strcmp(defel->defname, "freeze") == 0)
if (cstate->freeze)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->freeze = defGetBoolean(defel);
}
else if (strcmp(defel->defname, "delimiter") == 0)
if (cstate->delim)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->delim = defGetString(defel);
}
else if (strcmp(defel->defname, "null") == 0)
if (cstate->null_print)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->null_print = defGetString(defel);
}
else if (strcmp(defel->defname, "header") == 0)
if (cstate->header_line)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->header_line = defGetBoolean(defel);
}
else if (strcmp(defel->defname, "quote") == 0)
if (cstate->quote)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->quote = defGetString(defel);
}
else if (strcmp(defel->defname, "escape") == 0)
if (cstate->escape)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->escape = defGetString(defel);
}
else if (strcmp(defel->defname, "force_quote") == 0)
if (cstate->force_quote || cstate->force_quote_all)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
if (defel->arg && IsA(defel->arg, A_Star))
cstate->force_quote_all = true;
else if (defel->arg && IsA(defel->arg, List))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument to option \"%s\" must be a list of column names",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
else if (strcmp(defel->defname, "force_not_null") == 0)
{
if (cstate->force_notnull)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
if (defel->arg && IsA(defel->arg, List))
cstate->force_notnull = (List *) defel->arg;
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument to option \"%s\" must be a list of column names",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
else if (strcmp(defel->defname, "force_null") == 0)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument to option \"%s\" must be a list of column names",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
else if (strcmp(defel->defname, "convert_selectively") == 0)
{
if (cstate->convert_selectively)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->convert_selectively = true;
if (defel->arg == NULL || IsA(defel->arg, List))
cstate->convert_select = (List *) defel->arg;
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument to option \"%s\" must be a list of column names",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
else if (strcmp(defel->defname, "encoding") == 0)
{
if (cstate->file_encoding >= 0)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cstate->file_encoding = pg_char_to_encoding(defGetString(defel));
if (cstate->file_encoding < 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument to option \"%s\" must be a valid encoding name",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("option \"%s\" not recognized",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
}
/*
* NULL values as <null_print>.
*/
static CopyState
-BeginCopy(bool is_from,
+BeginCopy(ParseState *pstate,
+ bool is_from,
Relation rel,
Node *raw_query,
- const char *queryString,
const Oid queryRelId,
List *attnamelist,
List *options)
oldcontext = MemoryContextSwitchTo(cstate->copycontext);
/* Extract options from the statement node tree */
- ProcessCopyOptions(cstate, is_from, options);
+ ProcessCopyOptions(pstate, cstate, is_from, options);
/* Process the source/target relation or query */
if (rel)
* DECLARE CURSOR and PREPARE.) XXX FIXME someday.
*/
rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
- queryString, NULL, 0);
+ pstate->p_sourcetext, NULL, 0);
/* check that we got back something we can work with */
if (rewritten == NIL)
((DR_copy *) dest)->cstate = cstate;
/* Create a QueryDesc requesting no output */
- cstate->queryDesc = CreateQueryDesc(plan, queryString,
+ cstate->queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
GetActiveSnapshot(),
InvalidSnapshot,
dest, NULL, 0);
* Setup CopyState to read tuples from a table or a query for COPY TO.
*/
static CopyState
-BeginCopyTo(Relation rel,
+BeginCopyTo(ParseState *pstate,
+ Relation rel,
Node *query,
- const char *queryString,
const Oid queryRelId,
const char *filename,
bool is_program,
RelationGetRelationName(rel))));
}
- cstate = BeginCopy(false, rel, query, queryString, queryRelId, attnamelist,
+ cstate = BeginCopy(pstate, false, rel, query, queryRelId, attnamelist,
options);
oldcontext = MemoryContextSwitchTo(cstate->copycontext);
* Returns a CopyState, to be passed to NextCopyFrom and related functions.
*/
CopyState
-BeginCopyFrom(Relation rel,
+BeginCopyFrom(ParseState *pstate,
+ Relation rel,
const char *filename,
bool is_program,
List *attnamelist,
MemoryContext oldcontext;
bool volatile_defexprs;
- cstate = BeginCopy(true, rel, NULL, NULL, InvalidOid, attnamelist, options);
+ cstate = BeginCopy(pstate, true, rel, NULL, InvalidOid, attnamelist, options);
oldcontext = MemoryContextSwitchTo(cstate->copycontext);
/* Initialize state variables */
* CREATE DATABASE
*/
Oid
-createdb(const CreatedbStmt *stmt)
+createdb(ParseState *pstate, const CreatedbStmt *stmt)
{
HeapScanDesc scan;
Relation rel;
if (dtablespacename)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dtablespacename = defel;
}
else if (strcmp(defel->defname, "owner") == 0)
if (downer)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
downer = defel;
}
else if (strcmp(defel->defname, "template") == 0)
if (dtemplate)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dtemplate = defel;
}
else if (strcmp(defel->defname, "encoding") == 0)
if (dencoding)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dencoding = defel;
}
else if (strcmp(defel->defname, "lc_collate") == 0)
if (dcollate)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dcollate = defel;
}
else if (strcmp(defel->defname, "lc_ctype") == 0)
if (dctype)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dctype = defel;
}
else if (strcmp(defel->defname, "is_template") == 0)
if (distemplate)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
distemplate = defel;
}
else if (strcmp(defel->defname, "allow_connections") == 0)
if (dallowconnections)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dallowconnections = defel;
}
else if (strcmp(defel->defname, "connection_limit") == 0)
if (dconnlimit)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dconnlimit = defel;
}
else if (strcmp(defel->defname, "location") == 0)
ereport(WARNING,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("LOCATION is not supported anymore"),
- errhint("Consider using tablespaces instead.")));
+ errhint("Consider using tablespaces instead."),
+ parser_errposition(pstate, defel->location)));
}
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("option \"%s\" not recognized", defel->defname)));
+ errmsg("option \"%s\" not recognized", defel->defname),
+ parser_errposition(pstate, defel->location)));
}
if (downer && downer->arg)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("%d is not a valid encoding code",
- encoding)));
+ encoding),
+ parser_errposition(pstate, dencoding->location)));
}
else
{
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("%s is not a valid encoding name",
- encoding_name)));
+ encoding_name),
+ parser_errposition(pstate, dencoding->location)));
}
}
if (dcollate && dcollate->arg)
* ALTER DATABASE name ...
*/
Oid
-AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel)
+AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
{
Relation rel;
Oid dboid;
if (distemplate)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
distemplate = defel;
}
else if (strcmp(defel->defname, "allow_connections") == 0)
if (dallowconnections)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dallowconnections = defel;
}
else if (strcmp(defel->defname, "connection_limit") == 0)
if (dconnlimit)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dconnlimit = defel;
}
else if (strcmp(defel->defname, "tablespace") == 0)
if (dtablespace)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dtablespace = defel;
}
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("option \"%s\" not recognized", defel->defname)));
+ errmsg("option \"%s\" not recognized", defel->defname),
+ parser_errposition(pstate, defel->location)));
}
if (dtablespace)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("option \"%s\" cannot be specified with other options",
- dtablespace->defname)));
+ dtablespace->defname),
+ parser_errposition(pstate, dtablespace->location)));
/* this case isn't allowed within a transaction block */
PreventTransactionChain(isTopLevel, "ALTER DATABASE SET TABLESPACE");
movedb(stmt->dbname, defGetString(dtablespace));
def->defname, defGetString(def))));
return 0; /* keep compiler quiet */
}
-
-/*
- * Create a DefElem setting "oids" to the specified value.
- */
-DefElem *
-defWithOids(bool value)
-{
- return makeDefElem("oids", (Node *) makeInteger(value));
-}
* execute an EXPLAIN command
*/
void
-ExplainQuery(ExplainStmt *stmt, const char *queryString,
+ExplainQuery(ParseState *pstate, ExplainStmt *stmt, const char *queryString,
ParamListInfo params, DestReceiver *dest)
{
ExplainState *es = NewExplainState();
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized value for EXPLAIN option \"%s\": \"%s\"",
- opt->defname, p)));
+ opt->defname, p),
+ parser_errposition(pstate, opt->location)));
}
else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unrecognized EXPLAIN option \"%s\"",
- opt->defname)));
+ opt->defname),
+ parser_errposition(pstate, opt->location)));
}
if (es->buffers && !es->analyze)
* installed, allowing us to error out if we recurse to one of those.
*/
static ObjectAddress
-CreateExtensionInternal(CreateExtensionStmt *stmt, List *parents)
+CreateExtensionInternal(ParseState *pstate, CreateExtensionStmt *stmt, List *parents)
{
DefElem *d_schema = NULL;
DefElem *d_new_version = NULL;
if (d_schema)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
d_schema = defel;
}
else if (strcmp(defel->defname, "new_version") == 0)
if (d_new_version)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
d_new_version = defel;
}
else if (strcmp(defel->defname, "old_version") == 0)
if (d_old_version)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
d_old_version = defel;
}
else if (strcmp(defel->defname, "cascade") == 0)
if (d_cascade)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
d_cascade = defel;
cascade = defGetBoolean(d_cascade);
}
lappend(list_copy(parents), stmt->extname);
/* Create the required extension. */
- addr = CreateExtensionInternal(ces, cascade_parents);
+ addr = CreateExtensionInternal(pstate, ces, cascade_parents);
/* Get its newly-assigned OID. */
reqext = addr.objectId;
* CREATE EXTENSION
*/
ObjectAddress
-CreateExtension(CreateExtensionStmt *stmt)
+CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt)
{
/* Check extension name validity before any filesystem access */
check_valid_extension_name(stmt->extname);
errmsg("nested CREATE EXTENSION is not supported")));
/* Finally create the extension. */
- return CreateExtensionInternal(stmt, NIL);
+ return CreateExtensionInternal(pstate, stmt, NIL);
}
/*
* Execute ALTER EXTENSION UPDATE
*/
ObjectAddress
-ExecAlterExtensionStmt(AlterExtensionStmt *stmt)
+ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt)
{
DefElem *d_new_version = NULL;
char *versionName;
if (d_new_version)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
d_new_version = defel;
}
else
* parameters: list of FunctionParameter structs
* languageOid: OID of function language (InvalidOid if it's CREATE AGGREGATE)
* is_aggregate: needed only to determine error handling
- * queryString: likewise, needed only for error handling
*
* Results are stored into output parameters. parameterTypes must always
* be created, but the other arrays are set to NULL if not needed.
* else it is set to the OID of the implied result type.
*/
void
-interpret_function_parameter_list(List *parameters,
+interpret_function_parameter_list(ParseState *pstate,
+ List *parameters,
Oid languageOid,
bool is_aggregate,
- const char *queryString,
oidvector **parameterTypes,
ArrayType **allParameterTypes,
ArrayType **parameterModes,
bool have_defaults = false;
ListCell *x;
int i;
- ParseState *pstate;
*variadicArgType = InvalidOid; /* default result */
*requiredResultType = InvalidOid; /* default result */
paramNames = (Datum *) palloc0(parameterCount * sizeof(Datum));
*parameterDefaults = NIL;
- /* may need a pstate for parse analysis of default exprs */
- pstate = make_parsestate(NULL);
- pstate->p_sourcetext = queryString;
-
/* Scan the list and extract data into work arrays */
i = 0;
foreach(x, parameters)
i++;
}
- free_parsestate(pstate);
-
/* Now construct the proper outputs as needed */
*parameterTypes = buildoidvector(inTypes, inCount);
* SET parameters though --- if you're redundant, the last one wins.)
*/
static bool
-compute_common_attribute(DefElem *defel,
+compute_common_attribute(ParseState *pstate,
+ DefElem *defel,
DefElem **volatility_item,
DefElem **strict_item,
DefElem **security_item,
duplicate_error:
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
return false; /* keep compiler quiet */
}
* attributes.
*/
static void
-compute_attributes_sql_style(List *options,
+compute_attributes_sql_style(ParseState *pstate,
+ List *options,
List **as,
char **language,
Node **transform,
if (as_item)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
as_item = defel;
}
else if (strcmp(defel->defname, "language") == 0)
if (language_item)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
language_item = defel;
}
else if (strcmp(defel->defname, "transform") == 0)
if (transform_item)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
transform_item = defel;
}
else if (strcmp(defel->defname, "window") == 0)
if (windowfunc_item)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
windowfunc_item = defel;
}
- else if (compute_common_attribute(defel,
+ else if (compute_common_attribute(pstate,
+ defel,
&volatility_item,
&strict_item,
&security_item,
*------------
*/
static void
-compute_attributes_with_style(List *parameters, bool *isStrict_p, char *volatility_p)
+compute_attributes_with_style(ParseState *pstate, List *parameters, bool *isStrict_p, char *volatility_p)
{
ListCell *pl;
ereport(WARNING,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unrecognized function attribute \"%s\" ignored",
- param->defname)));
+ param->defname),
+ parser_errposition(pstate, param->location)));
}
}
* Execute a CREATE FUNCTION utility statement.
*/
ObjectAddress
-CreateFunction(CreateFunctionStmt *stmt, const char *queryString)
+CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt)
{
char *probin_str;
char *prosrc_str;
parallel = PROPARALLEL_UNSAFE;
/* override attributes from explicit list */
- compute_attributes_sql_style(stmt->options,
+ compute_attributes_sql_style(pstate,
+ stmt->options,
&as_clause, &language, &transformDefElem,
&isWindowFunc, &volatility,
&isStrict, &security, &isLeakProof,
* Convert remaining parameters of CREATE to form wanted by
* ProcedureCreate.
*/
- interpret_function_parameter_list(stmt->parameters,
+ interpret_function_parameter_list(pstate,
+ stmt->parameters,
languageOid,
false, /* not an aggregate */
- queryString,
¶meterTypes,
&allParameterTypes,
¶meterModes,
trftypes = NULL;
}
- compute_attributes_with_style(stmt->withClause, &isStrict, &volatility);
+ compute_attributes_with_style(pstate, stmt->withClause, &isStrict, &volatility);
interpret_AS_clause(languageOid, language, funcname, as_clause,
&prosrc_str, &probin_str);
* ALTER framework).
*/
ObjectAddress
-AlterFunction(AlterFunctionStmt *stmt)
+AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt)
{
HeapTuple tup;
Oid funcOid;
{
DefElem *defel = (DefElem *) lfirst(l);
- if (compute_common_attribute(defel,
+ if (compute_common_attribute(pstate,
+ defel,
&volatility_item,
&strict_item,
&security_def_item,
static void init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel);
static Form_pg_sequence read_seq_tuple(SeqTable elm, Relation rel,
Buffer *buf, HeapTuple seqtuple);
-static void init_params(List *options, bool isInit,
+static void init_params(ParseState *pstate, List *options, bool isInit,
Form_pg_sequence new, List **owned_by);
static void do_setval(Oid relid, int64 next, bool iscalled);
static void process_owned_by(Relation seqrel, List *owned_by);
* Creates a new sequence relation
*/
ObjectAddress
-DefineSequence(CreateSeqStmt *seq)
+DefineSequence(ParseState *pstate, CreateSeqStmt *seq)
{
FormData_pg_sequence new;
List *owned_by;
}
/* Check and set all option values */
- init_params(seq->options, true, &new, &owned_by);
+ init_params(pstate, seq->options, true, &new, &owned_by);
/*
* Create relation (and fill value[] and null[] for the tuple)
* Modify the definition of a sequence relation
*/
ObjectAddress
-AlterSequence(AlterSeqStmt *stmt)
+AlterSequence(ParseState *pstate, AlterSeqStmt *stmt)
{
Oid relid;
SeqTable elm;
memcpy(&new, seq, sizeof(FormData_pg_sequence));
/* Check and set new values */
- init_params(stmt->options, false, &new, &owned_by);
+ init_params(pstate, stmt->options, false, &new, &owned_by);
/* Clear local cache so that we don't think we have cached numbers */
/* Note that we do not change the currval() state */
* otherwise, do not change existing options that aren't explicitly overridden.
*/
static void
-init_params(List *options, bool isInit,
+init_params(ParseState *pstate, List *options, bool isInit,
Form_pg_sequence new, List **owned_by)
{
DefElem *start_value = NULL;
if (increment_by)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
increment_by = defel;
}
else if (strcmp(defel->defname, "start") == 0)
if (start_value)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
start_value = defel;
}
else if (strcmp(defel->defname, "restart") == 0)
if (restart_value)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
restart_value = defel;
}
else if (strcmp(defel->defname, "maxvalue") == 0)
if (max_value)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
max_value = defel;
}
else if (strcmp(defel->defname, "minvalue") == 0)
if (min_value)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
min_value = defel;
}
else if (strcmp(defel->defname, "cache") == 0)
if (cache_value)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
cache_value = defel;
}
else if (strcmp(defel->defname, "cycle") == 0)
if (is_cycled)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
is_cycled = defel;
}
else if (strcmp(defel->defname, "owned_by") == 0)
if (*owned_by)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
*owned_by = defGetQualifiedName(defel);
}
else
*wsptr++ = '\0';
result = lappend(result,
makeDefElem(pstrdup(workspace),
- (Node *) makeString(pstrdup(startvalue))));
+ (Node *) makeString(pstrdup(startvalue)), -1));
state = CS_WAITKEY;
}
}
*wsptr++ = '\0';
result = lappend(result,
makeDefElem(pstrdup(workspace),
- (Node *) makeString(pstrdup(startvalue))));
+ (Node *) makeString(pstrdup(startvalue)), -1));
state = CS_WAITKEY;
}
}
*wsptr++ = '\0';
result = lappend(result,
makeDefElem(pstrdup(workspace),
- (Node *) makeString(pstrdup(startvalue))));
+ (Node *) makeString(pstrdup(startvalue)), -1));
state = CS_WAITKEY;
}
else
*wsptr++ = '\0';
result = lappend(result,
makeDefElem(pstrdup(workspace),
- (Node *) makeString(pstrdup(startvalue))));
+ (Node *) makeString(pstrdup(startvalue)), -1));
}
else if (state != CS_WAITKEY)
ereport(ERROR,
* Registers a new base type.
*/
ObjectAddress
-DefineType(List *names, List *parameters)
+DefineType(ParseState *pstate, List *names, List *parameters)
{
char *typeName;
Oid typeNamespace;
ereport(WARNING,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("type attribute \"%s\" not recognized",
- defel->defname)));
+ defel->defname),
+ parser_errposition(pstate, defel->location)));
continue;
}
if (*defelp != NULL)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
*defelp = defel;
}
* CREATE ROLE
*/
Oid
-CreateRole(CreateRoleStmt *stmt)
+CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
{
Relation pg_authid_rel;
TupleDesc pg_authid_dsc;
if (dpassword)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dpassword = defel;
if (strcmp(defel->defname, "encryptedPassword") == 0)
encrypt_password = true;
if (dissuper)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dissuper = defel;
}
else if (strcmp(defel->defname, "inherit") == 0)
if (dinherit)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dinherit = defel;
}
else if (strcmp(defel->defname, "createrole") == 0)
if (dcreaterole)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dcreaterole = defel;
}
else if (strcmp(defel->defname, "createdb") == 0)
if (dcreatedb)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dcreatedb = defel;
}
else if (strcmp(defel->defname, "canlogin") == 0)
if (dcanlogin)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dcanlogin = defel;
}
else if (strcmp(defel->defname, "isreplication") == 0)
if (disreplication)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
disreplication = defel;
}
else if (strcmp(defel->defname, "connectionlimit") == 0)
if (dconnlimit)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dconnlimit = defel;
}
else if (strcmp(defel->defname, "addroleto") == 0)
if (daddroleto)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
daddroleto = defel;
}
else if (strcmp(defel->defname, "rolemembers") == 0)
if (drolemembers)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
drolemembers = defel;
}
else if (strcmp(defel->defname, "adminmembers") == 0)
if (dadminmembers)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dadminmembers = defel;
}
else if (strcmp(defel->defname, "validUntil") == 0)
if (dvalidUntil)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dvalidUntil = defel;
}
else if (strcmp(defel->defname, "bypassrls") == 0)
if (dbypassRLS)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options")));
+ errmsg("conflicting or redundant options"),
+ parser_errposition(pstate, defel->location)));
dbypassRLS = defel;
}
else
if (stmt->withCheckOption == LOCAL_CHECK_OPTION)
stmt->options = lappend(stmt->options,
makeDefElem("check_option",
- (Node *) makeString("local")));
+ (Node *) makeString("local"), -1));
else if (stmt->withCheckOption == CASCADED_CHECK_OPTION)
stmt->options = lappend(stmt->options,
makeDefElem("check_option",
- (Node *) makeString("cascaded")));
+ (Node *) makeString("cascaded"), -1));
/*
* Check that the view is auto-updatable if WITH CHECK OPTION was
COPY_STRING_FIELD(defname);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(defaction);
+ COPY_LOCATION_FIELD(location);
return newnode;
}
COMPARE_STRING_FIELD(defname);
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(defaction);
+ COMPARE_LOCATION_FIELD(location);
return true;
}
COMPARE_NODE_FIELD(lockedRels);
COMPARE_SCALAR_FIELD(strength);
COMPARE_SCALAR_FIELD(waitPolicy);
+ COMPARE_LOCATION_FIELD(location);
return true;
}
* and no special action.
*/
DefElem *
-makeDefElem(char *name, Node *arg)
+makeDefElem(char *name, Node *arg, int location)
{
DefElem *res = makeNode(DefElem);
res->defname = name;
res->arg = arg;
res->defaction = DEFELEM_UNSPEC;
+ res->location = location;
return res;
}
*/
DefElem *
makeDefElemExtended(char *nameSpace, char *name, Node *arg,
- DefElemAction defaction)
+ DefElemAction defaction, int location)
{
DefElem *res = makeNode(DefElem);
res->defname = name;
res->arg = arg;
res->defaction = defaction;
+ res->location = location;
return res;
}
WRITE_STRING_FIELD(defname);
WRITE_NODE_FIELD(arg);
WRITE_ENUM_FIELD(defaction, DefElemAction);
+ WRITE_LOCATION_FIELD(location);
}
static void
READ_STRING_FIELD(defname);
READ_NODE_FIELD(arg);
READ_ENUM_FIELD(defaction, DefElemAction);
+ READ_LOCATION_FIELD(location);
READ_DONE();
}
PASSWORD Sconst
{
$$ = makeDefElem("password",
- (Node *)makeString($2));
+ (Node *)makeString($2), @1);
}
| PASSWORD NULL_P
{
- $$ = makeDefElem("password", NULL);
+ $$ = makeDefElem("password", NULL, @1);
}
| ENCRYPTED PASSWORD Sconst
{
$$ = makeDefElem("encryptedPassword",
- (Node *)makeString($3));
+ (Node *)makeString($3), @1);
}
| UNENCRYPTED PASSWORD Sconst
{
$$ = makeDefElem("unencryptedPassword",
- (Node *)makeString($3));
+ (Node *)makeString($3), @1);
}
| INHERIT
{
- $$ = makeDefElem("inherit", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("inherit", (Node *)makeInteger(TRUE), @1);
}
| CONNECTION LIMIT SignedIconst
{
- $$ = makeDefElem("connectionlimit", (Node *)makeInteger($3));
+ $$ = makeDefElem("connectionlimit", (Node *)makeInteger($3), @1);
}
| VALID UNTIL Sconst
{
- $$ = makeDefElem("validUntil", (Node *)makeString($3));
+ $$ = makeDefElem("validUntil", (Node *)makeString($3), @1);
}
/* Supported but not documented for roles, for use by ALTER GROUP. */
| USER role_list
{
- $$ = makeDefElem("rolemembers", (Node *)$2);
+ $$ = makeDefElem("rolemembers", (Node *)$2, @1);
}
| IDENT
{
* size of the main parser.
*/
if (strcmp($1, "superuser") == 0)
- $$ = makeDefElem("superuser", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("superuser", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "nosuperuser") == 0)
- $$ = makeDefElem("superuser", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("superuser", (Node *)makeInteger(FALSE), @1);
else if (strcmp($1, "createrole") == 0)
- $$ = makeDefElem("createrole", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("createrole", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "nocreaterole") == 0)
- $$ = makeDefElem("createrole", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("createrole", (Node *)makeInteger(FALSE), @1);
else if (strcmp($1, "replication") == 0)
- $$ = makeDefElem("isreplication", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("isreplication", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "noreplication") == 0)
- $$ = makeDefElem("isreplication", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("isreplication", (Node *)makeInteger(FALSE), @1);
else if (strcmp($1, "createdb") == 0)
- $$ = makeDefElem("createdb", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("createdb", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "nocreatedb") == 0)
- $$ = makeDefElem("createdb", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("createdb", (Node *)makeInteger(FALSE), @1);
else if (strcmp($1, "login") == 0)
- $$ = makeDefElem("canlogin", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("canlogin", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "nologin") == 0)
- $$ = makeDefElem("canlogin", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("canlogin", (Node *)makeInteger(FALSE), @1);
else if (strcmp($1, "bypassrls") == 0)
- $$ = makeDefElem("bypassrls", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("bypassrls", (Node *)makeInteger(TRUE), @1);
else if (strcmp($1, "nobypassrls") == 0)
- $$ = makeDefElem("bypassrls", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("bypassrls", (Node *)makeInteger(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 *)makeInteger(FALSE));
+ $$ = makeDefElem("inherit", (Node *)makeInteger(FALSE), @1);
}
else
ereport(ERROR,
/* The following are not supported by ALTER ROLE/USER/GROUP */
| SYSID Iconst
{
- $$ = makeDefElem("sysid", (Node *)makeInteger($2));
+ $$ = makeDefElem("sysid", (Node *)makeInteger($2), @1);
}
| ADMIN role_list
{
- $$ = makeDefElem("adminmembers", (Node *)$2);
+ $$ = makeDefElem("adminmembers", (Node *)$2, @1);
}
| ROLE role_list
{
- $$ = makeDefElem("rolemembers", (Node *)$2);
+ $$ = makeDefElem("rolemembers", (Node *)$2, @1);
}
| IN_P ROLE role_list
{
- $$ = makeDefElem("addroleto", (Node *)$3);
+ $$ = makeDefElem("addroleto", (Node *)$3, @1);
}
| IN_P GROUP_P role_list
{
- $$ = makeDefElem("addroleto", (Node *)$3);
+ $$ = makeDefElem("addroleto", (Node *)$3, @1);
}
;
n->role = $3;
n->action = $4;
n->options = list_make1(makeDefElem("rolemembers",
- (Node *)$6));
+ (Node *)$6, @6));
$$ = (Node *)n;
}
;
reloption_elem:
ColLabel '=' def_arg
{
- $$ = makeDefElem($1, (Node *) $3);
+ $$ = makeDefElem($1, (Node *) $3, @1);
}
| ColLabel
{
- $$ = makeDefElem($1, NULL);
+ $$ = makeDefElem($1, NULL, @1);
}
| ColLabel '.' ColLabel '=' def_arg
{
$$ = makeDefElemExtended($1, $3, (Node *) $5,
- DEFELEM_UNSPEC);
+ DEFELEM_UNSPEC, @1);
}
| ColLabel '.' ColLabel
{
- $$ = makeDefElemExtended($1, $3, NULL, DEFELEM_UNSPEC);
+ $$ = makeDefElemExtended($1, $3, NULL, DEFELEM_UNSPEC, @1);
}
;
copy_opt_item:
BINARY
{
- $$ = makeDefElem("format", (Node *)makeString("binary"));
+ $$ = makeDefElem("format", (Node *)makeString("binary"), @1);
}
| OIDS
{
- $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("oids", (Node *)makeInteger(TRUE), @1);
}
| FREEZE
{
- $$ = makeDefElem("freeze", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("freeze", (Node *)makeInteger(TRUE), @1);
}
| DELIMITER opt_as Sconst
{
- $$ = makeDefElem("delimiter", (Node *)makeString($3));
+ $$ = makeDefElem("delimiter", (Node *)makeString($3), @1);
}
| NULL_P opt_as Sconst
{
- $$ = makeDefElem("null", (Node *)makeString($3));
+ $$ = makeDefElem("null", (Node *)makeString($3), @1);
}
| CSV
{
- $$ = makeDefElem("format", (Node *)makeString("csv"));
+ $$ = makeDefElem("format", (Node *)makeString("csv"), @1);
}
| HEADER_P
{
- $$ = makeDefElem("header", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("header", (Node *)makeInteger(TRUE), @1);
}
| QUOTE opt_as Sconst
{
- $$ = makeDefElem("quote", (Node *)makeString($3));
+ $$ = makeDefElem("quote", (Node *)makeString($3), @1);
}
| ESCAPE opt_as Sconst
{
- $$ = makeDefElem("escape", (Node *)makeString($3));
+ $$ = makeDefElem("escape", (Node *)makeString($3), @1);
}
| FORCE QUOTE columnList
{
- $$ = makeDefElem("force_quote", (Node *)$3);
+ $$ = makeDefElem("force_quote", (Node *)$3, @1);
}
| FORCE QUOTE '*'
{
- $$ = makeDefElem("force_quote", (Node *)makeNode(A_Star));
+ $$ = makeDefElem("force_quote", (Node *)makeNode(A_Star), @1);
}
| FORCE NOT NULL_P columnList
{
- $$ = makeDefElem("force_not_null", (Node *)$4);
+ $$ = makeDefElem("force_not_null", (Node *)$4, @1);
}
| FORCE NULL_P columnList
{
- $$ = makeDefElem("force_null", (Node *)$3);
+ $$ = makeDefElem("force_null", (Node *)$3, @1);
}
| ENCODING Sconst
{
- $$ = makeDefElem("encoding", (Node *)makeString($2));
+ $$ = makeDefElem("encoding", (Node *)makeString($2), @1);
}
;
opt_binary:
BINARY
{
- $$ = makeDefElem("format", (Node *)makeString("binary"));
+ $$ = makeDefElem("format", (Node *)makeString("binary"), @1);
}
| /*EMPTY*/ { $$ = NULL; }
;
opt_oids:
WITH OIDS
{
- $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("oids", (Node *)makeInteger(TRUE), @1);
}
| /*EMPTY*/ { $$ = NULL; }
;
copy_delimiter:
opt_using DELIMITERS Sconst
{
- $$ = makeDefElem("delimiter", (Node *)makeString($3));
+ $$ = makeDefElem("delimiter", (Node *)makeString($3), @2);
}
| /*EMPTY*/ { $$ = NULL; }
;
copy_generic_opt_elem:
ColLabel copy_generic_opt_arg
{
- $$ = makeDefElem($1, $2);
+ $$ = makeDefElem($1, $2, @1);
}
;
/* WITH (options) is preferred, WITH OIDS and WITHOUT OIDS are legacy forms */
OptWith:
WITH reloptions { $$ = $2; }
- | WITH OIDS { $$ = list_make1(defWithOids(true)); }
- | WITHOUT OIDS { $$ = list_make1(defWithOids(false)); }
+ | WITH OIDS { $$ = list_make1(makeDefElem("oids", (Node *) makeInteger(true), @1)); }
+ | WITHOUT OIDS { $$ = list_make1(makeDefElem("oids", (Node *) makeInteger(false), @1)); }
| /*EMPTY*/ { $$ = NIL; }
;
SeqOptElem: CACHE NumericOnly
{
- $$ = makeDefElem("cache", (Node *)$2);
+ $$ = makeDefElem("cache", (Node *)$2, @1);
}
| CYCLE
{
- $$ = makeDefElem("cycle", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("cycle", (Node *)makeInteger(TRUE), @1);
}
| NO CYCLE
{
- $$ = makeDefElem("cycle", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("cycle", (Node *)makeInteger(FALSE), @1);
}
| INCREMENT opt_by NumericOnly
{
- $$ = makeDefElem("increment", (Node *)$3);
+ $$ = makeDefElem("increment", (Node *)$3, @1);
}
| MAXVALUE NumericOnly
{
- $$ = makeDefElem("maxvalue", (Node *)$2);
+ $$ = makeDefElem("maxvalue", (Node *)$2, @1);
}
| MINVALUE NumericOnly
{
- $$ = makeDefElem("minvalue", (Node *)$2);
+ $$ = makeDefElem("minvalue", (Node *)$2, @1);
}
| NO MAXVALUE
{
- $$ = makeDefElem("maxvalue", NULL);
+ $$ = makeDefElem("maxvalue", NULL, @1);
}
| NO MINVALUE
{
- $$ = makeDefElem("minvalue", NULL);
+ $$ = makeDefElem("minvalue", NULL, @1);
}
| OWNED BY any_name
{
- $$ = makeDefElem("owned_by", (Node *)$3);
+ $$ = makeDefElem("owned_by", (Node *)$3, @1);
}
| START opt_with NumericOnly
{
- $$ = makeDefElem("start", (Node *)$3);
+ $$ = makeDefElem("start", (Node *)$3, @1);
}
| RESTART
{
- $$ = makeDefElem("restart", NULL);
+ $$ = makeDefElem("restart", NULL, @1);
}
| RESTART opt_with NumericOnly
{
- $$ = makeDefElem("restart", (Node *)$3);
+ $$ = makeDefElem("restart", (Node *)$3, @1);
}
;
create_extension_opt_item:
SCHEMA name
{
- $$ = makeDefElem("schema", (Node *)makeString($2));
+ $$ = makeDefElem("schema", (Node *)makeString($2), @1);
}
| VERSION_P NonReservedWord_or_Sconst
{
- $$ = makeDefElem("new_version", (Node *)makeString($2));
+ $$ = makeDefElem("new_version", (Node *)makeString($2), @1);
}
| FROM NonReservedWord_or_Sconst
{
- $$ = makeDefElem("old_version", (Node *)makeString($2));
+ $$ = makeDefElem("old_version", (Node *)makeString($2), @1);
}
| CASCADE
{
- $$ = makeDefElem("cascade", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("cascade", (Node *)makeInteger(TRUE), @1);
}
;
alter_extension_opt_item:
TO NonReservedWord_or_Sconst
{
- $$ = makeDefElem("new_version", (Node *)makeString($2));
+ $$ = makeDefElem("new_version", (Node *)makeString($2), @1);
}
;
;
fdw_option:
- HANDLER handler_name { $$ = makeDefElem("handler", (Node *)$2); }
- | NO HANDLER { $$ = makeDefElem("handler", NULL); }
- | VALIDATOR handler_name { $$ = makeDefElem("validator", (Node *)$2); }
- | NO VALIDATOR { $$ = makeDefElem("validator", NULL); }
+ HANDLER handler_name { $$ = makeDefElem("handler", (Node *)$2, @1); }
+ | NO HANDLER { $$ = makeDefElem("handler", NULL, @1); }
+ | VALIDATOR handler_name { $$ = makeDefElem("validator", (Node *)$2, @1); }
+ | NO VALIDATOR { $$ = makeDefElem("validator", NULL, @1); }
;
fdw_options:
}
| DROP generic_option_name
{
- $$ = makeDefElemExtended(NULL, $2, NULL, DEFELEM_DROP);
+ $$ = makeDefElemExtended(NULL, $2, NULL, DEFELEM_DROP, @2);
}
;
generic_option_elem:
generic_option_name generic_option_arg
{
- $$ = makeDefElem($1, $2);
+ $$ = makeDefElem($1, $2, @1);
}
;
event_trigger_when_item:
ColId IN_P '(' event_trigger_value_list ')'
- { $$ = makeDefElem($1, (Node *) $4); }
+ { $$ = makeDefElem($1, (Node *) $4, @1); }
;
event_trigger_value_list:
n->kind = OBJECT_COLLATION;
n->args = NIL;
n->defnames = $3;
- n->definition = list_make1(makeDefElem("from", (Node *) $5));
+ n->definition = list_make1(makeDefElem("from", (Node *) $5, @5));
$$ = (Node *)n;
}
;
def_elem: ColLabel '=' def_arg
{
- $$ = makeDefElem($1, (Node *) $3);
+ $$ = makeDefElem($1, (Node *) $3, @1);
}
| ColLabel
{
- $$ = makeDefElem($1, NULL);
+ $$ = makeDefElem($1, NULL, @1);
}
;
*/
old_aggr_elem: IDENT '=' def_arg
{
- $$ = makeDefElem($1, (Node *)$3);
+ $$ = makeDefElem($1, (Node *)$3, @1);
}
;
DefACLOption:
IN_P SCHEMA name_list
{
- $$ = makeDefElem("schemas", (Node *)$3);
+ $$ = makeDefElem("schemas", (Node *)$3, @1);
}
| FOR ROLE role_list
{
- $$ = makeDefElem("roles", (Node *)$3);
+ $$ = makeDefElem("roles", (Node *)$3, @1);
}
| FOR USER role_list
{
- $$ = makeDefElem("roles", (Node *)$3);
+ $$ = makeDefElem("roles", (Node *)$3, @1);
}
;
common_func_opt_item:
CALLED ON NULL_P INPUT_P
{
- $$ = makeDefElem("strict", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("strict", (Node *)makeInteger(FALSE), @1);
}
| RETURNS NULL_P ON NULL_P INPUT_P
{
- $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("strict", (Node *)makeInteger(TRUE), @1);
}
| STRICT_P
{
- $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("strict", (Node *)makeInteger(TRUE), @1);
}
| IMMUTABLE
{
- $$ = makeDefElem("volatility", (Node *)makeString("immutable"));
+ $$ = makeDefElem("volatility", (Node *)makeString("immutable"), @1);
}
| STABLE
{
- $$ = makeDefElem("volatility", (Node *)makeString("stable"));
+ $$ = makeDefElem("volatility", (Node *)makeString("stable"), @1);
}
| VOLATILE
{
- $$ = makeDefElem("volatility", (Node *)makeString("volatile"));
+ $$ = makeDefElem("volatility", (Node *)makeString("volatile"), @1);
}
| EXTERNAL SECURITY DEFINER
{
- $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("security", (Node *)makeInteger(TRUE), @1);
}
| EXTERNAL SECURITY INVOKER
{
- $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("security", (Node *)makeInteger(FALSE), @1);
}
| SECURITY DEFINER
{
- $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("security", (Node *)makeInteger(TRUE), @1);
}
| SECURITY INVOKER
{
- $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("security", (Node *)makeInteger(FALSE), @1);
}
| LEAKPROOF
{
- $$ = makeDefElem("leakproof", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("leakproof", (Node *)makeInteger(TRUE), @1);
}
| NOT LEAKPROOF
{
- $$ = makeDefElem("leakproof", (Node *)makeInteger(FALSE));
+ $$ = makeDefElem("leakproof", (Node *)makeInteger(FALSE), @1);
}
| COST NumericOnly
{
- $$ = makeDefElem("cost", (Node *)$2);
+ $$ = makeDefElem("cost", (Node *)$2, @1);
}
| ROWS NumericOnly
{
- $$ = makeDefElem("rows", (Node *)$2);
+ $$ = makeDefElem("rows", (Node *)$2, @1);
}
| FunctionSetResetClause
{
/* we abuse the normal content of a DefElem here */
- $$ = makeDefElem("set", (Node *)$1);
+ $$ = makeDefElem("set", (Node *)$1, @1);
}
| PARALLEL ColId
{
- $$ = makeDefElem("parallel", (Node *)makeString($2));
+ $$ = makeDefElem("parallel", (Node *)makeString($2), @1);
}
;
createfunc_opt_item:
AS func_as
{
- $$ = makeDefElem("as", (Node *)$2);
+ $$ = makeDefElem("as", (Node *)$2, @1);
}
| LANGUAGE NonReservedWord_or_Sconst
{
- $$ = makeDefElem("language", (Node *)makeString($2));
+ $$ = makeDefElem("language", (Node *)makeString($2), @1);
}
| TRANSFORM transform_type_list
{
- $$ = makeDefElem("transform", (Node *)$2);
+ $$ = makeDefElem("transform", (Node *)$2, @1);
}
| WINDOW
{
- $$ = makeDefElem("window", (Node *)makeInteger(TRUE));
+ $$ = makeDefElem("window", (Node *)makeInteger(TRUE), @1);
}
| common_func_opt_item
{
dostmt_opt_item:
Sconst
{
- $$ = makeDefElem("as", (Node *)makeString($1));
+ $$ = makeDefElem("as", (Node *)makeString($1), @1);
}
| LANGUAGE NonReservedWord_or_Sconst
{
- $$ = makeDefElem("language", (Node *)makeString($2));
+ $$ = makeDefElem("language", (Node *)makeString($2), @1);
}
;
;
operator_def_elem: ColLabel '=' NONE
- { $$ = makeDefElem($1, NULL); }
+ { $$ = makeDefElem($1, NULL, @1); }
| ColLabel '=' def_arg
- { $$ = makeDefElem($1, (Node *) $3); }
+ { $$ = makeDefElem($1, (Node *) $3, @1); }
;
/*****************************************************************************
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_SAVEPOINT;
n->options = list_make1(makeDefElem("savepoint_name",
- (Node *)makeString($2)));
+ (Node *)makeString($2), @1));
$$ = (Node *)n;
}
| RELEASE SAVEPOINT ColId
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_RELEASE;
n->options = list_make1(makeDefElem("savepoint_name",
- (Node *)makeString($3)));
+ (Node *)makeString($3), @1));
$$ = (Node *)n;
}
| RELEASE ColId
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_RELEASE;
n->options = list_make1(makeDefElem("savepoint_name",
- (Node *)makeString($2)));
+ (Node *)makeString($2), @1));
$$ = (Node *)n;
}
| ROLLBACK opt_transaction TO SAVEPOINT ColId
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_ROLLBACK_TO;
n->options = list_make1(makeDefElem("savepoint_name",
- (Node *)makeString($5)));
+ (Node *)makeString($5), @1));
$$ = (Node *)n;
}
| ROLLBACK opt_transaction TO ColId
TransactionStmt *n = makeNode(TransactionStmt);
n->kind = TRANS_STMT_ROLLBACK_TO;
n->options = list_make1(makeDefElem("savepoint_name",
- (Node *)makeString($4)));
+ (Node *)makeString($4), @1));
$$ = (Node *)n;
}
| PREPARE TRANSACTION Sconst
transaction_mode_item:
ISOLATION LEVEL iso_level
{ $$ = makeDefElem("transaction_isolation",
- makeStringConst($3, @3)); }
+ makeStringConst($3, @3), @1); }
| READ ONLY
{ $$ = makeDefElem("transaction_read_only",
- makeIntConst(TRUE, @1)); }
+ makeIntConst(TRUE, @1), @1); }
| READ WRITE
{ $$ = makeDefElem("transaction_read_only",
- makeIntConst(FALSE, @1)); }
+ makeIntConst(FALSE, @1), @1); }
| DEFERRABLE
{ $$ = makeDefElem("transaction_deferrable",
- makeIntConst(TRUE, @1)); }
+ makeIntConst(TRUE, @1), @1); }
| NOT DEFERRABLE
{ $$ = makeDefElem("transaction_deferrable",
- makeIntConst(FALSE, @1)); }
+ makeIntConst(FALSE, @1), @1); }
;
/* Syntax with commas is SQL-spec, without commas is Postgres historical */
createdb_opt_item:
createdb_opt_name opt_equal SignedIconst
{
- $$ = makeDefElem($1, (Node *)makeInteger($3));
+ $$ = makeDefElem($1, (Node *)makeInteger($3), @1);
}
| createdb_opt_name opt_equal opt_boolean_or_string
{
- $$ = makeDefElem($1, (Node *)makeString($3));
+ $$ = makeDefElem($1, (Node *)makeString($3), @1);
}
| createdb_opt_name opt_equal DEFAULT
{
- $$ = makeDefElem($1, NULL);
+ $$ = makeDefElem($1, NULL, @1);
}
;
AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
n->dbname = $3;
n->options = list_make1(makeDefElem("tablespace",
- (Node *)makeString($6)));
+ (Node *)makeString($6), @6));
$$ = (Node *)n;
}
;
{
ExplainStmt *n = makeNode(ExplainStmt);
n->query = $4;
- n->options = list_make1(makeDefElem("analyze", NULL));
+ n->options = list_make1(makeDefElem("analyze", NULL, @2));
if ($3)
n->options = lappend(n->options,
- makeDefElem("verbose", NULL));
+ makeDefElem("verbose", NULL, @3));
$$ = (Node *) n;
}
| EXPLAIN VERBOSE ExplainableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
n->query = $3;
- n->options = list_make1(makeDefElem("verbose", NULL));
+ n->options = list_make1(makeDefElem("verbose", NULL, @2));
$$ = (Node *) n;
}
| EXPLAIN '(' explain_option_list ')' ExplainableStmt
explain_option_elem:
explain_option_name explain_option_arg
{
- $$ = makeDefElem($1, $2);
+ $$ = makeDefElem($1, $2, @1);
}
;
* overridden if an inherited table has oids.
*/
stmt->options = lcons(makeDefElem("oids",
- (Node *) makeInteger(cxt.hasoids)), stmt->options);
+ (Node *) makeInteger(cxt.hasoids), -1),
+ stmt->options);
}
foreach(elements, stmt->tableElts)
makeString(cxt->relation->relname),
makeString(column->colname));
altseqstmt->options = list_make1(makeDefElem("owned_by",
- (Node *) attnamelist));
+ (Node *) attnamelist, -1));
cxt->alist = lappend(cxt->alist, altseqstmt);
char *name = TextDatumGetCString(datum_opts[i]);
char *opt = TextDatumGetCString(datum_opts[i + 1]);
- options = lappend(options, makeDefElem(name, (Node *) makeString(opt)));
+ options = lappend(options, makeDefElem(name, (Node *) makeString(opt), -1));
}
}
K_LABEL SCONST
{
$$ = makeDefElem("label",
- (Node *)makeString($2));
+ (Node *)makeString($2), -1);
}
| K_PROGRESS
{
$$ = makeDefElem("progress",
- (Node *)makeInteger(TRUE));
+ (Node *)makeInteger(TRUE), -1);
}
| K_FAST
{
$$ = makeDefElem("fast",
- (Node *)makeInteger(TRUE));
+ (Node *)makeInteger(TRUE), -1);
}
| K_WAL
{
$$ = makeDefElem("wal",
- (Node *)makeInteger(TRUE));
+ (Node *)makeInteger(TRUE), -1);
}
| K_NOWAIT
{
$$ = makeDefElem("nowait",
- (Node *)makeInteger(TRUE));
+ (Node *)makeInteger(TRUE), -1);
}
| K_MAX_RATE UCONST
{
$$ = makeDefElem("max_rate",
- (Node *)makeInteger($2));
+ (Node *)makeInteger($2), -1);
}
| K_TABLESPACE_MAP
{
$$ = makeDefElem("tablespace_map",
- (Node *)makeInteger(TRUE));
+ (Node *)makeInteger(TRUE), -1);
}
;
plugin_opt_elem:
IDENT plugin_opt_arg
{
- $$ = makeDefElem($1, $2);
+ $$ = makeDefElem($1, $2, -1);
}
;
ProcessUtility_hook_type ProcessUtility_hook = NULL;
/* local function declarations */
-static void ProcessUtilitySlow(Node *parsetree,
+static void ProcessUtilitySlow(ParseState *pstate,
+ Node *parsetree,
const char *queryString,
ProcessUtilityContext context,
ParamListInfo params,
char *completionTag)
{
bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
+ ParseState *pstate;
check_xact_readonly(parsetree);
if (completionTag)
completionTag[0] = '\0';
+ pstate = make_parsestate(NULL);
+ pstate->p_sourcetext = queryString;
+
switch (nodeTag(parsetree))
{
/*
{
uint64 processed;
- DoCopy((CopyStmt *) parsetree, queryString, &processed);
+ DoCopy(pstate, (CopyStmt *) parsetree, &processed);
if (completionTag)
snprintf(completionTag, COMPLETION_TAG_BUFSIZE,
"COPY " UINT64_FORMAT, processed);
case T_CreatedbStmt:
/* no event triggers for global objects */
PreventTransactionChain(isTopLevel, "CREATE DATABASE");
- createdb((CreatedbStmt *) parsetree);
+ createdb(pstate, (CreatedbStmt *) parsetree);
break;
case T_AlterDatabaseStmt:
/* no event triggers for global objects */
- AlterDatabase((AlterDatabaseStmt *) parsetree, isTopLevel);
+ AlterDatabase(pstate, (AlterDatabaseStmt *) parsetree, isTopLevel);
break;
case T_AlterDatabaseSetStmt:
break;
case T_ExplainStmt:
- ExplainQuery((ExplainStmt *) parsetree, queryString, params, dest);
+ ExplainQuery(pstate, (ExplainStmt *) parsetree, queryString, params, dest);
break;
case T_AlterSystemStmt:
*/
case T_CreateRoleStmt:
/* no event triggers for global objects */
- CreateRole((CreateRoleStmt *) parsetree);
+ CreateRole(pstate, (CreateRoleStmt *) parsetree);
break;
case T_AlterRoleStmt:
GrantStmt *stmt = (GrantStmt *) parsetree;
if (EventTriggerSupportsGrantObjectType(stmt->objtype))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
DropStmt *stmt = (DropStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->removeType))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
RenameStmt *stmt = (RenameStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->renameType))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
AlterObjectDependsStmt *stmt = (AlterObjectDependsStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->objectType))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->objectType))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
AlterOwnerStmt *stmt = (AlterOwnerStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->objectType))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
CommentStmt *stmt = (CommentStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->objtype))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
SecLabelStmt *stmt = (SecLabelStmt *) parsetree;
if (EventTriggerSupportsObjectType(stmt->objtype))
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
else
default:
/* All other statement types have event trigger support */
- ProcessUtilitySlow(parsetree, queryString,
+ ProcessUtilitySlow(pstate, parsetree, queryString,
context, params,
dest, completionTag);
break;
}
+
+ free_parsestate(pstate);
}
/*
* perform the trigger support calls if the context allows it.
*/
static void
-ProcessUtilitySlow(Node *parsetree,
+ProcessUtilitySlow(ParseState *pstate,
+ Node *parsetree,
const char *queryString,
ProcessUtilityContext context,
ParamListInfo params,
{
case OBJECT_AGGREGATE:
address =
- DefineAggregate(stmt->defnames, stmt->args,
+ DefineAggregate(pstate, stmt->defnames, stmt->args,
stmt->oldstyle,
- stmt->definition, queryString);
+ stmt->definition);
break;
case OBJECT_OPERATOR:
Assert(stmt->args == NIL);
break;
case OBJECT_TYPE:
Assert(stmt->args == NIL);
- address = DefineType(stmt->defnames,
+ address = DefineType(pstate,
+ stmt->defnames,
stmt->definition);
break;
case OBJECT_TSPARSER:
break;
case OBJECT_COLLATION:
Assert(stmt->args == NIL);
- address = DefineCollation(stmt->defnames,
+ address = DefineCollation(pstate,
+ stmt->defnames,
stmt->definition);
break;
default:
break;
case T_CreateExtensionStmt:
- address = CreateExtension((CreateExtensionStmt *) parsetree);
+ address = CreateExtension(pstate, (CreateExtensionStmt *) parsetree);
break;
case T_AlterExtensionStmt:
- address = ExecAlterExtensionStmt((AlterExtensionStmt *) parsetree);
+ address = ExecAlterExtensionStmt(pstate, (AlterExtensionStmt *) parsetree);
break;
case T_AlterExtensionContentsStmt:
break;
case T_CreateFunctionStmt: /* CREATE FUNCTION */
- address = CreateFunction((CreateFunctionStmt *) parsetree, queryString);
+ address = CreateFunction(pstate, (CreateFunctionStmt *) parsetree);
break;
case T_AlterFunctionStmt: /* ALTER FUNCTION */
- address = AlterFunction((AlterFunctionStmt *) parsetree);
+ address = AlterFunction(pstate, (AlterFunctionStmt *) parsetree);
break;
case T_RuleStmt: /* CREATE RULE */
break;
case T_CreateSeqStmt:
- address = DefineSequence((CreateSeqStmt *) parsetree);
+ address = DefineSequence(pstate, (CreateSeqStmt *) parsetree);
break;
case T_AlterSeqStmt:
- address = AlterSequence((AlterSeqStmt *) parsetree);
+ address = AlterSequence(pstate, (AlterSeqStmt *) parsetree);
break;
case T_CreateTableAsStmt:
break;
case T_AlterDefaultPrivilegesStmt:
- ExecAlterDefaultPrivilegesStmt((AlterDefaultPrivilegesStmt *) parsetree);
+ ExecAlterDefaultPrivilegesStmt(pstate, (AlterDefaultPrivilegesStmt *) parsetree);
EventTriggerCollectAlterDefPrivs((AlterDefaultPrivilegesStmt *) parsetree);
commandCollected = true;
break;
#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"
-extern ObjectAddress DefineCollation(List *names, List *parameters);
+extern ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters);
extern void IsThereCollationInNamespace(const char *collname, Oid nspOid);
#endif /* COLLATIONCMDS_H */
#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
#include "tcop/dest.h"
/* CopyStateData is private in commands/copy.c */
typedef struct CopyStateData *CopyState;
-extern Oid DoCopy(const CopyStmt *stmt, const char *queryString,
+extern Oid DoCopy(ParseState *state, const CopyStmt *stmt,
uint64 *processed);
-extern void ProcessCopyOptions(CopyState cstate, bool is_from, List *options);
-extern CopyState BeginCopyFrom(Relation rel, const char *filename,
+extern void ProcessCopyOptions(ParseState *pstate, CopyState cstate, bool is_from, List *options);
+extern CopyState BeginCopyFrom(ParseState *pstate, Relation rel, const char *filename,
bool is_program, List *attnamelist, List *options);
extern void EndCopyFrom(CopyState cstate);
extern bool NextCopyFrom(CopyState cstate, ExprContext *econtext,
#include "lib/stringinfo.h"
#include "nodes/parsenodes.h"
-extern Oid createdb(const CreatedbStmt *stmt);
+extern Oid createdb(ParseState *pstate, const CreatedbStmt *stmt);
extern void dropdb(const char *dbname, bool missing_ok);
extern ObjectAddress RenameDatabase(const char *oldname, const char *newname);
-extern Oid AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel);
+extern Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel);
extern Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
extern ObjectAddress AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
extern Oid GetDefaultOpClass(Oid type_id, Oid am_id);
/* commands/functioncmds.c */
-extern ObjectAddress CreateFunction(CreateFunctionStmt *stmt, const char *queryString);
+extern ObjectAddress CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt);
extern void RemoveFunctionById(Oid funcOid);
extern void SetFunctionReturnType(Oid funcOid, Oid newRetType);
extern void SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType);
-extern ObjectAddress AlterFunction(AlterFunctionStmt *stmt);
+extern ObjectAddress AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt);
extern ObjectAddress CreateCast(CreateCastStmt *stmt);
extern void DropCastById(Oid castOid);
extern ObjectAddress CreateTransform(CreateTransformStmt *stmt);
extern void ExecuteDoStmt(DoStmt *stmt);
extern Oid get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok);
extern Oid get_transform_oid(Oid type_id, Oid lang_id, bool missing_ok);
-extern void interpret_function_parameter_list(List *parameters,
+extern void interpret_function_parameter_list(ParseState *pstate,
+ List *parameters,
Oid languageOid,
bool is_aggregate,
- const char *queryString,
oidvector **parameterTypes,
ArrayType **allParameterTypes,
ArrayType **parameterModes,
extern ObjectAddress AlterOperator(AlterOperatorStmt *stmt);
/* commands/aggregatecmds.c */
-extern ObjectAddress DefineAggregate(List *name, List *args, bool oldstyle,
- List *parameters, const char *queryString);
+extern ObjectAddress DefineAggregate(ParseState *pstate, List *name, List *args, bool oldstyle,
+ List *parameters);
/* commands/opclasscmds.c */
extern ObjectAddress DefineOpClass(CreateOpClassStmt *stmt);
extern List *defGetQualifiedName(DefElem *def);
extern TypeName *defGetTypeName(DefElem *def);
extern int defGetTypeLength(DefElem *def);
-extern DefElem *defWithOids(bool value);
#endif /* DEFREM_H */
#include "executor/executor.h"
#include "lib/stringinfo.h"
+#include "parser/parse_node.h"
typedef enum ExplainFormat
{
extern PGDLLIMPORT explain_get_index_name_hook_type explain_get_index_name_hook;
-extern void ExplainQuery(ExplainStmt *stmt, const char *queryString,
+extern void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, const char *queryString,
ParamListInfo params, DestReceiver *dest);
extern ExplainState *NewExplainState(void);
extern Oid CurrentExtensionObject;
-extern ObjectAddress CreateExtension(CreateExtensionStmt *stmt);
+extern ObjectAddress CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt);
extern void RemoveExtensionById(Oid extId);
Datum extConfig, Datum extCondition,
List *requiredExtensions);
-extern ObjectAddress ExecAlterExtensionStmt(AlterExtensionStmt *stmt);
+extern ObjectAddress ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt);
extern ObjectAddress ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt,
ObjectAddress *objAddress);
#include "fmgr.h"
#include "lib/stringinfo.h"
#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
#include "storage/relfilenode.h"
extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
-extern ObjectAddress DefineSequence(CreateSeqStmt *stmt);
-extern ObjectAddress AlterSequence(AlterSeqStmt *stmt);
+extern ObjectAddress DefineSequence(ParseState *pstate, CreateSeqStmt *stmt);
+extern ObjectAddress AlterSequence(ParseState *pstate, AlterSeqStmt *stmt);
extern void ResetSequence(Oid seq_relid);
extern void ResetSequenceCaches(void);
#define DEFAULT_TYPDELIM ','
-extern ObjectAddress DefineType(List *names, List *parameters);
+extern ObjectAddress DefineType(ParseState *pstate, List *names, List *parameters);
extern void RemoveTypeById(Oid typeOid);
extern ObjectAddress DefineDomain(CreateDomainStmt *stmt);
extern ObjectAddress DefineEnum(CreateEnumStmt *stmt);
#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
/* Hook to check passwords in CreateRole() and AlterRole() */
extern PGDLLIMPORT check_password_hook_type check_password_hook;
-extern Oid CreateRole(CreateRoleStmt *stmt);
+extern Oid CreateRole(ParseState *pstate, CreateRoleStmt *stmt);
extern Oid AlterRole(AlterRoleStmt *stmt);
extern Oid AlterRoleSet(AlterRoleSetStmt *stmt);
extern void DropRole(DropRoleStmt *stmt);
extern FuncCall *makeFuncCall(List *name, List *args, int location);
-extern DefElem *makeDefElem(char *name, Node *arg);
+extern DefElem *makeDefElem(char *name, Node *arg, int location);
extern DefElem *makeDefElemExtended(char *nameSpace, char *name, Node *arg,
- DefElemAction defaction);
+ DefElemAction defaction, int location);
extern GroupingSet *makeGroupingSet(GroupingSetKind kind, List *content, int location);
char *defname;
Node *arg; /* a (Value *) or a (TypeName *) */
DefElemAction defaction; /* unspecified action, or SET/ADD/DROP */
+ int location; /* token location, or -1 if unknown */
} DefElem;
/*
#include "access/htup.h"
#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
#include "utils/array.h"
#include "utils/snapshot.h"
* prototypes for functions in aclchk.c
*/
extern void ExecuteGrantStmt(GrantStmt *stmt);
-extern void ExecAlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt *stmt);
+extern void ExecAlterDefaultPrivilegesStmt(ParseState *pstate, AlterDefaultPrivilegesStmt *stmt);
extern void RemoveRoleFromObjectACL(Oid roleid, Oid classid, Oid objid);
extern void RemoveDefaultACLById(Oid defaclOid);
projects / users / heikki / postgres.git / commitdiff