SQL Query optimization -performance issues - mysql

Question

I have the following SQL query I want to optimize :
select table1.tiers as col1, table1.id_item as col2
from items table1
where (table1.tiers is not null)
and table1.tiers<>''
and table1.id_item = (select max(table2.id_item)
from items table2
where table1.tiers=table2.tiers)
and table1.n_version_item=(select max(table2.n_version_item)
from items table2
where table2.id_item=table1.id_item)
I tried this:
select table1.tiers as col1, table1.id_item as col2
from items table1
where (table1.tiers is not null)
and table1.tiers<> ''
and CONCAT(table1.id_item,table1.n_version_item) = (select CONCAT(max(table2.id_item),max(table2.n_version_item))
from items table2
where table2.id_item=table1.id_item
and table1.tiers=table2.tiers)
But I'am not getting the same result. Original first query is returning fewer rows than the modified one. Note that table items has a primary key (id,version) and for each couple a tier can be affected.

Answer 1

When using a function , it will prevent the index to be used , so CONCAT(table1.id_item,table1.n_version_item) will not read an index unless if its Function based index. however as a_horse_with_no_name mentioned in comments you can use the below :
select itm.tiers as col1, itm.id_item as col2
from items itm
where itm.tiers is not null
and itm.tiers<>''
and (itm.id_item , itm.n_version_item)= (select
max(item_sub.id_item),max(item_sub.n_version_item)
from items item_sub
where itm.tiers=item_sub.tiers)
Then you have to check the query plan of the query what index is using ( you can start an index with column tiers and other index on id_item and n_version_item )

Answer 2

I think you want:
select i.tiers as col1, i.id_item as col2
from items i
where i.tiers is not null and -- redundant, but I'm leaving it in
i.tiers <> ''
(id_item, n_version_item) = (select i2.id_item, max(i2.n_version_item)
from items i2
where i2.tiers = i.tiers
order by i2.id_item desc, i2.n_version_item desc
limit 1
);
For this version, you want an index on items(tiers, id_item, n_version_item).

Answer 3

If you hide a column inside a 'function' (CONCAT, DATE, etc, etc), no index can be used to help performance. This eliminates your second version from consideration.
Related to that is the use of "Row Constructors" (see a_horse_with_no_name's Comment). They have historically been poorly optimized; avoid them. I am referring to WHERE (a,b) IN ( (1,2), ...) or other variants.
Now, let's dissect
and table1.id_item = (select max(table2.id_item)
from items table2
where table1.tiers=table2.tiers)
table2 needs INDEX(tiers, id_item) in that order. With such, the subquery is very fast. The other subquery needs INDEX(id_item, n_version_item) Those feed into the rest:
and table1.id_item = <<value>>
Now let's look at the whole
where (table1.tiers is not null)
and table1.tiers<>''
and table1.id_item = <<value>>
and table1.n_version_item = <<value>>
= is easy to optimize; the others are not. So let's build
INDEX(id_item, n_version_item, -- in either order
tiers) -- last
By using the order I specified, you can avoid also needing INDEX(id_item, n_version_item) that was mentioned above.
(It would help if you provided SHOW CREATE TABLE; I need to know what the PK is, and some other things.)
As a bonus, these indexes will be "covering indexes".
As a final note (a minor one):
where (table1.tiers is not null)
and table1.tiers<>''
It would be better to decide on only one encoding (NULL vs empty string) to whatever you are indicating by such.