O que é Controle de Concorrência - PolarDB: Central de Documentação do Alibaba Cloud

Pré-requisitos

O cluster PolarDB deve estar em uma das seguintes versões:

PolarDB for MySQL 8.0.
PolarDB for MySQL 5.7 com versão secundária do mecanismo 5.7.1.0.6 ou posterior.

Nota
Se o cluster for PolarDB for MySQL 5.7 com versão secundária do mecanismo 5.7.1.0.27 ou posterior, o CCL será compatível com o Thread Pool.
PolarDB for MySQL 5.6.

Observações

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

Design do recurso

Dimension features

O CCL define cinco recursos de dimensão. As instruções SQL são comparadas às regras de CCL com base nesses recursos:

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

How SQL statements are matched with CCL rules

Se o valor DIGEST em uma regra de CCL estiver vazio, o método de correspondência será o seguinte:
- Quando o valor DIGEST estiver vazio e os valores TYPE, SCHEMA e TABLE não estiverem vazios, a regra entrará em vigor somente se TYPE, SCHEMA e TABLE da instrução SQL corresponderem aos valores respectivos na regra de CCL.
- Caso o valor DIGEST esteja vazio, os valores SCHEMA e TABLE estejam vazios e o valor TYPE não esteja vazio, a regra entrará em vigor apenas se o TYPE da instrução SQL corresponder ao TYPE na regra de CCL.
Nota
Se o valor KEYWORD na regra de CCL não estiver vazio, a palavra-chave também será verificada:
- Para uma única palavra-chave configurada na regra de CCL, a correspondência será bem-sucedida se a instrução SQL contiver essa palavra-chave.
- Ao configurar múltiplas palavras-chave na regra de CCL, a correspondência só terá sucesso se a instrução SQL contiver todas as palavras-chave definidas. A ordem das palavras-chave na instrução SQL não importa.
Quando o valor DIGEST em uma regra de CCL não estiver vazio, a regra entrará em vigor somente se tanto o SCHEMA quanto o valor DIGEST da instrução SQL corresponderem aos valores respectivos na regra de CCL.
Se o valor SCHEMA em uma regra de CCL estiver vazio, a regra entrará em vigor caso o valor DIGEST da instrução SQL corresponda ao valor DIGEST na regra de CCL.

Matching Order for SQL Statements and CCL Rules

Uma única instrução SQL pode corresponder a apenas uma regra de CCL. Se uma instrução corresponder a várias regras, aquela com maior prioridade será utilizada. A prioridade é determinada na seguinte ordem. Caso múltiplas regras tenham a mesma prioridade, a regra com o menor ID será usada.

Correspondência pelo valor DIGEST.
Correspondência por TYPE, SCHEMA e TABLE.
Correspondência apenas por TYPE.

Parâmetros

Modifique os seguintes parâmetros no console PolarDB. Para mais informações, consulte Set cluster and node parameters.

Parâmetro

Descrição

loose_ccl_mode

Comportamento de uma instrução SQL quando o limite de concorrência é excedido. Valores válidos:

WAIT (padrão): A instrução entra na fila e aguarda a conclusão de outras instruções SQL antes de ser executada.
REFUSE: Um erro é reportado.

Nota

Este parâmetro é suportado apenas pelo PolarDB for MySQL 8.0. Nas versões 5.6 e 5.7, as instruções são colocadas diretamente na fila.

loose_ccl_max_waiting_count

Quando o parâmetro loose_ccl_mode está definido como WAIT, este é o número máximo de instruções SQL que podem ser enfileiradas para uma única regra de CCL. Se esse número for excedido, um erro será reportado.

Faixa de valores: 0 a 65536. Valor padrão: 0.

Nota

Este parâmetro é suportado apenas pelo PolarDB for MySQL 5.7 e 8.0.

Tabela de regras de CCL

O PolarDB utiliza uma tabela de sistema chamada concurrency_control para armazenar as regras de CCL. O sistema cria essa tabela automaticamente na inicialização, portanto, não é necessário criá-la manualmente. A instrução CREATE para esta tabela de sistema é a seguinte:

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;

