MySQL index not used - mysql
have some table with index for two columns (user_id,date)
and SQL query
select user_id, stat.in, stat.out, stat.time, date
from stat
where user_id in (select id from users force index (street_id) where street_id=30);
or
select user_id, stat.in, stat.out, stat.time, date
from stat where user_id in (select id from users force index (street_id) where street_id=30)
and date between STR_TO_DATE('2010-01-01 00:00:00', '%Y-%m-%d %H:%i:%s') and TR_TO_DATE('2014-05-22 23:59:59', '%Y-%m-%d %H:%i:%s')
In two case index must work, but I sink problem in in statement. If it's possible, how make it work?
Explain:
+----+--------------------+-------+------+---------------+-----------+---------+-------+----------+--------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+--------------------+-------+------+---------------+-----------+---------+-------+----------+--------------------------+
| 1 | PRIMARY | stat | ALL | NULL | NULL | NULL | NULL | 32028701 | Using where |
| 2 | DEPENDENT SUBQUERY | users | ref | street_id | street_id | 8 | const | 650 | Using where; Using index |
+----+--------------------+-------+------+---------------+-----------+---------+-------+----------+--------------------------+
if search with one user_id index work
explain select user_id, stat.in, stat.out, stat.time, date
from stat
where user_id=3991;
Explain:
+----+-------------+-------+------+---------------+-----------+---------+-------+------+-------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+-----------+---------+-------+------+-------+
| 1 | SIMPLE | stat | ref | user_id_2 | user_id_2 | 8 | const | 2973 | |
+----+-------------+-------+------+---------------+-----------+---------+-------+------+-------+
First thing in the query the IN clause is creating havoc and if I am not wrong the indexes are not done properly.
So here is how it should be lets say the tables are as
create table users (id int, name varchar(100),street_id int);
insert into users values
(1,'a',20),(2,'b',30),(3,'c',10),(4,'d',20),(5,'e',10),(6,'f',40),(7,'g',20),
(8,'h',10),(9,'i',10),(10,'j',40);
create table stat (user_id int ,`in` int, `out` int, time int , date date);
insert into stat values
(1,1,1,20,'2014-01-01'),
(1,1,1,20,'2014-01-02'),
(3,1,1,20,'2014-01-01'),
(2,1,1,20,'2014-01-01'),
(4,1,1,20,'2014-01-02'),
(6,1,1,20,'2014-01-02'),
(7,1,1,20,'2014-01-02'),
(8,1,1,20,'2014-01-02'),
(1,1,1,20,'2014-01-02'),
(2,1,1,20,'2014-01-02'),
(3,1,1,20,'2014-01-03'),
(4,1,1,20,'2014-01-04'),
(5,1,1,20,'2014-01-04'),
(6,1,1,20,'2014-01-04'),
(7,1,1,20,'2014-01-04'),
(2,1,1,20,'2014-01-04'),
(3,1,1,20,'2014-01-04'),
(4,1,1,20,'2014-01-05'),
(5,1,1,20,'2014-01-05'),
(6,1,1,20,'2014-01-05'),
(7,1,1,20,'2014-01-05'),
(8,1,1,20,'2014-01-05'),
(9,1,1,20,'2014-01-05'),
(10,1,1,20,'2014-01-05'),
(1,1,1,20,'2014-01-06'),
(4,1,1,20,'2014-01-06');
Now add some indexes on the table
alter table users add index id_idx (id);
alter table users add index street_idx(street_id);
alter table stat add index user_id_idx(user_id);
Now if we execute the same query that you are trying to do using explain yields
EXPLAIN
select user_id, stat.`in`, stat.`out`, stat.time, date
from stat
where user_id in (select id from users force index (street_id) where street_id=30);
+----+--------------------+-------+------+---------------+------------+---------+-------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+--------------------+-------+------+---------------+------------+---------+-------+------+-------------+
| 1 | PRIMARY | stat | ALL | NULL | NULL | NULL | NULL | 26 | Using where |
| 2 | DEPENDENT SUBQUERY | users | ref | street_idx | street_idx | 5 | const | 1 | Using where |
+----+--------------------+-------+------+---------------+------------+---------+-------+------+-------------+
It still looks like trying to scan the entire table.
Now lets modify the query and use JOIN and see what explain has to say, note that I have index on both table for the joining key and which are of same type and size.
EXPLAIN
select
s.user_id,
s.`in`,
s.`out`,
s.time,
s.date
from stat s
join users u on u.id = s.user_id
where u.street_id=30 ;
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
| 1 | SIMPLE | u | ref | id_idx,street_idx | street_idx | 5 | const | 1 | Using where |
| 1 | SIMPLE | s | ref | user_id_idx | user_id_idx | 5 | test.u.id | 3 | Using where |
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
Better hun ?? Now lets try a range search
EXPLAIN
select
s.user_id,
s.`in`,
s.`out`,
s.time,
s.date
from stat s
join users u on u.id = s.user_id
where
u.street_id=30
and s.date between '2014-01-01' AND '2014-01-06'
;
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
| 1 | SIMPLE | u | ref | id_idx,street_idx | street_idx | 5 | const | 1 | Using where |
| 1 | SIMPLE | s | ref | user_id_idx | user_id_idx | 5 | test.u.id | 3 | Using where |
+----+-------------+-------+------+-------------------+-------------+---------+-----------+------+-------------+
Still better right ??
So the underlying agenda is try avoiding IN queries. Use JOIN on indexed column and for search columns indexed them properly.
Related
Efficiently query on first two digits of indexed int column in MySQL
I have a table (MySQL 8.0.26, InnoDB) containing an indexed column of MEDIUMINTs that denote the date a record was created: date_created MEDIUMINT NOT NULL INDEX idx_created (date_created) E.g., the entry "210516" denotes 2021-05-16. Are the following queries roughly equally efficient in utilizing the index? WHERE 210000<=date_created AND date_created<220000, WHERE date_created DIV 10000 = 21, WHERE date_created LIKE '21%', and WHERE LEFT(date_created, 2) = '21' I am currently using WHERE date_created DIV 10000 = 21 in my code but wonder if I should alter all queries to make them more efficient. Thanks a lot in advance.
Look at the type column in EXPLAIN. If it says "ALL" it means it must do a table-scan of all the rows, evaluating the condition expression for each row. This is not using the index. mysql> explain select * from mytable where 21000<=date_created and date_created < 22000; +----+-------------+---------+------------+-------+---------------+--------------+---------+------+------+----------+-----------------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+-------+---------------+--------------+---------+------+------+----------+-----------------------+ | 1 | SIMPLE | mytable | NULL | range | date_created | date_created | 4 | NULL | 1 | 100.00 | Using index condition | +----+-------------+---------+------------+-------+---------------+--------------+---------+------+------+----------+-----------------------+ mysql> explain select * from mytable where date_created like '21%'; +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | 1 | SIMPLE | mytable | NULL | ALL | date_created | NULL | NULL | NULL | 8192 | 11.11 | Using where | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ mysql> explain select * from mytable where date_created div 10000 = 21; +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | 1 | SIMPLE | mytable | NULL | ALL | NULL | NULL | NULL | NULL | 8192 | 100.00 | Using where | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ mysql> explain select * from mytable where left(date_created, 2) = '21'; +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ | 1 | SIMPLE | mytable | NULL | ALL | NULL | NULL | NULL | NULL | 8192 | 100.00 | Using where | +----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+ MySQL 8.0 supports expression indexes, which helps a couple of the cases: mysql> alter table mytable add index expr1 ((left(date_created, 2))); mysql> explain select * from mytable where left(date_created, 2) = '21'; +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ | 1 | SIMPLE | mytable | NULL | ref | expr1 | expr1 | 11 | const | 1402 | 100.00 | NULL | +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ mysql> alter table mytable add index expr2 ((date_created DIV 10000)); mysql> explain select * from mytable where date_created div 10000 = 21; +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ | 1 | SIMPLE | mytable | NULL | ref | expr2 | expr2 | 5 | const | 1402 | 100.00 | NULL | +----+-------------+---------+------------+------+---------------+-------+---------+-------+------+----------+-------+ But expression indexes won't help the LIKE '21%' search, because you'd have to hard-code the value '21%' in the expression for the index definition. You could use that index to search for that value only, not for the value of a different year.
How to make an efficient UPDATE like my SELECT in MariaDB
Background I made a small table of 10 rows from a previous SELECT already ran (SavedAnimals). I have a massive table (animals) which I would like to UPDATE using the rows with the same id as each row in my new table. What I have tried so far I can quickly SELECT the desired rows from the big table like this: mysql> EXPLAIN SELECT * FROM animals WHERE ignored=0 and id IN (SELECT animal_id FROM SavedAnimals); +------+--------------+-------------------------------+--------+---------------+---------+---------+----------------------------------------------------------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +------+--------------+-------------------------------+--------+---------------+---------+---------+----------------------------------------------------------+------+-------------+ | 1 | PRIMARY | <subquery2> | ALL | distinct_key | NULL | NULL | NULL | 10 | | | 1 | PRIMARY | animals | eq_ref | PRIMARY | PRIMARY | 8 | db_staging.SavedAnimals.animal_id | 1 | Using where | | 2 | MATERIALIZED | SavedAnimals | ALL | NULL | NULL | NULL | NULL | 10 | | +------+--------------+-------------------------------+--------+---------------+---------+---------+----------------------------------------------------------+------+-------------+ But the "same" command on the UPDATE is not quick: mysql> EXPLAIN UPDATE animals SET ignored=1, ignored_when=CURRENT_TIMESTAMP WHERE ignored=0 and id IN (SELECT animal_id FROM SavedAnimals); +------+--------------------+-------------------------------+-------+---------------+---------+---------+------+----------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +------+--------------------+-------------------------------+-------+---------------+---------+---------+------+----------+-------------+ | 1 | PRIMARY | animals | index | NULL | PRIMARY | 8 | NULL | 34269464 | Using where | | 2 | DEPENDENT SUBQUERY | SavedAnimals | ALL | NULL | NULL | NULL | NULL | 10 | Using where | +------+--------------------+-------------------------------+-------+---------------+---------+---------+------+----------+-------------+ 2 rows in set (0.00 sec) The UPDATE command never finishes if I run it. QUESTION How do I make mariaDB run with the Materialized select_type on the UPDATE like it does on the SELECT? OR Is there a totally separate way that I should approach this which would be quick? Notes Version: 10.3.23-MariaDB-log
Use JOIN rather than WHERE...IN. MySQL tends to optimize them better. UPDATE animals AS a JOIN SavedAnimals AS sa ON a.id = sa.animal_id SET a.ignored=1, a.ignored_when=CURRENT_TIMESTAMP WHERE a.ignored = 0
You should find an EXISTS clause more efficient than an IN clause. For example: UPDATE animals a SET a.ignored = 1, a.ignored_when = CURRENT_TIMESTAMP WHERE a.ignored = 0 AND EXISTS (SELECT * FROM SavedAnimals sa WHERE sa.animal_id = a.id)
DELETE statement is not using INDEX on table and executing for long time
There is one huge table which is having 25M records and when we try to delete the records by manually passing the value it is using the INDEX and query is executing faster. Below are details. MySQL [(none)]> explain DELETE FROM isca51410_octopus_prod_eai.WMSERVICE WHERE contextid in ('1121','1245','5432','12412','1212','7856','2342','1345','5312','2342','3432','5321'); +----+-------------+-----------+------------+-------+---------------+-------------+---------+-------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+-------+---------------+-------------+---------+-------+------+----------+-------------+ | 1 | DELETE | BIG_TABLE | NULL | range | IDX_BIG_CID | IDX_BIG_CID | 109 | const | 12 | 100.00 | Using where | +----+-------------+-----------+------------+-------+---------------+-------------+---------+-------+------+----------+-------------+ But when we try to pass the values by using select query it is not using index and query is executing for more time. Below is the explain plan. MySQL [(none)]> explain DELETE FROM DATABASE1_1.BIG_TABLE WHERE contextid in (SELECT contextid FROM DATABASE_2.TABLE_2); +----+--------------------+------------------+------------+------+---------------+------+---------+------+----------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+--------------------+------------------+------------+------+---------------+------+---------+------+----------+----------+-------------+ | 1 | DELETE | BIG_TABLE | NULL | ALL | NULL | NULL | NULL | NULL | 25730673 | 100.00 | Using where | | 2 | DEPENDENT SUBQUERY | TABLE_2 | NULL | ALL | NULL | NULL | NULL | NULL | 10 | 10.00 | Using where | +----+--------------------+------------------+------------+------+---------------+------+---------+------+----------+----------+-------------+ Here DATABASE_2.TABLE_2 is a table where the values will change everytime and row count will be less than 100. How to make use of index IDX_BIG_CID on table DATABASE1_1.BIG_TABLE for the below query DELETE FROM DATABASE1_1.BIG_TABLE WHERE contextid in (SELECT contextid FROM DATABASE_2.TABLE_2);
Don't use IN ( SELECT ... ). Use a multi-table DELETE. (See the ref manual.)
MySQL : Indexes for View based on an aggregated query
I have a working, nice, indexed SQL query aggregating notes (sum of ints) for all my users and others stuffs. This is "query A". I want to use this aggregated notes in others queries, say "query B". If I create a View based on "query A", will the indexes of the original query will be used when needed if I join it in "query B" ? Is that true for MySQL ? For others flavors of SQL ? Thanks.
In MySQL, you cannot create an index on a view. MySQL uses indexes of the underlying tables when you query data against the views that use the merge algorithm. For the views that use the temptable algorithm, indexes are not utilized when you query data against the views. https://www.percona.com/blog/2007/08/12/mysql-view-as-performance-troublemaker/
Here's a demo table. It has a userid attribute column and a note column. mysql> create table t (id serial primary key, userid int not null, note int, key(userid,note)); If you do an aggregation to get the sum of note per userid, it does an index-scan on (userid, note). mysql> explain select userid, sum(note) from t group by userid; +----+-------------+-------+-------+---------------+--------+---------+------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+-------+-------+---------------+--------+---------+------+------+-------------+ | 1 | SIMPLE | t | index | userid | userid | 9 | NULL | 1 | Using index | +----+-------------+-------+-------+---------------+--------+---------+------+------+-------------+ 1 row in set (0.00 sec) If we create a view for the same query, then we can see that querying the view uses the same index on the underlying table. Views in MySQL are pretty much like macros — they just query the underlying table. mysql> create view v as select userid, sum(note) from t group by userid; Query OK, 0 rows affected (0.03 sec) mysql> explain select * from v; +----+-------------+------------+-------+---------------+--------+---------+------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+------------+-------+---------------+--------+---------+------+------+-------------+ | 1 | PRIMARY | <derived2> | ALL | NULL | NULL | NULL | NULL | 2 | NULL | | 2 | DERIVED | t | index | userid | userid | 9 | NULL | 1 | Using index | +----+-------------+------------+-------+---------------+--------+---------+------+------+-------------+ 2 rows in set (0.00 sec) So far so good. Now let's create a table to join with the view, and join to it. mysql> create table u (userid int primary key, name text); Query OK, 0 rows affected (0.09 sec) mysql> explain select * from v join u using (userid); +----+-------------+------------+-------+---------------+-------------+---------+---------------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+------------+-------+---------------+-------------+---------+---------------+------+-------------+ | 1 | PRIMARY | u | ALL | PRIMARY | NULL | NULL | NULL | 1 | NULL | | 1 | PRIMARY | <derived2> | ref | <auto_key0> | <auto_key0> | 4 | test.u.userid | 2 | NULL | | 2 | DERIVED | t | index | userid | userid | 9 | NULL | 1 | Using index | +----+-------------+------------+-------+---------------+-------------+---------+---------------+------+-------------+ 3 rows in set (0.01 sec) I tried to use hints like straight_join to force it to read v then join to u. mysql> explain select * from v straight_join u on (v.userid=u.userid); +----+-------------+------------+-------+---------------+--------+---------+------+------+----------------------------------------------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+------------+-------+---------------+--------+---------+------+------+----------------------------------------------------+ | 1 | PRIMARY | <derived2> | ALL | NULL | NULL | NULL | NULL | 7 | NULL | | 1 | PRIMARY | u | ALL | PRIMARY | NULL | NULL | NULL | 1 | Using where; Using join buffer (Block Nested Loop) | | 2 | DERIVED | t | index | userid | userid | 9 | NULL | 7 | Using index | +----+-------------+------------+-------+---------------+--------+---------+------+------+----------------------------------------------------+ "Using join buffer (Block Nested Loop)" is MySQL's terminology for "no index used for the join." It's just looping over the table the hard way -- by reading batches of rows from start to finish of the table. I tried to use force index to tell MySQL that type=ALL is to be avoided. mysql> explain select * from v straight_join u force index(PRIMARY) on (v.userid=u.userid); +----+-------------+------------+--------+---------------+---------+---------+----------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+------------+--------+---------------+---------+---------+----------+------+-------------+ | 1 | PRIMARY | <derived2> | ALL | NULL | NULL | NULL | NULL | 7 | NULL | | 1 | PRIMARY | u | eq_ref | PRIMARY | PRIMARY | 4 | v.userid | 1 | NULL | | 2 | DERIVED | t | index | userid | userid | 9 | NULL | 7 | Using index | +----+-------------+------------+--------+---------------+---------+---------+----------+------+-------------+ Maybe this is using an index for the join? But it's weird that table u is before table t in the EXPLAIN. I'm frankly not sure how to understand what it's doing, given the order of rows in this EXPLAIN report. I would expect the joined table should come after the primary table of the query. I only put a few rows of data into each table. One might get some different EXPLAIN results with a larger representative sample of test data. I'll leave that to you to try.
MySQL Indexing - In vs. Equals indexing issues
Following queries run quite fast and instantaneously on mysql server: SELECT table_name.id FROM table_name WHERE table_name.id in (10000) SELECT table_name.id from table_name where table_name.id = (SELECT table_name.id FROM table_name WHERE table_name.id in (10000) ); But if I change the second query to as following, then it takes more than 20 seconds: SELECT table_name.id from table_name where table_name.id in (SELECT table_name.id FROM table_name WHERE table_name.id in (10000) ); On doing explain, I get the following output. It is clear that there are some issues regarding how MySQL indexes the data, and use in keyword. For first query: +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ | 1 | SIMPLE | table_name | const | PRIMARY | PRIMARY | 4 | const | 1 | Using index | +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ For second query: +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ | 1 | PRIMARY | table_name | const | PRIMARY | PRIMARY | 4 | const | 1 | Using index | | 2 | SUBQUERY | table_name | const | PRIMARY | PRIMARY | 4 | | 1 | Using index | +----+-------------+---------------+-------+---------------+---------+---------+-------+------+-------------+ For third query: +----+--------------------+------------+-------+---------------+---------+---------+-------+---------+--------------------------+ | id | select_type | table_name | type | possible_keys | key | key_len | ref | rows | Extra | +----+--------------------+------------+-------+---------------+---------+---------+-------+---------+--------------------------+ | 1 | PRIMARY | table_name | index | NULL | sentTo | 5 | NULL | 6250751 | Using where; Using index | | 2 | DEPENDENT SUBQUERY | table_name | const | PRIMARY | PRIMARY | 4 | const | 1 | Using index | +----+--------------------+------------+-------+---------------+---------+---------+-------+---------+--------------------------+ I am using InnoDB and have tried changing the third query to forcibly use the index as indicated by the following category.
In first case you have only first record from subquery (It runs once, because equals is only for first value) In second query you got Cartesian multiplication (each per each) because IN runs subquery for each row. Which is not good for performance Try to use joins for these cases.