rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/backend/optimizer/util/clauses.c

747 lines
17 KiB
C
Raw Blame History

/*-------------------------------------------------------------------------
*
* clauses.c--
* routines to manipulate qualification clauses
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.2 1996/07/25 20:36:46 scrappy Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
* Andrew Yu Nov 3, 1994 clause.c and clauses.c combined
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "nodes/pg_list.h"
#include "nodes/primnodes.h"
#include "nodes/relation.h"
#include "nodes/parsenodes.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "catalog/pg_aggregate.h"
#include "utils/elog.h"
#include "utils/syscache.h"
#include "utils/lsyscache.h"
#include "optimizer/clauses.h"
#include "optimizer/internal.h"
#include "optimizer/var.h"
Expr *
make_clause(int type, Node *oper, List *args)
{
if (type == AND_EXPR || type == OR_EXPR || type == NOT_EXPR ||
type == OP_EXPR || type == FUNC_EXPR) {
Expr *expr = makeNode(Expr);
/*
* assume type checking already done and we don't need the type of
* the expr any more.
*/
expr->typeOid = InvalidOid;
expr->opType = type;
expr->oper = oper; /* ignored for AND, OR, NOT */
expr->args = args;
return expr;
}else {
/* will this ever happen? translated from lispy C code - ay 10/94 */
return((Expr*)args);
}
}
/*****************************************************************************
* OPERATOR clause functions
*****************************************************************************/
/*
* is_opclause--
*
* Returns t iff the clause is an operator clause:
* (op expr expr) or (op expr).
*
* [historical note: is_clause has the exact functionality and is used
* throughout the code. They're renamed to is_opclause for clarity.
* - ay 10/94.]
*/
bool
is_opclause(Node *clause)
{
return
(clause!=NULL &&
nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==OP_EXPR);
}
/*
* make_opclause--
* Creates a clause given its operator left operand and right
* operand (if it is non-null).
*
*/
Expr *
make_opclause(Oper *op, Var *leftop, Var *rightop)
{
Expr *expr = makeNode(Expr);
expr->typeOid = InvalidOid; /* assume type checking done */
expr->opType = OP_EXPR;
expr->oper = (Node*)op;
expr->args = makeList(leftop, rightop, -1);
return expr;
}
/*
* get_leftop--
*
* Returns the left operand of a clause of the form (op expr expr)
* or (op expr)
* NB: it is assumed (for now) that all expr must be Var nodes
*/
Var *
get_leftop(Expr *clause)
{
if (clause->args!=NULL)
return(lfirst(clause->args));
else
return NULL;
}
/*
* get_rightop
*
* Returns the right operand in a clause of the form (op expr expr).
*
*/
Var *
get_rightop(Expr *clause)
{
if (clause->args!=NULL && lnext(clause->args)!=NULL)
return (lfirst(lnext(clause->args)));
else
return NULL;
}
/*****************************************************************************
* AGG clause functions
*****************************************************************************/
bool
agg_clause(Node *clause)
{
return
(clause!=NULL && nodeTag(clause)==T_Aggreg);
}
/*****************************************************************************
* FUNC clause functions
*****************************************************************************/
/*
* is_funcclause--
*
* Returns t iff the clause is a function clause: (func { expr }).
*
*/
bool
is_funcclause(Node *clause)
{
return
(clause!=NULL &&
nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==FUNC_EXPR);
}
/*
* make_funcclause--
*
* Creates a function clause given the FUNC node and the functional
* arguments.
*
*/
Expr *
make_funcclause(Func *func, List *funcargs)
{
Expr *expr = makeNode(Expr);
expr->typeOid = InvalidOid; /* assume type checking done */
expr->opType = FUNC_EXPR;
expr->oper = (Node*)func;
expr->args = funcargs;
return expr;
}
/*****************************************************************************
* OR clause functions
*****************************************************************************/
/*
* or_clause--
*
* Returns t iff the clause is an 'or' clause: (OR { expr }).
*
*/
bool
or_clause(Node *clause)
{
return
(clause!=NULL &&
nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==OR_EXPR);
}
/*
* make_orclause--
*
* Creates an 'or' clause given a list of its subclauses.
*
*/
Expr *
make_orclause(List *orclauses)
{
Expr *expr = makeNode(Expr);
expr->typeOid = InvalidOid; /* assume type checking done */
expr->opType = OR_EXPR;
expr->oper = NULL;
expr->args = orclauses;
return expr;
}
/*****************************************************************************
* NOT clause functions
*****************************************************************************/
/*
* not_clause--
*
* Returns t iff this is a 'not' clause: (NOT expr).
*
*/
bool
not_clause(Node *clause)
{
return
(clause!=NULL &&
nodeTag(clause)==T_Expr && ((Expr*)clause)->opType == NOT_EXPR);
}
/*
* make_notclause--
*
* Create a 'not' clause given the expression to be negated.
*
*/
Expr *
make_notclause(Expr *notclause)
{
Expr *expr = makeNode(Expr);
expr->typeOid = InvalidOid; /* assume type checking done */
expr->opType = NOT_EXPR;
expr->oper = NULL;
expr->args = lcons(notclause, NIL);
return expr;
}
/*
* get_notclausearg--
*
* Retrieve the clause within a 'not' clause
*
*/
Expr *
get_notclausearg(Expr *notclause)
{
return(lfirst(notclause->args));
}
/*****************************************************************************
* AND clause functions
*****************************************************************************/
/*
* and_clause--
*
* Returns t iff its argument is an 'and' clause: (AND { expr }).
*
*/
bool
and_clause(Node *clause)
{
return
(clause!=NULL &&
nodeTag(clause)==T_Expr && ((Expr*)clause)->opType == AND_EXPR);
}
/*
* make_andclause--
*
* Create an 'and' clause given its arguments in a list.
*
*/
Expr *
make_andclause(List *andclauses)
{
Expr *expr = makeNode(Expr);
expr->typeOid = InvalidOid; /* assume type checking done */
expr->opType = AND_EXPR;
expr->oper = NULL;
expr->args = andclauses;
return expr;
}
/*****************************************************************************
* *
* *
* *
*****************************************************************************/
/*
* pull-constant-clauses--
* Scans through a list of qualifications and find those that
* contain no variables.
*
* Returns a list of the constant clauses in constantQual and the remaining
* quals as the return value.
*
*/
List *
pull_constant_clauses(List *quals, List **constantQual)
{
List *q;
List *constqual=NIL;
List *restqual=NIL;
foreach(q, quals) {
if (!contain_var_clause(lfirst(q))) {
constqual = lcons(lfirst(q), constqual);
}else {
restqual = lcons(lfirst(q), restqual);
}
}
freeList(quals);
*constantQual = constqual;
return restqual;
}
/*
* clause-relids-vars--
* Retrieves relids and vars appearing within a clause.
* Returns ((relid1 relid2 ... relidn) (var1 var2 ... varm)) where
* vars appear in the clause this is done by recursively searching
* through the left and right operands of a clause.
*
* Returns the list of relids and vars.
*
* XXX take the nreverse's out later
*
*/
void
clause_relids_vars(Node *clause, List **relids, List **vars)
{
List *clvars = pull_var_clause(clause);
List *var_list = NIL;
List *varno_list = NIL;
List *i = NIL;
foreach (i, clvars) {
Var *var = (Var *)lfirst(i);
List *vi;
if (!intMember(var->varno, varno_list)) {
varno_list = lappendi(varno_list, var->varno);
}
foreach (vi, var_list)
{
Var *in_list = (Var *)lfirst(vi);
if ( in_list->varno == var->varno &&
in_list->varattno == var->varattno )
break;
}
if ( vi == NIL )
var_list = lappend(var_list, var);
}
*relids = varno_list;
*vars = var_list;
return;
}
/*
* NumRelids--
* (formerly clause-relids)
*
* Returns the number of different relations referenced in 'clause'.
*/
int
NumRelids(Node *clause)
{
List *vars = pull_var_clause(clause);
List *i = NIL;
List *var_list = NIL;
foreach (i, vars) {
Var *var = (Var *)lfirst(i);
if (!intMember(var->varno, var_list)) {
var_list = lconsi(var->varno, var_list);
}
}
return(length(var_list));
}
/*
* contains-not--
*
* Returns t iff the clause is a 'not' clause or if any of the
* subclauses within an 'or' clause contain 'not's.
*
*/
bool
contains_not(Node *clause)
{
if (single_node(clause))
return (false);
if (not_clause(clause))
return (true);
if (or_clause(clause)) {
List *a;
foreach(a, ((Expr*)clause)->args) {
if (contains_not(lfirst(a)))
return (true);
}
}
return(false);
}
/*
* join-clause-p--
*
* Returns t iff 'clause' is a valid join clause.
*
*/
bool
join_clause_p(Node *clause)
{
Node *leftop, *rightop;
if (!is_opclause(clause))
return false;
leftop = (Node*)get_leftop((Expr*)clause);
rightop = (Node*)get_rightop((Expr*)clause);
/*
* One side of the clause (i.e. left or right operands)
* must either be a var node ...
*/
if (IsA(leftop,Var) || IsA(rightop,Var))
return true;
/*
* ... or a func node.
*/
if (is_funcclause(leftop) || is_funcclause(rightop))
return(true);
return(false);
}
/*
* qual-clause-p--
*
* Returns t iff 'clause' is a valid qualification clause.
*
*/
bool
qual_clause_p(Node *clause)
{
if (!is_opclause(clause))
return false;
if (IsA (get_leftop((Expr*)clause),Var) &&
IsA (get_rightop((Expr*)clause),Const))
{
return(true);
}
else if (IsA (get_rightop((Expr*)clause),Var) &&
IsA (get_leftop((Expr*)clause),Const))
{
return(true);
}
return(false);
}
/*
* fix-opid--
* Calculate the opfid from the opno...
*
* Returns nothing.
*
*/
void
fix_opid(Node *clause)
{
if (clause==NULL || single_node(clause)) {
;
}
else if (or_clause (clause)) {
fix_opids(((Expr*)clause)->args);
}
else if (is_funcclause (clause)) {
fix_opids(((Expr*)clause)->args);
}
else if (IsA(clause,ArrayRef)) {
ArrayRef *aref = (ArrayRef *)clause;
fix_opids(aref->refupperindexpr);
fix_opids(aref->reflowerindexpr);
fix_opid(aref->refexpr);
fix_opid(aref->refassgnexpr);
}
else if (not_clause(clause)) {
fix_opid((Node*)get_notclausearg((Expr*)clause));
}
else if (is_opclause (clause)) {
replace_opid((Oper*)((Expr*)clause)->oper);
fix_opid((Node*)get_leftop((Expr*)clause));
fix_opid((Node*)get_rightop((Expr*)clause));
}
}
/*
* fix-opids--
* Calculate the opfid from the opno for all the clauses...
*
* Returns its argument.
*
*/
List *
fix_opids(List *clauses)
{
List *clause;
foreach(clause, clauses)
fix_opid(lfirst(clause));
return(clauses);
}
/*
* get_relattval--
* For a non-join clause, returns a list consisting of the
* relid,
* attno,
* value of the CONST node (if any), and a
* flag indicating whether the value appears on the left or right
* of the operator and whether the value varied.
*
* OLD OBSOLETE COMMENT FOLLOWS:
* If 'clause' is not of the format (op var node) or (op node var),
* or if the var refers to a nested attribute, then -1's are returned for
* everything but the value a blank string "" (pointer to \0) is
* returned for the value if it is unknown or null.
* END OF OLD OBSOLETE COMMENT.
* NEW COMMENT:
* when defining rules one of the attibutes of the operator can
* be a Param node (which is supposed to be treated as a constant).
* However as there is no value specified for a parameter until run time
* this routine used to return "" as value, which made 'compute_selec'
* to bomb (because it was expecting a lisp integer and got back a lisp
* string). Now the code returns a plain old good "lispInteger(0)".
*
*/
void
get_relattval(Node *clause,
int *relid,
AttrNumber *attno,
Datum *constval,
int *flag)
{
Var *left = get_leftop((Expr*)clause);
Var *right = get_rightop((Expr*)clause);
if(is_opclause(clause) && IsA(left,Var) &&
IsA(right,Const)) {
if(right!=NULL) {
*relid = left->varno;
*attno = left->varattno;
*constval = ((Const *)right)->constvalue;
*flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_IS_CONSTANT_);
} else {
*relid = left->varno;
*attno = left->varattno;
*constval = 0;
*flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_NOT_CONSTANT_);
}
}else if (is_opclause(clause) &&
is_funcclause((Node*)left) &&
IsA(right,Const)) {
List *args = ((Expr*)left)->args;
*relid = ((Var*)lfirst(args))->varno;
*attno = InvalidAttrNumber;
*constval = ((Const*)right)->constvalue;
*flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_IS_CONSTANT_);
/*
* XXX both of these func clause handling if's seem wrong to me.
* they assume that the first argument is the Var. It could
* not handle (for example) f(1, emp.name). I think I may have
* been assuming no constants in functional index scans when I
* implemented this originally (still currently true).
* -mer 10 Aug 1992
*/
} else if (is_opclause(clause) &&
is_funcclause((Node*)right) &&
IsA(left,Const)) {
List *args = ((Expr*)right)->args;
*relid = ((Var*)lfirst(args))->varno;
*attno = InvalidAttrNumber;
*constval = ((Const*)left)->constvalue;
*flag = ( _SELEC_IS_CONSTANT_);
} else if (is_opclause (clause) && IsA (right,Var) &&
IsA (left,Const)) {
if (left!=NULL) {
*relid = right->varno;
*attno = right->varattno;
*constval = ((Const*)left)->constvalue;
*flag = (_SELEC_IS_CONSTANT_);
} else {
*relid = right->varno;
*attno = right->varattno;
*constval = 0;
*flag = (_SELEC_NOT_CONSTANT_);
}
} else {
/* One or more of the operands are expressions
* (e.g., oper clauses)
*/
*relid = _SELEC_VALUE_UNKNOWN_;
*attno = _SELEC_VALUE_UNKNOWN_;
*constval = 0;
*flag = (_SELEC_NOT_CONSTANT_);
}
}
/*
* get_relsatts--
*
* Returns a list
* ( relid1 attno1 relid2 attno2 )
* for a joinclause.
*
* If the clause is not of the form (op var var) or if any of the vars
* refer to nested attributes, then -1's are returned.
*
*/
void
get_rels_atts(Node *clause,
int *relid1,
AttrNumber *attno1,
int *relid2,
AttrNumber *attno2)
{
Var *left = get_leftop((Expr*)clause);
Var *right = get_rightop((Expr*)clause);
bool var_left = (IsA(left,Var));
bool var_right = (IsA(right,Var));
bool varexpr_left = (bool)((IsA(left,Func) || IsA (left,Oper)) &&
contain_var_clause((Node*)left));
bool varexpr_right = (bool)(( IsA(right,Func) || IsA (right,Oper)) &&
contain_var_clause((Node*)right));
if (is_opclause(clause)) {
if(var_left && var_right) {
*relid1 = left->varno;
*attno1 = left->varoattno;
*relid2 = right->varno;
*attno2 = right->varoattno;
return;
} else if (var_left && varexpr_right ) {
*relid1 = left->varno;
*attno1 = left->varoattno;
*relid2 = _SELEC_VALUE_UNKNOWN_;
*attno2 = _SELEC_VALUE_UNKNOWN_;
return;
} else if (varexpr_left && var_right) {
*relid1 = _SELEC_VALUE_UNKNOWN_;
*attno1 = _SELEC_VALUE_UNKNOWN_;
*relid2 = right->varno;
*attno2 = right->varoattno;
return;
}
}
*relid1 = _SELEC_VALUE_UNKNOWN_;
*attno1 = _SELEC_VALUE_UNKNOWN_;
*relid2 = _SELEC_VALUE_UNKNOWN_;
*attno2 = _SELEC_VALUE_UNKNOWN_;
return;
}
void
CommuteClause(Node *clause)
{
Node *temp;
Oper *commu;
OperatorTupleForm commuTup;
HeapTuple heapTup;
if (!is_opclause(clause))
return;
heapTup = (HeapTuple)
get_operator_tuple(get_commutator(((Oper*)((Expr*)clause)->oper)->opno));
if (heapTup == (HeapTuple)NULL)
return;
commuTup = (OperatorTupleForm)GETSTRUCT(heapTup);
commu = makeOper(heapTup->t_oid,
InvalidOid,
commuTup->oprresult,
((Oper*)((Expr*)clause)->oper)->opsize,
NULL);
/*
* reform the clause -> (operator func/var constant)
*/
((Expr*)clause)->oper = (Node*)commu;
temp = lfirst(((Expr*)clause)->args);
lfirst(((Expr*)clause)->args) = lsecond(((Expr*)clause)->args);
lsecond(((Expr*)clause)->args) = temp;
}
Reference in New Issue View Git Blame Copy Permalink