database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-07 00:36:50 +03:00
Code Activity

Pgindent clauses.c, per request from Tom.

Browse Source
This commit is contained in:
Bruce Momjian
2011-11-28 16:47:43 -05:00
parent a04161f2ea
commit 269755ef72
1 changed files with 975 additions and 940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2126,10 +2126,10 @@ eval_const_expressions_mutator(Node *node,
if (context->estimate || (prm->pflags & PARAM_FLAG_CONST))
{
/*
* Return a Const representing the param value. Must copy
* pass-by-ref datatypes, since the Param might be in a
* memory context shorter-lived than our output plan
* should be.
* Return a Const representing the param value.
* Must copy pass-by-ref datatypes, since the
* Param might be in a memory context
* shorter-lived than our output plan should be.
*/
int16 typLen;
bool typByVal;
@ -2151,7 +2151,11 @@ eval_const_expressions_mutator(Node *node,
}
}
}
/* Not replaceable, so just copy the Param (no need to recurse) */
/*
* Not replaceable, so just copy the Param (no need to
* recurse)
*/
return (Node *) copyObject(param);
}
case T_FuncExpr:
@ -2164,8 +2168,8 @@ eval_const_expressions_mutator(Node *node,
ListCell *lc;
/*
* Reduce constants in the FuncExpr's arguments, and check to see if
* there are any named args.
* Reduce constants in the FuncExpr's arguments, and check to
* see if there are any named args.
*/
args = NIL;
has_named_args = false;
@ -2180,10 +2184,11 @@ eval_const_expressions_mutator(Node *node,
}
/*
* Code for op/func reduction is pretty bulky, so split it out as a
* separate function. Note: exprTypmod normally returns -1 for a
* FuncExpr, but not when the node is recognizably a length coercion;
* we want to preserve the typmod in the eventual Const if so.
* Code for op/func reduction is pretty bulky, so split it out
* as a separate function. Note: exprTypmod normally returns
* -1 for a FuncExpr, but not when the node is recognizably a
* length coercion; we want to preserve the typmod in the
* eventual Const if so.
*/
simple = simplify_function((Expr *) expr,
expr->funcid,
@ -2196,10 +2201,10 @@ eval_const_expressions_mutator(Node *node,
return (Node *) simple;
/*
* The expression cannot be simplified any further, so build and
* return a replacement FuncExpr node using the possibly-simplified
* arguments. Note that we have also converted the argument list to
* positional notation.
* The expression cannot be simplified any further, so build
* and return a replacement FuncExpr node using the
* possibly-simplified arguments. Note that we have also
* converted the argument list to positional notation.
*/
newexpr = makeNode(FuncExpr);
newexpr->funcid = expr->funcid;
@ -2220,23 +2225,24 @@ eval_const_expressions_mutator(Node *node,
OpExpr *newexpr;
/*
* Reduce constants in the OpExpr's arguments. We know args is either
* NIL or a List node, so we can call expression_tree_mutator directly
* rather than recursing to self.
* Reduce constants in the OpExpr's arguments. We know args
* is either NIL or a List node, so we can call
* expression_tree_mutator directly rather than recursing to
* self.
*/
args = (List *) expression_tree_mutator((Node *) expr->args,
eval_const_expressions_mutator,
(void *) context);
/*
* Need to get OID of underlying function. Okay to scribble on input
* to this extent.
* Need to get OID of underlying function. Okay to scribble
* on input to this extent.
*/
set_opfuncid(expr);
/*
* Code for op/func reduction is pretty bulky, so split it out as a
* separate function.
* Code for op/func reduction is pretty bulky, so split it out
* as a separate function.
*/
simple = simplify_function((Expr *) expr,
expr->opfuncid,
@ -2249,9 +2255,9 @@ eval_const_expressions_mutator(Node *node,
return (Node *) simple;
/*
* If the operator is boolean equality or inequality, we know how to
* simplify cases involving one constant and one non-constant
* argument.
* If the operator is boolean equality or inequality, we know
* how to simplify cases involving one constant and one
* non-constant argument.
*/
if (expr->opno == BooleanEqualOperator ||
expr->opno == BooleanNotEqualOperator)
@ -2262,9 +2268,9 @@ eval_const_expressions_mutator(Node *node,
}
/*
* The expression cannot be simplified any further, so build and
* return a replacement OpExpr node using the possibly-simplified
* arguments.
* The expression cannot be simplified any further, so build
* and return a replacement OpExpr node using the
* possibly-simplified arguments.
*/
newexpr = makeNode(OpExpr);
newexpr->opno = expr->opno;
@ -2289,9 +2295,10 @@ eval_const_expressions_mutator(Node *node,
DistinctExpr *newexpr;
/*
* Reduce constants in the DistinctExpr's arguments. We know args is
* either NIL or a List node, so we can call expression_tree_mutator
* directly rather than recursing to self.
* Reduce constants in the DistinctExpr's arguments. We know
* args is either NIL or a List node, so we can call
* expression_tree_mutator directly rather than recursing to
* self.
*/
args = (List *) expression_tree_mutator((Node *) expr->args,
eval_const_expressions_mutator,
@ -2299,7 +2306,8 @@ eval_const_expressions_mutator(Node *node,
/*
* We must do our own check for NULLs because DistinctExpr has
* different results for NULL input than the underlying operator does.
* different results for NULL input than the underlying
* operator does.
*/
foreach(arg, args)
{
@ -2327,14 +2335,15 @@ eval_const_expressions_mutator(Node *node,
/* (NOT okay to try to inline it, though!) */
/*
* Need to get OID of underlying function. Okay to scribble on
* input to this extent.
* Need to get OID of underlying function. Okay to
* scribble on input to this extent.
*/
set_opfuncid((OpExpr *) expr); /* rely on struct equivalence */
set_opfuncid((OpExpr *) expr); /* rely on struct
* equivalence */
/*
* Code for op/func reduction is pretty bulky, so split it out as
* a separate function.
* Code for op/func reduction is pretty bulky, so split it
* out as a separate function.
*/
simple = simplify_function((Expr *) expr,
expr->opfuncid,
@ -2346,8 +2355,8 @@ eval_const_expressions_mutator(Node *node,
if (simple) /* successfully simplified it */
{
/*
* Since the underlying operator is "=", must negate its
* result
* Since the underlying operator is "=", must negate
* its result
*/
Const *csimple = (Const *) simple;
@ -2359,8 +2368,8 @@ eval_const_expressions_mutator(Node *node,
}
/*
* The expression cannot be simplified any further, so build and
* return a replacement DistinctExpr node using the
* The expression cannot be simplified any further, so build
* and return a replacement DistinctExpr node using the
* possibly-simplified arguments.
*/
newexpr = makeNode(DistinctExpr);
@ -2395,7 +2404,11 @@ eval_const_expressions_mutator(Node *node,
/* If all the inputs are FALSE, result is FALSE */
if (newargs == NIL)
return makeBoolConst(false, false);
/* If only one nonconst-or-NULL input, it's the result */
/*
* If only one nonconst-or-NULL input, it's the
* result
*/
if (list_length(newargs) == 1)
return (Node *) linitial(newargs);
/* Else we still need an OR node */
@ -2416,7 +2429,11 @@ eval_const_expressions_mutator(Node *node,
/* If all the inputs are TRUE, result is TRUE */
if (newargs == NIL)
return makeBoolConst(true, false);
/* If only one nonconst-or-NULL input, it's the result */
/*
* If only one nonconst-or-NULL input, it's the
* result
*/
if (list_length(newargs) == 1)
return (Node *) linitial(newargs);
/* Else we still need an AND node */
@ -2431,8 +2448,8 @@ eval_const_expressions_mutator(Node *node,
context);
/*
* Use negate_clause() to see if we can simplify away the
* NOT.
* Use negate_clause() to see if we can simplify
* away the NOT.
*/
return negate_clause(arg);
}
@ -2445,19 +2462,21 @@ eval_const_expressions_mutator(Node *node,
}
case T_SubPlan:
case T_AlternativeSubPlan:
/*
* Return a SubPlan unchanged --- too late to do anything with it.
*
* XXX should we ereport() here instead? Probably this routine should
* never be invoked after SubPlan creation.
* XXX should we ereport() here instead? Probably this routine
* should never be invoked after SubPlan creation.
*/
return node;
case T_RelabelType:
{
/*
* If we can simplify the input to a constant, then we don't need the
* RelabelType node anymore: just change the type field of the Const
* node. Otherwise, must copy the RelabelType node.
* If we can simplify the input to a constant, then we don't
* need the RelabelType node anymore: just change the type
* field of the Const node. Otherwise, must copy the
* RelabelType node.
*/
RelabelType *relabel = (RelabelType *) node;
Node *arg;
@ -2466,8 +2485,8 @@ eval_const_expressions_mutator(Node *node,
context);
/*
* If we find stacked RelabelTypes (eg, from foo :: int :: oid) we can
* discard all but the top one.
* If we find stacked RelabelTypes (eg, from foo :: int ::
* oid) we can discard all but the top one.
*/
while (arg && IsA(arg, RelabelType))
arg = (Node *) ((RelabelType *) arg)->arg;
@ -2514,13 +2533,13 @@ eval_const_expressions_mutator(Node *node,
args = list_make1(arg);
/*
* CoerceViaIO represents calling the source type's output function
* then the result type's input function. So, try to simplify it as
* though it were a stack of two such function calls. First we need
* to know what the functions are.
* CoerceViaIO represents calling the source type's output
* function then the result type's input function. So, try to
* simplify it as though it were a stack of two such function
* calls. First we need to know what the functions are.
*
* Note that the coercion functions are assumed not to care about
* input collation, so we just pass InvalidOid for that.
* Note that the coercion functions are assumed not to care
* about input collation, so we just pass InvalidOid for that.
*/
getTypeOutputInfo(exprType((Node *) arg), &outfunc, &outtypisvarlena);
getTypeInputInfo(expr->resulttype, &infunc, &intypioparam);
@ -2535,8 +2554,9 @@ eval_const_expressions_mutator(Node *node,
if (simple) /* successfully simplified output fn */
{
/*
* Input functions may want 1 to 3 arguments. We always supply
* all three, trusting that nothing downstream will complain.
* Input functions may want 1 to 3 arguments. We always
* supply all three, trusting that nothing downstream will
* complain.
*/
args = list_make3(simple,
makeConst(OIDOID, -1, InvalidOid, sizeof(Oid),
@ -2558,9 +2578,9 @@ eval_const_expressions_mutator(Node *node,
}
/*
* The expression cannot be simplified any further, so build and
* return a replacement CoerceViaIO node using the possibly-simplified
* argument.
* The expression cannot be simplified any further, so build
* and return a replacement CoerceViaIO node using the
* possibly-simplified argument.
*/
newexpr = makeNode(CoerceViaIO);
newexpr->arg = arg;
@ -2577,8 +2597,8 @@ eval_const_expressions_mutator(Node *node,
ArrayCoerceExpr *newexpr;
/*
* Reduce constants in the ArrayCoerceExpr's argument, then build a
* new ArrayCoerceExpr.
* Reduce constants in the ArrayCoerceExpr's argument, then
* build a new ArrayCoerceExpr.
*/
arg = (Expr *) eval_const_expressions_mutator((Node *) expr->arg,
context);
@ -2594,8 +2614,8 @@ eval_const_expressions_mutator(Node *node,
newexpr->location = expr->location;
/*
* If constant argument and it's a binary-coercible or immutable
* conversion, we can simplify it to a constant.
* If constant argument and it's a binary-coercible or
* immutable conversion, we can simplify it to a constant.
*/
if (arg && IsA(arg, Const) &&
(!OidIsValid(newexpr->elemfuncid) ||
@ -2611,11 +2631,12 @@ eval_const_expressions_mutator(Node *node,
case T_CollateExpr:
{
/*
* If we can simplify the input to a constant, then we don't need the
* CollateExpr node at all: just change the constcollid field of the
* Const node. Otherwise, replace the CollateExpr with a RelabelType.
* (We do that so as to improve uniformity of expression
* representation and thus simplify comparison of expressions.)
* If we can simplify the input to a constant, then we don't
* need the CollateExpr node at all: just change the
* constcollid field of the Const node. Otherwise, replace
* the CollateExpr with a RelabelType. (We do that so as to
* improve uniformity of expression representation and thus
* simplify comparison of expressions.)
*/
CollateExpr *collate = (CollateExpr *) node;
Node *arg;
@ -2702,7 +2723,8 @@ eval_const_expressions_mutator(Node *node,
if (newarg && IsA(newarg, Const))
{
context->case_val = newarg;
newarg = NULL; /* not needed anymore, see comment above */
newarg = NULL; /* not needed anymore, see comment
* above */
}
else
context->case_val = NULL;
@ -2724,8 +2746,9 @@ eval_const_expressions_mutator(Node *node,
context);
/*
* If the test condition is constant FALSE (or NULL), then drop
* this WHEN clause completely, without processing the result.
* If the test condition is constant FALSE (or NULL), then
* drop this WHEN clause completely, without processing
* the result.
*/
if (casecond && IsA(casecond, Const))
{
@ -2733,7 +2756,8 @@ eval_const_expressions_mutator(Node *node,
if (const_input->constisnull ||
!DatumGetBool(const_input->constvalue))
continue; /* drop alternative with FALSE condition */
continue; /* drop alternative with FALSE
* condition */
/* Else it's constant TRUE */
const_true_cond = true;
}
@ -2756,8 +2780,9 @@ eval_const_expressions_mutator(Node *node,
}
/*
* Found a TRUE condition, so none of the remaining alternatives
* can be reached. We treat the result as the default result.
* Found a TRUE condition, so none of the remaining
* alternatives can be reached. We treat the result as
* the default result.
*/
defresult = caseresult;
break;
@ -2771,7 +2796,10 @@ eval_const_expressions_mutator(Node *node,
context->case_val = save_case_val;
/* If no non-FALSE alternatives, CASE reduces to the default result */
/*
* If no non-FALSE alternatives, CASE reduces to the default
* result
*/
if (newargs == NIL)
return defresult;
/* Otherwise we need a new CASE node */
@ -2787,9 +2815,9 @@ eval_const_expressions_mutator(Node *node,
case T_CaseTestExpr:
{
/*
* If we know a constant test value for the current CASE construct,
* substitute it for the placeholder. Else just return the
* placeholder as-is.
* If we know a constant test value for the current CASE
* construct, substitute it for the placeholder. Else just
* return the placeholder as-is.
*/
if (context->case_val)
return copyObject(context->case_val);
@ -2848,11 +2876,12 @@ eval_const_expressions_mutator(Node *node,
context);
/*
* We can remove null constants from the list. For a non-null
* constant, if it has not been preceded by any other
* non-null-constant expressions then it is the result. Otherwise,
* it's the next argument, but we can drop following arguments
* since they will never be reached.
* We can remove null constants from the list. For a
* non-null constant, if it has not been preceded by any
* other non-null-constant expressions then it is the
* result. Otherwise, it's the next argument, but we can
* drop following arguments since they will never be
* reached.
*/
if (IsA(e, Const))
{
@ -2866,7 +2895,10 @@ eval_const_expressions_mutator(Node *node,
newargs = lappend(newargs, e);
}
/* If all the arguments were constant null, the result is just null */
/*
* If all the arguments were constant null, the result is just
* null
*/
if (newargs == NIL)
return (Node *) makeNullConst(coalesceexpr->coalescetype,
-1,
@ -2882,15 +2914,16 @@ eval_const_expressions_mutator(Node *node,
case T_FieldSelect:
{
/*
* We can optimize field selection from a whole-row Var into a simple
* Var. (This case won't be generated directly by the parser, because
* ParseComplexProjection short-circuits it. But it can arise while
* simplifying functions.) Also, we can optimize field selection from
* a RowExpr construct.
* We can optimize field selection from a whole-row Var into a
* simple Var. (This case won't be generated directly by the
* parser, because ParseComplexProjection short-circuits it.
* But it can arise while simplifying functions.) Also, we
* can optimize field selection from a RowExpr construct.
*
* We must however check that the declared type of the field is still
* the same as when the FieldSelect was created --- this can change if
* someone did ALTER COLUMN TYPE on the rowtype.
* We must however check that the declared type of the field
* is still the same as when the FieldSelect was created ---
* this can change if someone did ALTER COLUMN TYPE on the
* rowtype.
*/
FieldSelect *fselect = (FieldSelect *) node;
FieldSelect *newfselect;
@ -2953,9 +2986,10 @@ eval_const_expressions_mutator(Node *node,
if (arg && IsA(arg, RowExpr))
{
/*
* We break ROW(...) IS [NOT] NULL into separate tests on its
* component fields. This form is usually more efficient to
* evaluate, as well as being more amenable to optimization.
* We break ROW(...) IS [NOT] NULL into separate tests on
* its component fields. This form is usually more
* efficient to evaluate, as well as being more amenable
* to optimization.
*/
RowExpr *rarg = (RowExpr *) arg;
List *newargs = NIL;
@ -2968,8 +3002,8 @@ eval_const_expressions_mutator(Node *node,
Node *relem = (Node *) lfirst(l);
/*
* A constant field refutes the whole NullTest if it's of the
* wrong nullness; else we can discard it.
* A constant field refutes the whole NullTest if it's
* of the wrong nullness; else we can discard it.
*/
if (relem && IsA(relem, Const))
{
@ -3078,12 +3112,13 @@ eval_const_expressions_mutator(Node *node,
return (Node *) newbtest;
}
case T_PlaceHolderVar:
/*
* In estimation mode, just strip the PlaceHolderVar node altogether;
* this amounts to estimating that the contained value won't be forced
* to null by an outer join. In regular mode we just use the default
* behavior (ie, simplify the expression but leave the PlaceHolderVar
* node intact).
* In estimation mode, just strip the PlaceHolderVar node
* altogether; this amounts to estimating that the contained value
* won't be forced to null by an outer join. In regular mode we
* just use the default behavior (ie, simplify the expression but
* leave the PlaceHolderVar node intact).
*/
if (context->estimate)
{