Estou planejando fazer uma migração de banco de dados para um novo servidor. Durante o estágio de transição, não quero que o usuário do Apache possa gravar nada no banco de dados. Eu tenho duas opções.
Revogar privilégios de gravação:
REVOKE INSERT, UPDATE ON `mydb`.* FROM 'apache'@'localhost';
FLUSH PRIVILEGES;
Defina o banco de dados para o modo somente leitura:
FLUSH TABLES WITH READ LOCK;
SET GLOBAL read_only = 1;
Existem considerações práticas para escolher um sobre o outro?
Gostaria de realizar um teste de restauração em um backup instantâneo do meu banco de dados MariaDB usando um servidor de teste em execução em um sistema operacional de 32 bits. Meu servidor de produção é um sistema de 64 bits. Gostaria de saber se a arquitetura do SO faz diferença para os arquivos do banco de dados. Ambos os servidores estão executando a mesma versão do MariaDB.
Eu vi duas abordagens diferentes para fazer backup de banco de dados com instantâneo LVM. Este artigo sugere gerar outra instância MySQL para fazer um despejo SQL. O MYSQL Performance Blog sugere que é seguro copiar diretamente os arquivos do banco de dados:
6) Copie os dados para backup. Normalmente, você pode ignorar os logs de consulta lentos e o log de erros durante o backup. Você também pode pular a maioria dos logs binários - no entanto, se alguns de seus escravos estiverem muito atrasados, você pode querer manter alguns dos últimos logs binários apenas por precaução, ou você pode assumir que, em caso de recuperação do backup, você precisará restaurar os escravos como bem e pule logs binários em seu processo de backup.
Para o banco de dados no InnoDBformato, posso apenas fazer backup da /var/lib/mysql/pasta?
Estou muito incomodado com esse comportamento estranho que estou vendo no auto_incrementvalor registrado no bidID de uma tabela de Bids após realizar a inserção em massa usando um procedimento armazenado:
INSERT INTO Bids (itemID, buyerID, bidPrice)
SELECT itemID, rand_id(sellerID, user_last_id), FLOOR((1 + RAND())*askPrice)
FROM Items
WHERE closing BETWEEN NOW() AND NOW() + INTERVAL 1 WEEK ORDER BY RAND() LIMIT total_rows;
Por exemplo, se o auto_incrementvalor bidID for 101 no início e eu inserir 100 linhas, o valor final se tornará 213 em vez de 201. No entanto, os bidIDs dessas linhas inseridas são executados sequencialmente até um máximo de 201.
Verificando o seguinte,
SHOW VARIABLES LIKE 'auto_inc%';
+--------------------------+-------+
| Variable_name | Value |
+--------------------------+-------+
| auto_increment_increment | 1 |
| auto_increment_offset | 1 |
+--------------------------+-------+
Eu não tenho idéia por que isso está acontecendo. O que poderia estar causando o salto no auto incrementvalor?
Eu testei várias consultas simples como:
SELECT COUNT(*) FROM Users WHERE courses='a';
Mas nenhum está sendo armazenado em cache. A seguir estão as variáveis relacionadas ao cache:
show variables like "%cache%";
+-------------------------------+----------------------+
| Variable_name | Value |
+-------------------------------+----------------------+
| aria_pagecache_age_threshold | 300 |
| aria_pagecache_buffer_size | 100000000 |
| aria_pagecache_division_limit | 100 |
| binlog_cache_size | 32768 |
| binlog_stmt_cache_size | 32768 |
| have_query_cache | YES |
| join_cache_level | 2 |
| key_cache_age_threshold | 300 |
| key_cache_block_size | 1024 |
| key_cache_division_limit | 100 |
| key_cache_segments | 0 |
| max_binlog_cache_size | 18000000000000000000 |
| max_binlog_stmt_cache_size | 18000000000000000000 |
| metadata_locks_cache_size | 1024 |
| query_cache_limit | 1048576 |
| query_cache_min_res_unit | 4096 |
| query_cache_size | 0 |
| query_cache_strip_comments | OFF |
| query_cache_type | ON |
| query_cache_wlock_invalidate | OFF |
| stored_program_cache | 256 |
| table_definition_cache | 400 |
| table_open_cache | 400 |
| thread_cache_size | 0 |
+-------------------------------+----------------------+
O status relacionado ao cache mostra:
show status like "%cache%";
+-----------------------------------+-------+
| Variable_name | Value |
+-----------------------------------+-------+
| Aria_pagecache_blocks_not_flushed | 0 |
| Aria_pagecache_blocks_unused | 15737 |
| Aria_pagecache_blocks_used | 2 |
| Aria_pagecache_read_requests | 78 |
| Aria_pagecache_reads | 3 |
| Aria_pagecache_write_requests | 6 |
| Aria_pagecache_writes | 0 |
| Binlog_cache_disk_use | 0 |
| Binlog_cache_use | 0 |
| Binlog_stmt_cache_disk_use | 0 |
| Binlog_stmt_cache_use | 0 |
| Com_assign_to_keycache | 0 |
| Qcache_free_blocks | 0 |
| Qcache_free_memory | 0 |
| Qcache_hits | 0 |
| Qcache_inserts | 0 |
| Qcache_lowmem_prunes | 0 |
| Qcache_not_cached | 0 |
| Qcache_queries_in_cache | 0 |
| Qcache_total_blocks | 0 |
| Ssl_callback_cache_hits | 0 |
| Ssl_session_cache_hits | 0 |
| Ssl_session_cache_misses | 0 |
| Ssl_session_cache_mode | NONE |
| Ssl_session_cache_overflows | 0 |
| Ssl_session_cache_size | 0 |
| Ssl_session_cache_timeouts | 0 |
| Ssl_used_session_cache_entries | 0 |
| Subquery_cache_hit | 0 |
| Subquery_cache_miss | 0 |
| Threads_cached | 0 |
+-----------------------------------+-------+
Li todo o manual e verifiquei se as seguintes condições são atendidas:
não é da forma:
SELECT SQL_NO_CACHE ... SELECT ... INTO OUTFILE ... SELECT ... INTO DUMPFILE ... SELECT ... FOR UPDATE SELECT * FROM ... WHERE autoincrement_column IS NULL SELECT ... LOCK IN SHARE MODE
A única coisa que não tenho certeza é:
Eu corro SHOW FULL COLUMNS FROM Users;e todas as colunas contêm "selecionar, inserir, atualizar". Mesmo as tabelas recém-criadas contêm esses privilégios. Alguém pode explicar o que pode estar errado?
Não entendi ao consultar 5 linhas de uma tabela de 500.000 linhas, a seguinte consulta leva 0,00seg:
SELECT id, username FROM Users FORCE INDEX (PRIMARY) ORDER BY id LIMIT 20,5;
Mas consultar exatamente as mesmas linhas no sentido inverso leva 2,50 segundos:
SELECT id, username FROM Users FORCE INDEX (PRIMARY) ORDER BY id DESC LIMIT 499975,5;
Além disso, se eu não forçar o índice para a segunda consulta, o MySQL optará por não usá-lo.
Observo que há um plano para introduzir ordem de classificação para o índice, mas isso não explica por que o MySQL não pode usar o mesmo índice de forma eficaz quando LIMIT offset é grande, pois conhece a contagem total de linhas.
Desejo fazer backup do meu site que contém imagens carregadas pelo usuário e dados armazenados no banco de dados MySQL, de modo que sejam sempre consistentes entre si em qualquer ponto específico do tempo. Enquanto procurava soluções, encontrei este rsnapshot de aplicativo que pode ser apropriado para a tarefa. Tendo passado por alguns blogs na internet, percebi que isso é realmente feito com um backup_script usando o método mysqldump:
backup_script ssh [email protected] "mysqldump -A > /var/db/dump/mysql.sql" unused2
backup [email protected]:/var/db/dump/ example.com/
O que não tenho certeza é se há necessidade de liberar todas as tabelas com bloqueio de leitura antes de executar o dump no script para garantir a consistência do banco de dados. Em caso afirmativo, como isso deve ser incorporado? Se não, por que não é necessário?
Preciso realizar uma atualização do MySQL no meu servidor web. Pode haver muitos usuários conectados ao servidor a qualquer momento, realizando consultas ou atualizações no banco de dados ou enviando arquivos para o servidor. Além de colocar uma notificação avançada de que o sistema estará em manutenção durante um determinado período de tempo, o que devo fazer para evitar o cenário de parar o serviço MySQL ou o servidor enquanto algumas operações do usuário ainda estão sendo realizadas, o que pode levar a uma corrupção do sistema de arquivos ou do banco de dados?
No manual do MySQL, diz:
BOOL, BOOLEAN
Esses tipos são sinônimos de TINYINT(1). Um valor de zero é considerado falso. Valores diferentes de zero são considerados verdadeiros:
Criei uma coluna BOOLEAN com 0o valor padrão. Então eu atualizo o valor para 2. Logicamente, eu esperaria que o MySQL aceitasse 0ou 1porque é um booleano. No entanto, o MySQL não emitiu um erro ou me impediu de realizar a atualização.
Se BOOLEAN funciona exatamente da mesma forma que TINYINT(1), faz alguma diferença se eu uso TINYINT(1) ou BOOLEAN?