mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
postgres/src/backend/parser/analyze.c
Thomas G. Lockhart 05cdb99bfb Add detection and warnings for UNION and HAVING clauses. 
Generate non-fatal warning only and proceed by ignoring clauses.
1997-09-01 05:56:34 +00:00

2495 lines
65 KiB
C
Raw Blame History

/*-------------------------------------------------------------------------
*
* analyze.c--
* transform the parse tree into a query tree
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.36 1997/09/01 05:56:34 thomas Exp $
*
*-------------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "postgres.h"
#include "nodes/nodes.h"
#include "nodes/params.h"
#include "nodes/primnodes.h"
#include "nodes/parsenodes.h"
#include "nodes/relation.h"
#include "parse.h" /* for AND, OR, etc. */
#include "catalog/pg_type.h" /* for INT4OID, etc. */
#include "catalog/pg_proc.h"
#include "utils/elog.h"
#include "utils/builtins.h" /* namecmp(), textout() */
#include "utils/lsyscache.h"
#include "utils/palloc.h"
#include "utils/mcxt.h"
#include "utils/syscache.h"
#include "utils/acl.h"
#include "parser/parse_query.h"
#include "parser/parse_state.h"
#include "nodes/makefuncs.h" /* for makeResdom(), etc. */
#include "nodes/nodeFuncs.h"
#include "commands/sequence.h"
#include "optimizer/clauses.h"
#include "access/heapam.h"
#include "miscadmin.h"
#include "port-protos.h" /* strdup() */
/* convert the parse tree into a query tree */
static Query *transformStmt(ParseState *pstate, Node *stmt);
static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
static Query *transformInsertStmt(ParseState *pstate, AppendStmt *stmt);
static Query *transformIndexStmt(ParseState *pstate, IndexStmt *stmt);
static Query *transformExtendStmt(ParseState *pstate, ExtendStmt *stmt);
static Query *transformRuleStmt(ParseState *query, RuleStmt *stmt);
static Query *transformSelectStmt(ParseState *pstate, RetrieveStmt *stmt);
static Query *transformUpdateStmt(ParseState *pstate, ReplaceStmt *stmt);
static Query *transformCursorStmt(ParseState *pstate, CursorStmt *stmt);
static Node *handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno);
#define EXPR_COLUMN_FIRST 1
#define EXPR_RELATION_FIRST 2
static Node *transformExpr(ParseState *pstate, Node *expr, int precedence);
static Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
static void makeRangeTable(ParseState *pstate, char *relname, List *frmList);
static List *expandAllTables(ParseState *pstate);
static char *figureColname(Node *expr, Node *resval);
static List *makeTargetNames(ParseState *pstate, List *cols);
static List *transformTargetList(ParseState *pstate, List *targetlist);
static TargetEntry *make_targetlist_expr(ParseState *pstate,
char *colname, Node *expr,
List *arrayRef);
static bool inWhereClause = false;
static Node *transformWhereClause(ParseState *pstate, Node *a_expr);
static List *transformGroupClause(ParseState *pstate, List *grouplist,
List *targetlist);
static List *transformSortClause(ParseState *pstate,
List *orderlist, List *targetlist,
char* uniqueFlag);
static void parseFromClause(ParseState *pstate, List *frmList);
static Node *ParseFunc(ParseState *pstate, char *funcname,
List *fargs, int *curr_resno);
static List *setup_tlist(char *attname, Oid relid);
static List *setup_base_tlist(Oid typeid);
static void make_arguments(int nargs, List *fargs, Oid *input_typeids,
Oid *function_typeids);
static void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
static void finalizeAggregates(ParseState *pstate, Query *qry);
static void parseCheckAggregates(ParseState *pstate, Query *qry);
static ParseState* makeParseState(void);
/*****************************************************************************
*
*****************************************************************************/
/*
* makeParseState() --
* allocate and initialize a new ParseState.
* the CALLERS is responsible for freeing the ParseState* returned
*
*/
static ParseState*
makeParseState(void)
{
ParseState *pstate;
pstate = malloc(sizeof(ParseState));
pstate->p_last_resno = 1;
pstate->p_rtable = NIL;
pstate->p_numAgg = 0;
pstate->p_aggs = NIL;
pstate->p_is_insert = false;
pstate->p_insert_columns = NIL;
pstate->p_is_update = false;
pstate->p_is_rule = false;
pstate->p_target_relation = NULL;
pstate->p_target_rangetblentry = NULL;
return (pstate);
}
/*
* parse_analyze -
* analyze a list of parse trees and transform them if necessary.
*
* Returns a list of transformed parse trees. Optimizable statements are
* all transformed to Query while the rest stays the same.
*
* CALLER is responsible for freeing the QueryTreeList* returned
*/
QueryTreeList *
parse_analyze(List *pl)
{
QueryTreeList *result;
ParseState *pstate;
int i = 0;
result = malloc(sizeof(QueryTreeList));
result->len = length(pl);
result->qtrees = (Query**)malloc(result->len * sizeof(Query*));
inWhereClause = false; /* to avoid nextval(sequence) in WHERE */
while(pl!=NIL) {
pstate = makeParseState();
result->qtrees[i++] = transformStmt(pstate, lfirst(pl));
pl = lnext(pl);
if (pstate->p_target_relation != NULL)
heap_close(pstate->p_target_relation);
free(pstate);
}
return result;
}
/*
* transformStmt -
* transform a Parse tree. If it is an optimizable statement, turn it
* into a Query tree.
*/
static Query *
transformStmt(ParseState* pstate, Node *parseTree)
{
Query* result = NULL;
switch(nodeTag(parseTree)) {
/*------------------------
* Non-optimizable statements
*------------------------
*/
case T_IndexStmt:
result = transformIndexStmt(pstate, (IndexStmt *)parseTree);
break;
case T_ExtendStmt:
result = transformExtendStmt(pstate, (ExtendStmt *)parseTree);
break;
case T_RuleStmt:
result = transformRuleStmt(pstate, (RuleStmt *)parseTree);
break;
case T_ViewStmt:
{
ViewStmt *n = (ViewStmt *)parseTree;
n->query = (Query *)transformStmt(pstate, (Node*)n->query);
result = makeNode(Query);
result->commandType = CMD_UTILITY;
result->utilityStmt = (Node*)n;
}
break;
case T_VacuumStmt:
{
MemoryContext oldcontext;
/* make sure that this Query is allocated in TopMemory context
because vacuum spans transactions and we don't want to lose
the vacuum Query due to end-of-transaction free'ing*/
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
result = makeNode(Query);
result->commandType = CMD_UTILITY;
result->utilityStmt = (Node*)parseTree;
MemoryContextSwitchTo(oldcontext);
break;
}
case T_ExplainStmt:
{
ExplainStmt *n = (ExplainStmt *)parseTree;
result = makeNode(Query);
result->commandType = CMD_UTILITY;
n->query = transformStmt(pstate, (Node*)n->query);
result->utilityStmt = (Node*)parseTree;
}
break;
/*------------------------
* Optimizable statements
*------------------------
*/
case T_AppendStmt:
result = transformInsertStmt(pstate, (AppendStmt *)parseTree);
break;
case T_DeleteStmt:
result = transformDeleteStmt(pstate, (DeleteStmt *)parseTree);
break;
case T_ReplaceStmt:
result = transformUpdateStmt(pstate, (ReplaceStmt *)parseTree);
break;
case T_CursorStmt:
result = transformCursorStmt(pstate, (CursorStmt *)parseTree);
break;
case T_RetrieveStmt:
result = transformSelectStmt(pstate, (RetrieveStmt *)parseTree);
break;
default:
/*
* other statments don't require any transformation-- just
* return the original parsetree
*/
result = makeNode(Query);
result->commandType = CMD_UTILITY;
result->utilityStmt = (Node*)parseTree;
break;
}
return result;
}
/*
* transformDeleteStmt -
* transforms a Delete Statement
*/
static Query *
transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
{
Query *qry = makeNode(Query);
qry->commandType = CMD_DELETE;
/* set up a range table */
makeRangeTable(pstate, stmt->relname, NULL);
qry->uniqueFlag = NULL;
/* fix where clause */
qry->qual = transformWhereClause(pstate, stmt->whereClause);
qry->rtable = pstate->p_rtable;
qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
/* make sure we don't have aggregates in the where clause */
if (pstate->p_numAgg > 0)
parseCheckAggregates(pstate, qry);
return (Query *)qry;
}
/*
* transformInsertStmt -
* transform an Insert Statement
*/
static Query *
transformInsertStmt(ParseState *pstate, AppendStmt *stmt)
{
Query *qry = makeNode(Query); /* make a new query tree */
qry->commandType = CMD_INSERT;
pstate->p_is_insert = true;
/* set up a range table */
makeRangeTable(pstate, stmt->relname, stmt->fromClause);
qry->uniqueFlag = NULL;
/* fix the target list */
pstate->p_insert_columns = makeTargetNames(pstate, stmt->cols);
qry->targetList = transformTargetList(pstate, stmt->targetList);
/* fix where clause */
qry->qual = transformWhereClause(pstate, stmt->whereClause);
/* now the range table will not change */
qry->rtable = pstate->p_rtable;
qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
if (pstate->p_numAgg > 0)
finalizeAggregates(pstate, qry);
return (Query *)qry;
}
/*
* transformIndexStmt -
* transforms the qualification of the index statement
*/
static Query *
transformIndexStmt(ParseState *pstate, IndexStmt *stmt)
{
Query* q;
q = makeNode(Query);
q->commandType = CMD_UTILITY;
/* take care of the where clause */
stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
stmt->rangetable = pstate->p_rtable;
q->utilityStmt = (Node*)stmt;
return q;
}
/*
* transformExtendStmt -
* transform the qualifications of the Extend Index Statement
*
*/
static Query *
transformExtendStmt(ParseState *pstate, ExtendStmt *stmt)
{
Query *q;
q = makeNode(Query);
q->commandType = CMD_UTILITY;
/* take care of the where clause */
stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
stmt->rangetable = pstate->p_rtable;
q->utilityStmt = (Node*)stmt;
return q;
}
/*
* transformRuleStmt -
* transform a Create Rule Statement. The actions is a list of parse
* trees which is transformed into a list of query trees.
*/
static Query *
transformRuleStmt(ParseState *pstate, RuleStmt *stmt)
{
Query *q;
List *actions;
q = makeNode(Query);
q->commandType = CMD_UTILITY;
actions = stmt->actions;
/*
* transform each statment, like parse_analyze()
*/
while (actions != NIL) {
/*
* NOTE: 'CURRENT' must always have a varno equal to 1 and 'NEW'
* equal to 2.
*/
addRangeTableEntry(pstate, stmt->object->relname, "*CURRENT*",
FALSE, FALSE, NULL);
addRangeTableEntry(pstate, stmt->object->relname, "*NEW*",
FALSE, FALSE, NULL);
pstate->p_last_resno = 1;
pstate->p_is_rule = true; /* for expand all */
pstate->p_numAgg = 0;
pstate->p_aggs = NULL;
lfirst(actions) = transformStmt(pstate, lfirst(actions));
actions = lnext(actions);
}
/* take care of the where clause */
stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
q->utilityStmt = (Node*)stmt;
return q;
}
/*
* transformSelectStmt -
* transforms a Select Statement
*
*/
static Query *
transformSelectStmt(ParseState *pstate, RetrieveStmt *stmt)
{
Query *qry = makeNode(Query);
qry->commandType = CMD_SELECT;
/* set up a range table */
makeRangeTable(pstate, NULL, stmt->fromClause);
qry->uniqueFlag = stmt->unique;
qry->into = stmt->into;
qry->isPortal = FALSE;
/* fix the target list */
qry->targetList = transformTargetList(pstate, stmt->targetList);
/* fix where clause */
qry->qual = transformWhereClause(pstate,stmt->whereClause);
/* check subselect clause */
if (stmt->selectClause)
elog(NOTICE,"UNION not yet supported; using first SELECT only",NULL);
/* check subselect clause */
if (stmt->havingClause)
elog(NOTICE,"HAVING not yet supported; ignore clause",NULL);
/* fix order clause */
qry->sortClause = transformSortClause(pstate,
stmt->sortClause,
qry->targetList,
qry->uniqueFlag);
/* fix group by clause */
qry->groupClause = transformGroupClause(pstate,
stmt->groupClause,
qry->targetList);
qry->rtable = pstate->p_rtable;
if (pstate->p_numAgg > 0)
finalizeAggregates(pstate, qry);
return (Query *)qry;
}
/*
* transformUpdateStmt -
* transforms an update statement
*
*/
static Query *
transformUpdateStmt(ParseState *pstate, ReplaceStmt *stmt)
{
Query *qry = makeNode(Query);
qry->commandType = CMD_UPDATE;
pstate->p_is_update = true;
/*
* the FROM clause is non-standard SQL syntax. We used to be able to
* do this with REPLACE in POSTQUEL so we keep the feature.
*/
makeRangeTable(pstate, stmt->relname, stmt->fromClause);
/* fix the target list */
qry->targetList = transformTargetList(pstate, stmt->targetList);
/* fix where clause */
qry->qual = transformWhereClause(pstate,stmt->whereClause);
qry->rtable = pstate->p_rtable;
qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
/* make sure we don't have aggregates in the where clause */
if (pstate->p_numAgg > 0)
parseCheckAggregates(pstate, qry);
return (Query *)qry;
}
/*
* transformCursorStmt -
* transform a Create Cursor Statement
*
*/
static Query *
transformCursorStmt(ParseState *pstate, CursorStmt *stmt)
{
Query *qry = makeNode(Query);
/*
* in the old days, a cursor statement is a 'retrieve into portal';
* If you change the following, make sure you also go through the code
* in various places that tests the kind of operation.
*/
qry->commandType = CMD_SELECT;
/* set up a range table */
makeRangeTable(pstate, NULL, stmt->fromClause);
qry->uniqueFlag = stmt->unique;
qry->into = stmt->portalname;
qry->isPortal = TRUE;
qry->isBinary = stmt->binary; /* internal portal */
/* fix the target list */
qry->targetList = transformTargetList(pstate, stmt->targetList);
/* fix where clause */
qry->qual = transformWhereClause(pstate,stmt->whereClause);
/* fix order clause */
qry->sortClause = transformSortClause(pstate,
stmt->sortClause,
qry->targetList,
qry->uniqueFlag);
/* fix group by clause */
qry->groupClause = transformGroupClause(pstate,
stmt->groupClause,
qry->targetList);
qry->rtable = pstate->p_rtable;
if (pstate->p_numAgg > 0)
finalizeAggregates(pstate, qry);
return (Query *)qry;
}
/*****************************************************************************
*
* Transform Exprs, Aggs, etc.
*
*****************************************************************************/
/*
* 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.
*/
static Node *
transformExpr(ParseState *pstate, Node *expr, int precedence)
{
Node *result = NULL;
if (expr==NULL)
return NULL;
switch(nodeTag(expr)) {
case T_Attr: {
Attr *att = (Attr *)expr;
Node *temp;
/* what if att.attrs == "*"?? */
temp = handleNestedDots(pstate, att, &pstate->p_last_resno);
if (att->indirection != NIL) {
List *idx = att->indirection;
while(idx!=NIL) {
A_Indices *ai = (A_Indices *)lfirst(idx);
Node *lexpr=NULL, *uexpr;
uexpr = transformExpr(pstate, ai->uidx, precedence); /* must exists */
if (exprType(uexpr) != INT4OID)
elog(WARN, "array index expressions must be int4's");
if (ai->lidx != NULL) {
lexpr = transformExpr(pstate, ai->lidx, precedence);
if (exprType(lexpr) != INT4OID)
elog(WARN, "array index expressions must be int4's");
}
#if 0
pfree(ai->uidx);
if (ai->lidx!=NULL) pfree(ai->lidx);
#endif
ai->lidx = lexpr;
ai->uidx = uexpr;
/* note we reuse the list of indices, make sure we don't free
them! Otherwise, make a new list here */
idx = lnext(idx);
}
result = (Node*)make_array_ref(temp, att->indirection);
}else {
result = temp;
}
break;
}
case T_A_Const: {
A_Const *con= (A_Const *)expr;
Value *val = &con->val;
if (con->typename != NULL) {
result = parser_typecast(val, con->typename, -1);
}else {
result = (Node *)make_const(val);
}
break;
}
case T_ParamNo: {
ParamNo *pno = (ParamNo *)expr;
Oid toid;
int paramno;
Param *param;
paramno = pno->number;
toid = param_type(paramno);
if (!OidIsValid(toid)) {
elog(WARN, "Parameter '$%d' is out of range",
paramno);
}
param = makeNode(Param);
param->paramkind = PARAM_NUM;
param->paramid = (AttrNumber) paramno;
param->paramname = "<unnamed>";
param->paramtype = (Oid)toid;
param->param_tlist = (List*) NULL;
result = (Node *)param;
break;
}
case T_A_Expr: {
A_Expr *a = (A_Expr *)expr;
switch(a->oper) {
case OP:
{
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
Node *rexpr = transformExpr(pstate, a->rexpr, precedence);
result = (Node *)make_op(a->opname, lexpr, rexpr);
}
break;
case ISNULL:
{
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
result = ParseFunc(pstate,
"nullvalue", lcons(lexpr, NIL),
&pstate->p_last_resno);
}
break;
case NOTNULL:
{
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
result = ParseFunc(pstate,
"nonnullvalue", lcons(lexpr, NIL),
&pstate->p_last_resno);
}
break;
case AND:
{
Expr *expr = makeNode(Expr);
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
Node *rexpr = transformExpr(pstate, a->rexpr, precedence);
if (exprType(lexpr) != BOOLOID)
elog(WARN,
"left-hand side of AND is type '%s', not bool",
tname(get_id_type(exprType(lexpr))));
if (exprType(rexpr) != BOOLOID)
elog(WARN,
"right-hand side of AND is type '%s', not bool",
tname(get_id_type(exprType(rexpr))));
expr->typeOid = BOOLOID;
expr->opType = AND_EXPR;
expr->args = makeList(lexpr, rexpr, -1);
result = (Node *)expr;
}
break;
case OR:
{
Expr *expr = makeNode(Expr);
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
Node *rexpr = transformExpr(pstate, a->rexpr, precedence);
if (exprType(lexpr) != BOOLOID)
elog(WARN,
"left-hand side of OR is type '%s', not bool",
tname(get_id_type(exprType(lexpr))));
if (exprType(rexpr) != BOOLOID)
elog(WARN,
"right-hand side of OR is type '%s', not bool",
tname(get_id_type(exprType(rexpr))));
expr->typeOid = BOOLOID;
expr->opType = OR_EXPR;
expr->args = makeList(lexpr, rexpr, -1);
result = (Node *)expr;
}
break;
case NOT:
{
Expr *expr = makeNode(Expr);
Node *rexpr = transformExpr(pstate, a->rexpr, precedence);
if (exprType(rexpr) != BOOLOID)
elog(WARN,
"argument to NOT is type '%s', not bool",
tname(get_id_type(exprType(rexpr))));
expr->typeOid = BOOLOID;
expr->opType = NOT_EXPR;
expr->args = makeList(rexpr, -1);
result = (Node *)expr;
}
break;
}
break;
}
case T_Ident: {
/* look for a column name or a relation name (the default behavior) */
result = transformIdent(pstate, expr, precedence);
break;
}
case T_FuncCall: {
FuncCall *fn = (FuncCall *)expr;
List *args;
/* transform the list of arguments */
foreach(args, fn->args)
lfirst(args) = transformExpr(pstate, (Node*)lfirst(args), precedence);
result = ParseFunc(pstate,
fn->funcname, fn->args, &pstate->p_last_resno);
break;
}
default:
/* should not reach here */
elog(WARN, "transformExpr: does not know how to transform %d\n",
nodeTag(expr));
break;
}
return result;
}
static Node *
transformIdent(ParseState *pstate, Node *expr, int precedence)
{
Ident *ident = (Ident*)expr;
RangeTblEntry *rte;
Node *column_result, *relation_result, *result;
column_result = relation_result = result = 0;
/* try to find the ident as a column */
if ((rte = colnameRangeTableEntry(pstate, ident->name)) != NULL) {
Attr *att = makeNode(Attr);
att->relname = rte->refname;
att->attrs = lcons(makeString(ident->name), NIL);
column_result =
(Node*)handleNestedDots(pstate, att, &pstate->p_last_resno);
}
/* try to find the ident as a relation */
if (refnameRangeTableEntry(pstate->p_rtable, ident->name) != NULL) {
ident->isRel = TRUE;
relation_result = (Node*)ident;
}
/* choose the right result based on the precedence */
if(precedence == EXPR_COLUMN_FIRST) {
if(column_result)
result = column_result;
else
result = relation_result;
} else {
if(relation_result)
result = relation_result;
else
result = column_result;
}
if(result == NULL)
elog(WARN, "attribute \"%s\" not found", ident->name);
return result;
}
/*****************************************************************************
*
* From Clause
*
*****************************************************************************/
/*
* parseFromClause -
* turns the table references specified in the from-clause into a
* range table. The range table may grow as we transform the expressions
* in the target list. (Note that this happens because in POSTQUEL, we
* allow references to relations not specified in the from-clause. We
* also allow that in our POST-SQL)
*
*/
static void
parseFromClause(ParseState *pstate, List *frmList)
{
List *fl;
foreach(fl, frmList)
{
RangeVar *r = lfirst(fl);
RelExpr *baserel = r->relExpr;
char *relname = baserel->relname;
char *refname = r->name;
RangeTblEntry *rte;
if (refname==NULL)
refname = relname;
/*
* marks this entry to indicate it comes from the FROM clause. In
* SQL, the target list can only refer to range variables specified
* in the from clause but we follow the more powerful POSTQUEL
* semantics and automatically generate the range variable if not
* specified. However there are times we need to know whether the
* entries are legitimate.
*
* eg. select * from foo f where f.x = 1; will generate wrong answer
* if we expand * to foo.x.
*/
rte = addRangeTableEntry(pstate, relname, refname, baserel->inh, TRUE,
baserel->timeRange);
}
}
/*
* makeRangeTable -
* make a range table with the specified relation (optional) and the
* from-clause.
*/
static void
makeRangeTable(ParseState *pstate, char *relname, List *frmList)
{
RangeTblEntry *rte;
parseFromClause(pstate, frmList);
if (relname == NULL)
return;
if (refnameRangeTablePosn(pstate->p_rtable, relname) < 1)
rte = addRangeTableEntry(pstate, relname, relname, FALSE, FALSE, NULL);
else
rte = refnameRangeTableEntry(pstate->p_rtable, relname);
pstate->p_target_rangetblentry = rte;
Assert(pstate->p_target_relation == NULL);
pstate->p_target_relation = heap_open(rte->relid);
Assert(pstate->p_target_relation != NULL);
/* will close relation later */
}
/*
* exprType -
* returns the Oid of the type of the expression. (Used for typechecking.)
*/
Oid
exprType(Node *expr)
{
Oid type = (Oid)0;
switch(nodeTag(expr)) {
case T_Func:
type = ((Func*)expr)->functype;
break;
case T_Iter:
type = ((Iter*)expr)->itertype;
break;
case T_Var:
type = ((Var*)expr)->vartype;
break;
case T_Expr:
type = ((Expr*)expr)->typeOid;
break;
case T_Const:
type = ((Const*)expr)->consttype;
break;
case T_ArrayRef:
type = ((ArrayRef*)expr)->refelemtype;
break;
case T_Aggreg:
type = ((Aggreg*)expr)->aggtype;
break;
case T_Param:
type = ((Param*)expr)->paramtype;
break;
case T_Ident:
/* is this right? */
type = UNKNOWNOID;
break;
default:
elog(WARN, "exprType: don't know how to get type for %d node",
nodeTag(expr));
break;
}
return type;
}
/*
* expandAllTables -
* turns '*' (in the target list) into a list of attributes (of all
* relations in the range table)
*/
static List *
expandAllTables(ParseState *pstate)
{
List *target= NIL;
List *legit_rtable=NIL;
List *rt, *rtable;
rtable = pstate->p_rtable;
if (pstate->p_is_rule) {
/*
* skip first two entries, "*new*" and "*current*"
*/
rtable = lnext(lnext(pstate->p_rtable));
}
/* this should not happen */
if (rtable==NULL)
elog(WARN, "cannot expand: null p_rtable");
/*
* go through the range table and make a list of range table entries
* which we will expand.
*/
foreach(rt, rtable) {
RangeTblEntry *rte = lfirst(rt);
/*
* we only expand those specify in the from clause. (This will
* also prevent us from using the wrong table in inserts: eg. tenk2
* in "insert into tenk2 select * from tenk1;")
*/
if (!rte->inFromCl)
continue;
legit_rtable = lappend(legit_rtable, rte);
}
foreach(rt, legit_rtable) {
RangeTblEntry *rte = lfirst(rt);
List *temp = target;
if(temp == NIL )
target = expandAll(pstate, rte->relname, rte->refname,
&pstate->p_last_resno);
else {
while (temp != NIL && lnext(temp) != NIL)
temp = lnext(temp);
lnext(temp) = expandAll(pstate, rte->relname, rte->refname,
&pstate->p_last_resno);
}
}
return target;
}
/*
* figureColname -
* if the name of the resulting column is not specified in the target
* list, we have to guess.
*
*/
static char *
figureColname(Node *expr, Node *resval)
{
switch (nodeTag(expr)) {
case T_Aggreg:
return (char*) /* XXX */
((Aggreg *)expr)->aggname;
case T_Expr:
if (((Expr*)expr)->opType == FUNC_EXPR) {
if (nodeTag(resval)==T_FuncCall)
return ((FuncCall*)resval)->funcname;
}
break;
default:
break;
}
return "?column?";
}
/*****************************************************************************
*
* Target list
*
*****************************************************************************/
/*
* makeTargetNames -
* generate a list of column names if not supplied or
* test supplied column names to make sure they are in target table
* (used exclusively for inserts)
*/
static List *
makeTargetNames(ParseState *pstate, List *cols)
{
List *tl=NULL;
/* Generate ResTarget if not supplied */
if (cols == NIL) {
int numcol;
int i;
AttributeTupleForm *attr = pstate->p_target_relation->rd_att->attrs;
numcol = pstate->p_target_relation->rd_rel->relnatts;
for(i=0; i < numcol; i++) {
Ident *id = makeNode(Ident);
id->name = palloc(NAMEDATALEN);
strNcpy(id->name, attr[i]->attname.data, NAMEDATALEN-1);
id->indirection = NIL;
id->isRel = false;
if (tl == NIL)
cols = tl = lcons(id, NIL);
else {
lnext(tl) = lcons(id,NIL);
tl = lnext(tl);
}
}
}
else
foreach(tl, cols)
/* elog on failure */
varattno(pstate->p_target_relation,((Ident *)lfirst(tl))->name);
return cols;
}
/*
* transformTargetList -
* turns a list of ResTarget's into a list of TargetEntry's
*/
static List *
transformTargetList(ParseState *pstate, List *targetlist)
{
List *p_target= NIL;
List *tail_p_target = NIL;
while(targetlist != NIL) {
ResTarget *res= (ResTarget *)lfirst(targetlist);
TargetEntry *tent = makeNode(TargetEntry);
switch(nodeTag(res->val)) {
case T_Ident: {
Node *expr;
Oid type_id;
int type_len;
char *identname;
char *resname;
identname = ((Ident*)res->val)->name;
handleTargetColname(pstate, &res->name, NULL, identname );
/* here we want to look for column names only, not relation */
/* names (even though they can be stored in Ident nodes, */
/* too) */
expr = transformIdent(pstate, (Node*)res->val, EXPR_COLUMN_FIRST);
type_id = exprType(expr);
type_len = tlen(get_id_type(type_id));
resname = (res->name) ? res->name : identname;
tent->resdom = makeResdom((AttrNumber)pstate->p_last_resno++,
(Oid)type_id,
(Size)type_len,
resname,
(Index)0,
(Oid)0,
0);
tent->expr = expr;
break;
}
case T_ParamNo:
case T_FuncCall:
case T_A_Const:
case T_A_Expr: {
Node *expr = transformExpr(pstate, (Node *)res->val, EXPR_COLUMN_FIRST);
handleTargetColname(pstate, &res->name, NULL, NULL);
/* note indirection has not been transformed */
if (pstate->p_is_insert && res->indirection!=NIL) {
/* this is an array assignment */
char *val;
char *str, *save_str;
List *elt;
int i = 0, ndims;
int lindx[MAXDIM], uindx[MAXDIM];
int resdomno;
Relation rd;
Value *constval;
if (exprType(expr) != UNKNOWNOID ||
!IsA(expr,Const))
elog(WARN, "yyparse: string constant expected");
val = (char *) textout((struct varlena *)
((Const *)expr)->constvalue);
str = save_str = (char*)palloc(strlen(val) + MAXDIM * 25 + 2);
foreach(elt, res->indirection) {
A_Indices *aind = (A_Indices *)lfirst(elt);
aind->uidx = transformExpr(pstate, aind->uidx, EXPR_COLUMN_FIRST);
if (!IsA(aind->uidx,Const))
elog(WARN,
"Array Index for Append should be a constant");
uindx[i] = ((Const *)aind->uidx)->constvalue;
if (aind->lidx!=NULL) {
aind->lidx = transformExpr(pstate, aind->lidx, EXPR_COLUMN_FIRST);
if (!IsA(aind->lidx,Const))
elog(WARN,
"Array Index for Append should be a constant");
lindx[i] = ((Const*)aind->lidx)->constvalue;
}else {
lindx[i] = 1;
}
if (lindx[i] > uindx[i])
elog(WARN, "yyparse: lower index cannot be greater than upper index");
sprintf(str, "[%d:%d]", lindx[i], uindx[i]);
str += strlen(str);
i++;
}
sprintf(str, "=%s", val);
rd = pstate->p_target_relation;
Assert(rd != NULL);
resdomno = varattno(rd, res->name);
ndims = att_attnelems(rd, resdomno);
if (i != ndims)
elog(WARN, "yyparse: array dimensions do not match");
constval = makeNode(Value);
constval->type = T_String;
constval->val.str = save_str;
tent = make_targetlist_expr(pstate, res->name,
(Node*)make_const(constval),
NULL);
pfree(save_str);
} else {
char *colname= res->name;
/* this is not an array assignment */
if (colname==NULL) {
/* if you're wondering why this is here, look at
* the yacc grammar for why a name can be missing. -ay
*/
colname = figureColname(expr, res->val);
}
if (res->indirection) {
List *ilist = res->indirection;
while (ilist!=NIL) {
A_Indices *ind = lfirst(ilist);
ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
ilist = lnext(ilist);
}
}
res->name = colname;
tent = make_targetlist_expr(pstate, res->name, expr,
res->indirection);
}
break;
}
case T_Attr: {
Oid type_id;
int type_len;
Attr *att = (Attr *)res->val;
Node *result;
char *attrname;
char *resname;
Resdom *resnode;
List *attrs = att->attrs;
/*
* Target item is a single '*', expand all tables
* (eg. SELECT * FROM emp)
*/
if (att->relname!=NULL && !strcmp(att->relname, "*")) {
if (tail_p_target == NIL)
p_target = tail_p_target = expandAllTables(pstate);
else
lnext(tail_p_target) = expandAllTables(pstate);
while(lnext(tail_p_target)!=NIL)
/* make sure we point to the last target entry */
tail_p_target = lnext(tail_p_target);
/*
* skip rest of while loop
*/
targetlist = lnext(targetlist);
continue;
}
/*
* Target item is relation.*, expand the table
* (eg. SELECT emp.*, dname FROM emp, dept)
*/
attrname = strVal(lfirst(att->attrs));
if (att->attrs!=NIL && !strcmp(attrname,"*")) {
/* tail_p_target is the target list we're building in the while
* loop. Make sure we fix it after appending more nodes.
*/
if (tail_p_target == NIL)
p_target = tail_p_target = expandAll(pstate, att->relname,
att->relname, &pstate->p_last_resno);
else
lnext(tail_p_target) =
expandAll(pstate, att->relname, att->relname,
&pstate->p_last_resno);
while(lnext(tail_p_target)!=NIL)
/* make sure we point to the last target entry */
tail_p_target = lnext(tail_p_target);
/*
* skip the rest of the while loop
*/
targetlist = lnext(targetlist);
continue;
}
/*
* Target item is fully specified: ie. relation.attribute
*/
result = handleNestedDots(pstate, att, &pstate->p_last_resno);
handleTargetColname(pstate, &res->name, att->relname, attrname);
if (att->indirection != NIL) {
List *ilist = att->indirection;
while (ilist!=NIL) {
A_Indices *ind = lfirst(ilist);
ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
ilist = lnext(ilist);
}
result = (Node*)make_array_ref(result, att->indirection);
}
type_id = exprType(result);
type_len = tlen(get_id_type(type_id));
/* move to last entry */
while(lnext(attrs)!=NIL)
attrs=lnext(attrs);
resname = (res->name) ? res->name : strVal(lfirst(attrs));
resnode = makeResdom((AttrNumber)pstate->p_last_resno++,
(Oid)type_id,
(Size)type_len,
resname,
(Index)0,
(Oid)0,
0);
tent->resdom = resnode;
tent->expr = result;
break;
}
default:
/* internal error */
elog(WARN,
"internal error: do not know how to transform targetlist");
break;
}
if (p_target == NIL) {
p_target = tail_p_target = lcons(tent, NIL);
}else {
lnext(tail_p_target) = lcons(tent, NIL);
tail_p_target = lnext(tail_p_target);
}
targetlist = lnext(targetlist);
}
return p_target;
}
/*
* make_targetlist_expr -
* make a TargetEntry from an expression
*
* arrayRef is a list of transformed A_Indices
*/
static TargetEntry *
make_targetlist_expr(ParseState *pstate,
char *colname,
Node *expr,
List *arrayRef)
{
Oid type_id, attrtype;
int type_len, attrlen;
int resdomno;
Relation rd;
bool attrisset;
TargetEntry *tent;
Resdom *resnode;
if (expr == NULL)
elog(WARN, "make_targetlist_expr: invalid use of NULL expression");
type_id = exprType(expr);
if (type_id == InvalidOid) {
type_len = 0;
} else
type_len = tlen(get_id_type(type_id));
/* I have no idea what the following does! */
/* It appears to process target columns that will be receiving results */
if (pstate->p_is_insert||pstate->p_is_update) {
/*
* append or replace query --
* append, replace work only on one relation,
* so multiple occurence of same resdomno is bogus
*/
rd = pstate->p_target_relation;
Assert(rd != NULL);
resdomno = varattno(rd,colname);
attrisset = varisset(rd,colname);
attrtype = att_typeid(rd,resdomno);
if ((arrayRef != NIL) && (lfirst(arrayRef) == NIL))
attrtype = GetArrayElementType(attrtype);
if (attrtype==BPCHAROID || attrtype==VARCHAROID) {
attrlen = rd->rd_att->attrs[resdomno-1]->attlen;
} else {
attrlen = tlen(get_id_type(attrtype));
}
#if 0
if(Input_is_string && Typecast_ok){
Datum val;
if (type_id == typeid(type("unknown"))){
val = (Datum)textout((struct varlena *)
((Const)lnext(expr))->constvalue);
}else{
val = ((Const)lnext(expr))->constvalue;
}
if (attrisset) {
lnext(expr) = makeConst(attrtype,
attrlen,
val,
false,
true,
true, /* is set */
false);
} else {
lnext(expr) =
makeConst(attrtype,
attrlen,
(Datum)fmgr(typeid_get_retinfunc(attrtype),
val,get_typelem(attrtype),-1),
false,
true /* Maybe correct-- 80% chance */,
false, /* is not a set */
false);
}
} else if((Typecast_ok) && (attrtype != type_id)){
lnext(expr) =
parser_typecast2(expr, get_id_type(attrtype));
} else
if (attrtype != type_id) {
if ((attrtype == INT2OID) && (type_id == INT4OID))
lfirst(expr) = lispInteger (INT2OID); do CASHOID too
else if ((attrtype == FLOAT4OID) && (type_id == FLOAT8OID))
lfirst(expr) = lispInteger (FLOAT4OID);
else
elog(WARN, "unequal type in tlist : %s \n",
colname));
}
Input_is_string = false;
Input_is_integer = false;
Typecast_ok = true;
#endif
if (attrtype != type_id) {
if (IsA(expr,Const)) {
/* try to cast the constant */
if (arrayRef && !(((A_Indices *)lfirst(arrayRef))->lidx)) {
/* updating a single item */
Oid typelem = get_typelem(attrtype);
expr = (Node*)parser_typecast2(expr,
type_id,
get_id_type(typelem),
attrlen);
} else
expr = (Node*)parser_typecast2(expr,
type_id,
get_id_type(attrtype),
attrlen);
} else {
/* currently, we can't handle casting of expressions */
elog(WARN, "parser: attribute '%s' is of type '%s' but expression is of type '%s'",
colname,
get_id_typname(attrtype),
get_id_typname(type_id));
}
}
if (arrayRef != NIL) {
Expr *target_expr;
Attr *att = makeNode(Attr);
List *ar = arrayRef;
List *upperIndexpr = NIL;
List *lowerIndexpr = NIL;
att->relname = pstrdup(RelationGetRelationName(rd)->data);
att->attrs = lcons(makeString(colname), NIL);
target_expr = (Expr*)handleNestedDots(pstate, att,
&pstate->p_last_resno);
while(ar!=NIL) {
A_Indices *ind = lfirst(ar);
if (lowerIndexpr || (!upperIndexpr && ind->lidx)) {
/* XXX assume all lowerIndexpr is non-null in
* this case
*/
lowerIndexpr = lappend(lowerIndexpr, ind->lidx);
}
upperIndexpr = lappend(upperIndexpr, ind->uidx);
ar = lnext(ar);
}
expr = (Node*)make_array_set(target_expr,
upperIndexpr,
lowerIndexpr,
(Expr*)expr);
attrtype = att_typeid(rd,resdomno);
attrlen = tlen(get_id_type(attrtype));
}
} else {
resdomno = pstate->p_last_resno++;
attrtype = type_id;
attrlen = type_len;
}
tent = makeNode(TargetEntry);
resnode = makeResdom((AttrNumber)resdomno,
(Oid) attrtype,
(Size) attrlen,
colname,
(Index)0,
(Oid)0,
0);
tent->resdom = resnode;
tent->expr = expr;
return tent;
}
/*****************************************************************************
*
* Where Clause
*
*****************************************************************************/
/*
* transformWhereClause -
* transforms the qualification and make sure it is of type Boolean
*
*/
static Node *
transformWhereClause(ParseState *pstate, Node *a_expr)
{
Node *qual;
if (a_expr == NULL)
return (Node *)NULL; /* no qualifiers */
inWhereClause = true;
qual = transformExpr(pstate, a_expr, EXPR_COLUMN_FIRST);
inWhereClause = false;
if (exprType(qual) != BOOLOID) {
elog(WARN,
"where clause must return type bool, not %s",
tname(get_id_type(exprType(qual))));
}
return qual;
}
/*****************************************************************************
*
* Sort Clause
*
*****************************************************************************/
/*
* find_targetlist_entry -
* returns the Resdom in the target list matching the specified varname
* and range
*
*/
static TargetEntry *
find_targetlist_entry(ParseState *pstate, SortGroupBy *sortgroupby, List *tlist)
{
List *i;
int real_rtable_pos = 0, target_pos = 0;
TargetEntry *target_result = NULL;
if(sortgroupby->range)
real_rtable_pos = refnameRangeTablePosn(pstate->p_rtable,
sortgroupby->range);
foreach(i, tlist) {
TargetEntry *target = (TargetEntry *)lfirst(i);
Resdom *resnode = target->resdom;
Var *var = (Var *)target->expr;
char *resname = resnode->resname;
int test_rtable_pos = var->varno;
#ifdef PARSEDEBUG
printf("find_targetlist_entry- target name is %s, position %d, resno %d\n",
(sortgroupby->name? sortgroupby->name: "(null)"), target_pos+1, sortgroupby->resno);
#endif
if (!sortgroupby->name) {
if (sortgroupby->resno == ++target_pos) {
target_result = target;
break;
}
}
else {
if (!strcmp(resname, sortgroupby->name)) {
if(sortgroupby->range) {
if(real_rtable_pos == test_rtable_pos) {
if (target_result != NULL)
elog(WARN, "Order/Group By %s is ambiguous", sortgroupby->name);
else target_result = target;
}
}
else {
if (target_result != NULL)
elog(WARN, "Order/Group By %s is ambiguous", sortgroupby->name);
else target_result = target;
}
}
}
}
return target_result;
}
static Oid
any_ordering_op(int restype)
{
Operator order_op;
Oid order_opid;
order_op = oper("<",restype,restype,false);
order_opid = oprid(order_op);
return order_opid;
}
/*
* transformGroupClause -
* transform a Group By clause
*
*/
static List *
transformGroupClause(ParseState *pstate, List *grouplist, List *targetlist)
{
List *glist = NIL, *gl = NIL;
while (grouplist != NIL) {
GroupClause *grpcl = makeNode(GroupClause);
TargetEntry *restarget;
Resdom *resdom;
restarget = find_targetlist_entry(pstate, lfirst(grouplist), targetlist);
if (restarget == NULL)
elog(WARN,"The field being grouped by must appear in the target list");
grpcl->entry = restarget;
resdom = restarget->resdom;
grpcl->grpOpoid = oprid(oper("<",
resdom->restype,
resdom->restype,false));
if (glist == NIL)
gl = glist = lcons(grpcl, NIL);
else {
lnext(gl) = lcons(grpcl, NIL);
gl = lnext(gl);
}
grouplist = lnext(grouplist);
}
return glist;
}
/*
* transformSortClause -
* transform an Order By clause
*
*/
static List *
transformSortClause(ParseState *pstate,
List *orderlist, List *targetlist,
char* uniqueFlag)
{
List *sortlist = NIL;
List *s = NIL, *i;
while(orderlist != NIL) {
SortGroupBy *sortby = lfirst(orderlist);
SortClause *sortcl = makeNode(SortClause);
TargetEntry *restarget;
Resdom *resdom;
restarget = find_targetlist_entry(pstate, sortby, targetlist);
if (restarget == NULL)
elog(WARN,"The field being ordered by must appear in the target list");
sortcl->resdom = resdom = restarget->resdom;
sortcl->opoid = oprid(oper(sortby->useOp,
resdom->restype,
resdom->restype,false));
if (sortlist == NIL) {
s = sortlist = lcons(sortcl, NIL);
}else {
lnext(s) = lcons(sortcl, NIL);
s = lnext(s);
}
orderlist = lnext(orderlist);
}
if (uniqueFlag) {
if (uniqueFlag[0] == '*') {
/* concatenate all elements from target list
that are not already in the sortby list */
foreach (i,targetlist) {
TargetEntry *tlelt = (TargetEntry *)lfirst(i);
s = sortlist;
while(s != NIL) {
SortClause *sortcl = lfirst(s);
if (sortcl->resdom==tlelt->resdom)
break;
s = lnext(s);
}
if (s == NIL) {
/* not a member of the sortclauses yet */
SortClause *sortcl = makeNode(SortClause);
sortcl->resdom = tlelt->resdom;
sortcl->opoid = any_ordering_op(tlelt->resdom->restype);
sortlist = lappend(sortlist, sortcl);
}
}
}
else {
TargetEntry *tlelt = NULL;
char* uniqueAttrName = uniqueFlag;
/* only create sort clause with the specified unique attribute */
foreach (i, targetlist) {
tlelt = (TargetEntry*)lfirst(i);
if (strcmp(tlelt->resdom->resname, uniqueAttrName) == 0)
break;
}
if (i == NIL) {
elog(WARN, "The field specified in the UNIQUE ON clause is not in the targetlist");
}
s = sortlist;
foreach (s, sortlist) {
SortClause *sortcl = lfirst(s);
if (sortcl->resdom == tlelt->resdom)
break;
}
if (s == NIL) {
/* not a member of the sortclauses yet */
SortClause *sortcl = makeNode(SortClause);
sortcl->resdom = tlelt->resdom;
sortcl->opoid = any_ordering_op(tlelt->resdom->restype);
sortlist = lappend(sortlist, sortcl);
}
}
}
return sortlist;
}
/*
** HandleNestedDots --
** Given a nested dot expression (i.e. (relation func ... attr), build up
** a tree with of Iter and Func nodes.
*/
static Node*
handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno)
{
List *mutator_iter;
Node *retval = NULL;
if (attr->paramNo != NULL) {
Param *param = (Param *)transformExpr(pstate, (Node*)attr->paramNo, EXPR_RELATION_FIRST);
retval =
ParseFunc(pstate, strVal(lfirst(attr->attrs)),
lcons(param, NIL),
curr_resno);
} else {
Ident *ident = makeNode(Ident);
ident->name = attr->relname;
ident->isRel = TRUE;
retval =
ParseFunc(pstate, strVal(lfirst(attr->attrs)),
lcons(ident, NIL),
curr_resno);
}
foreach (mutator_iter, lnext(attr->attrs)) {
retval = ParseFunc(pstate,strVal(lfirst(mutator_iter)),
lcons(retval, NIL),
curr_resno);
}
return(retval);
}
/*
** make_arguments --
** Given the number and types of arguments to a function, and the
** actual arguments and argument types, do the necessary typecasting.
*/
static void
make_arguments(int nargs,
List *fargs,
Oid *input_typeids,
Oid *function_typeids)
{
/*
* there are two ways an input typeid can differ from a function typeid :
* either the input type inherits the function type, so no typecasting is
* necessary, or the input type can be typecast into the function type.
* right now, we only typecast unknowns, and that is all we check for.
*/
List *current_fargs;
int i;
for (i=0, current_fargs = fargs;
i<nargs;
i++, current_fargs = lnext(current_fargs)) {
if (input_typeids[i] == UNKNOWNOID && function_typeids[i] != InvalidOid) {
lfirst(current_fargs) =
parser_typecast2(lfirst(current_fargs),
input_typeids[i],
get_id_type(function_typeids[i]),
-1);
}
}
}
/*
** setup_tlist --
** Build a tlist that says which attribute to project to.
** This routine is called by ParseFunc() to set up a target list
** on a tuple parameter or return value. Due to a bug in 4.0,
** it's not possible to refer to system attributes in this case.
*/
static List *
setup_tlist(char *attname, Oid relid)
{
TargetEntry *tle;
Resdom *resnode;
Var *varnode;
Oid typeid;
int attno;
attno = get_attnum(relid, attname);
if (attno < 0)
elog(WARN, "cannot reference attribute %s of tuple params/return values for functions", attname);
typeid = find_atttype(relid, attname);
resnode = makeResdom(1,
typeid,
tlen(get_id_type(typeid)),
get_attname(relid, attno),
0,
(Oid)0,
0);
varnode = makeVar(-1, attno, typeid, -1, attno);
tle = makeNode(TargetEntry);
tle->resdom = resnode;
tle->expr = (Node*)varnode;
return (lcons(tle, NIL));
}
/*
** setup_base_tlist --
** Build a tlist that extracts a base type from the tuple
** returned by the executor.
*/
static List *
setup_base_tlist(Oid typeid)
{
TargetEntry *tle;
Resdom *resnode;
Var *varnode;
resnode = makeResdom(1,
typeid,
tlen(get_id_type(typeid)),
"<noname>",
0,
(Oid)0,
0);
varnode = makeVar(-1, 1, typeid, -1, 1);
tle = makeNode(TargetEntry);
tle->resdom = resnode;
tle->expr = (Node*)varnode;
return (lcons(tle, NIL));
}
/*
* ParseComplexProjection -
* handles function calls with a single argument that is of complex type.
* This routine returns NULL if it can't handle the projection (eg. sets).
*/
static Node *
ParseComplexProjection(ParseState *pstate,
char *funcname,
Node *first_arg,
bool *attisset)
{
Oid argtype;
Oid argrelid;
Name relname;
Relation rd;
Oid relid;
int attnum;
switch (nodeTag(first_arg)) {
case T_Iter:
{
Func *func;
Iter *iter;
iter = (Iter*)first_arg;
func = (Func *)((Expr*)iter->iterexpr)->oper;
argtype = funcid_get_rettype(func->funcid);
argrelid = typeid_get_relid(argtype);
if (argrelid &&
((attnum = get_attnum(argrelid, funcname))
!= InvalidAttrNumber)) {
/* the argument is a function returning a tuple, so funcname
may be a projection */
/* add a tlist to the func node and return the Iter */
rd = heap_openr(tname(get_id_type(argtype)));
if (RelationIsValid(rd)) {
relid = RelationGetRelationId(rd);
relname = RelationGetRelationName(rd);
heap_close(rd);
}
if (RelationIsValid(rd)) {
func->func_tlist =
setup_tlist(funcname, argrelid);
iter->itertype = att_typeid(rd,attnum);
return ((Node*)iter);
}else {
elog(WARN,
"Function %s has bad returntype %d",
funcname, argtype);
}
}else {
/* drop through */
;
}
break;
}
case T_Var:
{
/*
* The argument is a set, so this is either a projection
* or a function call on this set.
*/
*attisset = true;
break;
}
case T_Expr:
{
Expr *expr = (Expr*)first_arg;
Func *funcnode;
if (expr->opType != FUNC_EXPR)
break;
funcnode= (Func *) expr->oper;
argtype = funcid_get_rettype(funcnode->funcid);
argrelid = typeid_get_relid(argtype);
/*
* the argument is a function returning a tuple, so funcname
* may be a projection
*/
if (argrelid &&
(attnum = get_attnum(argrelid, funcname))
!= InvalidAttrNumber) {
/* add a tlist to the func node */
rd = heap_openr(tname(get_id_type(argtype)));
if (RelationIsValid(rd)) {
relid = RelationGetRelationId(rd);
relname = RelationGetRelationName(rd);
heap_close(rd);
}
if (RelationIsValid(rd)) {
Expr *newexpr;
funcnode->func_tlist =
setup_tlist(funcname, argrelid);
funcnode->functype = att_typeid(rd,attnum);
newexpr = makeNode(Expr);
newexpr->typeOid = funcnode->functype;
newexpr->opType = FUNC_EXPR;
newexpr->oper = (Node *)funcnode;
newexpr->args = lcons(first_arg, NIL);
return ((Node*)newexpr);
}
}
elog(WARN, "Function %s has bad returntype %d",
funcname, argtype);
break;
}
case T_Param:
{
Param *param = (Param*)first_arg;
/*
* If the Param is a complex type, this could be a projection
*/
rd = heap_openr(tname(get_id_type(param->paramtype)));
if (RelationIsValid(rd)) {
relid = RelationGetRelationId(rd);
relname = RelationGetRelationName(rd);
heap_close(rd);
}
if (RelationIsValid(rd) &&
(attnum = get_attnum(relid, funcname))
!= InvalidAttrNumber) {
param->paramtype = att_typeid(rd, attnum);
param->param_tlist = setup_tlist(funcname, relid);
return ((Node*)param);
}
break;
}
default:
break;
}
return NULL;
}
static Node *
ParseFunc(ParseState *pstate, char *funcname, List *fargs, int *curr_resno)
{
Oid rettype = (Oid)0;
Oid argrelid = (Oid)0;
Oid funcid = (Oid)0;
List *i = NIL;
Node *first_arg= NULL;
char *relname = NULL;
char *refname = NULL;
Relation rd;
Oid relid;
int nargs;
Func *funcnode;
Oid oid_array[8];
Oid *true_oid_array;
Node *retval;
bool retset;
bool exists;
bool attisset = false;
Oid toid = (Oid)0;
Expr *expr;
if (fargs) {
first_arg = lfirst(fargs);
if (first_arg == NULL)
elog (WARN,"function %s does not allow NULL input",funcname);
}
/*
** check for projection methods: if function takes one argument, and
** that argument is a relation, param, or PQ function returning a complex
** type, then the function could be a projection.
*/
if (length(fargs) == 1) {
if (nodeTag(first_arg)==T_Ident && ((Ident*)first_arg)->isRel) {
RangeTblEntry *rte;
Ident *ident = (Ident*)first_arg;
/*
* first arg is a relation. This could be a projection.
*/
refname = ident->name;
rte = refnameRangeTableEntry(pstate->p_rtable, refname);
if (rte == NULL)
rte = addRangeTableEntry(pstate, refname, refname, FALSE, FALSE,NULL);
relname = rte->relname;
relid = rte->relid;
/* If the attr isn't a set, just make a var for it. If
* it is a set, treat it like a function and drop through.
*/
if (get_attnum(relid, funcname) != InvalidAttrNumber) {
Oid dummyTypeId;
return
((Node*)make_var(pstate,
refname,
funcname,
&dummyTypeId));
} else {
/* drop through - attr is a set */
;
}
} else if (ISCOMPLEX(exprType(first_arg))) {
/*
* Attempt to handle projection of a complex argument. If
* ParseComplexProjection can't handle the projection, we
* have to keep going.
*/
retval = ParseComplexProjection(pstate,
funcname,
first_arg,
&attisset);
if (attisset) {
toid = exprType(first_arg);
rd = heap_openr(tname(get_id_type(toid)));
if (RelationIsValid(rd)) {
relname = RelationGetRelationName(rd)->data;
heap_close(rd);
} else
elog(WARN,
"Type %s is not a relation type",
tname(get_id_type(toid)));
argrelid = typeid_get_relid(toid);
/* A projection contains either an attribute name or the
* "*".
*/
if ((get_attnum(argrelid, funcname) == InvalidAttrNumber)
&& strcmp(funcname, "*")) {
elog(WARN, "Functions on sets are not yet supported");
}
}
if (retval)
return retval;
} else {
/*
* Parsing aggregates.
*/
Oid basetype;
/* the aggregate count is a special case,
ignore its base type. Treat it as zero */
if (strcmp(funcname, "count") == 0)
basetype = 0;
else
basetype = exprType(lfirst(fargs));
if (SearchSysCacheTuple(AGGNAME,
PointerGetDatum(funcname),
ObjectIdGetDatum(basetype),
0, 0)) {
Aggreg *aggreg = ParseAgg(funcname, basetype, lfirst(fargs));
AddAggToParseState(pstate, aggreg);
return (Node*)aggreg;
}
}
}
/*
** If we dropped through to here it's really a function (or a set, which
** is implemented as a function.)
** extract arg type info and transform relation name arguments into
** varnodes of the appropriate form.
*/
memset(&oid_array[0], 0, 8 * sizeof(Oid));
nargs=0;
foreach ( i , fargs ) {
int vnum;
RangeTblEntry *rte;
Node *pair = lfirst(i);
if (nodeTag(pair)==T_Ident && ((Ident*)pair)->isRel) {
/*
* a relation
*/
refname = ((Ident*)pair)->name;
rte = refnameRangeTableEntry(pstate->p_rtable, refname);
if (rte == NULL)
rte = addRangeTableEntry(pstate, refname, refname,
FALSE, FALSE, NULL);
relname = rte->relname;
vnum = refnameRangeTablePosn (pstate->p_rtable, rte->refname);
/*
* for func(relname), the param to the function
* is the tuple under consideration. we build a special
* VarNode to reflect this -- it has varno set to the
* correct range table entry, but has varattno == 0 to
* signal that the whole tuple is the argument.
*/
toid = typeid(type(relname));
/* replace it in the arg list */
lfirst(fargs) =
makeVar(vnum, 0, toid, vnum, 0);
}else if (!attisset) { /* set functions don't have parameters */
/* any functiona args which are typed "unknown", but aren't
constants, we don't know what to do with, because we
can't cast them - jolly*/
if (exprType(pair) == UNKNOWNOID &&
!IsA(pair, Const))
{
elog(WARN, "ParseFunc: no function named %s that takes in an unknown type as argument #%d", funcname, nargs);
}
else
toid = exprType(pair);
}
oid_array[nargs++] = toid;
}
/*
* func_get_detail looks up the function in the catalogs, does
* disambiguation for polymorphic functions, handles inheritance,
* and returns the funcid and type and set or singleton status of
* the function's return value. it also returns the true argument
* types to the function. if func_get_detail returns true,
* the function exists. otherwise, there was an error.
*/
if (attisset) { /* we know all of these fields already */
/* We create a funcnode with a placeholder function SetEval.
* SetEval() never actually gets executed. When the function
* evaluation routines see it, they use the funcid projected
* out from the relation as the actual function to call.
* Example: retrieve (emp.mgr.name)
* The plan for this will scan the emp relation, projecting
* out the mgr attribute, which is a funcid. This function
* is then called (instead of SetEval) and "name" is projected
* from its result.
*/
funcid = SetEvalRegProcedure;
rettype = toid;
retset = true;
true_oid_array = oid_array;
exists = true;
} else {
exists = func_get_detail(funcname, nargs, oid_array, &funcid,
&rettype, &retset, &true_oid_array);
}
if (!exists)
elog(WARN, "no such attribute or function %s", funcname);
/* got it */
funcnode = makeNode(Func);
funcnode->funcid = funcid;
funcnode->functype = rettype;
funcnode->funcisindex = false;
funcnode->funcsize = 0;
funcnode->func_fcache = NULL;
funcnode->func_tlist = NIL;
funcnode->func_planlist = NIL;
/* perform the necessary typecasting */
make_arguments(nargs, fargs, oid_array, true_oid_array);
/*
* for functions returning base types, we want to project out the
* return value. set up a target list to do that. the executor
* will ignore these for c functions, and do the right thing for
* postquel functions.
*/
if (typeid_get_relid(rettype) == InvalidOid)
funcnode->func_tlist = setup_base_tlist(rettype);
/* For sets, we want to make a targetlist to project out this
* attribute of the set tuples.
*/
if (attisset) {
if (!strcmp(funcname, "*")) {
funcnode->func_tlist =
expandAll(pstate, relname, refname, curr_resno);
} else {
funcnode->func_tlist = setup_tlist(funcname,argrelid);
rettype = find_atttype(argrelid, funcname);
}
}
/*
* Sequence handling.
*/
if ( funcid == SeqNextValueRegProcedure ||
funcid == SeqCurrValueRegProcedure )
{
Const *seq;
char *seqrel;
int32 aclcheck_result = -1;
Assert ( length(fargs) == 1 );
seq = (Const*)lfirst(fargs);
if ( ! IsA ((Node*)seq, Const) )
elog (WARN, "%s: only constant sequence names are acceptable", funcname);
seqrel = textout ((struct varlena *) (seq->constvalue));
if ( ( aclcheck_result = pg_aclcheck (seqrel, GetPgUserName(),
((funcid == SeqNextValueRegProcedure) ? ACL_WR : ACL_RD)) )
!= ACLCHECK_OK )
elog (WARN, "%s.%s: %s",
seqrel, funcname, aclcheck_error_strings[aclcheck_result]);
pfree (seqrel);
if ( funcid == SeqNextValueRegProcedure && inWhereClause )
elog (WARN, "nextval of a sequence in WHERE disallowed");
}
expr = makeNode(Expr);
expr->typeOid = rettype;
expr->opType = FUNC_EXPR;
expr->oper = (Node *)funcnode;
expr->args = fargs;
retval = (Node*)expr;
/*
* if the function returns a set of values, then we need to iterate
* over all the returned values in the executor, so we stick an
* iter node here. if it returns a singleton, then we don't need
* the iter node.
*/
if (retset) {
Iter *iter = makeNode(Iter);
iter->itertype = rettype;
iter->iterexpr = retval;
retval = (Node*)iter;
}
return(retval);
}
/*****************************************************************************
*
*****************************************************************************/
/*
* AddAggToParseState -
* add the aggregate to the list of unique aggregates in pstate.
*
* SIDE EFFECT: aggno in target list entry will be modified
*/
static void
AddAggToParseState(ParseState *pstate, Aggreg *aggreg)
{
List *ag;
int i;
/*
* see if we have the aggregate already (we only need to record
* the aggregate once)
*/
i = 0;
foreach(ag, pstate->p_aggs) {
Aggreg *a = lfirst(ag);
if (!strcmp(a->aggname, aggreg->aggname) &&
equal(a->target, aggreg->target)) {
/* fill in the aggno and we're done */
aggreg->aggno = i;
return;
}
i++;
}
/* not found, new aggregate */
aggreg->aggno = i;
pstate->p_numAgg++;
pstate->p_aggs = lappend(pstate->p_aggs, aggreg);
return;
}
/*
* finalizeAggregates -
* fill in qry_aggs from pstate. Also checks to make sure that aggregates
* are used in the proper place.
*/
static void
finalizeAggregates(ParseState *pstate, Query *qry)
{
List *l;
int i;
parseCheckAggregates(pstate, qry);
qry->qry_numAgg = pstate->p_numAgg;
qry->qry_aggs =
(Aggreg **)palloc(sizeof(Aggreg *) * qry->qry_numAgg);
i = 0;
foreach(l, pstate->p_aggs)
qry->qry_aggs[i++] = (Aggreg*)lfirst(l);
}
/*
* contain_agg_clause--
* Recursively find aggreg nodes from a clause.
*
* Returns true if any aggregate found.
*/
static bool
contain_agg_clause(Node *clause)
{
if (clause==NULL)
return FALSE;
else if (IsA(clause,Aggreg))
return TRUE;
else if (IsA(clause,Iter))
return contain_agg_clause(((Iter*)clause)->iterexpr);
else if (single_node(clause))
return FALSE;
else if (or_clause(clause)) {
List *temp;
foreach (temp, ((Expr*)clause)->args)
if (contain_agg_clause(lfirst(temp)))
return TRUE;
return FALSE;
} else if (is_funcclause (clause)) {
List *temp;
foreach(temp, ((Expr *)clause)->args)
if (contain_agg_clause(lfirst(temp)))
return TRUE;
return FALSE;
} else if (IsA(clause,ArrayRef)) {
List *temp;
foreach(temp, ((ArrayRef*)clause)->refupperindexpr)
if (contain_agg_clause(lfirst(temp)))
return TRUE;
foreach(temp, ((ArrayRef*)clause)->reflowerindexpr)
if (contain_agg_clause(lfirst(temp)))
return TRUE;
if (contain_agg_clause(((ArrayRef*)clause)->refexpr))
return TRUE;
if (contain_agg_clause(((ArrayRef*)clause)->refassgnexpr))
return TRUE;
return FALSE;
} else if (not_clause(clause))
return contain_agg_clause((Node*)get_notclausearg((Expr*)clause));
else if (is_opclause(clause))
return (contain_agg_clause((Node*)get_leftop((Expr*)clause)) ||
contain_agg_clause((Node*)get_rightop((Expr*)clause)));
return FALSE;
}
/*
* exprIsAggOrGroupCol -
* returns true if the expression does not contain non-group columns.
*/
static bool
exprIsAggOrGroupCol(Node *expr, List *groupClause)
{
List *gl;
if ( expr == NULL || IsA (expr, Const) ||
IsA (expr, Param) || IsA (expr, Aggreg) )
return TRUE;
foreach (gl, groupClause)
{
GroupClause *grpcl = lfirst(gl);
if ( equal (expr, grpcl->entry->expr) )
return TRUE;
}
if ( IsA (expr, Expr) )
{
List *temp;
foreach (temp, ((Expr*)expr)->args)
if (!exprIsAggOrGroupCol(lfirst(temp),groupClause))
return FALSE;
return TRUE;
}
return FALSE;
}
/*
* tleIsAggOrGroupCol -
* returns true if the TargetEntry is Agg or GroupCol.
*/
static bool
tleIsAggOrGroupCol(TargetEntry *tle, List *groupClause)
{
Node *expr = tle->expr;
List *gl;
if ( expr == NULL || IsA (expr, Const) || IsA (expr, Param) )
return TRUE;
foreach (gl, groupClause)
{
GroupClause *grpcl = lfirst(gl);
if ( tle->resdom->resno == grpcl->entry->resdom->resno )
{
if ( contain_agg_clause ((Node*) expr) )
elog (WARN, "parser: aggregates not allowed in GROUP BY clause");
return TRUE;
}
}
if ( IsA (expr, Aggreg) )
return TRUE;
if ( IsA (expr, Expr) )
{
List *temp;
foreach (temp, ((Expr*)expr)->args)
if (!exprIsAggOrGroupCol(lfirst(temp),groupClause))
return FALSE;
return TRUE;
}
return FALSE;
}
/*
* parseCheckAggregates -
* this should really be done earlier but the current grammar
* cannot differentiate functions from aggregates. So we have do check
* here when the target list and the qualifications are finalized.
*/
static void
parseCheckAggregates(ParseState *pstate, Query *qry)
{
List *tl;
Assert(pstate->p_numAgg > 0);
/*
* aggregates never appear in WHERE clauses. (we have to check where
* clause first because if there is an aggregate, the check for
* non-group column in target list may fail.)
*/
if (contain_agg_clause(qry->qual))
elog(WARN, "parser: aggregates not allowed in WHERE clause");
/*
* the target list can only contain aggregates, group columns and
* functions thereof.
*/
foreach (tl, qry->targetList) {
TargetEntry *tle = lfirst(tl);
if (!tleIsAggOrGroupCol(tle, qry->groupClause))
elog(WARN,
"parser: illegal use of aggregates or non-group column in target list");
}
/*
* the expression specified in the HAVING clause has the same restriction
* as those in the target list.
*/
/*
* Need to change here when we get HAVING works. Currently
* qry->havingQual is NULL. - vadim 04/05/97
if (!exprIsAggOrGroupCol(qry->havingQual, qry->groupClause))
elog(WARN,
"parser: illegal use of aggregates or non-group column in HAVING clause");
*/
return;
}
Reference in New Issue View Git Blame Copy Permalink