Procedimento morno do MySQL

Se você gostaria de aquecer seu MyISAM Key Buffer, você pode executar isto:

SELECT DISTINCT CONCAT('SELECT ',ndxcollist,' FROM ',db,'.',tb,' ORDER 
BY ',ndxcollist,';') SelectQueryToLoadCache
FROM (SELECT engine,table_schema db,table_name tb,index_name,
GROUP_CONCAT(column_name ORDER BY seq_in_index) ndxcollist
FROM (SELECT 
B.engine,A.table_schema,A.table_name,A.index_name,A.column_name,A.seq_in_index
FROM information_schema.statistics A INNER JOIN
(SELECT engine,table_schema,table_name
FROM information_schema.tables
WHERE engine='MyISAM' AND table_schema
NOT IN ('information_schema','mysql')) B
USING (table_schema,table_name)
WHERE A.index_type <> 'FULLTEXT'
ORDER BY table_schema,table_name,index_name,seq_in_index) A
GROUP BY table_schema,table_name,index_name) AA
ORDER BY db,tb
;

Aqui está a saída:

+----------------------------------------------------------------------+
| SelectQueryToLoadCache                                               |
+----------------------------------------------------------------------+
| SELECT start_time FROM annarbor.sq_20110722 ORDER     BY start_time; |
| SELECT id FROM junk.category ORDER     BY id;                        |
| SELECT id FROM junk.mytabletolimit ORDER     BY id;                  |
| SELECT parent_id FROM junk.observations ORDER     BY parent_id;      |
| SELECT id FROM junk.observations ORDER     BY id;                    |
| SELECT parent_id FROM junk.pctable ORDER     BY parent_id;           |
| SELECT id FROM junk.pctable ORDER     BY id;                         |
| SELECT id FROM junk.products ORDER     BY id;                        |
| SELECT id FROM junk.subcategory ORDER     BY id;                     |
| SELECT id FROM test.acties ORDER     BY id;                          |
| SELECT id FROM test.deletekeys ORDER     BY id;                      |
| SELECT email FROM test.emailtable ORDER     BY email;                |
| SELECT id FROM test.emailtable ORDER     BY id;                      |
| SELECT id FROM test.ft_test ORDER     BY id;                         |
| SELECT id_key FROM test.id_key_table ORDER     BY id_key;            |
| SELECT id_key FROM test.id_key_table_keys ORDER     BY id_key;       |
| SELECT id FROM test.mytabletodeletefrom ORDER     BY id;             |
| SELECT NGRAM_ID FROM test.ngram_key ORDER     BY NGRAM_ID;           |
| SELECT NGRAM FROM test.ngram_key ORDER     BY NGRAM;                 |
| SELECT NGRAM_ID FROM test.ngram_rec ORDER     BY NGRAM_ID;           |
| SELECT num FROM test.notforeverdata_matches ORDER     BY num;        |
| SELECT id FROM test.pamela ORDER     BY id;                          |
| SELECT id FROM test.rolando ORDER     BY id;                         |
| SELECT num FROM test.rolando2 ORDER     BY num;                      |
| SELECT CourseName FROM test.tab ORDER     BY CourseName;             |
| SELECT CourseName FROM test.tab_to_zap ORDER     BY CourseName;      |
| SELECT academy FROM test.under99color ORDER     BY academy;          |
| SELECT id FROM test.under99color ORDER     BY id;                    |
| SELECT id_key FROM test.weekly_batch ORDER     BY id_key;            |
| SELECT id FROM test.worktable ORDER     BY id;                       |
+----------------------------------------------------------------------+
30 rows in set (0.81 sec)

mysql>

Isso exibe todas as consultas possíveis que você pode executar nas tabelas MyISAM, selecionando apenas os campos da coluna de índice. A execução dessas consultas preencherá o MyISAM Key Buffer.

Aqui está uma consulta semelhante para fazer consultas que pré-carregam o InnoDB Buffer Pool

SELECT DISTINCT
    CONCAT('SELECT ',ndxcollist,' FROM ',db,'.',tb,
    ' ORDER BY ',ndxcollist,';') SelectQueryToLoadCache
    FROM
    (
        SELECT
            engine,table_schema db,table_name tb,
            index_name,GROUP_CONCAT(column_name ORDER BY seq_in_index) ndxcollist
        FROM
        (
            SELECT
                B.engine,A.table_schema,A.table_name,
                A.index_name,A.column_name,A.seq_in_index
            FROM
                information_schema.statistics A INNER JOIN
                (
                    SELECT engine,table_schema,table_name
                    FROM information_schema.tables WHERE
                    engine='InnoDB'
                ) B USING (table_schema,table_name)
            WHERE B.table_schema NOT IN ('information_schema','mysql')
            ORDER BY table_schema,table_name,index_name,seq_in_index
        ) A
        GROUP BY table_schema,table_name,index_name
    ) AA
ORDER BY db,tb
;

Aqui está uma consulta semelhante para fazer consultas que pré-carregam o InnoDB Buffer Pool e o MyISAM Key Buffer ( postei isso em novembro de 2011 )

SELECT DISTINCT
    CONCAT('SELECT ',ndxcollist,' FROM ',
    db,'.',tb,' ORDER BY ',ndxcollist,';') SelectQueryToLoadCache
FROM (
    SELECT
        engine,table_schema db,table_name tb,index_name,
        GROUP_CONCAT(column_name ORDER BY seq_in_index) ndxcollist
    FROM (
        SELECT
            B.engine,A.table_schema,A.table_name,
            A.index_name,A.column_name,A.seq_in_index
        FROM
            information_schema.statistics A INNER JOIN
            (
                SELECT engine,table_schema,table_name
                FROM information_schema.tables
                WHERE engine IN ('InnoDB','MyISAM')
            ) B USING (table_schema,table_name)
        WHERE
            B.table_schema NOT IN ('information_schema','mysql')
            AND A.index_type <> 'FULLTEXT'
        ORDER BY
            table_schema,table_name,index_name,seq_in_index
        ) A
    GROUP BY
        table_schema,table_name,index_name
) AA
ORDER BY
    engine DESC,db,tb
;

Se você vir a mesma consulta aparecer mais de uma vez em uma exibição, isso indica a presença de índices redundantes .

De uma chance !!!

ATUALIZAÇÃO 2012-02-04 21:53 EDT

Embora seja possível criar caches dedicados ao MyISAM da seguinte maneira:

SET GLOBAL authentication_cache.key_buffer_size = 1024 * 1024 * 8; 
CACHE INDEX mydb.users INTO authentication_cache; 
LOAD INDEX INTO CACHE mydb.users;

você ainda deve decidir carregar todos os índices ou alguns específicos. O script que forneci simplesmente mostra a lista de todos os índices possíveis que você pode carregar. Você não é obrigado a carregar todos os índices, apenas aqueles que você sabe que são mais usados. Se você tiver o hardware e o orçamento, pode carregar o quanto quiser nos caches MyISAM dedicados.

Aqui está outra coisa a considerar: Todas as consultas mencionadas estão, na verdade, acessando índices de cobertura . A execução dessas consultas acessará apenas as páginas MyISAM do arquivo .MYI e apenas as páginas de índice de tabelas InnoDB. Os dados da tabela nunca são recuperados. Diante disso, todas as consultas ou as consultas selecionadas preencheram as páginas de índice, independentemente do mecanismo de armazenamento.

Mais links sobre os princípios de índices de cobertura

• http://www.mysqlperformanceblog.com/2006/11/23/covering-index-and-prefix-indexes/
• http://ronaldbradford.com/blog/tag/covering-index/
• http://shallop.com/2011/04/covering-indexes-in-mysql/
• http://www.mysqlconf.com/mysql2009/public/schedule/detail/6796

ATUALIZAÇÃO 2012-02-04 22:05 EDT

Nota rápida sobre InnoDB vs MyISAM. Você pode armazenar em cache páginas de dados para InnoDB. MyISAM não .

Se você estiver executando uma versão suficientemente recente do servidor do percona, poderá usar a opção de configuração innodb_auto_lru_dump . Isso é relevante apenas para tabelas/dbs innodb.

Ele basicamente manterá um arquivo de mapa de páginas a serem recarregadas no buffer pool na inicialização antes de começar a aceitar conexões.

Em um servidor dedicado com 144 GB de buffer pool, ele manteve um arquivo de mapa de 71 milhões de páginas para recarregar. Acrescentou 5 minutos ao tempo de inicialização (mas está no fusionio). Tive tempos de inicialização semelhantes em caixas remotas que têm apenas alguns shows de buffer pool, mas discos ruins.