Una ricerca di un singolo disco è di circa 15 ms, forse un po' meno con i dischi di livello server. Un tempo di risposta inferiore a 500 ms limita a circa 30 accessi casuali al disco. Non è molto.
Sul mio piccolo laptop, ho un database di sviluppo con
[email protected] [kris]> select @@innodb_buffer_pool_size/1024/1024 as pool_mb;
+--------------+
| pool_mb |
+--------------+
| 128.00000000 |
+--------------+
1 row in set (0.00 sec)
e un disco portatile lento. Ho creato una tabella dei punteggi con
[email protected] [kris]> show create table score\G
*************************** 1. row ***************************
Table: score
Create Table: CREATE TABLE `score` (
`player_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`score` int(11) NOT NULL,
PRIMARY KEY (`player_id`),
KEY `score` (`score`)
) ENGINE=InnoDB AUTO_INCREMENT=2490316 DEFAULT CHARSET=latin1
1 row in set (0.00 sec)
con punteggi interi casuali e valori player_id sequenziali. Abbiamo
[email protected] [kris]> select count(*)/1000/1000 as mrows from score\G
*************************** 1. row ***************************
mrows: 2.09715200
1 row in set (0.39 sec)
Il database mantiene la coppia (score, player_id) nel score ordine nell'indice score , poiché i dati in un indice InnoDB sono archiviati in un BTREE e il puntatore di riga (puntatore dati) è il valore della chiave primaria, in modo che la definizione KEY (score) finisce per essere KEY(score, player_id) internamente. Possiamo dimostrarlo esaminando il piano di query per il recupero del punteggio:
[email protected] [kris]> explain select * from score where score = 17\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: score
type: ref
possible_keys: score
key: score
key_len: 4
ref: const
rows: 29
Extra: Using index
1 row in set (0.00 sec)
Come puoi vedere, la key: score viene utilizzato con Using index , il che significa che non è necessario l'accesso ai dati.
La query di classifica per una determinata costante player_id impiega esattamente 500 ms sul mio laptop:
[email protected] [kris]> select p.*, count(*) as rank
from score as p join score as s on p.score < s.score
where p.player_id = 479269\G
*************************** 1. row ***************************
player_id: 479269
score: 99901
rank: 2074
1 row in set (0.50 sec)
Con più memoria e su una scatola più veloce può essere più veloce, ma è comunque un'operazione relativamente costosa, perché il piano fa schifo:
[email protected] [kris]> explain select p.*, count(*) as rank from score as p join score as s on p.score < s.score where p.player_id = 479269;
+----+-------------+-------+-------+---------------+---------+---------+-------+---------+--------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+-------+---------------+---------+---------+-------+---------+--------------------------+
| 1 | SIMPLE | p | const | PRIMARY,score | PRIMARY | 4 | const | 1 | |
| 1 | SIMPLE | s | index | score | score | 4 | NULL | 2097979 | Using where; Using index |
+----+-------------+-------+-------+---------------+---------+---------+-------+---------+--------------------------+
2 rows in set (0.00 sec)
Come puoi vedere, la seconda tabella del piano è una scansione dell'indice, quindi la query rallenta in modo lineare con il numero di giocatori.
Se vuoi una classifica completa, devi omettere la clausola where e quindi ottieni due scansioni e tempi di esecuzione quadratici. Quindi questo piano implode completamente.
È ora di passare alla procedura qui:
[email protected] [kris]> set @count = 0;
select *, @count := @count + 1 as rank from score where score >= 99901 order by score desc ;
...
| 2353218 | 99901 | 2075 |
| 2279992 | 99901 | 2076 |
| 2264334 | 99901 | 2077 |
| 2239927 | 99901 | 2078 |
| 2158161 | 99901 | 2079 |
| 2076159 | 99901 | 2080 |
| 2027538 | 99901 | 2081 |
| 1908971 | 99901 | 2082 |
| 1887127 | 99901 | 2083 |
| 1848119 | 99901 | 2084 |
| 1692727 | 99901 | 2085 |
| 1658223 | 99901 | 2086 |
| 1581427 | 99901 | 2087 |
| 1469315 | 99901 | 2088 |
| 1466122 | 99901 | 2089 |
| 1387171 | 99901 | 2090 |
| 1286378 | 99901 | 2091 |
| 666050 | 99901 | 2092 |
| 633419 | 99901 | 2093 |
| 479269 | 99901 | 2094 |
| 329168 | 99901 | 2095 |
| 299189 | 99901 | 2096 |
| 290436 | 99901 | 2097 |
...
Poiché si tratta di un piano procedurale, è instabile:
- Non puoi usare LIMIT, perché ciò compenserà il contatore. Invece devi scaricare tutti questi dati.
- Non puoi davvero ordinare. Questo
ORDER BYLa clausola funziona, perché non esegue l'ordinamento, ma utilizza un indice. Non appena vediusing filesort, i valori dei contatori saranno decisamente fuori luogo.
Tuttavia, è la soluzione che si avvicina di più a ciò che un database NoSQL (leggi:procedurale) farà come piano di esecuzione.
Tuttavia, possiamo stabilizzare il NoSQL all'interno di una sottoquery e quindi tagliare la parte che ci interessa:
[email protected] [kris]> set @count = 0;
select * from (
select *, @count := @count + 1 as rank
from score
where score >= 99901
order by score desc
) as t
where player_id = 479269;
Query OK, 0 rows affected (0.00 sec)
+-----------+-------+------+
| player_id | score | rank |
+-----------+-------+------+
| 479269 | 99901 | 2094 |
+-----------+-------+------+
1 row in set (0.00 sec)
[email protected] [kris]> set @count = 0;
select * from (
select *, @count := @count + 1 as rank
from score
where score >= 99901
order by score desc
) as t
where rank between 2090 and 2100;
Query OK, 0 rows affected (0.00 sec)
+-----------+-------+------+
| player_id | score | rank |
+-----------+-------+------+
| 1387171 | 99901 | 2090 |
| 1286378 | 99901 | 2091 |
| 666050 | 99901 | 2092 |
| 633419 | 99901 | 2093 |
| 479269 | 99901 | 2094 |
| 329168 | 99901 | 2095 |
| 299189 | 99901 | 2096 |
| 290436 | 99901 | 2097 |
+-----------+-------+------+
8 rows in set (0.01 sec)
La sottoquery materializzerà il precedente set di risultati come una tabella ad hoc denominata t, a cui possiamo quindi accedere nella query esterna. Poiché è una tabella ad hoc, in MySQL non avrà alcun indice. Questo limita ciò che è possibile in modo efficiente nella query esterna.
Nota come entrambe le query soddisfino il tuo vincolo di tempo, però. Ecco il piano:
[email protected] [kris]> set @count = 0; explain select * from ( select *, @count := @count + 1 as rank from score where score >= 99901 order by score desc ) as t where rank between 2090 and 2100\G
Query OK, 0 rows affected (0.00 sec)
*************************** 1. row ***************************
id: 1
select_type: PRIMARY
table: <derived2>
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 2097
Extra: Using where
*************************** 2. row ***************************
id: 2
select_type: DERIVED
table: score
type: range
possible_keys: score
key: score
key_len: 4
ref: NULL
rows: 3750
Extra: Using where; Using index
2 rows in set (0.00 sec)
Entrambi i componenti della query (quello interno, DERIVED query e il BETWEEN esterno limite) diventerà più lento per i giocatori con una cattiva classificazione, tuttavia, e quindi violerà gravemente i tuoi limiti di tempo.
[email protected] [kris]> set @count = 0; select * from ( select *, @count := @count + 1 as rank from score where score >= 0 order by score desc ) as t;
...
2097152 rows in set (3.56 sec)
Il tempo di esecuzione per l'approccio descrittivo è stabile (dipendente solo dalla dimensione della tabella):
[email protected] [kris]> select p.*, count(*) as rank
from score as p join score as s on p.score < s.score
where p.player_id = 1134026;
+-----------+-------+---------+
| player_id | score | rank |
+-----------+-------+---------+
| 1134026 | 0 | 2097135 |
+-----------+-------+---------+
1 row in set (0.53 sec)
La tua chiamata.
