Acabei de instalar o servidor Wamp 2 e recebo os seguintes 4 usuários padrão do MySQL:
USER FROM HOST
<anonymous> localhost
root localhost
root 127.0.0.1
root ::1
O que significa ::1?
Suponha que eu tenha um subformulário, na exibição de planilha de dados para vários registros, que fornece ao usuário controle CRUD completo sobre uma tabela MySQL específica. (Os registros são filtrados pelo formulário-pai).
A opção 1 é simplesmente criar uma tabela vinculada e defini-la como fonte de registro para o subformulário. Isso, claro, requer pouco trabalho.
A opção 2 é criar um conjunto de procedimentos armazenados para inserir, excluir, atualizar e ler registros da tabela MySQL para/de uma tabela temporária local. A fonte de registro do subformulário é então definida para a tabela local e os eventos de formulário apropriados são vinculados às chamadas de procedimento armazenado apropriadas. Obviamente, isso requer muito mais trabalho do que a opção 1.
Agora, a pergunta óbvia é: por que escolher a opção 2? Bem, tenho experimentado a substituição de tabelas vinculadas por procedimentos armazenados e descobri que o aumento de velocidade é considerável, principalmente em uma rede lenta. Também fiz um pouco de trabalho de detetive e vasculhei os arquivos de log do MySQL e notei que a abordagem de tabela vinculada gera uma quantidade chocante de chamadas SQL. Isso explica a diferença de desempenho, suponho.
De qualquer forma, agora estou pensando em substituir todas as tabelas vinculadas pela opção de procedimentos armazenados (bem, talvez apenas as tabelas importantes). Alguém mais teve essa experiência? Quaisquer pensamentos ou conselhos?
Eu tenho um banco de dados MySql (5.5) com um front-end do MS Access. Se dois usuários estiverem visualizando o mesmo registro ao mesmo tempo, como posso tornar cada usuário ciente um do outro? Por exemplo, como eu exibiria um rótulo indicando que outro usuário também está visualizando o mesmo registro?
Estou usando o MySQL5.5 e para esta pergunta tenho 3 tabelas simples t1, t2 e t3 projetadas assim:
+------------+ +------------+ +------------+
| t1 | | t2 | | t3 |
+------------+ +------------+ +------------+
| t1_id (PK) | | t2_id (PK) | | t3_id (PK) |
+------------+ | some_value | | t1_id (FK) |
+------------+ | t2_id (FK) |
+------------+
PK = chave primária, FK = chave estrangeira e todos os campos são do tipo INT
O problema que tenho é que quero adicionar uma restrição à tabela t3 que envolve o campo t2.some_value. Basicamente, eu quero que a combinação de t1.t1_ide t2.some_valueseja única na tabela t3. Por exemplo, aqui está uma situação que quero evitar:
t1 t2 t3
+-------+ +-------+------------+ +-------+-------+-------+
| t1_id | | t2_id | some_value | | t3_id | t1_id | t2_id |
+-------+ +-------+------------+ +-------+-------+-------+
| 10 | | 20 | 1 | | 30 | 10 | 20 | <-- t2.some_value = 1
| 11 | | 21 | 2 | | 31 | 10 | 21 |
+-------+ | 22 | 3 | | 32 | 10 | 22 |
| 23 | 1 | | 33 | 10 | 23 | <-- t2.some_value = 1
+-------+------------+ | 34 | 11 | 23 |
+-------+-------+-------+
O problema aqui é que dois registros em t3 vinculam o mesmo registro t1 (t1_id=10) a dois registros t2 diferentes que têm o mesmo arquivo some_value. Existe alguma maneira de evitar que isso aconteça? Que eu saiba, o MySql não permite a definição de restrições que abrangem várias tabelas.
Posso pensar em uma solução, mas isso envolve duplicar o some_valuecampo na tabela t3 para que eu possa aplicar uma chave exclusiva diretamente a ele. Isso obviamente quebra a regra de design de normalização, mas existe outra maneira?