SQL & docker

BD/Lekpa/TP02/tp02_2.txt

@@ -139,12 +139,12 @@ BEGIN
     ELSIF UPDATING THEN
             OPEN c_attribut;
         LOOP
-        FETCH c_attribut INTO nom_colonne ;
+            FETCH c_attribut INTO nom_colonne ;
-        IF UPDATING(nom_colonne) THEN
+            IF UPDATING(nom_colonne) THEN
-               INSERT INTO CommandeAuditLog VALUES (USER, 'UDP', SYSDATE, nom_colonne);
+                INSERT INTO CommandeAuditLog VALUES (USER, 'UDP', SYSDATE, nom_colonne);
-        END IF;          
+            END IF;          
-    EXIT WHEN c_attribut%NOTFOUND;   
+            EXIT WHEN c_attribut%NOTFOUND;
-    END LOOP;
+        END LOOP;
-    CLOSE c_attribut;
+        CLOSE c_attribut;
     END IF;
 END combinedTrigger;

BD/Lekpa/TP_Note/Reponse.sql

@@ -0,0 +1,100 @@
+/*
+A
+Nom et prénom : Wamster alexis
+Groupe : 2
+Salle TP : 235
+Nom du voisin de gauche : DIMITRIJEVIC Hugo
+Nom du voisin de droite : Schnur Edouard
+*/
+
+/*Exercice 1*/
+
+Create or replace procedure update_COMM
+IS 
+    cursor comm_emp IS Select EMPNO,COMM from EMP;
+    e_comm EMP.COMM%TYPE;
+    e_empno EMP.EMPNO%TYPE;
+    comm_min EMP_SEUIL.COMM_MIN%TYPE;
+Begin
+    for v_comm in comm_emp
+    loop
+        e_comm := v_comm(comm_emp.COMM);
+        e_empno := v_comm(comm_emp.EMPNO);
+        select COMM_MIN into comm_min from EMP_SEUIL S, EMP E where E.EMPNO = e_empno AND S.JOB = E.JOB;
+        if (e_comm < comm_min) then
+            update EMP set COMM=comm_min where EMPNO=e_empno;
+        else if(e_comm = null) then
+            update EMP set COMM=comm_min where EMPNO=e_empno;
+        end if;
+    end loop;
+end;
+
+/*Exercice 2*/
+
+create or replace procedure insert_emp(empno EMP.EMPNO%TYPE, ename EMP.ENAME%TYPE, job EMP.JOB%TYPE, mgr EMP.MGR%TYPE, hiredate EMP.HIREDATE%TYPE, sal EMP.SAL%TYPE, comm EMP.COMM%TYPE, deptno EMP.DEPTNO%TYPE)
+is
+    comm_min EMP_SEUIL.COMM_MIN%TYPE;
+    nb_emp SUIVI_EMP.Nombre_Emp%TYPE;
+begin
+    select COMM_MIN into comm_min
+    from EMP_SEUIL S, EMP E
+    where E.EMPNO = empno AND S.JOB = E.JOB;
+
+    if (comm < comm_min) then
+        comm := comm_min;
+    else if(comm = null) then
+        comm := comm_min;
+    end if;
+  
+    insert into EMP values (empno, ename, job, mgr, hiredate, sal, comm, deptno);
+
+    select Nombre_Emp into nb_emp from SUIVI_EMP where DEPTNO=deptno;
+    nb_emp := nb_emp+1;
+    update SUIVI_EMP set Nombre_Emp=nb_emp where DEPTNO=deptno;
+
+    exception
+    WHEN OTHERS THEN
+        DBMS.OUTPUT.PUT_LINE('departemen inexisatant');
+
+end insert_emp;
+
+/*Exercice 3*/
+
+create or replace function salaire_moyen(job EMP.JOB%TYPE)
+    RETURN int
+    is
+        moyenne int;
+    begin
+        select AVG(SAL) into moyenne
+        from EMP
+        where JOB=job;
+    return moyenne
+end salaire_moyen;
+
+/*Test*/
+select distinct JOB, salaire_moyen(JOB) from emp;
+
+
+/*Exercice 4*/
+
+Create table EMP_HIS (
+    EMPID EMP.EMPNO%TYPE PRIMARY KEY,
+    ENAME EMP.JOB%TYPE,
+    JOB EMP.MGR%TYPE,
+    HIREDATE EMP.HIREDATE%TYPE,
+    DEPTNO EMP.DEPTNO%TYPE,
+    ENDDATE DEPT.DNAME%TYPE
+);
+
+CREATE OR REPLACE TRIGGER historique
+AFTER  DELETE
+ON EMP
+FOR EACH ROW
+DECLARE
+    dname DEPT.DNAME%TYPE;
+BEGIN
+    select DNAME into dname from DEPT where DEPTNO=DEPTNO:OLD;
+    insert into EMP_HIS values(EMPNO:OLD, JOB:OLD, MGR:OLD, HIREDATE:OLD, DEPTNO:OLD, dname);
+END historique;
+
+/*J'ai pas eu le temps de corriger les erreurs et de tester correctement*/

BD/Lekpa/TP_Note/TP_NOTE_FI_S3.sql

@@ -0,0 +1,84 @@
+DROP TABLE EMP_SEUIL;
+DROP TABLE SUIVI_EMP;
+DROP TABLE EMP;
+DROP TABLE DEPT;
+
+CREATE TABLE DEPT
+       (DEPTNO NUMBER(2) NOT NULL Primary Key,
+        DNAME VARCHAR2(14),
+        LOC VARCHAR2(13) );
+
+CREATE TABLE EMP
+       (EMPNO NUMBER(4) NOT NULL Primary Key,
+        ENAME VARCHAR2(10),
+        JOB VARCHAR2(9),
+        MGR NUMBER(4),
+        HIREDATE DATE,
+        SAL NUMBER(7, 2) check (sal > 0),
+        COMM NUMBER(7, 2) check (comm > 0),
+        DEPTNO NUMBER(2) References DEPT);
+
+create table Suivi_EMP (
+deptno number references dept,
+nombre_emp number);
+
+create table EMP_SEUIL (
+JOB VARCHAR2(9) NOT NULL Primary Key,
+COMM_MIN number);
+
+INSERT into EMP_SEUIL values ('CLERK',100);    
+INSERT into EMP_SEUIL values ('SALESMAN',1000); 
+INSERT into EMP_SEUIL values ('PRESIDENT',5000);
+INSERT into EMP_SEUIL values ('MANAGER',2000);  
+INSERT into EMP_SEUIL values ('ANALYST',200); 
+commit;
+
+INSERT INTO DEPT VALUES (10, 'ACCOUNTING', 'NEW YORK');
+INSERT INTO DEPT VALUES (20, 'RESEARCH',   'DALLAS');
+INSERT INTO DEPT VALUES (30, 'SALES',      'CHICAGO');
+INSERT INTO DEPT VALUES (40, 'OPERATIONS', 'BOSTON');
+commit;
+	
+
+INSERT INTO EMP VALUES (7369, 'SMITH',  'CLERK', 7902,  TO_DATE('17-12-1980', 'DD-MM-YYYY'),  800, NULL, 20);
+INSERT INTO EMP VALUES (7499, 'ALLEN',  'SALESMAN',  7698,  TO_DATE('20-02-1981', 'DD-MM-YYYY'), 1600,  300, 30);
+INSERT INTO EMP VALUES
+        (7521, 'WARD',   'SALESMAN',  7698,
+        TO_DATE('22-02-1981', 'DD-MM-YYYY'), 1250,  500, 30);
+INSERT INTO EMP VALUES
+        (7566, 'JONES',  'MANAGER',   7839, TO_DATE('2-04-1981', 'DD-MM-YYYY'),  2975, NULL, 20);
+INSERT INTO EMP VALUES (7654, 'MARTIN', 'SALESMAN',  7698, TO_DATE('28-09-1981', 'DD-MM-YYYY'), 1250, 1400, 30);
+INSERT INTO EMP VALUES
+        (7698, 'BLAKE',  'MANAGER',   7839,
+        TO_DATE('1-05-1981', 'DD-MM-YYYY'),  2850, NULL, 30);
+INSERT INTO EMP VALUES
+        (7782, 'CLARK',  'MANAGER',   7839,
+        TO_DATE('9-06-1981', 'DD-MM-YYYY'),  2450, NULL, 10);
+INSERT INTO EMP VALUES
+        (7788, 'SCOTT',  'ANALYST',   7566,
+        TO_DATE('09-12-1982', 'DD-MM-YYYY'), 3000, NULL, 20);
+INSERT INTO EMP VALUES(7839, 'KING',   'PRESIDENT', NULL,
+        TO_DATE('17-11-1981', 'DD-MM-YYYY'), 5000, NULL, 10);
+INSERT INTO EMP VALUES
+        (7844, 'TURNER', 'SALESMAN',  7698,
+        TO_DATE('8-09-1981', 'DD-MM-YYYY'),  1500,   10, 30);
+INSERT INTO EMP VALUES
+        (7876, 'ADAMS',  'CLERK',     7788,
+        TO_DATE('12-01-1983', 'DD-MM-YYYY'), 1100, NULL, 20);
+INSERT INTO EMP VALUES
+        (7900, 'JAMES',  'CLERK',     7698,
+        TO_DATE('3-12-1981', 'DD-MM-YYYY'),   950, NULL, 30);
+INSERT INTO EMP VALUES
+        (7902, 'FORD',   'ANALYST',   7566,
+        TO_DATE('3-12-1981', 'DD-MM-YYYY'),  3000, NULL, 20);
+INSERT INTO EMP VALUES
+        (7934, 'MILLER', 'CLERK',     7782,
+        TO_DATE('23-01-1982', 'DD-MM-YYYY'), 1300, NULL, 10);
+
+COMMIT;
+
+insert into suivi_emp select deptno, 0 from dept where deptno not in (select distinct deptno from emp);
+insert into suivi_emp select deptno, count(*) from emp group by deptno;
+commit;
+
+

