open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Extend join-selectivity API (oprjoin interface) so that join type is

Browse Source 
passed to join selectivity estimators.  Make use of this in eqjoinsel
to derive non-bogus selectivity for IN clauses.  Further tweaking of
cost estimation for IN.
initdb forced because of pg_proc.h changes.
WIN32_DEV
Tom Lane 23 years ago
parent 955a1f81a7
commit 2e46b762eb
16 changed files with 221 additions and 136 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 5
      doc/src/sgml/indexcost.sgml
  2. 7
      src/backend/catalog/pg_operator.c
  3. 38
      src/backend/optimizer/path/clausesel.c
  4. 125
      src/backend/optimizer/path/costsize.c
  5. 8
      src/backend/optimizer/path/indxpath.c
  6. 4
      src/backend/optimizer/plan/subselect.c
  7. 13
      src/backend/optimizer/util/plancat.c
  8. 75
      src/backend/utils/adt/selfuncs.c
  9. 4
      src/include/catalog/catversion.h
  10. 32
      src/include/catalog/pg_proc.h
  11. 17
      src/include/optimizer/cost.h
  12. 7
      src/include/optimizer/plancat.h
  13. 4
      src/include/utils/selfuncs.h
  14. 7
      src/test/regress/expected/opr_sanity.out
  15. 4
      src/test/regress/expected/subselect.out
  16. 7
      src/test/regress/sql/opr_sanity.sql

5
doc/src/sgml/indexcost.sgml
Unescape View File

@ -1,5 +1,5 @@
<!-- <!--
$Header: /cvsroot/pgsql/doc/src/sgml/Attic/indexcost.sgml,v 2.14 2003/01/14 10:19:02 petere Exp $ $Header: /cvsroot/pgsql/doc/src/sgml/Attic/indexcost.sgml,v 2.15 2003/01/28 22:13:24 tgl Exp $
--> -->
<chapter id="indexcost"> <chapter id="indexcost">
@ -205,7 +205,8 @@ amcostestimate (Query *root,
<programlisting> <programlisting>
*indexSelectivity = clauselist_selectivity(root, indexQuals, *indexSelectivity = clauselist_selectivity(root, indexQuals,
lfirsti(rel->relids)); lfirsti(rel->relids),
JOIN_INNER);
</programlisting> </programlisting>
</para> </para>
</step> </step>

7
src/backend/catalog/pg_operator.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.77 2002/09/04 20:31:14 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.78 2003/01/28 22:13:25 tgl Exp $
* *
* NOTES * NOTES
* these routines moved here from commands/define.c and somewhat cleaned up. * these routines moved here from commands/define.c and somewhat cleaned up.
@ -485,10 +485,11 @@ OperatorCreate(const char *operatorName,
typeId[0] = INTERNALOID; /* Query */ typeId[0] = INTERNALOID; /* Query */
typeId[1] = OIDOID; /* operator OID */ typeId[1] = OIDOID; /* operator OID */
typeId[2] = INTERNALOID; /* args list */ typeId[2] = INTERNALOID; /* args list */
typeId[3] = INT2OID; /* jointype */
joinOid = LookupFuncName(joinName, 3, typeId); joinOid = LookupFuncName(joinName, 4, typeId);
if (!OidIsValid(joinOid)) if (!OidIsValid(joinOid))
func_error("OperatorDef", joinName, 3, typeId, NULL); func_error("OperatorDef", joinName, 4, typeId, NULL);
} }
else else
joinOid = InvalidOid; joinOid = InvalidOid;

