Concurrency control - PolarDB: Central de Documentação do Alibaba Cloud

Pré-requisitos

Seu cluster PolarDB deve executar uma das seguintes versões:

PolarDB for MySQL 8.0.
PolarDB for MySQL 5.7 com versão de revisão 5.7.1.0.6 ou posterior.

Nota
Se o seu cluster executar o PolarDB for MySQL 5.7 com versão de revisão 5.7.1.0.27 ou posterior, o recurso CCL será compatível com o recurso thread pool.
PolarDB for MySQL 5.6.

Notas de uso

Modifique regras CCL apenas no nó primário. As alterações são sincronizadas automaticamente para todos os outros nós.

Funcionamento

Dimensões de correspondência

O CCL utiliza as cinco dimensões a seguir para comparar uma instrução SQL recebida com uma regra:

Dimensão	Descrição
TYPE	Tipo da instrução SQL, como SELECT, UPDATE, INSERT, DELETE ou DDL.
SCHEMA	Nome do banco de dados no qual a instrução SQL opera.
TABLE	Nome da tabela ou visualização na qual a instrução SQL opera.
KEYWORD	Palavra-chave dentro da instrução SQL. Especifique várias palavras-chave em uma regra CCL separando-as por ponto e vírgula (;).
DIGEST	String de hash gerada a partir da instrução SQL. Para obter mais informações, consulte STATEMENT_DIGEST().

Lógica de correspondência

Caso o valor DIGEST não esteja especificado em uma regra CCL:
- Se os valores TYPE, SCHEMA e TABLE estiverem definidos, a instrução SQL precisará corresponder às três dimensões para que a regra seja aplicada.
- Quando apenas o valor TYPE estiver definido, a instrução SQL deverá corresponder à dimensão TYPE para que a regra seja aplicada.
Nota
Se a dimensão KEYWORD também estiver especificada, o sistema realiza verificações adicionais:
- Ao definir uma única palavra-chave, a instrução SQL deve contê-la para que a correspondência tenha sucesso.
- Ao definir múltiplas palavras-chave, a instrução SQL precisa conter todas elas para que a correspondência tenha sucesso. A ordem das palavras-chave na instrução SQL não importa.
Se o valor DIGEST estiver especificado em uma regra CCL, o valor DIGEST da instrução SQL deve corresponder ao valor DIGEST da regra. Caso o valor SCHEMA também esteja definido na regra, o valor SCHEMA da instrução também precisará corresponder.
Quando o valor SCHEMA não estiver especificado em uma regra CCL, a instrução SQL precisará corresponder apenas ao valor DIGEST para que a regra seja aplicada.

Prioridade de correspondência

Uma instrução SQL pode corresponder a apenas uma regra CCL. Se uma instrução corresponder a várias regras, o PolarDB aplicará aquela com a maior prioridade. Caso múltiplas regras tenham a mesma prioridade, o PolarDB usará a regra com o menor ID. A prioridade de uma regra baseia-se em suas dimensões de correspondência, na seguinte ordem decrescente:

DIGEST
TYPE, SCHEMA e TABLE
Apenas TYPE

Parâmetros

Modifique os parâmetros a seguir no console do PolarDB. Para obter mais informações, consulte Configure cluster and node parameters.

Parâmetro

Descrição

loose_ccl_mode

Ação a ser tomada quando o limite de concorrência for excedido. Valores válidos:

WAIT (Padrão): O sistema coloca a instrução SQL em uma fila e aguarda a conclusão de outras instruções.
REFUSE: O sistema retorna um erro.

Nota

Este parâmetro tem suporte apenas no PolarDB for MySQL 8.0. Nas versões 5.6 e 5.7, o sistema enfileira as instruções automaticamente.

loose_ccl_max_waiting_count

Quando loose_ccl_mode está definido como WAIT, este parâmetro especifica o número máximo de instruções SQL enfileiradas para uma única regra CCL. O sistema retorna um erro se esse limite for excedido.

Valores válidos: 0 a 65536. Valor padrão: 0.

Nota

Este parâmetro tem suporte apenas no PolarDB for MySQL 5.7 e 8.0.