BD/Lekpa/TP_Optimisation/reponse.txt

@@ -0,0 +1,122 @@
+tallend studio
+sql developper
+
+Se connecter au terminal:
+
+sqlplus "wamster@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host=lorien.arda.lan)(Port=1521))(CONNECT_DATA=(SID=ORCLIUT)))"
+
+
+
+Mettre a jour les statistiques des tables:
+
+EXEC DBMS_STATS.GATHER_TABLE_STATS(USER,'LIGNE_COMMANDE');
+EXEC DBMS_STATS.GATHER_TABLE_STATS(USER,'COMMANDE');
+EXEC DBMS_STATS.GATHER_TABLE_STATS(USER,'PRODUIT');
+EXEC DBMS_STATS.GATHER_TABLE_STATS(USER,'CLIENT');
+
+
+Verifier les statistiques:
+
+select TABLE_NAME, BLOCKS, EMPTY_BLOCKS, AVG_SPACE, CHAIN_CNT , AVG_ROW_LEN, SAMPLE_SIZE, LAST_ANALYZED FROM user_tables;
+
+    TABLE_NAME: Le nom de la table.
+    BLOCKS: Le nombre total de blocs de stockage utilisés par la table.
+    EMPTY_BLOCKS: Le nombre de blocs vides dans la table.
+    AVG_SPACE: L'espace moyen utilisé par chaque bloc de la table.
+    CHAIN_CNT: Le nombre de chaînes de migration dans la table. Les chaînes de migration se produisent lorsqu'une ligne ne peut pas tenir dans un seul bloc et doit être stockée dans plusieurs blocs.
+    AVG_ROW_LEN: La longueur moyenne des lignes de la table en octets.
+    SAMPLE_SIZE: La taille de l'échantillon utilisé pour collecter les statistiques sur la table.
+    LAST_ANALYZED: La date à laquelle les statistiques de la table ont été analysées pour la dernière fois.
+
+
+
+-------------------------------------------EXERCICE 2---------------------------------------------
+
+SET AUTOTRACE ON
+select * from commande where reference='008084';
+
+le sgbd accede directement à la donnée en lisant la table ligne par ligne
+
+      1 recursive calls:
+      Le nombre de fois où le système a effectué des appels récursifs. Ces appels sont généralement associés à des opérations internes du système de gestion de base de données (SGDB) et peuvent être liés à la gestion des verrous, à la gestion des transactions, etc.
+      
+      0 db block gets:
+      Le nombre de blocs de données récupérés à partir du cache de la base de données en mémoire (buffer cache). Cela représente le nombre de lectures logiques.
+     
+     23 consistent gets:
+     Le nombre de blocs de données récupérés de manière cohérente depuis le cache de la base de données en mémoire. Cela inclut les blocs qui ont été lus à partir du disque et ont également été modifiés dans le cache.
+      
+      0 physical reads:
+      Le nombre de lectures physiques effectuées depuis le disque. Cela représente le nombre de fois où des données ont dû être lues à partir du stockage physique, généralement parce qu'elles n'étaient pas présentes dans le cache.
+      
+      0 redo size:
+      La taille du journal de transactions (redo log) générée pendant l'exécution de la requête. Le journal de transactions enregistre les modifications apportées à la base de données et est utilisé pour la récupération en cas de panne.
+    
+    513 bytes sent via SQL*Net to client:
+    La quantité de données envoyées au client via le protocole SQL*Net.
+     
+     41 bytes received via SQL*Net from client:
+     La quantité de données reçues du client via le protocole SQL*Net.
+      
+      2 SQL*Net roundtrips to/from client:
+      Le nombre d'échanges de messages entre le client et le serveur via le protocole SQL*Net.
+      
+      0 sorts (memory):
+      Le nombre de tri effectué en mémoire. Cela peut se produire lorsqu'une requête nécessite un tri des données, et cela peut être plus efficace s'il peut être fait en mémoire.
+      
+      0 sorts (disk):
+      Le nombre de tri effectué sur le disque. Cela peut se produire si le tri ne peut pas être entièrement effectué en mémoire.
+      
+      1 rows processed:
+      Le nombre total de lignes traitées par la requête.
+
+en réexecutant, la recursive row passe de 1 à 0.
+c'est peut être car les ressources sont directement dispo dans le cache, ou que des optimisations internes du SGDB ont été faites.
+
+
+-------------------------------------------EXERCICE 3---------------------------------------------
+
+SELECT ID,
+ROWID,
+DBMS_ROWID.ROWID_RELATIVE_FNO(rowid) FICHIER,
+DBMS_ROWID.ROWID_BLOCK_NUMBER(rowid) BLOC,
+DBMS_ROWID.ROWID_ROW_NUMBER(rowid) NUMLIGNE
+FROM COMMANDE;
+
+ROWID permet de recuperer des infos sur le fichier le bloc et la ligne d'un tuple sql
+
+SELECT ID,
+ROWID,
+DBMS_ROWID.ROWID_RELATIVE_FNO(rowid) FICHIER,
+DBMS_ROWID.ROWID_BLOCK_NUMBER(rowid) BLOC,
+DBMS_ROWID.ROWID_ROW_NUMBER(rowid) NUMLIGNE
+FROM COMMANDE
+WHERE id=10;
+
+select * from commande where rowid='AAAncgAAFAABPKgAAh';
+
+Il n'y a qu'un bloc qui a été lu.
+On peut difficilement faire plus efficace. il n'y a que le recursive call qui peut diminuer.
+en réexecutant la requette il passe à 0.
+
+
+
+-------------------------------------------EXERCICE 4---------------------------------------------
+
+CREATE INDEX ix_reference ON COMMANDE(REFERENCE) ;
+
+EXEC DBMS_STATS.GATHER_INDEX_STATS('wamster','ix_reference');
+select ix_reference from COMMANDE;
+
+
+-------------------------------------------EXERCICE 5---------------------------------------------
+
+create index ix_prix_total on ligne_commande(PRIX_TOTAL) ;
+SELECT commande_id FROM LIGNE_COMMANDE WHERE PRIX_TOTAL>1000 ;
+SELECT commande_id FROM LIGNE_COMMANDE WHERE PRIX_TOTAL/2>500 ;
+
+la deuxième requete recupere plus de blocs dans le cache
+
+drop index ix_prix_total;
+
+-------------------------------------------EXERCICE 6---------------------------------------------

