One place for hosting & domains

      gérer

      Comment gérer et utiliser les triggers de base de données MySQL sur Ubuntu 18.04


      L’auteur a choisi the Apache Software Foundation pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      Dans MySQL, un trigger (ou déclencheur) est une commande SQL définie par l’utilisateur qui est automatiquement invoquée lors d’une opération INSERT, DELETE ou UPDATE. Le code trigger est associé à une table et est détruit une fois que la table est supprimée. Vous pouvez spécifier une heure de déclenchement de l’action et définir si elle sera activée avant ou après l’événement défini dans la base de données.

      Les triggers ont plusieurs avantages. Par exemple, vous pouvez les utiliser pour générer la valeur d’une colonne dérivée lors d’une instruction INSERT. Un autre cas d’utilisation consiste à faire respecter l’intégrité référentielle par laquelle vous pouvez utiliser un trigger pour sauvegarder un enregistrement dans plusieurs tables apparentées. D’autres avantages incluent la journalisation des actions des utilisateurs dans les tables d’audit ainsi que la copie en direct des données dans différents schémas de base de données à des fins de redondance, pour éviter un point de défaillance.

      Vous pouvez également utiliser des triggers pour maintenir des règles de validation au niveau de la base de données. Cela permet de partager la source de données entre plusieurs applications sans rompre la logique commerciale. Cela réduit considérablement les allers-retours vers le serveur de la base de données, ce qui améliore donc le temps de réponse de vos applications. Comme le serveur de base de données exécute des triggers, ils peuvent profiter de ressources serveur améliorées telles que la RAM et le processeur.

      Dans ce tutoriel, vous allez créer, utiliser et supprimer différents types de triggers dans votre base de données MySQL.

      Conditions préalables

      Avant de commencer, assurez-vous que vous disposez de ce qui suit :

      Étape 1 — Création d’un exemple de base de données

      Dans cette étape, vous allez créer un exemple de base de données client avec plusieurs tables, afin de démontrer le fonctionnement des triggers MySQL.

      Pour en savoir plus sur les requêtes MySQL, consultez notre Introduction aux requêtes dans MySQL.

      Tout d’abord, connectez-vous à votre serveur MySQL en tant que root :

      Entrez votre mot de passe root MySQL lorsqu’il vous est demandé et cliquez sur ENTER pour continuer. Lorsque vous voyez l’invite mysql>, exécutez la commande suivante pour créer une base de données test_db :

      Output

      Query OK, 1 row affected (0.00 sec)

      Ensuite, accédez à test_db avec :

      Output

      Database changed

      Vous commencerez par créer une table de clients customers. Cette table contiendra les enregistrements des clients (customers), y compris les customer_id, customer_name, et level. Il y aura deux niveaux de clients : BASIC et VIP.

      • Create table customers(customer_id BIGINT PRIMARY KEY, customer_name VARCHAR(50), level VARCHAR(50) ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Maintenant, ajoutez quelques enregistrements à la table customers. Pour ce faire, exécutez les commandes suivantes une par une :

      • Insert into customers (customer_id, customer_name, level )values('1','JOHN DOE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('2','MARY ROE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('3','JOHN DOE','VIP');

      Vous verrez la sortie suivante après avoir exécuté chacune des commandes INSERT :

      Output

      Query OK, 1 row affected (0.01 sec)

      Pour vous assurer que les échantillons d’enregistrements ont été insérés avec succès, exécutez la commande SELECT :

      Output

      +-------------+---------------+-------+ | customer_id | customer_name | level | +-------------+---------------+-------+ | 1 | JOHN DOE | BASIC | | 2 | MARY ROE | BASIC | | 3 | JOHN DOE | VIP | +-------------+---------------+-------+ 3 rows in set (0.00 sec)

      Vous allez également créer une autre table pour conserver les informations relatives au compte de clients customers. La table contiendra les champs customer_id et status_notes

      Exécutez la commande suivante :

      • Create table customer_status(customer_id BIGINT PRIMARY KEY, status_notes VARCHAR(50)) ENGINE=INNODB;

      Ensuite, vous allez créer une table de ventes sales. Cette table contiendra les données de vente (sales) relatives aux différents clients via la colonne customer_id :

      • Create table sales(sales_id BIGINT PRIMARY KEY, customer_id BIGINT, sales_amount DOUBLE ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Vous allez ajouter des échantillons de données aux données de vente sales lors des étapes à venir, tout en testant les triggers. Ensuite, créez une table audit_log pour enregistrer les mises à jour apportées à la table des ventes sales lorsque vous implémenterez le trigger AFTER UPDATE à l’étape 5 :

      • Create table audit_log(log_id BIGINT PRIMARY KEY AUTO_INCREMENT, sales_id BIGINT, previous_amount DOUBLE, new_amount DOUBLE, updated_by VARCHAR(50), updated_on DATETIME ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.02 sec)

      Avec la base de données test_db et les quatre tables en place, vous allez maintenant travailler avec les différents triggers MySQL dans votre base de données.

      Étape 2 — Création d’un trigger Before Insert

      Dans cette étape, vous allez examiner la syntaxe d’un trigger MySQL avant d’appliquer cette logique pour créer un trigger BEFORE INSERT qui valide le champ sales_amount lorsque des données sont insérées dans la table sales.

      La syntaxe générale utilisée pour créer un trigger MySQL est illustrée dans l’exemple suivant :

      DELIMITER //
      CREATE TRIGGER [TRIGGER_NAME]
      [TRIGGER TIME] [TRIGGER EVENT]
      ON [TABLE]
      FOR EACH ROW
      [TRIGGER BODY]//
      DELIMITER ;
      

      La structure du trigger comprend :

      DELIMITER // : le délimiteur MySQL par défaut est ; — il est nécessaire de le changer en autre chose afin que MySQL traite les lignes suivantes comme une seule commande jusqu’à ce qu’il atteigne votre délimiteur personnalisé. Dans cet exemple, le délimiteur est changé en // et ensuite le délimiteur ; est redéfini à la fin.

      [TRIGGER_NAME] : Un trigger doit avoir un nom et c’est là que vous incluez la valeur.

      [TRIGGER TIME] : Un trigger peut être invoqué à différents moments. MySQL vous permet de définir si le trigger démarrera avant ou après une opération de base de données.

      [TRIGGER EVENT]: Les triggers ne sont appelés que par les opérations INSERT, UPDATE et DELETE. Vous pouvez utiliser n’importe quelle valeur ici en fonction de ce que vous voulez réaliser.

      [TABLE]: Tout trigger que vous créez sur votre base de données MySQL doit être associé à une table.

      FOR EACH ROW : Cette instruction ordonne à MySQL d’exécuter le code du trigger pour chaque ligne que ce dernier affecte.

      [TRIGGER BODY] : le code qui est exécuté lorsque le trigger est invoqué est appelé_ trigger body​​_​. Ce peut être une seule instruction SQL ou plusieurs commandes. Notez que si vous exécutez plusieurs instructions SQL sur le trigger body, vous devez les inclure dans un bloc BEGIN... END.

      Remarque : Lorsque vous créez le trigger body, vous pouvez utiliser les mots-clés OLD et NEW pour accéder aux valeurs de colonnes anciennes et nouvelles entrées lors d’une opération INSERT, UPDATE et DELETE. Dans un déclencheur DELETE, seul le mot-clé OLD peut être utilisé (que vous utiliserez à l’étape 4).

      Vous allez maintenant créer votre premier trigger BEFORE INSERT. Ce trigger sera associé à la table des ventes sales et il sera invoqué avant l’insertion d’un enregistrement pour valider le sales_amount. La fonction du trigger consiste à vérifier si le sales_amount inséré dans la table des ventes est supérieur à 10000 et à signaler une erreur si cette valeur est évaluée comme vraie (true).

      Assurez-vous que vous êtes connecté au serveur MySQL. Ensuite, entrez les commandes MySQL suivantes une par une :

      • DELIMITER //
      • CREATE TRIGGER validate_sales_amount
      • BEFORE INSERT
      • ON sales
      • FOR EACH ROW
      • IF NEW.sales_amount>10000 THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      • END IF//
      • DELIMITER ;

      Vous utilisez l’instruction IF... THEN... END IF pour évaluer si la quantité fournie lors de l’instruction INSERT est comprise dans votre plage. Le trigger est capable d’extraire la nouvelle valeur sales_amount fournie en utilisant le mot-clé NEW.

      Pour faire apparaître un message d’erreur générique, vous utilisez les lignes suivantes pour informer l’utilisateur de l’erreur :

      SIGNAL SQLSTATE '45000'
      SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      

      Ensuite, insérez un enregistrement avec un sales_amount de 11000 dans la table des ventes pour vérifier si le trigger arrêtera l’opération :

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','11000');

      Output

      ERROR 1644 (45000): Sale has exceeded the allowed amount of 10000.

      Cette erreur montre que le code du trigger fonctionne comme prévu.

      Essayez maintenant un nouvel enregistrement avec une valeur de 7500 pour vérifier si la commande aboutira :

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','7500');

      Comme la valeur est dans la plage recommandée, vous verrez la sortie suivante :

      Output

      Query OK, 1 row affected (0.01 sec)

      Pour confirmer que les données ont été insérées, exécutez la commande suivante :

      La sortie confirme que les données sont dans la table :

      Output

      +----------+-------------+--------------+ | sales_id | customer_id | sales_amount | +----------+-------------+--------------+ | 1 | 1 | 7500 | +----------+-------------+--------------+ 1 row in set (0.00 sec)

      Dans cette étape, vous avez testé des triggers pour valider les données avant leur insertion dans une base de données.

      Ensuite, vous allez travailler avec le trigger AFTER INSERT pour enregistrer les informations connexes dans différentes tables.

      Étape 3 — Création d’un trigger After Insert

      Les triggers AFTER INSERT sont exécutés lorsque les enregistrements sont insérés avec succès dans une table. Cette fonctionnalité peut être utilisée pour exécuter automatiquement d’autres logiques commerciales. Par exemple, dans une application bancaire, un déclencheur AFTER INSERT peut fermer un compte de prêt lorsqu’un client a fini de rembourser le prêt. Le trigger peut surveiller tous les paiements insérés dans une table de transactions et fermer le prêt automatiquement une fois que le solde du prêt est à zéro.

      Dans cette étape, vous travaillerez avec votre table customer_status en utilisant un trigger AFTER INSERT pour entrer des enregistrements de clients apparentés.

      Pour créer le trigger AFTER INSERT, entrez les commandes suivantes :

      • DELIMITER //
      • CREATE TRIGGER customer_status_records
      • AFTER INSERT
      • ON customers
      • FOR EACH ROW
      • Insert into customer_status(customer_id, status_notes) VALUES(NEW.customer_id, 'ACCOUNT OPENED SUCCESSFULLY')//
      • DELIMITER ;

      Output

      Query OK, 0 rows affected (0.00 sec)

      Ici, vous demandez à MySQL d’enregistrer un autre enregistrement dans la table customer_status une fois qu’un nouvel enregistrement client est inséré dans la table de clients customers.

      Maintenant, insérez un nouvel enregistrement dans la table customers pour confirmer que votre code de trigger sera invoqué :

      • Insert into customers (customer_id, customer_name, level )values('4','DAVID DOE','VIP');

      Output

      Query OK, 1 row affected (0.01 sec)

      Comme l’enregistrement a été inséré avec succès, vérifiez qu’un nouvel enregistrement de statut a été inséré dans la table customer_status :

      • Select * from customer_status;

      Output

      +-------------+-----------------------------+ | customer_id | status_notes | +-------------+-----------------------------+ | 4 | ACCOUNT OPENED SUCCESSFULLY | +-------------+-----------------------------+ 1 row in set (0.00 sec)

      La sortie confirme que le trigger a bien été exécuté.

      Le trigger AFTER INSERT est utile pour surveiller le cycle de vie d’un client. Dans un environnement de production, les comptes clients peuvent subir différentes étapes telles que l’ouverture, la suspension et la fermeture du compte.

      Dans les étapes suivantes, vous allez travailler avec des triggers UPDATE.

      Étape 4 — Création d’un trigger Before Update

      Un trigger BEFORE UPDATE est similaire au trigger BEFORE INSERT — la différence est le moment où ils sont invoqués. Vous pouvez utiliser le trigger BEFORE UPDATE pour vérifier une logique commerciale avant de mettre à jour un enregistrement. Pour tester cela, vous utiliserez la table customers dans laquelle vous avez déjà inséré certaines données.

      Vous disposez de deux niveaux pour vos clients dans la base de données. Dans cet exemple, une fois qu’un compte client est mis à jour au niveau VIP, le compte ne peut pas être retrogradé au niveau BASIC. Pour faire appliquer une telle règle, vous allez créer un trigger BEFORE UPDATE qui s’exécutera avant l’instruction UPDATE, comme indiqué ci-dessous. Si un utilisateur de la base de données tente de rétrograder un client du niveau VIP au niveau BASIC, une exception définie par l’utilisateur sera déclenchée.

      Entrez les commandes SQL suivantes une par une pour créer le trigger BEFORE UPDATE :

      • DELIMITER //
      • CREATE TRIGGER validate_customer_level
      • BEFORE UPDATE
      • ON customers
      • FOR EACH ROW
      • IF OLD.level='VIP' THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'A VIP customer can not be downgraded.';
      • END IF //
      • DELIMITER ;

      Vous utilisez le mot-clé OLD pour capturer le niveau fourni par l’utilisateur lors de l’exécution de la commande UPDATE. Encore une fois, vous utilisez l’instruction IF... THEN... END IF pour signaler à l’utilisateur une instruction d’erreur générique.

      Ensuite, exécutez la commande SQL suivante qui tente de rétrograder un compte client associé au customer_id 3 :

      • Update customers set level='BASIC' where customer_id='3';

      Vous verrez la sortie suivante fournissant le SET MESSAGE_TEXT: :

      Output

      ERROR 1644 (45000): A VIP customer can not be downgraded.

      Si vous exécutez la même commande pour un client de niveau BASIC, et que vous essayez de faire passer le compte au niveau VIP, la commande sera exécutée avec succès :

      • Update customers set level='VIP' where customer_id='1';

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Vous avez utilisé le trigger BEFORE UPDATE pour faire appliquer une règle commerciale. Vous allez maintenant utiliser un trigger AFTER UPDATE pour l’enregistrement des audits.

      Étape 5 — Création d’un trigger After Update

      Un trigger AFTER UPDATE est invoqué une fois qu’un enregistrement de base de données est mis à jour avec succès. Ce comportement rend le trigger adapté à l’enregistrement des audits. Dans un environnement multi-utilisateurs, l’administrateur peut vouloir consulter un historique des modifications apportées par les utilisateurs dans une table particulière, à des fins d’audit.

      Vous allez créer un trigger qui enregistre l’activité de mise à jour de la table sales. Notre table audit_log contiendra des informations sur les utilisateurs MySQL qui mettent à jour la table sales, la date de la mise à jour, et les valeurs new et old de sales_amount.

      Pour créer le trigger, exécutez les commandes SQL suivantes :

      • DELIMITER //
      • CREATE TRIGGER log_sales_updates
      • AFTER UPDATE
      • ON sales
      • FOR EACH ROW
      • Insert into audit_log(sales_id, previous_amount, new_amount, updated_by, updated_on) VALUES (NEW.sales_id,OLD.sales_amount, NEW.sales_amount,(SELECT USER()), NOW() )//
      • DELIMITER ;

      Vous insérez un nouvel enregistrement dans la table audit_log. Vous utilisez le mot-clé NEW pour récupérer la valeur du sales_id et du nouveau sales_amount En outre, vous utilisez le mot-clé OLD pour récupérer le sales_amount précédent puisque vous voulez enregistrer les deux montants à des fins d’audit.

      La commande SELECT User() récupère l’utilisateur actuel de l’opération et l’instruction NOW() extrait la valeur de la date et de l’heure actuelle du serveur MySQL

      Maintenant, si un utilisateur essaie de mettre à jour la valeur d’un enregistrement dans la table sales, le trigger log_sales_updates va insérer un nouvel enregistrement dans la table audit_log.

      Créons un nouvel enregistrement de ventes avec un sales_id aléatoire de 5 et essayons de le mettre à jour. En premier lieu, insérez l’enregistrement des ventes avec :

      • Insert into sales(sales_id, customer_id, sales_amount) values('5', '2','8000');

      Output

      Query OK, 1 row affected (0.00 sec)

      Ensuite, mettez à jour l’enregistrement :

      • Update sales set sales_amount='9000' where sales_id='5';

      Vous verrez la sortie suivante :

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Exécutez maintenant la commande suivante pour vérifier si le trigger AFTER UPDATE a pu enregistrer un nouvel enregistrement dans la table audit_log :

      Le trigger a enregistré la mise à jour. Votre sortie indique l’ancien et le nouveau sales_amount enregistrés avec l’utilisateur qui a mis à jour les enregistrements :

      Output

      +--------+----------+-----------------+------------+----------------+---------------------+ | log_id | sales_id | previous_amount | new_amount | updated_by | updated_on | +--------+----------+-----------------+------------+----------------+---------------------+ | 1 | 5 | 8000 | 9000 | root@localhost | 2019-11-07 09:28:36 | +--------+----------+-----------------+------------+----------------+---------------------+ 1 row in set (0.00 sec)

      Vous disposez également de la date et de l’heure auxquelles la mise à jour a été effectuée, ce qui est précieux à des fins d’audit.

      Ensuite, vous utiliserez le trigger DELETE pour faire respecter l’intégrité du référencement au niveau de la base de données.

      Étape 6 — Création d’un trigger Before Delete

      Les triggers BEFORE DELETE sont invoqués avant qu’une instruction DELETE ne s’exécute sur une table.  Ces types de triggers sont généralement utilisés pour faire respecter l’intégrité référentielle dans différentes tables apparentées. Par exemple, chaque enregistrement de la table sales concerne un customer_id de la table customers. Si un utilisateur de la base de données a supprimé un enregistrement de la table customers qui a un enregistrement lié dans la table sales, vous n’auriez aucun moyen de connaître le client associé à cet enregistrement.

      Pour éviter cela, vous pouvez créer un trigger BEFORE DELETE pour faire appliquer votre logique. Exécutez les commandes SQL suivantes une par une :

      • DELIMITER //
      • CREATE TRIGGER validate_related_records
      • BEFORE DELETE
      • ON customers
      • FOR EACH ROW
      • IF OLD.customer_id in (select customer_id from sales) THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'The customer has a related sales record.';
      • END IF//
      • DELIMITER ;

      Maintenant, essayez de supprimer un client qui a un enregistrement de vente connexe :

      • Delete from customers where customer_id='2';

      Vous recevrez alors la sortie suivante :

      Output

      ERROR 1644 (45000): The customer has a related sales record.

      Le trigger BEFORE DELETE peut empêcher la suppression accidentelle d’informations connexes dans une base de données.

      Toutefois, dans certaines situations, vous pouvez vouloir supprimer tous les enregistrements associés à un enregistrement particulier dans les différentes tables connexes. Dans cette situation, vous utiliserez le trigger AFTER DELETE, que vous allez tester à l’étape suivante.

      Étape 7 — Création d’un trigger After Delete

      Les triggers AFTER DELETE sont activés une fois qu’un enregistrement a été supprimé avec succès. Vous pouvez par exemple utiliser un trigger AFTER DELETE dans une situation où le niveau de remise qu’un client particulier reçoit est déterminé par le nombre de ventes effectuées pendant une période définie. Si certains des enregistrements du client sont supprimés de la table sales, le niveau de réduction du client devrait être réduit.

      Une autre utilisation du trigger AFTER DELETE consiste à supprimer des informations connexes d’une autre table une fois qu’un enregistrement de table de base est supprimé.  Par exemple, vous allez définir un trigger qui supprime l’enregistrement du client si les enregistrements de ventes avec le customer_id correspondant sont supprimés de la table sales. Exécutez la commande suivante pour créer votre trigger :

      • DELIMITER //
      • CREATE TRIGGER delete_related_info
      • AFTER DELETE
      • ON sales
      • FOR EACH ROW
      • Delete from customers where customer_id=OLD.customer_id;//
      • DELIMITER ;

      Ensuite, exécutez ce qui suit pour supprimer tous les enregistrements de ventes associés à un customer_id de 2 :

      • Delete from sales where customer_id='2';

      Output

      Query OK, 1 row affected (0.00 sec)

      Vérifiez maintenant s’il existe des enregistrements pour le client dans la table sales :

      • Select * from customers where customer_id='2';

      Vous recevrez une sortie Empty Set puisque l’enregistrement client associé au customer_id de 2 a été supprimé par le trigger :

      Output

      Empty set (0.00 sec)

      Vous avez maintenant utilisé chacune des différentes formes de triggers pour effectuer des fonctions spécifiques. Ensuite, vous allez voir comment vous pouvez supprimer un trigger de la base de données si vous n’en avez plus besoin.

      Étape 8 — Suppression de triggers

      Comme pour tout autre objet de la base de données, vous pouvez supprimer des triggers à l’aide de la commande DROP. Voici la syntaxe de suppression d’un trigger :

      Drop trigger [TRIGGER NAME];
      

      Par exemple, pour supprimer le dernier trigger AFTER DELETE que vous avez créé, exécutez la commande suivante :

      • Drop trigger delete_related_info;

      Output

      Query OK, 0 rows affected (0.00 sec)

      La nécessité de supprimer des triggers se pose lorsque vous voulez en recréer la structure. Dans ce cas, vous pouvez supprimer le trigger et en redéfinir un nouveau avec les différentes commandes de trigger.

      Conclusion

      Dans ce tutoriel, vous avez créé, utilisé et supprimé les différents types de triggers d’une base de données MySQL. À l’aide d’un exemple de base de données relative aux clients, vous avez mis en place des triggers pour différents cas d’utilisation tels que la validation des données, une application de logique d’entreprise, l’enregistrement des audits et la mise en application de l’intégrité référentielle.

      Pour obtenir des informations supplémentaires sur l’utilisation de votre base de données MySQL, consultez ce qui suit :



      Source link

      Comment gérer les sets triés dans Redis


      Introduction

      Redis est un magasin open source de données clé-valeur en mémoire. Dans Redis, les sets triés sont un type de données semblable aux sets, en ce sens qu’ils sont tous deux des groupes de chaînes non répétitifs. La différence est que chaque membre d’un set trié est associé à un score, ce qui permet de les trier du plus petit score au plus grand. Comme pour les sets, chaque membre d’un set trié doit être unique, même si plusieurs membres peuvent partager le même score.

      Ce tutoriel explique comment créer des sets triés, récupérer et supprimer leurs membres, et créer de nouveaux sets triés à partir de ceux qui existent déjà.

      Ce guide est rédigé sous la forme d’une fiche avec des exemples autonomes. Nous vous encourageons à passer directement à la section qui correspond à la tâche que vous essayez d’accomplir.

      Les commandes présentées dans ce guide ont été testées sur un serveur Ubuntu 18.04 exécutant la version 4.0.9 de Redis. Pour mettre en place un environnement similaire, vous pouvez suivre l’étape 1 de notre guide Comment installer et sécuriser Redis sur Ubuntu 18.04. Nous montrerons comment ces commandes se comportent en les exécutant avec redis-cli, l’interface en ligne de commande Redis. Notez que si vous utilisez une autre interface Redis, Redli par exemple, la sortie exacte de certaines commandes peut différer.

      Vous pouvez également provisionner une instance de base de données Redis gérée pour tester ces commandes, mais notez que selon le niveau de contrôle autorisé par votre fournisseur de base de données, certaines commandes de ce guide peuvent ne pas fonctionner comme décrit. Pour provisionner une base de données gérée DigitalOcean, suivez la documentation de notre produit Managed Databases. Ensuite, vous devez soit installer Redli, soit mettre en place un tunnel TLS afin de vous connecter à la base de données gérée via TLS.

      Création de sets triés et ajout de membres

      Pour créer un set trié, utilisez la commande zadd. zadd accepte comme arguments le nom de la clé qui contiendra le set trié, suivi du score du membre que vous ajoutez et de la valeur du membre lui-même. La commande suivante va créer une clé de set trié appelée faveGuitarists avec un membre, "Joe Pass", qui a un score de 1 :

      • zadd faveGuitarists 1 "Joe Pass"

      zadd renverra un entier indiquant combien de membres ont été ajoutés au set trié s’il a été créé avec succès.

      Output

      (integer) 1

      Vous pouvez ajouter plus d’un membre à un set trié avec zadd. Notez que leurs scores n’ont pas besoin d’être séquentiels, il peut y avoir des écarts entre les scores, et plusieurs membres détenus dans un même set trié peuvent partager le même score :

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd peut accepter les options suivantes, que vous devez saisir après le nom de la clé et avant le premier score de membre :

      • NX ou XX : ces options ont des effets opposés, de sorte que vous ne pouvez en inclure qu’une seule dans toute opération zadd :
        • NX : dit à zadd de ne pas mettre à jour les membres existants. Avec cette option, zadd ne fera qu’ajouter de nouveaux éléments.
        • XX : dit à zadd de seulement mettre à jour les éléments existants. Avec cette option, zadd n’ajoutera jamais de nouveaux membres.
      • CH : normalement, zadd ne renvoie que le nombre de nouveaux éléments ajoutés au set trié. Cependant, si cette option est incluse, zadd renvoie le nombre d’éléments modifiés. Cela inclut les membres nouvellement ajoutés et les membres dont les scores ont été modifiés.
      • INCR : avec cette option, la commande incrémente la valeur du score du membre. Si le membre n’existe pas encore, la commande l’ajoutera au set trié avec l’incrément comme score, comme si son score initial était de 0. Avec INCR inclus, zadd retournera le nouveau score du membre si la commande est réussie. Notez que vous ne pouvez inclure qu’une seule paire score/membre à la fois lorsque vous utilisez cette option.

      Au lieu de passer l’option INCR à zadd, vous pouvez utiliser la commande zincrby qui se comporte exactement de la même manière. Au lieu de donner au membre du set trié la valeur indiquée par la valeur du score comme zadd, elle incrémente le score de ce membre de cette valeur. Par exemple, la commande suivante augmente de 5 le score du membre "Stephen Malkmus", qui passe alors de 4 à 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      Comme c’est le cas avec l’option INCR de la commande zadd, si le membre spécifié n’existe pas, zincrby le créera avec la valeur d’incrément comme score.

      La façon la plus simple de récupérer les membres détenus dans un set trié est d’utiliser la commande zrange. Cette commande accepte comme arguments le nom de la clé dont vous voulez récupérer les membres et une série de membres détenus en son sein. La plage est définie par deux nombres qui représentent des indices basés sur zéro, ce qui signifie que 0 représente le premier membre du set trié (ou le membre ayant le score le plus bas), 1 représente le suivant, et ainsi de suite.

      L’exemple suivant renvoie les quatre premiers membres du set trié faveGuitarists créé dans la section précédente :

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Notez que si le set trié que vous passez à zrange comporte deux éléments ou plus qui partagent le même score, il triera ces éléments dans l’ordre lexicographique, ou alphabétique.

      Les indices de départ et d’arrêt peuvent également être des nombres négatifs, avec -1 représentant le dernier membre, -2 l’avant-dernier, etc. :

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange peut accepter l’argument WITHSCORES qui, une fois inclus, rendra également les scores des membres :

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange ne peut renvoyer une série de membres que dans l’ordre numérique croissant. Pour inverser cela et renvoyer une plage par ordre décroissant, vous devez utiliser la commande zrevrange. Considérez cette commande comme une inversion temporaire de l’ordre du set trié donné avant de renvoyer les membres qui se trouvent dans la plage spécifiée. Ainsi, avec zrevrange, 0 représentera le dernier membre détenu dans la clé, 1 représentera l’avant-dernier, et ainsi de suite :

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange peut également accepter l’option WITHSCORES.

      Vous pouvez renvoyer une série de membres en fonction de leurs scores avec la commande zrangebyscore. Dans l’exemple suivant, la commande renverra tout membre détenu dans la clé faveGuitarists avec un score de 2, 3 ou 4 :

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      Dans cet exemple, la fourchette est inclusive, ce qui signifie qu’elle renvoie les membres ayant un score de 2 ou 4. Vous pouvez exclure l’une ou l’autre des extrémités de la plage en la faisant précéder d’une parenthèse ouverte ((). Dans l’exemple suivant, la commande renverra chaque membre dont le score est supérieur ou égal à 2, mais inférieur à 4 :

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Comme pour zrange, zrangebyscore peut accepter l’argument WITHSCORES. La commande accepte également l’option LIMIT, que vous pouvez utiliser pour ne récupérer qu’une sélection d’éléments de la sortie zrangebyscore. Cette option accepte un décalage, qui marque le premier membre de la plage que la commande retournera, et un comptage, qui définit combien de membres la commande retournera au total. Par exemple, la commande suivante examinera les six premiers membres du set trié faveGuitarists mais n’en renverra que trois, à partir du deuxième membre du set, représenté par 1 :

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      La commande zrevrangebyscore renvoie une plage inversée de membres en fonction de leurs scores. La commande suivante renvoie chaque membre du set avec un score compris entre 10 et 6 :

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      Comme pour zrangebyscore, zrevrangebyscore peut accepter à la fois les options WITHSCORES et LIMIT. De plus, vous pouvez exclure l’une ou l’autre extrémité de la plage en la faisant précéder d’une parenthèse ouverte.

      Il peut arriver que tous les membres d’un set trié aient le même score. Dans ce cas, vous pouvez forcer redis à renvoyer une série d’éléments triés lexicographiquement, ou par ordre alphabétique, avec la commande zrangebylex. Pour essayer cette commande, lancez la commande zadd suivante pour créer un set trié où chaque membre a le même score :

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      zrangebylex doit être suivi du nom d’une clé, d’un intervalle de démarrage et d’un intervalle d’arrêt. Les intervalles de démarrage et d’arrêt doivent commencer par une parenthèse ouverte (() ou une accolade ouverte ([), comme ceci :

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Notez que cet exemple n’a renvoyé que quatre des huit membres du set, même si la commande recherchait une plage de a à z. Cela s’explique par le fait que les valeurs Redis sont sensibles à la casse, de sorte que les membres qui commencent par des lettres majuscules ont été exclus de sa sortie. Pour les restituer, vous pouvez procéder comme suit :

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex accepte également les caractères spéciaux -, qui représente l’infini négatif, et +, qui représente l’infini positif. Ainsi, la syntaxe de commande suivante renverra également chaque membre du set trié :

      • zrangebylex SomervilleSquares - +

      Notez que zrangebylex ne peut pas renvoyer les membres d’un set trié dans l’ordre lexicographique inverse (ordre alphabétique croissant). Pour ce faire, utilisez zrevrangebylex :

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Comme cette commande est destinée à l’utilisation avec les sets triés où chaque membre a le même score, zrangebylex n’accepte pas l’option WITHSCORES. Elle accepte toutefois l’option LIMIT.

      Pour savoir combien de membres se trouvent dans un set trié donné (ou, en d’autres termes, pour déterminer sa cardinalité), utilisez la commande zcard. L’exemple suivant montre combien de membres sont détenus dans la clé faveGuitarists de la première section de ce guide :

      Output

      (integer) 9

      zcount peut vous dire combien d’éléments conservés dans un set trié se situent dans une plage de scores. Le premier chiffre qui suit la clé est le début de la plage et le second est la fin de la plage :

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore renvoie le score d’un membre spécifique d’un set trié :

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Si la clé ou le membre spécifié n’existe pas, zscore retournera (nil).

      zrank est semblable à zscore, mais au lieu de renvoyer le score du membre donné, il renvoie son rang. Dans Redis, un rang est un indice basé sur zéro des membres d’un set trié, ordonné par leur score. Par exemple, "Joe Pass" a un score de 1, mais comme c’est le score le plus bas de tous les membres de la clé, il a un rang de 0 :

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Il existe une autre commande Redis appelé zrevrank qui remplit la même fonction que zrank, mais qui inverse les rangs des membres du set. Dans l’exemple suivant, le membre "Joe Pass" a le score le plus bas, et par conséquent le rang inversé le plus élevé :

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      La seule relation entre le score d’un membre et son rang est la position de son score par rapport à ceux des autres membres. S’il y a un écart de score entre deux membres successifs, cela ne se reflétera pas dans leur rang. Notez que si deux membres ont le même score, celui qui vient en premier dans l’ordre alphabétique aura le rang le plus bas.

      Comme zscore, zrank et zrevrank retourneront (nil) si la clé ou le membre n’existe pas.

      zlexcount peut vous dire combien de membres d’un set trié sont contenus dans une plage lexicographique. L’exemple suivant utilise le set trié SomervilleSquares de la section précédente :

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Cette commande suit la même syntaxe que la commande zrangebylex, reportez-vous donc à la section précédente pour savoir comment définir une plage de chaînes.

      Suppression de membres des sets triés

      La commande zrem permet de supprimer un ou plusieurs membres d’un set trié :

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem renverra un nombre entier indiquant combien de membres ont été retirés du set trié :

      Output

      (integer) 2

      Il existe trois commandes Redis qui vous permettent de supprimer les membres d’un set trié en fonction d’une plage. Par exemple, si chaque membre d’un set trié a le même score, vous pouvez supprimer des membres sur la base d’une plage lexicographique avec zremrangebylex. Cette commande utilise la même syntaxe que zrangebylex. L’exemple suivant permet de supprimer tout membre commençant par une majuscule de la clé SomervilleSquares créée dans la section précédente :

      • zremrangebylex SomervilleSquares [A [Z

      La commande zremrangebylex affichera un nombre entier indiquant le nombre de membres qu’elle a retirés :

      Output

      (integer) 3

      Vous pouvez également supprimer des membres sur la base d’une plage de scores avec la commande zremrangebyscore, qui utilise la même syntaxe que la commande zrangebyscore. L’exemple suivant permettra de supprimer tout membre détenu dans faveGuitarists avec un score de 4, 5 ou 6 :

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Vous pouvez retirer des membres d’un set basé sur une plage de rangs avec la commande zremrangebyrank, qui utilise la même syntaxe que zrangebyrank. La commande suivante supprimera les trois membres du set trié ayant les rangs les plus bas, qui sont définis par une série d’indices basés sur zéro :

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Notez que les chiffres transmis à remrangebyrank peuvent également être négatifs, avec -1 représentant le rang le plus élevé, -2 le rang suivant, et ainsi de suite.

      Création de nouveaux sets triés à partir de sets existants

      Redis comprend deux commandes qui vous permettent de comparer les membres de plusieurs sets triés et d’en créer de nouveaux sur la base de ces comparaisons : zinterstore et zunionstore. Pour expérimenter ces commandes, exécutez les commandes zadd suivantes pour créer des exemples de sets triés.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore trouve les membres partagés par deux ou plusieurs sets triés (leur intersection) et produit un nouveau set trié contenant uniquement ces membres. Cette commande doit inclure, dans l’ordre, le nom d’une clé de destination où les membres croisés seront stockés en tant que set trié, le nombre de clés transmises à zinterstore, et les noms des clés que vous voulez analyser :

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore renvoie un nombre entier indiquant le nombre d’éléments stockés dans le set trié de destination. Comme NewKids et Nsync ne partagent qu’un seul membre, "Joey", la commande renverra 1 :

      Output

      (integer) 1

      Sachez que si la clé de destination existe déjà, zinterstore écrasera son contenu.

      zunionstore va créer un nouveau set trié contenant tous les membres des clés qui lui ont été transmises. Cette commande utilise la même syntaxe que zinterstore, et nécessite le nom d’une clé de destination, le nombre de clés transmises à la commande et les noms des clés :

      • zunionstore SuperGroup 2 NewKids Nsync

      Comme zinterstore, zunionstore renvoie un nombre entier indiquant le nombre d’éléments stockés dans la clé de destination. Même si les deux sets triés originaux contenaient chacun cinq membres, puisque les sets triés ne peuvent pas avoir de membres répétés et que chaque clé a un membre nommé "Joey", l’entier résultant sera 9 :

      Output

      (integer) 9

      Comme zinterstore, zunionstore écrasera le contenu de la clé de destination si elle existe déjà.

      Pour vous donner plus de contrôle sur les scores des membres lors de la création de nouveaux sets triés avec zinterstore et zunionstore, ces deux commandes acceptent les options WEIGHTS et AGGREGATE.

      L’option WEIGHTS est suivie d’un chiffre pour chaque set trié inclus dans la commande qui pondère, ou multiplie, les scores de chaque membre. Le premier chiffre après l’option WEIGHTS pondère les scores de la première clé passée à la commande, le deuxième chiffre pondère la deuxième clé, et ainsi de suite.

      L’exemple suivant crée un nouveau set trié contenant les clés croisées des sets triés NewKids et Nsync. Il pondère les scores dans la clé NewKids par un facteur de trois, et pondère ceux dans la clé Nsync par un facteur de sept :

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Si l’option WEIGHTS n’est pas incluse, la pondération est par défaut de 1 pour zinterstore et zunionstore.

      AGGREGATE accepte trois sous-options. La première d’entre elles, SUM, implémente le comportement par défaut de zinterstore et zunionstore en ajoutant les scores des membres correspondants dans les sets combinés.

      Si vous exécutez une opération zinterstore ou zunionstore sur deux sets triés qui partagent un membre, mais que ce membre a un score différent dans chaque set, vous pouvez forcer l’opération à attribuer le plus bas des deux scores dans le nouveau set avec la sous-option MIN.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Comme les deux sets triés n’ont qu’un seul membre correspondant avec le même score (3), cette commande va créer un nouveau set avec un membre qui a le plus bas des deux scores pondérés :

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      De même, AGGREGATE peut forcer zinterstore ou zunionstore à attribuer le score le plus élevé des deux avec l’option MAX :

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      Cette commande crée un nouveau set avec un membre, "Joey", qui a le plus haut des deux scores pondérés :

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Il peut être utile de considérer WEIGHTS comme un moyen de manipuler temporairement les scores des membres avant qu’ils ne soient analysés. De même, il est utile de considérer l’option AGGREGATE comme un moyen de décider comment contrôler les scores des membres avant qu’ils ne soient ajoutés à leurs nouveaux sets.

      Conclusion

      Ce guide détaille un certain nombre de commandes utilisées pour créer et gérer des sets triés dans Redis. S’il y a d’autres commandes, arguments ou procédures connexes que vous aimeriez voir décrits dans ce guide, n’hésitez pas à faire des suggestions dans les commentaires ci-dessous.

      Pour plus d’informations sur les commandes Redis, consultez notre série de tutoriels Comment gérer une base de données Redis.



      Source link