Exercices sur les fonctions qui divergent d`Oracle

Exercices sur les fonctions qui divergent d’Oracle
Toutes les questions devront être réalisées sous ORACLE et Postgres
a) Manipulations
ex_1.sql, out_1.sql
Décrivez la structure détaillée des tables de votre base.
requete :
emacs ex_1.sql
\d+
en sortie :
\o out_1.sql
\d+
\o
ex_2.sql, out_2.sql
Décrivez la structure de la table étudiants.
requete :
emacs ex_2.sql
\d etudiants ;
en sortie :
\o out_2.sql
\d etudiants ;
\o
b) fonction DECODE
ex_3.sql, out_3.sql
Listez pour chaque étudiant, le nom, le prénom et un champ appelé qui aura pour alias
‘CALC’ et qui sera obtenu comme suit :
Si le nom est par exemple SPANNAGEL et le prénom est loïc, le champ ‘CALC’ sera SIX_L.
Partant du fait qu’il y a 6 caractères ou plus dans le nom, le champ ‘CALC’ commence par
SIX. Si le nom est par exemple SAIDI et le prénom est mouhssine, le champ ‘CALC’ sera
CINQ_M. Le résultat est à ordonner selon le champ ‘CALC’.
POSTGRES :
SELECT nom, prenom, note,
CASE WHEN note >= 11 and note <= 13 THEN '
ASSEZ_BIEN'
WHEN note >= 14 and note <= 17 THEN '
BIEN'
WHEN note >= 18 and note <= 20 THEN '
EXCELLENT'END
as "CMT" from etudiants, obtenir_note
where etudiants.identif = obtenir_note.identif
order by note, nom, prenom;
requete :
\w ex_3.sql
en sortie :
\g out_3.sql
ORACLE :
SELECT nom, prenom, note,
decode(note,11,'ASSEZ_BIEN',
12,'ASSEZ_BIEN',
13,'ASSEZ_BIEN',
14,'BIEN',
15,'BIEN',
16,'BIEN',
17,'BIEN',
18,'EXCELLENT',
19,'EXCELLENT',
20,'EXCELLENT')
as "CMT" from etudiants, obtenir_note
where etudiants.identif = obtenir_note.identif
order by note, nom, prenom;
ex_4.sql, out_4.sql
Affichez le nom, le prénom, la note, ainsi qu’un champ commentaire qui aura pour alias
‘CMT’ (qui sera défini par la règle qui suit) pour les étudiants ayant obtenus des notes dans
n’importe quel examen (il suffit que l’étudiant figure dans la table obtenir_note).
Le résultat est à ordonner par note, puis nom, puis prénom.
Si 11 <= Note <= 13 => Le commentaire est: ‘ASSEZ_BIEN’
Si 14 <= Note <= 17 => Le commentaire est: ‘BIEN’
Si 18 <= Note <= 20 => Le commentaire est: ‘EXCELLENT’
POSTGRES :
SELECT nom, prenom,
CASE WHEN length(nom) = 1 THEN '
UN_'
WHEN length(nom) = 2 THEN '
DEUX_'
WHEN length(nom) = 3 THEN '
TROIS_'
WHEN length(nom) = 4 THEN '
QUATRE_'
WHEN length(nom) = 5 THEN '
CINQ_'
ELSE '
SIX_'END || UPPER(substr(prenom,1,1))
as "CALC" from etudiants
order by "CALC";
requete :
\w ex_4.sql
en sortie :
\g out_4.sql
ORACLE :
SELECT nom, prenom,
decode( length(nom),1,'
UN_'
,
2,'
DEUX_'
,
3,'
TROIS_'
,
4,'
QUATRE_'
,
5, '
CINQ_'
,
'
SIX_'
)
|| UPPER(substr(prenom,1,1))
"CALC" from etudiants
order by "CALC";
c) fonction NVL (modifier dans le script pour que la requête marche)
ex_5.sql, out_5.sql
Donnez la liste des étudiants (identifiant, nom, prénom) qui n’ont jamais eu (obtenu) un zéro
tout examens confondus, en mettant le commentaire « absent » si l’étudiant n’a pas de note
pour cette exam.
Ordonnez le résultat par l’identifiant étudiant.
POSTGRES :
select e.identif, e.nom, e.prenom, COALESCE(TO_CHAR(o.note, '
99'
), '
Absent'
)
from etudiants e, obtenir_note o
where e.identif = o.identif
and o.note <> 0
order by e.identif;
ORACLE :
select e.identif, e.nom, e.prenom, NVL(TO_CHAR(o.note, '
99'
), '
Absent'
)
from etudiants e, obtenir_note o
where e.identif = o.identif
and o.note <> 0
order by e.identif;
ex_6.sql, out_6.sql
Donnez la moyenne obtenue par les étudiants, sachant que celle-ci est égale au rapport de la
somme des notes obtenues aux examens par le nombre d’examens passés par cet étudiant.
Ordonner le résultat par l’identifiant étudiant.
POSTGRES :
select e.identif,sum(COALESCE(obn.note,0))/count(COALESCE (obn.note,1)) as "MOY"
from examens ex,obtenir_note obn,etudiants e
where e.identif = obn.identif
and obn.code_exam = ex.code_exam
group by e.identif;
ORACLE :
select e.identif,sum(nvl(obn.note,0))/count(nvl(obn.note,1))
from examens ex,obtenir_note obn,etudiants e
where e.identif = obn.identif
and obn.code_exam = ex.code_exam
group by e.identif;
d) fonctions ADD_MONTHS / ADD_DAYS
ex_7.sql, out_7.sql
Le directeur de l’école vous demander de lui faire des statistiques sur les examens. Il aimerait
reculer les examens de 6mois. En affichant le libelle exam et le champ « Stat » qui va contenir
votre calcul.
POSTGRES :
Pas de function ADD_MONTHS sous postgres on suppose alors qu’un mois fait 30 jours
D’ou
Select LIBELLE_EXAM, TO_DATE(DATE_EXAM , '
MM/DD/YYYY'
)+180 "Stat" from examens;
requete :
\w ex_7.sql
en sortie :
\g out_7.sql
ORACLE :
Select LIBELLE_EXAM, add_months(TO_DATE(DATE_EXAM , '
MM/DD/YYYY'
), 6) "Stat" from examens;
e) fonction TO_CHAR (formatage de sortie)
ex_8.sql, out_8.sql
Déplacer tous les cours de 10 jours et afficher le code cours, la date a laquelle il se déroulera
et l’heure sous la forme :
‘Le cours 9 a lieu le Lundi 13 Mai 2002 de 09:00 heure a 12:00 heure.’
POSTGRES :
Select '
Le cours '|| code_cours || 'a lieu le '
|| to_char(TO_DATE(date_cours , '
DD/MM/YYYY'
)+ 10 , '
fmDay dd Month yyyy "de" '
)
|| heure_deb || 'heure a '|| heure_fin || 'heure.'
from cours;
ORACLE :
Select '
Le cours '|| code_cours || 'a lieu le '
|| to_char(TO_DATE(date_cours , '
DD/MM/YYYY'
)+ 10 , '
fmDay dd Month yyyy "de" '
)
|| heure_deb || 'heure a '|| heure_fin || 'heure.'
from cours;
f) Tables virtuelles
ex_9.sql, out_9.sql
Affichez les promotion(s) (tous les champs) qui ont le plus grand nombre d’examens à
l’année pour toutes matières confondues.
Ordonnez de manière dégressive le résultat par code promo.
POSTGRES :
Select promotions.* from promotions,
(Select code_promo from est_suivi_par
group by est_suivi_par.code_promo
having sum(nbr_exam_an)
= (select max(xx.su) from (select sum(nbr_exam_an) as su
from est_suivi_par group by code_promo) as xx )) as tt
where tt.code_promo = promotions.code_promo
order by promotions.code_promo desc;
requete :
\w ex_9.sql
en sortie :
\g out_9.sql
ORACLE :
select * from promotions
where code_promo IN (select code_promo from est_suivi_par
having sum(nbr_exam_an) = (select max(sum(nbr_exam_an)) from
est_suivi_par group by code_promo)
group by code_promo)
order by code_promo DESC;
ex_10.sql, out_10.sql
Donnez le nombre moyen d'
examens prévus par matière toutes promotions confondues.
Affichez le code matière et utilisez l'
alias ‘NPEX’ pour le champ
Calculé, le résultat est à ordonner par matière (code matière).
POSTGRES :
select xx.code_mat, avg(xx.NPEX) as "NPEX"
from etudiants , (select code_grp, code_mat,count(code_exam) as NPEX
from planifier group by code_mat, code_grp) as xx
where etudiants.code_grp = xx.code_grp
group by xx.code_mat
order by xx.code_mat;
requete :
\w ex_10.sql
en sortie :
\g out_10.sql
ORACLE :
select xx.code_mat, avg(xx.NPEX) as "NPEX"
from etudiants , (select code_grp, code_mat,count(code_exam) as NPEX
from planifier group by code_mat, code_grp) xx
where etudiants.code_grp = xx.code_grp
group by xx.code_mat
order by xx.code_mat;
g) Implémentation de séquences dans une table.
ex_11.sql, out_11.sql
Créez la table ‘PRFDS’, qui est une copie de la table Professeurs avec une colonne
supplémentaire ‘DDE’ correspondant à la date d’embauche, celle-ci sera par défaut initialisée
à la date du jour (une seule requête).
En fichier de sortie, afficher tous les enregistrements de la table PRFDS
POSTGRES :
create table "PRFDS" as (select code_prof, nom_prof, type, email_prf, current_date as "DDE" from professeurs
);
ou ce qui est identique :
create table "PRFDS" as (select p.* , current_date as "DDE" from professeurs p );
en sortie :
select * from "PRFDS" ;
\g out_11.sql
ORACLE :
Idem
ex_12.sql, out_12.sql
Puis créez une séquence ‘SQ_PRF’ allant de 100 à 1000, s'
incrémentant de 10.
Afficher tous les champs de votre séquence en fichier de sortie.
POSTGRES :
create sequence "SQ_PRF" increment 10 minvalue 100 maxvalue 1000 start 100;
en sortie :
select * from "SQ_PRF" ;
\g out_12.sql
ORACLE :
idem
ex_13.sql, out_13.sql
A la fin modifiez la table ‘PRFDS’ pour qu’à chaque fois que l'
on insère une donnée dans la
table, la clef primaire utilise la séquence comme valeur.
En fichier de sortie décrivez la structure de la table ‘PRFDS’.
POSTGRES :
alter table "PRFDS" alter column code_prof set default nextval('
"SQ_PRF"'
);
en sortie :
\o out_13.sql
\d "PRFDS"
\o
ORACLE :
alter table "PRFDS" alter column code_prof set default SQ_PRF.nextval();
ex_14.sql, out_14.sql
Créez la table ‘ETUD’, qui est une copie de la table étudiants.
En fichier de sortie afficher tous les enregistrements de la table ETUD
POSTGRES :
create table "ETUD" as (select * from etudiants);
\o out_13.sql
Select * from "ETUD";
\o
ORACLE :
IDEM
ex_15.sql, out_15.sql
Puis créez une séquence ‘SQ_ETUD’ allant de 200 a 1000, s'
incrémentant de 4.
Afficher tous les champs de votre séquence en fichier de sortie.
POSTGRES :
create sequence "SQ_ETUD" increment 4 minvalue 200 maxvalue 1000 start 200;
en sortie
select * from "SQ_ETUD" ;
\g out_12.sql
ORACLE :
Idem
ex_16.sql, out_16.sql
A la fin modifiez la table ‘ETUD’ pour qu’à chaque fois que l'
on insère une donnée dans la
table, la clef primaire utilise la séquence comme valeur.
En fichier de sortie décrivez la structure de la table ‘ETUD’.
POSTGRES :
alter table "ETUD" alter column code_etud set default nextval('
"SQ_ETUD"'
);
\o out_16.sql
\d "ETUD"
\o
ORACLE :
alter table "PRFDS" alter column code_prof set default SQ_ETUD.nextval();
h) Clause LIMIT nbr OFFSET start
ex_17.sql, out_17.sql
Afficher les étudiants (identif, nom, prénom) classés par groupe (code groupe) puis par
identifiant et limitez le résultat a l’affichage de la ligne 10 à la ligne 15
POSTGRES :
SELECT identif, nom, prenom, code_grp
from etudiants
order by code_grp, identif
limit 5 OFFSET 9 ;
\g out_17.sql
ORACLE :
Existe pas