Tabela de regras CCL

O PolarDB armazena as regras CCL na tabela de sistema concurrency_control. O sistema cria essa tabela automaticamente na inicialização, portanto, não é necessário criá-la manualmente. A instrução CREATE TABLE a seguir mostra a estrutura da tabela:

CREATE TABLE concurrency_control (
  Id bigint AUTO_INCREMENT NOT NULL,
  Type varchar(64),
  Schema_name varchar(64),
  Table_name varchar(64),
  Concurrency_count bigint NOT NULL,
  Keywords text,
  State enum('N','Y') COLLATE utf8_general_ci DEFAULT 'Y' NOT NULL,
  Ordered enum('N','Y') COLLATE utf8_general_ci DEFAULT 'N' NOT NULL,
  Digest varchar(64),
  Digest_text longtext,
  Extra mediumtext,
  PRIMARY KEY Rule_id(id)
) Engine=InnoDB STATS_PERSISTENT=0 CHARACTER SET utf8 COLLATE utf8_bin
  comment='Concurrency control' TABLESPACE=mysql;

A tabela a seguir descreve os parâmetros da tabela concurrency_control.

Parâmetro	Descrição
Id	ID da regra CCL.
Type	Tipo da instrução SQL, como SELECT, UPDATE, INSERT, DELETE ou DDL.
Schema_name	Nome do banco de dados.
Table_name	Nome da tabela no banco de dados.
Concurrency_count	Número máximo de instruções simultâneas permitidas pela regra. Nota Defina o valor de `Concurrency_count` como 0 para implementar uma lista de bloqueios de SQL, o que impede a execução de consultas correspondentes.
Keywords	Palavra-chave ou palavras-chave para correspondência. Separe múltiplas palavras-chave com ponto e vírgula (;).
State	Indica se a regra está ativada. Valores válidos: Y (Padrão): A regra está ativada. N: A regra está desativada.
Ordered	Se múltiplas palavras-chave forem especificadas no campo Keywords, este parâmetro define se elas devem ser correspondidas na ordem especificada. Valores válidos: N (Padrão): As palavras-chave no campo Keywords não precisam ser correspondidas em ordem. Y: As palavras-chave no campo Keywords devem ser correspondidas em ordem.
Digest	String de hash de 64 bytes gerada a partir de `Digest_text`. Para obter mais informações, consulte STATEMENT_DIGEST().
Digest_text	Digest normalizado da instrução SQL.
Extra	Informações adicionais.

Gerencie regras CCL

O PolarDB fornece os seis procedimentos armazenados a seguir no pacote DBMS_CCL para gerenciar regras CCL:

