*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.50 2002/11/13 00:39:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.51 2002/11/29 21:39:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return NULL;
/* If column has no "=" operator, we can't do much of anything */
- func_operator = compatible_oper(makeList1(makeString("=")),
- attr->atttypid,
- attr->atttypid,
- true);
+ func_operator = equality_oper(attr->atttypid, true);
if (func_operator != NULL)
{
oprrest = ((Form_pg_operator) GETSTRUCT(func_operator))->oprrest;
stats->attr->attstattarget = default_statistics_target;
/* Is there a "<" operator with suitable semantics? */
- func_operator = compatible_oper(makeList1(makeString("<")),
- attr->atttypid,
- attr->atttypid,
- true);
+ func_operator = ordering_oper(attr->atttypid, true);
if (func_operator != NULL)
{
oprrest = ((Form_pg_operator) GETSTRUCT(func_operator))->oprrest;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.96 2002/11/19 23:21:57 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.97 2002/11/29 21:39:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
&peraggstate->inputtypeLen,
&peraggstate->inputtypeByVal);
- eq_function = compatible_oper_funcid(makeList1(makeString("=")),
- inputType, inputType,
- true);
- if (!OidIsValid(eq_function))
- elog(ERROR, "Unable to identify an equality operator for type %s",
- format_type_be(inputType));
+ eq_function = equality_oper_funcid(inputType);
fmgr_info(eq_function, &(peraggstate->equalfn));
- peraggstate->sortOperator = any_ordering_op(inputType);
+ peraggstate->sortOperator = ordering_oper_opid(inputType);
peraggstate->sortstate = NULL;
}
* locate group boundaries.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.49 2002/11/06 22:31:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.50 2002/11/29 21:39:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Oid typid = tupdesc->attrs[att - 1]->atttypid;
Oid eq_function;
- eq_function = compatible_oper_funcid(makeList1(makeString("=")),
- typid, typid, true);
- if (!OidIsValid(eq_function))
- elog(ERROR, "Unable to identify an equality operator for type %s",
- format_type_be(typid));
+ eq_function = equality_oper_funcid(typid);
fmgr_info(eq_function, &eqfunctions[i]);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.131 2002/11/26 03:01:58 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.132 2002/11/29 21:39:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
+#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/analyze.h"
#include "parser/parsetree.h"
#include "parser/parse_expr.h"
+#include "parser/parse_oper.h"
#include "rewrite/rewriteManip.h"
#include "utils/lsyscache.h"
#include "utils/selfuncs.h"
+#include "utils/syscache.h"
/* Expression kind codes for preprocess_expression */
static void preprocess_qual_conditions(Query *parse, Node *jtnode);
static Plan *inheritance_planner(Query *parse, List *inheritlist);
static Plan *grouping_planner(Query *parse, double tuple_fraction);
+static bool hash_safe_grouping(Query *parse);
static List *make_subplanTargetList(Query *parse, List *tlist,
AttrNumber **groupColIdx);
static Plan *make_groupsortplan(Query *parse,
numGroups = (long) Min(dNumGroups, (double) LONG_MAX);
/*
+ * Check can't-do-it conditions, including whether the grouping
+ * operators are hashjoinable.
+ *
* Executor doesn't support hashed aggregation with DISTINCT
* aggregates. (Doing so would imply storing *all* the input
* values in the hash table, which seems like a certain loser.)
*/
- if (!enable_hashagg)
+ if (!enable_hashagg || !hash_safe_grouping(parse))
use_hashed_grouping = false;
else if (parse->hasAggs &&
(contain_distinct_agg_clause((Node *) tlist) ||
return result_plan;
}
+/*
+ * hash_safe_grouping - are grouping operators hashable?
+ *
+ * We assume hashed aggregation will work if the datatype's equality operator
+ * is marked hashjoinable.
+ */
+static bool
+hash_safe_grouping(Query *parse)
+{
+ List *gl;
+
+ foreach(gl, parse->groupClause)
+ {
+ GroupClause *grpcl = (GroupClause *) lfirst(gl);
+ TargetEntry *tle = get_sortgroupclause_tle(grpcl, parse->targetList);
+ Operator optup;
+ bool oprcanhash;
+
+ optup = equality_oper(tle->resdom->restype, false);
+ oprcanhash = ((Form_pg_operator) GETSTRUCT(optup))->oprcanhash;
+ ReleaseSysCache(optup);
+ if (!oprcanhash)
+ return false;
+ }
+ return true;
+}
+
/*---------------
* make_subplanTargetList
* Generate appropriate target list when grouping is required.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.99 2002/11/15 02:50:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.100 2002/11/29 21:39:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* transformGroupClause -
- * transform a Group By clause
- *
+ * transform a GROUP BY clause
*/
List *
transformGroupClause(ParseState *pstate, List *grouplist, List *targetlist)
grpcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
- grpcl->sortop = any_ordering_op(tle->resdom->restype);
+ grpcl->sortop = ordering_oper_opid(tle->resdom->restype);
glist = lappend(glist, grpcl);
}
* addTargetToSortList
* If the given targetlist entry isn't already in the ORDER BY list,
* add it to the end of the list, using the sortop with given name
- * or any available sort operator if opname == NIL.
+ * or the default sort operator if opname == NIL.
*
* Returns the updated ORDER BY list.
*/
tle->resdom->restype,
false);
else
- sortcl->sortop = any_ordering_op(tle->resdom->restype);
+ sortcl->sortop = ordering_oper_opid(tle->resdom->restype);
sortlist = lappend(sortlist, sortcl);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.60 2002/09/18 21:35:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.61 2002/11/29 21:39:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return operoid;
}
+/*
+ * equality_oper - identify a suitable equality operator for a datatype
+ *
+ * On failure, return NULL if noError, else report a standard error
+ */
+Operator
+equality_oper(Oid argtype, bool noError)
+{
+ Operator optup;
-/* Select an ordering operator for the given datatype */
-Oid
-any_ordering_op(Oid argtype)
+ /*
+ * Look for an "=" operator for the datatype. We require it to be
+ * an exact or binary-compatible match, since most callers are not
+ * prepared to cope with adding any run-time type coercion steps.
+ */
+ optup = compatible_oper(makeList1(makeString("=")),
+ argtype, argtype, true);
+ if (optup != NULL)
+ {
+ /*
+ * Only believe that it's equality if it's mergejoinable,
+ * hashjoinable, or uses eqsel() as oprrest.
+ */
+ Form_pg_operator pgopform = (Form_pg_operator) GETSTRUCT(optup);
+
+ if (OidIsValid(pgopform->oprlsortop) ||
+ pgopform->oprcanhash ||
+ pgopform->oprrest == F_EQSEL)
+ return optup;
+
+ ReleaseSysCache(optup);
+ }
+ if (!noError)
+ elog(ERROR, "Unable to identify an equality operator for type %s",
+ format_type_be(argtype));
+ return NULL;
+}
+
+/*
+ * ordering_oper - identify a suitable sorting operator ("<") for a datatype
+ *
+ * On failure, return NULL if noError, else report a standard error
+ */
+Operator
+ordering_oper(Oid argtype, bool noError)
{
- Oid order_opid;
+ Operator optup;
- order_opid = compatible_oper_opid(makeList1(makeString("<")),
- argtype, argtype, true);
- if (!OidIsValid(order_opid))
- elog(ERROR, "Unable to identify an ordering operator '%s' for type '%s'"
+ /*
+ * Find the type's equality operator, and use its lsortop (it *must*
+ * be mergejoinable). We use this definition because for sorting and
+ * grouping purposes, it's important that the equality and ordering
+ * operators are consistent.
+ */
+ optup = equality_oper(argtype, noError);
+ if (optup != NULL)
+ {
+ Oid lsortop = ((Form_pg_operator) GETSTRUCT(optup))->oprlsortop;
+
+ ReleaseSysCache(optup);
+
+ if (OidIsValid(lsortop))
+ {
+ optup = SearchSysCache(OPEROID,
+ ObjectIdGetDatum(lsortop),
+ 0, 0, 0);
+ if (optup != NULL)
+ return optup;
+ }
+ }
+ if (!noError)
+ elog(ERROR, "Unable to identify an ordering operator for type %s"
"\n\tUse an explicit ordering operator or modify the query",
- "<", format_type_be(argtype));
- return order_opid;
+ format_type_be(argtype));
+ return NULL;
+}
+
+/*
+ * equality_oper_funcid - convenience routine for oprfuncid(equality_oper())
+ */
+Oid
+equality_oper_funcid(Oid argtype)
+{
+ Operator optup;
+ Oid result;
+
+ optup = equality_oper(argtype, false);
+ result = oprfuncid(optup);
+ ReleaseSysCache(optup);
+ return result;
+}
+
+/*
+ * ordering_oper_opid - convenience routine for oprid(ordering_oper())
+ *
+ * This was formerly called any_ordering_op()
+ */
+Oid
+ordering_oper_opid(Oid argtype)
+{
+ Operator optup;
+ Oid result;
+
+ optup = ordering_oper(argtype, false);
+ result = oprid(optup);
+ ReleaseSysCache(optup);
+ return result;
}
+
/* given operator tuple, return the operator OID */
Oid
oprid(Operator op)
return InvalidOid;
}
-/* compatible_oper_funcid() -- get OID of a binary operator's function
- *
- * This is a convenience routine that extracts only the function OID
- * from the result of compatible_oper(). InvalidOid is returned if the
- * lookup fails and noError is true.
- */
-Oid
-compatible_oper_funcid(List *op, Oid arg1, Oid arg2, bool noError)
-{
- Operator optup;
- Oid result;
-
- optup = compatible_oper(op, arg1, arg2, noError);
- if (optup != NULL)
- {
- result = oprfuncid(optup);
- ReleaseSysCache(optup);
- return result;
- }
- return InvalidOid;
-}
-
/* right_oper() -- search for a unary right operator (operator on right)
* Given operator name and type of arg, return oper struct.
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.43 2002/10/03 21:06:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.44 2002/11/29 21:39:11 tgl Exp $
*
* ----------
*/
Oid opr_proc;
FmgrInfo finfo;
- opr_proc = compatible_oper_funcid(makeList1(makeString("=")),
- typeid, typeid, true);
- if (!OidIsValid(opr_proc))
- elog(ERROR,
- "ri_AttributesEqual(): cannot find '=' operator for type %u",
- typeid);
+ opr_proc = equality_oper_funcid(typeid);
/*
* Since fmgr_info could fail, call it *before* creating the
/*-------------------------------------------------------------------------
*
* parse_oper.h
- *
+ * handle operator things for parser
*
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_oper.h,v 1.22 2002/09/04 20:31:45 momjian Exp $
+ * $Id: parse_oper.h,v 1.23 2002/11/29 21:39:12 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* currently no need for compatible_left_oper/compatible_right_oper */
-/* Convenience routines that call compatible_oper() and return either */
-/* the operator OID or the underlying function OID, or InvalidOid if fail */
-extern Oid compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError);
-extern Oid compatible_oper_funcid(List *op, Oid arg1, Oid arg2, bool noError);
+/* Routines for identifying "=" and "<" operators for a type */
+extern Operator equality_oper(Oid argtype, bool noError);
+extern Operator ordering_oper(Oid argtype, bool noError);
-/* Convenience routine that packages a specific call on compatible_oper */
-extern Oid any_ordering_op(Oid argtype);
+/* Convenience routines for common calls on the above */
+extern Oid compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError);
+extern Oid equality_oper_funcid(Oid argtype);
+extern Oid ordering_oper_opid(Oid argtype);
/* Extract operator OID or underlying-function OID from an Operator tuple */
extern Oid oprid(Operator op);
projects / postgresql.git / commitdiff