*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.135 2007/01/05 22:19:32 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.136 2007/01/10 18:06:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parsetree.h"
#include "utils/memutils.h"
#include "utils/selfuncs.h"
+#include "utils/lsyscache.h"
#include "utils/syscache.h"
static List *translate_sub_tlist(List *tlist, int relid);
-static bool query_is_distinct_for(Query *query, List *colnos);
-static bool hash_safe_tlist(List *tlist);
+static bool query_is_distinct_for(Query *query, List *colnos, List *opids);
+static Oid distinct_col_search(int colno, List *colnos, List *opids);
+static bool hash_safe_operators(List *opids);
/*****************************************************************************
Path agg_path; /* dummy for result of cost_agg */
MemoryContext oldcontext;
List *sub_targetlist;
+ List *in_operators;
ListCell *l;
int numCols;
/*
* Try to identify the targetlist that will actually be unique-ified. In
* current usage, this routine is only used for sub-selects of IN clauses,
- * so we should be able to find the tlist in in_info_list.
+ * so we should be able to find the tlist in in_info_list. Get the IN
+ * clause's operators, too, because they determine what "unique" means.
*/
sub_targetlist = NIL;
+ in_operators = NIL;
foreach(l, root->in_info_list)
{
InClauseInfo *ininfo = (InClauseInfo *) lfirst(l);
if (bms_equal(ininfo->righthand, rel->relids))
{
sub_targetlist = ininfo->sub_targetlist;
+ in_operators = ininfo->in_operators;
break;
}
}
sub_tlist_colnos = translate_sub_tlist(sub_targetlist, rel->relid);
if (sub_tlist_colnos &&
- query_is_distinct_for(rte->subquery, sub_tlist_colnos))
+ query_is_distinct_for(rte->subquery,
+ sub_tlist_colnos, in_operators))
{
pathnode->umethod = UNIQUE_PATH_NOOP;
pathnode->rows = rel->rows;
/*
* Is it safe to use a hashed implementation? If so, estimate and compare
- * costs. We only try this if we know the targetlist for sure (else we
- * can't be sure about the datatypes involved).
+ * costs. We only try this if we know the IN operators, else we can't
+ * check their hashability.
*/
pathnode->umethod = UNIQUE_PATH_SORT;
- if (enable_hashagg && sub_targetlist && hash_safe_tlist(sub_targetlist))
+ if (enable_hashagg && in_operators && hash_safe_operators(in_operators))
{
/*
* Estimate the overhead per hashtable entry at 64 bytes (same as in
*
* colnos is an integer list of output column numbers (resno's). We are
* interested in whether rows consisting of just these columns are certain
- * to be distinct.
+ * to be distinct. "Distinctness" is defined according to whether the
+ * corresponding upper-level equality operators listed in opids would think
+ * the values are distinct. (Note: the opids entries could be cross-type
+ * operators, and thus not exactly the equality operators that the subquery
+ * would use itself. We assume that the subquery is compatible if these
+ * operators appear in the same btree opfamily as the ones the subquery uses.)
*/
static bool
-query_is_distinct_for(Query *query, List *colnos)
+query_is_distinct_for(Query *query, List *colnos, List *opids)
{
ListCell *l;
+ Oid opid;
+
+ Assert(list_length(colnos) == list_length(opids));
/*
* DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
- * columns in the DISTINCT clause appear in colnos.
+ * columns in the DISTINCT clause appear in colnos and operator
+ * semantics match.
*/
if (query->distinctClause)
{
TargetEntry *tle = get_sortgroupclause_tle(scl,
query->targetList);
- if (!list_member_int(colnos, tle->resno))
+ opid = distinct_col_search(tle->resno, colnos, opids);
+ if (!OidIsValid(opid) ||
+ !ops_in_same_btree_opfamily(opid, scl->sortop))
break; /* exit early if no match */
}
if (l == NULL) /* had matches for all? */
/*
* Similarly, GROUP BY guarantees uniqueness if all the grouped columns
- * appear in colnos.
+ * appear in colnos and operator semantics match.
*/
if (query->groupClause)
{
TargetEntry *tle = get_sortgroupclause_tle(grpcl,
query->targetList);
- if (!list_member_int(colnos, tle->resno))
+ opid = distinct_col_search(tle->resno, colnos, opids);
+ if (!OidIsValid(opid) ||
+ !ops_in_same_btree_opfamily(opid, grpcl->sortop))
break; /* exit early if no match */
}
if (l == NULL) /* had matches for all? */
{
/*
* If we have no GROUP BY, but do have aggregates or HAVING, then the
- * result is at most one row so it's surely unique.
+ * result is at most one row so it's surely unique, for any operators.
*/
if (query->hasAggs || query->havingQual)
return true;
/*
* UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
- * except with ALL
+ * except with ALL.
+ *
+ * XXX this code knows that prepunion.c will adopt the default ordering
+ * operator for each column datatype as the sortop. It'd probably be
+ * better if these operators were chosen at parse time and stored into
+ * the parsetree, instead of leaving bits of the planner to decide
+ * semantics.
*/
if (query->setOperations)
{
{
TargetEntry *tle = (TargetEntry *) lfirst(l);
- if (!tle->resjunk &&
- !list_member_int(colnos, tle->resno))
+ if (tle->resjunk)
+ continue; /* ignore resjunk columns */
+
+ opid = distinct_col_search(tle->resno, colnos, opids);
+ if (!OidIsValid(opid) ||
+ !ops_in_same_btree_opfamily(opid,
+ ordering_oper_opid(exprType((Node *) tle->expr))))
break; /* exit early if no match */
}
if (l == NULL) /* had matches for all? */
}
/*
- * hash_safe_tlist - can datatypes of given tlist be hashed?
+ * distinct_col_search - subroutine for query_is_distinct_for
*
- * We assume hashed aggregation will work if the datatype's equality operator
- * is marked hashjoinable.
+ * If colno is in colnos, return the corresponding element of opids,
+ * else return InvalidOid. (We expect colnos does not contain duplicates,
+ * so the result is well-defined.)
+ */
+static Oid
+distinct_col_search(int colno, List *colnos, List *opids)
+{
+ ListCell *lc1,
+ *lc2;
+
+ forboth(lc1, colnos, lc2, opids)
+ {
+ if (colno == lfirst_int(lc1))
+ return lfirst_oid(lc2);
+ }
+ return InvalidOid;
+}
+
+/*
+ * hash_safe_operators - can all the specified IN operators be hashed?
*
- * XXX this probably should be somewhere else. See also hash_safe_grouping
- * in plan/planner.c.
+ * We assume hashed aggregation will work if each IN operator is marked
+ * hashjoinable. If the IN operators are cross-type, this could conceivably
+ * fail: the aggregation will need a hashable equality operator for the RHS
+ * datatype --- but it's pretty hard to conceive of a hash opclass that has
+ * cross-type hashing without support for hashing the individual types, so
+ * we don't expend cycles here to support the case. We could check
+ * get_compatible_hash_operator() instead of just op_hashjoinable(), but the
+ * former is a significantly more expensive test.
*/
static bool
-hash_safe_tlist(List *tlist)
+hash_safe_operators(List *opids)
{
- ListCell *tl;
+ ListCell *lc;
- foreach(tl, tlist)
+ foreach(lc, opids)
{
- Node *expr = (Node *) lfirst(tl);
- Operator optup;
- bool oprcanhash;
-
- optup = equality_oper(exprType(expr), true);
- if (!optup)
- return false;
- oprcanhash = ((Form_pg_operator) GETSTRUCT(optup))->oprcanhash;
- ReleaseSysCache(optup);
- if (!oprcanhash)
+ if (!op_hashjoinable(lfirst_oid(lc)))
return false;
}
return true;
* ordering for each merge clause
* 'mergestrategies' are the btree operator strategies identifying the merge
* ordering for each merge clause
+ * 'mergenullsfirst' are the nulls first/last flags for each merge clause
* 'outersortkeys' are the sort varkeys for the outer relation
* 'innersortkeys' are the sort varkeys for the inner relation
*/
List *restrict_clauses,
List *pathkeys,
List *mergeclauses,
- List *mergefamilies,
- List *mergestrategies,
+ Oid *mergefamilies,
+ int *mergestrategies,
+ bool *mergenullsfirst,
List *outersortkeys,
List *innersortkeys)
{
pathnode->jpath.joinrestrictinfo = restrict_clauses;
pathnode->jpath.path.pathkeys = pathkeys;
pathnode->path_mergeclauses = mergeclauses;
- pathnode->path_mergefamilies = mergefamilies;
- pathnode->path_mergestrategies = mergestrategies;
+ pathnode->path_mergeFamilies = mergefamilies;
+ pathnode->path_mergeStrategies = mergestrategies;
+ pathnode->path_mergeNullsFirst = mergenullsfirst;
pathnode->outersortkeys = outersortkeys;
pathnode->innersortkeys = innersortkeys;
projects / postgresql / blobdiff