add_ccl_rule: Adiciona uma regra CCL com base em TYPE, SCHEMA, TABLE e KEYWORD.
Sintaxe
```
dbms_ccl.add_ccl_rule('<Type>','<Schema_name>','<Table_name>',<Concurrency_count>,'<Keywords>');
```
Example
- Adicione uma regra CCL para instruções SELECT com contagem de concorrência de 10. Ao atingir esse limite, o sistema enfileira ou recusa as instruções subsequentes.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 10, '');
```
- Adicione uma regra CCL para instruções SELECT que contenham a palavra-chave key1, com contagem de concorrência de 20.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1');
```
- Adicione uma regra CCL para instruções SELECT que contenham as palavras-chave key1, key2 e key3, com contagem de concorrência de 20. As palavras-chave podem aparecer em qualquer ordem.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1;key2;key3');
```
- Adicione uma regra CCL com TYPE como SELECT, SCHEMA como test e TABLE como t. Quando a contagem de concorrência de instruções SELECT atingir 10, as instruções serão enfileiradas ou um erro será reportado.
```
CALL dbms_ccl.add_ccl_rule('SELECT', 'test', 't', 10, '');
```
add_ccl_digest_rule: Adiciona uma regra CCL com base em um digest de instrução.
Nota
As seguintes versões de mecanismo de banco de dados oferecem suporte ao procedimento armazenado add_ccl_digest_rule:
- PolarDB for MySQL 8.0.1 com versão de revisão 8.0.1.1.31 ou posterior.
- PolarDB for MySQL 8.0.2 com versão de revisão 8.0.2.2.12 ou posterior.
Sintaxe
```
dbms_ccl.add_ccl_digest_rule('<Schema_name>', '<Query>', <Concurrency_count>);
```
Example
- Adicione uma regra CCL que corresponda à instrução SQL SELECT * FROM t1 para enfileirar solicitações ou reportar um erro quando a contagem de concorrência atingir 10.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1", 10);
```
- Adicione uma regra CCL para o schema test e para instruções SQL que correspondam a SELECT * FROM t1 para enfileirar solicitações ou reportar um erro quando a contagem de concorrência for 10.
```
CALL dbms_ccl.add_ccl_digest_rule("test", "SELECT * FROM t1", 10);
```
- Adicione uma regra CCL que corresponda à instrução SQL SELECT * FROM t1 WHERE col1=1 para enfileirar solicitações ou reportar um erro quando a contagem de concorrência for 10.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1 WHERE col1 = 1", 10);
```
  Nota
  Se uma instrução SQL contiver uma constante, a correspondência ocorrerá mesmo que os valores da constante sejam diferentes. Por exemplo, a regra CCL anterior também corresponde à instrução SQL SELECT * FROM t1 WHERE col1 = 2.
add_ccl_digest_rule_by_hash: Adiciona uma regra CCL com base em um hash de digest pré-calculado.

Nota
O procedimento armazenado add_ccl_digest_rule_by_hash tem suporte apenas se a versão do mecanismo PolarDB for MySQL for 8.0.1 e a versão de revisão for 8.0.1.1.31 ou posterior.
Sintaxe
```
dbms_ccl.add_ccl_digest_rule_by_hash('<Schema_name>', '<Digest>', <Concurrency_count>);
```
Example
- Adicione uma regra CCL para instruções SQL cujo valor DIGEST corresponda a 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a para enfileirar solicitações ou reportar um erro quando a contagem de concorrência for 10.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```
  Neste caso, 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a é o valor DIGEST calculado para SELECT * FROM t1. Use o comando SELECT statement_digest("SELECT * FROM t1") para calcular esse valor ou obtenha-o de outros módulos.
