Paul Ramsey <pramsey@cleverelephant.ca> writes:
> I added three indexes to my test table:
> CREATE INDEX foo_g_gist_x ON foo USING GIST (g);
> CREATE INDEX foo_g_gist_nd_x ON foo USING GIST (g gist_geometry_ops);
> CREATE INDEX foo_g_spgist_x ON foo USING SPGIST (g);
> They all support the overlaps (&&) operator.
> So, SupportRequestIndexCondition happens three times, and each time I say “yep, sure, you can construct an index
conditionby putting the && operator between left_arg and right_arg”.
Sounds right.
> How does the planner end up deciding on which index to *actually* use?
It's whichever has the cheapest cost estimate. In case of an exact tie,
I believe it'll choose the index with lowest OID (or maybe highest OID,
not sure).
> The selectivity is the same, the operator is the same. I found that I got the ND GIST one first, then the SPGIST and
finallythe 2d GIST, which is unfortunate, because the 2D and SPGIST are almost certainly faster than the ND GIST.
Given that it'll be the same selectivity, the cost preference is likely to
go to whichever index is physically smallest, at least for indexes of the
same type. When they're not the same type there might be an issue with
the index AM cost estimators not being lined up very well as to what they
account for and how.
I don't doubt that there's plenty of work to be done in making the cost
estimates better in cases like this --- in particular, I don't think we
have any way of accounting for the idea that one index opclass might be
smarter than another one for the same query, unless that shakes out as a
smaller index. But you'd have had the same issues with the old approach.
regards, tom lane