mirror of
https://github.com/postgres/postgres.git
synced 2025-07-28 23:42:10 +03:00
pgindent run before PG 9.1 beta 1.
This commit is contained in:
@ -66,7 +66,7 @@ static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
RangeTblEntry *rte);
|
||||
RangeTblEntry *rte);
|
||||
static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
|
||||
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
|
||||
bool *differentTypes);
|
||||
@ -413,11 +413,11 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
|
||||
/*
|
||||
* We have to make child entries in the EquivalenceClass data
|
||||
* structures as well. This is needed either if the parent
|
||||
* participates in some eclass joins (because we will want to
|
||||
* consider inner-indexscan joins on the individual children)
|
||||
* or if the parent has useful pathkeys (because we should try
|
||||
* to build MergeAppend paths that produce those sort orderings).
|
||||
* structures as well. This is needed either if the parent
|
||||
* participates in some eclass joins (because we will want to consider
|
||||
* inner-indexscan joins on the individual children) or if the parent
|
||||
* has useful pathkeys (because we should try to build MergeAppend
|
||||
* paths that produce those sort orderings).
|
||||
*/
|
||||
if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
|
||||
add_child_rel_equivalences(root, appinfo, rel, childrel);
|
||||
@ -462,7 +462,7 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
/* Have we already seen this ordering? */
|
||||
foreach(lpk, all_child_pathkeys)
|
||||
{
|
||||
List *existing_pathkeys = (List *) lfirst(lpk);
|
||||
List *existing_pathkeys = (List *) lfirst(lpk);
|
||||
|
||||
if (compare_pathkeys(existing_pathkeys,
|
||||
childkeys) == PATHKEYS_EQUAL)
|
||||
@ -540,18 +540,18 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
|
||||
/*
|
||||
* Next, build MergeAppend paths based on the collected list of child
|
||||
* pathkeys. We consider both cheapest-startup and cheapest-total
|
||||
* cases, ie, for each interesting ordering, collect all the cheapest
|
||||
* startup subpaths and all the cheapest total paths, and build a
|
||||
* MergeAppend path for each list.
|
||||
* pathkeys. We consider both cheapest-startup and cheapest-total cases,
|
||||
* ie, for each interesting ordering, collect all the cheapest startup
|
||||
* subpaths and all the cheapest total paths, and build a MergeAppend path
|
||||
* for each list.
|
||||
*/
|
||||
foreach(l, all_child_pathkeys)
|
||||
{
|
||||
List *pathkeys = (List *) lfirst(l);
|
||||
List *startup_subpaths = NIL;
|
||||
List *total_subpaths = NIL;
|
||||
bool startup_neq_total = false;
|
||||
ListCell *lcr;
|
||||
List *pathkeys = (List *) lfirst(l);
|
||||
List *startup_subpaths = NIL;
|
||||
List *total_subpaths = NIL;
|
||||
bool startup_neq_total = false;
|
||||
ListCell *lcr;
|
||||
|
||||
/* Select the child paths for this ordering... */
|
||||
foreach(lcr, live_childrels)
|
||||
@ -581,8 +581,8 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
|
||||
|
||||
/*
|
||||
* Notice whether we actually have different paths for the
|
||||
* "cheapest" and "total" cases; frequently there will be no
|
||||
* point in two create_merge_append_path() calls.
|
||||
* "cheapest" and "total" cases; frequently there will be no point
|
||||
* in two create_merge_append_path() calls.
|
||||
*/
|
||||
if (cheapest_startup != cheapest_total)
|
||||
startup_neq_total = true;
|
||||
@ -623,7 +623,7 @@ accumulate_append_subpath(List *subpaths, Path *path)
|
||||
{
|
||||
if (IsA(path, AppendPath))
|
||||
{
|
||||
AppendPath *apath = (AppendPath *) path;
|
||||
AppendPath *apath = (AppendPath *) path;
|
||||
|
||||
/* list_copy is important here to avoid sharing list substructure */
|
||||
return list_concat(subpaths, list_copy(apath->subpaths));
|
||||
|
@ -1096,7 +1096,7 @@ cost_recursive_union(Plan *runion, Plan *nrterm, Plan *rterm)
|
||||
* accesses (XXX can't we refine that guess?)
|
||||
*
|
||||
* By default, we charge two operator evals per tuple comparison, which should
|
||||
* be in the right ballpark in most cases. The caller can tweak this by
|
||||
* be in the right ballpark in most cases. The caller can tweak this by
|
||||
* specifying nonzero comparison_cost; typically that's used for any extra
|
||||
* work that has to be done to prepare the inputs to the comparison operators.
|
||||
*
|
||||
@ -1218,7 +1218,7 @@ cost_sort(Path *path, PlannerInfo *root,
|
||||
* Determines and returns the cost of a MergeAppend node.
|
||||
*
|
||||
* MergeAppend merges several pre-sorted input streams, using a heap that
|
||||
* at any given instant holds the next tuple from each stream. If there
|
||||
* at any given instant holds the next tuple from each stream. If there
|
||||
* are N streams, we need about N*log2(N) tuple comparisons to construct
|
||||
* the heap at startup, and then for each output tuple, about log2(N)
|
||||
* comparisons to delete the top heap entry and another log2(N) comparisons
|
||||
@ -2909,7 +2909,7 @@ adjust_semi_join(PlannerInfo *root, JoinPath *path, SpecialJoinInfo *sjinfo,
|
||||
List *nrclauses;
|
||||
|
||||
nrclauses = select_nonredundant_join_clauses(root,
|
||||
path->joinrestrictinfo,
|
||||
path->joinrestrictinfo,
|
||||
path->innerjoinpath);
|
||||
*indexed_join_quals = (nrclauses == NIL);
|
||||
}
|
||||
@ -3185,7 +3185,7 @@ set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel,
|
||||
|
||||
/*
|
||||
* Compute per-output-column width estimates by examining the subquery's
|
||||
* targetlist. For any output that is a plain Var, get the width estimate
|
||||
* targetlist. For any output that is a plain Var, get the width estimate
|
||||
* that was made while planning the subquery. Otherwise, fall back on a
|
||||
* datatype-based estimate.
|
||||
*/
|
||||
@ -3210,7 +3210,7 @@ set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel,
|
||||
if (IsA(texpr, Var) &&
|
||||
subroot->parse->setOperations == NULL)
|
||||
{
|
||||
Var *var = (Var *) texpr;
|
||||
Var *var = (Var *) texpr;
|
||||
RelOptInfo *subrel = find_base_rel(subroot, var->varno);
|
||||
|
||||
item_width = subrel->attr_widths[var->varattno - subrel->min_attr];
|
||||
@ -3332,7 +3332,7 @@ set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, Plan *cteplan)
|
||||
* of estimating baserestrictcost, so we set that, and we also set up width
|
||||
* using what will be purely datatype-driven estimates from the targetlist.
|
||||
* There is no way to do anything sane with the rows value, so we just put
|
||||
* a default estimate and hope that the wrapper can improve on it. The
|
||||
* a default estimate and hope that the wrapper can improve on it. The
|
||||
* wrapper's PlanForeignScan function will be called momentarily.
|
||||
*
|
||||
* The rel's targetlist and restrictinfo list must have been constructed
|
||||
@ -3396,8 +3396,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel)
|
||||
ndx = var->varattno - rel->min_attr;
|
||||
|
||||
/*
|
||||
* If it's a whole-row Var, we'll deal with it below after we
|
||||
* have already cached as many attr widths as possible.
|
||||
* If it's a whole-row Var, we'll deal with it below after we have
|
||||
* already cached as many attr widths as possible.
|
||||
*/
|
||||
if (var->varattno == 0)
|
||||
{
|
||||
@ -3406,8 +3406,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel)
|
||||
}
|
||||
|
||||
/*
|
||||
* The width may have been cached already (especially if it's
|
||||
* a subquery), so don't duplicate effort.
|
||||
* The width may have been cached already (especially if it's a
|
||||
* subquery), so don't duplicate effort.
|
||||
*/
|
||||
if (rel->attr_widths[ndx] > 0)
|
||||
{
|
||||
@ -3464,13 +3464,13 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel)
|
||||
*/
|
||||
if (have_wholerow_var)
|
||||
{
|
||||
int32 wholerow_width = sizeof(HeapTupleHeaderData);
|
||||
int32 wholerow_width = sizeof(HeapTupleHeaderData);
|
||||
|
||||
if (reloid != InvalidOid)
|
||||
{
|
||||
/* Real relation, so estimate true tuple width */
|
||||
wholerow_width += get_relation_data_width(reloid,
|
||||
rel->attr_widths - rel->min_attr);
|
||||
rel->attr_widths - rel->min_attr);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -3484,8 +3484,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel)
|
||||
rel->attr_widths[0 - rel->min_attr] = wholerow_width;
|
||||
|
||||
/*
|
||||
* Include the whole-row Var as part of the output tuple. Yes,
|
||||
* that really is what happens at runtime.
|
||||
* Include the whole-row Var as part of the output tuple. Yes, that
|
||||
* really is what happens at runtime.
|
||||
*/
|
||||
tuple_width += wholerow_width;
|
||||
}
|
||||
|
@ -385,7 +385,7 @@ process_equivalence(PlannerInfo *root, RestrictInfo *restrictinfo,
|
||||
* Also, the expression's exposed collation must match the EC's collation.
|
||||
* This is important because in comparisons like "foo < bar COLLATE baz",
|
||||
* only one of the expressions has the correct exposed collation as we receive
|
||||
* it from the parser. Forcing both of them to have it ensures that all
|
||||
* it from the parser. Forcing both of them to have it ensures that all
|
||||
* variant spellings of such a construct behave the same. Again, we can
|
||||
* stick on a RelabelType to force the right exposed collation. (It might
|
||||
* work to not label the collation at all in EC members, but this is risky
|
||||
@ -414,13 +414,13 @@ canonicalize_ec_expression(Expr *expr, Oid req_type, Oid req_collation)
|
||||
exprCollation((Node *) expr) != req_collation)
|
||||
{
|
||||
/*
|
||||
* Strip any existing RelabelType, then add a new one if needed.
|
||||
* This is to preserve the invariant of no redundant RelabelTypes.
|
||||
* Strip any existing RelabelType, then add a new one if needed. This
|
||||
* is to preserve the invariant of no redundant RelabelTypes.
|
||||
*
|
||||
* If we have to change the exposed type of the stripped expression,
|
||||
* set typmod to -1 (since the new type may not have the same typmod
|
||||
* interpretation). If we only have to change collation, preserve
|
||||
* the exposed typmod.
|
||||
* interpretation). If we only have to change collation, preserve the
|
||||
* exposed typmod.
|
||||
*/
|
||||
while (expr && IsA(expr, RelabelType))
|
||||
expr = (Expr *) ((RelabelType *) expr)->arg;
|
||||
@ -1784,8 +1784,8 @@ add_child_rel_equivalences(PlannerInfo *root,
|
||||
ListCell *lc2;
|
||||
|
||||
/*
|
||||
* If this EC contains a constant, then it's not useful for sorting
|
||||
* or driving an inner index-scan, so we skip generating child EMs.
|
||||
* If this EC contains a constant, then it's not useful for sorting or
|
||||
* driving an inner index-scan, so we skip generating child EMs.
|
||||
*
|
||||
* If this EC contains a volatile expression, then generating child
|
||||
* EMs would be downright dangerous. We rely on a volatile EC having
|
||||
|
@ -119,7 +119,7 @@ static bool match_special_index_operator(Expr *clause,
|
||||
static Expr *expand_boolean_index_clause(Node *clause, int indexcol,
|
||||
IndexOptInfo *index);
|
||||
static List *expand_indexqual_opclause(RestrictInfo *rinfo,
|
||||
Oid opfamily, Oid idxcollation);
|
||||
Oid opfamily, Oid idxcollation);
|
||||
static RestrictInfo *expand_indexqual_rowcompare(RestrictInfo *rinfo,
|
||||
IndexOptInfo *index,
|
||||
int indexcol);
|
||||
@ -1159,8 +1159,8 @@ group_clauses_by_indexkey(IndexOptInfo *index,
|
||||
* (2) must contain an operator which is in the same family as the index
|
||||
* operator for this column, or is a "special" operator as recognized
|
||||
* by match_special_index_operator();
|
||||
* and
|
||||
* (3) must match the collation of the index, if collation is relevant.
|
||||
* and
|
||||
* (3) must match the collation of the index, if collation is relevant.
|
||||
*
|
||||
* Our definition of "const" is pretty liberal: we allow Vars belonging
|
||||
* to the caller-specified outer_relids relations (which had better not
|
||||
@ -1312,7 +1312,7 @@ match_clause_to_indexcol(IndexOptInfo *index,
|
||||
* is a "special" indexable operator.
|
||||
*/
|
||||
if (plain_op &&
|
||||
match_special_index_operator(clause, opfamily, idxcollation, true))
|
||||
match_special_index_operator(clause, opfamily, idxcollation, true))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
@ -1438,7 +1438,7 @@ match_rowcompare_to_indexcol(IndexOptInfo *index,
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* ---- ROUTINES TO CHECK ORDERING OPERATORS ----
|
||||
* ---- ROUTINES TO CHECK ORDERING OPERATORS ----
|
||||
****************************************************************************/
|
||||
|
||||
/*
|
||||
@ -1461,7 +1461,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys)
|
||||
|
||||
foreach(lc1, pathkeys)
|
||||
{
|
||||
PathKey *pathkey = (PathKey *) lfirst(lc1);
|
||||
PathKey *pathkey = (PathKey *) lfirst(lc1);
|
||||
bool found = false;
|
||||
ListCell *lc2;
|
||||
|
||||
@ -1483,7 +1483,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys)
|
||||
foreach(lc2, pathkey->pk_eclass->ec_members)
|
||||
{
|
||||
EquivalenceMember *member = (EquivalenceMember *) lfirst(lc2);
|
||||
int indexcol;
|
||||
int indexcol;
|
||||
|
||||
/* No possibility of match if it references other relations */
|
||||
if (!bms_equal(member->em_relids, index->rel->relids))
|
||||
@ -1491,7 +1491,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys)
|
||||
|
||||
for (indexcol = 0; indexcol < index->ncolumns; indexcol++)
|
||||
{
|
||||
Expr *expr;
|
||||
Expr *expr;
|
||||
|
||||
expr = match_clause_to_ordering_op(index,
|
||||
indexcol,
|
||||
@ -1535,7 +1535,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys)
|
||||
* Note that we currently do not consider the collation of the ordering
|
||||
* operator's result. In practical cases the result type will be numeric
|
||||
* and thus have no collation, and it's not very clear what to match to
|
||||
* if it did have a collation. The index's collation should match the
|
||||
* if it did have a collation. The index's collation should match the
|
||||
* ordering operator's input collation, not its result.
|
||||
*
|
||||
* If successful, return 'clause' as-is if the indexkey is on the left,
|
||||
@ -1598,8 +1598,8 @@ match_clause_to_ordering_op(IndexOptInfo *index,
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Is the (commuted) operator an ordering operator for the opfamily?
|
||||
* And if so, does it yield the right sorting semantics?
|
||||
* Is the (commuted) operator an ordering operator for the opfamily? And
|
||||
* if so, does it yield the right sorting semantics?
|
||||
*/
|
||||
sortfamily = get_op_opfamily_sortfamily(expr_op, opfamily);
|
||||
if (sortfamily != pk_opfamily)
|
||||
@ -2198,9 +2198,9 @@ relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel,
|
||||
continue;
|
||||
|
||||
/*
|
||||
* XXX at some point we may need to check collations here
|
||||
* too. For the moment we assume all collations reduce to
|
||||
* the same notion of equality.
|
||||
* XXX at some point we may need to check collations here too.
|
||||
* For the moment we assume all collations reduce to the same
|
||||
* notion of equality.
|
||||
*/
|
||||
|
||||
/* OK, see if the condition operand matches the index key */
|
||||
@ -2544,10 +2544,10 @@ match_special_index_operator(Expr *clause, Oid opfamily, Oid idxcollation,
|
||||
*
|
||||
* The non-pattern opclasses will not sort the way we need in most non-C
|
||||
* locales. We can use such an index anyway for an exact match (simple
|
||||
* equality), but not for prefix-match cases. Note that we are looking
|
||||
* at the index's collation, not the expression's collation -- this test
|
||||
* is not dependent on the LIKE/regex operator's collation (which would
|
||||
* only affect case folding behavior of ILIKE, anyway).
|
||||
* equality), but not for prefix-match cases. Note that we are looking at
|
||||
* the index's collation, not the expression's collation -- this test is
|
||||
* not dependent on the LIKE/regex operator's collation (which would only
|
||||
* affect case folding behavior of ILIKE, anyway).
|
||||
*/
|
||||
switch (expr_op)
|
||||
{
|
||||
@ -2657,7 +2657,7 @@ expand_indexqual_conditions(IndexOptInfo *index, List *clausegroups)
|
||||
resultquals = list_concat(resultquals,
|
||||
expand_indexqual_opclause(rinfo,
|
||||
curFamily,
|
||||
curCollation));
|
||||
curCollation));
|
||||
}
|
||||
else if (IsA(clause, ScalarArrayOpExpr))
|
||||
{
|
||||
@ -3254,7 +3254,7 @@ network_prefix_quals(Node *leftop, Oid expr_op, Oid opfamily, Datum rightop)
|
||||
expr = make_opclause(opr1oid, BOOLOID, false,
|
||||
(Expr *) leftop,
|
||||
(Expr *) makeConst(datatype, -1,
|
||||
InvalidOid, /* not collatable */
|
||||
InvalidOid, /* not collatable */
|
||||
-1, opr1right,
|
||||
false, false),
|
||||
InvalidOid, InvalidOid);
|
||||
@ -3272,7 +3272,7 @@ network_prefix_quals(Node *leftop, Oid expr_op, Oid opfamily, Datum rightop)
|
||||
expr = make_opclause(opr2oid, BOOLOID, false,
|
||||
(Expr *) leftop,
|
||||
(Expr *) makeConst(datatype, -1,
|
||||
InvalidOid, /* not collatable */
|
||||
InvalidOid, /* not collatable */
|
||||
-1, opr2right,
|
||||
false, false),
|
||||
InvalidOid, InvalidOid);
|
||||
|
@ -97,11 +97,11 @@ add_paths_to_joinrel(PlannerInfo *root,
|
||||
|
||||
/*
|
||||
* 1. Consider mergejoin paths where both relations must be explicitly
|
||||
* sorted. Skip this if we can't mergejoin.
|
||||
* sorted. Skip this if we can't mergejoin.
|
||||
*/
|
||||
if (mergejoin_allowed)
|
||||
sort_inner_and_outer(root, joinrel, outerrel, innerrel,
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
|
||||
/*
|
||||
* 2. Consider paths where the outer relation need not be explicitly
|
||||
@ -112,7 +112,7 @@ add_paths_to_joinrel(PlannerInfo *root,
|
||||
*/
|
||||
if (mergejoin_allowed)
|
||||
match_unsorted_outer(root, joinrel, outerrel, innerrel,
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
|
||||
#ifdef NOT_USED
|
||||
|
||||
@ -129,7 +129,7 @@ add_paths_to_joinrel(PlannerInfo *root,
|
||||
*/
|
||||
if (mergejoin_allowed)
|
||||
match_unsorted_inner(root, joinrel, outerrel, innerrel,
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
restrictlist, mergeclause_list, jointype, sjinfo);
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
@ -30,7 +30,7 @@ static bool has_legal_joinclause(PlannerInfo *root, RelOptInfo *rel);
|
||||
static bool is_dummy_rel(RelOptInfo *rel);
|
||||
static void mark_dummy_rel(RelOptInfo *rel);
|
||||
static bool restriction_is_constant_false(List *restrictlist,
|
||||
bool only_pushed_down);
|
||||
bool only_pushed_down);
|
||||
|
||||
|
||||
/*
|
||||
@ -604,10 +604,10 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
|
||||
*
|
||||
* Also, a provably constant-false join restriction typically means that
|
||||
* we can skip evaluating one or both sides of the join. We do this by
|
||||
* marking the appropriate rel as dummy. For outer joins, a constant-false
|
||||
* restriction that is pushed down still means the whole join is dummy,
|
||||
* while a non-pushed-down one means that no inner rows will join so we
|
||||
* can treat the inner rel as dummy.
|
||||
* marking the appropriate rel as dummy. For outer joins, a
|
||||
* constant-false restriction that is pushed down still means the whole
|
||||
* join is dummy, while a non-pushed-down one means that no inner rows
|
||||
* will join so we can treat the inner rel as dummy.
|
||||
*
|
||||
* We need only consider the jointypes that appear in join_info_list, plus
|
||||
* JOIN_INNER.
|
||||
|
@ -253,7 +253,7 @@ make_pathkey_from_sortinfo(PlannerInfo *root,
|
||||
/*
|
||||
* EquivalenceClasses need to contain opfamily lists based on the family
|
||||
* membership of mergejoinable equality operators, which could belong to
|
||||
* more than one opfamily. So we have to look up the opfamily's equality
|
||||
* more than one opfamily. So we have to look up the opfamily's equality
|
||||
* operator and get its membership.
|
||||
*/
|
||||
equality_op = get_opfamily_member(opfamily,
|
||||
@ -558,9 +558,9 @@ build_index_pathkeys(PlannerInfo *root,
|
||||
true);
|
||||
|
||||
/*
|
||||
* If the sort key isn't already present in any EquivalenceClass,
|
||||
* then it's not an interesting sort order for this query. So
|
||||
* we can stop now --- lower-order sort keys aren't useful either.
|
||||
* If the sort key isn't already present in any EquivalenceClass, then
|
||||
* it's not an interesting sort order for this query. So we can stop
|
||||
* now --- lower-order sort keys aren't useful either.
|
||||
*/
|
||||
if (!cpathkey)
|
||||
break;
|
||||
@ -747,8 +747,8 @@ convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel,
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Build a representation of this targetlist entry as
|
||||
* an outer Var.
|
||||
* Build a representation of this targetlist entry as an
|
||||
* outer Var.
|
||||
*/
|
||||
outer_expr = (Expr *) makeVarFromTargetEntry(rel->relid,
|
||||
tle);
|
||||
@ -923,7 +923,7 @@ make_pathkeys_for_sortclauses(PlannerInfo *root,
|
||||
* right sides.
|
||||
*
|
||||
* Note this is called before EC merging is complete, so the links won't
|
||||
* necessarily point to canonical ECs. Before they are actually used for
|
||||
* necessarily point to canonical ECs. Before they are actually used for
|
||||
* anything, update_mergeclause_eclasses must be called to ensure that
|
||||
* they've been updated to point to canonical ECs.
|
||||
*/
|
||||
|
Reference in New Issue
Block a user