- Adicione uma regra CCL para instruções SQL onde o SCHEMA é test e o valor DIGEST da instrução SQL corresponde a 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a. Quando a contagem de concorrência atingir 10, as solicitações serão enfileiradas ou um erro será retornado.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('test', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```

del_ccl_rule: Exclua uma regra CCL.

Sintaxe

dbms_ccl.del_ccl_rule(<Id>);

Example

Exclua a regra CCL com ID 15.

CALL dbms_ccl.del_ccl_rule(15);

Se a regra a ser excluída não existir, o sistema reportará um aviso. Use o comando SHOW WARNINGS; para visualizar o conteúdo do aviso. Veja um exemplo a seguir:

Exclua a regra CCL com ID 100.

CALL dbms_ccl.del_ccl_rule(100);

A saída retornada é:

Query OK, 0 rows affected, 2 warnings (0.00 sec)

Execute o comando a seguir para visualizar a mensagem de aviso:

SHOW WARNINGS;

A saída retornada é:

+---------+------+----------------------------------------------------+
| Level   | Code | Message                                            |
+---------+------+----------------------------------------------------+
| Warning | 7517 | Concurrency control rule 100 is not found in table |
| Warning | 7517 | Concurrency control rule 100 is not found in cache |
+---------+------+----------------------------------------------------+

Nota

No exemplo anterior, o PolarDB for MySQL versão 8.0 possui um Code de 7517, o PolarDB for MySQL versão 5.7 possui um Code de 3267 e o PolarDB for MySQL versão 5.6 possui um Code de 3045.

show_ccl_rule: Visualize as regras CCL ativadas atualmente na memória.

Sintaxe

dbms_ccl.show_ccl_rule();

Example

CALL dbms_ccl.show_ccl_rule();

A saída retornada é:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITTING | KEYWORDS |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
|   17 | SELECT | test   | t     | Y     | N     |                30 |       0 |       0 |        0 |          |
|   16 | SELECT |        |       | Y     | N     |                20 |       0 |       0 |        0 | key1     |
|   18 | SELECT |        |       | Y     | N     |                10 |       0 |       0 |        0 |          |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+

Nota

A tabela a seguir descreve as colunas MATCHED, RUNNING e WAITTING.

MATCHED: Número total de vezes que a regra correspondeu a uma instrução.
RUNNING: Quantidade de threads em execução sob esta regra no momento.
WAITTING: Quantidade de threads aguardando execução sob esta regra no momento.

Use uma instrução UPDATE para modificar o ID de uma regra, alterando assim sua prioridade.

Sintaxe

UPDATE mysql.concurrency_control SET ID = xx WHERE ID = xx;

Example

Execute o comando a seguir para visualizar as regras CCL ativadas na memória:

CALL dbms_ccl.show_ccl_rule();

A saída retornada é:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITTING | KEYWORDS |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
|   17 | SELECT | test   | t     | Y     | N     |                30 |       0 |       0 |        0 |          |
|   16 | SELECT |        |       | Y     | N     |                20 |       0 |       0 |        0 | key1     |
|   18 | SELECT |        |       | Y     | N     |                10 |       0 |       0 |        0 |          |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+

Execute o comando a seguir para alterar a prioridade da regra CCL com ID 17, mudando seu ID para 20:
```
UPDATE mysql.concurrency_control SET ID = 20 WHERE ID = 17;
```

Execute o comando a seguir para visualizar as regras modificadas:

CALL dbms_ccl.show_ccl_rule();

A saída retornada é:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITTING | KEYWORDS |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
|   16 | SELECT |        |       | Y     | N     |                20 |       0 |       0 |        0 | key1     |
|   18 | SELECT |        |       | Y     | N     |                10 |       0 |       0 |        0 |          |
|   20 | SELECT | test   | t     | Y     | N     |                30 |       0 |       0 |        0 |          |
+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+

flush_ccl_rule: Se você modificar uma regra CCL alterando o conteúdo da tabela concurrency_control, também precisará usar o comando a seguir para que a regra entre em vigor.
Sintaxe
```
dbms_ccl.flush_ccl_rule();
```
Example
Use uma instrução UPDATE para alterar a contagem de concorrência de uma regra.
```
UPDATE mysql.concurrency_control SET CONCURRENCY_COUNT = 15 WHERE Id = 18;
```
A saída retornada é:
```
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```
Execute o comando a seguir para aplicar a alteração:
```
CALL dbms_ccl.flush_ccl_rule();
```
A saída retornada é:
```
Query OK, 0 rows affected (0.00 sec)
```

Testar o recurso

Crie três regras CCL com diferentes dimensões de correspondência:

CALL dbms_ccl.add_ccl_rule('SELECT', 'test', 'sbtest1', 3, '');  // Limit SELECT statements on the test.sbtest1 table to a concurrency of 3.
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 2, 'sbtest2');       // Limit SELECT statements containing the keyword 'sbtest2' to a concurrency of 2.
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 2, '');            // Limit all other SELECT statements to a concurrency of 2.

Use o Sysbench para executar um teste com a seguinte configuração:
- 64 threads
- 4 tabelas
- select.lua

Visualize o status de concorrência em tempo real:

CALL dbms_ccl.show_ccl_rule();

A saída retornada é:

+------+--------+--------+---------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE   | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITTING | KEYWORDS |
+------+--------+--------+---------+-------+-------+-------------------+---------+---------+----------+----------+
|   20 | SELECT | test   | sbtest1 | Y     | N     |                 3 |     389 |       3 |        9 |          |
|   21 | SELECT |        |         | Y     | N     |                 2 |     375 |       2 |       14 | sbtest2  |
|   22 | SELECT |        |         | Y     | N     |                 2 |     519 |       2 |       34 |          |
+------+--------+--------+---------+-------+-------+-------------------+---------+---------+----------+----------+
3 rows in set (0.00 sec)

Verifique a coluna RUNNING. Os valores correspondem aos limites de concorrência especificados, o que indica que as regras estão funcionando corretamente.