diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index f5cffcb..13ceb93 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -101,6 +101,7 @@ #include #include +#include "access/brin.h" #include "access/gin.h" #include "access/htup_details.h" #include "access/sysattr.h" @@ -7724,11 +7725,22 @@ brincostestimate(PlannerInfo *root, IndexPath *path, double loop_count, List *indexOrderBys = path->indexorderbys; double numPages = index->pages; double numTuples = index->tuples; + RelOptInfo *baserel = index->rel; List *qinfos; Cost spc_seq_page_cost; Cost spc_random_page_cost; double qual_op_cost; double qual_arg_cost; + double qualSelectivity; + BlockNumber pagesPerRange; + double indexRanges; + double minimalRanges; + double estimatedRanges; + double selec; + Relation indexRel; + ListCell *l; + VariableStatData vardata; + RangeTblEntry *rte; /* Do preliminary analysis of indexquals */ qinfos = deconstruct_indexquals(path); @@ -7752,15 +7764,151 @@ brincostestimate(PlannerInfo *root, IndexPath *path, double loop_count, */ *indexTotalCost = spc_random_page_cost * numPages * loop_count; - *indexSelectivity = - clauselist_selectivity(root, indexQuals, - path->indexinfo->rel->relid, - JOIN_INNER, NULL, - path->indexinfo->rel); - *indexCorrelation = 1; + /* + * Compute index correlation + * + * Because we can use all index quals equally when scanning, we can use + * the largest correlation (in absolute value) among columns used by the + * query. Start at zero, the worst possible case. If we cannot find + * any correlation statistics, we will keep use it as 0. + */ + *indexCorrelation = 0; + + rte = planner_rt_fetch(index->rel->relid, root); + + Assert(rte->rtekind == RTE_RELATION); + + foreach(l, qinfos) + { + IndexQualInfo *qinfo = (IndexQualInfo *) lfirst(l); + AttrNumber attnum = index->indexkeys[qinfo->indexcol]; + + /* attempt to lookup stats in relation for this index column */ + if (attnum != 0) + { + /* Simple variable -- look to stats for the underlying table */ + if (get_relation_stats_hook && + (*get_relation_stats_hook) (root, rte, attnum, &vardata)) + { + /* + * The hook took control of acquiring a stats tuple. + * If it did supply a tuple, it'd better have supplied + * a freefunc. + */ + if (HeapTupleIsValid(vardata.statsTuple) && + !vardata.freefunc) + elog(ERROR, "no function provided to release variable stats with"); + } + else + { + vardata.statsTuple = SearchSysCache3(STATRELATTINH, + ObjectIdGetDatum(rte->relid), + Int16GetDatum(attnum), + BoolGetDatum(false)); + vardata.freefunc = ReleaseSysCache; + } + } + else + { + /* + * Looks like we've found an expression column in the index. Let's + * see if there's any stats for it. + */ + + /* get the attnum from the 0-based index. */ + attnum = qinfo->indexcol + 1; + + if (get_index_stats_hook && + (*get_index_stats_hook) (root, index->indexoid, attnum, &vardata)) + { + /* + * The hook took control of acquiring a stats tuple. If it did + * supply a tuple, it'd better have supplied a freefunc. + */ + if (HeapTupleIsValid(vardata.statsTuple) && + !vardata.freefunc) + elog(ERROR, "no function provided to release variable stats with"); + } + else + { + vardata.statsTuple = SearchSysCache3(STATRELATTINH, + ObjectIdGetDatum(index->indexoid), + Int16GetDatum(attnum), + BoolGetDatum(false)); + vardata.freefunc = ReleaseSysCache; + } + } + + if (HeapTupleIsValid(vardata.statsTuple)) + { + float4 *numbers; + int nnumbers; + + if (get_attstatsslot(vardata.statsTuple, InvalidOid, 0, + STATISTIC_KIND_CORRELATION, + InvalidOid, + NULL, + NULL, NULL, + &numbers, &nnumbers)) + { + double varCorrelation = 0.0; + + if (nnumbers > 0); + varCorrelation = Abs(numbers[0]); + + if (varCorrelation > *indexCorrelation) + *indexCorrelation = varCorrelation; + + free_attstatsslot(InvalidOid, NULL, 0, numbers, nnumbers); + } + } + + ReleaseVariableStats(vardata); + } + + qualSelectivity = clauselist_selectivity(root, indexQuals, + baserel->relid, + JOIN_INNER, NULL, + baserel); + + indexRel = index_open(index->indexoid, AccessShareLock); + pagesPerRange = BrinGetPagesPerRange(indexRel); + index_close(indexRel, AccessShareLock); + + Assert(pagesPerRange > 0); + + /* work out the actual number of ranges in the index */ + indexRanges = Max(ceil((double) baserel->pages / pagesPerRange), 1.0); + + /* + * Now calculate the minimum possible ranges we could match with if all of + * the rows were in the perfect order in the table's heap. + */ + minimalRanges = ceil(indexRanges * qualSelectivity); + + /* + * Now estimate the number of ranges that we'll touch by using the + * indexCorrelation from the stats. Careful not to divide by zero. + * + * Here we're using the absolute value of the correlation as found from + * the statistics above. It may be questionable as to whether this is a + * good idea, but we have little else to go on for now.. In any case, + * this is much better than assuming everything is correlated perfectly. + */ + if (*indexCorrelation < 1.0e-10) + estimatedRanges = indexRanges; + else + estimatedRanges = Min(minimalRanges / *indexCorrelation, indexRanges); + + /* we expect to visit this portion of the table */ + selec = estimatedRanges / indexRanges; + + CLAMP_PROBABILITY(selec); + + *indexSelectivity = selec; /* - * Add on index qual eval costs, much as in genericcostestimate. + * Add the index qual costs, much as in genericcostestimate. */ qual_arg_cost = other_operands_eval_cost(root, qinfos) + orderby_operands_eval_cost(root, path); @@ -7769,8 +7917,19 @@ brincostestimate(PlannerInfo *root, IndexPath *path, double loop_count, *indexStartupCost += qual_arg_cost; *indexTotalCost += qual_arg_cost; - *indexTotalCost += (numTuples * *indexSelectivity) * (cpu_index_tuple_cost + qual_op_cost); - *indexPages = index->pages; - /* XXX what about pages_per_range? */ + /* Also charge for our visit to each range in the index */ + *indexTotalCost += indexRanges * (cpu_index_tuple_cost + qual_op_cost); + + /* + * Charge a small amount per range tuple which we expect to match to. This + * is meant to reflect the costs of manipulating the bitmap. The BRIN scan + * will set a bit for each page in the range when we find a matching + * range, so we must multiply the charge by the number of pages in the + * range. + */ + *indexTotalCost += 0.1 * cpu_operator_cost * estimatedRanges * + pagesPerRange; + + *indexPages = index->pages; } diff --git a/src/test/regress/expected/brin.out b/src/test/regress/expected/brin.out index a40f87a..ca80f00 100644 --- a/src/test/regress/expected/brin.out +++ b/src/test/regress/expected/brin.out @@ -363,6 +363,8 @@ BEGIN END LOOP; END; $x$; +RESET enable_seqscan; +RESET enable_bitmapscan; INSERT INTO brintest SELECT repeat(stringu1, 42)::bytea, substr(stringu1, 1, 1)::"char", @@ -481,3 +483,27 @@ SELECT brin_summarize_range('brin_summarize_idx', -1); ERROR: block number out of range: -1 SELECT brin_summarize_range('brin_summarize_idx', 4294967296); ERROR: block number out of range: 4294967296 +-- test brin cost estimates behave sanely based on correlation of values +CREATE TABLE brin_test (a INT, b INT); +INSERT INTO brin_test SELECT x/100,x%100 FROM generate_series(1,10000) x(x); +CREATE INDEX brin_test_a_idx ON brin_test USING brin (a) WITH (pages_per_range = 2); +CREATE INDEX brin_test_b_idx ON brin_test USING brin (b) WITH (pages_per_range = 2); +VACUUM ANALYZE brin_test; +-- Ensure brin index is used when columns are perfectly correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test WHERE a = 1; + QUERY PLAN +-------------------------------------------- + Bitmap Heap Scan on brin_test + Recheck Cond: (a = 1) + -> Bitmap Index Scan on brin_test_a_idx + Index Cond: (a = 1) +(4 rows) + +-- Ensure brin index is not used when values are not correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test WHERE b = 1; + QUERY PLAN +----------------------- + Seq Scan on brin_test + Filter: (b = 1) +(2 rows) + diff --git a/src/test/regress/sql/brin.sql b/src/test/regress/sql/brin.sql index 521b22f..11f8fe9 100644 --- a/src/test/regress/sql/brin.sql +++ b/src/test/regress/sql/brin.sql @@ -370,6 +370,9 @@ BEGIN END; $x$; +RESET enable_seqscan; +RESET enable_bitmapscan; + INSERT INTO brintest SELECT repeat(stringu1, 42)::bytea, substr(stringu1, 1, 1)::"char", @@ -444,3 +447,16 @@ SELECT brin_summarize_range('brin_summarize_idx', 4294967295); -- invalid block number values SELECT brin_summarize_range('brin_summarize_idx', -1); SELECT brin_summarize_range('brin_summarize_idx', 4294967296); + + +-- test brin cost estimates behave sanely based on correlation of values +CREATE TABLE brin_test (a INT, b INT); +INSERT INTO brin_test SELECT x/100,x%100 FROM generate_series(1,10000) x(x); +CREATE INDEX brin_test_a_idx ON brin_test USING brin (a) WITH (pages_per_range = 2); +CREATE INDEX brin_test_b_idx ON brin_test USING brin (b) WITH (pages_per_range = 2); +VACUUM ANALYZE brin_test; + +-- Ensure brin index is used when columns are perfectly correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test WHERE a = 1; +-- Ensure brin index is not used when values are not correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test WHERE b = 1;