Les boucles :Loop,While ,Repeat

Exemples

Q(LOOP): Créez une procédure stockée pourafficher les nombres de 1 à 10.


DELIMITER //
CREATE PROCEDURE AfficherNombres()
BEGIN
    DECLARE i INT DEFAULT 1;
	DECLARE res text DEFAULT "";
    WHILE i <= 10 DO
      
		SET res=concat(res,' ',i);
        SET i = i + 1;
    END WHILE;
	  SELECT res;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourcalculer la somme des entiers de 1 à 100.


DELIMITER //
CREATE PROCEDURE CalculerSomme()
BEGIN
    DECLARE i INT DEFAULT 1;
    DECLARE somme INT DEFAULT 0;
    REPEAT
        SET somme = somme + i;
        SET i = i + 1;
    UNTIL i > 100 END REPEAT;
    SELECT somme;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourafficher les noms des produits jusqu'à ce qu'un produit spécifique soit trouvé.


DELIMITER //
CREATE PROCEDURE AfficherNomsProduits()
BEGIN
    DECLARE produitRecherche VARCHAR(25) DEFAULT 'ProduitX';
    DECLARE nomProduit VARCHAR(25);
	Declare i int default 0;
	declare res text default "";
    boucle:LOOP
        SELECT nom INTO nomProduit FROM produits LIMIT i,1;
				SET res=concat(res,' ',nomProduit);
        IF nomProduit = produitRecherche THEN
            LEAVE boucle;
        END IF;
		set i=i+1;
    END LOOP;
	        SELECT res;
END;
//
DELIMITER ;