Os parâmetros estão descritos na tabela a seguir:

Parâmetro	Descrição
Id	ID da regra de CCL.
Type	Tipo de 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	Limite de concorrência. Nota Defina `Concurrency_count` como 0 para implementar uma lista de bloqueios de SQL. Isso impede a execução desse tipo de consulta.
Keywords	Palavras-chave. 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	Quando múltiplas palavras-chave são configuradas em Keywords, este parâmetro especifica se elas devem ser correspondidas em ordem. Valores válidos: N (padrão): Quando múltiplas palavras-chave são configuradas em Keywords, elas não precisam ser correspondidas em ordem. Y: Quando múltiplas palavras-chave são configuradas em Keywords, elas devem ser correspondidas em ordem.
Digest	String de hash de 64 bytes gerada a partir de `Digest_text`. Para mais informações, consulte STATEMENT_DIGEST().
Digest_text	Recursos da instrução SQL.
Extra	Outras informações.

Gerenciar regras de CCL

Para ajudar a gerenciar regras de CCL, o PolarDB fornece os seis procedimentos armazenados locais a seguir no DBMS_CCL.

add_ccl_rule: Adiciona uma regra de CCL que corresponde por TYPE, SCHEMA, TABLE e KEYWORD.
Syntax
```
dbms_ccl.add_ccl_rule('<Type>','<Schema_name>','<Table_name>',<Concurrency_count>,'<Keywords>');
```
Example
- Adicione uma regra de CCL para o tipo SELECT. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 10, '');
```
- Adicione uma regra de CCL para instruções SELECT que contenham a palavra-chave key1. Quando a concorrência atingir 20, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1');
```
- Adicione uma regra de CCL para instruções SELECT que contenham as palavras-chave key1, key2 e key3. A ordem das palavras-chave não importa. Quando a concorrência atingir 20, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1;key2;key3');
```
- Adicione uma regra de CCL para instruções SELECT na tabela t no schema test. Quando a concorrência de instruções SELECT atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_rule('SELECT', 'test', 't', 10, '');
```
add_ccl_digest_rule: Adiciona uma regra de CCL que corresponde pelo valor DIGEST.
Nota
O procedimento armazenado add_ccl_digest_rule é suportado apenas nas seguintes versões do mecanismo de banco de dados:
- PolarDB for MySQL 8.0.1 com versão secundária do mecanismo 8.0.1.1.31 ou posterior.
- PolarDB for MySQL 8.0.2 com versão secundária do mecanismo 8.0.2.2.12 ou posterior.
Syntax
```
dbms_ccl.add_ccl_digest_rule('<Schema_name>', '<Query>', <Concurrency_count>);
```
Example
- Adicione uma regra de CCL que corresponda à instrução SQL SELECT * FROM t1. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1", 10);
```
- Adicione uma regra de CCL que corresponda à instrução SQL SELECT * FROM t1 no schema test. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_digest_rule("test", "SELECT * FROM t1", 10);
```
- Adicione uma regra de CCL que corresponda à instrução SQL SELECT * FROM t1 WHERE col1=1. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1 WHERE col1 = 1", 10);
```
  Nota
  Se uma instrução SQL contiver constantes, ela poderá ser correspondida mesmo que os valores das constantes sejam diferentes. Por exemplo, a regra de CCL anterior também corresponde à instrução SQL SELECT * FROM t1 WHERE col1 = 2.
add_ccl_digest_rule_by_hash: Adiciona uma regra de CCL que corresponde pelo valor DIGEST. Este procedimento usa um valor DIGEST pré-calculado em vez de uma instrução SQL.

Nota
O procedimento armazenado add_ccl_digest_rule_by_hash é suportado apenas no PolarDB for MySQL 8.0.1 com versão secundária do mecanismo 8.0.1.1.31 ou posterior.
Syntax
```
dbms_ccl.add_ccl_digest_rule_by_hash('<Schema_name>', '<Digest>', <Concurrency_count>);
```
Example
- Adicione uma regra de CCL que corresponda ao valor DIGEST 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```
  O valor 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a é o valor DIGEST calculado para SELECT * FROM t1. Calcule esse valor executando o comando SELECT statement_digest("SELECT * FROM t1") ou obtenha-o de outros módulos.
