Exercices Corrigés PL/SQL: Fonctions de chaînes de caractères

La meilleure façon d’apprendre quelque chose est de pratiquer des exercices. Nous avons préparer ces exercices corrigés pour les personnes (débutantes ou intermédiaires) qui sont familières avec PL/SQL. Nous espérons que ces exercices vous aideront à améliorer vos compétences en PL/SQL. Les exercices corrigés suivantes sont actuellement disponibles, nous travaillons dur pour ajouter plus d’exercices. Bon apprentissage!

Vous pouvez lire notre tutoriel PL/SQL avant de résoudre les exercices suivants.

Exercices corrigés PL/SQL: Fonctions de chaînes de caractères

1. Écrire un bloc PL/SQL pour calculer la longueur du nom de chaque employé dans la table employees.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
str_size NUMBER;
BEGIN
  FOR e IN (SELECT nom FROM employees) LOOP
    str_size := LENGTH(e.nom);
    DBMS_OUTPUT.PUT_LINE('Longueur du nom ' || e.nom || ': ' || str_size);
  END LOOP;
END;
/

Sortie:

Longueur du nom Eddie        : 5
Longueur du nom Eleanor      : 7
Longueur du nom Glen         : 4
Longueur du nom Ali          : 3
Longueur du nom Earl         : 4
Longueur du nom Bryan        : 5

2. Écrire un bloc PL/SQL pour concaténer le prénom et le nom de chaque employé et afficher le nom complet.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
prenom_nom VARCHAR2(100);
BEGIN
  FOR e IN (SELECT prenom, nom FROM employees) LOOP
    prenom_nom := e.prenom || ' ' || e.nom;
    DBMS_OUTPUT.PUT_LINE('Le nom complet: ' || prenom_nom);
  END LOOP;
END;
/

Sortie:

Le nom complet: Parker Eddie
Le nom complet: Deas Eleanor
Le nom complet: Powell Glen
Le nom complet: Fawaz Ali
Le nom complet: Horn Earl
Le nom complet: Savoy Bryan

3. Ecrivez un bloc PL/SQL pour trouver la position de la première occurrence de la lettre ‘a’ dans le nom de chaque employé.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
pos NUMBER;
BEGIN
  FOR e IN (SELECT nom FROM employees) LOOP
    pos := INSTR(e.nom, 'a');
    DBMS_OUTPUT.PUT_LINE('Position du "a" dans ' || e.nom || ': ' || pos);
  END LOOP;
END;
/

Sortie:

Position du "a" dans Eddie: 0
Position du "a" dans Eleanor: 4
Position du "a" dans Glen: 0
Position du "a" dans Ali: 1
Position du "a" dans Earl: 2
Position du "a" dans Bryan: 4

4. Écrire un bloc PL/SQL pour récupérer les 3 premiers caractères du nom de chaque employé.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
soustr VARCHAR2(3);
BEGIN
  FOR e IN (SELECT nom FROM employees) LOOP
    soustr := SUBSTR(e.nom, 1, 3);
    DBMS_OUTPUT.PUT_LINE('Les trois premiers caractères du nom ' || e.nom || ': ' || soustr);
  END LOOP;
END;
/

Sortie:

Les trois premiers caractères du nom Eddie: Edd
Les trois premiers caractères du nom Eleanor: Ele
Les trois premiers caractères du nom Glen: Gle
Les trois premiers caractères du nom Ali: Ali
Les trois premiers caractères du nom Earl: Ear
Les trois premiers caractères du nom Bryan: Bry

5. Écrire un bloc PL/SQL pour convertir le nom de chaque employé en minuscules et afficher le résultat.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
minus VARCHAR2(50);
BEGIN
  FOR e IN (SELECT nom FROM employees) LOOP
    minus := LOWER(e.nom);
    DBMS_OUTPUT.PUT_LINE('Nom en minuscules: ' || e.nom || ': ' || minus);
  END LOOP;
