Ben's questions

Suponha que eu tenha uma tabela foo, que contém algumas estatísticas que são calculadas de vez em quando. É muito usado por outras consultas.

É por isso que quero computar estatísticas mais recentes foo_newe trocá-las quando a computação estiver pronta.

eu poderia fazer

ALTER TABLE foo RENAME foo_tmp;
ALTER TABLE foo_new RENAME foo;

mas o que acontece se uma consulta precisar de uma tabela fooentre essas duas linhas quando não houver uma tabela foo? Acho que tenho que bloqueá-lo de alguma forma... ou há outra maneira de fazer isso?

Eu tenho uma grande tabela foobardescrevendo uma relação muitos-para-muitos e contendo milhões de foo's, milhões de bar's e cada baruma com várias centenas de foo's -> bilhões de linhas.

CREATE TABLE `foobar` (
`foo_id` INT(10) UNSIGNED NOT NULL,
`bar_id` INT(10) UNSIGNED NOT NULL,
PRIMARY KEY (`foo_id`, `bar_id`),
INDEX `bar_id_idx` (`bar_id`))

Eu tenho outra tabela contando os foo_id's em foobar:

CREATE TABLE `foo_amount` (
`foo_id` INT(10) UNSIGNED NOT NULL,
`amount` INT(10) UNSIGNED NOT NULL,
PRIMARY KEY (`foo_id`),
INDEX `amount_idx` (`amount`))

A contagem poderia ser feita assim:

INSERT INTO foo_amount (SELECT foo_id, COUNT(*) AS amount FROM foobar GROUP BY foo_id);

Mas eu teria que recalcular a tabela com cada linha inserida/excluída em foobar.

Uma inserção geralmente adiciona um novo barobjeto com várias centenas foode 's. Por exemplo, inserir a barcom bar_id42 tendo foo's com foo_id's 3, 8, 26, 44, .... ficaria assim:

INSERT INTO foobar VALUES (3,42), (8,42), (26,42), (44,42), ...;

Minha segunda tentativa foi atualizar a foo_counttabela após cada barobjeto inserido:

INSERT INTO foo_amount (SELECT foo_id, 1 FROM foobar WHERE bar_id = 42)
ON DUPLICATE KEY UPDATE amount = amount + 1;

Mas isso é muito lento. Você tem alguma ideia de como otimizar isso? Uma opção pode ser acumular novos bar's temporariamente foo_count_tmpe mesclá-los de foo_countvez em quando. A foo_counttabela não estaria atualizada o tempo todo, mas tudo bem. Mas como eu acionaria a atualização então?

Então, isso é o que eu tenho:

Uma tabela simples classes__to_students:

|class   |student|
---------------
 Math     Alice
 Math     Bob
 Math     Peter
 Math     Anne
 Music    Bob
 Music    Chis
 Music    Debbie
 ...

Há 1000000 aulas. Cada aluno assiste a 500 aulas. (Analogia ruim, eu sei...) Para testar, há 4.000 alunos no banco de dados (então há 2.000.000 linhas), mas esse banco de dados deve lidar com vários milhões de alunos, é por isso que estou usando um MySQL ndbcluster.

De qualquer forma ... uma consulta como esta:

SELECT student, COUNT(class) as common_classes
FROM classes_table
WHERE class IN (my_subject_list)
GROUP BY student
ORDER BY common_classes DESC

resultando em algo como:

|student |commonClasses|
 Brad     6
 Melissa  4
 Chris    3
 Bob      3
 ...

leva cerca de 1 segundo com um mecanismo InnoDB em um servidor, o que é bom. Em um ndbcluster com 3 datanodes, a mesma consulta leva até 10 segundos, o que é demais. Não sei como o enunciado acima é tratado internamente, mas imagino que haja muita comunicação entre os nós, o que a torna lenta devido à latência. Alguém pode me dizer, o que acontece no cluster quando realizo esta consulta? Como posso torná-lo mais rápido?

Nota: esta é uma pergunta que surgiu depois que postei esta pergunta: https://stackoverflow.com/questions/9095054/how-do-i-compute-a-ranking-with-mysql-stored-procedures Para mais informações, dá uma olhada lá!