database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-10-31 10:30:33 +03:00
Code Activity

Update typedefs.list and re-run pgindent

Browse Source 
Discussion: http://postgr.es/m/CA+TgmoaA9=1RWKtBWpDaj+sF3Stgc8sHgf5z=KGtbjwPLQVDMA@mail.gmail.com
This commit is contained in:
Robert Haas
2017-11-29 09:24:24 -05:00
parent 801386af62
commit eaedf0df71
52 changed files with 224 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/backend/optimizer/plan/setrefs.c
View File

@@ -1795,7 +1795,7 @@ set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset)
static void
set_param_references(PlannerInfo *root, Plan *plan)
{
Assert(IsA(plan, Gather) || IsA(plan, GatherMerge));
Assert(IsA(plan, Gather) ||IsA(plan, GatherMerge));
if (plan->lefttree->extParam)
{

2
src/backend/optimizer/util/clauses.c
View File

@@ -1118,7 +1118,7 @@ is_parallel_safe(PlannerInfo *root, Node *node)
foreach(l2, initsubplan->setParam)
context.safe_param_ids = lcons_int(lfirst_int(l2),
context.safe_param_ids);
context.safe_param_ids);
}
}

8
src/backend/optimizer/util/pathnode.c
View File

@@ -2412,7 +2412,7 @@ apply_projection_to_path(PlannerInfo *root,
* workers can help project. But if there is something that is not
* parallel-safe in the target expressions, then we can't.
*/
if ((IsA(path, GatherPath) || IsA(path, GatherMergePath)) &&
if ((IsA(path, GatherPath) ||IsA(path, GatherMergePath)) &&
is_parallel_safe(root, (Node *) target->exprs))
{
/*
@@ -2421,9 +2421,9 @@ apply_projection_to_path(PlannerInfo *root,
* It seems unlikely at present that there could be any other
* references to the subpath, but better safe than sorry.
*
* Note that we don't change the parallel path's cost estimates; it might
* be appropriate to do so, to reflect the fact that the bulk of the
* target evaluation will happen in workers.
* Note that we don't change the parallel path's cost estimates; it
* might be appropriate to do so, to reflect the fact that the bulk of
* the target evaluation will happen in workers.
*/
if (IsA(path, GatherPath))
{

6
src/backend/optimizer/util/plancat.c
View File

@@ -1825,7 +1825,7 @@ set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
Relation relation)
{
PartitionDesc partdesc;
PartitionKey partkey;
PartitionKey partkey;
Assert(relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
@@ -1890,8 +1890,8 @@ find_partition_scheme(PlannerInfo *root, Relation relation)
/*
* Did not find matching partition scheme. Create one copying relevant
* information from the relcache. We need to copy the contents of the array
* since the relcache entry may not survive after we have closed the
* information from the relcache. We need to copy the contents of the
* array since the relcache entry may not survive after we have closed the
* relation.
*/
part_scheme = (PartitionScheme) palloc0(sizeof(PartitionSchemeData));

34
src/backend/optimizer/util/relnode.c
View File

@@ -873,11 +873,11 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
continue;
/*
* Otherwise, anything in a baserel or joinrel targetlist ought to be a
* Var. Children of a partitioned table may have ConvertRowtypeExpr
* translating whole-row Var of a child to that of the parent. Children
* of an inherited table or subquery child rels can not directly
* participate in a join, so other kinds of nodes here.
* Otherwise, anything in a baserel or joinrel targetlist ought to be
* a Var. Children of a partitioned table may have ConvertRowtypeExpr
* translating whole-row Var of a child to that of the parent.
* Children of an inherited table or subquery child rels can not
* directly participate in a join, so other kinds of nodes here.
*/
if (IsA(var, Var))
{
@@ -901,7 +901,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
child_expr = (ConvertRowtypeExpr *) childvar;
childvar = (Var *) child_expr->arg;
}
Assert(IsA(childvar, Var) && childvar->varattno == 0);
Assert(IsA(childvar, Var) &&childvar->varattno == 0);
baserel = find_base_rel(root, childvar->varno);
ndx = 0 - baserel->min_attr;
@@ -1666,18 +1666,19 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) *partnatts);
(List **) palloc0(sizeof(List *) * partnatts);
/*
* Construct partition keys for the join.
*
* An INNER join between two partitioned relations can be regarded as
* partitioned by either key expression. For example, A INNER JOIN B ON A.a =
* B.b can be regarded as partitioned on A.a or on B.b; they are equivalent.
* partitioned by either key expression. For example, A INNER JOIN B ON
* A.a = B.b can be regarded as partitioned on A.a or on B.b; they are
* equivalent.
*
* For a SEMI or ANTI join, the result can only be regarded as being
* partitioned in the same manner as the outer side, since the inner columns
* are not retained.
* partitioned in the same manner as the outer side, since the inner
* columns are not retained.
*
* An OUTER join like (A LEFT JOIN B ON A.a = B.b) may produce rows with
* B.b NULL. These rows may not fit the partitioning conditions imposed on
@@ -1686,11 +1687,12 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* expressions from the OUTER side only. However, because all
* commonly-used comparison operators are strict, the presence of nulls on
* the outer side doesn't cause any problem; they can't match anything at
* future join levels anyway. Therefore, we track two sets of expressions:
* those that authentically partition the relation (partexprs) and those
* that partition the relation with the exception that extra nulls may be
* present (nullable_partexprs). When the comparison operator is strict,
* the latter is just as good as the former.
* future join levels anyway. Therefore, we track two sets of
* expressions: those that authentically partition the relation
* (partexprs) and those that partition the relation with the exception
* that extra nulls may be present (nullable_partexprs). When the
* comparison operator is strict, the latter is just as good as the
* former.
*/
for (cnt = 0; cnt < partnatts; cnt++)
{