# Como atualizar MySQL ou MariaDB na hospedagem compartilhada

Onde fica o botão que não existe, o que o dump precisa ter antes de qualquer pedido e como ensaiar o sql_mode do MySQL 8.0 sem tocar na versão do servidor.

> em conta compartilhada você atualiza zero: a versão do MySQL/MariaDB pertence ao servidor inteiro e só o root troca pelo WHM. O caminho real é migrar a aplicação para um host com a versão exigida ou pedir o upgrade sabendo que downgrade in-place não existe.

João Rizzon · 2026-09-29 · Servidores

---

Uma instalação exige MySQL 8.0 ou MariaDB 10.6 e você está numa conta compartilhada. Abre o cPanel procurando o seletor de versão do banco, do jeito que existe para o PHP no MultiPHP Manager, e não encontra. Não é um item escondido: ele não existe. A versão do motor SQL é uma propriedade do servidor inteiro, não da conta, e a troca acontece em outro plano, pelo WHM, com a conta de root, conforme o [MySQL Upgrade Information Center do cPanel](https://docs.cpanel.net/knowledge-base/sql/mysql-upgrade-information-center/).

A partir daí sobram dois caminhos reais, e este texto trata dos dois: levar a aplicação para um ambiente que já roda a versão exigida, ou pedir o upgrade ao provedor sabendo exatamente o que se compromete, porque a mudança não volta atrás na mesma instalação.

Não há medição nossa neste tema. Tudo o que segue é documental ou reproduzível em laboratório: os comandos, as consultas e as mensagens de erro são exemplos que você pode executar numa base de teste, não telemetria de produção.

## Quem troca a versão do banco em hospedagem compartilhada

O daemon MySQL ou MariaDB é um único processo servindo todas as contas da máquina. Não existe instância por usuário em compartilhado convencional. Consequência prática: subir de MariaDB 10.5 para 10.11 muda o motor de todos os sites daquele servidor ao mesmo tempo, e o serviço reinicia durante o procedimento, o que significa indisponibilidade de banco para todo mundo naquele host, não só para você.

A interface que faz isso no cPanel/WHM é o assistente de upgrade de MySQL/MariaDB, e ele é operação de root: não há ACL de revendedor que delegue essa ação. A documentação do cPanel descreve o fluxo, os pré-requisitos e as advertências. Em conta compartilhada você não tem essa sessão, e nenhum comando no seu shell vai trocar o binário do servidor.

O que você controla na sua conta:

- as bases, tabelas, usuários de banco e privilégios dentro do seu prefixo;
- o charset e a collation das suas tabelas e colunas;
- o `sql_mode` da sua sessão, o que é mais útil do que parece (seção sobre ensaio, adiante);
- a versão do PHP por domínio, via MultiPHP Manager.

Extensões de PHP são caso à parte: dependem do que o servidor oferece. Em servidores com CloudLinux existe o Select PHP Version, onde você marca e desmarca extensões por conta; onde ele não existe, o que sobra é o MultiPHP INI Editor para diretivas do `php.ini`, e habilitar um módulo novo passa por root. Confira qual das duas interfaces aparece no seu cPanel antes de contar com ela.

O que você não controla: versão do servidor, `default_authentication_plugin`, `sql_mode` global, `innodb_*`, collation padrão do servidor.

## Confirme o motor e a versão reais, não o rótulo do painel

Antes de pedir qualquer coisa, saiba o que existe. O rótulo exibido em painel às vezes é genérico ("MySQL") quando o motor é MariaDB. Rode isto por SSH ou na aba SQL do phpMyAdmin:

```sql
SELECT VERSION() AS versao,
       @@version_comment AS distro,
       @@sql_mode        AS sql_mode,
       @@character_set_server  AS charset_srv,
       @@collation_server      AS collation_srv,
       @@default_storage_engine AS engine;
```

Como ler o resultado:

- `VERSION()` terminando em `-MariaDB` é MariaDB, independentemente do que o painel diz. `8.0.x` sem sufixo é MySQL da Oracle.
- `@@version_comment` costuma identificar a origem do pacote (por exemplo Source distribution, MariaDB Server, ou MySQL Community Server). Esses dois campos bastam para saber qual motor você tem; não tente usar `@@innodb_version` como desempate, porque em MariaDB moderno ele espelha a versão do servidor e não distingue nada.
- `@@sql_mode` é o que realmente vai derrubar consultas. Guarde essa string: é a linha de base para comparar depois.

Para saber se a sua aplicação de fato precisa da versão nova, olhe o que ela usa e não só o que o README pede. Duas consultas rápidas:

```sql
-- funções de janela: MySQL 8.0+ e MariaDB 10.2+
-- CTE recursiva: MySQL 8.0+ e MariaDB 10.2.2+
-- JSON_TABLE: MySQL 8.0.4+ e sem equivalente em MariaDB
SELECT ROUTINE_NAME, ROUTINE_TYPE
FROM information_schema.ROUTINES
WHERE ROUTINE_SCHEMA = DATABASE();

SELECT TABLE_NAME, ENGINE, ROW_FORMAT, TABLE_COLLATION
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = DATABASE();
```

Recomendação contra o nosso próprio interesse: muita exigência de "MySQL 8 ou superior" em documentação de aplicação é um mínimo conservador do time de desenvolvimento, não um requisito de sintaxe. Se o schema não usa `JSON_TABLE`, funções de janela, índices descendentes reais ou colunas virtuais indexadas, é comum a aplicação rodar sem nenhum ajuste num MariaDB 10.5. Testar isso custa uma tarde e pode evitar uma migração inteira. Quando a aplicação realmente usa recurso exclusivo, o erro aparece na primeira consulta e a decisão fica óbvia.

## O dump completo e verificável, antes de pedir o upgrade

O upgrade não tem volta na mesma instalação. Isso torna o backup a única rede de segurança, e um backup não verificado é uma suposição. Pelo SSH da conta, por base:

```bash
mysqldump --single-transaction --quick --no-tablespaces \
  --routines --triggers --events \
  --default-character-set=utf8mb4 \
  --databases usuario_loja > usuario_loja-$(date +%F).sql
```

O que cada flag resolve, e onde ela falha:

- `--single-transaction` dá consistência sem travar escrita, mas só para tabelas InnoDB. Se `information_schema.TABLES` mostrar MyISAM ou Aria, esse dump não é consistente para elas. Nesse caso, ou você converte a tabela para InnoDB antes, ou aceita fazer o dump em janela sem tráfego.
- `--no-tablespaces` evita o erro de acesso negado por falta do privilégio `PROCESS`, que a conta compartilhada normalmente não tem no MySQL 8.
- `--routines --triggers --events` inclui procedures, funções, triggers e eventos. Se `--events` retornar acesso negado por falta do privilégio `EVENT`, remova a flag e confirme que você não tem eventos agendados.
- `--databases` inclui o `CREATE DATABASE` e o `USE`, o que é bom para restaurar no lugar e ruim para restaurar num nome diferente. Para o teste de restauração, gere um segundo dump sem essa flag.

### Verificar que o dump não foi truncado

O fim do arquivo é a prova de que o `mysqldump` terminou, e não morreu no meio por timeout ou disco cheio:

```bash
tail -n 3 usuario_loja-2026-09-17.sql
# a última linha precisa ser algo como:
# -- Dump completed on 2026-09-17 14:02:11
```

Sem essa linha, o dump está truncado. Não siga adiante. Se comprimiu, teste a integridade do container antes:

```bash
gzip -t usuario_loja-2026-09-17.sql.gz && echo ok
```

### Restaurar em base de teste e comparar COUNT e CHECKSUM

Crie uma base extra na conta (`usuario_teste`) pelo cPanel e restaure o dump gerado sem `--databases`:

```bash
mysqldump --single-transaction --quick --no-tablespaces \
  --routines --triggers usuario_loja > loja-tabelas.sql

mysql usuario_teste < loja-tabelas.sql
```

Depois compare o que importa, tabela por tabela, nas duas bases:

```sql
SELECT COUNT(*) FROM usuario_loja.pedidos;
SELECT COUNT(*) FROM usuario_teste.pedidos;

CHECKSUM TABLE usuario_loja.pedidos;
CHECKSUM TABLE usuario_teste.pedidos;
```

Não use `information_schema.TABLES.TABLE_ROWS` para conferir: em InnoDB é estimativa e varia entre execuções. `CHECKSUM TABLE` lê a tabela inteira, então é lento em tabelas grandes; rode nas que carregam dado de negócio e use `COUNT(*)` no resto.

Guarde o dump fora do servidor. Um backup que vive no mesmo disco do banco que você está mexendo não é backup.

## Por que o upgrade é de mão única e não aceita downgrade

Nem MySQL nem MariaDB suportam downgrade in-place entre releases maiores. O upgrade reescreve o dicionário de dados e estruturas internas, e o binário antigo não sabe ler o formato novo. Subiu de 10.5 para 10.11, ou de 5.7 para 8.0, e o caminho de volta não é desinstalar o pacote: é reinstalar a versão antiga e restaurar de um dump logicamente compatível. Em servidor compartilhado, isso significa reconstruir o serviço SQL da máquina inteira.

É por isso que o assistente do WHM apresenta a advertência e exige confirmação explícita antes de executar, e que a documentação do cPanel insiste em backup previamente. O conteúdo da advertência é o resumo honesto da situação: a operação é considerada irreversível, e o suporte à volta não existe.

Duas implicações para quem desenvolve:

- Se o servidor é compartilhado, o provedor está avaliando o risco de dezenas de sites de terceiros, não só o seu. Um pedido de upgrade pode ser legitimamente recusado, e recusar é a decisão tecnicamente defensável. Não interprete como má vontade.
- Se você precisa da versão nova com data marcada, o ambiente com root (VPS ou dedicado) resolve não porque é mais rápido, e sim porque te dá o snapshot antes e o controle da janela. O plano de reversão passa a existir.

## Os oito erros que aparecem depois da subida para o MySQL 8.0

Quando o motor sobe, o que rompe é previsível. A tabela abaixo é a lista dos casos que aparecem em quase toda subida para MySQL 8.0, com o erro exato, a causa e o conserto. Todos reproduzíveis numa base de teste.

| Erro | Causa | Correção |
|---|---|---||
| `ERROR 1055 (42000)` expression of SELECT list is not in GROUP BY clause | `ONLY_FULL_GROUP_BY` no `sql_mode` padrão desde o MySQL 5.7.5 | agregar a coluna (`MAX()`, `MIN()`), incluir no `GROUP BY` ou envolver em `ANY_VALUE()` |
| `ERROR 1292 (22007)` Incorrect date value: `'0000-00-00'` | `NO_ZERO_DATE` e `NO_ZERO_IN_DATE` combinados com `STRICT_TRANS_TABLES` | tornar a coluna `NULL`-able, migrar as datas zero para `NULL`, revisar `DEFAULT` |
| `ERROR 1406 (22001)` Data too long for column | antes o modo permissivo truncava, agora `STRICT_TRANS_TABLES` rejeita | validar no aplicativo ou aumentar o tamanho da coluna |
| `ERROR 2059` authentication plugin `caching_sha2_password` cannot be loaded | plugin de autenticação padrão do MySQL 8.0 contra driver antigo | usar PHP 7.4 ou superior com mysqlnd; em cliente legado, pedir usuário com `mysql_native_password` |
| `ERROR 1064 (42000)` syntax error near `rank` | `RANK`, `ROWS`, `GROUPS`, `OVER`, `WINDOW`, `LEAD`, `LAG` e companhia passaram a palavras reservadas no 8.0 | crase nos identificadores (`` `rank` ``) ou renomear a coluna |
| `ERROR 1267 (HY000)` Illegal mix of collations | `JOIN` entre coluna `utf8mb4_general_ci` (herdada do dump) e `utf8mb4_0900_ai_ci` (padrão novo) | padronizar a collation das duas tabelas, ou `COLLATE` explícito na comparação |
| aviso de depreciação em `utf8`/`utf8mb3` | `utf8` é apelido de `utf8mb3`, depreciado no 8.0 | converter tabelas e colunas para `utf8mb4` |
| `ERROR 1305 (42000)` FUNCTION PASSWORD does not exist | `PASSWORD()` foi removida no MySQL 8.0 | `ALTER USER ... IDENTIFIED BY '...'`, ou `SHA2()` se era hash de aplicação |

### Collation misturada, o erro 1267 que só aparece no primeiro JOIN

O detalhe que pega: ao restaurar um dump antigo num MySQL 8.0, as tabelas recriadas carregam `COLLATE utf8mb4_general_ci` escrito no `CREATE TABLE`. As tabelas que a aplicação criar depois nascem com a collation padrão do servidor, `utf8mb4_0900_ai_ci`. A base fica misturada, tudo funciona até o primeiro `JOIN` entre uma tabela velha e uma nova, e aí surge o 1267 num ponto do código que ninguém tocou.

Auditoria em uma consulta:

```sql
SELECT TABLE_NAME, COLUMN_NAME, CHARACTER_SET_NAME, COLLATION_NAME
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE()
  AND COLLATION_NAME IS NOT NULL
ORDER BY COLLATION_NAME, TABLE_NAME;
```

Se voltar mais de uma collation, padronize antes de o problema aparecer. Escolha uma e aplique nas duas pontas do `JOIN`. Vale notar que `utf8mb4_0900_ai_ci` não existe no MariaDB: se o destino é MariaDB, padronize em algo que os dois lados conheçam.

### Palavras reservadas do 8.0, em uma consulta

```sql
SELECT TABLE_NAME, COLUMN_NAME
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE()
  AND UPPER(COLUMN_NAME) IN (
    'RANK','ROWS','GROUPS','OVER','WINDOW','LEAD','LAG',
    'CUME_DIST','DENSE_RANK','FIRST_VALUE','LAST_VALUE',
    'NTILE','PERCENT_RANK','RECURSIVE'
  );
```

Nada retornado significa que essa classe de erro não vai aparecer. Se retornar, o conserto é barato agora e caro em produção.

### Por que subir dentro da linha MariaDB quebra menos

Subir dentro da linha MariaDB (10.5 para 10.11, ou para 11.x) rompe menos porque o `sql_mode` padrão do MariaDB não inclui `ONLY_FULL_GROUP_BY`, `PASSWORD()` continua existindo e a autenticação padrão segue sendo `mysql_native_password`. Os pontos de atenção mudam de lugar, e aqui a instrução é verificar em vez de acreditar:

- levante o `ENGINE` e o `ROW_FORMAT` das suas tabelas com a consulta de `information_schema.TABLES` acima e, se aparecer `COMPRESSED`, confirme o status desse formato na nota de upgrade da release exata de destino antes de subir.
- leia as notas de upgrade release por release, e não só a da versão final: o MariaDB documenta as incompatibilidades em página própria por release, e pular versões intermediárias esconde mudanças.
- se o destino for MySQL 8.4, confirme na nota de release da própria 8.4 qual é a situação do plugin `mysql_native_password` naquela linha, porque é isso que decide se um cliente legado continua conectando.

Não trate nenhum desses três itens como fato deste texto: trate como checagem a fazer na documentação oficial da versão de destino.

## Ensaie o upgrade mudando só o sql_mode da sessão

Este é o ponto que os tutoriais não cobrem, e ele funciona na sua conta compartilhada atual, sem pedir nada a ninguém. O `sql_mode` é ajustável por sessão. Você pode aplicar o padrão do MySQL 8.0 na sua conexão e rodar a aplicação contra o banco antigo para ver o que estoura.

A string precisa ir em uma linha só, sem espaço depois das vírgulas e sem quebra: espaço ou newline dentro do literal faz o servidor responder `ERROR 1231 (42000) Variable 'sql_mode' can't be set to the value of ...`.

```sql
SET SESSION sql_mode = 'ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION';

SELECT @@session.sql_mode;
```

Para exercitar a aplicação inteira, e não só consultas soltas, aplique o `SET SESSION` na abertura de cada conexão. Em PDO, note que a concatenação abaixo não introduz espaço nem quebra dentro das aspas simples:

```php
$dsn = 'mysql:host=localhost;dbname=usuario_teste;charset=utf8mb4';
$pdo = new PDO($dsn, $usuario, $senha, [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    PDO::MYSQL_ATTR_INIT_COMMAND =>
        "SET SESSION sql_mode='ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,"
      . "NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,"
      . "NO_ENGINE_SUBSTITUTION'",
]);
```

Rode a suíte de testes, ou navegue os fluxos críticos com `display_errors` e log de exceções ligados na base de teste. Cada 1055, 1292 e 1406 que aparecer é um bug que o upgrade real ia entregar em produção. O que essa técnica não cobre: palavras reservadas novas, mudanças de otimizador, autenticação e collation, porque essas dependem do binário, não do modo. Para esses quatro, use as consultas de auditoria das seções anteriores.

Para varrer datas zero antes da hora:

```sql
SELECT COUNT(*) FROM pedidos WHERE criado_em = '0000-00-00 00:00:00';
SELECT COUNT(*) FROM clientes WHERE nascimento = '0000-00-00';
```

Substitua por `NULL` com a coluna já `NULL`-able, ou por uma data sentinela que faça sentido no domínio. Fazer isso antes evita a importação falhando na metade, depois.

## Migrar a aplicação ou pedir o upgrade ao provedor

| Situação | Caminho mais razoável | Por quê |
|---|---|---||
| Aplicação nova, ainda sem dados em produção | provisionar onde a versão exigida já roda | custo zero de migração, nenhum risco de terceiros |
| Aplicação em produção, precisa de recurso exclusivo do 8.0 | migrar para ambiente com a versão, com dump validado e janela combinada | você controla o rollback: a instalação antiga continua intacta até a virada de DNS |
| Requisito da aplicação é só um mínimo declarado | ficar na versão atual e testar | frequentemente não há incompatibilidade real de sintaxe |
| Precisa de versão específica com data e plano de volta | ambiente com root e snapshot | em compartilhado o rollback não existe |
| O provedor já planeja subir a versão do servidor | preparar o código com a auditoria acima | a mudança vai chegar de qualquer forma; melhor chegar testado |

Migrar a aplicação tem uma vantagem que pedir upgrade não tem: durante a migração as duas versões coexistem. Você importa o dump no destino, aponta uma cópia da aplicação para lá, corrige o que a lista fechada apontar, e só então vira o tráfego. Se algo der errado, o ambiente antigo está de pé, com os dados de pé. O upgrade in-place não oferece esse intervalo.

## Ordem das operações, do inventário à pós-virada

- **Inventário.** Rodar o bloco de `SELECT VERSION()` e guardar a saída, inclusive o `@@sql_mode` atual.
- **Auditoria de schema.** Levantar collations, palavras reservadas, `ENGINE`, `ROW_FORMAT` e uso de `PASSWORD()` no schema e nas routines.
- **Varredura de dados.** Procurar datas zero e valores que hoje são truncados em silêncio.
- **Dump verificado.** Gerar o dump com as flags corretas, conferir a linha final `Dump completed on`, restaurar em base de teste e comparar `COUNT(*)` e `CHECKSUM TABLE`. Copiar o dump para fora do servidor.
- **Ensaio do sql_mode.** Aplicar o padrão do 8.0 por sessão e corrigir o código até a suíte passar limpa.
- **PHP.** Confirmar a versão do PHP no MultiPHP Manager, porque autenticação `caching_sha2_password` com driver antigo é falha de conexão, não de consulta.
- **Decisão.** Migrar a aplicação para onde a versão exigida já roda, ou abrir o pedido de upgrade ao provedor, ciente de que a operação é considerada irreversível na mesma instalação e afeta todas as contas daquele servidor.
- **Pós-virada.** Repetir o inventário e a auditoria de schema no ambiente novo. O `@@sql_mode` e a collation padrão mudaram, e é isso que explica qualquer comportamento diferente.

Se o dump verificado não sair com a linha final íntegra e restaurável, pare aí. Nenhum dos passos seguintes é seguro sem ele.

