*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.79 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.80 2003/11/25 21:00:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
hashstate->ps.plan = (Plan *) node;
hashstate->ps.state = estate;
hashstate->hashtable = NULL;
+ hashstate->hashkeys = NIL; /* will be set by parent HashJoin */
/*
* Miscellaneous initialization
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.57 2003/09/25 06:57:59 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.58 2003/11/25 21:00:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
HashJoinState *hjstate;
Plan *outerNode;
Hash *hashNode;
- List *hclauses;
+ List *lclauses;
+ List *rclauses;
List *hoperators;
List *hcl;
hjstate->hj_CurTuple = (HashJoinTuple) NULL;
/*
- * The planner already made a list of the inner hashkeys for us, but
- * we also need a list of the outer hashkeys, as well as a list of the
- * hash operator OIDs. Both lists of exprs must then be prepared for
- * execution.
+ * Deconstruct the hash clauses into outer and inner argument values,
+ * so that we can evaluate those subexpressions separately. Also make
+ * a list of the hash operator OIDs, in preparation for looking up the
+ * hash functions to use.
*/
- hjstate->hj_InnerHashKeys = (List *)
- ExecInitExpr((Expr *) hashNode->hashkeys,
- innerPlanState(hjstate));
- ((HashState *) innerPlanState(hjstate))->hashkeys =
- hjstate->hj_InnerHashKeys;
-
- hclauses = NIL;
+ lclauses = NIL;
+ rclauses = NIL;
hoperators = NIL;
- foreach(hcl, node->hashclauses)
+ foreach(hcl, hjstate->hashclauses)
{
- OpExpr *hclause = (OpExpr *) lfirst(hcl);
+ FuncExprState *fstate = (FuncExprState *) lfirst(hcl);
+ OpExpr *hclause;
+ Assert(IsA(fstate, FuncExprState));
+ hclause = (OpExpr *) fstate->xprstate.expr;
Assert(IsA(hclause, OpExpr));
- hclauses = lappend(hclauses, get_leftop((Expr *) hclause));
+ lclauses = lappend(lclauses, lfirst(fstate->args));
+ rclauses = lappend(rclauses, lsecond(fstate->args));
hoperators = lappendo(hoperators, hclause->opno);
}
- hjstate->hj_OuterHashKeys = (List *)
- ExecInitExpr((Expr *) hclauses,
- (PlanState *) hjstate);
+ hjstate->hj_OuterHashKeys = lclauses;
+ hjstate->hj_InnerHashKeys = rclauses;
hjstate->hj_HashOperators = hoperators;
+ /* child Hash node needs to evaluate inner hash keys, too */
+ ((HashState *) innerPlanState(hjstate))->hashkeys = rclauses;
hjstate->js.ps.ps_OuterTupleSlot = NULL;
hjstate->js.ps.ps_TupFromTlist = false;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.267 2003/11/12 21:15:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.268 2003/11/25 21:00:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* copy remainder of node
*/
- COPY_NODE_FIELD(hashkeys);
return newnode;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.220 2003/11/12 21:15:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.221 2003/11/25 21:00:53 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_NODE_TYPE("HASH");
_outPlanInfo(str, (Plan *) node);
-
- WRITE_NODE_FIELD(hashkeys);
}
/*****************************************************************************
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.159 2003/11/12 21:15:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.160 2003/11/25 21:00:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *hashclauses,
Plan *lefttree, Plan *righttree,
JoinType jointype);
-static Hash *make_hash(List *tlist, List *hashkeys, Plan *lefttree);
+static Hash *make_hash(List *tlist, Plan *lefttree);
static MergeJoin *make_mergejoin(List *tlist,
List *joinclauses, List *otherclauses,
List *mergeclauses,
List *hashclauses;
HashJoin *join_plan;
Hash *hash_plan;
- List *innerhashkeys;
- List *hcl;
/* Get the join qual clauses (in plain expression form) */
if (IS_OUTER_JOIN(best_path->jpath.jointype))
otherclauses = order_qual_clauses(root, otherclauses);
hashclauses = order_qual_clauses(root, hashclauses);
- /*
- * Extract the inner hash keys (right-hand operands of the
- * hashclauses) to put in the Hash node.
- */
- innerhashkeys = NIL;
- foreach(hcl, hashclauses)
- innerhashkeys = lappend(innerhashkeys, get_rightop(lfirst(hcl)));
-
/* We don't want any excess columns in the hashed tuples */
disuse_physical_tlist(inner_plan, best_path->jpath.innerjoinpath);
* Build the hash node and hash join node.
*/
hash_plan = make_hash(inner_plan->targetlist,
- innerhashkeys,
inner_plan);
join_plan = make_hashjoin(tlist,
joinclauses,
}
static Hash *
-make_hash(List *tlist, List *hashkeys, Plan *lefttree)
+make_hash(List *tlist, Plan *lefttree)
{
Hash *node = makeNode(Hash);
Plan *plan = &node->plan;
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
- node->hashkeys = hashkeys;
return node;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.97 2003/08/08 21:41:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.98 2003/11/25 21:00:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
(Node *) ((HashJoin *) plan)->hashclauses);
break;
case T_Hash:
-
- /*
- * Hash does not evaluate its targetlist or quals, so don't
- * touch those (see comments below). But we do need to fix
- * its hashkeys. The hashkeys are a little bizarre because
- * they need to match the hashclauses of the parent HashJoin
- * node, so we use join_references to fix them.
- */
- ((Hash *) plan)->hashkeys =
- join_references(((Hash *) plan)->hashkeys,
- rtable,
- NIL,
- plan->lefttree->targetlist,
- (Index) 0,
- targetlist_has_non_vars(plan->lefttree->targetlist));
- fix_expr_references(plan,
- (Node *) ((Hash *) plan)->hashkeys);
- break;
case T_Material:
case T_Sort:
case T_Unique:
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.83 2003/10/18 16:52:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.84 2003/11/25 21:00:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
break;
case T_Hash:
- finalize_primnode((Node *) ((Hash *) plan)->hashkeys,
- &context);
- break;
-
case T_Agg:
case T_SeqScan:
case T_Material:
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.70 2003/11/12 21:15:59 tgl Exp $
+ * $Id: plannodes.h,v 1.71 2003/11/25 21:00:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct Hash
{
Plan plan;
- List *hashkeys;
+ /* all other info is in the parent HashJoin node */
} Hash;
/* ----------------
projects / postgresql.git / commitdiff