Contrôle de la concurrence - PolarDB - Centre de documentation Alibaba Cloud

Prérequis

Votre cluster PolarDB doit exécuter l'une des versions suivantes :

PolarDB for MySQL 8,0.
PolarDB for MySQL 5.7 avec une version de révision 5.7.1.0.6 ou ultérieure.

Remarque
Si votre cluster exécute PolarDB for MySQL 5.7 avec une version de révision 5.7.1.0.27 ou ultérieure, la fonctionnalité CCL est compatible avec la fonctionnalité thread pool.
PolarDB for MySQL 5,6.

Notes d'utilisation

Modifiez les règles CCL uniquement sur le nœud principal. Les modifications sont automatiquement synchronisées vers tous les autres nœuds.

Fonctionnement

Dimensions de correspondance

Le CCL utilise les cinq dimensions suivantes pour faire correspondre une instruction SQL entrante à une règle :

Dimension

Description

TYPE

Type de l'instruction SQL, par exemple SELECT, UPDATE, INSERT, DELETE ou DDL.

SCHEMA

Nom de la base de données sur laquelle l'instruction SQL s'exécute.

TABLE

Nom de la table ou de la vue sur laquelle l'instruction SQL s'exécute.

KEYWORD

Mot-clé présent dans l'instruction SQL. Vous pouvez spécifier plusieurs mots-clés dans une règle CCL. Séparez-les par un point-virgule (;).

DIGEST

Chaîne de hachage générée à partir de l'instruction SQL. Pour plus d'informations, consultez STATEMENT_DIGEST().

Logique de correspondance

Si la valeur DIGEST n'est pas spécifiée dans une règle CCL :
- Si les valeurs TYPE, SCHEMA et TABLE sont spécifiées, l'instruction SQL doit correspondre aux trois dimensions pour que la règle s'applique.
- Si seule la valeur TYPE est spécifiée, l'instruction SQL doit correspondre à la dimension TYPE pour que la règle s'applique.
Remarque
Si la dimension KEYWORD est également spécifiée, des vérifications supplémentaires sont effectuées :
- Si un seul mot-clé est spécifié, l'instruction SQL doit contenir ce mot-clé pour que la correspondance soit réussie.
- Si plusieurs mots-clés sont spécifiés, l'instruction SQL doit contenir tous les mots-clés indiqués pour que la correspondance soit réussie. L'ordre des mots-clés dans l'instruction SQL n'a pas d'importance.
Si la valeur DIGEST est spécifiée dans une règle CCL, la valeur DIGEST de l'instruction SQL doit correspondre à celle de la règle. Si la valeur SCHEMA est également spécifiée dans la règle, la valeur SCHEMA de l'instruction doit également correspondre.
Si la valeur SCHEMA n'est pas spécifiée dans une règle CCL, l'instruction SQL doit uniquement correspondre à la valeur DIGEST pour que la règle s'applique.

Priorité de correspondance

Une instruction SQL ne peut correspondre qu'à une seule règle CCL. Si une instruction correspond à plusieurs règles, PolarDB applique la règle ayant la priorité la plus élevée. Si plusieurs règles ont la même priorité, PolarDB utilise la règle dont l'ID est le plus petit. La priorité d'une règle est déterminée par ses dimensions de correspondance, selon l'ordre décroissant suivant :

DIGEST
TYPE, SCHEMA et TABLE
TYPE uniquement

Paramètres

Modifiez les paramètres suivants dans la console PolarDB. Pour plus d'informations, consultez la rubrique Configure cluster and node parameters.

Paramètre

Description

loose_ccl_mode

Action à entreprendre lorsque la limite de concurrence est dépassée. Valeurs possibles :

WAIT (par défaut) : l'instruction SQL est placée dans une file d'attente et attend la fin des autres instructions.
REFUSE : une erreur est renvoyée.

Remarque

Ce paramètre est pris en charge uniquement pour PolarDB for MySQL 8.0. Pour les versions 5.6 et 5.7, le système met automatiquement les instructions en file d'attente.

loose_ccl_max_waiting_count

Lorsque loose_ccl_mode est défini sur WAIT, ce paramètre spécifie le nombre maximal d'instructions SQL mises en file d'attente pour une seule règle CCL. Le système renvoie une erreur si cette limite est dépassée.

Valeurs possibles : 0 à 65536. Valeur par défaut : 0.

Remarque

Ce paramètre est pris en charge uniquement pour PolarDB for MySQL 5,7 et 8,0.

Table des règles CCL

PolarDB stocke les règles CCL dans la table système concurrency_control. Le système crée automatiquement cette table au démarrage ; vous n'avez pas besoin de la créer manuellement. L'instruction CREATE TABLE suivante illustre la structure de la table :

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;

Le tableau suivant décrit les paramètres de la table concurrency_control.

