database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-18 17:42:25 +03:00
Code Activity

pgindent run for 9.0

Browse Source
This commit is contained in:
Bruce Momjian
2010-02-26 02:01:40 +00:00
parent 16040575a0
commit 65e806cba1
403 changed files with 6786 additions and 6530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/backend/parser/analyze.c
View File

@ -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);