Q(WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour afficher les nombres pairs de 2 à 20.


DELIMITER //
CREATE PROCEDURE AfficherNombresPairs()
BEGIN
    DECLARE i INT DEFAULT 2;
	declare res text default "";
    WHILE i <= 20 DO
		SET res=concat(res,' ',i);
        SET i = i + 2;
    END WHILE;
	SELECT res;
END;
//
DELIMITER ;

Q(WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour trouver le plus petit multiple commun (PGCD) de deux nombres.


create procedure if not exists PGCD(a int , b int)
begin 	   
	declare n defaut 0;
	declare i int defaut 1;
	declare j int defaut 1;
	declare afois int defaut 0;
	declare bfois int defaut 0;
	 if a < b then
	  n=b;
	 else 
		 n=a;
	 end if;
  while  i<=n do
	 set afois=a*i;
	set i=i+1;
	while j<=n do
		set bfois=b*j;
		set j=j+1;
		if afois=bfois then 
		  set j=n+1;
		  set i=n+1;
		end if;
	end While;
  end while;
select afois;
	end ;

Q(REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour afficher les carrés des nombres de 1 à 5.


DELIMITER //
CREATE PROCEDURE AfficherCarres()
BEGIN
    DECLARE i INT DEFAULT 1;
	declare res text default "";
    REPEAT
		SET res=concat(res,' ',i*i);
        SET i = i + 1;
    UNTIL i > 5 
	END REPEAT;
	SELECT res;
END;
//
DELIMITER ;

Q(REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour trouver le premier nombre premier supérieur à un nombre donné.


DELIMITER //
CREATE PROCEDURE PremierNombrePremier(superieurA INT)
BEGIN
    DECLARE nombre INT;
	DECLARE diviseur INT;
	DECLARE premier BOOLEAN DEFAULT TRUE;
    SET nombre = superieurA + 1;
   boucle1:REPEAT
        SET diviseur = 2;
		SET premier=true;
        boucle2:WHILE diviseur <= (nombre) DO
            IF nombre % diviseur = 0 THEN
                SET premier = FALSE;
                LEAVE boucle2;
            END IF;
            SET diviseur = diviseur + 1;
        END WHILE;
        IF premier THEN
            SELECT nombre;
            LEAVE boucle1;
        END IF;
        SET nombre = nombre + 1;
    UNTIL 0 END REPEAT;
END;
//
DELIMITER ;

Q(WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour calculer la factorielle d'un nombre donné.


DELIMITER //
CREATE PROCEDURE Factorielle(n INT)
BEGIN
    DECLARE resultat INT DEFAULT 1;
    DECLARE i INT DEFAULT 1;
    WHILE i <= n DO
        SET resultat = resultat * i;
        SET i = i + 1;
    END WHILE;
    SELECT resultat;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourtransférer des produits d'une catégorie à une autre jusqu'à ce qu'un certain nombre de produits ait été transféré.


DELIMITER //
CREATE PROCEDURE TransfererProduits()
BEGIN
    DECLARE produitsTransférés INT DEFAULT 0;
    DECLARE limiteTransferts INT DEFAULT 10;
    boucle:LOOP
        UPDATE produits SET categorie = 'NouvelleCategorie' WHERE categorie = 'AncienneCategorie' LIMIT 1;
        SET produitsTransférés = produitsTransférés + 1;
        IF produitsTransférés >= limiteTransferts THEN
            LEAVE boucle;
        END IF;
    END LOOP;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourafficher les nombres pairs jusqu'à un certain nombre.


DELIMITER //
CREATE PROCEDURE NombresPairsJusqua(n INT)
BEGIN
    DECLARE i INT DEFAULT 2;
	DECLARE res text DEFAULT "";
    boucle:LOOP
		SET res=concat(res,' ',i);
        SET i = i + 2;
        IF i > n THEN
            LEAVE boucle;
        END IF;
    END LOOP;
	SELECT res;
END;
//
DELIMITER ;

Q(REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour afficher la table de multiplication d'un nombre donné.


DELIMITER //
CREATE PROCEDURE TableMultiplication(n INT)
BEGIN
    DECLARE i INT DEFAULT 1;
	DECLARE res text default "";
    REPEAT
        set res= CONCAT(res,' ',n, ' x ', i, ' = ', n * i);
        SET i = i + 1;
    UNTIL i > 10 
	END REPEAT;
	select res;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourdéplacer les produits d'une catégorie à une autre jusqu'à ce qu'il ne reste plus de produits dans la catégorie d'origine.


DELIMITER //
CREATE PROCEDURE DeplacerProduits()
BEGIN
    DECLARE produitsRestants INT;
    SELECT COUNT(*) INTO produitsRestants FROM produits WHERE categorie = 'AncienneCategorie';
    WHILE produitsRestants > 0 DO
        UPDATE produits SET categorie = 'NouvelleCategorie' WHERE categorie = 'AncienneCategorie' LIMIT 1;
        SET produitsRestants = produitsRestants - 1;
    END WHILE;
END;
//
DELIMITER ;

Q(REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour afficher les termes de la suite de Fibonacci jusqu'à un certain nombre.


DELIMITER //
CREATE PROCEDURE SuiteFibonacciJusqua(n INT)
BEGIN
    DECLARE a INT DEFAULT 0;
    DECLARE b INT DEFAULT 1;
	DECLARE res text default "";
    REPEAT
		SET res=concat(res,' ',a);
        SET b = a + b;
        SET a = b - a;
    UNTIL a > n
	END REPEAT;
	SELECT res;
END;
//
DELIMITER ;

Q(LOOP): Créez une procédure stockée pourdéplacer les produits d'une catégorie à une autre jusqu'à atteindre un nombre limite de produits déplacés.


DELIMITER //
CREATE PROCEDURE DeplacerProduitsLimite(limite INT)
BEGIN
    DECLARE produitsDeplaces INT DEFAULT 0;
    boucle:LOOP
        UPDATE produits SET categorie = 'NouvelleCategorie' WHERE categorie = 'AncienneCategorie' LIMIT 1;
        SET produitsDeplaces = produitsDeplaces + 1;
        IF produitsDeplaces >= limite THEN
            LEAVE boucle;
        END IF;
    END LOOP;
END;
//
DELIMITER ;

Q(WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour trouver le plus petit nombre premier supérieur à un nombre donné.


DELIMITER //
CREATE PROCEDURE PremierNombrePremierSuperieurA(superieurA INT)
BEGIN
    DECLARE nombre INT;
	DECLARE diviseur INT;
	DECLARE premier BOOLEAN DEFAULT TRUE;
    SET nombre = superieurA + 1;
   boucle1: WHILE TRUE DO
       
        SET diviseur = 2;
        SET premier=true;
        boucle2:WHILE diviseur <= (nombre) DO
            IF nombre % diviseur = 0 THEN
                SET premier = FALSE;
                LEAVE boucle2;
            END IF;
            SET diviseur = diviseur + 1;
        END WHILE;
        IF premier THEN
            SELECT nombre;
            LEAVE boucle1;
        END IF;
        SET nombre = nombre + 1;
    END WHILE;
END;
//
DELIMITER ;

Q (LOOP): Créez une procédure stockée qui utilise une boucle LOOP pour transférer les produits de la catégorie A à la catégorie B jusqu'à ce qu'il n'y ait plus de produits de la catégorie A.

DELIMITER //
CREATE PROCEDURE DeplacerProduits()
BEGIN
    DECLARE produitsRestants INT;
    REPEAT
        UPDATE produits SET categorie = 'B' WHERE categorie = 'A' LIMIT 1;
        SELECT COUNT(*) INTO produitsRestants FROM produits WHERE categorie = 'A';
    UNTIL produitsRestants = 0 END REPEAT;
END;
//
DELIMITER ;

Q (WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour afficher les nombres premiers jusqu'à un certain nombre.


DELIMITER //
CREATE PROCEDURE NombresPremiersJusqua(n INT)
BEGIN
    DECLARE i INT DEFAULT 2;
     DECLARE premier BOOLEAN DEFAULT TRUE;
     DECLARE diviseur INT;
    boucle1:WHILE i <= n DO
        SET diviseur = 2;
        set premier=true;
        WHILE diviseur <= SQRT(i) DO
            IF i % diviseur = 0 THEN
                SET premier = FALSE;
                LEAVE boucle1;
            END IF;
            SET diviseur = diviseur + 1;
        END WHILE;
        IF premier THEN
            SELECT i;
        END IF;
        SET i = i + 1;
    END WHILE;
END;
//
DELIMITER ;

Q (REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour afficher les chiffres en toutes lettres de 1 à 10.

DELIMITER //
CREATE PROCEDURE ChiffresEnLettres()
BEGIN
    DECLARE i INT DEFAULT 1;
    REPEAT
        CASE
            WHEN i = 1 THEN SELECT 'Un';
            WHEN i = 2 THEN SELECT 'Deux';
            WHEN i = 3 THEN SELECT 'Trois';
            WHEN i = 4 THEN SELECT 'Quatre';
            WHEN i = 5 THEN SELECT 'Cinq';
            WHEN i = 6 THEN SELECT 'Six';
            WHEN i = 7 THEN SELECT 'Sept';
            WHEN i = 8 THEN SELECT 'Huit';
            WHEN i = 9 THEN SELECT 'Neuf';
            ELSE SELECT 'Dix';
        END CASE;
        SET i = i + 1;
    UNTIL i > 10 END REPEAT;
END;
//
DELIMITER ;

Q (LOOP): Créez une procédure stockée qui utilise une boucle LOOP pour transférer les produits de la catégorie X à la catégorie Y jusqu'à ce qu'un nombre limite de produits ait été transféré.

DELIMITER //
CREATE PROCEDURE TransfererProduitsJusquaLimite(limite INT)
BEGIN
    DECLARE produitsTransférés INT DEFAULT 0;
    boucle1:LOOP
        UPDATE produits SET categorie = 'Y' WHERE categorie = 'X' LIMIT 1;
        SET produitsTransférés = produitsTransférés + 1;
        IF produitsTransférés >= limite THEN
            LEAVE boucle1;
        END IF;
    END LOOP;
END;
//
DELIMITER ;

Q (WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour afficher les nombres impairs jusqu'à un certain nombre donné.

DELIMITER //
CREATE PROCEDURE NombresImpairsJusqua(n INT)
BEGIN
    DECLARE i INT DEFAULT 1;
	DECLARE res text default "";
    WHILE i <= n DO
		SET res=concat(res,' ',i*i);
        SET i = i + 2;
    END WHILE;
	SELECT res;
END;
//
DELIMITER ;

Q (REPEAT): Créez une procédure stockée qui utilise une boucle REPEAT pour trouver le plus grand diviseur commun (PGCD) de deux nombres.

DELIMITER //
CREATE PROCEDURE PGCD(a INT, b INT)
BEGIN
    REPEAT
        SET a = a % b;
        SET a = b;
        SET b = a % b;
    UNTIL b = 0 END REPEAT;
    SELECT a;
END;
//
DELIMITER ;

Q (LOOP): Créez une procédure stockée qui utilise une boucle LOOP pour transférer les produits de la catégorie A à la catégorie B jusqu'à ce qu'un certain nombre de produits ait été transféré.

DELIMITER //
CREATE PROCEDURE TransfererProduitsJusquaNombre(nombre INT)
BEGIN
    DECLARE produitsTransférés INT DEFAULT 0;
    boucle1:LOOP
        UPDATE produits SET categorie = 'B' WHERE categorie = 'A' LIMIT 1;
        SET produitsTransférés = produitsTransférés + 1;
        IF produitsTransférés >= nombre THEN
            LEAVE boucle1;
        END IF;
    END LOOP;
END;
//
DELIMITER ;

Q (WHILE): Créez une procédure stockée qui utilise une boucle WHILE pour afficher les puissances d'un nombre donné jusqu'à un certain exposant.

DELIMITER //
CREATE PROCEDURE Puissances(n INT, exposant INT)
BEGIN
    DECLARE i INT DEFAULT 1;
	DECLARE res text default "";
    WHILE i <= exposant DO
		SET res=concat(res,' ',n ^ i);
        SET i = i + 1;
    END WHILE;
	SELECT res;
END;
//
DELIMITER ;

Fonctions et procédures

Les triggers

la Sécurité de données

Exercices

Mysql

SELECT

DataTypes

UPDATE

DELETE

CREATE

DROP

RENAME

ALTER

Tables

Les boucles :Loop,While ,Repeat