*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.241 2003/03/23 05:14:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.242 2003/04/29 22:13:08 tgl Exp $
*
*
* INTERFACE ROUTINES
/*
* Make sure it yields a boolean result.
*/
- expr = coerce_to_boolean(expr, "CHECK");
+ expr = coerce_to_boolean(pstate, expr, "CHECK");
/*
* Make sure no outside relations are referred to.
{
Oid type_id = exprType(expr);
- if (coerce_to_target_type(expr, type_id,
+ if (coerce_to_target_type(pstate, expr, type_id,
atttypid, atttypmod,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST) == NULL)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/schemacmds.c,v 1.7 2002/12/05 04:04:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/schemacmds.c,v 1.8 2003/04/29 22:13:08 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *querytree_list,
*querytree_item;
- querytree_list = parse_analyze(parsetree, NULL);
+ querytree_list = parse_analyze(parsetree, NULL, 0);
foreach(querytree_item, querytree_list)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.71 2003/04/21 15:19:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.72 2003/04/29 22:13:08 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Make sure it yields a boolean result.
*/
- expr = coerce_to_boolean(expr, "CHECK");
+ expr = coerce_to_boolean(pstate, expr, "CHECK");
/*
* Make sure no outside relations are referred to.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.33 2003/04/08 16:57:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.34 2003/04/29 22:13:08 tgl Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
/*
* Make sure it yields a boolean result.
*/
- expr = coerce_to_boolean(expr, "CHECK");
+ expr = coerce_to_boolean(pstate, expr, "CHECK");
/*
* Make sure no outside relations are
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.92 2003/04/29 03:21:29 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.93 2003/04/29 22:13:09 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Parse the request string into a list of raw parse trees.
*/
- raw_parsetree_list = pg_parse_query(src, argtypes, nargs);
+ raw_parsetree_list = pg_parse_query(src);
/*
* Do parse analysis and rule rewrite for each raw parsetree.
if (plan)
plan->origCmdType = origCmdType;
- query_list = pg_analyze_and_rewrite(parsetree);
+ query_list = pg_analyze_and_rewrite(parsetree, argtypes, nargs);
query_list_list = lappend(query_list_list, query_list);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.74 2003/04/08 23:20:01 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.75 2003/04/29 22:13:09 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Make the expression node.
*
* Note: we use make_op_expr in case runtime type conversion
- * function calls must be inserted for this operator!
+ * function calls must be inserted for this operator! (But we
+ * are not expecting to have to resolve unknown Params, so
+ * it's okay to pass a null pstate.)
*/
result = lappend(result,
- make_op_expr(tup,
+ make_op_expr(NULL,
+ tup,
leftop,
rightop,
exprType(leftop),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.93 2003/04/24 23:43:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.94 2003/04/29 22:13:09 tgl Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- expr = coerce_to_common_type(expr,
+ expr = coerce_to_common_type(NULL, /* no UNKNOWNs here */
+ expr,
colType,
"UNION/INTERSECT/EXCEPT");
colTypmod = -1;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.135 2003/04/27 20:09:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.136 2003/04/29 22:13:09 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
/*
* We just do parsing and parse analysis, not rewriting, because
- * rewriting will not affect SELECT-only queries, which is all that
- * we care about. Also, we can punt as soon as we detect more than
+ * rewriting will not affect table-free-SELECT-only queries, which is all
+ * that we care about. Also, we can punt as soon as we detect more than
* one command in the function body.
*/
- raw_parsetree_list = pg_parse_query(src,
- funcform->proargtypes,
- funcform->pronargs);
+ raw_parsetree_list = pg_parse_query(src);
if (length(raw_parsetree_list) != 1)
goto fail;
- querytree_list = parse_analyze(lfirst(raw_parsetree_list), NULL);
+ querytree_list = parse_analyze(lfirst(raw_parsetree_list),
+ funcform->proargtypes,
+ funcform->pronargs);
if (length(querytree_list) != 1)
goto fail;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.267 2003/04/29 03:21:29 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.268 2003/04/29 22:13:09 tgl Exp $
*
*-------------------------------------------------------------------------
*/
} CreateStmtContext;
+static List *do_parse_analyze(Node *parseTree, ParseState *pstate);
static Query *transformStmt(ParseState *pstate, Node *stmt,
List **extras_before, List **extras_after);
static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
static FromExpr *makeFromExpr(List *fromlist, Node *quals);
-
/*
- * parse_analyze -
- * analyze a raw parse tree and transform it to Query form.
+ * parse_analyze
+ * Analyze a raw parse tree and transform it to Query form.
+ *
+ * Optionally, information about $n parameter types can be supplied.
+ * References to $n indexes not defined by paramTypes[] are disallowed.
*
* The result is a List of Query nodes (we need a list since some commands
* produce multiple Queries). Optimizable statements require considerable
* a dummy CMD_UTILITY Query node.
*/
List *
-parse_analyze(Node *parseTree, ParseState *parentParseState)
+parse_analyze(Node *parseTree, Oid *paramTypes, int numParams)
+{
+ ParseState *pstate = make_parsestate(NULL);
+ List *result;
+
+ pstate->p_paramtypes = paramTypes;
+ pstate->p_numparams = numParams;
+ pstate->p_variableparams = false;
+
+ result = do_parse_analyze(parseTree, pstate);
+
+ pfree(pstate);
+
+ return result;
+}
+
+/*
+ * parse_analyze_varparams
+ *
+ * This variant is used when it's okay to deduce information about $n
+ * symbol datatypes from context. The passed-in paramTypes[] array can
+ * be modified or enlarged (via repalloc).
+ */
+List *
+parse_analyze_varparams(Node *parseTree, Oid **paramTypes, int *numParams)
+{
+ ParseState *pstate = make_parsestate(NULL);
+ List *result;
+
+ pstate->p_paramtypes = *paramTypes;
+ pstate->p_numparams = *numParams;
+ pstate->p_variableparams = true;
+
+ result = do_parse_analyze(parseTree, pstate);
+
+ *paramTypes = pstate->p_paramtypes;
+ *numParams = pstate->p_numparams;
+
+ pfree(pstate);
+
+ return result;
+}
+
+/*
+ * parse_sub_analyze
+ * Entry point for recursively analyzing a sub-statement.
+ */
+List *
+parse_sub_analyze(Node *parseTree, ParseState *parentParseState)
{
- List *result = NIL;
ParseState *pstate = make_parsestate(parentParseState);
+ List *result;
+
+ result = do_parse_analyze(parseTree, pstate);
+
+ pfree(pstate);
+ return result;
+}
+
+/*
+ * do_parse_analyze
+ * Workhorse code shared by the above variants of parse_analyze.
+ */
+static List *
+do_parse_analyze(Node *parseTree, ParseState *pstate)
+{
+ List *result = NIL;
/* Lists to return extra commands from transformation */
List *extras_before = NIL;
List *extras_after = NIL;
List *listscan;
query = transformStmt(pstate, parseTree, &extras_before, &extras_after);
+
+ /* don't need to access result relation any more */
release_pstate_resources(pstate);
while (extras_before != NIL)
{
- result = nconc(result, parse_analyze(lfirst(extras_before), pstate));
+ result = nconc(result,
+ parse_sub_analyze(lfirst(extras_before), pstate));
extras_before = lnext(extras_before);
}
while (extras_after != NIL)
{
- result = nconc(result, parse_analyze(lfirst(extras_after), pstate));
+ result = nconc(result,
+ parse_sub_analyze(lfirst(extras_after), pstate));
extras_after = lnext(extras_after);
}
/*
* Make sure that only the original query is marked original. We have
- * to do this explicitly since recursive calls of parse_analyze will
+ * to do this explicitly since recursive calls of do_parse_analyze will
* have marked some of the added-on queries as "original".
*/
foreach(listscan, result)
q->querySource = (q == query ? QSRC_ORIGINAL : QSRC_PARSER);
}
- pfree(pstate);
-
return result;
}
*/
if (stmt->selectStmt)
{
- ParseState *sub_pstate = make_parsestate(pstate->parentParseState);
+ /*
+ * We make the sub-pstate a child of the outer pstate so that it
+ * can see any Param definitions supplied from above. Since the
+ * outer pstate's rtable and namespace are presently empty, there
+ * are no side-effects of exposing names the sub-SELECT shouldn't
+ * be able to see.
+ */
+ ParseState *sub_pstate = make_parsestate(pstate);
Query *selectQuery;
RangeTblEntry *rte;
RangeTblRef *rtr;
* separate from the subquery's tlist because we may add columns,
* insert datatype coercions, etc.)
*
- * HACK: constants in the INSERT's targetlist are copied up as-is
- * rather than being referenced as subquery outputs. This is
- * mainly to ensure that when we try to coerce them to the target
- * column's datatype, the right things happen for UNKNOWN
- * constants. Otherwise this fails: INSERT INTO foo SELECT 'bar',
- * ... FROM baz
+ * HACK: unknown-type constants and params in the INSERT's targetlist
+ * are copied up as-is rather than being referenced as subquery
+ * outputs. This is to ensure that when we try to coerce them
+ * to the target column's datatype, the right things happen (see
+ * special cases in coerce_type). Otherwise, this fails:
+ * INSERT INTO foo SELECT 'bar', ... FROM baz
*/
qry->targetList = NIL;
foreach(tl, selectQuery->targetList)
if (resnode->resjunk)
continue;
- if (tle->expr && IsA(tle->expr, Const))
+ if (tle->expr &&
+ (IsA(tle->expr, Const) || IsA(tle->expr, Param)) &&
+ exprType((Node *) tle->expr) == UNKNOWNOID)
expr = tle->expr;
else
expr = (Expr *) makeVar(rtr->rtindex,
resnode->restypmod,
0);
resnode = copyObject(resnode);
- resnode->resno = (AttrNumber) pstate->p_last_resno++;
+ resnode->resno = (AttrNumber) pstate->p_next_resno++;
qry->targetList = lappend(qry->targetList,
makeTargetEntry(resnode, expr));
}
*/
/* Prepare to assign non-conflicting resnos to resjunk attributes */
- if (pstate->p_last_resno <= pstate->p_target_relation->rd_rel->relnatts)
- pstate->p_last_resno = pstate->p_target_relation->rd_rel->relnatts + 1;
+ if (pstate->p_next_resno <= pstate->p_target_relation->rd_rel->relnatts)
+ pstate->p_next_resno = pstate->p_target_relation->rd_rel->relnatts + 1;
/* Validate stmt->cols list, or build default list if no list given */
icolumns = checkInsertTargets(pstate, stmt->cols, &attrnos);
List *newactions = NIL;
/*
- * transform each statement, like parse_analyze()
+ * transform each statement, like parse_sub_analyze()
*/
foreach(oldactions, stmt->actions)
{
Resdom *resdom;
Expr *expr;
- resdom = makeResdom((AttrNumber) pstate->p_last_resno++,
+ resdom = makeResdom((AttrNumber) pstate->p_next_resno++,
colType,
-1,
colName,
* of this sub-query, because they are not in the toplevel
* pstate's namespace list.
*/
- selectList = parse_analyze((Node *) stmt, pstate);
+ selectList = parse_sub_analyze((Node *) stmt, pstate);
Assert(length(selectList) == 1);
selectQuery = (Query *) lfirst(selectList);
*/
/* Prepare to assign non-conflicting resnos to resjunk attributes */
- if (pstate->p_last_resno <= pstate->p_target_relation->rd_rel->relnatts)
- pstate->p_last_resno = pstate->p_target_relation->rd_rel->relnatts + 1;
+ if (pstate->p_next_resno <= pstate->p_target_relation->rd_rel->relnatts)
+ pstate->p_next_resno = pstate->p_target_relation->rd_rel->relnatts + 1;
/* Prepare non-junk columns for assignment to target table */
origTargetList = stmt->targetList;
* columns; else rewriter or planner might get confused.
*/
resnode->resname = "?resjunk?";
- resnode->resno = (AttrNumber) pstate->p_last_resno++;
+ resnode->resno = (AttrNumber) pstate->p_next_resno++;
continue;
}
if (origTargetList == NIL)
transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt)
{
Query *result = makeNode(Query);
- List *extras_before = NIL,
- *extras_after = NIL;
List *argtype_oids = NIL; /* argtype OIDs in a list */
- Oid *argtoids = NULL; /* as an array for parser_param_set */
+ Oid *argtoids = NULL; /* and as an array */
int nargs;
+ List *queries;
result->commandType = CMD_UTILITY;
result->utilityStmt = (Node *) stmt;
stmt->argtype_oids = argtype_oids;
/*
- * We need to adjust the parameters expected by the rest of the
- * system, so that $1, ... $n are parsed properly.
- *
- * This is somewhat of a hack; however, the main parser interface only
- * allows parameters to be specified when working with a raw query
- * string, which is not helpful here.
+ * Analyze the statement using these parameter types (any parameters
+ * passed in from above us will not be visible to it).
*/
- parser_param_set(argtoids, nargs);
-
- stmt->query = transformStmt(pstate, (Node *) stmt->query,
- &extras_before, &extras_after);
+ queries = parse_analyze((Node *) stmt->query, argtoids, nargs);
- /* Shouldn't get any extras, since grammar only allows OptimizableStmt */
- if (extras_before || extras_after)
+ /*
+ * Shouldn't get any extra statements, since grammar only allows
+ * OptimizableStmt
+ */
+ if (length(queries) != 1)
elog(ERROR, "transformPrepareStmt: internal error");
- /* Remove links to our local parameters */
- parser_param_set(NULL, 0);
+ stmt->query = lfirst(queries);
return result;
}
given_type_id = exprType(expr);
expected_type_id = lfirsto(paramtypes);
- expr = coerce_to_target_type(expr, given_type_id,
+ expr = coerce_to_target_type(pstate, expr, given_type_id,
expected_type_id, -1,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.112 2003/03/22 01:49:38 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.113 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RangeFunction *r);
static Node *transformFromClauseItem(ParseState *pstate, Node *n,
List **containedRels);
-static Node *buildMergedJoinVar(JoinType jointype,
+static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
Var *l_colvar, Var *r_colvar);
static TargetEntry *findTargetlistEntry(ParseState *pstate, Node *node,
List *tlist, int clause);
*/
result = transformExpr(pstate, result);
- result = coerce_to_boolean(result, "JOIN/USING");
+ result = coerce_to_boolean(pstate, result, "JOIN/USING");
return result;
} /* transformJoinUsingClause() */
/* This part is just like transformWhereClause() */
result = transformExpr(pstate, j->quals);
- result = coerce_to_boolean(result, "JOIN/ON");
+ result = coerce_to_boolean(pstate, result, "JOIN/ON");
pstate->p_namespace = save_namespace;
/*
* Analyze and transform the subquery.
*/
- parsetrees = parse_analyze(r->subquery, pstate);
+ parsetrees = parse_sub_analyze(r->subquery, pstate);
/*
* Check that we got something reasonable. Some of these conditions
res_colnames = lappend(res_colnames, lfirst(ucol));
res_colvars = lappend(res_colvars,
- buildMergedJoinVar(j->jointype,
+ buildMergedJoinVar(pstate,
+ j->jointype,
l_colvar,
r_colvar));
}
* generate a suitable replacement expression for a merged join column
*/
static Node *
-buildMergedJoinVar(JoinType jointype, Var *l_colvar, Var *r_colvar)
+buildMergedJoinVar(ParseState *pstate, JoinType jointype,
+ Var *l_colvar, Var *r_colvar)
{
Oid outcoltype;
int32 outcoltypmod;
* typmod is not same as input.
*/
if (l_colvar->vartype != outcoltype)
- l_node = coerce_type((Node *) l_colvar, l_colvar->vartype,
+ l_node = coerce_type(pstate, (Node *) l_colvar, l_colvar->vartype,
outcoltype,
COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
else if (l_colvar->vartypmod != outcoltypmod)
l_node = (Node *) l_colvar;
if (r_colvar->vartype != outcoltype)
- r_node = coerce_type((Node *) r_colvar, r_colvar->vartype,
+ r_node = coerce_type(pstate, (Node *) r_colvar, r_colvar->vartype,
outcoltype,
COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
else if (r_colvar->vartypmod != outcoltypmod)
qual = transformExpr(pstate, clause);
- qual = coerce_to_boolean(qual, "WHERE");
+ qual = coerce_to_boolean(pstate, qual, "WHERE");
return qual;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.95 2003/04/10 02:47:46 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.96 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_cast.h"
#include "catalog/pg_proc.h"
#include "nodes/makefuncs.h"
+#include "nodes/params.h"
#include "optimizer/clauses.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
* conversion is not possible. (We do this, rather than elog'ing directly,
* so that callers can generate custom error messages indicating context.)
*
+ * pstate - parse state (can be NULL, see coerce_type)
* expr - input expression tree (already transformed by transformExpr)
* exprtype - result type of expr
* targettype - desired result type
* ccontext, cformat - context indicators to control coercions
*/
Node *
-coerce_to_target_type(Node *expr, Oid exprtype,
+coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype,
Oid targettype, int32 targettypmod,
CoercionContext ccontext,
CoercionForm cformat)
{
if (can_coerce_type(1, &exprtype, &targettype, ccontext))
- expr = coerce_type(expr, exprtype, targettype,
+ expr = coerce_type(pstate, expr, exprtype, targettype,
ccontext, cformat);
/*
* String hacks to get transparent conversions for char and varchar:
if (can_coerce_type(1, &exprtype, &text_id, ccontext))
{
- expr = coerce_type(expr, exprtype, text_id,
+ expr = coerce_type(pstate, expr, exprtype, text_id,
ccontext, cformat);
/* Need a RelabelType if no typmod coercion is performed */
if (targettypmod < 0)
* call coerce_type_typmod as well, if a typmod constraint is wanted.
* (But if the target type is a domain, it may internally contain a
* typmod constraint, which will be applied inside coerce_to_domain.)
+ *
+ * pstate is only used in the case that we are able to resolve the type of
+ * a previously UNKNOWN Param. It is okay to pass pstate = NULL if the
+ * caller does not want type information updated for Params.
*/
Node *
-coerce_type(Node *node, Oid inputTypeId, Oid targetTypeId,
+coerce_type(ParseState *pstate, Node *node,
+ Oid inputTypeId, Oid targetTypeId,
CoercionContext ccontext, CoercionForm cformat)
{
Node *result;
node == NULL)
{
/* no conversion needed */
- result = node;
+ return node;
}
- else if (inputTypeId == UNKNOWNOID && IsA(node, Const))
+ if (inputTypeId == UNKNOWNOID && IsA(node, Const))
{
/*
* Input is a string constant with previously undetermined type.
cformat);
ReleaseSysCache(targetType);
+
+ return result;
}
- else if (targetTypeId == ANYOID ||
- targetTypeId == ANYARRAYOID ||
- targetTypeId == ANYELEMENTOID)
+ if (inputTypeId == UNKNOWNOID && IsA(node, Param) &&
+ ((Param *) node)->paramkind == PARAM_NUM &&
+ pstate != NULL && pstate->p_variableparams)
+ {
+ /*
+ * Input is a Param of previously undetermined type, and we want
+ * to update our knowledge of the Param's type. Find the topmost
+ * ParseState and update the state.
+ */
+ Param *param = (Param *) node;
+ int paramno = param->paramid;
+ ParseState *toppstate;
+
+ toppstate = pstate;
+ while (toppstate->parentParseState != NULL)
+ toppstate = toppstate->parentParseState;
+
+ if (paramno <= 0 || /* shouldn't happen, but... */
+ paramno > toppstate->p_numparams)
+ elog(ERROR, "Parameter '$%d' is out of range", paramno);
+
+ if (toppstate->p_paramtypes[paramno-1] == UNKNOWNOID)
+ {
+ /* We've successfully resolved the type */
+ toppstate->p_paramtypes[paramno-1] = targetTypeId;
+ }
+ else if (toppstate->p_paramtypes[paramno-1] == targetTypeId)
+ {
+ /* We previously resolved the type, and it matches */
+ }
+ else
+ {
+ /* Ooops */
+ elog(ERROR, "Inconsistent types deduced for parameter '$%d'"
+ "\n\tCould be either %s or %s",
+ paramno,
+ format_type_be(toppstate->p_paramtypes[paramno-1]),
+ format_type_be(targetTypeId));
+ }
+
+ param->paramtype = targetTypeId;
+ return (Node *) param;
+ }
+ if (targetTypeId == ANYOID ||
+ targetTypeId == ANYARRAYOID ||
+ targetTypeId == ANYELEMENTOID)
{
/* assume can_coerce_type verified that implicit coercion is okay */
/* NB: we do NOT want a RelabelType here */
- result = node;
+ return node;
}
- else if (find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
- &funcId))
+ if (find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
+ &funcId))
{
if (OidIsValid(funcId))
{
cformat);
}
}
+ return result;
}
- else if (typeInheritsFrom(inputTypeId, targetTypeId))
+ if (typeInheritsFrom(inputTypeId, targetTypeId))
{
/*
* Input class type is a subclass of target, so nothing to do ---
* except relabel the type. This is binary compatibility for
* complex types.
*/
- result = (Node *) makeRelabelType((Expr *) node,
- targetTypeId, -1,
- cformat);
+ return (Node *) makeRelabelType((Expr *) node,
+ targetTypeId, -1,
+ cformat);
}
- else
- {
- /* If we get here, caller blew it */
- elog(ERROR, "coerce_type: no conversion function from %s to %s",
- format_type_be(inputTypeId), format_type_be(targetTypeId));
- result = NULL; /* keep compiler quiet */
- }
-
- return result;
+ /* If we get here, caller blew it */
+ elog(ERROR, "coerce_type: no conversion function from %s to %s",
+ format_type_be(inputTypeId), format_type_be(targetTypeId));
+ return NULL; /* keep compiler quiet */
}
* (AND, OR, NOT, etc). Also check that input is not a set.
*
* Returns the possibly-transformed node tree.
+ *
+ * As with coerce_type, pstate may be NULL if no special unknown-Param
+ * processing is wanted.
*/
Node *
-coerce_to_boolean(Node *node, const char *constructName)
+coerce_to_boolean(ParseState *pstate, Node *node,
+ const char *constructName)
{
Oid inputTypeId = exprType(node);
if (inputTypeId != BOOLOID)
{
- node = coerce_to_target_type(node, inputTypeId,
+ node = coerce_to_target_type(pstate, node, inputTypeId,
BOOLOID, -1,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
* This is used following select_common_type() to coerce the individual
* expressions to the desired type. 'context' is a phrase to use in the
* error message if we fail to coerce.
+ *
+ * As with coerce_type, pstate may be NULL if no special unknown-Param
+ * processing is wanted.
*/
Node *
-coerce_to_common_type(Node *node, Oid targetTypeId, const char *context)
+coerce_to_common_type(ParseState *pstate, Node *node,
+ Oid targetTypeId, const char *context)
{
Oid inputTypeId = exprType(node);
if (inputTypeId == targetTypeId)
return node; /* no work */
if (can_coerce_type(1, &inputTypeId, &targetTypeId, COERCION_IMPLICIT))
- node = coerce_type(node, inputTypeId, targetTypeId,
+ node = coerce_type(pstate, node, inputTypeId, targetTypeId,
COERCION_IMPLICIT, COERCE_IMPLICIT_CAST);
else
elog(ERROR, "%s unable to convert to type %s",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.147 2003/04/08 23:20:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.148 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool Transform_null_equals = false;
-static Node *typecast_expression(Node *expr, TypeName *typename);
+static Node *typecast_expression(ParseState *pstate, Node *expr,
+ TypeName *typename);
static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
static Node *transformIndirection(ParseState *pstate, Node *basenode,
List *indirection);
{
ParamRef *pref = (ParamRef *) expr;
int paramno = pref->number;
- Oid paramtyp = param_type(paramno);
+ ParseState *toppstate;
Param *param;
List *fields;
- if (!OidIsValid(paramtyp))
- elog(ERROR, "Parameter '$%d' is out of range", paramno);
+ /*
+ * Find topmost ParseState, which is where paramtype info
+ * lives.
+ */
+ toppstate = pstate;
+ while (toppstate->parentParseState != NULL)
+ toppstate = toppstate->parentParseState;
+
+ /* Check parameter number is in range */
+ if (paramno <= 0) /* probably can't happen? */
+ elog(ERROR, "Parameter '$%d' is out of range",
+ paramno);
+ if (paramno > toppstate->p_numparams)
+ {
+ if (!toppstate->p_variableparams)
+ elog(ERROR, "Parameter '$%d' is out of range",
+ paramno);
+ /* Okay to enlarge param array */
+ if (toppstate->p_paramtypes)
+ toppstate->p_paramtypes =
+ (Oid *) repalloc(toppstate->p_paramtypes,
+ paramno * sizeof(Oid));
+ else
+ toppstate->p_paramtypes =
+ (Oid *) palloc(paramno * sizeof(Oid));
+ /* Zero out the previously-unreferenced slots */
+ MemSet(toppstate->p_paramtypes + toppstate->p_numparams,
+ 0,
+ (paramno - toppstate->p_numparams) * sizeof(Oid));
+ toppstate->p_numparams = paramno;
+ }
+ if (toppstate->p_variableparams)
+ {
+ /* If not seen before, initialize to UNKNOWN type */
+ if (toppstate->p_paramtypes[paramno-1] == InvalidOid)
+ toppstate->p_paramtypes[paramno-1] = UNKNOWNOID;
+ }
+
param = makeNode(Param);
param->paramkind = PARAM_NUM;
param->paramid = (AttrNumber) paramno;
- param->paramtype = paramtyp;
+ param->paramtype = toppstate->p_paramtypes[paramno-1];
result = (Node *) param;
+
/* handle qualification, if any */
foreach(fields, pref->fields)
{
result = (Node *) make_const(val);
if (con->typename != NULL)
- result = typecast_expression(result, con->typename);
+ result = typecast_expression(pstate, result,
+ con->typename);
break;
}
case T_ExprFieldSelect:
TypeCast *tc = (TypeCast *) expr;
Node *arg = transformExpr(pstate, tc->arg);
- result = typecast_expression(arg, tc->typename);
+ result = typecast_expression(pstate, arg, tc->typename);
break;
}
case T_A_Expr:
Node *rexpr = transformExpr(pstate,
a->rexpr);
- result = (Node *) make_op(a->name,
+ result = (Node *) make_op(pstate,
+ a->name,
lexpr,
rexpr);
}
Node *rexpr = transformExpr(pstate,
a->rexpr);
- lexpr = coerce_to_boolean(lexpr, "AND");
- rexpr = coerce_to_boolean(rexpr, "AND");
+ lexpr = coerce_to_boolean(pstate, lexpr, "AND");
+ rexpr = coerce_to_boolean(pstate, rexpr, "AND");
result = (Node *) makeBoolExpr(AND_EXPR,
makeList2(lexpr,
Node *rexpr = transformExpr(pstate,
a->rexpr);
- lexpr = coerce_to_boolean(lexpr, "OR");
- rexpr = coerce_to_boolean(rexpr, "OR");
+ lexpr = coerce_to_boolean(pstate, lexpr, "OR");
+ rexpr = coerce_to_boolean(pstate, rexpr, "OR");
result = (Node *) makeBoolExpr(OR_EXPR,
makeList2(lexpr,
Node *rexpr = transformExpr(pstate,
a->rexpr);
- rexpr = coerce_to_boolean(rexpr, "NOT");
+ rexpr = coerce_to_boolean(pstate, rexpr, "NOT");
result = (Node *) makeBoolExpr(NOT_EXPR,
makeList1(rexpr));
Node *rexpr = transformExpr(pstate,
a->rexpr);
- result = (Node *) make_op(a->name,
+ result = (Node *) make_op(pstate,
+ a->name,
lexpr,
rexpr);
if (((OpExpr *) result)->opresulttype != BOOLOID)
Node *rexpr = transformExpr(pstate,
a->rexpr);
- result = (Node *) make_op(a->name,
+ result = (Node *) make_op(pstate,
+ a->name,
lexpr,
rexpr);
if (((OpExpr *) result)->opresulttype != BOOLOID)
break;
}
pstate->p_hasSubLinks = true;
- qtrees = parse_analyze(sublink->subselect, pstate);
+ qtrees = parse_sub_analyze(sublink->subselect, pstate);
if (length(qtrees) != 1)
elog(ERROR, "Bad query in subselect");
qtree = (Query *) lfirst(qtrees);
if (needNot)
{
- expr = coerce_to_boolean(expr, "NOT");
+ expr = coerce_to_boolean(pstate, expr, "NOT");
expr = (Node *) makeBoolExpr(NOT_EXPR,
makeList1(expr));
}
}
neww->expr = (Expr *) transformExpr(pstate, warg);
- neww->expr = (Expr *) coerce_to_boolean((Node *) neww->expr,
+ neww->expr = (Expr *) coerce_to_boolean(pstate,
+ (Node *) neww->expr,
"CASE/WHEN");
/*
/* Convert default result clause, if necessary */
newc->defresult = (Expr *)
- coerce_to_common_type((Node *) newc->defresult,
+ coerce_to_common_type(pstate,
+ (Node *) newc->defresult,
ptype,
"CASE/ELSE");
CaseWhen *w = (CaseWhen *) lfirst(args);
w->result = (Expr *)
- coerce_to_common_type((Node *) w->result,
+ coerce_to_common_type(pstate,
+ (Node *) w->result,
ptype,
"CASE/WHEN");
}
Node *e = (Node *) lfirst(element);
Node *newe;
- newe = coerce_to_common_type(e, element_type, "ARRAY");
+ newe = coerce_to_common_type(pstate, e,
+ element_type,
+ "ARRAY");
newcoercedelems = lappend(newcoercedelems, newe);
}
Node *e = (Node *) lfirst(args);
Node *newe;
- newe = coerce_to_common_type(e, newc->coalescetype,
+ newe = coerce_to_common_type(pstate, e,
+ newc->coalescetype,
"COALESCE");
newcoercedargs = lappend(newcoercedargs, newe);
}
b->arg = (Expr *) transformExpr(pstate, (Node *) b->arg);
- b->arg = (Expr *) coerce_to_boolean((Node *) b->arg, clausename);
+ b->arg = (Expr *) coerce_to_boolean(pstate,
+ (Node *) b->arg,
+ clausename);
result = expr;
break;
* the type name and then apply any necessary coercion function(s).
*/
static Node *
-typecast_expression(Node *expr, TypeName *typename)
+typecast_expression(ParseState *pstate, Node *expr, TypeName *typename)
{
Oid inputType = exprType(expr);
Oid targetType;
if (inputType == InvalidOid)
return expr; /* do nothing if NULL input */
- expr = coerce_to_target_type(expr, inputType,
+ expr = coerce_to_target_type(pstate, expr, inputType,
targetType, typename->typmod,
COERCION_EXPLICIT,
COERCE_EXPLICIT_CAST);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.146 2003/04/24 21:16:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.147 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* We can do it as a trivial coercion. coerce_type can handle
* these cases, so why duplicate code...
*/
- return coerce_type(lfirst(fargs), actual_arg_types[0], rettype,
+ return coerce_type(pstate, lfirst(fargs), actual_arg_types[0],
+ rettype,
COERCION_EXPLICIT, COERCE_EXPLICIT_CALL);
}
else if (fdresult == FUNCDETAIL_NORMAL)
rettype);
/* perform the necessary typecasting of arguments */
- make_fn_arguments(fargs, actual_arg_types, declared_arg_types);
+ make_fn_arguments(pstate, fargs, actual_arg_types, declared_arg_types);
/* build the appropriate output structure */
if (fdresult == FUNCDETAIL_NORMAL)
* allowed.
*
* Caution: given argument list is modified in-place.
+ *
+ * As with coerce_type, pstate may be NULL if no special unknown-Param
+ * processing is wanted.
*/
void
-make_fn_arguments(List *fargs,
+make_fn_arguments(ParseState *pstate,
+ List *fargs,
Oid *actual_arg_types,
Oid *declared_arg_types)
{
/* types don't match? then force coercion using a function call... */
if (actual_arg_types[i] != declared_arg_types[i])
{
- lfirst(current_fargs) = coerce_type(lfirst(current_fargs),
+ lfirst(current_fargs) = coerce_type(pstate,
+ lfirst(current_fargs),
actual_arg_types[i],
declared_arg_types[i],
COERCION_IMPLICIT,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.77 2003/04/08 23:20:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.78 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
pstate = palloc0(sizeof(ParseState));
pstate->parentParseState = parentParseState;
- pstate->p_last_resno = 1;
+
+ /* Fill in fields that don't start at null/false/zero */
+ pstate->p_next_resno = 1;
+
+ if (parentParseState)
+ pstate->p_variableparams = parentParseState->p_variableparams;
return pstate;
}
{
subexpr = transformExpr(pstate, ai->lidx);
/* If it's not int4 already, try to coerce */
- subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
+ subexpr = coerce_to_target_type(pstate,
+ subexpr, exprType(subexpr),
INT4OID, -1,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
}
subexpr = transformExpr(pstate, ai->uidx);
/* If it's not int4 already, try to coerce */
- subexpr = coerce_to_target_type(subexpr, exprType(subexpr),
+ subexpr = coerce_to_target_type(pstate,
+ subexpr, exprType(subexpr),
INT4OID, -1,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
if (typesource != InvalidOid)
{
- assignFrom = coerce_to_target_type(assignFrom, typesource,
+ assignFrom = coerce_to_target_type(pstate,
+ assignFrom, typesource,
typeneeded, arrayTypMod,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.62 2003/04/08 23:20:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.63 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*
* Transform operator expression ensuring type compatibility.
* This is where some type conversion happens.
+ *
+ * As with coerce_type, pstate may be NULL if no special unknown-Param
+ * processing is wanted.
*/
Expr *
-make_op(List *opname, Node *ltree, Node *rtree)
+make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree)
{
Oid ltypeId,
rtypeId;
}
/* Do typecasting and build the expression tree */
- result = make_op_expr(tup, ltree, rtree, ltypeId, rtypeId);
+ result = make_op_expr(pstate, tup, ltree, rtree, ltypeId, rtypeId);
ReleaseSysCache(tup);
/*
* make_op_expr()
* Build operator expression using an already-looked-up operator.
+ *
+ * As with coerce_type, pstate may be NULL if no special unknown-Param
+ * processing is wanted.
*/
Expr *
-make_op_expr(Operator op, Node *ltree, Node *rtree,
+make_op_expr(ParseState *pstate, Operator op,
+ Node *ltree, Node *rtree,
Oid ltypeId, Oid rtypeId)
{
Form_pg_operator opform = (Form_pg_operator) GETSTRUCT(op);
opform->oprresult);
/* perform the necessary typecasting of arguments */
- make_fn_arguments(args, actual_arg_types, declared_arg_types);
+ make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
/* and build the expression node */
result = makeNode(OpExpr);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.80 2002/12/12 15:49:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.81 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Node *varnode = (Node *) lfirst(vars);
TargetEntry *te = makeNode(TargetEntry);
- te->resdom = makeResdom((AttrNumber) (pstate->p_last_resno)++,
+ te->resdom = makeResdom((AttrNumber) pstate->p_next_resno++,
exprType(varnode),
exprTypmod(varnode),
label,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.99 2003/04/08 23:20:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.100 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
colname = FigureColname(node);
}
- resnode = makeResdom((AttrNumber) pstate->p_last_resno++,
+ resnode = makeResdom((AttrNumber) pstate->p_next_resno++,
type_id,
type_mod,
colname,
if (type_id != InvalidOid)
{
tle->expr = (Expr *)
- coerce_to_target_type((Node *) tle->expr, type_id,
+ coerce_to_target_type(pstate,
+ (Node *) tle->expr, type_id,
attrtype, attrtypmod,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.56 2003/04/27 20:09:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.57 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
initStringInfo(&buf);
appendStringInfo(&buf, "SELECT (NULL::%s)", str);
- raw_parsetree_list = parser(buf.data, NULL, 0);
+ raw_parsetree_list = raw_parser(buf.data);
/*
* Make sure we got back exactly what we expected and no more;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.56 2003/04/27 20:09:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.57 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *parsetree; /* result of parsing is left here */
-static Oid *param_type_info; /* state for param_type() */
-static int param_count;
-
static int lookahead_token; /* one-token lookahead */
static bool have_lookahead; /* lookahead_token set? */
/*
- * parser
- * Given a query in string form, and optionally info about
- * parameter types, do lexical and syntactic analysis.
+ * raw_parser
+ * Given a query in string form, do lexical and grammatical analysis.
*
* Returns a list of raw (un-analyzed) parse trees.
*/
List *
-parser(const char *str, Oid *typev, int nargs)
+raw_parser(const char *str)
{
int yyresult;
- parsetree = NIL; /* in case parser forgets to set it */
+ parsetree = NIL; /* in case grammar forgets to set it */
have_lookahead = false;
scanner_init(str);
parser_init();
parse_expr_init();
- parser_param_set(typev, nargs);
yyresult = yyparse();
}
-/*
- * Save information needed to fill out the type of Param references ($n)
- *
- * This is used for SQL functions, PREPARE statements, etc. It's split
- * out from parser() setup because PREPARE needs to change the info after
- * the grammar runs and before parse analysis is done on the preparable
- * query.
- */
-void
-parser_param_set(Oid *typev, int nargs)
-{
- param_type_info = typev;
- param_count = nargs;
-}
-
-/*
- * param_type()
- *
- * Fetch a parameter type previously passed to parser_param_set
- */
-Oid
-param_type(int t)
-{
- if (t > param_count || t <= 0)
- return InvalidOid;
- return param_type_info[t - 1];
-}
-
-
/*
* Intermediate filter between parser and base lexer (base_yylex in scan.l).
*
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.118 2003/02/25 23:47:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.119 2003/04/29 22:13:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
exprtype = exprType(expr);
- expr = coerce_to_target_type(expr, exprtype,
+ expr = coerce_to_target_type(NULL, /* no UNKNOWN params here */
+ expr, exprtype,
atttype, atttypmod,
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.325 2003/04/27 20:09:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.326 2003/04/29 22:13:11 tgl Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
*/
List *
pg_parse_and_rewrite(const char *query_string, /* string to execute */
- Oid *typev, /* parameter types */
- int nargs) /* number of parameters */
+ Oid *paramTypes, /* parameter types */
+ int numParams) /* number of parameters */
{
List *raw_parsetree_list;
List *querytree_list;
/*
* (1) parse the request string into a list of raw parse trees.
*/
- raw_parsetree_list = pg_parse_query(query_string, typev, nargs);
+ raw_parsetree_list = pg_parse_query(query_string);
/*
* (2) Do parse analysis and rule rewrite.
Node *parsetree = (Node *) lfirst(list_item);
querytree_list = nconc(querytree_list,
- pg_analyze_and_rewrite(parsetree));
+ pg_analyze_and_rewrite(parsetree,
+ paramTypes,
+ numParams));
}
return querytree_list;
* commands are not processed any further than the raw parse stage.
*/
List *
-pg_parse_query(const char *query_string, Oid *typev, int nargs)
+pg_parse_query(const char *query_string)
{
List *raw_parsetree_list;
if (log_parser_stats)
ResetUsage();
- raw_parsetree_list = parser(query_string, typev, nargs);
+ raw_parsetree_list = raw_parser(query_string);
if (log_parser_stats)
ShowUsage("PARSER STATISTICS");
}
/*
- * Given a raw parsetree (gram.y output), perform parse analysis and
- * rule rewriting.
+ * Given a raw parsetree (gram.y output), and optionally information about
+ * types of parameter symbols ($n), perform parse analysis and rule rewriting.
*
* A list of Query nodes is returned, since either the analyzer or the
* rewriter might expand one query to several.
* NOTE: for reasons mentioned above, this must be separate from raw parsing.
*/
List *
-pg_analyze_and_rewrite(Node *parsetree)
+pg_analyze_and_rewrite(Node *parsetree, Oid *paramTypes, int numParams)
{
List *querytree_list;
List *list_item;
if (log_parser_stats)
ResetUsage();
- querytree_list = parse_analyze(parsetree, NULL);
+ querytree_list = parse_analyze(parsetree, paramTypes, numParams);
if (log_parser_stats)
{
*
* ----------------------------------------------------------------
*/
-
-void
+static void
pg_exec_query_string(const char *query_string, /* string to execute */
CommandDest dest, /* where results should go */
MemoryContext parse_context) /* context for
* Do basic parsing of the query or queries (this should be safe even
* if we are in aborted transaction state!)
*/
- parsetree_list = pg_parse_query(query_string, NULL, 0);
+ parsetree_list = pg_parse_query(query_string);
/*
* Switch back to execution context to enter the loop.
*/
oldcontext = MemoryContextSwitchTo(parse_context);
- querytree_list = pg_analyze_and_rewrite(parsetree);
+ querytree_list = pg_analyze_and_rewrite(parsetree, NULL, 0);
/*
* Switch back to execution context for planning and execution.
if (!IsUnderPostmaster)
{
puts("\nPOSTGRES backend interactive interface ");
- puts("$Revision: 1.325 $ $Date: 2003/04/27 20:09:44 $\n");
+ puts("$Revision: 1.326 $ $Date: 2003/04/29 22:13:11 $\n");
}
/*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: analyze.h,v 1.20 2002/06/20 20:29:51 momjian Exp $
+ * $Id: analyze.h,v 1.21 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_node.h"
-extern List *parse_analyze(Node *parseTree, ParseState *parentParseState);
+
+extern List *parse_analyze(Node *parseTree, Oid *paramTypes, int numParams);
+extern List *parse_analyze_varparams(Node *parseTree, Oid **paramTypes,
+ int *numParams);
+extern List *parse_sub_analyze(Node *parseTree, ParseState *parentParseState);
extern List *analyzeCreateSchemaStmt(CreateSchemaStmt *stmt);
extern void CheckSelectForUpdate(Query *qry);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: gramparse.h,v 1.26 2003/04/27 20:09:44 tgl Exp $
+ * $Id: gramparse.h,v 1.27 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/parsenodes.h"
+
/* from parser.c */
-extern void parser_param_set(Oid *typev, int nargs);
-extern Oid param_type(int t);
extern int yylex(void);
/* from scan.l */
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_coerce.h,v 1.50 2003/04/08 23:20:04 tgl Exp $
+ * $Id: parse_coerce.h,v 1.51 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_type.h"
#include "parser/parse_node.h"
+
typedef enum CATEGORY
{
INVALID_TYPE,
extern bool IsPreferredType(CATEGORY category, Oid type);
extern CATEGORY TypeCategory(Oid type);
-extern Node *coerce_to_target_type(Node *expr, Oid exprtype,
+extern Node *coerce_to_target_type(ParseState *pstate,
+ Node *expr, Oid exprtype,
Oid targettype, int32 targettypmod,
CoercionContext ccontext,
CoercionForm cformat);
extern bool can_coerce_type(int nargs, Oid *input_typeids, Oid *target_typeids,
CoercionContext ccontext);
-extern Node *coerce_type(Node *node, Oid inputTypeId, Oid targetTypeId,
+extern Node *coerce_type(ParseState *pstate, Node *node,
+ Oid inputTypeId, Oid targetTypeId,
CoercionContext ccontext, CoercionForm cformat);
extern Node *coerce_to_domain(Node *arg, Oid baseTypeId, Oid typeId,
CoercionForm cformat);
-extern Node *coerce_to_boolean(Node *node, const char *constructName);
+extern Node *coerce_to_boolean(ParseState *pstate, Node *node,
+ const char *constructName);
extern Oid select_common_type(List *typeids, const char *context);
-extern Node *coerce_to_common_type(Node *node, Oid targetTypeId,
- const char *context);
+extern Node *coerce_to_common_type(ParseState *pstate, Node *node,
+ Oid targetTypeId,
+ const char *context);
extern bool check_generic_type_consistency(Oid *actual_arg_types,
Oid *declared_arg_types,
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_func.h,v 1.44 2003/04/08 23:20:04 tgl Exp $
+ * $Id: parse_func.h,v 1.45 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_node.h"
+
/*
* This structure is used to explore the inheritance hierarchy above
* nodes in the type tree in order to disambiguate among polymorphic
extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
-extern void make_fn_arguments(List *fargs,
+extern void make_fn_arguments(ParseState *pstate,
+ List *fargs,
Oid *actual_arg_types,
Oid *declared_arg_types);
/*-------------------------------------------------------------------------
*
* parse_node.h
+ * Internal definitions for parser
*
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_node.h,v 1.34 2003/04/08 23:20:04 tgl Exp $
+ * $Id: parse_node.h,v 1.35 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* joinlist. Note that an RTE that is present in p_namespace, but does not
* have its inFromCl flag set, is accessible only with an explicit qualifier;
* lookups of unqualified column names should ignore it.
+ *
+ * p_paramtypes: an array of p_numparams type OIDs for $n parameter symbols
+ * (zeroth entry in array corresponds to $1). If p_variableparams is true, the
+ * set of param types is not predetermined; in that case, a zero array entry
+ * means that parameter number hasn't been seen, and UNKNOWNOID means the
+ * parameter has been used but its type is not yet known. NOTE: in a stack
+ * of ParseStates, only the topmost ParseState contains paramtype info; but
+ * we copy the p_variableparams flag down to the child nodes for speed in
+ * coerce_type.
*/
typedef struct ParseState
{
List *p_joinlist; /* join items so far (will become FromExpr
* node's fromlist) */
List *p_namespace; /* current lookup namespace (join items) */
- int p_last_resno; /* last targetlist resno assigned */
+ Oid *p_paramtypes; /* OIDs of types for $n parameter symbols */
+ int p_numparams; /* allocated size of p_paramtypes[] */
+ int p_next_resno; /* next targetlist resno to assign */
List *p_forUpdate; /* FOR UPDATE clause, if any (see gram.y) */
Node *p_value_substitute; /* what to replace VALUE with, if any */
+ bool p_variableparams;
bool p_hasAggs;
bool p_hasSubLinks;
bool p_is_insert;
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_oper.h,v 1.24 2003/04/08 23:20:04 tgl Exp $
+ * $Id: parse_oper.h,v 1.25 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define PARSE_OPER_H
#include "access/htup.h"
-#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
+
typedef HeapTuple Operator;
extern Oid oprfuncid(Operator op);
/* Build expression tree for an operator invocation */
-extern Expr *make_op(List *opname, Node *ltree, Node *rtree);
-extern Expr *make_op_expr(Operator op, Node *ltree, Node *rtree,
+extern Expr *make_op(ParseState *pstate, List *opname,
+ Node *ltree, Node *rtree);
+extern Expr *make_op_expr(ParseState *pstate, Operator op,
+ Node *ltree, Node *rtree,
Oid ltypeId, Oid rtypeId);
#endif /* PARSE_OPER_H */
/*-------------------------------------------------------------------------
*
* parser.h
- *
+ * Definitions for the "raw" parser (lex and yacc phases only)
*
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parser.h,v 1.14 2003/04/27 20:09:44 tgl Exp $
+ * $Id: parser.h,v 1.15 2003/04/29 22:13:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef PARSER_H
#define PARSER_H
-#include "parser/parse_node.h"
-
-extern List *parser(const char *str, Oid *typev, int nargs);
+extern List *raw_parser(const char *str);
#endif /* PARSER_H */
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: tcopprot.h,v 1.54 2003/04/27 20:09:44 tgl Exp $
+ * $Id: tcopprot.h,v 1.55 2003/04/29 22:13:11 tgl Exp $
*
* OLD COMMENTS
* This file was created so that other c files could get the two
#ifndef BOOTSTRAP_INCLUDE
-extern List *pg_parse_query(const char *query_string, Oid *typev, int nargs);
-extern List *pg_analyze_and_rewrite(Node *parsetree);
+extern List *pg_parse_query(const char *query_string);
+extern List *pg_analyze_and_rewrite(Node *parsetree,
+ Oid *paramTypes, int numParams);
extern List *pg_parse_and_rewrite(const char *query_string,
- Oid *typev, int nargs);
+ Oid *paramTypes, int numParams);
extern Plan *pg_plan_query(Query *querytree);
-extern void pg_exec_query_string(const char *query_string,
- CommandDest dest,
- MemoryContext parse_context);
#endif /* BOOTSTRAP_INCLUDE */
projects / postgresql.git / commitdiff