On 20/01/2024 12:14 am, Tomas Vondra wrote:
Looks like I was not true, even if it is not index-only scan but index
condition involves only index attributes, then heap is not accessed
until we find tuple satisfying search condition.
Inclusive index case described above
(https://commitfest.postgresql.org/46/4352/) is interesting but IMHO
exotic case. If keys are actually used in search, then why not to create
normal compound index instead?
Not sure I follow ...
Firstly, I'm not convinced the example addressed by that other patch is
that exotic. IMHO it's quite possible it's actually quite common, but
the users do no realize the possible gains.
Also, there are reasons to not want very wide indexes - it has overhead
associated with maintenance, disk space, etc. I think it's perfectly
rational to design indexes in a way eliminates most heap fetches
necessary to evaluate conditions, but does not guarantee IOS (so the
last heap fetch is still needed).
We are comparing compound index (a,b) and covering (inclusive) index (a)
include (b)
This indexes have exactly the same width and size and almost the same
maintenance overhead.
First index has more expensive comparison function (involving two
columns) but I do not think that it can significantly affect
performance and maintenance cost. Also if selectivity of "a" is good
enough, then there is no need to compare "b"
Why we can prefer covering index to compound index? I see only two good
reasons:
1. Extra columns type do not have comparison function need for AM.
2. The extra columns are never used in query predicate.
If you are going to use this columns in query predicates I do not see
much sense in creating inclusive index rather than compound index.
Do you?
What do you mean by "create normal compound index"? The patch addresses
a limitation that not every condition can be translated into a proper
scan key. Even if we improve this, there will always be such conditions.
The the IOS can evaluate them on index tuple, the regular index scan
can't do that (currently).
Can you share an example demonstrating the alternative approach?
May be I missed something.
This is the example from
https://www.postgresql.org/message-id/flat/N1xaIrU29uk5YxLyW55MGk5fz9s6V2FNtj54JRaVlFbPixD5z8sJ07Ite5CvbWwik8ZvDG07oSTN-usENLVMq2UAcizVTEd5b-o16ZGDIIU=@yamlcoder.me
:
```
And here is the plan with index on (a,b).
Limit (cost=0.42..4447.90 rows=1 width=12) (actual time=6.883..6.884
rows=0 loops=1) Output: a, b, d Buffers: shared hit=613 ->
Index Scan using t_a_b_idx on public.t (cost=0.42..4447.90 rows=1
width=12) (actual time=6.880..6.881 rows=0 loops=1) Output: a,
b, d Index Cond: ((t.a > 1000000) AND (t.b = 4))
Buffers: shared hit=613 Planning: Buffers: shared hit=41 Planning
Time: 0.314 ms Execution Time: 6.910 ms ```
Isn't it an optimal plan for this query?
And cite from self reproducible example https://dbfiddle.uk/iehtq44L :
```
create unique index t_a_include_b on t(a) include (b);
-- I'd expecd index above to behave the same as index below for this query
--create unique index on t(a,b);
```
I agree that it is natural to expect the same result for both indexes.
So this PR definitely makes sense.
My point is only that compound index (a,b) in this case is more natural
and preferable.
