between index order and table order.
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/Attic/indexcost.sgml,v 2.6 2000/12/22 21:51:57 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/Attic/indexcost.sgml,v 2.7 2001/05/09 23:13:34 tgl Exp $
-->
<chapter id="indexcost">
List *indexQuals,
Cost *indexStartupCost,
Cost *indexTotalCost,
- Selectivity *indexSelectivity);
+ Selectivity *indexSelectivity,
+ double *indexCorrelation);
</programlisting>
The first four parameters are inputs:
</para>
<para>
- The last three parameters are pass-by-reference outputs:
+ The last four parameters are pass-by-reference outputs:
<variablelist>
<varlistentry>
</para>
</listitem>
</varlistentry>
+
+ <varlistentry>
+ <term>*indexCorrelation</term>
+ <listitem>
+ <para>
+ Set to correlation coefficient between index scan order and
+ underlying table's order
+ </para>
+ </listitem>
+ </varlistentry>
</variablelist>
</para>
tuples that actually pass the given qual conditions.
</para>
+ <para>
+ The indexCorrelation should be set to the correlation (ranging between
+ -1.0 and 1.0) between the index order and the table order. This is used
+ to adjust the estimate for the cost of fetching tuples from the main
+ table.
+ </para>
+
<procedure>
<title>Cost Estimation</title>
<para>
</programlisting>
</para>
</step>
+
+ <step>
+ <para>
+ Estimate the index correlation. For a simple ordered index on a single
+ field, this can be retrieved from pg_statistic. If the correlation
+ is not known, the conservative estimate is zero (no correlation).
+ </para>
+ </step>
</procedure>
<para>
<programlisting>
prorettype = 0
-pronargs = 7
-proargtypes = 0 0 0 0 0 0 0
+pronargs = 8
+proargtypes = 0 0 0 0 0 0 0 0
</programlisting>
We use zero ("opaque") for all the arguments since none of them have types
* result by interpolating between startup_cost and total_cost. In detail:
* actual_cost = startup_cost +
* (total_cost - startup_cost) * tuples_to_fetch / path->parent->rows;
- * Note that a relation's rows count (and, by extension, a Plan's plan_rows)
- * are set without regard to any LIMIT, so that this equation works properly.
- * (Also, these routines guarantee not to set the rows count to zero, so there
- * will be no zero divide.) The LIMIT is applied as a separate Plan node.
+ * Note that a base relation's rows count (and, by extension, plan_rows for
+ * plan nodes below the LIMIT node) are set without regard to any LIMIT, so
+ * that this equation works properly. (Also, these routines guarantee not to
+ * set the rows count to zero, so there will be no zero divide.) The LIMIT is
+ * applied as a top-level plan node.
*
*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.72 2001/05/09 00:35:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.73 2001/05/09 23:13:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
Cost startup_cost = 0;
Cost run_cost = 0;
- Cost cpu_per_tuple;
Cost indexStartupCost;
Cost indexTotalCost;
Selectivity indexSelectivity;
+ double indexCorrelation,
+ csquared;
+ Cost min_IO_cost,
+ max_IO_cost;
+ Cost cpu_per_tuple;
double tuples_fetched;
double pages_fetched;
+ double T,
+ b;
/* Should only be applied to base relations */
Assert(IsA(baserel, RelOptInfo) &&IsA(index, IndexOptInfo));
* Call index-access-method-specific code to estimate the processing
* cost for scanning the index, as well as the selectivity of the
* index (ie, the fraction of main-table tuples we will have to
- * retrieve).
+ * retrieve) and its correlation to the main-table tuple order.
*/
- OidFunctionCall7(index->amcostestimate,
+ OidFunctionCall8(index->amcostestimate,
PointerGetDatum(root),
PointerGetDatum(baserel),
PointerGetDatum(index),
PointerGetDatum(indexQuals),
PointerGetDatum(&indexStartupCost),
PointerGetDatum(&indexTotalCost),
- PointerGetDatum(&indexSelectivity));
+ PointerGetDatum(&indexSelectivity),
+ PointerGetDatum(&indexCorrelation));
/* all costs for touching index itself included here */
startup_cost += indexStartupCost;
run_cost += indexTotalCost - indexStartupCost;
- /*
+ /*----------
* Estimate number of main-table tuples and pages fetched.
*
- * If the number of tuples is much smaller than the number of pages in
- * the relation, each tuple will cost a separate nonsequential fetch.
- * If it is comparable or larger, then probably we will be able to
- * avoid some fetches. We use a growth rate of log(#tuples/#pages +
- * 1) --- probably totally bogus, but intuitively it gives the right
- * shape of curve at least.
+ * When the index ordering is uncorrelated with the table ordering,
+ * we use an approximation proposed by Mackert and Lohman, "Index Scans
+ * Using a Finite LRU Buffer: A Validated I/O Model", ACM Transactions
+ * on Database Systems, Vol. 14, No. 3, September 1989, Pages 401-424.
+ * The Mackert and Lohman approximation is that the number of pages
+ * fetched is
+ * PF =
+ * min(2TNs/(2T+Ns), T) when T <= b
+ * 2TNs/(2T+Ns) when T > b and Ns <= 2Tb/(2T-b)
+ * b + (Ns - 2Tb/(2T-b))*(T-b)/T when T > b and Ns > 2Tb/(2T-b)
+ * where
+ * T = # pages in table
+ * N = # tuples in table
+ * s = selectivity = fraction of table to be scanned
+ * b = # buffer pages available (we include kernel space here)
*
- * XXX if the relation has recently been "clustered" using this index,
- * then in fact the target tuples will be highly nonuniformly
- * distributed, and we will be seriously overestimating the scan cost!
- * Currently we have no way to know whether the relation has been
- * clustered, nor how much it's been modified since the last
- * clustering, so we ignore this effect. Would be nice to do better
- * someday.
+ * When the index ordering is exactly correlated with the table ordering
+ * (just after a CLUSTER, for example), the number of pages fetched should
+ * be just sT. What's more, these will be sequential fetches, not the
+ * random fetches that occur in the uncorrelated case. So, depending on
+ * the extent of correlation, we should estimate the actual I/O cost
+ * somewhere between s * T * 1.0 and PF * random_cost. We currently
+ * interpolate linearly between these two endpoints based on the
+ * correlation squared (XXX is that appropriate?).
+ *
+ * In any case the number of tuples fetched is Ns.
+ *----------
*/
tuples_fetched = indexSelectivity * baserel->tuples;
if (tuples_fetched < 1.0)
tuples_fetched = 1.0;
- if (baserel->pages > 0)
- pages_fetched = ceil(baserel->pages *
- log(tuples_fetched / baserel->pages + 1.0));
+ /* This part is the Mackert and Lohman formula */
+
+ T = (baserel->pages > 1) ? (double) baserel->pages : 1.0;
+ b = (effective_cache_size > 1) ? effective_cache_size : 1.0;
+
+ if (T <= b)
+ {
+ pages_fetched =
+ (2.0 * T * tuples_fetched) / (2.0 * T + tuples_fetched);
+ if (pages_fetched > T)
+ pages_fetched = T;
+ }
else
- pages_fetched = tuples_fetched;
+ {
+ double lim;
+
+ lim = (2.0 * T * b) / (2.0 * T - b);
+ if (tuples_fetched <= lim)
+ {
+ pages_fetched =
+ (2.0 * T * tuples_fetched) / (2.0 * T + tuples_fetched);
+ }
+ else
+ {
+ pages_fetched =
+ b + (tuples_fetched - lim) * (T - b) / T;
+ }
+ }
/*
- * Now estimate one nonsequential access per page fetched, plus
- * appropriate CPU costs per tuple.
+ * min_IO_cost corresponds to the perfectly correlated case (csquared=1),
+ * max_IO_cost to the perfectly uncorrelated case (csquared=0). Note
+ * that we just charge random_page_cost per page in the uncorrelated
+ * case, rather than using cost_nonsequential_access, since we've already
+ * accounted for caching effects by using the Mackert model.
*/
+ min_IO_cost = ceil(indexSelectivity * T);
+ max_IO_cost = pages_fetched * random_page_cost;
- /* disk costs for main table */
- run_cost += pages_fetched * cost_nonsequential_access(baserel->pages);
+ /*
+ * Now interpolate based on estimated index order correlation
+ * to get total disk I/O cost for main table accesses.
+ */
+ csquared = indexCorrelation * indexCorrelation;
- /* CPU costs */
- cpu_per_tuple = cpu_tuple_cost + baserel->baserestrictcost;
+ run_cost += max_IO_cost + csquared * (min_IO_cost - max_IO_cost);
/*
+ * Estimate CPU costs per tuple.
+ *
* Normally the indexquals will be removed from the list of
* restriction clauses that we have to evaluate as qpquals, so we
* should subtract their costs from baserestrictcost. For a lossy
* Rather than work out exactly how much to subtract, we don't
* subtract anything in that case either.
*/
+ cpu_per_tuple = cpu_tuple_cost + baserel->baserestrictcost;
+
if (!index->lossy && !is_injoin)
cpu_per_tuple -= cost_qual_eval(indexQuals);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.31 2001/04/18 20:42:55 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.32 2001/05/09 23:13:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct
{
int varno;
+ int varattno;
int sublevels_up;
-} contain_whole_tuple_var_context;
+} contain_var_reference_context;
typedef struct
{
static bool pull_varnos_walker(Node *node,
pull_varnos_context *context);
-static bool contain_whole_tuple_var_walker(Node *node,
- contain_whole_tuple_var_context *context);
+static bool contain_var_reference_walker(Node *node,
+ contain_var_reference_context *context);
static bool contain_var_clause_walker(Node *node, void *context);
static bool pull_var_clause_walker(Node *node,
pull_var_clause_context *context);
/*
- * contain_whole_tuple_var
+ * contain_var_reference
*
- * Detect whether a parsetree contains any references to the whole
- * tuple of a given rtable entry (ie, a Var with varattno = 0).
+ * Detect whether a parsetree contains any references to a specified
+ * attribute of a specified rtable entry.
*
* NOTE: this is used on not-yet-planned expressions. It may therefore find
* bare SubLinks, and if so it needs to recurse into them to look for uplevel
* SubPlan, we only need to look at the parameters passed to the subplan.
*/
bool
-contain_whole_tuple_var(Node *node, int varno, int levelsup)
+contain_var_reference(Node *node, int varno, int varattno, int levelsup)
{
- contain_whole_tuple_var_context context;
+ contain_var_reference_context context;
context.varno = varno;
+ context.varattno = varattno;
context.sublevels_up = levelsup;
/*
*/
if (node && IsA(node, Query))
return query_tree_walker((Query *) node,
- contain_whole_tuple_var_walker,
+ contain_var_reference_walker,
(void *) &context, true);
else
- return contain_whole_tuple_var_walker(node, &context);
+ return contain_var_reference_walker(node, &context);
}
static bool
-contain_whole_tuple_var_walker(Node *node,
- contain_whole_tuple_var_context *context)
+contain_var_reference_walker(Node *node,
+ contain_var_reference_context *context)
{
if (node == NULL)
return false;
Var *var = (Var *) node;
if (var->varno == context->varno &&
- var->varlevelsup == context->sublevels_up &&
- var->varattno == InvalidAttrNumber)
+ var->varattno == context->varattno &&
+ var->varlevelsup == context->sublevels_up)
return true;
return false;
}
*/
Expr *expr = (Expr *) node;
- if (contain_whole_tuple_var_walker((Node *) ((SubPlan *) expr->oper)->sublink->oper,
- context))
+ if (contain_var_reference_walker((Node *) ((SubPlan *) expr->oper)->sublink->oper,
+ context))
return true;
- if (contain_whole_tuple_var_walker((Node *) expr->args,
- context))
+ if (contain_var_reference_walker((Node *) expr->args,
+ context))
return true;
return false;
}
context->sublevels_up++;
result = query_tree_walker((Query *) node,
- contain_whole_tuple_var_walker,
+ contain_var_reference_walker,
(void *) context, true);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, contain_whole_tuple_var_walker,
+ return expression_tree_walker(node, contain_var_reference_walker,
(void *) context);
}
+/*
+ * contain_whole_tuple_var
+ *
+ * Detect whether a parsetree contains any references to the whole
+ * tuple of a given rtable entry (ie, a Var with varattno = 0).
+ */
+bool
+contain_whole_tuple_var(Node *node, int varno, int levelsup)
+{
+ return contain_var_reference(node, varno, InvalidAttrNumber, levelsup);
+}
+
+
/*
* contain_var_clause
* Recursively scan a clause to discover whether it contains any Var nodes
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.88 2001/05/07 00:43:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.89 2001/05/09 23:13:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/cost.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
+#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/int8.h"
{
#ifdef NOT_USED /* see neqjoinsel() before removing me! */
Oid opid = PG_GETARG_OID(0);
-
#endif
Oid relid1 = PG_GETARG_OID(1);
AttrNumber attno1 = PG_GETARG_INT16(2);
*-------------------------------------------------------------------------
*/
-static Datum
-genericcostestimate(PG_FUNCTION_ARGS)
+static void
+genericcostestimate(Query *root, RelOptInfo *rel,
+ IndexOptInfo *index, List *indexQuals,
+ Cost *indexStartupCost,
+ Cost *indexTotalCost,
+ Selectivity *indexSelectivity,
+ double *indexCorrelation)
{
- Query *root = (Query *) PG_GETARG_POINTER(0);
- RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
- IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
- List *indexQuals = (List *) PG_GETARG_POINTER(3);
- Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
- Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
- Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
double numIndexTuples;
double numIndexPages;
*indexTotalCost = numIndexPages +
(cpu_index_tuple_cost + cost_qual_eval(indexQuals)) * numIndexTuples;
- PG_RETURN_VOID();
+ /*
+ * Generic assumption about index correlation: there isn't any.
+ */
+ *indexCorrelation = 0.0;
}
-/*
- * For first cut, just use generic function for all index types.
- */
Datum
btcostestimate(PG_FUNCTION_ARGS)
{
- return genericcostestimate(fcinfo);
+ Query *root = (Query *) PG_GETARG_POINTER(0);
+ RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
+ IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
+ List *indexQuals = (List *) PG_GETARG_POINTER(3);
+ Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
+ Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
+ Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
+ double *indexCorrelation = (double *) PG_GETARG_POINTER(7);
+
+ genericcostestimate(root, rel, index, indexQuals,
+ indexStartupCost, indexTotalCost,
+ indexSelectivity, indexCorrelation);
+
+ /*
+ * If it's a functional index, leave the default zero-correlation
+ * estimate in place. If not, and if we can get an estimate for
+ * the first variable's ordering correlation C from pg_statistic,
+ * estimate the index correlation as C / number-of-columns.
+ * (The idea here is that multiple columns dilute the importance
+ * of the first column's ordering, but don't negate it entirely.)
+ */
+ if (index->indproc == InvalidOid)
+ {
+ Oid relid;
+ HeapTuple tuple;
+
+ relid = getrelid(lfirsti(rel->relids), root->rtable);
+ Assert(relid != InvalidOid);
+ tuple = SearchSysCache(STATRELATT,
+ ObjectIdGetDatum(relid),
+ Int16GetDatum(index->indexkeys[0]),
+ 0, 0);
+ if (HeapTupleIsValid(tuple))
+ {
+ Oid typid;
+ int32 typmod;
+ float4 *numbers;
+ int nnumbers;
+
+ get_atttypetypmod(relid, index->indexkeys[0],
+ &typid, &typmod);
+ if (get_attstatsslot(tuple, typid, typmod,
+ STATISTIC_KIND_CORRELATION,
+ index->ordering[0],
+ NULL, NULL, &numbers, &nnumbers))
+ {
+ double varCorrelation;
+ int nKeys;
+
+ Assert(nnumbers == 1);
+ varCorrelation = numbers[0];
+ for (nKeys = 1; index->indexkeys[nKeys] != 0; nKeys++)
+ /*skip*/;
+
+ *indexCorrelation = varCorrelation / nKeys;
+
+ free_attstatsslot(typid, NULL, 0, numbers, nnumbers);
+ }
+ ReleaseSysCache(tuple);
+ }
+ }
+
+ PG_RETURN_VOID();
}
Datum
rtcostestimate(PG_FUNCTION_ARGS)
{
- return genericcostestimate(fcinfo);
+ Query *root = (Query *) PG_GETARG_POINTER(0);
+ RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
+ IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
+ List *indexQuals = (List *) PG_GETARG_POINTER(3);
+ Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
+ Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
+ Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
+ double *indexCorrelation = (double *) PG_GETARG_POINTER(7);
+
+ genericcostestimate(root, rel, index, indexQuals,
+ indexStartupCost, indexTotalCost,
+ indexSelectivity, indexCorrelation);
+
+ PG_RETURN_VOID();
}
Datum
hashcostestimate(PG_FUNCTION_ARGS)
{
- return genericcostestimate(fcinfo);
+ Query *root = (Query *) PG_GETARG_POINTER(0);
+ RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
+ IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
+ List *indexQuals = (List *) PG_GETARG_POINTER(3);
+ Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
+ Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
+ Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
+ double *indexCorrelation = (double *) PG_GETARG_POINTER(7);
+
+ genericcostestimate(root, rel, index, indexQuals,
+ indexStartupCost, indexTotalCost,
+ indexSelectivity, indexCorrelation);
+
+ PG_RETURN_VOID();
}
Datum
gistcostestimate(PG_FUNCTION_ARGS)
{
- return genericcostestimate(fcinfo);
+ Query *root = (Query *) PG_GETARG_POINTER(0);
+ RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1);
+ IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2);
+ List *indexQuals = (List *) PG_GETARG_POINTER(3);
+ Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4);
+ Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5);
+ Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6);
+ double *indexCorrelation = (double *) PG_GETARG_POINTER(7);
+
+ genericcostestimate(root, rel, index, indexQuals,
+ indexStartupCost, indexTotalCost,
+ indexSelectivity, indexCorrelation);
+
+ PG_RETURN_VOID();
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.54 2001/05/09 00:35:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.55 2001/05/09 23:13:35 tgl Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
return -1;
}
+/*
+ * get_atttypetypmod
+ *
+ * A two-fer: given the relation id and the attribute number,
+ * fetch both type OID and atttypmod in a single cache lookup.
+ *
+ * Unlike the otherwise-similar get_atttype/get_atttypmod, this routine
+ * raises an error if it can't obtain the information.
+ */
+void
+get_atttypetypmod(Oid relid, AttrNumber attnum,
+ Oid *typid, int32 *typmod)
+{
+ HeapTuple tp;
+ Form_pg_attribute att_tup;
+
+ tp = SearchSysCache(ATTNUM,
+ ObjectIdGetDatum(relid),
+ Int16GetDatum(attnum),
+ 0, 0);
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for relation %u attribute %d",
+ relid, attnum);
+ att_tup = (Form_pg_attribute) GETSTRUCT(tp);
+
+ *typid = att_tup->atttypid;
+ *typmod = att_tup->atttypmod;
+ ReleaseSysCache(tp);
+}
+
/* ---------- INDEX CACHE ---------- */
/* watch this space...
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_proc.h,v 1.184 2001/03/22 04:00:39 momjian Exp $
+ * $Id: pg_proc.h,v 1.185 2001/05/09 23:13:35 tgl Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
DATA(insert OID = 89 ( version PGUID 12 f t f t 0 f 25 "" 100 0 0 100 pgsql_version - ));
DESCR("PostgreSQL version string");
-DATA(insert OID = 1265 ( rtcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 rtcostestimate - ));
+DATA(insert OID = 1265 ( rtcostestimate PGUID 12 f t f t 8 f 0 "0 0 0 0 0 0 0 0" 100 0 0 100 rtcostestimate - ));
DESCR("r-tree cost estimator");
-DATA(insert OID = 1268 ( btcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 btcostestimate - ));
+DATA(insert OID = 1268 ( btcostestimate PGUID 12 f t f t 8 f 0 "0 0 0 0 0 0 0 0" 100 0 0 100 btcostestimate - ));
DESCR("btree cost estimator");
/* OIDS 100 - 199 */
DATA(insert OID = 409 ( name PGUID 12 f t t t 1 f 19 "1042" 100 0 0 100 bpchar_name - ));
DESCR("convert char() to name");
-DATA(insert OID = 438 ( hashcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 hashcostestimate - ));
+DATA(insert OID = 438 ( hashcostestimate PGUID 12 f t f t 8 f 0 "0 0 0 0 0 0 0 0" 100 0 0 100 hashcostestimate - ));
DESCR("hash index cost estimator");
DATA(insert OID = 440 ( hashgettuple PGUID 12 f t f t 2 f 23 "0 0" 100 0 0 100 hashgettuple - ));
DATA(insert OID = 771 ( int2smaller PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2smaller - ));
DESCR("smaller of two");
-DATA(insert OID = 772 ( gistcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 gistcostestimate - ));
+DATA(insert OID = 772 ( gistcostestimate PGUID 12 f t f t 8 f 0 "0 0 0 0 0 0 0 0" 100 0 0 100 gistcostestimate - ));
DESCR("gist cost estimator");
DATA(insert OID = 774 ( gistgettuple PGUID 12 f t f t 2 f 23 "0 0" 100 0 0 100 gistgettuple - ));
DESCR("gist(internal)");
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: var.h,v 1.13 2001/04/18 20:42:55 tgl Exp $
+ * $Id: var.h,v 1.14 2001/05/09 23:13:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/primnodes.h"
extern List *pull_varnos(Node *node);
+extern bool contain_var_reference(Node *node, int varno, int varattno,
+ int levelsup);
extern bool contain_whole_tuple_var(Node *node, int varno, int levelsup);
extern bool contain_var_clause(Node *node);
extern List *pull_var_clause(Node *node, bool includeUpperVars);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.32 2001/05/09 00:35:09 tgl Exp $
+ * $Id: lsyscache.h,v 1.33 2001/05/09 23:13:37 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid get_atttype(Oid relid, AttrNumber attnum);
extern bool get_attisset(Oid relid, char *attname);
extern int32 get_atttypmod(Oid relid, AttrNumber attnum);
+extern void get_atttypetypmod(Oid relid, AttrNumber attnum,
+ Oid *typid, int32 *typmod);
extern RegProcedure get_opcode(Oid opno);
extern char *get_opname(Oid opno);
extern bool op_mergejoinable(Oid opno, Oid ltype, Oid rtype,
projects / postgresql.git / commitdiff