38
src/backend/optimizer/path/clausesel.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.55 2003/01/15 19:35:39 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.56 2003/01/28 22:13:29 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -65,12 +65,13 @@ static void addRangeClause(RangeQueryClause **rqlist, Node *clause,
Selectivity Selectivity
restrictlist_selectivity(Query *root, restrictlist_selectivity(Query *root,
List *restrictinfo_list, List *restrictinfo_list,
int varRelid) int varRelid,
JoinType jointype)
{ {
List *clauselist = get_actual_clauses(restrictinfo_list); List *clauselist = get_actual_clauses(restrictinfo_list);
Selectivity result; Selectivity result;
result = clauselist_selectivity(root, clauselist, varRelid); result = clauselist_selectivity(root, clauselist, varRelid, jointype);
freeList(clauselist); freeList(clauselist);
return result; return result;
} }
@ -81,7 +82,7 @@ restrictlist_selectivity(Query *root,
* expression clauses. The list can be empty, in which case 1.0 * expression clauses. The list can be empty, in which case 1.0
* must be returned. * must be returned.
* *
* See clause_selectivity() for the meaning of the varRelid parameter. * See clause_selectivity() for the meaning of the additional parameters.
* *
* Our basic approach is to take the product of the selectivities of the * Our basic approach is to take the product of the selectivities of the
* subclauses. However, that's only right if the subclauses have independent * subclauses. However, that's only right if the subclauses have independent
@ -113,7 +114,8 @@ restrictlist_selectivity(Query *root,
Selectivity Selectivity
clauselist_selectivity(Query *root, clauselist_selectivity(Query *root,
List *clauses, List *clauses,
int varRelid) int varRelid,
JoinType jointype)
{ {
Selectivity s1 = 1.0; Selectivity s1 = 1.0;
RangeQueryClause *rqlist = NULL; RangeQueryClause *rqlist = NULL;
@ -184,7 +186,7 @@ clauselist_selectivity(Query *root,
} }
} }
/* Not the right form, so treat it generically. */ /* Not the right form, so treat it generically. */
s2 = clause_selectivity(root, clause, varRelid); s2 = clause_selectivity(root, clause, varRelid, jointype);
s1 = s1 * s2; s1 = s1 * s2;
} }
@ -362,11 +364,15 @@ addRangeClause(RangeQueryClause **rqlist, Node *clause,
* *
* When varRelid is 0, all variables are treated as variables. This * When varRelid is 0, all variables are treated as variables. This
* is appropriate for ordinary join clauses and restriction clauses. * is appropriate for ordinary join clauses and restriction clauses.
*
* jointype is the join type, if the clause is a join clause. Pass JOIN_INNER
* if the clause isn't a join clause or the context is uncertain.
*/ */
Selectivity Selectivity
clause_selectivity(Query *root, clause_selectivity(Query *root,
Node *clause, Node *clause,
int varRelid) int varRelid,
JoinType jointype)
{ {
Selectivity s1 = 1.0; /* default for any unhandled clause type */ Selectivity s1 = 1.0; /* default for any unhandled clause type */
@ -424,14 +430,16 @@ clause_selectivity(Query *root,
/* inverse of the selectivity of the underlying clause */ /* inverse of the selectivity of the underlying clause */
s1 = 1.0 - clause_selectivity(root, s1 = 1.0 - clause_selectivity(root,
(Node *) get_notclausearg((Expr *) clause), (Node *) get_notclausearg((Expr *) clause),
varRelid); varRelid,
jointype);
} }
else if (and_clause(clause)) else if (and_clause(clause))
{ {
/* share code with clauselist_selectivity() */ /* share code with clauselist_selectivity() */
s1 = clauselist_selectivity(root, s1 = clauselist_selectivity(root,
((BoolExpr *) clause)->args, ((BoolExpr *) clause)->args,
varRelid); varRelid,
jointype);
} }
else if (or_clause(clause)) else if (or_clause(clause))
{ {
@ -447,7 +455,8 @@ clause_selectivity(Query *root,
{ {
Selectivity s2 = clause_selectivity(root, Selectivity s2 = clause_selectivity(root,
(Node *) lfirst(arg), (Node *) lfirst(arg),
varRelid); varRelid,
jointype);
s1 = s1 + s2 - s1 * s2; s1 = s1 + s2 - s1 * s2;
} }
@ -479,7 +488,8 @@ clause_selectivity(Query *root,
{ {
/* Estimate selectivity for a join clause. */ /* Estimate selectivity for a join clause. */
s1 = join_selectivity(root, opno, s1 = join_selectivity(root, opno,
((OpExpr *) clause)->args); ((OpExpr *) clause)->args,
jointype);
} }
else else
{ {
@ -519,14 +529,16 @@ clause_selectivity(Query *root,
s1 = booltestsel(root, s1 = booltestsel(root,
((BooleanTest *) clause)->booltesttype, ((BooleanTest *) clause)->booltesttype,
(Node *) ((BooleanTest *) clause)->arg, (Node *) ((BooleanTest *) clause)->arg,
varRelid); varRelid,
jointype);
} }
else if (IsA(clause, RelabelType)) else if (IsA(clause, RelabelType))
{ {
/* Not sure this case is needed, but it can't hurt */ /* Not sure this case is needed, but it can't hurt */
s1 = clause_selectivity(root, s1 = clause_selectivity(root,
(Node *) ((RelabelType *) clause)->arg, (Node *) ((RelabelType *) clause)->arg,
varRelid); varRelid,
jointype);
} }
#ifdef SELECTIVITY_DEBUG #ifdef SELECTIVITY_DEBUG

125
src/backend/optimizer/path/costsize.c
Unescape View File

@ -49,7 +49,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.103 2003/01/27 20:51:50 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.104 2003/01/28 22:13:33 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -104,7 +104,8 @@ bool enable_hashjoin = true;
static Selectivity estimate_hash_bucketsize(Query *root, Var *var, static Selectivity estimate_hash_bucketsize(Query *root, Var *var,
int nbuckets); int nbuckets);
static bool cost_qual_eval_walker(Node *node, QualCost *total); static bool cost_qual_eval_walker(Node *node, QualCost *total);
static Selectivity approx_selectivity(Query *root, List *quals); static Selectivity approx_selectivity(Query *root, List *quals,
JoinType jointype);
static void set_rel_width(Query *root, RelOptInfo *rel); static void set_rel_width(Query *root, RelOptInfo *rel);
static double relation_byte_size(double tuples, int width); static double relation_byte_size(double tuples, int width);
static double page_size(double tuples, int width); static double page_size(double tuples, int width);
@ -697,7 +698,8 @@ cost_nestloop(NestPath *path, Query *root)
*/ */
if (path->jointype == JOIN_IN) if (path->jointype == JOIN_IN)
{ {
Selectivity qual_selec = approx_selectivity(root, restrictlist); Selectivity qual_selec = approx_selectivity(root, restrictlist,
path->jointype);
double qptuples; double qptuples;
qptuples = ceil(qual_selec * outer_path_rows * inner_path_rows); qptuples = ceil(qual_selec * outer_path_rows * inner_path_rows);
@ -816,10 +818,12 @@ cost_mergejoin(MergePath *path, Query *root)
* Note: it's probably bogus to use the normal selectivity calculation * Note: it's probably bogus to use the normal selectivity calculation
* here when either the outer or inner path is a UniquePath. * here when either the outer or inner path is a UniquePath.
*/ */
merge_selec = approx_selectivity(root, mergeclauses); merge_selec = approx_selectivity(root, mergeclauses,
path->jpath.jointype);
cost_qual_eval(&merge_qual_cost, mergeclauses); cost_qual_eval(&merge_qual_cost, mergeclauses);
qpquals = set_ptrDifference(restrictlist, mergeclauses); qpquals = set_ptrDifference(restrictlist, mergeclauses);
qp_selec = approx_selectivity(root, qpquals); qp_selec = approx_selectivity(root, qpquals,
path->jpath.jointype);
cost_qual_eval(&qp_qual_cost, qpquals); cost_qual_eval(&qp_qual_cost, qpquals);
freeList(qpquals); freeList(qpquals);
@ -1044,10 +1048,12 @@ cost_hashjoin(HashPath *path, Query *root)
* Note: it's probably bogus to use the normal selectivity calculation * Note: it's probably bogus to use the normal selectivity calculation
* here when either the outer or inner path is a UniquePath. * here when either the outer or inner path is a UniquePath.
*/ */
hash_selec = approx_selectivity(root, hashclauses); hash_selec = approx_selectivity(root, hashclauses,
path->jpath.jointype);
cost_qual_eval(&hash_qual_cost, hashclauses); cost_qual_eval(&hash_qual_cost, hashclauses);
qpquals = set_ptrDifference(restrictlist, hashclauses); qpquals = set_ptrDifference(restrictlist, hashclauses);
qp_selec = approx_selectivity(root, qpquals); qp_selec = approx_selectivity(root, qpquals,
path->jpath.jointype);
cost_qual_eval(&qp_qual_cost, qpquals); cost_qual_eval(&qp_qual_cost, qpquals);
freeList(qpquals); freeList(qpquals);
@ -1084,54 +1090,67 @@ cost_hashjoin(HashPath *path, Query *root)
* Determine bucketsize fraction for inner relation. We use the * Determine bucketsize fraction for inner relation. We use the
* smallest bucketsize estimated for any individual hashclause; * smallest bucketsize estimated for any individual hashclause;
* this is undoubtedly conservative. * this is undoubtedly conservative.
*
* BUT: if inner relation has been unique-ified, we can assume it's
* good for hashing. This is important both because it's the right
* answer, and because we avoid contaminating the cache with a value
* that's wrong for non-unique-ified paths.
*/ */
innerbucketsize = 1.0; if (IsA(inner_path, UniquePath))
foreach(hcl, hashclauses) innerbucketsize = 1.0 / virtualbuckets;
else
{ {
RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(hcl); innerbucketsize = 1.0;
Selectivity thisbucketsize; foreach(hcl, hashclauses)
{
RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(hcl);
Selectivity thisbucketsize;
Assert(IsA(restrictinfo, RestrictInfo)); Assert(IsA(restrictinfo, RestrictInfo));
/* /*
* First we have to figure out which side of the hashjoin clause is the * First we have to figure out which side of the hashjoin clause
* inner side. * is the inner side.
* *
* Since we tend to visit the same clauses over and over when planning * Since we tend to visit the same clauses over and over when
* a large query, we cache the bucketsize estimate in the RestrictInfo * planning a large query, we cache the bucketsize estimate in the
* node to avoid repeated lookups of statistics. * RestrictInfo node to avoid repeated lookups of statistics.
*/ */
if (is_subseti(restrictinfo->right_relids, inner_path->parent->relids)) if (is_subseti(restrictinfo->right_relids,
{ inner_path->parent->relids))
/* righthand side is inner */
thisbucketsize = restrictinfo->right_bucketsize;
if (thisbucketsize < 0)
{ {
/* not cached yet */ /* righthand side is inner */
thisbucketsize = estimate_hash_bucketsize(root, thisbucketsize = restrictinfo->right_bucketsize;
if (thisbucketsize < 0)
{
/* not cached yet */
thisbucketsize =
estimate_hash_bucketsize(root,
(Var *) get_rightop(restrictinfo->clause), (Var *) get_rightop(restrictinfo->clause),
virtualbuckets); virtualbuckets);
restrictinfo->right_bucketsize = thisbucketsize; restrictinfo->right_bucketsize = thisbucketsize;
}
} }
} else
else
{
Assert(is_subseti(restrictinfo->left_relids,
inner_path->parent->relids));
/* lefthand side is inner */
thisbucketsize = restrictinfo->left_bucketsize;
if (thisbucketsize < 0)
{ {
/* not cached yet */ Assert(is_subseti(restrictinfo->left_relids,
thisbucketsize = estimate_hash_bucketsize(root, inner_path->parent->relids));
/* lefthand side is inner */
thisbucketsize = restrictinfo->left_bucketsize;
if (thisbucketsize < 0)
{
/* not cached yet */
thisbucketsize =
estimate_hash_bucketsize(root,
(Var *) get_leftop(restrictinfo->clause), (Var *) get_leftop(restrictinfo->clause),
virtualbuckets); virtualbuckets);
restrictinfo->left_bucketsize = thisbucketsize; restrictinfo->left_bucketsize = thisbucketsize;
}
} }
}
if (innerbucketsize > thisbucketsize) if (innerbucketsize > thisbucketsize)
innerbucketsize = thisbucketsize; innerbucketsize = thisbucketsize;
}
} }
/* /*
@ -1557,7 +1576,7 @@ cost_qual_eval_walker(Node *node, QualCost *total)
* seems OK to live with the approximation. * seems OK to live with the approximation.
*/ */
static Selectivity static Selectivity
approx_selectivity(Query *root, List *quals) approx_selectivity(Query *root, List *quals, JoinType jointype)
{ {
Selectivity total = 1.0; Selectivity total = 1.0;
List *l; List *l;
@ -1582,13 +1601,14 @@ approx_selectivity(Query *root, List *quals)
restrictinfo->this_selec = restrictinfo->this_selec =
clause_selectivity(root, clause_selectivity(root,
(Node *) restrictinfo->clause, (Node *) restrictinfo->clause,
0); 0,
jointype);
selec = restrictinfo->this_selec; selec = restrictinfo->this_selec;
} }
else else
{ {
/* If it's a bare expression, must always do it the hard way */ /* If it's a bare expression, must always do it the hard way */
selec = clause_selectivity(root, qual, 0); selec = clause_selectivity(root, qual, 0, jointype);
} }
total *= selec; total *= selec;
} }
@ -1620,7 +1640,8 @@ set_baserel_size_estimates(Query *root, RelOptInfo *rel)
temp = rel->tuples * temp = rel->tuples *
restrictlist_selectivity(root, restrictlist_selectivity(root,
rel->baserestrictinfo, rel->baserestrictinfo,
lfirsti(rel->relids)); lfirsti(rel->relids),
JOIN_INNER);
/* /*
* Force estimate to be at least one row, to make explain output look * Force estimate to be at least one row, to make explain output look
@ -1682,7 +1703,8 @@ set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
*/ */
selec = restrictlist_selectivity(root, selec = restrictlist_selectivity(root,
restrictlist, restrictlist,
0); 0,
jointype);
/* /*
* Basically, we multiply size of Cartesian product by selectivity. * Basically, we multiply size of Cartesian product by selectivity.
@ -1694,8 +1716,6 @@ set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
* For JOIN_IN and variants, the Cartesian product is figured with * For JOIN_IN and variants, the Cartesian product is figured with
* respect to a unique-ified input, and then we can clamp to the size * respect to a unique-ified input, and then we can clamp to the size
* of the other input. * of the other input.
* XXX it's not at all clear that the ordinary selectivity calculation
* is appropriate in this case.
*/ */
switch (jointype) switch (jointype)
{ {
@ -1798,7 +1818,8 @@ set_function_size_estimates(Query *root, RelOptInfo *rel)
temp = rel->tuples * temp = rel->tuples *
restrictlist_selectivity(root, restrictlist_selectivity(root,
rel->baserestrictinfo, rel->baserestrictinfo,
lfirsti(rel->relids)); lfirsti(rel->relids),
JOIN_INNER);
/* /*
* Force estimate to be at least one row, to make explain output look * Force estimate to be at least one row, to make explain output look

8
src/backend/optimizer/path/indxpath.c
Unescape View File

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.133 2003/01/24 03:58:34 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.134 2003/01/28 22:13:33 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1599,12 +1599,16 @@ make_innerjoin_index_path(Query *root,
* selectivity. However, since RestrictInfo nodes aren't copied when * selectivity. However, since RestrictInfo nodes aren't copied when
* linking them into different lists, it should be sufficient to use * linking them into different lists, it should be sufficient to use
* pointer comparison to remove duplicates.) * pointer comparison to remove duplicates.)
*
* Always assume the join type is JOIN_INNER; even if some of the
* join clauses come from other contexts, that's not our problem.
*/ */
pathnode->rows = rel->tuples * pathnode->rows = rel->tuples *
restrictlist_selectivity(root, restrictlist_selectivity(root,
set_ptrUnion(rel->baserestrictinfo, set_ptrUnion(rel->baserestrictinfo,
clausegroup), clausegroup),
lfirsti(rel->relids)); lfirsti(rel->relids),
JOIN_INNER);
/* Like costsize.c, force estimate to be at least one row */ /* Like costsize.c, force estimate to be at least one row */
if (pathnode->rows < 1.0) if (pathnode->rows < 1.0)
pathnode->rows = 1.0; pathnode->rows = 1.0;

4
src/backend/optimizer/plan/subselect.c
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.68 2003/01/20 18:54:53 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.69 2003/01/28 22:13:35 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -351,7 +351,7 @@ make_subplan(SubLink *slink, List *lefthand, bool isTopQual)
qualsel = clauselist_selectivity(subquery, qualsel = clauselist_selectivity(subquery,
plan->qual, plan->qual,
0); 0, JOIN_INNER);
/* Is 10% selectivity a good threshold?? */ /* Is 10% selectivity a good threshold?? */
use_material = qualsel < 0.10; use_material = qualsel < 0.10;
} }

13
src/backend/optimizer/util/plancat.c
Unescape View File

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.75 2002/11/24 21:52:14 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.76 2003/01/28 22:13:35 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -196,8 +196,7 @@ find_secondary_indexes(Oid relationObjectId)
* This code executes registered procedures stored in the * This code executes registered procedures stored in the
* operator relation, by calling the function manager. * operator relation, by calling the function manager.
* *
* varRelid is either 0 or a rangetable index. See clause_selectivity() * See clause_selectivity() for the meaning of the additional parameters.
* for details about its meaning.
*/ */
Selectivity Selectivity
restriction_selectivity(Query *root, restriction_selectivity(Query *root,
@ -237,7 +236,8 @@ restriction_selectivity(Query *root,
Selectivity Selectivity
join_selectivity(Query *root, join_selectivity(Query *root,
Oid operator, Oid operator,
List *args) List *args,
JoinType jointype)
{ {
RegProcedure oprjoin = get_oprjoin(operator); RegProcedure oprjoin = get_oprjoin(operator);
float8 result; float8 result;
@ -249,10 +249,11 @@ join_selectivity(Query *root,
if (!oprjoin) if (!oprjoin)
return (Selectivity) 0.5; return (Selectivity) 0.5;
result = DatumGetFloat8(OidFunctionCall3(oprjoin, result = DatumGetFloat8(OidFunctionCall4(oprjoin,
PointerGetDatum(root), PointerGetDatum(root),
ObjectIdGetDatum(operator), ObjectIdGetDatum(operator),
PointerGetDatum(args))); PointerGetDatum(args),
Int16GetDatum(jointype)));
if (result < 0.0 || result > 1.0) if (result < 0.0 || result > 1.0)
elog(ERROR, "join_selectivity: bad value %f", result); elog(ERROR, "join_selectivity: bad value %f", result);

75
src/backend/utils/adt/selfuncs.c
Unescape View File

@ -15,7 +15,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.130 2003/01/27 20:51:54 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.131 2003/01/28 22:13:35 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -56,13 +56,18 @@
* float8 oprrest (internal, oid, internal, int4); * float8 oprrest (internal, oid, internal, int4);
* *
* The call convention for a join estimator (oprjoin function) is similar * The call convention for a join estimator (oprjoin function) is similar
* except that varRelid is not needed: * except that varRelid is not needed, and instead the join type is
* supplied:
* *
* Selectivity oprjoin (Query *root, * Selectivity oprjoin (Query *root,
* Oid operator, * Oid operator,
* List *args); * List *args,
* JoinType jointype);
*
* float8 oprjoin (internal, oid, internal, int2);
* *
* float8 oprjoin (internal, oid, internal); * (We deliberately make the SQL signature different to facilitate
* catching errors.)
*---------- *----------
*/ */
@ -1009,7 +1014,8 @@ icnlikesel(PG_FUNCTION_ARGS)
* booltestsel - Selectivity of BooleanTest Node. * booltestsel - Selectivity of BooleanTest Node.
*/ */
Selectivity Selectivity
booltestsel(Query *root, BoolTestType booltesttype, Node *arg, int varRelid) booltestsel(Query *root, BoolTestType booltesttype, Node *arg,
int varRelid, JoinType jointype)
{ {
Var *var; Var *var;
Oid relid; Oid relid;
@ -1047,11 +1053,13 @@ booltestsel(Query *root, BoolTestType booltesttype, Node *arg, int varRelid)
break; break;
case IS_TRUE: case IS_TRUE:
case IS_NOT_FALSE: case IS_NOT_FALSE:
selec = (double) clause_selectivity(root, arg, varRelid); selec = (double) clause_selectivity(root, arg,
varRelid, jointype);
break; break;
case IS_FALSE: case IS_FALSE:
case IS_NOT_TRUE: case IS_NOT_TRUE:
selec = 1.0 - (double) clause_selectivity(root, arg, varRelid); selec = 1.0 - (double) clause_selectivity(root, arg,
varRelid, jointype);
break; break;
default: default:
elog(ERROR, "booltestsel: unexpected booltesttype %d", elog(ERROR, "booltestsel: unexpected booltesttype %d",
@ -1321,6 +1329,7 @@ eqjoinsel(PG_FUNCTION_ARGS)
Query *root = (Query *) PG_GETARG_POINTER(0); Query *root = (Query *) PG_GETARG_POINTER(0);
Oid operator = PG_GETARG_OID(1); Oid operator = PG_GETARG_OID(1);
List *args = (List *) PG_GETARG_POINTER(2); List *args = (List *) PG_GETARG_POINTER(2);
JoinType jointype = (JoinType) PG_GETARG_INT16(3);
Var *var1; Var *var1;
Var *var2; Var *var2;
double selec; double selec;
@ -1421,6 +1430,8 @@ eqjoinsel(PG_FUNCTION_ARGS)
FmgrInfo eqproc; FmgrInfo eqproc;
bool *hasmatch1; bool *hasmatch1;
bool *hasmatch2; bool *hasmatch2;
double nullfrac1 = stats1->stanullfrac;
double nullfrac2 = stats2->stanullfrac;
double matchprodfreq, double matchprodfreq,
matchfreq1, matchfreq1,
matchfreq2, matchfreq2,
@ -1434,10 +1445,36 @@ eqjoinsel(PG_FUNCTION_ARGS)
nmatches; nmatches;
fmgr_info(get_opcode(operator), &eqproc); fmgr_info(get_opcode(operator), &eqproc);
hasmatch1 = (bool *) palloc(nvalues1 * sizeof(bool)); hasmatch1 = (bool *) palloc0(nvalues1 * sizeof(bool));
memset(hasmatch1, 0, nvalues1 * sizeof(bool)); hasmatch2 = (bool *) palloc0(nvalues2 * sizeof(bool));
hasmatch2 = (bool *) palloc(nvalues2 * sizeof(bool));
memset(hasmatch2, 0, nvalues2 * sizeof(bool)); /*
* If we are doing any variant of JOIN_IN, pretend all the values
* of the righthand relation are unique (ie, act as if it's been
* DISTINCT'd).
*
* NOTE: it might seem that we should unique-ify the lefthand
* input when considering JOIN_REVERSE_IN. But this is not so,
* because the join clause we've been handed has not been
* commuted from the way the parser originally wrote it. We know
* that the unique side of the IN clause is *always* on the right.
*
* NOTE: it would be dangerous to try to be smart about JOIN_LEFT
* or JOIN_RIGHT here, because we do not have enough information
* to determine which var is really on which side of the join.
* Perhaps someday we should pass in more information.
*/
if (jointype == JOIN_IN ||
jointype == JOIN_REVERSE_IN ||
jointype == JOIN_UNIQUE_INNER ||
jointype == JOIN_UNIQUE_OUTER)
{
float4 oneovern = 1.0 / nd2;
for (i = 0; i < nvalues2; i++)
numbers2[i] = oneovern;
nullfrac2 = oneovern;
}
/* /*
* Note we assume that each MCV will match at most one member * Note we assume that each MCV will match at most one member
@ -1496,8 +1533,8 @@ eqjoinsel(PG_FUNCTION_ARGS)
* Compute total frequency of non-null values that are not in * Compute total frequency of non-null values that are not in
* the MCV lists. * the MCV lists.
*/ */
otherfreq1 = 1.0 - stats1->stanullfrac - matchfreq1 - unmatchfreq1; otherfreq1 = 1.0 - nullfrac1 - matchfreq1 - unmatchfreq1;
otherfreq2 = 1.0 - stats2->stanullfrac - matchfreq2 - unmatchfreq2; otherfreq2 = 1.0 - nullfrac2 - matchfreq2 - unmatchfreq2;
CLAMP_PROBABILITY(otherfreq1); CLAMP_PROBABILITY(otherfreq1);
CLAMP_PROBABILITY(otherfreq2); CLAMP_PROBABILITY(otherfreq2);
@ -1585,6 +1622,7 @@ neqjoinsel(PG_FUNCTION_ARGS)
Query *root = (Query *) PG_GETARG_POINTER(0); Query *root = (Query *) PG_GETARG_POINTER(0);
Oid operator = PG_GETARG_OID(1); Oid operator = PG_GETARG_OID(1);
List *args = (List *) PG_GETARG_POINTER(2); List *args = (List *) PG_GETARG_POINTER(2);
JoinType jointype = (JoinType) PG_GETARG_INT16(3);
Oid eqop; Oid eqop;
float8 result; float8 result;
@ -1595,11 +1633,11 @@ neqjoinsel(PG_FUNCTION_ARGS)
eqop = get_negator(operator); eqop = get_negator(operator);
if (eqop) if (eqop)
{ {
result = DatumGetFloat8(DirectFunctionCall3(eqjoinsel, result = DatumGetFloat8(DirectFunctionCall4(eqjoinsel,
PointerGetDatum(root), PointerGetDatum(root),
ObjectIdGetDatum(eqop), ObjectIdGetDatum(eqop),
PointerGetDatum(args))); PointerGetDatum(args),
Int16GetDatum(jointype)));
} }
else else
{ {
@ -3784,7 +3822,8 @@ genericcostestimate(Query *root, RelOptInfo *rel,
/* Estimate the fraction of main-table tuples that will be visited */ /* Estimate the fraction of main-table tuples that will be visited */
*indexSelectivity = clauselist_selectivity(root, selectivityQuals, *indexSelectivity = clauselist_selectivity(root, selectivityQuals,
lfirsti(rel->relids)); lfirsti(rel->relids),
JOIN_INNER);
/* /*
* Estimate the number of tuples that will be visited. We do it in * Estimate the number of tuples that will be visited. We do it in

4
src/include/catalog/catversion.h
Unescape View File

@ -37,7 +37,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: catversion.h,v 1.173 2003/01/23 23:39:04 petere Exp $ * $Id: catversion.h,v 1.174 2003/01/28 22:13:36 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -53,6 +53,6 @@
*/ */
/* yyyymmddN */ /* yyyymmddN */
#define CATALOG_VERSION_NO 200301241 #define CATALOG_VERSION_NO 200301281
#endif #endif

32
src/include/catalog/pg_proc.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: pg_proc.h,v 1.281 2003/01/09 00:58:41 tgl Exp $ * $Id: pg_proc.h,v 1.282 2003/01/28 22:13:36 tgl Exp $
* *
* NOTES * NOTES
* The script catalog/genbki.sh reads this file and generates .bki * The script catalog/genbki.sh reads this file and generates .bki
@ -218,13 +218,13 @@ DATA(insert OID = 103 ( scalarltsel PGNSP PGUID 12 f f t f s 4 701 "2281 26
DESCR("restriction selectivity of < and related operators on scalar datatypes"); DESCR("restriction selectivity of < and related operators on scalar datatypes");
DATA(insert OID = 104 ( scalargtsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" scalargtsel - _null_ )); DATA(insert OID = 104 ( scalargtsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" scalargtsel - _null_ ));
DESCR("restriction selectivity of > and related operators on scalar datatypes"); DESCR("restriction selectivity of > and related operators on scalar datatypes");
DATA(insert OID = 105 ( eqjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" eqjoinsel - _null_ )); DATA(insert OID = 105 ( eqjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" eqjoinsel - _null_ ));
DESCR("join selectivity of = and related operators"); DESCR("join selectivity of = and related operators");
DATA(insert OID = 106 ( neqjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" neqjoinsel - _null_ )); DATA(insert OID = 106 ( neqjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" neqjoinsel - _null_ ));
DESCR("join selectivity of <> and related operators"); DESCR("join selectivity of <> and related operators");
DATA(insert OID = 107 ( scalarltjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" scalarltjoinsel - _null_ )); DATA(insert OID = 107 ( scalarltjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" scalarltjoinsel - _null_ ));
DESCR("join selectivity of < and related operators on scalar datatypes"); DESCR("join selectivity of < and related operators on scalar datatypes");
DATA(insert OID = 108 ( scalargtjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" scalargtjoinsel - _null_ )); DATA(insert OID = 108 ( scalargtjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" scalargtjoinsel - _null_ ));
DESCR("join selectivity of > and related operators on scalar datatypes"); DESCR("join selectivity of > and related operators on scalar datatypes");
DATA(insert OID = 109 ( unknownin PGNSP PGUID 12 f f t f i 1 705 "2275" unknownin - _null_ )); DATA(insert OID = 109 ( unknownin PGNSP PGUID 12 f f t f i 1 705 "2275" unknownin - _null_ ));
@ -290,7 +290,7 @@ DATA(insert OID = 138 ( box_center PGNSP PGUID 12 f f t f i 1 600 "603" bo
DESCR("center of"); DESCR("center of");
DATA(insert OID = 139 ( areasel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" areasel - _null_ )); DATA(insert OID = 139 ( areasel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" areasel - _null_ ));
DESCR("restriction selectivity for area-comparison operators"); DESCR("restriction selectivity for area-comparison operators");
DATA(insert OID = 140 ( areajoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" areajoinsel - _null_ )); DATA(insert OID = 140 ( areajoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" areajoinsel - _null_ ));
DESCR("join selectivity for area-comparison operators"); DESCR("join selectivity for area-comparison operators");
DATA(insert OID = 141 ( int4mul PGNSP PGUID 12 f f t f i 2 23 "23 23" int4mul - _null_ )); DATA(insert OID = 141 ( int4mul PGNSP PGUID 12 f f t f i 2 23 "23 23" int4mul - _null_ ));
DESCR("multiply"); DESCR("multiply");
@ -1590,11 +1590,11 @@ DESCR("current transaction time");
DATA(insert OID = 1300 ( positionsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" positionsel - _null_ )); DATA(insert OID = 1300 ( positionsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" positionsel - _null_ ));
DESCR("restriction selectivity for position-comparison operators"); DESCR("restriction selectivity for position-comparison operators");
DATA(insert OID = 1301 ( positionjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" positionjoinsel - _null_ )); DATA(insert OID = 1301 ( positionjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" positionjoinsel - _null_ ));
DESCR("join selectivity for position-comparison operators"); DESCR("join selectivity for position-comparison operators");
DATA(insert OID = 1302 ( contsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" contsel - _null_ )); DATA(insert OID = 1302 ( contsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" contsel - _null_ ));
DESCR("restriction selectivity for containment comparison operators"); DESCR("restriction selectivity for containment comparison operators");
DATA(insert OID = 1303 ( contjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" contjoinsel - _null_ )); DATA(insert OID = 1303 ( contjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" contjoinsel - _null_ ));
DESCR("join selectivity for containment comparison operators"); DESCR("join selectivity for containment comparison operators");
DATA(insert OID = 1304 ( overlaps PGNSP PGUID 12 f f f f i 4 16 "1184 1184 1184 1184" overlaps_timestamp - _null_ )); DATA(insert OID = 1304 ( overlaps PGNSP PGUID 12 f f f f i 4 16 "1184 1184 1184 1184" overlaps_timestamp - _null_ ));
@ -2545,9 +2545,9 @@ DATA(insert OID = 1814 ( iclikesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 228
DESCR("restriction selectivity of ILIKE"); DESCR("restriction selectivity of ILIKE");
DATA(insert OID = 1815 ( icnlikesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" icnlikesel - _null_ )); DATA(insert OID = 1815 ( icnlikesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" icnlikesel - _null_ ));
DESCR("restriction selectivity of NOT ILIKE"); DESCR("restriction selectivity of NOT ILIKE");
DATA(insert OID = 1816 ( iclikejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" iclikejoinsel - _null_ )); DATA(insert OID = 1816 ( iclikejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" iclikejoinsel - _null_ ));
DESCR("join selectivity of ILIKE"); DESCR("join selectivity of ILIKE");
DATA(insert OID = 1817 ( icnlikejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" icnlikejoinsel - _null_ )); DATA(insert OID = 1817 ( icnlikejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" icnlikejoinsel - _null_ ));
DESCR("join selectivity of NOT ILIKE"); DESCR("join selectivity of NOT ILIKE");
DATA(insert OID = 1818 ( regexeqsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" regexeqsel - _null_ )); DATA(insert OID = 1818 ( regexeqsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" regexeqsel - _null_ ));
DESCR("restriction selectivity of regex match"); DESCR("restriction selectivity of regex match");
@ -2561,17 +2561,17 @@ DATA(insert OID = 1822 ( nlikesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281
DESCR("restriction selectivity of NOT LIKE"); DESCR("restriction selectivity of NOT LIKE");
DATA(insert OID = 1823 ( icregexnesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" icregexnesel - _null_ )); DATA(insert OID = 1823 ( icregexnesel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 23" icregexnesel - _null_ ));
DESCR("restriction selectivity of case-insensitive regex non-match"); DESCR("restriction selectivity of case-insensitive regex non-match");
DATA(insert OID = 1824 ( regexeqjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" regexeqjoinsel - _null_ )); DATA(insert OID = 1824 ( regexeqjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" regexeqjoinsel - _null_ ));
DESCR("join selectivity of regex match"); DESCR("join selectivity of regex match");
DATA(insert OID = 1825 ( likejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" likejoinsel - _null_ )); DATA(insert OID = 1825 ( likejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" likejoinsel - _null_ ));
DESCR("join selectivity of LIKE"); DESCR("join selectivity of LIKE");
DATA(insert OID = 1826 ( icregexeqjoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" icregexeqjoinsel - _null_ )); DATA(insert OID = 1826 ( icregexeqjoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" icregexeqjoinsel - _null_ ));
DESCR("join selectivity of case-insensitive regex match"); DESCR("join selectivity of case-insensitive regex match");
DATA(insert OID = 1827 ( regexnejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" regexnejoinsel - _null_ )); DATA(insert OID = 1827 ( regexnejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" regexnejoinsel - _null_ ));
DESCR("join selectivity of regex non-match"); DESCR("join selectivity of regex non-match");
DATA(insert OID = 1828 ( nlikejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" nlikejoinsel - _null_ )); DATA(insert OID = 1828 ( nlikejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" nlikejoinsel - _null_ ));
DESCR("join selectivity of NOT LIKE"); DESCR("join selectivity of NOT LIKE");
DATA(insert OID = 1829 ( icregexnejoinsel PGNSP PGUID 12 f f t f s 3 701 "2281 26 2281" icregexnejoinsel - _null_ )); DATA(insert OID = 1829 ( icregexnejoinsel PGNSP PGUID 12 f f t f s 4 701 "2281 26 2281 21" icregexnejoinsel - _null_ ));
DESCR("join selectivity of case-insensitive regex non-match"); DESCR("join selectivity of case-insensitive regex non-match");
/* Aggregate-related functions */ /* Aggregate-related functions */

17
src/include/optimizer/cost.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: cost.h,v 1.51 2003/01/27 20:51:54 tgl Exp $ * $Id: cost.h,v 1.52 2003/01/28 22:13:41 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -88,13 +88,16 @@ extern void set_function_size_estimates(Query *root, RelOptInfo *rel);
* routines to compute clause selectivities * routines to compute clause selectivities
*/ */
extern Selectivity restrictlist_selectivity(Query *root, extern Selectivity restrictlist_selectivity(Query *root,
List *restrictinfo_list, List *restrictinfo_list,
int varRelid); int varRelid,
JoinType jointype);
extern Selectivity clauselist_selectivity(Query *root, extern Selectivity clauselist_selectivity(Query *root,
List *clauses, List *clauses,
int varRelid); int varRelid,
JoinType jointype);
extern Selectivity clause_selectivity(Query *root, extern Selectivity clause_selectivity(Query *root,
Node *clause, Node *clause,
int varRelid); int varRelid,
JoinType jointype);
#endif /* COST_H */ #endif /* COST_H */

7
src/include/optimizer/plancat.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: plancat.h,v 1.27 2002/06/20 20:29:51 momjian Exp $ * $Id: plancat.h,v 1.28 2003/01/28 22:13:41 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -34,7 +34,8 @@ extern Selectivity restriction_selectivity(Query *root,
int varRelid); int varRelid);
extern Selectivity join_selectivity(Query *root, extern Selectivity join_selectivity(Query *root,
Oid operator, Oid operator,
List *args); List *args,
JoinType jointype);
#endif /* PLANCAT_H */ #endif /* PLANCAT_H */

4
src/include/utils/selfuncs.h
Unescape View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: selfuncs.h,v 1.11 2003/01/20 18:55:07 tgl Exp $ * $Id: selfuncs.h,v 1.12 2003/01/28 22:13:41 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -67,7 +67,7 @@ extern Datum nlikejoinsel(PG_FUNCTION_ARGS);
extern Datum icnlikejoinsel(PG_FUNCTION_ARGS); extern Datum icnlikejoinsel(PG_FUNCTION_ARGS);
extern Selectivity booltestsel(Query *root, BoolTestType booltesttype, extern Selectivity booltestsel(Query *root, BoolTestType booltesttype,
Node *arg, int varRelid); Node *arg, int varRelid, JoinType jointype);
extern Selectivity nulltestsel(Query *root, NullTestType nulltesttype, extern Selectivity nulltestsel(Query *root, NullTestType nulltesttype,
Node *arg, int varRelid); Node *arg, int varRelid);

7
src/test/regress/expected/opr_sanity.out
Unescape View File

@ -530,16 +530,17 @@ WHERE p1.oprrest = p2.oid AND
-- If oprjoin is set, the operator must be a binary boolean op, -- If oprjoin is set, the operator must be a binary boolean op,
-- and it must link to a proc with the right signature -- and it must link to a proc with the right signature
-- to be a join selectivity estimator. -- to be a join selectivity estimator.
-- The proc signature we want is: float8 proc(internal, oid, internal) -- The proc signature we want is: float8 proc(internal, oid, internal, int2)
SELECT p1.oid, p1.oprname, p2.oid, p2.proname SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2 FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprjoin = p2.oid AND WHERE p1.oprjoin = p2.oid AND
(p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR (p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
p2.prorettype != 'float8'::regtype OR p2.proretset OR p2.prorettype != 'float8'::regtype OR p2.proretset OR
p2.pronargs != 3 OR p2.pronargs != 4 OR
p2.proargtypes[0] != 'internal'::regtype OR p2.proargtypes[0] != 'internal'::regtype OR
p2.proargtypes[1] != 'oid'::regtype OR p2.proargtypes[1] != 'oid'::regtype OR
p2.proargtypes[2] != 'internal'::regtype); p2.proargtypes[2] != 'internal'::regtype OR
p2.proargtypes[3] != 'int2'::regtype);
oid | oprname | oid | proname oid | oprname | oid | proname
-----+---------+-----+--------- -----+---------+-----+---------
(0 rows) (0 rows)

4
src/test/regress/expected/subselect.out
Unescape View File

@ -134,10 +134,10 @@ SELECT '' AS five, f1 AS "Correlated Field"
WHERE f3 IS NOT NULL); WHERE f3 IS NOT NULL);
five | Correlated Field five | Correlated Field
------+------------------ ------+------------------
| 1
| 2
| 2 | 2
| 3 | 3
| 1
| 2
| 3 | 3
(5 rows) (5 rows)

7
src/test/regress/sql/opr_sanity.sql
Unescape View File

@ -444,17 +444,18 @@ WHERE p1.oprrest = p2.oid AND
-- If oprjoin is set, the operator must be a binary boolean op, -- If oprjoin is set, the operator must be a binary boolean op,
-- and it must link to a proc with the right signature -- and it must link to a proc with the right signature
-- to be a join selectivity estimator. -- to be a join selectivity estimator.
-- The proc signature we want is: float8 proc(internal, oid, internal) -- The proc signature we want is: float8 proc(internal, oid, internal, int2)
SELECT p1.oid, p1.oprname, p2.oid, p2.proname SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2 FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprjoin = p2.oid AND WHERE p1.oprjoin = p2.oid AND
(p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR (p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
p2.prorettype != 'float8'::regtype OR p2.proretset OR p2.prorettype != 'float8'::regtype OR p2.proretset OR
p2.pronargs != 3 OR p2.pronargs != 4 OR
p2.proargtypes[0] != 'internal'::regtype OR p2.proargtypes[0] != 'internal'::regtype OR
p2.proargtypes[1] != 'oid'::regtype OR p2.proargtypes[1] != 'oid'::regtype OR
p2.proargtypes[2] != 'internal'::regtype); p2.proargtypes[2] != 'internal'::regtype OR
p2.proargtypes[3] != 'int2'::regtype);
-- **************** pg_aggregate **************** -- **************** pg_aggregate ****************

Write Preview
Loading…
Cancel
Save