CV
Langages
- C
- PHP
- Java
- Perl
- Ruby
- Javascript
- Flex 3
- Python
- GO
- C#
- TCL
- Bash
Liens
Articles
Contact

Notes sur MySql

LEFT JOIN et RIGHT JOIN
UNION
Les procédures stockées
- Gestion des erreurs
- Test unitaires
Trucs et astuces
- Extraction de données via la ligne de commande
- Insertion conditionnelle

Dans cet article, nous utiliserons les bases de test définies ci-dessous.

Première base de test

SET foreign_key_checks = 0;
DROP TABLE IF EXISTS citoyen;
DROP TABLE IF EXISTS activite;
DROP TABLE IF EXISTS voiture;
SET foreign_key_checks = 1;
 
CREATE TABLE activite
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    PRIMARY KEY(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO activite SET name='comptable'; SELECT LAST_INSERT_ID() INTO @comptable;
INSERT INTO activite SET name='patissier'; SELECT LAST_INSERT_ID() INTO @patissier;
INSERT INTO activite SET name='peintre';   SELECT LAST_INSERT_ID() INTO @peintre;
INSERT INTO activite SET name='jardinier'; SELECT LAST_INSERT_ID() INTO @jardinier;
INSERT INTO activite SET name='plombier';  SELECT LAST_INSERT_ID() INTO @plombier;
INSERT INTO activite SET name='vitrier';   SELECT LAST_INSERT_ID() INTO @vitrier;
INSERT INTO activite SET name='policier';  SELECT LAST_INSERT_ID() INTO @policier;
INSERT INTO activite SET name='juge';      SELECT LAST_INSERT_ID() INTO @juge;
INSERT INTO activite SET name='sabotier';  SELECT LAST_INSERT_ID() INTO @sabotier;
 
CREATE TABLE voiture
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    PRIMARY KEY(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO voiture SET name='Renault'; SELECT LAST_INSERT_ID() INTO @Renault;
INSERT INTO voiture SET name='Peugeot'; SELECT LAST_INSERT_ID() INTO @Peugeot;
INSERT INTO voiture SET name='BMW';     SELECT LAST_INSERT_ID() INTO @BMW;
INSERT INTO voiture SET name='Toyota';  SELECT LAST_INSERT_ID() INTO @Toyota;
INSERT INTO voiture SET name='Porshe';  SELECT LAST_INSERT_ID() INTO @Porshe;
 
CREATE TABLE citoyen
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    fk_activite INT,
    fk_voiture INT,
    PRIMARY KEY(id),
    FOREIGN KEY (fk_activite) REFERENCES activite(id),
    FOREIGN KEY (fk_voiture) REFERENCES voiture(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO citoyen SET name='Paul',      fk_activite=@comptable,  fk_voiture=@Renault;
INSERT INTO citoyen SET name='Denis',     fk_activite=@comptable,  fk_voiture=@Renault;
INSERT INTO citoyen SET name='Vincent',   fk_activite=@patissier,  fk_voiture=@Peugeot;
INSERT INTO citoyen SET name='Eric',      fk_activite=@peintre,    fk_voiture=@Peugeot;  
INSERT INTO citoyen SET name='Laurent',   fk_activite=@peintre;  
INSERT INTO citoyen SET name='Nicolas',   fk_activite=@jardinier;
INSERT INTO citoyen SET name='Valerie',   fk_activite=@plombier,   fk_voiture=@Toyota; 
INSERT INTO citoyen SET name='Kathy',     fk_activite=@vitrier,    fk_voiture=@Toyota;  
INSERT INTO citoyen SET name='Stephanie';                        
INSERT INTO citoyen SET name='Jean',                               fk_voiture=@BMW;

LEFT JOIN

Sélectionne les éléments de la table de gauche avec éventuellement pour chaque élément (de la table de gauche), les éléments correspondants de la table de droite, s'il y a correspondance. Nous désignerons la table de gauche par l'appellation "table de référence". Tous les enregistrements de la table de référence seront présents au moins une fois dans la sélection.


    SELECT      ...
    FROM        table_de_référence
    LEFT JOIN   autre_table ON ...

La table de référence ("A") est représentée avec la couleur rouge pâle.
@T: Un enregistrement de la table "T".
+@T: Un enregistrement de la table "T" est présent au moins une fois.
*@T: Un enregistrement de la table "T" est présent zéro ou plusieurs fois.

Exemple: On sélectionne tous les citoyens, avec leurs activités correspondantes.

Exemple: On sélectionne toutes les activités, avec les citoyens qui les assurent.

RIGHT JOIN

Sélectionne tous les éléments de la table de droite avec éventuellement pour chaque élément (de la table de droite), les éléments correspondants de la table de gauche, s'il y a correspondance Nous désignerons la table de droite par l'appellation "table de référence". Tous les enregistrements de la table de référence seront présents au moins une fois dans la sélection.


    SELECT      ...
    FROM        autre_table
    RIGHT JOIN  table_de_référence ON ...

La table de référence ("B") est représentée avec la couleur rouge pâle.
@T: Un enregistrement de la table "T".
+@T: Un enregistrement de la table "T" est présent au moins une fois.
*@T: Un enregistrement de la table "T" est présent zéro ou plusieurs fois.

Exemple: On sélectionne tous les citoyens, avec leurs activités correspondantes.

Exemple: On sélectionne toutes les activités, avec les citoyens qui les assurent.

Composition d'un LEFT JOIN et d'un RIGHT JOIN

On suppose que l'on a une base composée de trois tables "A", "B" et "C".

"A" est liée à "B".
"A" est liée à "C".


    SELECT      ...
    FROM        A
    LEFT JOIN   B ON A... = B...
    RIGHT JOIN  C ON A... = C...

La table de référence ("A") est représentée avec la couleur rouge pâle.
@T: Un enregistrement de la table "T".
+@T: Un enregistrement de la table "T" est présent au moins une fois.
*@T: Un enregistrement de la table "T" est présent zéro ou plusieurs fois.

On commence par exécuter la première jointure, dans l'ordre d'écriture des jointures. C'est la jointure de type "LEFT JOIN". On obtient une sélection intermédiaire.

Puis on exécute la seconde jointure (le RIGHT JOIN, en l'occurrence). On obtient la sélection finale.

Tous les enregistrements de la dernière table de référence (la table "C", en l'occurrence) seront présents au moins une fois dans la sélection.

Exemple:


    SELECT      citoyen.name as 'citoyen', voiture.name as 'voiture', activite.name as 'activite'
    FROM        citoyen
    LEFT JOIN   activite ON citoyen.fk_activite = activite.id
    RIGHT JOIN  voiture  ON citoyen.fk_voiture  = voiture.id;

On commence par effectuer le "LEFT JOIN". La table de référence est "citoyen". Cette jointure intermédiaire est :


    SELECT      citoyen.name as 'citoyen', activite.name as 'activite'
    FROM        citoyen
    LEFT JOIN   activite ON citoyen.fk_activite = activite.id;

Résultat:

Puis, on effectue le "RIGHT JOIN" entre le résultat de la jointure intermédiaire et la table "voiture". La table de référence est la table "voiture".

Résultat:

Utilisation d'un "LEFT JOIN" pour sélectionner tous les enregistrements d'une table qui n'ont pas de correspondance dans une autre table.

On sélectionne tous les enregistrements de la "table de référence" qui n'ont pas de correspondance dans une autre table.


    SELECT      ...
    FROM        table_de_reference
    LEFT JOIN   autre_table ON table_de_reference.key = autre_table.key
    WHERE       autre_table.key IS NULL

Exemple: On sélectionne tous les citoyens qui n'ont pas d'activité.

Et pour information, on affiche les voitures des citoyens qui n'ont pas d'activité.

Et pour information, on sélectionne les citoyens qui n'ont ni activité ni voiture.

Utilisation d'un "RIGHT JOIN" pour sélectionner tous les enregistrements d'une table qui n'ont pas de correspondance dans une autre table.

On sélectionne tous les enregistrements de la table de référence qui n'ont pas de correspondance dans une autre table.


    SELECT      ...
    FROM        autre_table
    RIGHT JOIN  table_de_reference ON table_de_reference.key = autre_table.key
    WHERE       autre_table.key IS NULL

UNION

Introduction

Dans cet article, nous utiliserons les bases de test définies ci-dessous.

Première base de test

SET foreign_key_checks = 0;
DROP TABLE IF EXISTS citoyen;
DROP TABLE IF EXISTS activite;
DROP TABLE IF EXISTS voiture;
SET foreign_key_checks = 1;
 
CREATE TABLE activite
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    PRIMARY KEY(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO activite SET name='comptable'; SELECT LAST_INSERT_ID() INTO @comptable;
INSERT INTO activite SET name='patissier'; SELECT LAST_INSERT_ID() INTO @patissier;
INSERT INTO activite SET name='peintre';   SELECT LAST_INSERT_ID() INTO @peintre;
INSERT INTO activite SET name='jardinier'; SELECT LAST_INSERT_ID() INTO @jardinier;
INSERT INTO activite SET name='plombier';  SELECT LAST_INSERT_ID() INTO @plombier;
INSERT INTO activite SET name='vitrier';   SELECT LAST_INSERT_ID() INTO @vitrier;
INSERT INTO activite SET name='policier';  SELECT LAST_INSERT_ID() INTO @policier;
INSERT INTO activite SET name='juge';      SELECT LAST_INSERT_ID() INTO @juge;
INSERT INTO activite SET name='sabotier';  SELECT LAST_INSERT_ID() INTO @sabotier;
 
CREATE TABLE voiture
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    PRIMARY KEY(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO voiture SET name='Renault'; SELECT LAST_INSERT_ID() INTO @Renault;
INSERT INTO voiture SET name='Peugeot'; SELECT LAST_INSERT_ID() INTO @Peugeot;
INSERT INTO voiture SET name='BMW';     SELECT LAST_INSERT_ID() INTO @BMW;
INSERT INTO voiture SET name='Toyota';  SELECT LAST_INSERT_ID() INTO @Toyota;
INSERT INTO voiture SET name='Porshe';  SELECT LAST_INSERT_ID() INTO @Porshe;
 
CREATE TABLE citoyen
(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    fk_activite INT,
    fk_voiture INT,
    PRIMARY KEY(id),
    FOREIGN KEY (fk_activite) REFERENCES activite(id),
    FOREIGN KEY (fk_voiture) REFERENCES voiture(id),
    CONSTRAINT uc_name UNIQUE (name)
)
ENGINE=INNODB;
 
INSERT INTO citoyen SET name='Paul',      fk_activite=@comptable,  fk_voiture=@Renault;
INSERT INTO citoyen SET name='Denis',     fk_activite=@comptable,  fk_voiture=@Renault;
INSERT INTO citoyen SET name='Vincent',   fk_activite=@patissier,  fk_voiture=@Peugeot;
INSERT INTO citoyen SET name='Eric',      fk_activite=@peintre,    fk_voiture=@Peugeot;  
INSERT INTO citoyen SET name='Laurent',   fk_activite=@peintre;  
INSERT INTO citoyen SET name='Nicolas',   fk_activite=@jardinier;
INSERT INTO citoyen SET name='Valerie',   fk_activite=@plombier,   fk_voiture=@Toyota; 
INSERT INTO citoyen SET name='Kathy',     fk_activite=@vitrier,    fk_voiture=@Toyota;  
INSERT INTO citoyen SET name='Stephanie';                        
INSERT INTO citoyen SET name='Jean',                               fk_voiture=@BMW;

Description générale

Par défaut, toutes les valeurs agrégées sont distinctes.

Dans de nombreux cas d'utilisation il faut utiliser des parenthèses!.

Exemple:

Utilisation avec des jointures de types LEFT JOIN et RIGHT JOIN.

Exemple: Sélectionner tous les citoyens sans activité et toutes les activités qui ne sont assurées par aucun citoyen.

Les procédures stockées

Gestion des erreurs

La discrimination, au niveau du code, entre les différentes erreurs susceptibles de se produire n’est pas toujours évidente. Il faut analyser des codes d’erreurs propres au SGBD...

Il peut être intéressant d’intégrer aux procédures stockées la « mécanique » permettant de discriminer certaines erreurs « particulièrement importantes », afin de faciliter le traitement ultérieur de ces erreurs (dans le code).

L’exemple qui suit illustre la technique utiliser.

La procédure stockée ci-dessous permet de mettre à jour une table qui contient des compagnies. Plusieurs erreurs peuvent de produire:

Le code du pays spécifié n'existe pas. Plus généralement : une clé de jointure n'est pas définie.
La nouvelle adresse email spécifiée est déjà utilisée par une autre compagnie. Plus généralement : une contrainte d'unicité n'est pas respectée.
La mise à jour doit modifier un enregistrement. Ce n'est pas le cas.
Une autre erreur.

/****************************************************************************************

Conventions :

Si error=NULL
  Il n'y a pas d'erreur.

Si error="DUP(...)"
  Des contraintes d'unicité ne sont pas respectées.
  Exemples:
    error="DUP(a)": "a" est un index unique. La valeur indiquée est déjà présente dans la base.
    error="DUP(a b)": même raisonnement, mais avec deux indexes uniques.

Si error="DFK(...)"
  Des contraintes de jointure ne sont pas respectées.
  Exemples:
    error="DFK(a)": "a" est une clé de jointure vers une table "T". La valeur indiquée ne représente aucun enregistrement dans la table "T".
    error="DFK(a b)": même raisonnement, mais avec deux jointures.

Si error="NOCHANGE"
   Une requête aurait dû entrainer une modification de la base.
   Ce n’est pas le cas.

Si error="ERROR"
   Une erreur imprévue est survenue.

****************************************************************************************/

# Modifie une compagnie.
# Les arguments dont les valeurs transmisent à la procédure valent NULL ne seront pas modifiés.
# Error: NOCHANGE, DFK(country), DUP(email) ou ERROR.

DELIMITER //
CREATE PROCEDURE updateCompany(IN id INT UNSIGNED,
                               IN address VARCHAR(255),
                               IN zip MEDIUMINT UNSIGNED,
                               IN city VARCHAR(255),
                               IN phone VARCHAR(255),
                               IN www VARCHAR(255),
                               IN email VARCHAR(255),
                               IN country_id INT UNSIGNED,
                               OUT error VARCHAR(255))
updateCompany_label:BEGIN

    DECLARE icount INT;
    DECLARE vvcount INT;

    # Détection de toutes les erreurs.
    DECLARE EXIT HANDLER FOR SQLEXCEPTION
    BEGIN
        SELECT 'ERROR' INTO error;
    END;
    
    # Détection des clés dupliquées (Duplicate entry).
    DECLARE EXIT HANDLER FOR SQLSTATE '23000'
    BEGIN
        SELECT 'DUP(email)' INTO error;
    END;

    # Détection des clés de jointures qui n'existent pas.
    DECLARE EXIT HANDLER FOR 1452
    BEGIN   
        SELECT "DFK(country)" INTO error;     
    END;

    UPDATE `companies`
    SET    `companies`.`address`         = COALESCE(address,    `companies`.`address`),
           `companies`.`zip`             = COALESCE(zip,        `companies`.`zip`),
           `companies`.`city`            = COALESCE(city,       `companies`.`city`),
           `companies`.`phone`           = COALESCE(phone,      `companies`.`phone`),
           `companies`.`www`             = COALESCE(www,        `companies`.`www`),
           `companies`.`email`           = COALESCE(email,      `companies`.`email`),
           `companies`.`fk_contries_id`  = COALESCE(country_id, `companies`.`fk_contries_id`)
    WHERE  `companies`.`id` = id;
    
    SELECT ROW_COUNT() INTO icount;
    IF icount = 0 THEN
        BEGIN
            # See http://dev.mysql.com/doc/refman/5.0/en/information-functions.html
            # Cette fonction retourne le nombre d’enregistrements modifiés.
            # Il se peut que l’enregistrement à modifier existe, mais que la modification n’ait aucun effet
            # (modification avec les mêmes valeurs).
            SELECT COUNT(`companies`.`id`)
            FROM   `companies`
            WHERE  `companies`.`id` = id
            INTO   vvcount;
        
            IF vvcount = 0 THEN
                BEGIN
                    SELECT 'NOCHANGE' INTO error;
                    LEAVE updateCompany_label;
                END;
            END IF;
        END;
    END IF;
    
    SELECT NULL INTO error;
END //

L’exemple ci-dessous est plus complet.

Il illustre l’utilisation des transactions.
Il illustre une technique pour définir une liste de tags dans des messages d’erreur.

# Cette procédure stockée ajoute un utilisateur.
# "id" contiendra la valeur de la clé primaire associée au nouvel enregistrement.
# Erreur: ERROR, DUP(email | login | company), DFK(company | type | country).

DELIMITER //
CREATE PROCEDURE createUser(IN login VARCHAR(255), 
                            IN password VARCHAR(255), 
                            IN first_name VARCHAR(255), 
                            IN last_name VARCHAR(255), 
                            IN email VARCHAR(255), 
                            IN type_id VARCHAR(255), 
                            IN birth_date DATETIME,
                            IN address VARCHAR(255), 
                            IN zip MEDIUMINT UNSIGNED,
                            IN city VARCHAR(255),
                            IN phone VARCHAR(255),
                            IN www VARCHAR(255),
                            IN photo VARCHAR(255),
                            IN country_id INT UNSIGNED,
                            IN company_id INT UNSIGNED,
                            OUT id INT UNSIGNED,
                            OUT error VARCHAR(255))
createUser_label:BEGIN

    DECLARE list VARCHAR(255);
    DECLARE vcount INT;

    # Détection de toutes les erreurs.
    DECLARE EXIT HANDLER FOR SQLEXCEPTION
    BEGIN
        ROLLBACK;
        SELECT 'ERROR' INTO error;
        SELECT NULL INTO id;
    END;

    # Détection des clés dupliquées (Duplicate entry).
    DECLARE EXIT HANDLER FOR 1062
    BEGIN
        ROLLBACK;

        SET list = '';
        
        SELECT COUNT(`users`.`id`) FROM `users` WHERE `users`.`email` = email INTO vcount;
        IF vcount > 0 THEN SELECT 'email ' INTO list; END IF;
        
        SELECT COUNT(`users`.`id`) FROM `users` WHERE `users`.`login` = login INTO vcount;
        IF vcount > 0 THEN SELECT CONCAT(list, 'login ') INTO list; END IF;

        IF company_id IS NOT NULL THEN
            BEGIN
                SELECT COUNT(`users`.`id`) FROM `users` WHERE `users`.`fk_companies_id` = company_id INTO vcount;
                IF vcount > 0 THEN SELECT CONCAT(list, 'company ') INTO list; END IF;
            END;
        END IF;

        SELECT CONCAT('DUP(', RTRIM(list), ')') INTO error;
        SELECT NULL INTO id;
    END;
    
    # Détection des clés de jointures qui n'existent pas.
    DECLARE EXIT HANDLER FOR 1452
    BEGIN  
        ROLLBACK;
        SET list = '';
        
        IF company_id IS NOT NULL THEN
            BEGIN
                SELECT COUNT(`companies`.`id`) FROM `companies` WHERE `companies`.`id` = company_id INTO vcount;
                IF vcount = 0 THEN SELECT 'company ' INTO list; END IF;
            END;    
        END IF;

        SELECT COUNT(`user_types`.`id`) FROM `user_types` WHERE `user_types`.`id` = type_id INTO vcount;
        IF vcount = 0 THEN SELECT CONCAT(list, 'type ') INTO list; END IF;
        
        SELECT COUNT(`countries`.`id`) FROM `countries` WHERE `countries`.`id` = country_id INTO vcount;
        IF vcount = 0 THEN SELECT CONCAT(list, 'country ') INTO list; END IF;

        SELECT CONCAT('DFK(', RTRIM(list) ,')') INTO error;
        SELECT NULL INTO id;        
    END;

    START TRANSACTION;
    
        INSERT INTO `users`
        SET         `users`.`login`            = login,
                    `users`.`password`         = password,
                    `users`.`first_name`       = first_name,
                    `users`.`last_name`        = last_name,
                    `users`.`email`            = email,
                    `users`.`birth_date`       = birth_date,
                    `users`.`address`          = address,
                    `users`.`zip`              = zip,
                    `users`.`city`             = city,
                    `users`.`phone`            = phone,
                    `users`.`www`              = www,
                    `users`.`photo`            = photo,
                    `users`.`fk_contries_id`   = country_id,
                    `users`.`fk_user_types_id` = type_id;

        SELECT LAST_INSERT_ID() INTO id;

        IF company_id IS NOT NULL THEN
            UPDATE `users`
            SET    `users`.`fk_companies_id` = company_id
            WHERE  `users`.`id` = id;
        END IF;

    COMMIT;
    SELECT NULL INTO error;
END //

Test unitaires

Les quelques fonctions présentées ci-dessous permettent de rédiger des tests unitaires.

CREATE TEMPORARY TABLE `results` (
	`id`     INT UNSIGNED NOT NULL AUTO_INCREMENT,
	`name`   VARCHAR(255) NOT NULL,
	`result` VARCHAR(255) NOT NULL,
	`error`  VARCHAR(255) DEFAULT 'OK',
	PRIMARY KEY (`id`)
);

SET @current_test = NULL;

DELIMITER //
CREATE PROCEDURE checkError(IN error VARCHAR(255), OUT v VARCHAR(255))
BEGIN
	IF error IS NULL THEN
		select "Fail" INTO v;
	ELSE
		select "Passed" INTO v;
	END IF;
	INSERT INTO `results` SET `name`=@current_test, `result`=v, `error`=error;
END //

DELIMITER //
CREATE PROCEDURE checkTheError(IN error VARCHAR(255), IN description VARCHAR(255), OUT v VARCHAR(255))
BEGIN
	IF error = description THEN
		select "Passed" INTO v;
	ELSE
		select "Fail" INTO v;
	END IF;
	INSERT INTO `results` SET `name`=@current_test, `result`=v, `error`=error;
END //

CREATE PROCEDURE checkSuccess(IN error VARCHAR(255), OUT v VARCHAR(255))
BEGIN
	IF error IS NULL THEN
		select "Passed" INTO v;
	ELSE
		select "Fail" INTO v;
	END IF;
	INSERT INTO `results` SET `name`=@current_test, `result`=v, `error`=error;
END //

###################################################################
# We test the procedure updateCompany().
###################################################################

# Here we define some variables... and the function getIds().
# ...

SET @current_test = 'updateCompany';

# OK.
CALL getIds();
CALL updateCompany(@company_id, '10 rue Trebois', NULL, NULL, NULL, NULL, NULL, NULL, @error);
CALL checkSuccess(@error, @v);

# OK (update with same values).
CALL getIds();
CALL updateCompany(@company_id, '10 rue Trebois', NULL, NULL, NULL, NULL, NULL, NULL, @error);
CALL checkSuccess(@error, @v);

# Company ID 1000 does not exist.
CALL getIds();
CALL updateCompany(1000, '10 rue Trebois', NULL, NULL, NULL, NULL, NULL, NULL, @error);
CALL checkTheError(@error, 'NOCHANGE', @v);

# Country code 1000 does not exist.
CALL getIds();
CALL updateCompany(@company_id, '10 rue Trebois', NULL, NULL, NULL, NULL, NULL, 1000, @error);
CALL checkTheError(@error, 'DFK(country)', @v);

# Email is already used.
CALL getIds();
CALL createCompany('edf', '10 rue de le villa du pres', 12345, 'La Ville', '123456789', 'www.edf.com', 'ggg@g.com', @country_id, @id, @error);
CALL checkSuccess(@error, @v);
SET @company_id = @id;
SELECT `companies`.`email` FROM `companies` WHERE `companies`.`id` <> @company_id LIMIT 1 INTO @email;
CALL updateCompany(@company_id, '10 rue Trebois', NULL, NULL, NULL, NULL, @email, NULL, @error);
CALL checkTheError(@error, 'DUP(email)', @v);

Trucs et astuces

Extraction de données via la ligne de commande

Il peut être utile de lancer une requête de sélection via la ligne de commande. Cela permet, par exemple, de diriger le résultat de la requête vers un script qui se chargera de l’exploitation des données.

Les options N et B permettent de supprimer le formatage du résultat en tableau.

Par exemple :

mysql -u root test -e 'select name from t_car_color limit 5';

Va retourner :

mysql -u root test -NBe 'select name from t_car_color limit 5';

Va retourner :

Une fois les données extraites, vous pouvez avoir besoin de les présenter sur une seule ligne. Pour cela vous pouvez utiliser Perl de la façon suivante :

mysql -u root test -NBe 'select name from t_car_color limit 5' | perl -e '@lines = (); while (<STDIN>) { chomp; push(@lines, $_); } print join(",", @lines);'

Va retourner :

Pour extraire le schéma d'une table :

mysql -u root test -NBe 'show create table t_car_color;' | perl -e '$t=<STDIN>; $t=~s/^[^\s]+\s+//; $t=~s/\\n/\n/mg; print $t;'

Insertion conditionnelle

Il arrive fréquemment que vous vouliez insérer une donnée uniquement si cette dernière n’a pas déjà été insérée.

Une solution simple pour parvenir à cet objectif est d’utiliser la construction « INSERT IGNORE ».

Par exemple :

La table définit un index unique sur le champ « name » (qui représentent le nom de la couleur). Vous disposez d’un grand nombre de couleurs dont certaines sont déjà déclarées dans la table. La construction « INSERT IGNORE » vous dispense de procéder à un tri préalablement au processus d’injection.

La commande mysql -u root test -e 'INSERT INTO t_car_color SET name="Air Force blue";' échoue car la couleur "Air Force blue" est déjà présente dans la table.

En revanche la commande mysql -u root test -e 'INSERT IGNORE INTO t_car_color SET name="Air Force blue";' fonctionne.