Paramètre	Description
Id	ID de la règle CCL.
Type	Type de l'instruction SQL, par exemple SELECT, UPDATE, INSERT, DELETE ou DDL.
Schema_name	Nom de la base de données.
Table_name	Nom de la table dans la base de données.
Concurrency_count	Nombre maximal d'instructions simultanées autorisées par la règle. Remarque Vous pouvez définir la valeur `Concurrency_count` sur 0 pour mettre en œuvre une liste noire SQL, qui bloque l'exécution des requêtes correspondantes.
Keywords	Mot-clé ou mots-clés à faire correspondre. Séparez plusieurs mots-clés par un point-virgule (;).
State	Indique si la règle est activée. Valeurs possibles : Y (par défaut) : la règle est activée. N : la règle est désactivée.
Ordered	Si plusieurs mots-clés sont spécifiés dans le champ Keywords, ce paramètre indique si les mots-clés doivent être mis en correspondance dans l'ordre spécifié. Valeurs possibles : N (par défaut) : les mots-clés du champ Keywords n'ont pas besoin d'être mis en correspondance dans l'ordre. Y : les mots-clés du champ Keywords doivent être mis en correspondance dans l'ordre.
Digest	Chaîne de hachage de 64 octets générée à partir de `Digest_text`. Pour plus d'informations, consultez STATEMENT_DIGEST().
Digest_text	Résumé normalisé de l'instruction SQL.
Extra	Informations supplémentaires.

Gestion des règles CCL

PolarDB fournit les six procédures stockées suivantes dans le package DBMS_CCL pour gérer les règles CCL :

add_ccl_rule : ajoute une règle CCL basée sur TYPE, SCHEMA, TABLE et KEYWORD.
Syntaxe
```
dbms_ccl.add_ccl_rule('<Type>','<Schema_name>','<Table_name>',<Concurrency_count>,'<Keywords>');
```
Example
- Ajoutez une règle CCL pour les instructions SELECT avec un niveau de concurrence de 10. Lorsque cette limite est atteinte, le système met en file d'attente ou refuse les instructions suivantes.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 10, '');
```
- Ajoutez une règle CCL pour les instructions SELECT contenant le mot-clé key1, avec un niveau de concurrence de 20.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1');
```
- Ajoutez une règle CCL pour les instructions SELECT contenant les mots-clés key1, key2 et key3, avec un niveau de concurrence de 20. Les mots-clés peuvent apparaître dans n'importe quel ordre.
```
CALL dbms_ccl.add_ccl_rule('SELECT', '', '', 20, 'key1;key2;key3');
```
- Ajoutez une règle CCL avec TYPE défini sur SELECT, SCHEMA sur test et TABLE sur t. Lorsque le niveau de concurrence des instructions SELECT atteint 10, les instructions sont mises en file d'attente ou une erreur est signalée.
```
CALL dbms_ccl.add_ccl_rule('SELECT', 'test', 't', 10, '');
```
add_ccl_digest_rule : ajoute une règle CCL basée sur un résumé d'instruction.
Remarque
Les versions de moteur de base de données suivantes prennent en charge la procédure stockée add_ccl_digest_rule :
- PolarDB for MySQL 8.0.1 avec une version de révision 8.0.1.1.31 ou ultérieure.
- PolarDB for MySQL 8.0.2 avec une version de révision 8.0.2.2.12 ou ultérieure.
Syntaxe
```
dbms_ccl.add_ccl_digest_rule('<Schema_name>', '<Query>', <Concurrency_count>);
```
Example
- Ajoutez une règle CCL qui correspond à l'instruction SQL SELECT * FROM t1 pour mettre en file d'attente les requêtes ou signaler une erreur lorsque le niveau de concurrence atteint 10.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1", 10);
```
- Ajoutez une règle CCL pour le schéma test et pour les instructions SQL correspondant à SELECT * FROM t1 afin de mettre en file d'attente les requêtes ou de signaler une erreur lorsque le niveau de concurrence est de 10.
```
CALL dbms_ccl.add_ccl_digest_rule("test", "SELECT * FROM t1", 10);
```
- Ajoutez une règle CCL qui correspond à l'instruction SQL SELECT * FROM t1 WHERE col1=1 pour mettre en file d'attente les requêtes ou signaler une erreur lorsque le niveau de concurrence est de 10.
```
CALL dbms_ccl.add_ccl_digest_rule("", "SELECT * FROM t1 WHERE col1 = 1", 10);
```
  Remarque
  Si une instruction SQL contient une constante, une correspondance est établie même si les valeurs constantes sont différentes. Par exemple, la règle CCL précédente correspond également à l'instruction SQL SELECT * FROM t1 WHERE col1 = 2.
add_ccl_digest_rule_by_hash : ajoute une règle CCL basée sur un hachage de résumé précalculé.

Remarque
La procédure stockée add_ccl_digest_rule_by_hash est prise en charge uniquement si la version du moteur PolarDB for MySQL est 8.0.1 et la version de révision est 8.0.1.1.31 ou ultérieure.
Syntaxe
```
dbms_ccl.add_ccl_digest_rule_by_hash('<Schema_name>', '<Digest>', <Concurrency_count>);
```
Example
- Ajoutez une règle CCL pour les instructions SQL dont la valeur DIGEST correspond à 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a afin de mettre en file d'attente les requêtes ou de signaler une erreur lorsque le niveau de concurrence est de 10.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```
  Dans ce cas, 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a est la valeur DIGEST calculée pour SELECT * FROM t1. Vous pouvez utiliser la commande SELECT statement_digest("SELECT * FROM t1") pour calculer cette valeur ou l'obtenir à partir d'autres modules.
