# Referência do MariaDB no SQL do Amazon RDS
A seguir, há descrições de procedimentos armazenados em sistema que estão disponíveis para instâncias do Amazon RDS em execução no mecanismo de banco de dados do MariaDB.
Também é possível usar os procedimentos armazenados em sistema que estão disponíveis para as instâncias de banco de dados MySQL para instâncias de banco de dados MariaDB. Esses procedimentos armazenados estão documentados em [Referência de procedimentos armazenados do RDS para MySQL](Appendix.MySQL.SQLRef.md). As instâncias de banco de dados MariaDB são compatíveis com todos os procedimentos armazenados, exceto `mysql.rds_start_replication_until` e `mysql.rds_start_replication_until_gtid`.
Além disso, os procedimentos armazenados em sistema a seguir são compatíveis apenas para instâncias de banco de dados do Amazon RDS que executam o MariaDB:
+ [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md)
+ [mysql.rds\$1kill\$1query\$1id](mysql_rds_kill_query_id.md)
+ [mysql.rds\$1execute\$1operation](mysql_rds_execute_operation.md)
# mysql.rds\$1replica\$1status
Mostra o status de replicação de uma réplica de leitura MariaDB.
Chame este procedimento na réplica de leitura para mostrar informações de status sobre parâmetros essenciais dos threads de réplica.
## Sintaxe
```
CALL mysql.rds_replica_status;
```
## Observações de uso
Esse procedimento só é compatível com instâncias de banco de dados MariaDB que executam MariaDB versão 10.5 e versões posteriores.
Esse procedimento é o equivalente ao comando `SHOW REPLICA STATUS`. Esse comando não é compatível com instâncias de banco de dados MariaDB versão 10.5 e posterior.
Nas versões anteriores do MariaDB, esse comando `SHOW SLAVE STATUS` exigia o privilégio `REPLICATION SLAVE`. No MariaDB versão 10.5 e posteriores, ele requer o privilégio `REPLICATION REPLICA ADMIN`. Para proteger o gerenciamento do RDS das instâncias de banco de dados MariaDB 10.5, esse novo privilégio não é concedido ao usuário principal do RDS.
## Exemplos
O exemplo a seguir mostra o status de uma réplica de leitura MariaDB:
```
call mysql.rds_replica_status;
```
A resposta é semelhante à seguinte:
```
*************************** 1. row ***************************
Replica_IO_State: Waiting for master to send event
Source_Host: XX.XX.XX.XXX
Source_User: rdsrepladmin
Source_Port: 3306
Connect_Retry: 60
Source_Log_File: mysql-bin-changelog.003988
Read_Source_Log_Pos: 405
Relay_Log_File: relaylog.011024
Relay_Log_Pos: 657
Relay_Source_Log_File: mysql-bin-changelog.003988
Replica_IO_Running: Yes
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table: mysql.rds_sysinfo,mysql.rds_history,mysql.rds_replication_status
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 405
Relay_Log_Space: 1016
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: 0
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 807509301
Source_SSL_Crl:
Source_SSL_Crlpath:
Using_Gtid: Slave_Pos
Gtid_IO_Pos: 0-807509301-3980
Replicate_Do_Domain_Ids:
Replicate_Ignore_Domain_Ids:
Parallel_Mode: optimistic
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Replica_SQL_Running_State: Reading event from the relay log
Replica_DDL_Groups: 15
Replica_Non_Transactional_Groups: 0
Replica_Transactional_Groups: 3658
1 row in set (0.000 sec)
Query OK, 0 rows affected (0.000 sec)
```
# mysql.rds\$1set\$1external\$1master\$1gtid
Configura a replicação baseada em GTID de uma instância do MariaDB executada externamente em relação ao Amazon RDS para uma instância de banco de dados MariaDB. Esse procedimento armazenado é compatível apenas com a versão 10.0.24 ou posteriores da instância externa do MariaDB. Ao configurar a replicação na qual uma ou ambas as instâncias não oferecem suporte a identificadores de transações globais (GTIDs) do MariaDB, use [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master).
O uso de GTIDs para replicação oferece recursos de segurança contra falhas não disponibilizados pela replicação de log binário, por isso recomendamos nos casos em que há o suporte pelas instâncias de replicação.
## Sintaxe
```
CALL mysql.rds_set_external_master_gtid(
host_name
, host_port
, replication_user_name
, replication_user_password
, gtid
, ssl_encryption
);
```
## Parâmetros
*host\$1name*
String. O nome de host ou o endereço IP da instância do MariaDB sendo executada externamente ao Amazon RDS que se tornará a instância de origem.
*host\$1port*
Inteiro. A porta usada para executar a instância do MariaDB sendo executada externamente ao Amazon RDS a ser configurada como a instância de origem. Se sua configuração de rede inclui replicação de porta SSH que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
String. O ID de um usuário com permissões `REPLICATION SLAVE` na instância de banco de dados MariaDB deve ser configurado como a réplica de leitura.
*replication\$1user\$1password*
String. A senha do ID de usuário especificada em `replication_user_name`.
*gtid*
String. O ID da transação global na instância de origem a partir da qual a replicação deve iniciar.
É possível usar o `@@gtid_current_pos` para obter o GTID atual se a instância de origem tiver sido bloqueada enquanto você estiver configurando a replicação, de modo que o log binário não mude entre os pontos quando você obtiver o GTID e quando a replicação iniciar.
Caso contrário, se você estiver usando o `mysqldump` versão 10.0.13 ou posterior para preencher a instância de réplica antes de iniciar a replicação, será possível obter a posição de GTID na saída usando as opções `--master-data` ou `--dump-slave`. Se você não estiver usando o `mysqldump` versão 10.0.13 ou superior, você poderá executar o `SHOW MASTER STATUS` ou usar as mesmas opções de `mysqldump` para obter o nome e a posição do arquivo de log binário, convertê-los em um GTID executando `BINLOG_GTID_POS` na instância externa do MariaDB:
```
SELECT BINLOG_GTID_POS('', );
```
Para obter mais informações sobre a implantação de GTIDs do MariaDB, acesse [Global Transaction ID](http://mariadb.com/kb/en/mariadb/global-transaction-id/) na documentação do MariaDB.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `MASTER_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
## Observações de uso
O procedimento `mysql.rds_set_external_master_gtid` deve ser executado pelo usuário mestre. Ele deve ser executado na instância de banco de dados MariaDB que você está configurando como a réplica de uma instância do MariaDB, sendo executada externamente ao Amazon RDS. Antes de executar `mysql.rds_set_external_master_gtid`, é necessário configurar a instância do MariaDB sendo executada externamente ao Amazon RDS como uma instância de origem. Para obter mais informações, consulte [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB](MariaDB.Procedural.Importing.md).
**Atenção**
Não use o `mysql.rds_set_external_master_gtid` para gerenciar uma replicação entre duas instâncias de banco de dados do Amazon RDS. Use-o apenas ao replicar com uma instância MariaDB sendo executada externamente ao RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Após chamar `mysql.rds_set_external_master_gtid` para configurar uma instância de banco de dados do Amazon RDS como uma réplica de leitura, você poderá chamar [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) na réplica para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) para remover a configuração da réplica de leitura.
Quando `mysql.rds_set_external_master_gtid` é chamado, o Amazon RDS grava a hora, o usuário e uma ação do "mestre do conjunto" nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
## Exemplos
Quando executado em uma instância de banco de dados MariaDB, o exemplo a seguir o configura como a réplica de uma instância do MariaDB sendo executada externamente ao Amazon RDS.
```
call mysql.rds_set_external_master_gtid ('Sourcedb.some.com',3306,'ReplicationUser','SomePassW0rd','0-123-456',0);
```
# mysql.rds\$1kill\$1query\$1id
Encerra uma consulta em execução no servidor do MariaDB para terminar consultas problemáticas ou de longa duração. É possível identificar o ID da consulta e interromper efetivamente uma consulta específica para resolver problemas de desempenho e manter a operação ideal do banco de dados.
## Sintaxe
```
CALL mysql.rds_kill_query_id(queryID);
```
## Parâmetros
*queryID*
Inteiro. A identidade da consulta a ser encerrada.
## Observações de uso
Para encerrar uma consulta em execução no servidor do MariaDB, use o procedimento `mysql.rds_kill_query_id` e passe o ID da consulta. Para obter o ID da consulta, consulte a [Tabela Information schema PROCESSLIST](http://mariadb.com/kb/en/mariadb/information-schema-processlist-table/) do MariaDB, como mostrado a seguir:
```
SELECT USER, HOST, COMMAND, TIME, STATE, INFO, QUERY_ID FROM
INFORMATION_SCHEMA.PROCESSLIST WHERE USER = '';
```
A conexão ao servidor do MariaDB é retida.
## Exemplos
O exemplo a seguir encerra uma consulta com um ID de consulta de 230040:
```
call mysql.rds_kill_query_id(230040);
```
# mysql.rds\$1execute\$1operation
Executa operações do InnoDB para gerenciar estados de grupo de buffers e espaços para tabela temporários. Esse procedimento pode ser usado para controlar dinamicamente as operações do InnoDB, como despejar e carregar estados do grupo de buffers ou truncar o espaço para tabela temporário.
## Sintaxe
```
CALL mysql.rds_execute_operation(operation);
```
## Parâmetros
*Operação do*
String. As operações do InnoDB a serem executadas. Os valores válidos são:
+ *innodb\$1buffer\$1pool\$1dump\$1now*: operação que despeja o estado atual do grupo de buffers.
+ *innodb\$1buffer\$1pool\$1load\$1now*: operação que carrega o estado do grupo de buffers salvo.
+ *innodb\$1buffer\$1pool\$1load\$1abort*: operação que cancela uma operação de carregamento do grupo de buffers.
+ *innodb\$1truncate\$1temporary\$1tablespace\$1now*: operação que trunca o espaço para tabela temporário.
## Observações de uso
Esse procedimento só é compatível com instâncias de banco de dados MariaDB que executam MariaDB versão 11.8 e versões posteriores.
Durante a execução, o registro em log binário é temporariamente desabilitado para impedir a replicação desses comandos administrativos.
O procedimento mantém uma trilha de auditoria registrando em log todas as operações na tabela [https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls](https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls).
## Exemplos
O exemplo a seguir demonstra a redução temporária do espaço para tabela usando `mysql.rds_execute_operation`:
Para conferir o tamanho atual do espaço para tabela temporário, execute a seguinte consulta:
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+------------+
| FILE_SIZE |
+------------+
| 6723469312 | -- 6.3 GB
+------------+
```
Quando você elimina tabelas temporárias, isso não reduz o uso de armazenamento no espaço para tabela global. Para reduzir o tamanho do espaço para tabela global, execute o comando `mysql.rds_execute_operation` para reduzir o espaço para tabela temporário.
```
CALL mysql.rds_execute_operation('innodb_truncate_temporary_tablespace_now');
Query OK, 2 rows affected (0.004 sec)
```
Depois de executar o procedimento, verifique se o espaço foi recuperado.
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+-----------+
| FILE_SIZE |
+-----------+
| 12582912 | -- 12 MB
+-----------+
```
**nota**
A operação de redução pode levar algum tempo, dependendo do tamanho do espaço para tabela temporário e da workload atual.
**Importante**
O espaço para tabela temporário diminui somente quando todas as tabelas temporárias que contribuíram para seu tamanho não estão mais em uso. Recomendamos que você execute esse procedimento quando não houver espaços para tabela temporários ativos na instância.