- Adicione uma regra de CCL para o schema test que corresponda ao valor DIGEST 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a. Quando a concorrência atingir 10, as instruções subsequentes serão enfileiradas ou retornarão um erro.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('test', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```

del_ccl_rule: Exclui uma regra de CCL.

Syntax

dbms_ccl.del_ccl_rule(<Id>);

Example

Exclua a regra de CCL com ID 15.

CALL dbms_ccl.del_ccl_rule(15);

Se a regra que você deseja excluir não existir, o sistema reportará um aviso. Execute o comando SHOW WARNINGS; para visualizar os detalhes do aviso. Veja um exemplo abaixo:

Exclua a regra de CCL com ID 100.

CALL dbms_ccl.del_ccl_rule(100);

A saída será semelhante a:

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

Execute o seguinte comando para visualizar os detalhes do aviso.

SHOW WARNINGS;

A saída será semelhante a:

+---------+------+----------------------------------------------------+
| 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

Por exemplo, o Code para o PolarDB for MySQL 8.0 é 7517, o Code para o PolarDB for MySQL 5.7 é 3267 e o Code para o PolarDB for MySQL 5.6 é 3045.

show_ccl_rule: Exibe as regras de CCL ativas na memória.

Syntax

dbms_ccl.show_ccl_rule();

Example

CALL dbms_ccl.show_ccl_rule();

A saída será semelhante a:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITING  | 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

Os parâmetros MATCHED, RUNNING e WAITING são descritos da seguinte forma:

MATCHED: Número de vezes que a regra foi correspondida com sucesso.
RUNNING: Número de threads executando simultaneamente sob esta regra.
WAITING: Número de threads aguardando execução sob esta regra.

Utilize a instrução UPDATE para modificar o ID de uma regra de CCL e ajustar sua prioridade.

Syntax

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

Example

Execute o seguinte comando para visualizar as regras de CCL ativas na memória.

CALL dbms_ccl.show_ccl_rule();

A saída será semelhante a:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| 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 seguinte comando para ajustar a prioridade da regra de CCL com ID 17. Isso altera o ID para 20.
```
UPDATE mysql.concurrency_control SET ID = 20 WHERE ID = 17;
```

Execute o seguinte comando para visualizar as regras de CCL ativas atualizadas.

CALL dbms_ccl.show_ccl_rule();

A saída será semelhante a:

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITING  | 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 de CCL alterando a tabela concurrency_control, execute este comando para que a alteração tenha efeito.
Syntax
```
dbms_ccl.flush_ccl_rule();
```
Example
Ajuste a prioridade da regra de destino modificando o ID da regra de CCL em uma instrução UPDATE.
```
UPDATE mysql.concurrency_control SET CONCURRENCY_COUNT = 15 WHERE Id = 18;
```
A saída será semelhante a:
```
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```
Execute o seguinte comando para que a configuração tenha efeito.
```
CALL dbms_ccl.flush_ccl_rule();
```
A saída será semelhante a:
```
Query OK, 0 rows affected (0.00 sec)
```

Testes funcionais

Crie regras de CCL para três dimensões:

CALL dbms_ccl.add_ccl_rule('SELECT', 'test', 'sbtest1', 3, '');  // For SELECT statements on the sbtest1 table in the test database, the concurrency is 3.
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 2, 'sbtest2');       // For SELECT statements that contain the keyword sbtest2, the concurrency is 2.
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 2, '');            // For SELECT statements, the concurrency is 2.

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

Visualize a concorrência das regras:

CALL dbms_ccl.show_ccl_rule();

A saída será semelhante a:

+------+--------+--------+---------+-------+-------+-------------------+---------+---------+----------+----------+
| ID   | TYPE   | SCHEMA | TABLE   | STATE | ORDER | CONCURRENCY_COUNT | MATCHED | RUNNING | WAITING  | 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 à concorrência esperada.