SQL -PLSQL

Objectifs :
 SQL

 SQL
 Structured Query Language langage de requête structuré, est
le langage standard ISO-ANSI de définition et de manipulation
de données pour les SGBDR
 Les SGBDR utilisent des dialectes légèrement différents de
syntaxe SQL et de règles de dénomination; (voir guides
d'utilisation SQL de ces systèmes).
 SQL

 Classification des ordres SQL

Ordres SQL Aspect du langage

CREATE – ALTER – DROP - Définition des données
COMMENT – RENAME – TRUNCATE- (DDL : Data Definition
GRANT - REVOKE Language)
SELECT - INSERT – UPDATE – Manipulation des données (DML :
DELETE – Data Manipulation Language)
LOCK TABLE
COMMIT – ROLLBACK – SAVEPOINT Contrôle des transactions (TCL :
– Transaction Control)
SET TRANSACTION
 SQL

 Noms et opérateurs SQL

 Noms SQL : certaines versions de SQL spécifiques r ont certaines restrictions.
 Par exemple, dans Oracle, les noms de tables et de colonnes (attributs) peuvent comporter jusqu'à 30
caractères, doivent commencer par une lettre et peuvent inclure les symboles (a-z, 0-9,_,$,#).

 Types de données pour les attributs :

 character, character varying, numeric, decimal, integer, smallint,
float, double precision, real, bit, bit varying, date, time, timestamp,
interval.
 Opérateurs logiques : et, ou, non, ().
 Opérateurs de comparaison : =, <>, <, <=, >, >=, (), in, any, some, all, between, not
between, is null, is not null, like.
 SQL

 Noms et opérateurs SQL

 Opérateurs ensemblistes :
 union : combine les requêtes pour afficher n'importe quelle ligne
dans chaque sous-requête
 intersect : combine les requêtes pour afficher des lignes distinctes
communes à toutes les sous-requêtes
 except: (“minus” ou “difference”)
 Fonctiions ensembliste: count, sum, min, max, avg.
 Expressions avancées : CASE, CAST, constructeurs de
valeurs de ligne.
 CASE est similaire aux expressions CASE dans les langages de
programmation,
 CAST vous permet de convertir des données d'un type en un type
différent
 SQL

 Langage de définition de données (DDL)

 create table: définit une table et tous ses attributs
 alter table: ajouter de nouvelles colonnes, supprimer des colonnes ou
modifier les colonnes existantes dans une table
 drop table : supprime une table existante
 create view, drop view: définit/supprime une vue de base de données

 create index/drop index : définit/supprime un index sur un attribut

particulier ou un composite de plusieurs attributs dans une table
particulière.
 SQL

 Langage de définition de données (DDL)

create table clients

(num_clt numeric,
nom_clt char(20),
addresse varchar(256),
niveau_credit numeric,
check (niveau_credit >= 1000),
primary key (num_clt));

 La règle de vérification (check) est une contrainte d'intégrité qui indique à SQL de tester
automatiquement chaque insertion de niveau_credit pour une valeur supérieure ou égale à
1 000. Dans le cas contraire, un message d'erreur doit s'afficher.
 SQL

 Langage de définition de données (DDL)

create table article
(num_article numeric,
nom_article char(20),
prix numeric,
poids numeric,
primary key (num_article));

create table article

(id INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
nom_article char(20),
prix numeric,
poids numeric,
primary key (num_article));
 SQL

 Langage de définition de données (DDL)

create table commandes

(num_cde char(15),
num_clt numeric not null,
num_article numeric not null,
quantite numeric,
cout_total numeric,
primary key (num_cde),
foreign key (num_clt) references clients
on delete no action on update cascade,
foreign key (num_article) references articles
on delete no action on update cascade);
 SQL

 Langage de définition de données (DDL)

 Format recommandé pour la clé primaire et la clé étrangère,

constraint pk_constr primary key (num_cde),

constraint fk_constr1 foreign key

(num_clt) references clients
(num_clt) on delete no action on update cascade,

constraint fk_constr2 foreign key

(num_article) references articles (num_article)
on delete no action on update cascade);
 SQL

 Langage de définition de données (DDL)

 Les contraintes courantes pour les attributs dans les commandes SQL create
table :
 Not null : spécifie qu'un attribut doit avoir une valeur non nulle.
 Unique : spécifie que l'attribut est une clé candidate ; c'est-à-dire qu'il a une valeur
unique pour chaque ligne du tableau.

 Chaque attribut qui est une clé candidate doit également avoir la contrainte Not null
 La contrainte unique est également utilisée comme clause pour désigner des clés
candidates composites qui ne sont pas la clé primaire. Ceci est particulièrement utile
lors de la transformation de relations ternaires en SQL.
 SQL

 Langage de définition de données (DDL)

 on delete cascade : l'opération de suppression sur la table référencée se
propage sur toutes les clés étrangères correspondantes.
 on delete set null : les clés étrangères sont mises à null lorsqu'elles correspondent à la
clé primaire d'une ligne supprimée dans la table référencée. Chaque clé étrangère doit
pouvoir accepter des valeurs nulles pour que cette opération s'applique.
 on delete set default : les clés étrangères sont définies sur une valeur par
défaut lorsqu'elles correspondent à la clé primaire de la ou des lignes supprimées dans
la table de référence. Les valeurs légales par défaut incluent une valeur littérale, «
utilisateur », « utilisateur système » ou « no action».
 on update cascade: : l'opération de mise à jour sur la ou les clés primaires
de la table référencée « se propagen » sur toutes les clés étrangères correspondantes.
 on update set null : les clés étrangères sont définies sur null lorsqu'elles
correspondent à l'ancienne valeur de clé primaire d'une ligne mise à jour dans la table
référencée.
 on update set default
 SQL

 Langage de définition de données (DDL)

 L'option cascade est généralement applicable lorsque la
contrainte d'existence obligatoire ou la contrainte de
dépendance d'ID est spécifiée dans le diagramme ER pour la
table référencée.
 set null ou set default est applicable lorsque l'existence
facultative est spécifiée dans le diagramme ER pour la table
référencée
 SQL

 Langage de définition de données (DDL)

 Commandes additionnelle : alter table, drop table

alter table clients

modify (nom_clt varchar(256));

alter table clients

add column clt_limit_credit numeric;

alter table clients

drop column niveau_credit ;

drop table customer;

 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 base de toutes les requêtes de base de données.
 Tours les clients
select *
from clients;

 Affichez le nom du client, le numéro de client et le niveau de crédit pour tous les
clients qui ont un niveau de crédit supérieur à 7.
select nom_clt, num_clt, niveau_credit
from clients
where address = 'Enterprise’ and niveau_credit > 7
order by nom_clt asc;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 toutes les informations sur les clients et les articles commandés,
mais omettez les clients dont le niveau de crédit est supérieur à 6.
select cl.*, co.*
from clients as cl, commandes as co
where cl.num_clt= co.num_clt and cl.niveau_credit< 7
order by cust__no asc;

 Utilisation d’alias et de la jointure entre tables

 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Union et Intersection.
 Quels articles ont été commandés par le client 002 ou le client
007 ? deux manières, l'une avec un opérateur d'ensemble (union)
et l'autrenum_article,
select avec un opérateur logique (ou). num_clt, nom_clt
nom_article,
from commandes
where num_clt = 002
union
select num_article, nom_article, num_clt, nom_clt
from commandes
where num_clt = 007;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Union et Intersection.
 Quels articles ont été commandés par le client 002 ou le client
007 ? deux manières, l'une avec un opérateur d'ensemble (union)
et l'autrenum_article,
select avec un opérateur logique (ou). num_clt, nom_clt
nom_article,
from commandes
where (num_clt = 002 or num_clt = 007);
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Union et Intersection.
 Quels articles sont commandés a la fois par les clients 005 et 006 ?

select num_article, nom_article, num_clt, nom_clt

from commandes
where num_clt = 005
intersect
select num_article, nom_article, num_clt, nom_clt
from commandes
where num_clt = 006;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Fonction d’agrégation
 Afficher le nombre total de commandes
select count(*)
from commandes;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Fonction d’agrégation
 Affichez le nombre total de clients passant réellement des
commandes d’articles. Le nombre distinct de clients doit être
compté.
select count( distinct num_clt)
from commandes;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Fonction d’agrégation
 Afficher la quantité maximale d'une commande de l'article
numéro 125.
select max (quantite)
from commandes
where num_article = 125;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Fonction d’agrégation
 Pour chaque type d'article commandé, affichez le numéro
d'article et la quantité totale commandée.
select num_article, nom_article, sum(quantite)
from commandes
Group by num_article, nom_article
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Fonction d’agrégation
 Afficher les numéros d'article pour tous les articles commandés
plus d'une fois. Cette requête nécessite l'utilisation des clauses
group by et having
select num_article, nom_article,
from commandes
Group by num_article, nom_article
Having count(*) > 1;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Jointures et sous-requêtes

 Afficher les noms des clients qui commandent le numéro

d'article 125. Cette requête nécessite une jointure
select cl.nom_clt,
(équijointure) co.num_cde
des tables clients et commandes
from clients as cl, commandes as co
where cl.num_clt = co.num_clt
and num_article = 125;
 SQL

 Langage de manipulation de données (DML)

 utilisé pour les requêtes, les mises à jour et la définition de
vues.

 Commande SELECT
 Jointures et sous-requêtes
 Cette requête peut être effectuée de manière équivalente avec
une sous-requête (parfois appelée sous-requête imbriquée) au
format suivant.
select nom_clt, num_cde
from clients
where num_clt in
(select num_clt
from commandes
where item_num = 125);
 SQL

 Langage de manipulation de données (DML)

 Commande SELECT
 Jointures et sous-requêtes
 Afficher les noms des clients qui commandent au moins un article dont
le prix est supérieur à 1 000. sous-requête imbriquée à trois niveaux.
 Les expressions in, = some et = any sont souvent utilisées comme
opérateurs de comparaison équivalents ;

select cl.nom_client
from clients as cl
where cl.num_client in
(select co. num_client
from commandes as co
where co.num_article = any
(select a.num_article
from articles as a
where [Link] > 1000));
 SQL

 Langage de manipulation de données (DML)

 Commande SELECT
 Jointures et sous-requêtes
 Quels clients n’ont commandé aucun article d’un prix supérieur à
1000 ?
 on peut utiliser de manière équivalente not in au lieu de not any.

select cl.nom_client
from clients as cl
where cl.num_client not any
(select co. num_client
from commandes as co, articles as a
where co.num_article = a. num_article
and [Link] > 1000);
 SQL

 Langage de manipulation de données (DML)

 Commande SELECT
 Jointures et sous-requêtes
 Quels clients ont commandé uniquement des articles pesant plus de 1
000 ?
 Ceci est un exemple du quantificateur universel all.

select c.nom_client
from clients as cl, commandes as co
where cl.num_client = o.num_client
and co.num_article = all
(select a. num_article
from articles as a
where [Link] > 1000);
 SQL

 Langage de manipulation de données (DML)

 Commandes de mise à jour SQL
 Insertion de données dans une table

insert into clients values(1, "Kone mariam", "ouaga

2000", 50000);
 suppression de données dans une table

delete from clients

where niveau_credit >12000

 Mise a jour denregistrement

update client
set niveau_credit = 10000
where niveau_credit = 9000;
 SQL

 Langage de manipulation de données (DML)

 Insertion de données dans une table

 A partir d'un fichier texte (syntaxe sqlserver)
 Un enregistrement par ligne; une tabulation entre les champs

LOAD DATA INFILE 'D:/[Link]' INTO TABLE

clients;
 SQL

 Langage de manipulation de données (DML)

 VUES SQL
 Une vue en SQL est une table nommée et dérivée (virtuelle) qui
dérive ses données de tables de base, les tables réelles définies par
la commande create table.

 Les définitions de vues peuvent être stockées dans la base de

données, mais les vues (tables dérivées) elles-mêmes ne sont pas
stockées ; elles sont dérivés au moment de l'exécution lorsque la
vue est appelée en tant que requête à l'aide de la commande SQL
select. La personne qui interroge la vue traite la vue comme s'il
s'agissait d'une table réelle (stockée).
 Utilité
 Permettre de simplifier lecriture de requetes complexes;
 une plus grande sécurité à une base de données, car l'administrateur peut
attribuer différentes vues des données à différents utilisateurs et contrôler ce
que chaque utilisateur voit dans la base de données.
 SQL

 Langage de manipulation de données (DML)

 VUES SQL
 vue appelée Lescommandes qui montre quels articles ont été
commandés par chaque client et combien.

create view Lescommandes (nom_client, nom_article, quantite) as

select cl. nom_client, a. nom_article, [Link]
from clients as cl, articles as a, commandes as co
where cl. nom_client = co.num_cde
and co.num_article = a. num_article ;
 PL SQL

 PLSQL
 PL SQL

 Les sous-programmes
 blocs nommés qui sont compilés et qui résident dans la base
de données (stored procedures ou stored routines.
 fonctions ou procédures « cataloguées » (ou « stockées »):
similarité avec les langages de programmation

 Cycle de vie d’un sous-programme

 création de la procédure ou de la fonction (compilation et stockage
dans la base);
 appel du sous-programme;
 et éventuellement suppression du sous-programme de la base.

 Il est possible de retrouver le code d’un sous-programme au

niveau du dictionnaire des données.
 PL SQL

 Avantage des sous-programmes

 procédures ou fonctions cataloguées sont stockées côté serveur

(potentiellement moins d'encombrement du trafic réseau :
 La modularité
 La portabilité : un sous-programme est indépendant du système
d’exploitation qui héberge le serveur MySQL.
 L’intégration avec les données des tables
 La sécurité, car les sous-programmes s’exécutent dans un
environnement a priori sécurisé (SGBD) où il est plus facile de garder la
maîtrise sur les ordres SQL exécuté.
 PL SQL

 Les sous-programmes
 Parties d’un sous-programmes
 déclaration des variables,
 les instructions
 et éventuellement une partie pour gérer les exceptions

 Appel d’une procédure

 à l’aide de l’interface de commande (par CALL),
 dans un programme externe (Java, PHP, C…),
 par d’autres procédures ou fonctions, ou dans le corps d’un
déclencheur.
 Les fonctions peuvent être invoquées
 dans une instruction SQL (SELECT, INSERT, et UPDATE)
 ou dans une expression (affectation de variable ou calcul).
 PL SQL

 Syntaxe d’une procédure stockée



CREATE PROCEDURE [nomBase.]nomProcédure(

[ [ IN | OUT | INOUT ] param typeMySQL
[,[ IN | OUT | INOUT ] param2 typeMySQL ] ] ...)
[ LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL
DATA }
| SQL SECURITY { DEFINER | INVOKER }
| COMMENT 'commentaire'
]
BEGIN
[DECLARE ... ;]
bloc d’instructions SQL et MySQL ... ;
END;
délimiteur
 PL SQL

 Syntaxe d’une procédure stockée



CREATE PROCEDURE [nomBase.]nomProcédure(

[ [ IN | OUT | INOUT ] param typeMySQL
[,[ IN | OUT | INOUT ] param2 typeMySQL ] ] ...)

BEGIN
[DECLARE ... ;]
bloc d’instructions SQL et MySQL ... ;

END;
délimiteur
 PL SQL

 Syntaxe d’une fonction cataloguée


CREATE FUNCTION [nomBase.]nomFonction(
[ param typeMySQL
[,param2 typeMySQL ] ] ...)
RETURNS typeMySQL
[ LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
| COMMENT 'commentaire'
]
BEGIN
[DECLARE ... ;]
bloc d’instructions SQL et MySQL ... ;
contenant un « RETURN variable ; »
END;
délimiteur
 PL SQL

 Structure d’un bloc

 Un bloc d’instructions est composé de :

 BEGIN (section obligatoire) contient le code incluant ou non des

directives SQL se terminant par le symbole « ; » ;
 DECLARE (directive optionnelle) déclare une variable, un curseur,
une exception, etc. ;
 END ferme le bloc.

 Un bloc peut être imbriqué dans un autre bloc

 Portée des objets: Un objet (variable, curseur ou exception) déclaré
dans un bloc est accessible dans les sous-blocs
 Aucun objet manipulé par programme n’est sensible à la casse (not
case sensitive)
 deux types de commentaires : monolignes, commençant au symbole
"--" et multilignes, commençant par "/*" et finissant par "*/"
 PL SQL

 Variables

 déclarées (et éventuellement initialisées) par la directive DECLARE.

 Deux types de variables sont disponibles sous MySQL :
 scalaires : recevant une seule valeur d’un type SQL (ex : colonne d’une table) ;
 externes : définies dans la session et qui peuvent servir de paramètres d’entrée ou de sortie.

 La déclaration d’une variable scalaire :

 DECLARE Var1[,Var2...] typeMSQL [DEFAULT expression];
 DEFAULT permet d’initialiser la (ou les) variable(s) – pas forcément à l’aide d’une constante.
 DECLARE v_dateNaissance DATE;
 DECLARE v_trouve BOOLEAN DEFAULT TRUE;
 PL SQL

 Variables

 Affectation (plusieurs possibilités :

 SET variable : =expression;
 la directive DEFAULT ;
 la directive INTO d’une requête (SELECT… INTO variable FROM…).

 Opérateurs
 Les opérateurs SQL (logiques, arithmétiques, de concaténation…) sont disponibles au sein
d’un sous-programmes
 PL SQL

 Variables

DECLARE v_compteur INT(3) DEFAULT 0;

DECLARE v_trouve BOOLEAN;
DECLARE v_nombre INT(3);

SET v_compteur := v_compteur+1;

SET v_trouve := (v_compteur=v_nombre);
SET v_trouve := (v_nombre IS NULL);
 PL SQL

 Variables externes
 Variables de session
 Il est possible de passer en paramètres d’entrée d’un bloc des variables externes.
 Ces variables sont dites de session (user variables). Elles n’existent que durant la session.
 On déclare ces variables en ligne de commande à l’aide du symbole "@ "
 SET @var1 = expression1 [, @var2 = expression2] ...
SET @vs_num = 'PL-4'$
SET @vs_hvol = 15$
BEGIN
DECLARE v_nom CHAR(16);
DECLARE v_nbHVol DECIMAL(7,2);
SELECT nom,nbHVol
INTO v_nom, v_nbHVol FROM Pilote
WHERE brevet = @vs_num ;
SET v_nbHVol := v_nbHVol + @vs_hvol ;
SELECT v_nom, v_nbHVol;
END;
 PL SQL

 Variables externes

delimiter $ Déclaration du
délimiteur
SET @vs_nom = 'Placide Fresnais’$ variable de session
DROP PROCEDURE sp1$ Suppression de la
procédure.
CREATE PROCEDURE sp1() Création de la
procédure.
BEGIN
DECLARE v_nbHVol DECIMAL(7,2);
SELECT nbHVol INTO v_nbHVol
FROM Pilote WHERE nom = @vs_nom;
SELECT v_nbHVol; Trace du résultat.
END; Fin du bloc
$

CALL sp1()$ Appel de la procédure.

 PL SQL

 Structures de Contrôles
 Structures conditionnelles

 IF-THEN (si alors),

 IF-THEN-ELSE (avec le sinon à programmer),
 et IF-THEN-ELSEIF (imbrications de conditions).
 PL SQL

 Structures de Contrôles
 Structure CASE

CASE variable CASE

WHEN expr1 THEN instructions1; WHEN condition1 THEN
WHEN expr2 THEN instructions2; instructions1;
… WHEN condition2 THEN
WHEN exprN THEN instructionsN; instructions2;
[ELSE instructionsN+1;] …
END CASE; WHEN conditionN THEN
instructionsN;
[ELSE instructionsN+1;]
END CASE;
 PL SQL

 Structures de Contrôles
 Structures répétitives

WHILE condition DO
instructions;
END WHILE ;

REPEAT
instructions;
UNTIL condition END REPEAT;

[etiquette:] LOOP
instructions;
END LOOP [etiquette];

LEAVE etiquette permet de sortir de la boucle

 PL SQL

 Interactions avec la base

 Extraction de données

SELECT col1 [,col2 ...]INTO vaR1 [,var2 ...]

FROM nomTable ...;

ne récupérer qu’un seul enregistrement à l’aide du WHERE de la

requête.
 PL SQL

 Interactions avec la base

 Extraction de données
BEGIN
DECLARE v_comp VARCHAR(15);
SELECT compa INTO v_comp
FROM Pilote WHERE brevet='PL-2';
...
END;
--------------------------------------------------------------------------------
SET @vs_compa=''
SELECT compa INTO @vs_compa FROM Pilote
WHERE brevet='PL-2'$
...
-----------------------------------------------------------------------------
SET @vs_compa=''$
CREATE PROCEDURE sp1()
BEGIN
SELECT compa INTO @vs_compa
FROM Pilote WHERE brevet='PL-2';
Chargement d’une variable de session dans un sousprogramme
 PL SQL

 Interactions avec la base

 Extraction de données
 Fonction SQL : disponibles dans un sous-programme, à condition de les
utiliser au sein d’une instruction SELECT
BEGIN
DECLARE v_plusGrandHVol DECIMAL(7,2);
SELECT MAX(nbHVol) INTO v_plusGrandHVol
FROM Pilote;
SELECT v_plusGrandHVol ;
END;
 PLSQL

 EXEMPLES

CREATE FUNCTION [Link](pcomp VARCHAR(4), pheuresVol

DECIMAL(7,2)) RETURNS SMALLINT
BEGIN
DECLARE resultat SMALLINT;
IF (pcomp IS NULL) THEN
SELECT COUNT(*) INTO resultat FROM Pilote WHERE nbHVol > pheuresVol;
ELSE
SELECT COUNT(*) INTO resultat FROM Pilote WHERE nbHVol > pheuresVol
AND comp =pcomp;
END IF;
RETURN resultat;
END;
 PLSQL

 EXEMPLES
CREATE PROCEDURE [Link] (INOUT pcomp VARCHAR(4),
OUT pnomPil VARCHAR(20), OUT pheuresVol DECIMAL(7,2))
BEGIN
DECLARE p1 SMALLINT;
IF (pcomp IS NULL) THEN
SELECT COUNT(*) INTO p1 FROM Pilote
WHERE nbHVol=(SELECT MAX(nbHVol) FROM Pilote);
ELSE
SELECT COUNT(*) INTO p1 FROM Pilote
WHERE nbHVol=(SELECT MAX(nbHVol) FROM Pilote WHERE com
p=pcomp)
AND comp = pcomp;
END IF;
IF (p1 = 0) THEN
SELECT ('Aucun pilote n''est le plus expérimenté') AS resultat;
ELSEIF p1 > 1 THEN
SELECT('Plusieurs pilotes sont les plus expérimentés') AS resultat;
…
 PLSQL

 Compilation
 En ligne de commande, il faut ajouter un délimiteur après chaque
dernier END
delimiter $
Sous programme ;
$

 Appel d’un sous-programme En ligne de commande

 La commande CALL permet d’appeler une procédure.
 Une fonction est exécutée par son nom dans une instruction SQL.