mirror of
https://github.com/postgres/postgres.git
synced 2025-07-09 22:41:56 +03:00
pgindent run for 9.0
This commit is contained in:
Bruce Momjian
@ -17,7 +17,7 @@
|
||||
* Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.401 2010/02/12 22:48:56 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.402 2010/02/26 02:00:49 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -53,7 +53,7 @@ static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
|
||||
static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
|
||||
bool isTopLevel, List **colInfo);
|
||||
static void determineRecursiveColTypes(ParseState *pstate,
|
||||
Node *larg, List *lcolinfo);
|
||||
Node *larg, List *lcolinfo);
|
||||
static void applyColumnNames(List *dst, List *src);
|
||||
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
|
||||
static List *transformReturningList(ParseState *pstate, List *returningList);
|
||||
@ -62,7 +62,7 @@ static Query *transformDeclareCursorStmt(ParseState *pstate,
|
||||
static Query *transformExplainStmt(ParseState *pstate,
|
||||
ExplainStmt *stmt);
|
||||
static void transformLockingClause(ParseState *pstate, Query *qry,
|
||||
LockingClause *lc, bool pushedDown);
|
||||
LockingClause *lc, bool pushedDown);
|
||||
|
||||
|
||||
/*
|
||||
@ -823,14 +823,14 @@ transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
|
||||
qry->sortClause = transformSortClause(pstate,
|
||||
stmt->sortClause,
|
||||
&qry->targetList,
|
||||
true /* fix unknowns */,
|
||||
false /* allow SQL92 rules */);
|
||||
true /* fix unknowns */ ,
|
||||
false /* allow SQL92 rules */ );
|
||||
|
||||
qry->groupClause = transformGroupClause(pstate,
|
||||
stmt->groupClause,
|
||||
&qry->targetList,
|
||||
qry->sortClause,
|
||||
false /* allow SQL92 rules */);
|
||||
false /* allow SQL92 rules */ );
|
||||
|
||||
if (stmt->distinctClause == NIL)
|
||||
{
|
||||
@ -1040,8 +1040,8 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt)
|
||||
qry->sortClause = transformSortClause(pstate,
|
||||
stmt->sortClause,
|
||||
&qry->targetList,
|
||||
true /* fix unknowns */,
|
||||
false /* allow SQL92 rules */);
|
||||
true /* fix unknowns */ ,
|
||||
false /* allow SQL92 rules */ );
|
||||
|
||||
qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
|
||||
"OFFSET");
|
||||
@ -1294,8 +1294,8 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
|
||||
qry->sortClause = transformSortClause(pstate,
|
||||
sortClause,
|
||||
&qry->targetList,
|
||||
false /* no unknowns expected */,
|
||||
false /* allow SQL92 rules */);
|
||||
false /* no unknowns expected */ ,
|
||||
false /* allow SQL92 rules */ );
|
||||
|
||||
pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length);
|
||||
pstate->p_relnamespace = sv_relnamespace;
|
||||
@ -1494,8 +1494,8 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
|
||||
&lcolinfo);
|
||||
|
||||
/*
|
||||
* If we are processing a recursive union query, now is the time
|
||||
* to examine the non-recursive term's output columns and mark the
|
||||
* If we are processing a recursive union query, now is the time to
|
||||
* examine the non-recursive term's output columns and mark the
|
||||
* containing CTE as having those result columns. We should do this
|
||||
* only at the topmost setop of the CTE, of course.
|
||||
*/
|
||||
@ -1552,25 +1552,25 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
|
||||
rescoltypmod = -1;
|
||||
|
||||
/*
|
||||
* Verify the coercions are actually possible. If not, we'd
|
||||
* fail later anyway, but we want to fail now while we have
|
||||
* sufficient context to produce an error cursor position.
|
||||
* Verify the coercions are actually possible. If not, we'd fail
|
||||
* later anyway, but we want to fail now while we have sufficient
|
||||
* context to produce an error cursor position.
|
||||
*
|
||||
* The if-tests might look wrong, but they are correct: we should
|
||||
* verify if the input is non-UNKNOWN *or* if it is an UNKNOWN
|
||||
* Const (to verify the literal is valid for the target data type)
|
||||
* or Param (to possibly resolve the Param's type). We should do
|
||||
* nothing if the input is say an UNKNOWN Var, which can happen in
|
||||
* some cases. The planner is sometimes able to fold the Var to a
|
||||
* some cases. The planner is sometimes able to fold the Var to a
|
||||
* constant before it has to coerce the type, so failing now would
|
||||
* just break cases that might work.
|
||||
*/
|
||||
if (lcoltype != UNKNOWNOID ||
|
||||
IsA(lcolnode, Const) || IsA(lcolnode, Param))
|
||||
IsA(lcolnode, Const) ||IsA(lcolnode, Param))
|
||||
(void) coerce_to_common_type(pstate, lcolnode,
|
||||
rescoltype, context);
|
||||
if (rcoltype != UNKNOWNOID ||
|
||||
IsA(rcolnode, Const) || IsA(rcolnode, Param))
|
||||
IsA(rcolnode, Const) ||IsA(rcolnode, Param))
|
||||
(void) coerce_to_common_type(pstate, rcolnode,
|
||||
rescoltype, context);
|
||||
|
||||
@ -1647,8 +1647,8 @@ determineRecursiveColTypes(ParseState *pstate, Node *larg, List *lcolinfo)
|
||||
Assert(leftmostQuery != NULL);
|
||||
|
||||
/*
|
||||
* Generate dummy targetlist using column names of leftmost select
|
||||
* and dummy result expressions of the non-recursive term.
|
||||
* Generate dummy targetlist using column names of leftmost select and
|
||||
* dummy result expressions of the non-recursive term.
|
||||
*/
|
||||
targetList = NIL;
|
||||
left_tlist = list_head(leftmostQuery->targetList);
|
||||
@ -2095,12 +2095,13 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
|
||||
case RTE_SUBQUERY:
|
||||
applyLockingClause(qry, i,
|
||||
lc->forUpdate, lc->noWait, pushedDown);
|
||||
|
||||
/*
|
||||
* FOR UPDATE/SHARE of subquery is propagated to all of
|
||||
* subquery's rels, too. We could do this later (based
|
||||
* on the marking of the subquery RTE) but it is convenient
|
||||
* to have local knowledge in each query level about
|
||||
* which rels need to be opened with RowShareLock.
|
||||
* subquery's rels, too. We could do this later (based on
|
||||
* the marking of the subquery RTE) but it is convenient
|
||||
* to have local knowledge in each query level about which
|
||||
* rels need to be opened with RowShareLock.
|
||||
*/
|
||||
transformLockingClause(pstate, rte->subquery,
|
||||
allrels, true);
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.91 2010/02/12 17:33:20 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.92 2010/02/26 02:00:49 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -51,7 +51,7 @@ static bool check_ungrouped_columns_walker(Node *node,
|
||||
*
|
||||
* Here we convert the args list into a targetlist by inserting TargetEntry
|
||||
* nodes, and then transform the aggorder and agg_distinct specifications to
|
||||
* produce lists of SortGroupClause nodes. (That might also result in adding
|
||||
* produce lists of SortGroupClause nodes. (That might also result in adding
|
||||
* resjunk expressions to the targetlist.)
|
||||
*
|
||||
* We must also determine which query level the aggregate actually belongs to,
|
||||
@ -61,11 +61,11 @@ static bool check_ungrouped_columns_walker(Node *node,
|
||||
void
|
||||
transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
|
||||
{
|
||||
List *tlist;
|
||||
List *torder;
|
||||
List *tdistinct = NIL;
|
||||
AttrNumber attno;
|
||||
int save_next_resno;
|
||||
List *tlist;
|
||||
List *torder;
|
||||
List *tdistinct = NIL;
|
||||
AttrNumber attno;
|
||||
int save_next_resno;
|
||||
int min_varlevel;
|
||||
ListCell *lc;
|
||||
|
||||
@ -77,7 +77,7 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
|
||||
attno = 1;
|
||||
foreach(lc, agg->args)
|
||||
{
|
||||
Expr *arg = (Expr *) lfirst(lc);
|
||||
Expr *arg = (Expr *) lfirst(lc);
|
||||
TargetEntry *tle = makeTargetEntry(arg, attno++, NULL, false);
|
||||
|
||||
tlist = lappend(tlist, tle);
|
||||
@ -98,8 +98,8 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
|
||||
torder = transformSortClause(pstate,
|
||||
agg->aggorder,
|
||||
&tlist,
|
||||
true /* fix unknowns */,
|
||||
true /* force SQL99 rules */);
|
||||
true /* fix unknowns */ ,
|
||||
true /* force SQL99 rules */ );
|
||||
|
||||
/*
|
||||
* If we have DISTINCT, transform that to produce a distinctList.
|
||||
@ -118,12 +118,12 @@ transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
|
||||
|
||||
if (!OidIsValid(sortcl->sortop))
|
||||
{
|
||||
Node *expr = get_sortgroupclause_expr(sortcl, tlist);
|
||||
Node *expr = get_sortgroupclause_expr(sortcl, tlist);
|
||||
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_UNDEFINED_FUNCTION),
|
||||
errmsg("could not identify an ordering operator for type %s",
|
||||
format_type_be(exprType(expr))),
|
||||
errmsg("could not identify an ordering operator for type %s",
|
||||
format_type_be(exprType(expr))),
|
||||
errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
|
||||
parser_errposition(pstate, exprLocation(expr))));
|
||||
}
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.197 2010/02/12 17:33:20 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_clause.c,v 1.198 2010/02/26 02:00:50 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -73,7 +73,7 @@ static Node *transformFromClauseItem(ParseState *pstate, Node *n,
|
||||
static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
|
||||
Var *l_colvar, Var *r_colvar);
|
||||
static void checkExprIsVarFree(ParseState *pstate, Node *n,
|
||||
const char *constructName);
|
||||
const char *constructName);
|
||||
static TargetEntry *findTargetlistEntrySQL92(ParseState *pstate, Node *node,
|
||||
List **tlist, int clause);
|
||||
static TargetEntry *findTargetlistEntrySQL99(ParseState *pstate, Node *node,
|
||||
@ -88,7 +88,7 @@ static List *addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
|
||||
bool resolveUnknown);
|
||||
static WindowClause *findWindowClause(List *wclist, const char *name);
|
||||
static Node *transformFrameOffset(ParseState *pstate, int frameOptions,
|
||||
Node *clause);
|
||||
Node *clause);
|
||||
|
||||
|
||||
/*
|
||||
@ -802,7 +802,7 @@ transformFromClauseItem(ParseState *pstate, Node *n,
|
||||
ListCell *lx,
|
||||
*rx;
|
||||
|
||||
Assert(j->usingClause == NIL); /* shouldn't have USING() too */
|
||||
Assert(j->usingClause == NIL); /* shouldn't have USING() too */
|
||||
|
||||
foreach(lx, l_colnames)
|
||||
{
|
||||
@ -1245,9 +1245,9 @@ checkExprIsVarFree(ParseState *pstate, Node *n, const char *constructName)
|
||||
*
|
||||
* This function supports the old SQL92 ORDER BY interpretation, where the
|
||||
* expression is an output column name or number. If we fail to find a
|
||||
* match of that sort, we fall through to the SQL99 rules. For historical
|
||||
* match of that sort, we fall through to the SQL99 rules. For historical
|
||||
* reasons, Postgres also allows this interpretation for GROUP BY, though
|
||||
* the standard never did. However, for GROUP BY we prefer a SQL99 match.
|
||||
* the standard never did. However, for GROUP BY we prefer a SQL99 match.
|
||||
* This function is *not* used for WINDOW definitions.
|
||||
*
|
||||
* node the ORDER BY, GROUP BY, or DISTINCT ON expression to be matched
|
||||
@ -1421,7 +1421,7 @@ findTargetlistEntrySQL99(ParseState *pstate, Node *node, List **tlist)
|
||||
/*
|
||||
* Convert the untransformed node to a transformed expression, and search
|
||||
* for a match in the tlist. NOTE: it doesn't really matter whether there
|
||||
* is more than one match. Also, we are willing to match an existing
|
||||
* is more than one match. Also, we are willing to match an existing
|
||||
* resjunk target here, though the SQL92 cases above must ignore resjunk
|
||||
* targets.
|
||||
*/
|
||||
@ -1617,13 +1617,13 @@ transformWindowDefinitions(ParseState *pstate,
|
||||
orderClause = transformSortClause(pstate,
|
||||
windef->orderClause,
|
||||
targetlist,
|
||||
true /* fix unknowns */,
|
||||
true /* force SQL99 rules */);
|
||||
true /* fix unknowns */ ,
|
||||
true /* force SQL99 rules */ );
|
||||
partitionClause = transformGroupClause(pstate,
|
||||
windef->partitionClause,
|
||||
targetlist,
|
||||
orderClause,
|
||||
true /* force SQL99 rules */);
|
||||
true /* force SQL99 rules */ );
|
||||
|
||||
/*
|
||||
* And prepare the new WindowClause.
|
||||
@ -2220,8 +2220,8 @@ transformFrameOffset(ParseState *pstate, int frameOptions, Node *clause)
|
||||
else if (frameOptions & FRAMEOPTION_RANGE)
|
||||
{
|
||||
/*
|
||||
* this needs a lot of thought to decide how to support in the
|
||||
* context of Postgres' extensible datatype framework
|
||||
* this needs a lot of thought to decide how to support in the context
|
||||
* of Postgres' extensible datatype framework
|
||||
*/
|
||||
constructName = "RANGE";
|
||||
/* error was already thrown by gram.y, this is just a backstop */
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.180 2010/02/14 18:42:15 rhaas Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_coerce.c,v 2.181 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -263,8 +263,8 @@ coerce_type(ParseState *pstate, Node *node,
|
||||
pstate != NULL && pstate->p_coerce_param_hook != NULL)
|
||||
{
|
||||
/*
|
||||
* Allow the CoerceParamHook to decide what happens. It can return
|
||||
* a transformed node (very possibly the same Param node), or return
|
||||
* Allow the CoerceParamHook to decide what happens. It can return a
|
||||
* transformed node (very possibly the same Param node), or return
|
||||
* NULL to indicate we should proceed with normal coercion.
|
||||
*/
|
||||
result = (*pstate->p_coerce_param_hook) (pstate,
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.253 2010/01/02 16:57:49 momjian Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.254 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -61,7 +61,7 @@ static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
|
||||
static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
|
||||
static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
|
||||
static Node *transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte,
|
||||
int location);
|
||||
int location);
|
||||
static Node *transformIndirection(ParseState *pstate, Node *basenode,
|
||||
List *indirection);
|
||||
static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
|
||||
@ -172,8 +172,8 @@ transformExpr(ParseState *pstate, Node *expr)
|
||||
* not a domain, transformTypeCast is a no-op.
|
||||
*/
|
||||
targetType = getBaseTypeAndTypmod(targetType,
|
||||
&targetTypmod);
|
||||
|
||||
&targetTypmod);
|
||||
|
||||
tc = copyObject(tc);
|
||||
tc->arg = transformArrayExpr(pstate,
|
||||
(A_ArrayExpr *) tc->arg,
|
||||
@ -466,7 +466,8 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
|
||||
char *colname = NULL;
|
||||
RangeTblEntry *rte;
|
||||
int levels_up;
|
||||
enum {
|
||||
enum
|
||||
{
|
||||
CRERR_NO_COLUMN,
|
||||
CRERR_NO_RTE,
|
||||
CRERR_WRONG_DB,
|
||||
@ -474,7 +475,7 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
|
||||
} crerr = CRERR_NO_COLUMN;
|
||||
|
||||
/*
|
||||
* Give the PreParseColumnRefHook, if any, first shot. If it returns
|
||||
* Give the PreParseColumnRefHook, if any, first shot. If it returns
|
||||
* non-null then that's all, folks.
|
||||
*/
|
||||
if (pstate->p_pre_columnref_hook != NULL)
|
||||
@ -708,22 +709,22 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
|
||||
break;
|
||||
}
|
||||
default:
|
||||
crerr = CRERR_TOO_MANY; /* too many dotted names */
|
||||
crerr = CRERR_TOO_MANY; /* too many dotted names */
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now give the PostParseColumnRefHook, if any, a chance. We pass the
|
||||
* translation-so-far so that it can throw an error if it wishes in the
|
||||
* case that it has a conflicting interpretation of the ColumnRef.
|
||||
* (If it just translates anyway, we'll throw an error, because we can't
|
||||
* undo whatever effects the preceding steps may have had on the pstate.)
|
||||
* If it returns NULL, use the standard translation, or throw a suitable
|
||||
* error if there is none.
|
||||
* case that it has a conflicting interpretation of the ColumnRef. (If it
|
||||
* just translates anyway, we'll throw an error, because we can't undo
|
||||
* whatever effects the preceding steps may have had on the pstate.) If it
|
||||
* returns NULL, use the standard translation, or throw a suitable error
|
||||
* if there is none.
|
||||
*/
|
||||
if (pstate->p_post_columnref_hook != NULL)
|
||||
{
|
||||
Node *hookresult;
|
||||
Node *hookresult;
|
||||
|
||||
hookresult = (*pstate->p_post_columnref_hook) (pstate, cref, node);
|
||||
if (node == NULL)
|
||||
@ -765,15 +766,15 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
|
||||
case CRERR_WRONG_DB:
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
||||
errmsg("cross-database references are not implemented: %s",
|
||||
NameListToString(cref->fields)),
|
||||
errmsg("cross-database references are not implemented: %s",
|
||||
NameListToString(cref->fields)),
|
||||
parser_errposition(pstate, cref->location)));
|
||||
break;
|
||||
case CRERR_TOO_MANY:
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("improper qualified name (too many dotted names): %s",
|
||||
NameListToString(cref->fields)),
|
||||
errmsg("improper qualified name (too many dotted names): %s",
|
||||
NameListToString(cref->fields)),
|
||||
parser_errposition(pstate, cref->location)));
|
||||
break;
|
||||
}
|
||||
@ -788,7 +789,7 @@ transformParamRef(ParseState *pstate, ParamRef *pref)
|
||||
Node *result;
|
||||
|
||||
/*
|
||||
* The core parser knows nothing about Params. If a hook is supplied,
|
||||
* The core parser knows nothing about Params. If a hook is supplied,
|
||||
* call it. If not, or if the hook returns NULL, throw a generic error.
|
||||
*/
|
||||
if (pstate->p_paramref_hook != NULL)
|
||||
@ -1972,10 +1973,10 @@ transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
|
||||
|
||||
/*
|
||||
* Check to see if the cursor name matches a parameter of type REFCURSOR.
|
||||
* If so, replace the raw name reference with a parameter reference.
|
||||
* (This is a hack for the convenience of plpgsql.)
|
||||
* If so, replace the raw name reference with a parameter reference. (This
|
||||
* is a hack for the convenience of plpgsql.)
|
||||
*/
|
||||
if (cexpr->cursor_name != NULL) /* in case already transformed */
|
||||
if (cexpr->cursor_name != NULL) /* in case already transformed */
|
||||
{
|
||||
ColumnRef *cref = makeNode(ColumnRef);
|
||||
Node *node = NULL;
|
||||
@ -1991,13 +1992,13 @@ transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
|
||||
node = (*pstate->p_post_columnref_hook) (pstate, cref, NULL);
|
||||
|
||||
/*
|
||||
* XXX Should we throw an error if we get a translation that isn't
|
||||
* a refcursor Param? For now it seems best to silently ignore
|
||||
* false matches.
|
||||
* XXX Should we throw an error if we get a translation that isn't a
|
||||
* refcursor Param? For now it seems best to silently ignore false
|
||||
* matches.
|
||||
*/
|
||||
if (node != NULL && IsA(node, Param))
|
||||
{
|
||||
Param *p = (Param *) node;
|
||||
Param *p = (Param *) node;
|
||||
|
||||
if (p->paramkind == PARAM_EXTERN &&
|
||||
p->paramtype == REFCURSOROID)
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.221 2010/02/14 18:42:15 rhaas Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.222 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -125,13 +125,13 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
*
|
||||
* We allow mixed notation (some named and some not), but only with all
|
||||
* the named parameters after all the unnamed ones. So the name list
|
||||
* corresponds to the last N actual parameters and we don't need any
|
||||
* extra bookkeeping to match things up.
|
||||
* corresponds to the last N actual parameters and we don't need any extra
|
||||
* bookkeeping to match things up.
|
||||
*/
|
||||
argnames = NIL;
|
||||
foreach(l, fargs)
|
||||
{
|
||||
Node *arg = lfirst(l);
|
||||
Node *arg = lfirst(l);
|
||||
|
||||
if (IsA(arg, NamedArgExpr))
|
||||
{
|
||||
@ -144,8 +144,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
if (strcmp(na->name, (char *) lfirst(lc)) == 0)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("argument name \"%s\" used more than once",
|
||||
na->name),
|
||||
errmsg("argument name \"%s\" used more than once",
|
||||
na->name),
|
||||
parser_errposition(pstate, na->location)));
|
||||
}
|
||||
argnames = lappend(argnames, na->name);
|
||||
@ -155,7 +155,7 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
if (argnames != NIL)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("positional argument cannot follow named argument"),
|
||||
errmsg("positional argument cannot follow named argument"),
|
||||
parser_errposition(pstate, exprLocation(arg))));
|
||||
}
|
||||
}
|
||||
@ -246,8 +246,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
if (agg_order != NIL)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
||||
errmsg("ORDER BY specified, but %s is not an aggregate function",
|
||||
NameListToString(funcname)),
|
||||
errmsg("ORDER BY specified, but %s is not an aggregate function",
|
||||
NameListToString(funcname)),
|
||||
parser_errposition(pstate, location)));
|
||||
if (over)
|
||||
ereport(ERROR,
|
||||
@ -262,8 +262,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
/*
|
||||
* Oops. Time to die.
|
||||
*
|
||||
* If we are dealing with the attribute notation rel.function,
|
||||
* let the caller handle failure.
|
||||
* If we are dealing with the attribute notation rel.function, let the
|
||||
* caller handle failure.
|
||||
*/
|
||||
if (is_column)
|
||||
return NULL;
|
||||
@ -408,9 +408,9 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
|
||||
/*
|
||||
* Currently it's not possible to define an aggregate with named
|
||||
* arguments, so this case should be impossible. Check anyway
|
||||
* because the planner and executor wouldn't cope with NamedArgExprs
|
||||
* in an Aggref node.
|
||||
* arguments, so this case should be impossible. Check anyway because
|
||||
* the planner and executor wouldn't cope with NamedArgExprs in an
|
||||
* Aggref node.
|
||||
*/
|
||||
if (argnames != NIL)
|
||||
ereport(ERROR,
|
||||
@ -481,9 +481,9 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
|
||||
parser_errposition(pstate, location)));
|
||||
|
||||
/*
|
||||
* We might want to support this later, but for now reject it
|
||||
* because the planner and executor wouldn't cope with NamedArgExprs
|
||||
* in a WindowFunc node.
|
||||
* We might want to support this later, but for now reject it because
|
||||
* the planner and executor wouldn't cope with NamedArgExprs in a
|
||||
* WindowFunc node.
|
||||
*/
|
||||
if (argnames != NIL)
|
||||
ereport(ERROR,
|
||||
@ -1075,10 +1075,9 @@ func_get_detail(List *funcname,
|
||||
return FUNCDETAIL_MULTIPLE;
|
||||
|
||||
/*
|
||||
* We disallow VARIADIC with named arguments unless the last
|
||||
* argument (the one with VARIADIC attached) actually matched the
|
||||
* variadic parameter. This is mere pedantry, really, but some
|
||||
* folks insisted.
|
||||
* We disallow VARIADIC with named arguments unless the last argument
|
||||
* (the one with VARIADIC attached) actually matched the variadic
|
||||
* parameter. This is mere pedantry, really, but some folks insisted.
|
||||
*/
|
||||
if (fargnames != NIL && !expand_variadic && nargs > 0 &&
|
||||
best_candidate->argnumbers[nargs - 1] != nargs - 1)
|
||||
@ -1142,17 +1141,17 @@ func_get_detail(List *funcname,
|
||||
{
|
||||
/*
|
||||
* This is a bit tricky in named notation, since the supplied
|
||||
* arguments could replace any subset of the defaults. We
|
||||
* arguments could replace any subset of the defaults. We
|
||||
* work by making a bitmapset of the argnumbers of defaulted
|
||||
* arguments, then scanning the defaults list and selecting
|
||||
* the needed items. (This assumes that defaulted arguments
|
||||
* should be supplied in their positional order.)
|
||||
*/
|
||||
Bitmapset *defargnumbers;
|
||||
int *firstdefarg;
|
||||
List *newdefaults;
|
||||
ListCell *lc;
|
||||
int i;
|
||||
Bitmapset *defargnumbers;
|
||||
int *firstdefarg;
|
||||
List *newdefaults;
|
||||
ListCell *lc;
|
||||
int i;
|
||||
|
||||
defargnumbers = NULL;
|
||||
firstdefarg = &best_candidate->argnumbers[best_candidate->nargs - best_candidate->ndargs];
|
||||
@ -1174,8 +1173,8 @@ func_get_detail(List *funcname,
|
||||
else
|
||||
{
|
||||
/*
|
||||
* Defaults for positional notation are lots easier;
|
||||
* just remove any unwanted ones from the front.
|
||||
* Defaults for positional notation are lots easier; just
|
||||
* remove any unwanted ones from the front.
|
||||
*/
|
||||
int ndelete;
|
||||
|
||||
@ -1226,11 +1225,11 @@ make_fn_arguments(ParseState *pstate,
|
||||
/* types don't match? then force coercion using a function call... */
|
||||
if (actual_arg_types[i] != declared_arg_types[i])
|
||||
{
|
||||
Node *node = (Node *) lfirst(current_fargs);
|
||||
Node *node = (Node *) lfirst(current_fargs);
|
||||
|
||||
/*
|
||||
* If arg is a NamedArgExpr, coerce its input expr instead ---
|
||||
* we want the NamedArgExpr to stay at the top level of the list.
|
||||
* If arg is a NamedArgExpr, coerce its input expr instead --- we
|
||||
* want the NamedArgExpr to stay at the top level of the list.
|
||||
*/
|
||||
if (IsA(node, NamedArgExpr))
|
||||
{
|
||||
@ -1364,7 +1363,7 @@ ParseComplexProjection(ParseState *pstate, char *funcname, Node *first_arg,
|
||||
* The result is something like "foo(integer)".
|
||||
*
|
||||
* If argnames isn't NIL, it is a list of C strings representing the actual
|
||||
* arg names for the last N arguments. This must be considered part of the
|
||||
* arg names for the last N arguments. This must be considered part of the
|
||||
* function signature too, when dealing with named-notation function calls.
|
||||
*
|
||||
* This is typically used in the construction of function-not-found error
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.112 2010/02/14 18:42:15 rhaas Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_oper.c,v 1.113 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -229,11 +229,12 @@ get_sort_group_operators(Oid argtype,
|
||||
lt_opr = gt_opr = InvalidOid;
|
||||
}
|
||||
#else
|
||||
|
||||
/*
|
||||
* ... but for the moment we have to do this. This is because
|
||||
* anyarray has sorting but not hashing support. So, if the
|
||||
* element type is only hashable, there is nothing we can do
|
||||
* with the array type.
|
||||
* element type is only hashable, there is nothing we can do with
|
||||
* the array type.
|
||||
*/
|
||||
if (!OidIsValid(typentry->lt_opr) ||
|
||||
!OidIsValid(typentry->eq_opr) ||
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_param.c,v 2.3 2010/01/13 01:17:07 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_param.c,v 2.4 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -53,8 +53,8 @@ typedef struct VarParamState
|
||||
static Node *fixed_paramref_hook(ParseState *pstate, ParamRef *pref);
|
||||
static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
|
||||
static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
|
||||
Oid targetTypeId, int32 targetTypeMod,
|
||||
int location);
|
||||
Oid targetTypeId, int32 targetTypeMod,
|
||||
int location);
|
||||
static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
|
||||
|
||||
|
||||
@ -245,7 +245,7 @@ variable_coerce_param_hook(ParseState *pstate, Param *param,
|
||||
* of parsing with parse_variable_parameters.
|
||||
*
|
||||
* Note: this code intentionally does not check that all parameter positions
|
||||
* were used, nor that all got non-UNKNOWN types assigned. Caller of parser
|
||||
* were used, nor that all got non-UNKNOWN types assigned. Caller of parser
|
||||
* should enforce that if it's important.
|
||||
*/
|
||||
void
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.149 2010/02/14 18:42:15 rhaas Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_relation.c,v 1.150 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -88,11 +88,11 @@ refnameRangeTblEntry(ParseState *pstate,
|
||||
|
||||
/*
|
||||
* We can use LookupNamespaceNoError() here because we are only
|
||||
* interested in finding existing RTEs. Checking USAGE permission
|
||||
* on the schema is unnecessary since it would have already been
|
||||
* checked when the RTE was made. Furthermore, we want to report
|
||||
* "RTE not found", not "no permissions for schema", if the name
|
||||
* happens to match a schema name the user hasn't got access to.
|
||||
* interested in finding existing RTEs. Checking USAGE permission on
|
||||
* the schema is unnecessary since it would have already been checked
|
||||
* when the RTE was made. Furthermore, we want to report "RTE not
|
||||
* found", not "no permissions for schema", if the name happens to
|
||||
* match a schema name the user hasn't got access to.
|
||||
*/
|
||||
namespaceId = LookupNamespaceNoError(schemaname);
|
||||
if (!OidIsValid(relId))
|
||||
@ -2369,8 +2369,8 @@ errorMissingRTE(ParseState *pstate, RangeVar *relation)
|
||||
|
||||
/*
|
||||
* Check to see if there are any potential matches in the query's
|
||||
* rangetable. (Note: cases involving a bad schema name in the
|
||||
* RangeVar will throw error immediately here. That seems OK.)
|
||||
* rangetable. (Note: cases involving a bad schema name in the RangeVar
|
||||
* will throw error immediately here. That seems OK.)
|
||||
*/
|
||||
rte = searchRangeTable(pstate, relation);
|
||||
|
||||
@ -2394,11 +2394,11 @@ errorMissingRTE(ParseState *pstate, RangeVar *relation)
|
||||
if (rte)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_UNDEFINED_TABLE),
|
||||
errmsg("invalid reference to FROM-clause entry for table \"%s\"",
|
||||
relation->relname),
|
||||
errmsg("invalid reference to FROM-clause entry for table \"%s\"",
|
||||
relation->relname),
|
||||
(badAlias ?
|
||||
errhint("Perhaps you meant to reference the table alias \"%s\".",
|
||||
badAlias) :
|
||||
errhint("Perhaps you meant to reference the table alias \"%s\".",
|
||||
badAlias) :
|
||||
errhint("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
|
||||
rte->eref->aliasname)),
|
||||
parser_errposition(pstate, relation->location)));
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.176 2010/01/02 16:57:50 momjian Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.177 2010/02/26 02:00:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -49,9 +49,9 @@ static List *ExpandAllTables(ParseState *pstate, int location);
|
||||
static List *ExpandIndirectionStar(ParseState *pstate, A_Indirection *ind,
|
||||
bool targetlist);
|
||||
static List *ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte,
|
||||
int location, bool targetlist);
|
||||
int location, bool targetlist);
|
||||
static List *ExpandRowReference(ParseState *pstate, Node *expr,
|
||||
bool targetlist);
|
||||
bool targetlist);
|
||||
static int FigureColnameInternal(Node *node, char **name);
|
||||
|
||||
|
||||
@ -884,12 +884,12 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
|
||||
*
|
||||
* (e.g., SELECT emp.*, dname FROM emp, dept)
|
||||
*
|
||||
* Note: this code is a lot like transformColumnRef; it's tempting
|
||||
* to call that instead and then replace the resulting whole-row Var
|
||||
* with a list of Vars. However, that would leave us with the
|
||||
* RTE's selectedCols bitmap showing the whole row as needing
|
||||
* select permission, as well as the individual columns. That would
|
||||
* be incorrect (since columns added later shouldn't need select
|
||||
* Note: this code is a lot like transformColumnRef; it's tempting to
|
||||
* call that instead and then replace the resulting whole-row Var with
|
||||
* a list of Vars. However, that would leave us with the RTE's
|
||||
* selectedCols bitmap showing the whole row as needing select
|
||||
* permission, as well as the individual columns. That would be
|
||||
* incorrect (since columns added later shouldn't need select
|
||||
* permissions). We could try to remove the whole-row permission bit
|
||||
* after the fact, but duplicating code is less messy.
|
||||
*/
|
||||
@ -897,14 +897,15 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
|
||||
char *relname = NULL;
|
||||
RangeTblEntry *rte = NULL;
|
||||
int levels_up;
|
||||
enum {
|
||||
enum
|
||||
{
|
||||
CRSERR_NO_RTE,
|
||||
CRSERR_WRONG_DB,
|
||||
CRSERR_TOO_MANY
|
||||
} crserr = CRSERR_NO_RTE;
|
||||
|
||||
/*
|
||||
* Give the PreParseColumnRefHook, if any, first shot. If it returns
|
||||
* Give the PreParseColumnRefHook, if any, first shot. If it returns
|
||||
* non-null then we should use that expression.
|
||||
*/
|
||||
if (pstate->p_pre_columnref_hook != NULL)
|
||||
@ -932,35 +933,35 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
|
||||
&levels_up);
|
||||
break;
|
||||
case 4:
|
||||
{
|
||||
char *catname = strVal(linitial(fields));
|
||||
|
||||
/*
|
||||
* We check the catalog name and then ignore it.
|
||||
*/
|
||||
if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
|
||||
{
|
||||
crserr = CRSERR_WRONG_DB;
|
||||
char *catname = strVal(linitial(fields));
|
||||
|
||||
/*
|
||||
* We check the catalog name and then ignore it.
|
||||
*/
|
||||
if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
|
||||
{
|
||||
crserr = CRSERR_WRONG_DB;
|
||||
break;
|
||||
}
|
||||
nspname = strVal(lsecond(fields));
|
||||
relname = strVal(lthird(fields));
|
||||
rte = refnameRangeTblEntry(pstate, nspname, relname,
|
||||
cref->location,
|
||||
&levels_up);
|
||||
break;
|
||||
}
|
||||
nspname = strVal(lsecond(fields));
|
||||
relname = strVal(lthird(fields));
|
||||
rte = refnameRangeTblEntry(pstate, nspname, relname,
|
||||
cref->location,
|
||||
&levels_up);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
crserr = CRSERR_TOO_MANY;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now give the PostParseColumnRefHook, if any, a chance.
|
||||
* We cheat a bit by passing the RangeTblEntry, not a Var,
|
||||
* as the planned translation. (A single Var wouldn't be
|
||||
* strictly correct anyway. This convention allows hooks
|
||||
* that really care to know what is happening.)
|
||||
* Now give the PostParseColumnRefHook, if any, a chance. We cheat a
|
||||
* bit by passing the RangeTblEntry, not a Var, as the planned
|
||||
* translation. (A single Var wouldn't be strictly correct anyway.
|
||||
* This convention allows hooks that really care to know what is
|
||||
* happening.)
|
||||
*/
|
||||
if (pstate->p_post_columnref_hook != NULL)
|
||||
{
|
||||
@ -1111,9 +1112,9 @@ ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte,
|
||||
NULL, &vars);
|
||||
|
||||
/*
|
||||
* Require read access to the table. This is normally redundant
|
||||
* with the markVarForSelectPriv calls below, but not if the table
|
||||
* has zero columns.
|
||||
* Require read access to the table. This is normally redundant with
|
||||
* the markVarForSelectPriv calls below, but not if the table has zero
|
||||
* columns.
|
||||
*/
|
||||
rte->requiredPerms |= ACL_SELECT;
|
||||
|
||||
@ -1147,7 +1148,7 @@ ExpandRowReference(ParseState *pstate, Node *expr,
|
||||
|
||||
/*
|
||||
* If the rowtype expression is a whole-row Var, we can expand the fields
|
||||
* as simple Vars. Note: if the RTE is a relation, this case leaves us
|
||||
* as simple Vars. Note: if the RTE is a relation, this case leaves us
|
||||
* with the RTE's selectedCols bitmap showing the whole row as needing
|
||||
* select permission, as well as the individual columns. However, we can
|
||||
* only get here for weird notations like (table.*).*, so it's not worth
|
||||
@ -1165,8 +1166,8 @@ ExpandRowReference(ParseState *pstate, Node *expr,
|
||||
}
|
||||
|
||||
/*
|
||||
* Otherwise we have to do it the hard way. Our current implementation
|
||||
* is to generate multiple copies of the expression and do FieldSelects.
|
||||
* Otherwise we have to do it the hard way. Our current implementation is
|
||||
* to generate multiple copies of the expression and do FieldSelects.
|
||||
* (This can be pretty inefficient if the expression involves nontrivial
|
||||
* computation :-(.)
|
||||
*
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
* Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.39 2010/02/14 18:42:15 rhaas Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.40 2010/02/26 02:00:53 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -106,7 +106,7 @@ static void transformTableConstraint(ParseState *pstate,
|
||||
static void transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
|
||||
InhRelation *inhrelation);
|
||||
static void transformOfType(ParseState *pstate, CreateStmtContext *cxt,
|
||||
TypeName *ofTypename);
|
||||
TypeName *ofTypename);
|
||||
static char *chooseIndexName(const RangeVar *relation, IndexStmt *index_stmt);
|
||||
static IndexStmt *generateClonedIndexStmt(CreateStmtContext *cxt,
|
||||
Relation parent_index, AttrNumber *attmap);
|
||||
@ -186,7 +186,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
|
||||
cxt.pkey = NULL;
|
||||
cxt.hasoids = interpretOidsOption(stmt->options);
|
||||
|
||||
Assert(!stmt->ofTypename || !stmt->inhRelations); /* grammar enforces */
|
||||
Assert(!stmt->ofTypename || !stmt->inhRelations); /* grammar enforces */
|
||||
|
||||
if (stmt->ofTypename)
|
||||
transformOfType(pstate, &cxt, stmt->ofTypename);
|
||||
@ -486,6 +486,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
|
||||
break;
|
||||
|
||||
case CONSTR_FOREIGN:
|
||||
|
||||
/*
|
||||
* Fill in the current attribute's name and throw it into the
|
||||
* list of FK constraints to be processed later.
|
||||
@ -760,11 +761,11 @@ transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
|
||||
|
||||
if (comment != NULL)
|
||||
{
|
||||
CommentStmt *stmt;
|
||||
CommentStmt *stmt;
|
||||
|
||||
/*
|
||||
* We have to assign the index a name now, so that we
|
||||
* can reference it in CommentStmt.
|
||||
* We have to assign the index a name now, so that we can
|
||||
* reference it in CommentStmt.
|
||||
*/
|
||||
if (index_stmt->idxname == NULL)
|
||||
index_stmt->idxname = chooseIndexName(cxt->relation,
|
||||
@ -811,7 +812,7 @@ transformOfType(ParseState *pstate, CreateStmtContext *cxt, TypeName *ofTypename
|
||||
tuple = typenameType(NULL, ofTypename, NULL);
|
||||
typ = (Form_pg_type) GETSTRUCT(tuple);
|
||||
ofTypeId = HeapTupleGetOid(tuple);
|
||||
ofTypename->typeOid = ofTypeId; /* cached for later */
|
||||
ofTypename->typeOid = ofTypeId; /* cached for later */
|
||||
|
||||
if (typ->typtype != TYPTYPE_COMPOSITE)
|
||||
ereport(ERROR,
|
||||
@ -823,7 +824,7 @@ transformOfType(ParseState *pstate, CreateStmtContext *cxt, TypeName *ofTypename
|
||||
for (i = 0; i < tupdesc->natts; i++)
|
||||
{
|
||||
Form_pg_attribute attr = tupdesc->attrs[i];
|
||||
ColumnDef *n = makeNode(ColumnDef);
|
||||
ColumnDef *n = makeNode(ColumnDef);
|
||||
|
||||
n->colname = pstrdup(NameStr(attr->attname));
|
||||
n->typeName = makeTypeNameFromOid(attr->atttypid, attr->atttypmod);
|
||||
@ -934,7 +935,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
|
||||
*/
|
||||
if (index->primary || index->unique || idxrelrec->relhasexclusion)
|
||||
{
|
||||
Oid constraintId = get_index_constraint(source_relid);
|
||||
Oid constraintId = get_index_constraint(source_relid);
|
||||
|
||||
if (OidIsValid(constraintId))
|
||||
{
|
||||
@ -942,7 +943,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
|
||||
Form_pg_constraint conrec;
|
||||
|
||||
ht_constr = SearchSysCache1(CONSTROID,
|
||||
ObjectIdGetDatum(constraintId));
|
||||
ObjectIdGetDatum(constraintId));
|
||||
if (!HeapTupleIsValid(ht_constr))
|
||||
elog(ERROR, "cache lookup failed for constraint %u",
|
||||
constraintId);
|
||||
@ -955,9 +956,9 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
|
||||
/* If it's an exclusion constraint, we need the operator names */
|
||||
if (idxrelrec->relhasexclusion)
|
||||
{
|
||||
Datum *elems;
|
||||
int nElems;
|
||||
int i;
|
||||
Datum *elems;
|
||||
int nElems;
|
||||
int i;
|
||||
|
||||
Assert(conrec->contype == CONSTRAINT_EXCLUSION);
|
||||
/* Extract operator OIDs from the pg_constraint tuple */
|
||||
@ -1310,17 +1311,17 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt)
|
||||
index->concurrent = false;
|
||||
|
||||
/*
|
||||
* If it's an EXCLUDE constraint, the grammar returns a list of pairs
|
||||
* of IndexElems and operator names. We have to break that apart into
|
||||
* If it's an EXCLUDE constraint, the grammar returns a list of pairs of
|
||||
* IndexElems and operator names. We have to break that apart into
|
||||
* separate lists.
|
||||
*/
|
||||
if (constraint->contype == CONSTR_EXCLUSION)
|
||||
{
|
||||
foreach(lc, constraint->exclusions)
|
||||
{
|
||||
List *pair = (List *) lfirst(lc);
|
||||
IndexElem *elem;
|
||||
List *opname;
|
||||
List *pair = (List *) lfirst(lc);
|
||||
IndexElem *elem;
|
||||
List *opname;
|
||||
|
||||
Assert(list_length(pair) == 2);
|
||||
elem = (IndexElem *) linitial(pair);
|
||||
|
||||
Reference in New Issue
Block a user