Paul Ramsey <pram...@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 condition by 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 finally the 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