BD/Lekpa/TP_Optimisation2/DATA_COMMANDE_OPTIMISATION.sql

@@ -0,0 +1,269 @@
+
+--DROP TABLE ligne_commande ;
+--DROP TABLE commande ;
+--DROP TABLE client ;
+--DROP TABLE produit;
+
+--
+-- Table structure for table client
+--
+
+
+	CREATE TABLE client (
+	  id NUMBER(10)  NOT NULL ,
+	  prenom varchar2(255) NOT NULL,
+	  nom varchar2(255) NOT NULL,
+	  email varchar2(255) NOT NULL,
+	  ville varchar2(255) NOT NULL,
+	  PRIMARY KEY (id)
+	);
+
+
+CREATE TABLE commande (
+  id NUMBER(2)  NOT NULL ,
+  client_id NUMBER(10) ,
+  date_achat date NOT NULL,
+  reference varchar2(255) NOT NULL,
+  PRIMARY KEY (id)
+);
+
+
+CREATE TABLE produit (
+id NUMBER(2)	NOT NULL,
+nom_produit varchar2(255) NOT NULL,
+prix_unitaire NUMBER(10, 3) NOT NULL,
+PRIMARY KEY(id)
+);
+
+-- la table ligne commande contient pour une commande donnée, tous les produits achetés lors de cette commande
+CREATE TABLE ligne_commande (
+  id NUMBER(10)  NOT NULL ,
+  commande_id NUMBER(10) NOT NULL,
+  produit_id NUMBER(2)	NOT NULL,
+  quantite NUMBER(10) NOT NULL,
+  prix_total NUMBER(10, 3)  NOT NULL,
+  PRIMARY KEY (id)
+);
+
+
+
+
+--
+-- Dumping data for table client
+--
+REM INSERTING into client
+SET DEFINE OFF;
+
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (1, 'Flavie', 'Da costa', 'f.da.costa@example.com', 'Pomoy');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (2, 'Valentin', 'Vespasien', 'valentin@example.com', 'Buvilly');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (3, 'Gustave', 'Collin', 'gust@example.com', 'Marseille');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (4, 'Emilien', 'Camus', 'emilien@example.com', 'Toulouse');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (5, 'Firmin', 'Marais', 'firmin.marais@example.com', 'Lyon');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (6, 'Olivier', 'Riou', 'olive.de.lugagnac@example.com', 'Lugagnac');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (7, 'Lucas', 'Jung', 'lucas.jung@example.com', 'Coulgens');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (8, 'Maurice', 'Huet', 'maurice.villemareuil@example.com', 'Villemareuil');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (9, 'Manon', 'Durand', 'm.durand.s.e@example.com', 'Saint-Etienne');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (10, 'Joachim', 'Leon', 'joachim@example.com', 'Longwy-sur-le-Doubs');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (11, 'Muriel', 'Dupuis', 'muriel@example.com', 'Paris');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (12, 'Christiane', 'Riou', 'chritianelesabrets@example.com', 'Les Abrets');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (13, 'Jacinthe', 'Langlois', 'jacinthe.langlois@example.com', 'Lagney');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (14, 'Amaury', 'Payet', 'amaury@example.com', 'Avermes');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (15, 'Maris', 'Buisson', 'maris@example.com', 'Le Havre');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (16, 'Fabrice', 'Foucher', 'fab.montlouis@example.com', 'Montlouis');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (17, 'Patrick', 'Saunier', 'patrick.saunier@example.com', 'Saligney');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (18, 'Emile', 'Ramos', 'emile@example.com', 'Arzay');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (19, 'Armel', 'Vigneron', 'armel.delain@example.com', 'Delain');
+INSERT INTO client (id, prenom, nom, email, ville) VALUES (20, 'Arnaude', 'Vallee', 'armaude.vallee@example.com', 'Hostias');
+COMMIT;
+
+REM INSERTING into commande
+SET DEFINE OFF;
+
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (1, 20, TO_DATE('2019-01-01','YYYY-MM-DD'), '004214');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (2, 3, TO_DATE('2019-01-03','YYYY-MM-DD'), '007120');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (3, 11, TO_DATE('2019-01-04','YYYY-MM-DD'), '002957');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (4, 6, TO_DATE('2019-01-07','YYYY-MM-DD'), '003425');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (5, 17, TO_DATE('2019-01-08','YYYY-MM-DD'), '008255');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (6, 7, TO_DATE('2019-01-09','YYYY-MM-DD'), '000996');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (7, 2, TO_DATE('2019-01-10','YYYY-MM-DD'), '000214');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (8, 7, TO_DATE('2019-01-11','YYYY-MM-DD'), '008084');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (9, 12, TO_DATE('2019-01-11','YYYY-MM-DD'), '009773');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (10, 16, TO_DATE('2019-01-13','YYYY-MM-DD'), '004616');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (11, 4, TO_DATE('2019-01-14','YYYY-MM-DD'), '003757');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (12, 9, TO_DATE('2019-01-15','YYYY-MM-DD'), '004939');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (13, 14, TO_DATE('2019-01-16','YYYY-MM-DD'), '003421');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (14, 6, TO_DATE('2019-01-16','YYYY-MM-DD'), '002286');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (15, 3, TO_DATE('2019-01-17','YYYY-MM-DD'), '001167');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (16, 15, TO_DATE('2019-01-18','YYYY-MM-DD'), '008974');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (17, 9, TO_DATE('2019-01-19','YYYY-MM-DD'), '001369');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (18, 17, TO_DATE('2019-01-20','YYYY-MM-DD'), '009924');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (19, 3, TO_DATE('2019-01-21','YYYY-MM-DD'), '005510');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (20, 17, TO_DATE('2019-01-22','YYYY-MM-DD'), '007778');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (21, 17, TO_DATE('2019-01-23','YYYY-MM-DD'), '002359');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (22, 15, TO_DATE('2019-01-25','YYYY-MM-DD'), '008459');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (23, 4, TO_DATE('2019-01-27','YYYY-MM-DD'), '005217');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (24, 12, TO_DATE('2019-01-29','YYYY-MM-DD'), '000706');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (25, 9, TO_DATE('2019-02-01','YYYY-MM-DD'), '007879');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (26, 8, TO_DATE('2019-02-02','YYYY-MM-DD'), '007277');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (27, 11, TO_DATE('2019-02-02','YYYY-MM-DD'), '002745');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (28, 11, TO_DATE('2019-02-03','YYYY-MM-DD'), '001893');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (29, 20, TO_DATE('2019-02-04','YYYY-MM-DD'), '001230');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (30, 10, TO_DATE('2019-02-05','YYYY-MM-DD'), '000469');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (31, 7, TO_DATE('2019-02-05','YYYY-MM-DD'), '008653');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (32, 3, TO_DATE('2019-02-06','YYYY-MM-DD'), '001858');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (33, 14, TO_DATE('2019-02-07','YYYY-MM-DD'), '003330');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (34, 2, TO_DATE('2019-02-08','YYYY-MM-DD'), '001074');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (35, 5, TO_DATE('2019-02-08','YYYY-MM-DD'), '005379');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (36, 16, TO_DATE('2019-02-09','YYYY-MM-DD'), '003672');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (37, 10, TO_DATE('2019-02-09','YYYY-MM-DD'), '002220');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (38, 19, TO_DATE('2019-02-10','YYYY-MM-DD'), '000086');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (39, 8, TO_DATE('2019-02-11','YYYY-MM-DD'), '003770');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (40, 2, TO_DATE('2019-02-12','YYYY-MM-DD'), '008590');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (41, 2, TO_DATE('2019-02-12','YYYY-MM-DD'), '001639');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (42, 4, TO_DATE('2019-02-13','YYYY-MM-DD'), '002426');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (43, 13, TO_DATE('2019-02-14','YYYY-MM-DD'), '007209');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (44, 13, TO_DATE('2019-02-15','YYYY-MM-DD'), '008768');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (45, 7, TO_DATE('2019-02-16','YYYY-MM-DD'), '002213');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (46, 12, TO_DATE('2019-02-17','YYYY-MM-DD'), '004759');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (47, 19, TO_DATE('2019-02-18','YYYY-MM-DD'), '007155');
+INSERT INTO commande (id, client_id, date_achat, reference) VALUES (48, 2, TO_DATE('2019-02-19','YYYY-MM-DD'), '001496');
+COMMIT;
+
+REM INSERTING into Produit
+SET DEFINE OFF;
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (00, 'Produit0', 49.57);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (01, 'Produit1', 10.99);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (02, 'Produit2', 100.10);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (03, 'Produit3', 20);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (04, 'Produit4', 72.98);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (05, 'Produit5', 9);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (06, 'Produit6', 0.99);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (07, 'Produit7', 44.50);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (08, 'Produit8', 112);
+INSERT INTO Produit(id, nom_produit, prix_unitaire)  VALUES (09, 'Produit9', 5);
+COMMIT;
+
+REM INSERTING into ligne_commande
+SET DEFINE OFF;
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (1, 1, 01, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (2, 1, 09, 1,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (3, 1, 06, 2,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (4, 2, 05, 4,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (5, 2, 07, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (6, 3, 09, 7,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (7, 4, 03, 8,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (8, 4, 04, 10, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (9, 4, 07, 4,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (10, 4, 08, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (11, 4, 09, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (12, 5, 00, 10, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (13, 5, 07, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (14, 6, 01, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (15, 7, 06, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (16, 7, 07, 7,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (17, 7, 09, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (18, 8, 05, 9,  0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (19, 9, 07, 10, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (20, 10, 02, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (21, 10, 00, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (22, 10, 06, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (23, 10, 01, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (24, 11, 04, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (25, 12, 02, 1, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (26, 12, 09, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (27, 13, 03, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (28, 13, 00, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (29, 14, 01, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (30, 14, 00, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (31, 15, 07, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (32, 15, 02, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (33, 16, 02, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (34, 17, 03, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (35, 17, 06, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (36, 17, 04, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (37, 17, 01, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (38, 18, 04, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (39, 18, 01, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (40, 18, 03, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (41, 18, 02, 1, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (42, 19, 05, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (43, 20, 01, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (44, 20, 04, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (45, 20, 03, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (46, 21, 04, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (47, 21, 07, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (48, 22, 09, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (49, 22, 01, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (50, 22, 02, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (51, 22, 06, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (52, 22, 09, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (53, 23, 00, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (54, 23, 08, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (55, 23, 09, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (56, 24, 09, 1, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (57, 24, 08, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (58, 24, 05, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (59, 25, 00, 1, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (60, 25, 06, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (61, 26, 07, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (62, 27, 01, 1, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (63, 27, 04, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (64, 28, 05, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (65, 28, 03, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (66, 29, 09, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (67, 29, 02, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (68, 29, 06, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (69, 30, 00, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (70, 31, 03, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (71, 31, 00, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (72, 32, 03, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (73, 32, 05, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (74, 32, 02, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (75, 32, 01, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (76, 33, 00, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (77, 33, 06, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (78, 33, 03, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (79, 34, 05, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (80, 35, 02, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (81, 36, 03, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (82, 37, 06, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (83, 37, 01, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (84, 38, 01, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (85, 38, 02, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (86, 39, 01, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (87, 39, 07, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (88, 40, 06, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (89, 40, 03, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (90, 41, 08, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (91, 41, 06, 4, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (92, 42, 01, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (93, 42, 05, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (94, 43, 04, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (95, 43, 03, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (96, 44, 04, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (97, 44, 02, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (98, 44, 09, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (99, 44, 00, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (100, 44, 06, 4,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (101, 45, 00, 3,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (102, 45, 06, 2,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (103, 45, 05, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (104, 45, 07, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (105, 46, 04, 3, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (106, 46, 09, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (107, 46, 05, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (108, 46, 03, 8, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (109, 46, 02, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (110, 47, 06, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (111, 47, 08, 6, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (112, 47, 09, 10,0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (113, 47, 01, 2, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (114, 47, 03, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (115, 48, 04, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (116, 48, 02, 5, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (117, 48, 03, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (118, 48, 05, 9, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (119, 48, 09, 7, 0);
+INSERT INTO ligne_commande (id, commande_id, produit_id, quantite, prix_total) VALUES (120, 48, 06, 4, 0);
+COMMIT;
+

BD/Lekpa/TP_Optimisation2/Reponse.sql

@@ -0,0 +1,133 @@
+--Exercice 1
+
+CREATE INDEX ix_cl ON CLIENT(id);
+/*
+impossible d'inserer cet index parce que id est la clef primaire.
+et les clef primaire ont deja un index
+*/
+
+
+
+--Exercice 2
+
+SET AUTOTRACE ON
+SELECT * FROM LIGNE_COMMANDE WHERE COMMANDE_ID=46;
+--observation
+
+CREATE INDEX ix_commande_id ON LIGNE_COMMANDE (COMMANDE_ID,
+PRODUIT_ID) ;
+
+SET AUTOTRACE ON
+SELECT * FROM LIGNE_COMMANDE WHERE COMMANDE_ID=46;
+--observation: l'index est sur la colonne COMMANDE_ID donc c'est beaucoup plus efficace
+
+SELECT PRODUIT_ID FROM LIGNE_COMMANDE WHERE
+COMMANDE_ID = 46;
+--observation: l'index est sur la colonne COMMANDE_ID et PRODUIT_ID donc c'est beaucoup plus efficace
+
+DROP INDEX ix_commande_id;
+
+
+
+--Exercice 3
+
+SELECT cl.nom, SUM(lc.prix_total)
+FROM CLIENT cl
+INNER JOIN COMMANDE c ON c.client_id = cl.id
+INNER JOIN LIGNE_COMMANDE lc ON lc.commande_id = c.id
+GROUP BY cl.nom;
+
+SELECT cl.nom, SUM(lc.prix_total) FROM CLIENT cl INNER JOIN COMMANDE c ON c.client_id = cl.id INNER JOIN LIGNE_COMMANDE lc ON lc.commande_id = c.id GROUP BY cl.nom;
+
+--on utilise ici des hash join pour les jointures.
+--les tables sont lu integralement
+
+CREATE index test1 on COMMANDE(client_id);
+CREATE index test2 on LIGNE_COMMANDE(commande_id);
+
+DROP INDEX test1;
+DROP INDEX test2;
+
+
+
+--Exercice 4
+
+SELECT * FROM LIGNE_COMMANDE WHERE PRODUIT_ID IN (SELECT ID FROM PRODUIT WHERE PRIX_UNITAIRE>100);
+SELECT L.* FROM LIGNE_COMMANDE L JOIN PRODUIT P ON (L.PRODUIT_ID=P.ID) WHERE P.PRIX_UNITAIRE>100;
+--parreille 13 de cout et 46 de consistents get
+SELECT * FROM LIGNE_COMMANDE lc WHERE EXISTS (SELECT * FROM PRODUIT p WHERE p.id=lc.produit_id AND p.prix_unitaire > 100);
+-- 93 consistent gets
+
+--il doit y avoir une erreur quelque part. Mais voici du plus efficace au moins efficace:
+-- 1) EXISTS / NOT EXISTS
+-- 2) JOIN ON
+-- 3) WHERE IN
+
+
+
+--Exercice 5
+
+CREATE TABLE BIGBITMAP(
+    id NUMBER PRIMARY KEY,
+    nbitmap NUMBER,
+    date_insertion DATE
+);
+
+BEGIN
+for id in 0..300000 LOOP
+INSERT INTO BIGBITMAP VALUES
+( id,
+MOD(id,5) ,
+TO_DATE(sysdate, 'DD/MM/YYYY')
+);
+Commit;
+END LOOP;
+dbms_output.put_line ('100000 lignes inserees');
+END;
+
+CREATE INDEX ix_nbitmap_tree ON BIGBITMAP (nbitmap);
+DROP INDEX ix_nbitmap_tree;
+
+CREATE BITMAP INDEX ix_nbitmap_bitmap ON BIGBITMAP (nbitmap);
+DROP INDEX ix_nbitmap_bitmap;
+
+/*
+    218  recursive calls
+	0    db block gets
+    3741 consistent gets
+    1568 physical reads
+	  0  redo size
+	335  bytes sent via SQL*Net to client
+	 41  bytes received via SQL*Net from client
+	  2  SQL*Net roundtrips to/from client
+	  5  sorts (memory)
+	  0  sorts (disk)
+	  1  rows processed
+*/
+
+/*
+	  0  recursive calls
+	  0  db block gets
+       2558  consistent gets
+	  0  physical reads
+	  0  redo size
+	335  bytes sent via SQL*Net to client
+	 41  bytes received via SQL*Net from client
+	  2  SQL*Net roundtrips to/from client
+	  0  sorts (memory)
+	  0  sorts (disk)
+	  1  rows processed
+*/
+/*
+52  recursive calls
+	  0  db block gets
+	127  consistent gets
+	 35  physical reads
+	  0  redo size
+	335  bytes sent via SQL*Net to client
+	 41  bytes received via SQL*Net from client
+	  2  SQL*Net roundtrips to/from client
+	  0  sorts (memory)
+	  0  sorts (disk)
+	  1  rows processed
+*/

DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.java~

@@ -1,106 +0,0 @@
-/**
-   Il y a en fait pleins d'assertions possibles.
-
-   voici un exemple faisant un petit tour de ce qui est possible que j'ai pris ici.
-   https://github.com/junit-team/junit4/wiki/Assertions
-
-   NB. hamcrest est un projet maintenant intégré à junit
-   (c'est un anagrame de matchers)
-
- */
-
-import static org.hamcrest.CoreMatchers.allOf;
-import static org.hamcrest.CoreMatchers.anyOf;
-import static org.hamcrest.CoreMatchers.both;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.CoreMatchers.hasItems;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.sameInstance;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-
-import org.hamcrest.core.CombinableMatcher;
-import org.junit.Test;
-
-public class AssertTests {
-  @Test
-  public void testAssertArrayEquals() {
-    byte[] expected = "trial".getBytes();
-    byte[] actual = "trial".getBytes();
-    assertArrayEquals("failure - byte arrays not same", expected, actual);
-  }
-
-  @Test
-  public void testAssertEquals() {
-    assertEquals("failure - strings are not equal", "text", "text");
-  }
-
-  @Test
-  public void testAssertFalse() {
-    assertFalse("failure - should be false", false);
-  }
-
-  @Test
-  public void testAssertNotNull() {
-    assertNotNull("should not be null", new Object());
-  }
-
-  @Test
-  public void testAssertNotSame() {
-    assertNotSame("should not be same Object", new Object(), new Object());
-  }
-
-  @Test
-  public void testAssertNull() {
-    assertNull("should be null", null);
-  }
-
-  @Test
-  public void testAssertSame() {
-    Integer aNumber = Integer.valueOf(768);
-    assertSame("should be same", aNumber, aNumber);
-  }
-
-  // JUnit Matchers assertThat
-  @Test
-  public void testAssertThatBothContainsString() {
-    assertThat("albumen", both(containsString("a")).and(containsString("b")));
-  }
-
-  @Test
-  public void testAssertThatHasItems() {
-    assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
-  }
-
-  @Test
-  public void testAssertThatEveryItemContainsString() {
-    assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
-  }
-
-  // Core Hamcrest Matchers with assertThat
-  @Test
-  public void testAssertThatHamcrestCoreMatchers() {
-    assertThat("good", allOf(equalTo("good"), startsWith("good")));
-    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
-    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
-    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
-    assertThat(new Object(), not(sameInstance(new Object())));
-  }
-
-  @Test
-  public void testAssertTrue() {
-    assertTrue("failure - should be true", true);
-  }
-}

DEV/DEV2.3/TP02_JUnit/ex1/Calculator.java~

@@ -1,30 +0,0 @@
-
-/**
-   Calculator est une classe offrant une seule méthode qui évalue une somme, donnée sous la forme d'une chaîne de caractère listant des opérandes séparées par des +
-
-*/
-
-public class Calculator {
-
-    /**
-       somme les opérandes passées sous forme d'une chaîne de caractères et retourne le résultat sous forme d'entier.
-       @param expression : chaîne de caractères ("nombres" séparés par des + sans espaces), par exemple "42+3" ou encore "-42+42" (le moins unaire est autorisé).
-                           ici nombre est à comprendre au sens de  parseInt(java.lang.String)
-       @throws NumberFormatException : si l'expression n'est pas dans ce format (par exemple "x+2" ou " 1 +2" -- il y a des espaces -- ou encore "9999999990").
-     */    
-    public int evaluate(String expression) {
-        int sum = 0;
-        for (String summand: expression.split("\\+"))
-            sum += Integer.valueOf(summand);
-        return sum;
-    }
-
-    /**
-       Pour appeller cette super méthode depuis la ligne de commande (on ne regarde que le premier argument, les autres sont ignorés).
- 
-     */   
-    public static void main(String[] args) {
-        Calculator calculator = new Calculator();
-        System.out.println(calculator.evaluate(args[0]));
-    }
-}

DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.java~

@@ -1,18 +0,0 @@
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
-
-/**
-  CalculatorTest1 est un exemple de test pour la classe Calculator utilisant junit4.
-  Comment vérifier qu'on lance bien une exception?
- */
-
-public class CalculatorTest1 {
-
-    
-    // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
-    @Test(expected = NumberFormatException.class) 
-    public void doesNotEvaluateBadExpression() {
-        Calculator calculator = new Calculator();
-        int sum = calculator.evaluate("1 +2+3");//notez l'espace qui va génèrez une exception
-    }
-}

DEV/DEV2.3/TP02_JUnit/ex2/Largest.java~

@@ -1,18 +0,0 @@
-public class Largest {
- 
-  /**
-  * Return the largest element in a list.
-  *
-  * @param list A list of integers
-  * @return The largest number in the given list
-  */
-  public static int largest(int[] list) {
-    int index, max=Integer.MIN_VALUE;
-    for (index = 0; index <= list.length-1; index++) {
-      if (list[index] > max) {
-        max = list[index];
-      }
-    }
-    return max;
-  }
-}

DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.java~

@@ -1,10 +0,0 @@
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
- 
-public class TestLargest {
- 
-  @Test
-  public void testSimple() {
-    assertEquals(12, Largest.largest(new int[] {9,8,7,12}));
-  }
-}

DEV/DEV2.3/cm1/Reponses.txt

@@ -1,38 +0,0 @@
-// Il faut compléter les questions par vos réponses ci-dessous.
-
-========================================================================================
-Question 1.
-Quelle est la sanction disciplinaire encourrue en cas de triche à un TP noté à l'IUT?
-
-Votre réponse : sans doute un 0/20
-
-
-
-
-========================================================================================
-Question 2.
-Quelles sont la ou les commandes nécessaires pour lancer les tests permettant de debuguer pour la première partie du TP?
-
-Votre réponse :
-CLASSPATH=".:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
-javac -cp $CLASSPATH <fichierTest.java>
-java -cp $CLASSPATH org.junit.runner.JUnitCore <fichierTest.class>
-
-
-
-========================================================================================
-Question 3.
-Comment puis-je tester si une méthode retourne une exception avec JUnit?
-
-Votre réponse :en mettant des parenthèse derrière le @Test, avec l'erreur que l'on souhaite que la méthode retourne. voici un exemple plus parlant:
-@Test(expected = NullPointerException.class)
-
-
-
-
-
-
-
-
-
-========================================================================================

DEV/DEV2.3/cm1/TestsACompleterDirection.java

@@ -1,75 +0,0 @@
-import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
-import static org.junit.Assert.assertFalse; //
-import static org.junit.Assert.assertEquals; // 
-import org.junit.Test;
-
-import java.lang.StringBuilder;
-
-
-
-/**
- * Une classe pour faire des tests sur la classe MaMemoire avec JUnit
- */
-public class TestsACompleterDirection {
-
-
-    /**
-     * Test nord x vaut 0
-     */
-    @Test
-    public void Nordx(){
-        Direction d = Direction.NORD;
-        assertEquals(0,d.getDecalageX());
-
-    }
-
-    /**
-     * Test nord y vaut -1
-     */
-    @Test
-    public void Nordy(){
-      Direction d = Direction.NORD;
-      assertEquals(-1,d.getDecalageY()); //on constate que dans le fichier Direction.java, les
-    }
-
-    /**
-     * Test que reset retourne une NullPointerException
-     */
-    @Test(expected = NullPointerException.class)
-    public void ResetNPE(){
-		Direction.reset();
-    }
-
-
-    /**
-     * Test que l'on peut faire 64 fois un huitième de tour dans le sens trigonométrique et être au même endroit quand on part du Sud Est
-     */
-    @Test
-    public void whenIGetOlder(){
-		Direction d1 = Direction.SE;
-		Direction d2 = Direction.SE;
-		for (int i=0; i<64; i++){
-			d2 = d2.huitDeTour();
-		}
-		assertEquals(d1,d2);
-    }
-
-
-    /**
-     * Test que l'on peut faire 65 fois un huitième detour dans le sens antitrigonométrique et être au même endroit que si on faisait un anti huitième de tour quand on part du Sud Est
-     */
-    @Test
-    public void losingMyHair(){
-		Direction d1 = Direction.SE;
-		Direction d2 = Direction.SE;
-		for (int i=0; i<65; i++){
-			d2 = d2.huitDeTourAnti();
-		}
-		assertEquals(d1.huitDeTourAnti(),d2);
-    }
-
-    
-    
-
-    
-}

DEV/DEV2.3/cm3/Direction.java~

@@ -1,226 +0,0 @@
-import java.util.Objects;
-
-/**
- * La classe <code>Direction</code>, initialement utilisée pour signifier une orientation possible
- * parmi les quatre points cardinaux, a été transformée pour permettre de fabriquer une rose des vents à 8 directions.
- *  
- *   (y)
- *
- *   -1   NO    N    NE
- *
- *    0    O         E     
- *
- *    1   SO    S    SE
- *
- *        -1    0    1   (x)
- *
- * @version 1.2
- * @author Luc Hernandez, Florent Madelaine.
- */
-public class Direction {
-    
-    /**
-     * Constante pointant vers le nord (c'est à dire vers le haut de l'écran).
-     */
-    public static final Direction NORD = new Direction(+0, -1);///BUGFIX remplacé (0, 1) par (0, -1)
-
-    /**
-     * Constante pointant vers le Nord Ouest (c'est à dire la diagonale entre le haut et la gauche de l'écran).
-     */
-    public static final Direction NO = new Direction(-1, -1);
-    
-    /**
-     * Constante pointant vers l'ouest (c'est à dire vers la gauche de l'écran).
-     */
-    public static final Direction OUEST = new Direction(-1, +0);
-
-    /**
-     * Constante pointant vers le Sud Ouest (c'est à dire la diagonale entre le bas et la gauche de l'écran).
-     */
-    public static final Direction SO = new Direction(-1, +1);
-
-    /**
-     * Constante pointant vers le sud (c'est à dire vers le bas de l'écran).
-     */
-    public static final Direction SUD = new Direction(+0, +1);
-
-    /**
-     * Constante pointant vers le Sud Est (c'est à dire la diagonale vers le bas et la droite de l'écran).
-     */
-    public static final Direction SE = new Direction(+1, +1);
-    
-    /**
-     * Constante pointant vers l'est (c'est à dire vers la droite de l'écran).
-     */
-    public static final Direction EST = new Direction(+1, +0);
-
-    /**
-     * Constante pointant vers le Nord Est (c'est à dire la diagonale vers le haut et la droite de l'écran).
-     */
-    public static final Direction NE = new Direction(+1, -1);
-  
-  
-    /**
-     * Composante horizontale de la direction (-1, 0 ou 1).
-     */
-    private int decalageX;
-    
-    /**
-     * Composante verticale de la direction (-1, 0 ou 1).
-     */
-    private int decalageY;
-  
-    /**
-     * Constructeur uniquement destiné à la création des constantes publiques.
-     *
-     * @param x l'abcisse (-1, 0 ou 1)
-     * @param y l'ordonnée (-1, 0 ou 1)
-     */
-    private Direction(int x, int y) {
-        this.decalageX = x; //BUGFIX y par x
-        this.decalageY = y; //BUGFIX x par y
-    }
-  
-    /**
-     * Renvoie la composante horizontale de la direction.
-     *
-     * @return la composante horizontale de la direction (-1, 0 ou 1)
-     */
-    public int getDecalageX() {
-        return this.decalageX;
-    }
-  
-    /**
-     * Renvoie la composante verticale de la direction.
-     *
-     * @return la composante verticale de la direction (-1, 0 ou 1)
-     */
-    public int getDecalageY() {
-        return this.decalageY;
-    }
-
-    
-    private static Direction[] DirectionsInTrigOrder = { Direction.NORD, Direction.NE, Direction.EST, Direction.SE, Direction.SUD, Direction.SO, Direction.OUEST, Direction.NO};
-
-    /**
-     * Renvoie la direction produite par un décalage de un huitième de tour dans le sens horaire.
-     *
-     * @return la nouvelle direction
-     */
-    public Direction huitDeTour() { 
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i < this.DirectionsInTrigOrder.length - 1 par i< i < this.DirectionsInTrigOrder.length
-            if (this == this.DirectionsInTrigOrder[i])
-                return this.DirectionsInTrigOrder[(i+1) % this.DirectionsInTrigOrder.length]; //BUGFIX i+1%this.DirectionsInTrigOrder.length par (i+1)%this.DirectionsInTrigOrder.length
-        }
-        return null;
-    }
-
-    /**
-     * Renvoie la direction produite par un décalage d'un huitième de tour dans le sens anti-horaire.
-     *
-     * @return la nouvelle direction
-     */
-    public Direction huitDeTourAnti() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i+=2 par ++
-            if (this == this.DirectionsInTrigOrder[i]){ //BUGFIX {} par {return ...}
-                return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)];
-             }
-            
-        }
-        return null;
-    }
-
-    /**
-     * Renvoie la direction produite par un quart de tour dans le sens horaire.
-     *
-     * @return la nouvelle direction
-     */
-    public Direction quartDeTour() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i=1 par i=0
-            if (this == this.DirectionsInTrigOrder[i])
-                return this.DirectionsInTrigOrder[(i+2) % this.DirectionsInTrigOrder.length];
-                    
-        }
-        return null;
-    }
-
-    /**
-     * Renvoie la direction produite par un quart de tour dans le sens anti-horaire.
-     *
-     * @return la nouvelle direction
-     */
-    public Direction quartDeTourAnti() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) {
-            if (this == this.DirectionsInTrigOrder[i])// de i-1 à i
-                return this.DirectionsInTrigOrder[(i+6)%this.DirectionsInTrigOrder.length]; //BUGFIX remplacé i+8-2 par (i+6)%this.DirectionsInTrigOrder.length
-            
-        }
-        return null;
-    }
-
-
-    /**
-     * Renvoie la direction produite par un demi tour.
-     *
-     * @return la nouvelle direction
-     */
-    public Direction demiTour() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) {
-            if (this == this.DirectionsInTrigOrder[i]){
-                Direction d = this.DirectionsInTrigOrder[(i+4)% this.DirectionsInTrigOrder.length];
-                return d; //BUGFIX remplacé d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length] par d
-            }
-                    
-        }
-        return null;
-    }
-
-
-    
-    
-    // /**
-    //  * Renvoie la direction produite par un quart de tour dans le sens horaire.
-    //  *
-    //  * @return la nouvelle direction
-    //  */
-    // public Direction quartDeTour() {
-    //     if (this == Direction.NORD)
-    //         return Direction.EST;
-    //     else if (this == Direction.EST)
-    //         return Direction.SUD;
-    //     else if (this == Direction.SUD)
-    //         return Direction.OUEST;
-    //     else // if (this == Direction.OUEST)
-    //         return Direction.NORD;
-    // }
-    
-    // /**
-    //  * Renvoie la direction produite par un quart de tour dans le sens anti-horaire.
-    //  *
-    //  * @return la nouvelle direction
-    //  */
-    // public Direction quartDeTourAnti() {
-    //     if (this == Direction.NORD)
-    //         return Direction.OUEST;
-    //     else if (this == Direction.EST)
-    //         return Direction.NORD;
-    //     else if (this == Direction.SUD)
-    //         return Direction.EST;
-    //     else // if (this == Direction.OUEST)
-    //         return Direction.SUD;
-    // }
-
-
-    public String toString(){
-        return "(x: "+ this.decalageX + " ," + "y:"+ this.decalageY + ")";
-    }
-
- 
-    /**
-     * Méthode qui ne sert qu'à faire un exemple de méthode qui va renvoyer une exeption
-     */
-    public static void reset(){
-        Objects.requireNonNull(null, "On ne devrait pas faire comme ça");
-    }
-    
-}

DEV/DEV2.3/cm3/TestsACompleterDirection.java

@@ -68,6 +68,12 @@ public class TestsACompleterDirection {
 		assertEquals(d1.huitDeTourAnti(),d2);
     }
 
+    @Test
+    public void test1(){
+      boolean var = true;
+		assert(var);
+    }
+
     
     
 

DEV/DEV2.3/controle_original/Direction.java

@@ -22,7 +22,7 @@ public class Direction {
     /**
      * Constante pointant vers le nord (c'est à dire vers le haut de l'écran).
      */
-    public static final Direction NORD = new Direction(+0, -1);///BUGFIX remplacé (0, 1) par (0, -1)
+    public static final Direction NORD = new Direction(+0, 1);
 
     /**
      * Constante pointant vers le Nord Ouest (c'est à dire la diagonale entre le haut et la gauche de l'écran).
@@ -77,8 +77,8 @@ public class Direction {
      * @param y l'ordonnée (-1, 0 ou 1)
      */
     private Direction(int x, int y) {
-        this.decalageX = x; //BUGFIX y par x
+        this.decalageX = y;
-        this.decalageY = y; //BUGFIX x par y
+        this.decalageY = x;
     }
   
     /**
@@ -107,10 +107,10 @@ public class Direction {
      *
      * @return la nouvelle direction
      */
-    public Direction huitDeTour() { 
+    public Direction huitDeTour() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i < this.DirectionsInTrigOrder.length - 1 par i< i < this.DirectionsInTrigOrder.length
+        for (int i = 0; i < this.DirectionsInTrigOrder.length -1; i++) {
             if (this == this.DirectionsInTrigOrder[i])
-                return this.DirectionsInTrigOrder[(i+1) % this.DirectionsInTrigOrder.length]; //BUGFIX i+1%this.DirectionsInTrigOrder.length par (i+1)%this.DirectionsInTrigOrder.length
+                return this.DirectionsInTrigOrder[i+1 % this.DirectionsInTrigOrder.length];
         }
         return null;
     }
@@ -121,10 +121,9 @@ public class Direction {
      * @return la nouvelle direction
      */
     public Direction huitDeTourAnti() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i+=2 par ++
+        for (int i = 0; i < this.DirectionsInTrigOrder.length; i+=2) {
-            if (this == this.DirectionsInTrigOrder[i]){ //BUGFIX {} par {return ...}
+            if (this == this.DirectionsInTrigOrder[i]){}
-                return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)];
+                return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)];
-             }
             
         }
         return null;
@@ -136,7 +135,7 @@ public class Direction {
      * @return la nouvelle direction
      */
     public Direction quartDeTour() {
-        for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i=1 par i=0
+        for (int i = 1; i < this.DirectionsInTrigOrder.length; i++) {
             if (this == this.DirectionsInTrigOrder[i])
                 return this.DirectionsInTrigOrder[(i+2) % this.DirectionsInTrigOrder.length];
                     
@@ -151,8 +150,8 @@ public class Direction {
      */
     public Direction quartDeTourAnti() {
         for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) {
-            if (this == this.DirectionsInTrigOrder[i])// de i-1 à i
+            if (this == this.DirectionsInTrigOrder[i-1])
-                return this.DirectionsInTrigOrder[(i+6)%this.DirectionsInTrigOrder.length]; //BUGFIX remplacé i+8-2 par (i+6)%this.DirectionsInTrigOrder.length
+                return this.DirectionsInTrigOrder[(i+8-2)];
             
         }
         return null;
@@ -168,7 +167,7 @@ public class Direction {
         for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) {
             if (this == this.DirectionsInTrigOrder[i]){
                 Direction d = this.DirectionsInTrigOrder[(i+4)% this.DirectionsInTrigOrder.length];
-                return d; //BUGFIX remplacé d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length] par d
+                return d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length];
             }
                     
         }

DEV/DEV2.3/controle_original/Exemple.java

@@ -0,0 +1,38 @@
+/**
+ * Mise en oeuvre de la classe <code>Direction</code>, quit permet de manipuler une direction dans la rose des vents à 8 directions.
+ *  
+ *   (y)
+ *
+ *   -1   NO    N    NE
+ *
+ *    0    O         E     
+ *
+ *    1   SO    S    SE
+ *
+ *        -1    0    1   (x)
+ *
+ * @version 1.2
+ * @author  Florent Madelaine.
+ */
+
+public class Exemple{
+    
+    public static void main(String[] args) {
+        Direction d = Direction.NORD;
+        System.out.println(d.toString());
+        d = d.demiTour();
+        System.out.println(d.toString());
+        d = d.demiTour();
+        System.out.println(d.toString());
+        int i = 0;
+        System.out.println(i);
+        int j = i+8-1;
+        System.out.println(j);
+        int k = j % 8;
+        System.out.println(k);
+        int l = i-1;
+        System.out.println(l);
+        int m = l % 8;
+        System.out.println(m);
+    }
+}

DEV/DEV2.3/controle_original/README.md

@@ -0,0 +1,53 @@
+# TP noté sur les tests 
+
+## Fichiers mis à disposition
+Pour ce TP noté sur les tests, vous disposez des fichiers suivants
+
++ README.md                          ce fichier, qui vous indique ce qu'il faut faire.
++ **Direction.java**                 une classe java inspirée de celle à 4 directions de Luc Hernandez mais pour 8 directions.
++ Exemple.java                       des exemples d'uilisation de cette implémentation.
++ TestsFournisDirection.java         des tests fournis pour corriger Direction.java
++ **TestsACompleterDirection.java**  un fichier squelette de tests à compléter.
++ **Reponses.txt**                   un fichier texte à compléter
+
+Seuls les fichiers dont les noms sont **en gras** ci-dessus sont à compléter et à rendre.
+Pour les modalités, voir ci-dessous.
+
+## Avant la premioère partie : questions 
+aller compléter le fichier **Reponses.txt**
+
+## Première partie : debug 
+Un certains nombres de tests sont fournis. Vous ne devez pas changer ces derniers.
+Vous devez exécuter ces tests puis changer le code de la classe **Direction** idéalement jusqu'à ce que les tests fournis soient satisfaits.
+
+Chaque ligne de **Direction.java** changée devra être suivi du commentaire //BUGFIX éventuellement suivi de texte
+Si il y a plusieurs bugs sur la ligne, vous pouvez les indiquez l'un après l'autre.
+
+Par exemple : 
+Pour 1 bug
+> return (this.index); //BUGFIX enlevé +1
+Pour 2 bugs
+> if (a < b) { //BUGFIX remplacé <= par < //BUGFIX ajouté un crochet.
+
+**Attention** Le correcteur utilise grep pour corriger et il faut suivre exactement la consigne ci-dessus sans peine de voir son travail évalué à 0.
+
+## Seconde partie : test 
+Vous devez compléter le fichier **TestsACompleterDirection.java**
+Il n'est pas demandé de changer le code de **Direction.java** pour passer ces nouveaux tests.
+
+
+
+## Modalité de rendu 
+Vous devez rendre votre travail sur devoir
+l'url est :
+www.iut-fbleau.fr/site/site/DEVOIR/
+
+Il faut pour ce faire soumettre une archive tests.tar.gz **contenant uniquement les deux fichiers .java** (on ne veut pas les .class) suivants, édités par vos soins comme indiqué dans les questions ci-dessus :
+**Direction.java**
+**TestsACompleterDirection.java**
+**Reponses.txt**
+
+Pour ceux qui ont oublié comment faire :
+
+> bob@box:~$ tar czvvf tests.tar.gz Direction.java TestsACompleterDirection.java Reponses.txt 
+

DEV/DEV2.3/controle_original/TestsACompleterDirection.java

@@ -18,8 +18,9 @@ public class TestsACompleterDirection {
      */
     @Test
     public void Nordx(){
-        Direction d = Direction.NORD;
+        // au nord c'était les corons.
-        assertEquals(0,d.getDecalageX());
+
+        assertEquals(0,Direction.NORD.getDecalageX());
 
     }
 
@@ -28,8 +29,8 @@ public class TestsACompleterDirection {
      */
     @Test
     public void Nordy(){
-      Direction d = Direction.NORD;
+        assertEquals(-1,Direction.NORD.getDecalageY());
-      assertEquals(-1,d.getDecalageY());
+
     }
 
     /**
@@ -37,35 +38,24 @@ public class TestsACompleterDirection {
      */
     @Test(expected = NullPointerException.class)
     public void ResetNPE(){
-		Direction.reset();
+        Direction.reset();
+
     }
 
 
     /**
      * Test que l'on peut faire 64 fois un huitième de tour dans le sens trigonométrique et être au même endroit quand on part du Sud Est
      */
-    @Test
     public void whenIGetOlder(){
-		Direction d1 = Direction.SE;
+
-		Direction d2 = Direction.SE;
-		for (int i=0; i<64; i++){
-			d2 = d2.huitDeTour();
-		}
-		assertEquals(d1,d2);
     }
 
 
     /**
      * Test que l'on peut faire 65 fois un huitième detour dans le sens antitrigonométrique et être au même endroit que si on faisait un anti huitième de tour quand on part du Sud Est
      */
-    @Test
     public void losingMyHair(){
-		Direction d1 = Direction.SE;
+
-		Direction d2 = Direction.SE;
-		for (int i=0; i<65; i++){
-			d2 = d2.huitDeTour();
-		}
-		assertEquals(d1.huitDeTourAnti(),d2);
     }
 
     

DEV/DEV2.3/controle_original/TestsFournisDirection.java

@@ -0,0 +1,97 @@
+import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse; //
+import static org.junit.Assert.assertEquals; // 
+import org.junit.Test;
+
+import java.lang.StringBuilder;
+
+
+/**
+ * Une classe pour faire des tests sur la classe MaMemoire avec JUnit
+ */
+public class TestsFournisDirection {
+
+
+    /**
+     * Test quart de tour depuis nord donne l'est.
+     */
+    @Test
+    public void NordQuartDeTour(){
+        Direction d = Direction.NORD;
+        assertEquals(Direction.EST,d.quartDeTour());
+    }
+
+    /**
+     * Test huit de tour depuis nord donne le nord-est.
+     */
+    @Test
+    public void NordHuiDeTour(){
+        Direction d = Direction.NORD;
+        assertEquals(Direction.NE,d.huitDeTour());
+    }
+
+    /**
+     * Test deux demi-tours depuis nord.
+     */
+    @Test
+    public void NordDeuxDemiTour(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.demiTour().demiTour());
+    }
+
+    /**
+     * Test 4 quart-tours depuis nord.
+     */
+    @Test
+    public void NordQuatreQuartTour(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.quartDeTour().quartDeTour().quartDeTour().quartDeTour());
+    }
+
+    /**
+     * Test 1 huit-tour depuis nord suivi d'un huit tour anti.
+     */
+    @Test
+    public void NordAntiHuitHuit(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.huitDeTour().huitDeTourAnti());
+    }
+
+    /**
+     * Test 1 huit-tour anti depuis nord suivi d'un huit tour.
+     */
+    @Test
+    public void NordHuitAntiHuit(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.huitDeTourAnti().huitDeTour());
+    }
+
+    /**
+     * Test 1 quart-tour depuis nord suivi d'un quart tour anti.
+     */
+    @Test
+    public void NordAntiQuartQuart(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.quartDeTour().quartDeTourAnti());
+    }
+
+    /**
+     * Test 1 quart-tour anti depuis nord suivi d'un quart tour.
+     */
+    @Test
+    public void NordQuartAntiQuart(){
+        Direction d = Direction.NORD;
+        assertEquals(d,d.quartDeTourAnti().quartDeTour());
+    }
+
+    /**
+     * Test 1 huit-tour anti depuis nord donne le Nord Ouest.
+     */
+    @Test
+    public void NordAntiHuitTour(){
+        Direction d = Direction.NORD;
+        assertEquals(Direction.NE,d.huitDeTourAnti()); // parce qu'il faut bien un test pas très juste
+    }
+
+    
+}

DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java

@@ -8,4 +8,4 @@ public class Main{
 	Fenetre fenetre = new Fenetre();
 	fenetre.setVisible(true);
     }
-}
+}

DEV/DEV3.2/DEV32/1/Bulle.java

@@ -0,0 +1,39 @@
+public class Bulle{
+
+    public static <E> boolean bulle(File<E> pileRemplis, File<E> pileVide){
+        if (pileVide.isEmpty() == false){
+            throw new IllegalArgumentException("Erreur : l'argument pileVide n'est pas vide");
+        }
+
+        E max, v2;
+        boolean haveChangement = false;
+        if (pileRemplis.isEmpty() == false){
+            max = pileRemplis.dequeue();
+            while (pileRemplis.isEmpty() == false){
+                v2 = max;
+                max = pileRemplis.dequeue();
+                if (max < v2){ // changer cette ligne pour rendre les objet comparable
+                    pileVide.enqueue(max);
+                    max = v2;
+                    haveChangement = true;
+                }
+                else{
+                    pileVide.enqueue(v2);
+                }
+            }
+            pileVide.enqueue(max);
+        }
+        return haveChangement;
+    }
+
+    public static <E> File<E> tri(File<E> pile1){
+        File<E> pile2 = new File<>();
+        File<E> transition = null;
+        while (Bulle.bulle(pile1, pile2)){
+            transition = pile2;
+            pile2 = pile1;
+            pile1 = transition; 
+        }
+        return pile2;
+    }
+}

DEV/DEV3.2/DEV32/1/File.java

@@ -0,0 +1,22 @@
+import java.util.*;
+
+public class File<E>{
+
+    private Queue<E> file;
+
+    public File(){
+        this.file = new LinkedList<>();
+    }
+
+    public void enqueue(E valeur){
+        this.file.offer(valeur);
+    }
+
+    public E dequeue(){
+        return this.file.poll();
+    }
+
+    public boolean isEmpty(){
+        return this.file.isEmpty();
+    }
+}

DEV/DEV3.2/DEV32/1/Main.java

@@ -0,0 +1,43 @@
+public class Main{
+    public static void main(String[] args){
+        int[] tableauEntier = new int[args.length];
+        int i;
+        try{
+            //convertion en int
+            for (i=0; i<args.length; i++){
+                tableauEntier[i] = Integer.parseInt(args[i]);
+                if (tableauEntier[i] < 0){
+                    throw new NumberFormatException("Erreur : l'entier naturel saisis est negatif "+tableauEntier[i]);
+                }
+            }
+
+            //remplissage
+            File<Integer> fileRemplisBulle = new File<>();
+            File<Integer> fileRemplisTri = new File<>();
+            File<Integer> fileVide = new File<>();
+            for (int entier : tableauEntier){
+                fileRemplisBulle.enqueue(entier);
+                fileRemplisTri.enqueue(entier);
+            }
+
+            // methode bulle
+            Bulle.bulle(fileRemplisBulle, fileVide);
+            System.out.print("Bulle : ");
+            while (fileVide.isEmpty() == false){
+                System.out.print(fileVide.dequeue() + " ");
+            }
+            System.out.println();
+
+            //methode tri
+            Bulle.tri(fileRemplisTri);
+            System.out.print("Tri : ");
+            while (fileRemplisTri.isEmpty() == false){
+                System.out.print(fileRemplisTri.dequeue() + " ");
+            }
+            System.out.println();
+        }
+        catch(NumberFormatException e){
+            System.out.println("argument invalide");
+        }
+    }
+}