- Ajoutez une règle CCL pour les instructions SQL où le SCHEMA est test et la valeur DIGEST de l'instruction SQL correspond à 533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a. Lorsque le niveau de concurrence atteint 10, les requêtes sont mises en file d'attente ou une erreur est renvoyée.
```
CALL dbms_ccl.add_ccl_digest_rule_by_hash('test', '533c0a9cf0cf92d2c26e7fe8821735eb4a72c409aaca24f9f281d137427bfa9a', 10);
```
del_ccl_rule : supprime une règle CCL.
Syntaxe
```
dbms_ccl.del_ccl_rule(<Id>);
```
Example
Supprimez la règle CCL dont l'ID est 15.
```
CALL dbms_ccl.del_ccl_rule(15);
```
Si la règle à supprimer n'existe pas, le système signale un avertissement. Utilisez la commande SHOW WARNINGS; pour afficher le contenu de l'avertissement. Voici un exemple :
1. Supprimez la règle CCL dont l'ID est 100.
```
CALL dbms_ccl.del_ccl_rule(100);
```
  La sortie suivante est renvoyée :
```
Query OK, 0 rows affected, 2 warnings (0.00 sec)
```
2. Exécutez la commande suivante pour afficher le message d'avertissement :
```
SHOW WARNINGS;
```
  La sortie suivante est renvoyée :
```
+---------+------+----------------------------------------------------+
| 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 |
+---------+------+----------------------------------------------------+
```
Remarque
Dans l'exemple précédent, la version PolarDB for MySQL 8,0 affiche un Code de 7517, la version PolarDB for MySQL 5.7 affiche un Code de 3267, et la version PolarDB for MySQL 5.6 affiche un Code de 3045.

show_ccl_rule : affiche les règles CCL activées actuellement en mémoire.

Syntaxe

dbms_ccl.show_ccl_rule();

Example

CALL dbms_ccl.show_ccl_rule();

La sortie suivante est renvoyée :

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

Remarque

Le tableau suivant décrit les colonnes MATCHED, RUNNING et WAITTING.

MATCHED : nombre total de fois où la règle a correspondu à une instruction.
RUNNING : nombre de threads actuellement en cours d'exécution sous cette règle.
WAITTING : nombre de threads actuellement en attente d'exécution sous cette règle.

Utilisez une instruction UPDATE pour modifier l'ID d'une règle, ce qui change sa priorité.

Syntaxe

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

Example

Exécutez la commande suivante pour afficher les règles CCL activées en mémoire :

CALL dbms_ccl.show_ccl_rule();

La sortie suivante est renvoyée :

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

Exécutez la commande suivante pour modifier la priorité de la règle CCL dont l'ID est 17 en changeant son ID en 20 :
```
UPDATE mysql.concurrency_control SET ID = 20 WHERE ID = 17;
```

Exécutez la commande suivante pour afficher les règles modifiées :

CALL dbms_ccl.show_ccl_rule();

La sortie suivante est renvoyée :

+------+--------+--------+-------+-------+-------+-------------------+---------+---------+----------+----------+
| 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 : si vous modifiez une règle CCL en modifiant le contenu de la table concurrency_control, vous devez également utiliser la commande suivante pour appliquer la règle.
Syntaxe
```
dbms_ccl.flush_ccl_rule();
```
Example
Utilisez une instruction UPDATE pour modifier le niveau de concurrence d'une règle.
```
UPDATE mysql.concurrency_control SET CONCURRENCY_COUNT = 15 WHERE Id = 18;
```
La sortie suivante est renvoyée :
```
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```
Exécutez la commande suivante pour appliquer la modification :
```
CALL dbms_ccl.flush_ccl_rule();
```
La sortie suivante est renvoyée :
```
Query OK, 0 rows affected (0.00 sec)
```

Test de la fonctionnalité

Créez trois règles CCL avec différentes dimensions de correspondance :

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.

Utilisez Sysbench pour exécuter un test avec la configuration suivante :
- 64 threads
- 4 tables
- select.lua

Consultez l'état de la concurrence en temps réel :

CALL dbms_ccl.show_ccl_rule();

La sortie suivante est renvoyée :

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

Vérifiez la colonne RUNNING. Les valeurs correspondent aux limites de concurrence spécifiées, ce qui indique que les règles fonctionnent correctement.