END;
/

Sortie:

Nom en minuscules Eddie: eddie
Nom en minuscules Eleanor: eleanor
Nom en minuscules Glen: glen
Nom en minuscules Ali: ali
Nom en minuscules Earl: earl
Nom en minuscules Bryan: bryan

6. Écrire un bloc PL/SQL pour remplacer la ville ‘Paris’ de chaque client en ‘Île-de-France’ et afficher le résultat.

Table: clients

+-----------+----------------+-------------+--------+
| client_id |       nom      |    ville    |  age   |
+-----------+----------------+-------------+--------+
|    1001   | Alex Barbara   | Paris       |  25    |
|    1002   | Lois Collins   | Lyon        |  30    |
|    1005   | Karen Farley   | Nice        |  44    |
|    1006   | Kevin Thompson | Paris       |  65    |
|    1007   | Scott Henry    | Marseille   |  32    |
|    1003   | Ellen McMullen | Montpellier |  53    |
+-----------+----------------+-------------+--------+

DECLARE
v_old VARCHAR2(50);
v_new VARCHAR2(50);
ville_client clients.ville%TYPE;
BEGIN
v_old := 'Paris';
v_new := 'Ile-de-France';
  FOR c IN (SELECT ville FROM clients) LOOP
    ville_client := REPLACE(c.ville, v_old, v_new);
    DBMS_OUTPUT.PUT_LINE('Ville mis à jour: ' || ville_client);
  END LOOP;
END;

Sortie:

Ville mis à jour: Ile-de-France
Ville mis à jour: Lyon
Ville mis à jour: Nice
Ville mis à jour: Ile-de-France
Ville mis à jour: Marseille
Ville mis à jour: Montpellier

7. Écrire un bloc PL/SQL qui supprime les zéros de début et de fin dans une chaîne de caractères. Affichez la chaîne de caractères. Exemple:

str = "0000hello world!0000";
hello world!

DECLARE
str VARCHAR2(50);
res VARCHAR2(50);
BEGIN
  str := '0000hello world!0000';
  res := TRIM('0' FROM str);
  DBMS_OUTPUT.PUT_LINE(res);
END;

Sortie:

hello world!

8. Écrire un bloc PL/SQL pour convertir le nom de chaque employé en majuscules et afficher le résultat.

Table: employees

+------+---------+----------+----------+----------------+
|  id  |   nom   |  prenom  | salaire  | departement_id |
+------+---------+----------+----------+----------------+
| 1001 | Eddie   | Parker   | 6000.00  | 8              |
| 1002 | Eleanor | Deas     | 4500.00  | 8              |
| 1003 | Glen    | Powell   | 5000.00  | 6              |
| 1004 | Ali     | Fawaz    | 7800.00  | 2              |
| 1005 | Earl    | Horn     | 9000.00  | 9              |
| 1006 | Bryan   | Savoy    | 8000.00  | 3              |
+------+---------+----------+----------+----------------+

DECLARE
maj VARCHAR2(50);
BEGIN
  FOR e IN (SELECT nom FROM employees) LOOP
    maj := UPPER(e.nom);
    DBMS_OUTPUT.PUT_LINE('Nom en majuscules: ' || e.nom || ': ' || maj);
  END LOOP;
END;
/

Sortie:

Nom en majuscules Eddie: EDDIE
Nom en majuscules Eleanor: ELEANOR
Nom en majuscules Glen: GLEN
Nom en majuscules Ali: ALI
Nom en majuscules Earl: EARL
Nom en majuscules Bryan: BRYAN

Exercices corrigés PL/SQL: Fonctions de chaînes de caractères

Vous pourrez aussi aimer

32 Exercices Corrigés PL/SQL: Principes de base

Exercices Corrigés PL/SQL: Instruction IF-THEN-ELSE

Exercices Corrigés PL/SQL: Curseurs

Laisser un commentaire Annuler la réponse