mirror of
https://github.com/postgres/postgres.git
synced 2025-04-20 00:42:27 +03:00
255f66efa9
code was already okay with this, but the hack that obtained the output column types of a recursive union in advance of doing real parse analysis of the recursive union forgot to handle the case where there was an inner WITH clause available to the non-recursive term. Best fix seems to be to refactor so that we don't need the "throwaway" parse analysis step at all. Instead, teach the transformSetOperationStmt code to set up the CTE's output column information after it's processed the non-recursive term normally. Per report from David Fetter.
2314 lines
61 KiB
C
2314 lines
61 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* parse_expr.c
|
|
* handle expressions in parser
|
|
*
|
|
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.243 2009/09/09 03:32:52 tgl Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "catalog/pg_type.h"
|
|
#include "commands/dbcommands.h"
|
|
#include "miscadmin.h"
|
|
#include "nodes/makefuncs.h"
|
|
#include "nodes/nodeFuncs.h"
|
|
#include "optimizer/var.h"
|
|
#include "parser/analyze.h"
|
|
#include "parser/parse_coerce.h"
|
|
#include "parser/parse_expr.h"
|
|
#include "parser/parse_func.h"
|
|
#include "parser/parse_oper.h"
|
|
#include "parser/parse_relation.h"
|
|
#include "parser/parse_target.h"
|
|
#include "parser/parse_type.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/lsyscache.h"
|
|
#include "utils/xml.h"
|
|
|
|
|
|
bool Transform_null_equals = false;
|
|
|
|
static Node *transformParamRef(ParseState *pstate, ParamRef *pref);
|
|
static Node *transformAExprOp(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprAnd(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprOr(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprNot(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprOpAny(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprOpAll(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprDistinct(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprNullIf(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprOf(ParseState *pstate, A_Expr *a);
|
|
static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
|
|
static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
|
|
static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
|
|
static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
|
|
static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
|
|
Oid array_type, Oid element_type, int32 typmod);
|
|
static Node *transformRowExpr(ParseState *pstate, RowExpr *r);
|
|
static Node *transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c);
|
|
static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m);
|
|
static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
|
|
static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
|
|
static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
|
|
static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
|
|
static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
|
|
static Node *transformWholeRowRef(ParseState *pstate, char *schemaname,
|
|
char *relname, int location);
|
|
static Node *transformIndirection(ParseState *pstate, Node *basenode,
|
|
List *indirection);
|
|
static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
|
|
static Node *make_row_comparison_op(ParseState *pstate, List *opname,
|
|
List *largs, List *rargs, int location);
|
|
static Node *make_row_distinct_op(ParseState *pstate, List *opname,
|
|
RowExpr *lrow, RowExpr *rrow, int location);
|
|
static Expr *make_distinct_op(ParseState *pstate, List *opname,
|
|
Node *ltree, Node *rtree, int location);
|
|
|
|
|
|
/*
|
|
* transformExpr -
|
|
* Analyze and transform expressions. Type checking and type casting is
|
|
* done here. The optimizer and the executor cannot handle the original
|
|
* (raw) expressions collected by the parse tree. Hence the transformation
|
|
* here.
|
|
*
|
|
* NOTE: there are various cases in which this routine will get applied to
|
|
* an already-transformed expression. Some examples:
|
|
* 1. At least one construct (BETWEEN/AND) puts the same nodes
|
|
* into two branches of the parse tree; hence, some nodes
|
|
* are transformed twice.
|
|
* 2. Another way it can happen is that coercion of an operator or
|
|
* function argument to the required type (via coerce_type())
|
|
* can apply transformExpr to an already-transformed subexpression.
|
|
* An example here is "SELECT count(*) + 1.0 FROM table".
|
|
* While it might be possible to eliminate these cases, the path of
|
|
* least resistance so far has been to ensure that transformExpr() does
|
|
* no damage if applied to an already-transformed tree. This is pretty
|
|
* easy for cases where the transformation replaces one node type with
|
|
* another, such as A_Const => Const; we just do nothing when handed
|
|
* a Const. More care is needed for node types that are used as both
|
|
* input and output of transformExpr; see SubLink for example.
|
|
*/
|
|
Node *
|
|
transformExpr(ParseState *pstate, Node *expr)
|
|
{
|
|
Node *result = NULL;
|
|
|
|
if (expr == NULL)
|
|
return NULL;
|
|
|
|
/* Guard against stack overflow due to overly complex expressions */
|
|
check_stack_depth();
|
|
|
|
switch (nodeTag(expr))
|
|
{
|
|
case T_ColumnRef:
|
|
result = transformColumnRef(pstate, (ColumnRef *) expr);
|
|
break;
|
|
|
|
case T_ParamRef:
|
|
result = transformParamRef(pstate, (ParamRef *) expr);
|
|
break;
|
|
|
|
case T_A_Const:
|
|
{
|
|
A_Const *con = (A_Const *) expr;
|
|
Value *val = &con->val;
|
|
|
|
result = (Node *) make_const(pstate, val, con->location);
|
|
break;
|
|
}
|
|
|
|
case T_A_Indirection:
|
|
{
|
|
A_Indirection *ind = (A_Indirection *) expr;
|
|
|
|
result = transformExpr(pstate, ind->arg);
|
|
result = transformIndirection(pstate, result,
|
|
ind->indirection);
|
|
break;
|
|
}
|
|
|
|
case T_A_ArrayExpr:
|
|
result = transformArrayExpr(pstate, (A_ArrayExpr *) expr,
|
|
InvalidOid, InvalidOid, -1);
|
|
break;
|
|
|
|
case T_TypeCast:
|
|
{
|
|
TypeCast *tc = (TypeCast *) expr;
|
|
|
|
/*
|
|
* If the subject of the typecast is an ARRAY[] construct and
|
|
* the target type is an array type, we invoke
|
|
* transformArrayExpr() directly so that we can pass down the
|
|
* type information. This avoids some cases where
|
|
* transformArrayExpr() might not infer the correct type.
|
|
*/
|
|
if (IsA(tc->arg, A_ArrayExpr))
|
|
{
|
|
Oid targetType;
|
|
Oid elementType;
|
|
int32 targetTypmod;
|
|
|
|
targetType = typenameTypeId(pstate, tc->typeName,
|
|
&targetTypmod);
|
|
elementType = get_element_type(targetType);
|
|
if (OidIsValid(elementType))
|
|
{
|
|
result = transformArrayExpr(pstate,
|
|
(A_ArrayExpr *) tc->arg,
|
|
targetType,
|
|
elementType,
|
|
targetTypmod);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Corner case: ARRAY[] cast to a non-array type. Fall
|
|
* through to do it the standard way.
|
|
*/
|
|
}
|
|
|
|
result = transformTypeCast(pstate, tc);
|
|
break;
|
|
}
|
|
|
|
case T_A_Expr:
|
|
{
|
|
A_Expr *a = (A_Expr *) expr;
|
|
|
|
switch (a->kind)
|
|
{
|
|
case AEXPR_OP:
|
|
result = transformAExprOp(pstate, a);
|
|
break;
|
|
case AEXPR_AND:
|
|
result = transformAExprAnd(pstate, a);
|
|
break;
|
|
case AEXPR_OR:
|
|
result = transformAExprOr(pstate, a);
|
|
break;
|
|
case AEXPR_NOT:
|
|
result = transformAExprNot(pstate, a);
|
|
break;
|
|
case AEXPR_OP_ANY:
|
|
result = transformAExprOpAny(pstate, a);
|
|
break;
|
|
case AEXPR_OP_ALL:
|
|
result = transformAExprOpAll(pstate, a);
|
|
break;
|
|
case AEXPR_DISTINCT:
|
|
result = transformAExprDistinct(pstate, a);
|
|
break;
|
|
case AEXPR_NULLIF:
|
|
result = transformAExprNullIf(pstate, a);
|
|
break;
|
|
case AEXPR_OF:
|
|
result = transformAExprOf(pstate, a);
|
|
break;
|
|
case AEXPR_IN:
|
|
result = transformAExprIn(pstate, a);
|
|
break;
|
|
default:
|
|
elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case T_FuncCall:
|
|
result = transformFuncCall(pstate, (FuncCall *) expr);
|
|
break;
|
|
|
|
case T_SubLink:
|
|
result = transformSubLink(pstate, (SubLink *) expr);
|
|
break;
|
|
|
|
case T_CaseExpr:
|
|
result = transformCaseExpr(pstate, (CaseExpr *) expr);
|
|
break;
|
|
|
|
case T_RowExpr:
|
|
result = transformRowExpr(pstate, (RowExpr *) expr);
|
|
break;
|
|
|
|
case T_CoalesceExpr:
|
|
result = transformCoalesceExpr(pstate, (CoalesceExpr *) expr);
|
|
break;
|
|
|
|
case T_MinMaxExpr:
|
|
result = transformMinMaxExpr(pstate, (MinMaxExpr *) expr);
|
|
break;
|
|
|
|
case T_XmlExpr:
|
|
result = transformXmlExpr(pstate, (XmlExpr *) expr);
|
|
break;
|
|
|
|
case T_XmlSerialize:
|
|
result = transformXmlSerialize(pstate, (XmlSerialize *) expr);
|
|
break;
|
|
|
|
case T_NullTest:
|
|
{
|
|
NullTest *n = (NullTest *) expr;
|
|
|
|
n->arg = (Expr *) transformExpr(pstate, (Node *) n->arg);
|
|
/* the argument can be any type, so don't coerce it */
|
|
result = expr;
|
|
break;
|
|
}
|
|
|
|
case T_BooleanTest:
|
|
result = transformBooleanTest(pstate, (BooleanTest *) expr);
|
|
break;
|
|
|
|
case T_CurrentOfExpr:
|
|
result = transformCurrentOfExpr(pstate, (CurrentOfExpr *) expr);
|
|
break;
|
|
|
|
/*********************************************
|
|
* Quietly accept node types that may be presented when we are
|
|
* called on an already-transformed tree.
|
|
*
|
|
* Do any other node types need to be accepted? For now we are
|
|
* taking a conservative approach, and only accepting node
|
|
* types that are demonstrably necessary to accept.
|
|
*********************************************/
|
|
case T_Var:
|
|
case T_Const:
|
|
case T_Param:
|
|
case T_Aggref:
|
|
case T_WindowFunc:
|
|
case T_ArrayRef:
|
|
case T_FuncExpr:
|
|
case T_OpExpr:
|
|
case T_DistinctExpr:
|
|
case T_ScalarArrayOpExpr:
|
|
case T_NullIfExpr:
|
|
case T_BoolExpr:
|
|
case T_FieldSelect:
|
|
case T_FieldStore:
|
|
case T_RelabelType:
|
|
case T_CoerceViaIO:
|
|
case T_ArrayCoerceExpr:
|
|
case T_ConvertRowtypeExpr:
|
|
case T_CaseTestExpr:
|
|
case T_CoerceToDomain:
|
|
case T_CoerceToDomainValue:
|
|
case T_SetToDefault:
|
|
{
|
|
result = (Node *) expr;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
/* should not reach here */
|
|
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformIndirection(ParseState *pstate, Node *basenode, List *indirection)
|
|
{
|
|
Node *result = basenode;
|
|
List *subscripts = NIL;
|
|
ListCell *i;
|
|
|
|
/*
|
|
* We have to split any field-selection operations apart from
|
|
* subscripting. Adjacent A_Indices nodes have to be treated as a single
|
|
* multidimensional subscript operation.
|
|
*/
|
|
foreach(i, indirection)
|
|
{
|
|
Node *n = lfirst(i);
|
|
|
|
if (IsA(n, A_Indices))
|
|
subscripts = lappend(subscripts, n);
|
|
else if (IsA(n, A_Star))
|
|
{
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("row expansion via \"*\" is not supported here"),
|
|
parser_errposition(pstate, exprLocation(basenode))));
|
|
}
|
|
else
|
|
{
|
|
Assert(IsA(n, String));
|
|
|
|
/* process subscripts before this field selection */
|
|
if (subscripts)
|
|
result = (Node *) transformArraySubscripts(pstate,
|
|
result,
|
|
exprType(result),
|
|
InvalidOid,
|
|
exprTypmod(result),
|
|
subscripts,
|
|
NULL);
|
|
subscripts = NIL;
|
|
|
|
result = ParseFuncOrColumn(pstate,
|
|
list_make1(n),
|
|
list_make1(result),
|
|
false, false, false,
|
|
NULL, true, -1);
|
|
}
|
|
}
|
|
/* process trailing subscripts, if any */
|
|
if (subscripts)
|
|
result = (Node *) transformArraySubscripts(pstate,
|
|
result,
|
|
exprType(result),
|
|
InvalidOid,
|
|
exprTypmod(result),
|
|
subscripts,
|
|
NULL);
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformColumnRef(ParseState *pstate, ColumnRef *cref)
|
|
{
|
|
int numnames = list_length(cref->fields);
|
|
Node *node;
|
|
int levels_up;
|
|
|
|
/*----------
|
|
* The allowed syntaxes are:
|
|
*
|
|
* A First try to resolve as unqualified column name;
|
|
* if no luck, try to resolve as unqualified table name (A.*).
|
|
* A.B A is an unqualified table name; B is either a
|
|
* column or function name (trying column name first).
|
|
* A.B.C schema A, table B, col or func name C.
|
|
* A.B.C.D catalog A, schema B, table C, col or func D.
|
|
* A.* A is an unqualified table name; means whole-row value.
|
|
* A.B.* whole-row value of table B in schema A.
|
|
* A.B.C.* whole-row value of table C in schema B in catalog A.
|
|
*
|
|
* We do not need to cope with bare "*"; that will only be accepted by
|
|
* the grammar at the top level of a SELECT list, and transformTargetList
|
|
* will take care of it before it ever gets here. Also, "A.*" etc will
|
|
* be expanded by transformTargetList if they appear at SELECT top level,
|
|
* so here we are only going to see them as function or operator inputs.
|
|
*
|
|
* Currently, if a catalog name is given then it must equal the current
|
|
* database name; we check it here and then discard it.
|
|
*----------
|
|
*/
|
|
switch (numnames)
|
|
{
|
|
case 1:
|
|
{
|
|
Node *field1 = (Node *) linitial(cref->fields);
|
|
char *name1;
|
|
|
|
Assert(IsA(field1, String));
|
|
name1 = strVal(field1);
|
|
|
|
/* Try to identify as an unqualified column */
|
|
node = colNameToVar(pstate, name1, false, cref->location);
|
|
|
|
if (node == NULL)
|
|
{
|
|
/*
|
|
* Not known as a column of any range-table entry.
|
|
*
|
|
* Consider the possibility that it's VALUE in a domain
|
|
* check expression. (We handle VALUE as a name, not a
|
|
* keyword, to avoid breaking a lot of applications that
|
|
* have used VALUE as a column name in the past.)
|
|
*/
|
|
if (pstate->p_value_substitute != NULL &&
|
|
strcmp(name1, "value") == 0)
|
|
{
|
|
node = (Node *) copyObject(pstate->p_value_substitute);
|
|
|
|
/*
|
|
* Try to propagate location knowledge. This should
|
|
* be extended if p_value_substitute can ever take on
|
|
* other node types.
|
|
*/
|
|
if (IsA(node, CoerceToDomainValue))
|
|
((CoerceToDomainValue *) node)->location = cref->location;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Try to find the name as a relation. Note that only
|
|
* relations already entered into the rangetable will be
|
|
* recognized.
|
|
*
|
|
* This is a hack for backwards compatibility with
|
|
* PostQUEL-inspired syntax. The preferred form now is
|
|
* "rel.*".
|
|
*/
|
|
if (refnameRangeTblEntry(pstate, NULL, name1,
|
|
cref->location,
|
|
&levels_up) != NULL)
|
|
node = transformWholeRowRef(pstate, NULL, name1,
|
|
cref->location);
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_COLUMN),
|
|
errmsg("column \"%s\" does not exist",
|
|
name1),
|
|
parser_errposition(pstate, cref->location)));
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
Node *field1 = (Node *) linitial(cref->fields);
|
|
Node *field2 = (Node *) lsecond(cref->fields);
|
|
char *name1;
|
|
char *name2;
|
|
|
|
Assert(IsA(field1, String));
|
|
name1 = strVal(field1);
|
|
|
|
/* Whole-row reference? */
|
|
if (IsA(field2, A_Star))
|
|
{
|
|
node = transformWholeRowRef(pstate, NULL, name1,
|
|
cref->location);
|
|
break;
|
|
}
|
|
|
|
Assert(IsA(field2, String));
|
|
name2 = strVal(field2);
|
|
|
|
/* Try to identify as a once-qualified column */
|
|
node = qualifiedNameToVar(pstate, NULL, name1, name2, true,
|
|
cref->location);
|
|
if (node == NULL)
|
|
{
|
|
/*
|
|
* Not known as a column of any range-table entry, so try
|
|
* it as a function call. Here, we will create an
|
|
* implicit RTE for tables not already entered.
|
|
*/
|
|
node = transformWholeRowRef(pstate, NULL, name1,
|
|
cref->location);
|
|
node = ParseFuncOrColumn(pstate,
|
|
list_make1(makeString(name2)),
|
|
list_make1(node),
|
|
false, false, false,
|
|
NULL, true, cref->location);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
Node *field1 = (Node *) linitial(cref->fields);
|
|
Node *field2 = (Node *) lsecond(cref->fields);
|
|
Node *field3 = (Node *) lthird(cref->fields);
|
|
char *name1;
|
|
char *name2;
|
|
char *name3;
|
|
|
|
Assert(IsA(field1, String));
|
|
name1 = strVal(field1);
|
|
Assert(IsA(field2, String));
|
|
name2 = strVal(field2);
|
|
|
|
/* Whole-row reference? */
|
|
if (IsA(field3, A_Star))
|
|
{
|
|
node = transformWholeRowRef(pstate, name1, name2,
|
|
cref->location);
|
|
break;
|
|
}
|
|
|
|
Assert(IsA(field3, String));
|
|
name3 = strVal(field3);
|
|
|
|
/* Try to identify as a twice-qualified column */
|
|
node = qualifiedNameToVar(pstate, name1, name2, name3, true,
|
|
cref->location);
|
|
if (node == NULL)
|
|
{
|
|
/* Try it as a function call */
|
|
node = transformWholeRowRef(pstate, name1, name2,
|
|
cref->location);
|
|
node = ParseFuncOrColumn(pstate,
|
|
list_make1(makeString(name3)),
|
|
list_make1(node),
|
|
false, false, false,
|
|
NULL, true, cref->location);
|
|
}
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
Node *field1 = (Node *) linitial(cref->fields);
|
|
Node *field2 = (Node *) lsecond(cref->fields);
|
|
Node *field3 = (Node *) lthird(cref->fields);
|
|
Node *field4 = (Node *) lfourth(cref->fields);
|
|
char *name1;
|
|
char *name2;
|
|
char *name3;
|
|
char *name4;
|
|
|
|
Assert(IsA(field1, String));
|
|
name1 = strVal(field1);
|
|
Assert(IsA(field2, String));
|
|
name2 = strVal(field2);
|
|
Assert(IsA(field3, String));
|
|
name3 = strVal(field3);
|
|
|
|
/*
|
|
* We check the catalog name and then ignore it.
|
|
*/
|
|
if (strcmp(name1, get_database_name(MyDatabaseId)) != 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("cross-database references are not implemented: %s",
|
|
NameListToString(cref->fields)),
|
|
parser_errposition(pstate, cref->location)));
|
|
|
|
/* Whole-row reference? */
|
|
if (IsA(field4, A_Star))
|
|
{
|
|
node = transformWholeRowRef(pstate, name2, name3,
|
|
cref->location);
|
|
break;
|
|
}
|
|
|
|
Assert(IsA(field4, String));
|
|
name4 = strVal(field4);
|
|
|
|
/* Try to identify as a twice-qualified column */
|
|
node = qualifiedNameToVar(pstate, name2, name3, name4, true,
|
|
cref->location);
|
|
if (node == NULL)
|
|
{
|
|
/* Try it as a function call */
|
|
node = transformWholeRowRef(pstate, name2, name3,
|
|
cref->location);
|
|
node = ParseFuncOrColumn(pstate,
|
|
list_make1(makeString(name4)),
|
|
list_make1(node),
|
|
false, false, false,
|
|
NULL, true, cref->location);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("improper qualified name (too many dotted names): %s",
|
|
NameListToString(cref->fields)),
|
|
parser_errposition(pstate, cref->location)));
|
|
node = NULL; /* keep compiler quiet */
|
|
break;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
/*
|
|
* Locate the parameter type info for the given parameter number, and
|
|
* return a pointer to it.
|
|
*/
|
|
static Oid *
|
|
find_param_type(ParseState *pstate, int paramno, int location)
|
|
{
|
|
Oid *result;
|
|
|
|
/*
|
|
* Find topmost ParseState, which is where paramtype info lives.
|
|
*/
|
|
while (pstate->parentParseState != NULL)
|
|
pstate = pstate->parentParseState;
|
|
|
|
/* Check parameter number is in range */
|
|
if (paramno <= 0) /* probably can't happen? */
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_PARAMETER),
|
|
errmsg("there is no parameter $%d", paramno),
|
|
parser_errposition(pstate, location)));
|
|
if (paramno > pstate->p_numparams)
|
|
{
|
|
if (!pstate->p_variableparams)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_PARAMETER),
|
|
errmsg("there is no parameter $%d", paramno),
|
|
parser_errposition(pstate, location)));
|
|
/* Okay to enlarge param array */
|
|
if (pstate->p_paramtypes)
|
|
pstate->p_paramtypes = (Oid *) repalloc(pstate->p_paramtypes,
|
|
paramno * sizeof(Oid));
|
|
else
|
|
pstate->p_paramtypes = (Oid *) palloc(paramno * sizeof(Oid));
|
|
/* Zero out the previously-unreferenced slots */
|
|
MemSet(pstate->p_paramtypes + pstate->p_numparams,
|
|
0,
|
|
(paramno - pstate->p_numparams) * sizeof(Oid));
|
|
pstate->p_numparams = paramno;
|
|
}
|
|
|
|
result = &pstate->p_paramtypes[paramno - 1];
|
|
|
|
if (pstate->p_variableparams)
|
|
{
|
|
/* If not seen before, initialize to UNKNOWN type */
|
|
if (*result == InvalidOid)
|
|
*result = UNKNOWNOID;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformParamRef(ParseState *pstate, ParamRef *pref)
|
|
{
|
|
int paramno = pref->number;
|
|
Oid *pptype = find_param_type(pstate, paramno, pref->location);
|
|
Param *param;
|
|
|
|
param = makeNode(Param);
|
|
param->paramkind = PARAM_EXTERN;
|
|
param->paramid = paramno;
|
|
param->paramtype = *pptype;
|
|
param->paramtypmod = -1;
|
|
param->location = pref->location;
|
|
|
|
return (Node *) param;
|
|
}
|
|
|
|
/* Test whether an a_expr is a plain NULL constant or not */
|
|
static bool
|
|
exprIsNullConstant(Node *arg)
|
|
{
|
|
if (arg && IsA(arg, A_Const))
|
|
{
|
|
A_Const *con = (A_Const *) arg;
|
|
|
|
if (con->val.type == T_Null)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static Node *
|
|
transformAExprOp(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = a->lexpr;
|
|
Node *rexpr = a->rexpr;
|
|
Node *result;
|
|
|
|
/*
|
|
* Special-case "foo = NULL" and "NULL = foo" for compatibility with
|
|
* standards-broken products (like Microsoft's). Turn these into IS NULL
|
|
* exprs.
|
|
*/
|
|
if (Transform_null_equals &&
|
|
list_length(a->name) == 1 &&
|
|
strcmp(strVal(linitial(a->name)), "=") == 0 &&
|
|
(exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)))
|
|
{
|
|
NullTest *n = makeNode(NullTest);
|
|
|
|
n->nulltesttype = IS_NULL;
|
|
|
|
if (exprIsNullConstant(lexpr))
|
|
n->arg = (Expr *) rexpr;
|
|
else
|
|
n->arg = (Expr *) lexpr;
|
|
|
|
result = transformExpr(pstate, (Node *) n);
|
|
}
|
|
else if (lexpr && IsA(lexpr, RowExpr) &&
|
|
rexpr && IsA(rexpr, SubLink) &&
|
|
((SubLink *) rexpr)->subLinkType == EXPR_SUBLINK)
|
|
{
|
|
/*
|
|
* Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the
|
|
* grammar did this, but now that a row construct is allowed anywhere
|
|
* in expressions, it's easier to do it here.
|
|
*/
|
|
SubLink *s = (SubLink *) rexpr;
|
|
|
|
s->subLinkType = ROWCOMPARE_SUBLINK;
|
|
s->testexpr = lexpr;
|
|
s->operName = a->name;
|
|
s->location = a->location;
|
|
result = transformExpr(pstate, (Node *) s);
|
|
}
|
|
else if (lexpr && IsA(lexpr, RowExpr) &&
|
|
rexpr && IsA(rexpr, RowExpr))
|
|
{
|
|
/* "row op row" */
|
|
lexpr = transformExpr(pstate, lexpr);
|
|
rexpr = transformExpr(pstate, rexpr);
|
|
Assert(IsA(lexpr, RowExpr));
|
|
Assert(IsA(rexpr, RowExpr));
|
|
|
|
result = make_row_comparison_op(pstate,
|
|
a->name,
|
|
((RowExpr *) lexpr)->args,
|
|
((RowExpr *) rexpr)->args,
|
|
a->location);
|
|
}
|
|
else
|
|
{
|
|
/* Ordinary scalar operator */
|
|
lexpr = transformExpr(pstate, lexpr);
|
|
rexpr = transformExpr(pstate, rexpr);
|
|
|
|
result = (Node *) make_op(pstate,
|
|
a->name,
|
|
lexpr,
|
|
rexpr,
|
|
a->location);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformAExprAnd(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
lexpr = coerce_to_boolean(pstate, lexpr, "AND");
|
|
rexpr = coerce_to_boolean(pstate, rexpr, "AND");
|
|
|
|
return (Node *) makeBoolExpr(AND_EXPR,
|
|
list_make2(lexpr, rexpr),
|
|
a->location);
|
|
}
|
|
|
|
static Node *
|
|
transformAExprOr(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
lexpr = coerce_to_boolean(pstate, lexpr, "OR");
|
|
rexpr = coerce_to_boolean(pstate, rexpr, "OR");
|
|
|
|
return (Node *) makeBoolExpr(OR_EXPR,
|
|
list_make2(lexpr, rexpr),
|
|
a->location);
|
|
}
|
|
|
|
static Node *
|
|
transformAExprNot(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
rexpr = coerce_to_boolean(pstate, rexpr, "NOT");
|
|
|
|
return (Node *) makeBoolExpr(NOT_EXPR,
|
|
list_make1(rexpr),
|
|
a->location);
|
|
}
|
|
|
|
static Node *
|
|
transformAExprOpAny(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
return (Node *) make_scalar_array_op(pstate,
|
|
a->name,
|
|
true,
|
|
lexpr,
|
|
rexpr,
|
|
a->location);
|
|
}
|
|
|
|
static Node *
|
|
transformAExprOpAll(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
return (Node *) make_scalar_array_op(pstate,
|
|
a->name,
|
|
false,
|
|
lexpr,
|
|
rexpr,
|
|
a->location);
|
|
}
|
|
|
|
static Node *
|
|
transformAExprDistinct(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
|
|
if (lexpr && IsA(lexpr, RowExpr) &&
|
|
rexpr && IsA(rexpr, RowExpr))
|
|
{
|
|
/* "row op row" */
|
|
return make_row_distinct_op(pstate, a->name,
|
|
(RowExpr *) lexpr,
|
|
(RowExpr *) rexpr,
|
|
a->location);
|
|
}
|
|
else
|
|
{
|
|
/* Ordinary scalar operator */
|
|
return (Node *) make_distinct_op(pstate,
|
|
a->name,
|
|
lexpr,
|
|
rexpr,
|
|
a->location);
|
|
}
|
|
}
|
|
|
|
static Node *
|
|
transformAExprNullIf(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Node *rexpr = transformExpr(pstate, a->rexpr);
|
|
Node *result;
|
|
|
|
result = (Node *) make_op(pstate,
|
|
a->name,
|
|
lexpr,
|
|
rexpr,
|
|
a->location);
|
|
if (((OpExpr *) result)->opresulttype != BOOLOID)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
errmsg("NULLIF requires = operator to yield boolean"),
|
|
parser_errposition(pstate, a->location)));
|
|
|
|
/*
|
|
* We rely on NullIfExpr and OpExpr being the same struct
|
|
*/
|
|
NodeSetTag(result, T_NullIfExpr);
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformAExprOf(ParseState *pstate, A_Expr *a)
|
|
{
|
|
/*
|
|
* Checking an expression for match to a list of type names. Will result
|
|
* in a boolean constant node.
|
|
*/
|
|
Node *lexpr = transformExpr(pstate, a->lexpr);
|
|
Const *result;
|
|
ListCell *telem;
|
|
Oid ltype,
|
|
rtype;
|
|
bool matched = false;
|
|
|
|
ltype = exprType(lexpr);
|
|
foreach(telem, (List *) a->rexpr)
|
|
{
|
|
rtype = typenameTypeId(pstate, lfirst(telem), NULL);
|
|
matched = (rtype == ltype);
|
|
if (matched)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* We have two forms: equals or not equals. Flip the sense of the result
|
|
* for not equals.
|
|
*/
|
|
if (strcmp(strVal(linitial(a->name)), "<>") == 0)
|
|
matched = (!matched);
|
|
|
|
result = (Const *) makeBoolConst(matched, false);
|
|
|
|
/* Make the result have the original input's parse location */
|
|
result->location = exprLocation((Node *) a);
|
|
|
|
return (Node *) result;
|
|
}
|
|
|
|
static Node *
|
|
transformAExprIn(ParseState *pstate, A_Expr *a)
|
|
{
|
|
Node *result = NULL;
|
|
Node *lexpr;
|
|
List *rexprs;
|
|
List *rvars;
|
|
List *rnonvars;
|
|
bool useOr;
|
|
bool haveRowExpr;
|
|
ListCell *l;
|
|
|
|
/*
|
|
* If the operator is <>, combine with AND not OR.
|
|
*/
|
|
if (strcmp(strVal(linitial(a->name)), "<>") == 0)
|
|
useOr = false;
|
|
else
|
|
useOr = true;
|
|
|
|
/*
|
|
* We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
|
|
* possible if the inputs are all scalars (no RowExprs) and there is a
|
|
* suitable array type available. If not, we fall back to a boolean
|
|
* condition tree with multiple copies of the lefthand expression. Also,
|
|
* any IN-list items that contain Vars are handled as separate boolean
|
|
* conditions, because that gives the planner more scope for optimization
|
|
* on such clauses.
|
|
*
|
|
* First step: transform all the inputs, and detect whether any are
|
|
* RowExprs or contain Vars.
|
|
*/
|
|
lexpr = transformExpr(pstate, a->lexpr);
|
|
haveRowExpr = (lexpr && IsA(lexpr, RowExpr));
|
|
rexprs = rvars = rnonvars = NIL;
|
|
foreach(l, (List *) a->rexpr)
|
|
{
|
|
Node *rexpr = transformExpr(pstate, lfirst(l));
|
|
|
|
haveRowExpr |= (rexpr && IsA(rexpr, RowExpr));
|
|
rexprs = lappend(rexprs, rexpr);
|
|
if (contain_vars_of_level(rexpr, 0))
|
|
rvars = lappend(rvars, rexpr);
|
|
else
|
|
rnonvars = lappend(rnonvars, rexpr);
|
|
}
|
|
|
|
/*
|
|
* ScalarArrayOpExpr is only going to be useful if there's more than one
|
|
* non-Var righthand item. Also, it won't work for RowExprs.
|
|
*/
|
|
if (!haveRowExpr && list_length(rnonvars) > 1)
|
|
{
|
|
List *allexprs;
|
|
Oid scalar_type;
|
|
Oid array_type;
|
|
|
|
/*
|
|
* Try to select a common type for the array elements. Note that
|
|
* since the LHS' type is first in the list, it will be preferred when
|
|
* there is doubt (eg, when all the RHS items are unknown literals).
|
|
*
|
|
* Note: use list_concat here not lcons, to avoid damaging rnonvars.
|
|
*/
|
|
allexprs = list_concat(list_make1(lexpr), rnonvars);
|
|
scalar_type = select_common_type(pstate, allexprs, NULL, NULL);
|
|
|
|
/* Do we have an array type to use? */
|
|
if (OidIsValid(scalar_type))
|
|
array_type = get_array_type(scalar_type);
|
|
else
|
|
array_type = InvalidOid;
|
|
if (array_type != InvalidOid)
|
|
{
|
|
/*
|
|
* OK: coerce all the right-hand non-Var inputs to the common type
|
|
* and build an ArrayExpr for them.
|
|
*/
|
|
List *aexprs;
|
|
ArrayExpr *newa;
|
|
|
|
aexprs = NIL;
|
|
foreach(l, rnonvars)
|
|
{
|
|
Node *rexpr = (Node *) lfirst(l);
|
|
|
|
rexpr = coerce_to_common_type(pstate, rexpr,
|
|
scalar_type,
|
|
"IN");
|
|
aexprs = lappend(aexprs, rexpr);
|
|
}
|
|
newa = makeNode(ArrayExpr);
|
|
newa->array_typeid = array_type;
|
|
newa->element_typeid = scalar_type;
|
|
newa->elements = aexprs;
|
|
newa->multidims = false;
|
|
newa->location = -1;
|
|
|
|
result = (Node *) make_scalar_array_op(pstate,
|
|
a->name,
|
|
useOr,
|
|
lexpr,
|
|
(Node *) newa,
|
|
a->location);
|
|
|
|
/* Consider only the Vars (if any) in the loop below */
|
|
rexprs = rvars;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Must do it the hard way, ie, with a boolean expression tree.
|
|
*/
|
|
foreach(l, rexprs)
|
|
{
|
|
Node *rexpr = (Node *) lfirst(l);
|
|
Node *cmp;
|
|
|
|
if (haveRowExpr)
|
|
{
|
|
if (!IsA(lexpr, RowExpr) ||
|
|
!IsA(rexpr, RowExpr))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("arguments of row IN must all be row expressions"),
|
|
parser_errposition(pstate, a->location)));
|
|
cmp = make_row_comparison_op(pstate,
|
|
a->name,
|
|
(List *) copyObject(((RowExpr *) lexpr)->args),
|
|
((RowExpr *) rexpr)->args,
|
|
a->location);
|
|
}
|
|
else
|
|
cmp = (Node *) make_op(pstate,
|
|
a->name,
|
|
copyObject(lexpr),
|
|
rexpr,
|
|
a->location);
|
|
|
|
cmp = coerce_to_boolean(pstate, cmp, "IN");
|
|
if (result == NULL)
|
|
result = cmp;
|
|
else
|
|
result = (Node *) makeBoolExpr(useOr ? OR_EXPR : AND_EXPR,
|
|
list_make2(result, cmp),
|
|
a->location);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformFuncCall(ParseState *pstate, FuncCall *fn)
|
|
{
|
|
List *targs;
|
|
ListCell *args;
|
|
|
|
/* Transform the list of arguments ... */
|
|
targs = NIL;
|
|
foreach(args, fn->args)
|
|
{
|
|
targs = lappend(targs, transformExpr(pstate,
|
|
(Node *) lfirst(args)));
|
|
}
|
|
|
|
/* ... and hand off to ParseFuncOrColumn */
|
|
return ParseFuncOrColumn(pstate,
|
|
fn->funcname,
|
|
targs,
|
|
fn->agg_star,
|
|
fn->agg_distinct,
|
|
fn->func_variadic,
|
|
fn->over,
|
|
false,
|
|
fn->location);
|
|
}
|
|
|
|
static Node *
|
|
transformCaseExpr(ParseState *pstate, CaseExpr *c)
|
|
{
|
|
CaseExpr *newc;
|
|
Node *arg;
|
|
CaseTestExpr *placeholder;
|
|
List *newargs;
|
|
List *resultexprs;
|
|
ListCell *l;
|
|
Node *defresult;
|
|
Oid ptype;
|
|
|
|
/* If we already transformed this node, do nothing */
|
|
if (OidIsValid(c->casetype))
|
|
return (Node *) c;
|
|
|
|
newc = makeNode(CaseExpr);
|
|
|
|
/* transform the test expression, if any */
|
|
arg = transformExpr(pstate, (Node *) c->arg);
|
|
|
|
/* generate placeholder for test expression */
|
|
if (arg)
|
|
{
|
|
/*
|
|
* If test expression is an untyped literal, force it to text. We have
|
|
* to do something now because we won't be able to do this coercion on
|
|
* the placeholder. This is not as flexible as what was done in 7.4
|
|
* and before, but it's good enough to handle the sort of silly coding
|
|
* commonly seen.
|
|
*/
|
|
if (exprType(arg) == UNKNOWNOID)
|
|
arg = coerce_to_common_type(pstate, arg, TEXTOID, "CASE");
|
|
|
|
placeholder = makeNode(CaseTestExpr);
|
|
placeholder->typeId = exprType(arg);
|
|
placeholder->typeMod = exprTypmod(arg);
|
|
}
|
|
else
|
|
placeholder = NULL;
|
|
|
|
newc->arg = (Expr *) arg;
|
|
|
|
/* transform the list of arguments */
|
|
newargs = NIL;
|
|
resultexprs = NIL;
|
|
foreach(l, c->args)
|
|
{
|
|
CaseWhen *w = (CaseWhen *) lfirst(l);
|
|
CaseWhen *neww = makeNode(CaseWhen);
|
|
Node *warg;
|
|
|
|
Assert(IsA(w, CaseWhen));
|
|
|
|
warg = (Node *) w->expr;
|
|
if (placeholder)
|
|
{
|
|
/* shorthand form was specified, so expand... */
|
|
warg = (Node *) makeSimpleA_Expr(AEXPR_OP, "=",
|
|
(Node *) placeholder,
|
|
warg,
|
|
w->location);
|
|
}
|
|
neww->expr = (Expr *) transformExpr(pstate, warg);
|
|
|
|
neww->expr = (Expr *) coerce_to_boolean(pstate,
|
|
(Node *) neww->expr,
|
|
"CASE/WHEN");
|
|
|
|
warg = (Node *) w->result;
|
|
neww->result = (Expr *) transformExpr(pstate, warg);
|
|
neww->location = w->location;
|
|
|
|
newargs = lappend(newargs, neww);
|
|
resultexprs = lappend(resultexprs, neww->result);
|
|
}
|
|
|
|
newc->args = newargs;
|
|
|
|
/* transform the default clause */
|
|
defresult = (Node *) c->defresult;
|
|
if (defresult == NULL)
|
|
{
|
|
A_Const *n = makeNode(A_Const);
|
|
|
|
n->val.type = T_Null;
|
|
n->location = -1;
|
|
defresult = (Node *) n;
|
|
}
|
|
newc->defresult = (Expr *) transformExpr(pstate, defresult);
|
|
|
|
/*
|
|
* Note: default result is considered the most significant type in
|
|
* determining preferred type. This is how the code worked before, but it
|
|
* seems a little bogus to me --- tgl
|
|
*/
|
|
resultexprs = lcons(newc->defresult, resultexprs);
|
|
|
|
ptype = select_common_type(pstate, resultexprs, "CASE", NULL);
|
|
Assert(OidIsValid(ptype));
|
|
newc->casetype = ptype;
|
|
|
|
/* Convert default result clause, if necessary */
|
|
newc->defresult = (Expr *)
|
|
coerce_to_common_type(pstate,
|
|
(Node *) newc->defresult,
|
|
ptype,
|
|
"CASE/ELSE");
|
|
|
|
/* Convert when-clause results, if necessary */
|
|
foreach(l, newc->args)
|
|
{
|
|
CaseWhen *w = (CaseWhen *) lfirst(l);
|
|
|
|
w->result = (Expr *)
|
|
coerce_to_common_type(pstate,
|
|
(Node *) w->result,
|
|
ptype,
|
|
"CASE/WHEN");
|
|
}
|
|
|
|
newc->location = c->location;
|
|
|
|
return (Node *) newc;
|
|
}
|
|
|
|
static Node *
|
|
transformSubLink(ParseState *pstate, SubLink *sublink)
|
|
{
|
|
Node *result = (Node *) sublink;
|
|
Query *qtree;
|
|
|
|
/* If we already transformed this node, do nothing */
|
|
if (IsA(sublink->subselect, Query))
|
|
return result;
|
|
|
|
pstate->p_hasSubLinks = true;
|
|
qtree = parse_sub_analyze(sublink->subselect, pstate, NULL);
|
|
|
|
/*
|
|
* Check that we got something reasonable. Many of these conditions are
|
|
* impossible given restrictions of the grammar, but check 'em anyway.
|
|
*/
|
|
if (!IsA(qtree, Query) ||
|
|
qtree->commandType != CMD_SELECT ||
|
|
qtree->utilityStmt != NULL)
|
|
elog(ERROR, "unexpected non-SELECT command in SubLink");
|
|
if (qtree->intoClause)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("subquery cannot have SELECT INTO"),
|
|
parser_errposition(pstate,
|
|
exprLocation((Node *) qtree->intoClause))));
|
|
|
|
sublink->subselect = (Node *) qtree;
|
|
|
|
if (sublink->subLinkType == EXISTS_SUBLINK)
|
|
{
|
|
/*
|
|
* EXISTS needs no test expression or combining operator. These fields
|
|
* should be null already, but make sure.
|
|
*/
|
|
sublink->testexpr = NULL;
|
|
sublink->operName = NIL;
|
|
}
|
|
else if (sublink->subLinkType == EXPR_SUBLINK ||
|
|
sublink->subLinkType == ARRAY_SUBLINK)
|
|
{
|
|
ListCell *tlist_item = list_head(qtree->targetList);
|
|
|
|
/*
|
|
* Make sure the subselect delivers a single column (ignoring resjunk
|
|
* targets).
|
|
*/
|
|
if (tlist_item == NULL ||
|
|
((TargetEntry *) lfirst(tlist_item))->resjunk)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("subquery must return a column"),
|
|
parser_errposition(pstate, sublink->location)));
|
|
while ((tlist_item = lnext(tlist_item)) != NULL)
|
|
{
|
|
if (!((TargetEntry *) lfirst(tlist_item))->resjunk)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("subquery must return only one column"),
|
|
parser_errposition(pstate, sublink->location)));
|
|
}
|
|
|
|
/*
|
|
* EXPR and ARRAY need no test expression or combining operator. These
|
|
* fields should be null already, but make sure.
|
|
*/
|
|
sublink->testexpr = NULL;
|
|
sublink->operName = NIL;
|
|
}
|
|
else
|
|
{
|
|
/* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */
|
|
Node *lefthand;
|
|
List *left_list;
|
|
List *right_list;
|
|
ListCell *l;
|
|
|
|
/*
|
|
* Transform lefthand expression, and convert to a list
|
|
*/
|
|
lefthand = transformExpr(pstate, sublink->testexpr);
|
|
if (lefthand && IsA(lefthand, RowExpr))
|
|
left_list = ((RowExpr *) lefthand)->args;
|
|
else
|
|
left_list = list_make1(lefthand);
|
|
|
|
/*
|
|
* Build a list of PARAM_SUBLINK nodes representing the output columns
|
|
* of the subquery.
|
|
*/
|
|
right_list = NIL;
|
|
foreach(l, qtree->targetList)
|
|
{
|
|
TargetEntry *tent = (TargetEntry *) lfirst(l);
|
|
Param *param;
|
|
|
|
if (tent->resjunk)
|
|
continue;
|
|
|
|
param = makeNode(Param);
|
|
param->paramkind = PARAM_SUBLINK;
|
|
param->paramid = tent->resno;
|
|
param->paramtype = exprType((Node *) tent->expr);
|
|
param->paramtypmod = exprTypmod((Node *) tent->expr);
|
|
param->location = -1;
|
|
|
|
right_list = lappend(right_list, param);
|
|
}
|
|
|
|
/*
|
|
* We could rely on make_row_comparison_op to complain if the list
|
|
* lengths differ, but we prefer to generate a more specific error
|
|
* message.
|
|
*/
|
|
if (list_length(left_list) < list_length(right_list))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("subquery has too many columns"),
|
|
parser_errposition(pstate, sublink->location)));
|
|
if (list_length(left_list) > list_length(right_list))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("subquery has too few columns"),
|
|
parser_errposition(pstate, sublink->location)));
|
|
|
|
/*
|
|
* Identify the combining operator(s) and generate a suitable
|
|
* row-comparison expression.
|
|
*/
|
|
sublink->testexpr = make_row_comparison_op(pstate,
|
|
sublink->operName,
|
|
left_list,
|
|
right_list,
|
|
sublink->location);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* transformArrayExpr
|
|
*
|
|
* If the caller specifies the target type, the resulting array will
|
|
* be of exactly that type. Otherwise we try to infer a common type
|
|
* for the elements using select_common_type().
|
|
*/
|
|
static Node *
|
|
transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
|
|
Oid array_type, Oid element_type, int32 typmod)
|
|
{
|
|
ArrayExpr *newa = makeNode(ArrayExpr);
|
|
List *newelems = NIL;
|
|
List *newcoercedelems = NIL;
|
|
ListCell *element;
|
|
Oid coerce_type;
|
|
bool coerce_hard;
|
|
|
|
/*
|
|
* Transform the element expressions
|
|
*
|
|
* Assume that the array is one-dimensional unless we find an array-type
|
|
* element expression.
|
|
*/
|
|
newa->multidims = false;
|
|
foreach(element, a->elements)
|
|
{
|
|
Node *e = (Node *) lfirst(element);
|
|
Node *newe;
|
|
|
|
/*
|
|
* If an element is itself an A_ArrayExpr, recurse directly so that we
|
|
* can pass down any target type we were given.
|
|
*/
|
|
if (IsA(e, A_ArrayExpr))
|
|
{
|
|
newe = transformArrayExpr(pstate,
|
|
(A_ArrayExpr *) e,
|
|
array_type,
|
|
element_type,
|
|
typmod);
|
|
/* we certainly have an array here */
|
|
Assert(array_type == InvalidOid || array_type == exprType(newe));
|
|
newa->multidims = true;
|
|
}
|
|
else
|
|
{
|
|
newe = transformExpr(pstate, e);
|
|
|
|
/*
|
|
* Check for sub-array expressions, if we haven't already found
|
|
* one.
|
|
*/
|
|
if (!newa->multidims && type_is_array(exprType(newe)))
|
|
newa->multidims = true;
|
|
}
|
|
|
|
newelems = lappend(newelems, newe);
|
|
}
|
|
|
|
/*
|
|
* Select a target type for the elements.
|
|
*
|
|
* If we haven't been given a target array type, we must try to deduce a
|
|
* common type based on the types of the individual elements present.
|
|
*/
|
|
if (OidIsValid(array_type))
|
|
{
|
|
/* Caller must ensure array_type matches element_type */
|
|
Assert(OidIsValid(element_type));
|
|
coerce_type = (newa->multidims ? array_type : element_type);
|
|
coerce_hard = true;
|
|
}
|
|
else
|
|
{
|
|
/* Can't handle an empty array without a target type */
|
|
if (newelems == NIL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INDETERMINATE_DATATYPE),
|
|
errmsg("cannot determine type of empty array"),
|
|
errhint("Explicitly cast to the desired type, "
|
|
"for example ARRAY[]::integer[]."),
|
|
parser_errposition(pstate, a->location)));
|
|
|
|
/* Select a common type for the elements */
|
|
coerce_type = select_common_type(pstate, newelems, "ARRAY", NULL);
|
|
|
|
if (newa->multidims)
|
|
{
|
|
array_type = coerce_type;
|
|
element_type = get_element_type(array_type);
|
|
if (!OidIsValid(element_type))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_OBJECT),
|
|
errmsg("could not find element type for data type %s",
|
|
format_type_be(array_type)),
|
|
parser_errposition(pstate, a->location)));
|
|
}
|
|
else
|
|
{
|
|
element_type = coerce_type;
|
|
array_type = get_array_type(element_type);
|
|
if (!OidIsValid(array_type))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_OBJECT),
|
|
errmsg("could not find array type for data type %s",
|
|
format_type_be(element_type)),
|
|
parser_errposition(pstate, a->location)));
|
|
}
|
|
coerce_hard = false;
|
|
}
|
|
|
|
/*
|
|
* Coerce elements to target type
|
|
*
|
|
* If the array has been explicitly cast, then the elements are in turn
|
|
* explicitly coerced.
|
|
*
|
|
* If the array's type was merely derived from the common type of its
|
|
* elements, then the elements are implicitly coerced to the common type.
|
|
* This is consistent with other uses of select_common_type().
|
|
*/
|
|
foreach(element, newelems)
|
|
{
|
|
Node *e = (Node *) lfirst(element);
|
|
Node *newe;
|
|
|
|
if (coerce_hard)
|
|
{
|
|
newe = coerce_to_target_type(pstate, e,
|
|
exprType(e),
|
|
coerce_type,
|
|
typmod,
|
|
COERCION_EXPLICIT,
|
|
COERCE_EXPLICIT_CAST,
|
|
-1);
|
|
if (newe == NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_CANNOT_COERCE),
|
|
errmsg("cannot cast type %s to %s",
|
|
format_type_be(exprType(e)),
|
|
format_type_be(coerce_type)),
|
|
parser_errposition(pstate, exprLocation(e))));
|
|
}
|
|
else
|
|
newe = coerce_to_common_type(pstate, e,
|
|
coerce_type,
|
|
"ARRAY");
|
|
newcoercedelems = lappend(newcoercedelems, newe);
|
|
}
|
|
|
|
newa->array_typeid = array_type;
|
|
newa->element_typeid = element_type;
|
|
newa->elements = newcoercedelems;
|
|
newa->location = a->location;
|
|
|
|
return (Node *) newa;
|
|
}
|
|
|
|
static Node *
|
|
transformRowExpr(ParseState *pstate, RowExpr *r)
|
|
{
|
|
RowExpr *newr = makeNode(RowExpr);
|
|
|
|
/* Transform the field expressions */
|
|
newr->args = transformExpressionList(pstate, r->args);
|
|
|
|
/* Barring later casting, we consider the type RECORD */
|
|
newr->row_typeid = RECORDOID;
|
|
newr->row_format = COERCE_IMPLICIT_CAST;
|
|
newr->colnames = NIL; /* ROW() has anonymous columns */
|
|
newr->location = r->location;
|
|
|
|
return (Node *) newr;
|
|
}
|
|
|
|
static Node *
|
|
transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c)
|
|
{
|
|
CoalesceExpr *newc = makeNode(CoalesceExpr);
|
|
List *newargs = NIL;
|
|
List *newcoercedargs = NIL;
|
|
ListCell *args;
|
|
|
|
foreach(args, c->args)
|
|
{
|
|
Node *e = (Node *) lfirst(args);
|
|
Node *newe;
|
|
|
|
newe = transformExpr(pstate, e);
|
|
newargs = lappend(newargs, newe);
|
|
}
|
|
|
|
newc->coalescetype = select_common_type(pstate, newargs, "COALESCE", NULL);
|
|
|
|
/* Convert arguments if necessary */
|
|
foreach(args, newargs)
|
|
{
|
|
Node *e = (Node *) lfirst(args);
|
|
Node *newe;
|
|
|
|
newe = coerce_to_common_type(pstate, e,
|
|
newc->coalescetype,
|
|
"COALESCE");
|
|
newcoercedargs = lappend(newcoercedargs, newe);
|
|
}
|
|
|
|
newc->args = newcoercedargs;
|
|
newc->location = c->location;
|
|
return (Node *) newc;
|
|
}
|
|
|
|
static Node *
|
|
transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m)
|
|
{
|
|
MinMaxExpr *newm = makeNode(MinMaxExpr);
|
|
List *newargs = NIL;
|
|
List *newcoercedargs = NIL;
|
|
const char *funcname = (m->op == IS_GREATEST) ? "GREATEST" : "LEAST";
|
|
ListCell *args;
|
|
|
|
newm->op = m->op;
|
|
foreach(args, m->args)
|
|
{
|
|
Node *e = (Node *) lfirst(args);
|
|
Node *newe;
|
|
|
|
newe = transformExpr(pstate, e);
|
|
newargs = lappend(newargs, newe);
|
|
}
|
|
|
|
newm->minmaxtype = select_common_type(pstate, newargs, funcname, NULL);
|
|
|
|
/* Convert arguments if necessary */
|
|
foreach(args, newargs)
|
|
{
|
|
Node *e = (Node *) lfirst(args);
|
|
Node *newe;
|
|
|
|
newe = coerce_to_common_type(pstate, e,
|
|
newm->minmaxtype,
|
|
funcname);
|
|
newcoercedargs = lappend(newcoercedargs, newe);
|
|
}
|
|
|
|
newm->args = newcoercedargs;
|
|
newm->location = m->location;
|
|
return (Node *) newm;
|
|
}
|
|
|
|
static Node *
|
|
transformXmlExpr(ParseState *pstate, XmlExpr *x)
|
|
{
|
|
XmlExpr *newx = makeNode(XmlExpr);
|
|
ListCell *lc;
|
|
int i;
|
|
|
|
newx->op = x->op;
|
|
if (x->name)
|
|
newx->name = map_sql_identifier_to_xml_name(x->name, false, false);
|
|
else
|
|
newx->name = NULL;
|
|
newx->xmloption = x->xmloption;
|
|
newx->location = x->location;
|
|
|
|
/*
|
|
* gram.y built the named args as a list of ResTarget. Transform each,
|
|
* and break the names out as a separate list.
|
|
*/
|
|
newx->named_args = NIL;
|
|
newx->arg_names = NIL;
|
|
|
|
foreach(lc, x->named_args)
|
|
{
|
|
ResTarget *r = (ResTarget *) lfirst(lc);
|
|
Node *expr;
|
|
char *argname;
|
|
|
|
Assert(IsA(r, ResTarget));
|
|
|
|
expr = transformExpr(pstate, r->val);
|
|
|
|
if (r->name)
|
|
argname = map_sql_identifier_to_xml_name(r->name, false, false);
|
|
else if (IsA(r->val, ColumnRef))
|
|
argname = map_sql_identifier_to_xml_name(FigureColname(r->val),
|
|
true, false);
|
|
else
|
|
{
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
x->op == IS_XMLELEMENT
|
|
? errmsg("unnamed XML attribute value must be a column reference")
|
|
: errmsg("unnamed XML element value must be a column reference"),
|
|
parser_errposition(pstate, r->location)));
|
|
argname = NULL; /* keep compiler quiet */
|
|
}
|
|
|
|
/* reject duplicate argnames in XMLELEMENT only */
|
|
if (x->op == IS_XMLELEMENT)
|
|
{
|
|
ListCell *lc2;
|
|
|
|
foreach(lc2, newx->arg_names)
|
|
{
|
|
if (strcmp(argname, strVal(lfirst(lc2))) == 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("XML attribute name \"%s\" appears more than once",
|
|
argname),
|
|
parser_errposition(pstate, r->location)));
|
|
}
|
|
}
|
|
|
|
newx->named_args = lappend(newx->named_args, expr);
|
|
newx->arg_names = lappend(newx->arg_names, makeString(argname));
|
|
}
|
|
|
|
/* The other arguments are of varying types depending on the function */
|
|
newx->args = NIL;
|
|
i = 0;
|
|
foreach(lc, x->args)
|
|
{
|
|
Node *e = (Node *) lfirst(lc);
|
|
Node *newe;
|
|
|
|
newe = transformExpr(pstate, e);
|
|
switch (x->op)
|
|
{
|
|
case IS_XMLCONCAT:
|
|
newe = coerce_to_specific_type(pstate, newe, XMLOID,
|
|
"XMLCONCAT");
|
|
break;
|
|
case IS_XMLELEMENT:
|
|
/* no coercion necessary */
|
|
break;
|
|
case IS_XMLFOREST:
|
|
newe = coerce_to_specific_type(pstate, newe, XMLOID,
|
|
"XMLFOREST");
|
|
break;
|
|
case IS_XMLPARSE:
|
|
if (i == 0)
|
|
newe = coerce_to_specific_type(pstate, newe, TEXTOID,
|
|
"XMLPARSE");
|
|
else
|
|
newe = coerce_to_boolean(pstate, newe, "XMLPARSE");
|
|
break;
|
|
case IS_XMLPI:
|
|
newe = coerce_to_specific_type(pstate, newe, TEXTOID,
|
|
"XMLPI");
|
|
break;
|
|
case IS_XMLROOT:
|
|
if (i == 0)
|
|
newe = coerce_to_specific_type(pstate, newe, XMLOID,
|
|
"XMLROOT");
|
|
else if (i == 1)
|
|
newe = coerce_to_specific_type(pstate, newe, TEXTOID,
|
|
"XMLROOT");
|
|
else
|
|
newe = coerce_to_specific_type(pstate, newe, INT4OID,
|
|
"XMLROOT");
|
|
break;
|
|
case IS_XMLSERIALIZE:
|
|
/* not handled here */
|
|
Assert(false);
|
|
break;
|
|
case IS_DOCUMENT:
|
|
newe = coerce_to_specific_type(pstate, newe, XMLOID,
|
|
"IS DOCUMENT");
|
|
break;
|
|
}
|
|
newx->args = lappend(newx->args, newe);
|
|
i++;
|
|
}
|
|
|
|
return (Node *) newx;
|
|
}
|
|
|
|
static Node *
|
|
transformXmlSerialize(ParseState *pstate, XmlSerialize *xs)
|
|
{
|
|
Node *result;
|
|
XmlExpr *xexpr;
|
|
Oid targetType;
|
|
int32 targetTypmod;
|
|
|
|
xexpr = makeNode(XmlExpr);
|
|
xexpr->op = IS_XMLSERIALIZE;
|
|
xexpr->args = list_make1(coerce_to_specific_type(pstate,
|
|
transformExpr(pstate, xs->expr),
|
|
XMLOID,
|
|
"XMLSERIALIZE"));
|
|
|
|
targetType = typenameTypeId(pstate, xs->typeName, &targetTypmod);
|
|
|
|
xexpr->xmloption = xs->xmloption;
|
|
xexpr->location = xs->location;
|
|
/* We actually only need these to be able to parse back the expression. */
|
|
xexpr->type = targetType;
|
|
xexpr->typmod = targetTypmod;
|
|
|
|
/*
|
|
* The actual target type is determined this way. SQL allows char and
|
|
* varchar as target types. We allow anything that can be cast implicitly
|
|
* from text. This way, user-defined text-like data types automatically
|
|
* fit in.
|
|
*/
|
|
result = coerce_to_target_type(pstate, (Node *) xexpr,
|
|
TEXTOID, targetType, targetTypmod,
|
|
COERCION_IMPLICIT,
|
|
COERCE_IMPLICIT_CAST,
|
|
-1);
|
|
if (result == NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_CANNOT_COERCE),
|
|
errmsg("cannot cast XMLSERIALIZE result to %s",
|
|
format_type_be(targetType)),
|
|
parser_errposition(pstate, xexpr->location)));
|
|
return result;
|
|
}
|
|
|
|
static Node *
|
|
transformBooleanTest(ParseState *pstate, BooleanTest *b)
|
|
{
|
|
const char *clausename;
|
|
|
|
switch (b->booltesttype)
|
|
{
|
|
case IS_TRUE:
|
|
clausename = "IS TRUE";
|
|
break;
|
|
case IS_NOT_TRUE:
|
|
clausename = "IS NOT TRUE";
|
|
break;
|
|
case IS_FALSE:
|
|
clausename = "IS FALSE";
|
|
break;
|
|
case IS_NOT_FALSE:
|
|
clausename = "IS NOT FALSE";
|
|
break;
|
|
case IS_UNKNOWN:
|
|
clausename = "IS UNKNOWN";
|
|
break;
|
|
case IS_NOT_UNKNOWN:
|
|
clausename = "IS NOT UNKNOWN";
|
|
break;
|
|
default:
|
|
elog(ERROR, "unrecognized booltesttype: %d",
|
|
(int) b->booltesttype);
|
|
clausename = NULL; /* keep compiler quiet */
|
|
}
|
|
|
|
b->arg = (Expr *) transformExpr(pstate, (Node *) b->arg);
|
|
|
|
b->arg = (Expr *) coerce_to_boolean(pstate,
|
|
(Node *) b->arg,
|
|
clausename);
|
|
|
|
return (Node *) b;
|
|
}
|
|
|
|
static Node *
|
|
transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
|
|
{
|
|
int sublevels_up;
|
|
|
|
/* CURRENT OF can only appear at top level of UPDATE/DELETE */
|
|
Assert(pstate->p_target_rangetblentry != NULL);
|
|
cexpr->cvarno = RTERangeTablePosn(pstate,
|
|
pstate->p_target_rangetblentry,
|
|
&sublevels_up);
|
|
Assert(sublevels_up == 0);
|
|
|
|
/* If a parameter is used, it must be of type REFCURSOR */
|
|
if (cexpr->cursor_name == NULL)
|
|
{
|
|
Oid *pptype = find_param_type(pstate, cexpr->cursor_param, -1);
|
|
|
|
if (pstate->p_variableparams && *pptype == UNKNOWNOID)
|
|
{
|
|
/* resolve unknown param type as REFCURSOR */
|
|
*pptype = REFCURSOROID;
|
|
}
|
|
else if (*pptype != REFCURSOROID)
|
|
{
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_AMBIGUOUS_PARAMETER),
|
|
errmsg("inconsistent types deduced for parameter $%d",
|
|
cexpr->cursor_param),
|
|
errdetail("%s versus %s",
|
|
format_type_be(*pptype),
|
|
format_type_be(REFCURSOROID))));
|
|
}
|
|
}
|
|
|
|
return (Node *) cexpr;
|
|
}
|
|
|
|
/*
|
|
* Construct a whole-row reference to represent the notation "relation.*".
|
|
*
|
|
* A whole-row reference is a Var with varno set to the correct range
|
|
* table entry, and varattno == 0 to signal that it references the whole
|
|
* tuple. (Use of zero here is unclean, since it could easily be confused
|
|
* with error cases, but it's not worth changing now.) The vartype indicates
|
|
* a rowtype; either a named composite type, or RECORD.
|
|
*/
|
|
static Node *
|
|
transformWholeRowRef(ParseState *pstate, char *schemaname, char *relname,
|
|
int location)
|
|
{
|
|
Var *result;
|
|
RangeTblEntry *rte;
|
|
int vnum;
|
|
int sublevels_up;
|
|
Oid toid;
|
|
|
|
/* Look up the referenced RTE, creating it if needed */
|
|
|
|
rte = refnameRangeTblEntry(pstate, schemaname, relname, location,
|
|
&sublevels_up);
|
|
|
|
if (rte == NULL)
|
|
rte = addImplicitRTE(pstate,
|
|
makeRangeVar(schemaname, relname, location));
|
|
|
|
vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
|
|
|
|
/* Build the appropriate referencing node */
|
|
|
|
switch (rte->rtekind)
|
|
{
|
|
case RTE_RELATION:
|
|
/* relation: the rowtype is a named composite type */
|
|
toid = get_rel_type_id(rte->relid);
|
|
if (!OidIsValid(toid))
|
|
elog(ERROR, "could not find type OID for relation %u",
|
|
rte->relid);
|
|
result = makeVar(vnum,
|
|
InvalidAttrNumber,
|
|
toid,
|
|
-1,
|
|
sublevels_up);
|
|
break;
|
|
case RTE_FUNCTION:
|
|
toid = exprType(rte->funcexpr);
|
|
if (type_is_rowtype(toid))
|
|
{
|
|
/* func returns composite; same as relation case */
|
|
result = makeVar(vnum,
|
|
InvalidAttrNumber,
|
|
toid,
|
|
-1,
|
|
sublevels_up);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* func returns scalar; instead of making a whole-row Var,
|
|
* just reference the function's scalar output. (XXX this
|
|
* seems a tad inconsistent, especially if "f.*" was
|
|
* explicitly written ...)
|
|
*/
|
|
result = makeVar(vnum,
|
|
1,
|
|
toid,
|
|
-1,
|
|
sublevels_up);
|
|
}
|
|
break;
|
|
case RTE_VALUES:
|
|
toid = RECORDOID;
|
|
/* returns composite; same as relation case */
|
|
result = makeVar(vnum,
|
|
InvalidAttrNumber,
|
|
toid,
|
|
-1,
|
|
sublevels_up);
|
|
break;
|
|
default:
|
|
|
|
/*
|
|
* RTE is a join or subselect. We represent this as a whole-row
|
|
* Var of RECORD type. (Note that in most cases the Var will be
|
|
* expanded to a RowExpr during planning, but that is not our
|
|
* concern here.)
|
|
*/
|
|
result = makeVar(vnum,
|
|
InvalidAttrNumber,
|
|
RECORDOID,
|
|
-1,
|
|
sublevels_up);
|
|
break;
|
|
}
|
|
|
|
/* location is not filled in by makeVar */
|
|
result->location = location;
|
|
|
|
/* mark relation as requiring whole-row SELECT access */
|
|
markVarForSelectPriv(pstate, result, rte);
|
|
|
|
return (Node *) result;
|
|
}
|
|
|
|
/*
|
|
* Handle an explicit CAST construct.
|
|
*
|
|
* Transform the argument, then look up the type name and apply any necessary
|
|
* coercion function(s).
|
|
*/
|
|
static Node *
|
|
transformTypeCast(ParseState *pstate, TypeCast *tc)
|
|
{
|
|
Node *result;
|
|
Node *expr = transformExpr(pstate, tc->arg);
|
|
Oid inputType = exprType(expr);
|
|
Oid targetType;
|
|
int32 targetTypmod;
|
|
int location;
|
|
|
|
targetType = typenameTypeId(pstate, tc->typeName, &targetTypmod);
|
|
|
|
if (inputType == InvalidOid)
|
|
return expr; /* do nothing if NULL input */
|
|
|
|
/*
|
|
* Location of the coercion is preferentially the location of the :: or
|
|
* CAST symbol, but if there is none then use the location of the type
|
|
* name (this can happen in TypeName 'string' syntax, for instance).
|
|
*/
|
|
location = tc->location;
|
|
if (location < 0)
|
|
location = tc->typeName->location;
|
|
|
|
result = coerce_to_target_type(pstate, expr, inputType,
|
|
targetType, targetTypmod,
|
|
COERCION_EXPLICIT,
|
|
COERCE_EXPLICIT_CAST,
|
|
location);
|
|
if (result == NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_CANNOT_COERCE),
|
|
errmsg("cannot cast type %s to %s",
|
|
format_type_be(inputType),
|
|
format_type_be(targetType)),
|
|
parser_coercion_errposition(pstate, location, expr)));
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Transform a "row compare-op row" construct
|
|
*
|
|
* The inputs are lists of already-transformed expressions.
|
|
* As with coerce_type, pstate may be NULL if no special unknown-Param
|
|
* processing is wanted.
|
|
*
|
|
* The output may be a single OpExpr, an AND or OR combination of OpExprs,
|
|
* or a RowCompareExpr. In all cases it is guaranteed to return boolean.
|
|
* The AND, OR, and RowCompareExpr cases further imply things about the
|
|
* behavior of the operators (ie, they behave as =, <>, or < <= > >=).
|
|
*/
|
|
static Node *
|
|
make_row_comparison_op(ParseState *pstate, List *opname,
|
|
List *largs, List *rargs, int location)
|
|
{
|
|
RowCompareExpr *rcexpr;
|
|
RowCompareType rctype;
|
|
List *opexprs;
|
|
List *opnos;
|
|
List *opfamilies;
|
|
ListCell *l,
|
|
*r;
|
|
List **opfamily_lists;
|
|
List **opstrat_lists;
|
|
Bitmapset *strats;
|
|
int nopers;
|
|
int i;
|
|
|
|
nopers = list_length(largs);
|
|
if (nopers != list_length(rargs))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("unequal number of entries in row expressions"),
|
|
parser_errposition(pstate, location)));
|
|
|
|
/*
|
|
* We can't compare zero-length rows because there is no principled basis
|
|
* for figuring out what the operator is.
|
|
*/
|
|
if (nopers == 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("cannot compare rows of zero length"),
|
|
parser_errposition(pstate, location)));
|
|
|
|
/*
|
|
* Identify all the pairwise operators, using make_op so that behavior is
|
|
* the same as in the simple scalar case.
|
|
*/
|
|
opexprs = NIL;
|
|
forboth(l, largs, r, rargs)
|
|
{
|
|
Node *larg = (Node *) lfirst(l);
|
|
Node *rarg = (Node *) lfirst(r);
|
|
OpExpr *cmp;
|
|
|
|
cmp = (OpExpr *) make_op(pstate, opname, larg, rarg, location);
|
|
Assert(IsA(cmp, OpExpr));
|
|
|
|
/*
|
|
* We don't use coerce_to_boolean here because we insist on the
|
|
* operator yielding boolean directly, not via coercion. If it
|
|
* doesn't yield bool it won't be in any index opfamilies...
|
|
*/
|
|
if (cmp->opresulttype != BOOLOID)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
errmsg("row comparison operator must yield type boolean, "
|
|
"not type %s",
|
|
format_type_be(cmp->opresulttype)),
|
|
parser_errposition(pstate, location)));
|
|
if (expression_returns_set((Node *) cmp))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
errmsg("row comparison operator must not return a set"),
|
|
parser_errposition(pstate, location)));
|
|
opexprs = lappend(opexprs, cmp);
|
|
}
|
|
|
|
/*
|
|
* If rows are length 1, just return the single operator. In this case we
|
|
* don't insist on identifying btree semantics for the operator (but we
|
|
* still require it to return boolean).
|
|
*/
|
|
if (nopers == 1)
|
|
return (Node *) linitial(opexprs);
|
|
|
|
/*
|
|
* Now we must determine which row comparison semantics (= <> < <= > >=)
|
|
* apply to this set of operators. We look for btree opfamilies
|
|
* containing the operators, and see which interpretations (strategy
|
|
* numbers) exist for each operator.
|
|
*/
|
|
opfamily_lists = (List **) palloc(nopers * sizeof(List *));
|
|
opstrat_lists = (List **) palloc(nopers * sizeof(List *));
|
|
strats = NULL;
|
|
i = 0;
|
|
foreach(l, opexprs)
|
|
{
|
|
Oid opno = ((OpExpr *) lfirst(l))->opno;
|
|
Bitmapset *this_strats;
|
|
ListCell *j;
|
|
|
|
get_op_btree_interpretation(opno,
|
|
&opfamily_lists[i], &opstrat_lists[i]);
|
|
|
|
/*
|
|
* convert strategy number list to a Bitmapset to make the
|
|
* intersection calculation easy.
|
|
*/
|
|
this_strats = NULL;
|
|
foreach(j, opstrat_lists[i])
|
|
{
|
|
this_strats = bms_add_member(this_strats, lfirst_int(j));
|
|
}
|
|
if (i == 0)
|
|
strats = this_strats;
|
|
else
|
|
strats = bms_int_members(strats, this_strats);
|
|
i++;
|
|
}
|
|
|
|
/*
|
|
* If there are multiple common interpretations, we may use any one of
|
|
* them ... this coding arbitrarily picks the lowest btree strategy
|
|
* number.
|
|
*/
|
|
i = bms_first_member(strats);
|
|
if (i < 0)
|
|
{
|
|
/* No common interpretation, so fail */
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("could not determine interpretation of row comparison operator %s",
|
|
strVal(llast(opname))),
|
|
errhint("Row comparison operators must be associated with btree operator families."),
|
|
parser_errposition(pstate, location)));
|
|
}
|
|
rctype = (RowCompareType) i;
|
|
|
|
/*
|
|
* For = and <> cases, we just combine the pairwise operators with AND or
|
|
* OR respectively.
|
|
*
|
|
* Note: this is presently the only place where the parser generates
|
|
* BoolExpr with more than two arguments. Should be OK since the rest of
|
|
* the system thinks BoolExpr is N-argument anyway.
|
|
*/
|
|
if (rctype == ROWCOMPARE_EQ)
|
|
return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
|
|
if (rctype == ROWCOMPARE_NE)
|
|
return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);
|
|
|
|
/*
|
|
* Otherwise we need to choose exactly which opfamily to associate with
|
|
* each operator.
|
|
*/
|
|
opfamilies = NIL;
|
|
for (i = 0; i < nopers; i++)
|
|
{
|
|
Oid opfamily = InvalidOid;
|
|
|
|
forboth(l, opfamily_lists[i], r, opstrat_lists[i])
|
|
{
|
|
int opstrat = lfirst_int(r);
|
|
|
|
if (opstrat == rctype)
|
|
{
|
|
opfamily = lfirst_oid(l);
|
|
break;
|
|
}
|
|
}
|
|
if (OidIsValid(opfamily))
|
|
opfamilies = lappend_oid(opfamilies, opfamily);
|
|
else /* should not happen */
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("could not determine interpretation of row comparison operator %s",
|
|
strVal(llast(opname))),
|
|
errdetail("There are multiple equally-plausible candidates."),
|
|
parser_errposition(pstate, location)));
|
|
}
|
|
|
|
/*
|
|
* Now deconstruct the OpExprs and create a RowCompareExpr.
|
|
*
|
|
* Note: can't just reuse the passed largs/rargs lists, because of
|
|
* possibility that make_op inserted coercion operations.
|
|
*/
|
|
opnos = NIL;
|
|
largs = NIL;
|
|
rargs = NIL;
|
|
foreach(l, opexprs)
|
|
{
|
|
OpExpr *cmp = (OpExpr *) lfirst(l);
|
|
|
|
opnos = lappend_oid(opnos, cmp->opno);
|
|
largs = lappend(largs, linitial(cmp->args));
|
|
rargs = lappend(rargs, lsecond(cmp->args));
|
|
}
|
|
|
|
rcexpr = makeNode(RowCompareExpr);
|
|
rcexpr->rctype = rctype;
|
|
rcexpr->opnos = opnos;
|
|
rcexpr->opfamilies = opfamilies;
|
|
rcexpr->largs = largs;
|
|
rcexpr->rargs = rargs;
|
|
|
|
return (Node *) rcexpr;
|
|
}
|
|
|
|
/*
|
|
* Transform a "row IS DISTINCT FROM row" construct
|
|
*
|
|
* The input RowExprs are already transformed
|
|
*/
|
|
static Node *
|
|
make_row_distinct_op(ParseState *pstate, List *opname,
|
|
RowExpr *lrow, RowExpr *rrow,
|
|
int location)
|
|
{
|
|
Node *result = NULL;
|
|
List *largs = lrow->args;
|
|
List *rargs = rrow->args;
|
|
ListCell *l,
|
|
*r;
|
|
|
|
if (list_length(largs) != list_length(rargs))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("unequal number of entries in row expressions"),
|
|
parser_errposition(pstate, location)));
|
|
|
|
forboth(l, largs, r, rargs)
|
|
{
|
|
Node *larg = (Node *) lfirst(l);
|
|
Node *rarg = (Node *) lfirst(r);
|
|
Node *cmp;
|
|
|
|
cmp = (Node *) make_distinct_op(pstate, opname, larg, rarg, location);
|
|
if (result == NULL)
|
|
result = cmp;
|
|
else
|
|
result = (Node *) makeBoolExpr(OR_EXPR,
|
|
list_make2(result, cmp),
|
|
location);
|
|
}
|
|
|
|
if (result == NULL)
|
|
{
|
|
/* zero-length rows? Generate constant FALSE */
|
|
result = makeBoolConst(false, false);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* make the node for an IS DISTINCT FROM operator
|
|
*/
|
|
static Expr *
|
|
make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree,
|
|
int location)
|
|
{
|
|
Expr *result;
|
|
|
|
result = make_op(pstate, opname, ltree, rtree, location);
|
|
if (((OpExpr *) result)->opresulttype != BOOLOID)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DATATYPE_MISMATCH),
|
|
errmsg("IS DISTINCT FROM requires = operator to yield boolean"),
|
|
parser_errposition(pstate, location)));
|
|
|
|
/*
|
|
* We rely on DistinctExpr and OpExpr being same struct
|
|
*/
|
|
NodeSetTag(result, T_DistinctExpr);
|
|
|
|
return result;
|
|
}
|