mirror of
https://github.com/postgres/postgres.git
synced 2025-06-29 10:41:53 +03:00
Remove tabs after spaces in C comments
This was not changed in HEAD, but will be done later as part of a pgindent run. Future pgindent runs will also do this. Report by Tom Lane Backpatch through all supported branches, but not HEAD
This commit is contained in:
Bruce Momjian
@ -26,7 +26,7 @@
|
||||
* ExecProject() is used to make tuple projections. Rather then
|
||||
* trying to speed it up, the execution plan should be pre-processed
|
||||
* to facilitate attribute sharing between nodes wherever possible,
|
||||
* instead of doing needless copying. -cim 5/31/91
|
||||
* instead of doing needless copying. -cim 5/31/91
|
||||
*
|
||||
* During expression evaluation, we check_stack_depth only in
|
||||
* ExecMakeFunctionResult (and substitute routines) rather than at every
|
||||
@ -199,7 +199,7 @@ static Datum ExecEvalCurrentOfExpr(ExprState *exprstate, ExprContext *econtext,
|
||||
*
|
||||
* Note: for notational simplicity we declare these functions as taking the
|
||||
* specific type of ExprState that they work on. This requires casting when
|
||||
* assigning the function pointer in ExecInitExpr. Be careful that the
|
||||
* assigning the function pointer in ExecInitExpr. Be careful that the
|
||||
* function signature is declared correctly, because the cast suppresses
|
||||
* automatic checking!
|
||||
*
|
||||
@ -234,7 +234,7 @@ static Datum ExecEvalCurrentOfExpr(ExprState *exprstate, ExprContext *econtext,
|
||||
* The caller should already have switched into the temporary memory
|
||||
* context econtext->ecxt_per_tuple_memory. The convenience entry point
|
||||
* ExecEvalExprSwitchContext() is provided for callers who don't prefer to
|
||||
* do the switch in an outer loop. We do not do the switch in these routines
|
||||
* do the switch in an outer loop. We do not do the switch in these routines
|
||||
* because it'd be a waste of cycles during nested expression evaluation.
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
@ -364,7 +364,7 @@ ExecEvalArrayRef(ArrayRefExprState *astate,
|
||||
* We might have a nested-assignment situation, in which the
|
||||
* refassgnexpr is itself a FieldStore or ArrayRef that needs to
|
||||
* obtain and modify the previous value of the array element or slice
|
||||
* being replaced. If so, we have to extract that value from the
|
||||
* being replaced. If so, we have to extract that value from the
|
||||
* array and pass it down via the econtext's caseValue. It's safe to
|
||||
* reuse the CASE mechanism because there cannot be a CASE between
|
||||
* here and where the value would be needed, and an array assignment
|
||||
@ -437,7 +437,7 @@ ExecEvalArrayRef(ArrayRefExprState *astate,
|
||||
/*
|
||||
* For assignment to varlena arrays, we handle a NULL original array
|
||||
* by substituting an empty (zero-dimensional) array; insertion of the
|
||||
* new element will result in a singleton array value. It does not
|
||||
* new element will result in a singleton array value. It does not
|
||||
* matter whether the new element is NULL.
|
||||
*/
|
||||
if (*isNull)
|
||||
@ -827,11 +827,11 @@ ExecEvalWholeRowVar(WholeRowVarExprState *wrvstate, ExprContext *econtext,
|
||||
* We really only care about numbers of attributes and data types.
|
||||
* Also, we can ignore type mismatch on columns that are dropped in
|
||||
* the destination type, so long as (1) the physical storage matches
|
||||
* or (2) the actual column value is NULL. Case (1) is helpful in
|
||||
* or (2) the actual column value is NULL. Case (1) is helpful in
|
||||
* some cases involving out-of-date cached plans, while case (2) is
|
||||
* expected behavior in situations such as an INSERT into a table with
|
||||
* dropped columns (the planner typically generates an INT4 NULL
|
||||
* regardless of the dropped column type). If we find a dropped
|
||||
* regardless of the dropped column type). If we find a dropped
|
||||
* column and cannot verify that case (1) holds, we have to use
|
||||
* ExecEvalWholeRowSlow to check (2) for each row.
|
||||
*/
|
||||
@ -1488,7 +1488,7 @@ ExecEvalFuncArgs(FunctionCallInfo fcinfo,
|
||||
* ExecPrepareTuplestoreResult
|
||||
*
|
||||
* Subroutine for ExecMakeFunctionResult: prepare to extract rows from a
|
||||
* tuplestore function result. We must set up a funcResultSlot (unless
|
||||
* tuplestore function result. We must set up a funcResultSlot (unless
|
||||
* already done in a previous call cycle) and verify that the function
|
||||
* returned the expected tuple descriptor.
|
||||
*/
|
||||
@ -1533,7 +1533,7 @@ ExecPrepareTuplestoreResult(FuncExprState *fcache,
|
||||
}
|
||||
|
||||
/*
|
||||
* If function provided a tupdesc, cross-check it. We only really need to
|
||||
* If function provided a tupdesc, cross-check it. We only really need to
|
||||
* do this for functions returning RECORD, but might as well do it always.
|
||||
*/
|
||||
if (resultDesc)
|
||||
@ -1716,7 +1716,7 @@ restart:
|
||||
if (fcache->func.fn_retset || hasSetArg)
|
||||
{
|
||||
/*
|
||||
* We need to return a set result. Complain if caller not ready to
|
||||
* We need to return a set result. Complain if caller not ready to
|
||||
* accept one.
|
||||
*/
|
||||
if (isDone == NULL)
|
||||
@ -2035,7 +2035,7 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
|
||||
/*
|
||||
* Normally the passed expression tree will be a FuncExprState, since the
|
||||
* grammar only allows a function call at the top level of a table
|
||||
* function reference. However, if the function doesn't return set then
|
||||
* function reference. However, if the function doesn't return set then
|
||||
* the planner might have replaced the function call via constant-folding
|
||||
* or inlining. So if we see any other kind of expression node, execute
|
||||
* it via the general ExecEvalExpr() code; the only difference is that we
|
||||
@ -2074,7 +2074,7 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
|
||||
*
|
||||
* Note: ideally, we'd do this in the per-tuple context, but then the
|
||||
* argument values would disappear when we reset the context in the
|
||||
* inner loop. So do it in caller context. Perhaps we should make a
|
||||
* inner loop. So do it in caller context. Perhaps we should make a
|
||||
* separate context just to hold the evaluated arguments?
|
||||
*/
|
||||
argDone = ExecEvalFuncArgs(&fcinfo, fcache->args, econtext);
|
||||
@ -2160,7 +2160,7 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
|
||||
* Can't do anything very useful with NULL rowtype values. For a
|
||||
* function returning set, we consider this a protocol violation
|
||||
* (but another alternative would be to just ignore the result and
|
||||
* "continue" to get another row). For a function not returning
|
||||
* "continue" to get another row). For a function not returning
|
||||
* set, we fall out of the loop; we'll cons up an all-nulls result
|
||||
* row below.
|
||||
*/
|
||||
@ -2294,7 +2294,7 @@ no_function_result:
|
||||
}
|
||||
|
||||
/*
|
||||
* If function provided a tupdesc, cross-check it. We only really need to
|
||||
* If function provided a tupdesc, cross-check it. We only really need to
|
||||
* do this for functions returning RECORD, but might as well do it always.
|
||||
*/
|
||||
if (rsinfo.setDesc)
|
||||
@ -2472,7 +2472,7 @@ ExecEvalDistinct(FuncExprState *fcache,
|
||||
*
|
||||
* Evaluate "scalar op ANY/ALL (array)". The operator always yields boolean,
|
||||
* and we combine the results across all array elements using OR and AND
|
||||
* (for ANY and ALL respectively). Of course we short-circuit as soon as
|
||||
* (for ANY and ALL respectively). Of course we short-circuit as soon as
|
||||
* the result is known.
|
||||
*/
|
||||
static Datum
|
||||
@ -2659,7 +2659,7 @@ ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
|
||||
* qualification to conjunctive normal form. If we ever get
|
||||
* an AND to evaluate, we can be sure that it's not a top-level
|
||||
* clause in the qualification, but appears lower (as a function
|
||||
* argument, for example), or in the target list. Not that you
|
||||
* argument, for example), or in the target list. Not that you
|
||||
* need to know this, mind you...
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
@ -2790,7 +2790,7 @@ ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
|
||||
/* ----------------------------------------------------------------
|
||||
* ExecEvalConvertRowtype
|
||||
*
|
||||
* Evaluate a rowtype coercion operation. This may require
|
||||
* Evaluate a rowtype coercion operation. This may require
|
||||
* rearranging field positions.
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
@ -2919,7 +2919,7 @@ ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
|
||||
|
||||
/*
|
||||
* if we have a true test, then we return the result, since the case
|
||||
* statement is satisfied. A NULL result from the test is not
|
||||
* statement is satisfied. A NULL result from the test is not
|
||||
* considered true.
|
||||
*/
|
||||
if (DatumGetBool(clause_value) && !*isNull)
|
||||
@ -3133,7 +3133,7 @@ ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
|
||||
* If all items were null or empty arrays, return an empty array;
|
||||
* otherwise, if some were and some weren't, raise error. (Note: we
|
||||
* must special-case this somehow to avoid trying to generate a 1-D
|
||||
* array formed from empty arrays. It's not ideal...)
|
||||
* array formed from empty arrays. It's not ideal...)
|
||||
*/
|
||||
if (haveempty)
|
||||
{
|
||||
@ -4296,7 +4296,7 @@ ExecEvalExprSwitchContext(ExprState *expression,
|
||||
* ExecInitExpr: prepare an expression tree for execution
|
||||
*
|
||||
* This function builds and returns an ExprState tree paralleling the given
|
||||
* Expr node tree. The ExprState tree can then be handed to ExecEvalExpr
|
||||
* Expr node tree. The ExprState tree can then be handed to ExecEvalExpr
|
||||
* for execution. Because the Expr tree itself is read-only as far as
|
||||
* ExecInitExpr and ExecEvalExpr are concerned, several different executions
|
||||
* of the same plan tree can occur concurrently.
|
||||
@ -4307,9 +4307,9 @@ ExecEvalExprSwitchContext(ExprState *expression,
|
||||
*
|
||||
* Any Aggref, WindowFunc, or SubPlan nodes found in the tree are added to the
|
||||
* lists of such nodes held by the parent PlanState. Otherwise, we do very
|
||||
* little initialization here other than building the state-node tree. Any
|
||||
* little initialization here other than building the state-node tree. Any
|
||||
* nontrivial work associated with initializing runtime info for a node should
|
||||
* happen during the first actual evaluation of that node. (This policy lets
|
||||
* happen during the first actual evaluation of that node. (This policy lets
|
||||
* us avoid work if the node is never actually evaluated.)
|
||||
*
|
||||
* Note: there is no ExecEndExpr function; we assume that any resource
|
||||
@ -5108,7 +5108,7 @@ ExecQual(List *qual, ExprContext *econtext, bool resultForNull)
|
||||
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
|
||||
|
||||
/*
|
||||
* Evaluate the qual conditions one at a time. If we find a FALSE result,
|
||||
* Evaluate the qual conditions one at a time. If we find a FALSE result,
|
||||
* we can stop evaluating and return FALSE --- the AND result must be
|
||||
* FALSE. Also, if we find a NULL result when resultForNull is FALSE, we
|
||||
* can stop and return FALSE --- the AND result must be FALSE or NULL in
|
||||
@ -5267,7 +5267,7 @@ ExecTargetList(List *targetlist,
|
||||
else
|
||||
{
|
||||
/*
|
||||
* We have some done and some undone sets. Restart the done ones
|
||||
* We have some done and some undone sets. Restart the done ones
|
||||
* so that we can deliver a tuple (if possible).
|
||||
*/
|
||||
foreach(tl, targetlist)
|
||||
|
||||
Reference in New Issue
Block a user