diff --git a/DATA_COMMANDE_OPTIMISATION.sql b/DATA_COMMANDE_OPTIMISATION.sql
index 1258321..fc8df82 100644
--- a/DATA_COMMANDE_OPTIMISATION.sql
+++ b/DATA_COMMANDE_OPTIMISATION.sql
@@ -1,8 +1,8 @@
---DROP TABLE ligne_commande ;
---DROP TABLE commande ;
---DROP TABLE client ;
---DROP TABLE produit;
+DROP TABLE ligne_commande4 ;
+DROP TABLE commande4 ;
+DROP TABLE client4 ;
+DROP TABLE produit4;
--
-- Table structure for table client
diff --git a/TPS2_Index.txt b/TPS2_Index.txt
index 321e575..bc0c331 100644
--- a/TPS2_Index.txt
+++ b/TPS2_Index.txt
@@ -1,4 +1,4 @@
-sqlplus "username@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host=lorien.arda.lan)(Port=1521))(CONNECT_DATA=(SID=ORCLIUT)))"
+sqlplus "raban@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host=lorien.arda.lan)(Port=1521))(CONNECT_DATA=(SID=ORCLIUT)))"
select index_name from user_indexes where index_name not like 'SYS%’ and table_name =
'EMP’;
@@ -378,48 +378,934 @@ Index dropped.
Exo 3 :
1)
-SELECT c.NOM, SUM(l.MONTANT) AS MONTANT_TOTAL
+EXPLAIN PLAN FOR
+SQL> SELECT c.NOM, SUM(l.PRIX_TOTAL) AS MONTANT_TOTAL
FROM CLIENT4 c
JOIN COMMANDE4 co ON c.CLIENT_ID = co.CLIENT_ID
JOIN LIGNE_COMMANDE4 l ON co.COMMANDE_ID = l.COMMANDE_ID
GROUP BY c.CLIENT_ID, c.NOM;
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Vallee
+ 0
+
+Jung
+ 0
+
+Buisson
+ 0
+
+
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Riou
+ 0
+
+Payet
+ 0
+
+Leon
+ 0
+
+
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Riou
+ 0
+
+Vespasien
+ 0
+
+Foucher
+ 0
+
+
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Camus
+ 0
+
+Durand
+ 0
+
+Dupuis
+ 0
+
+
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Huet
+ 0
+
+Marais
+ 0
+
+Collin
+ 0
+
+
+NOM
+--------------------------------------------------------------------------------
+MONTANT_TOTAL
+-------------
+Saunier
+ 0
+
+Langlois
+ 0
+
+Vigneron
+ 0
+
+
+18 rows selected.
+
2)
-plan d'exécution :
-Après avoir exécuté la requête, observez le plan d'exécution. Vous devriez y voir :
- Une jointure entre la table CLIENT et COMMANDE sur la colonne CLIENT_ID.
- Une autre jointure entre COMMANDE et LIGNE_COMMANDE sur la colonne COMMANDE_ID.
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 1660592450
-Méthode de jointure : Le type de jointure utilisé (par exemple, Nested Loop Join, Merge Join, Hash Join) dépend de plusieurs facteurs, notamment de l'ordre des tables dans la requête et de la présence ou non d'index. Si les données sont très volumineuses, un Hash Join ou Merge Join pourrait être préféré pour une meilleure performance.
+--------------------------------------------------------------------------------
+--------
-Accès aux données :
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Ti
+me |
+
+--------------------------------------------------------------------------------
+--------
+
+| 0 | SELECT STATEMENT | | 120 | 23280 | 20 (10)| 00
+:00:01 |
+
+| 1 | HASH GROUP BY | | 120 | 23280 | 20 (10)| 00
+:00:01 |
+
+|* 2 | HASH JOIN | | 120 | 23280 | 19 (6)| 00
+:00:01 |
+
+| 3 | TABLE ACCESS FULL | CLIENT4 | 20 | 2840 | 6 (0)| 00
+:00:01 |
+
+|* 4 | HASH JOIN | | 120 | 6240 | 13 (8)| 00
+:00:01 |
+
+| 5 | TABLE ACCESS FULL| COMMANDE4 | 48 | 1248 | 6 (0)| 00
+:00:01 |
+
+| 6 | TABLE ACCESS FULL| LIGNE_COMMANDE4 | 120 | 3120 | 6 (0)| 00
+:00:01 |
+
+--------------------------------------------------------------------------------
+--------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 2 - access("C"."CLIENT_ID"="CO"."CLIENT_ID")
+ 4 - access("CO"."COMMANDE_ID"="L"."COMMANDE_ID")
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+
+Statistics
+----------------------------------------------------------
+ 0 recursive calls
+ 0 db block gets
+ 66 consistent gets
+ 0 physical reads
+ 0 redo size
+ 703 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 0 sorts (memory)
+ 0 sorts (disk)
+ 18 rows processed
- Si des index existent, la base de données pourrait utiliser des Index Seek pour accéder aux lignes spécifiques, ce qui améliore l'efficacité.
- Sans index, des Full Table Scans pourraient être effectués, ce qui est moins optimal.
3)
- Index sur CLIENT_ID dans la table CLIENT pour accélérer la jointure avec la table COMMANDE.
- Index sur COMMANDE_ID dans la table LIGNE_COMMANDE pour accélérer la jointure avec la table COMMANDE.
- Index composite sur (CLIENT_ID, NOM) dans la table CLIENT pour optimiser la recherche des clients et faciliter le groupement par CLIENT_ID.
-
-Les requêtes pour créer ces index :
-
-CREATE INDEX ix_client_id ON CLIENT(CLIENT_ID);
-CREATE INDEX ix_commande_id ON COMMANDE(COMMANDE_ID);
-CREATE INDEX ix_ligne_commande_commande_id ON LIGNE_COMMANDE(COMMANDE_ID);
-CREATE INDEX ix_client_id_nom ON CLIENT(CLIENT_ID, NOM);
+CREATE INDEX ix_ligne_commande_commande_id ON LIGNE_COMMANDE4(COMMANDE_ID);
+CREATE INDEX ix_client_id_nom ON CLIENT4(CLIENT_ID, NOM);
4)
-Après avoir créé les index, réexécutez la requête et examinez à nouveau le plan d'exécution. Vous devriez observer les points suivants :
+SQL> EXPLAIN PLAN FOR
+SELECT c.NOM, SUM(l.PRIX_TOTAL) AS MONTANT_TOTAL
+FROM CLIENT4 c
+JOIN COMMANDE4 co ON c.CLIENT_ID = co.CLIENT_ID
+JOIN LIGNE_COMMANDE4 l ON co.COMMANDE_ID = l.COMMANDE_ID
+GROUP BY c.CLIENT_ID, c.NOM; 2 3 4 5 6
- Utilisation des index : L'optimiseur de la base de données devrait désormais utiliser les index pour accéder plus rapidement aux tables, ce qui peut conduire à des Index Seek plutôt qu'à des Full Table Scans.
- Amélioration des performances : Les statistiques devraient indiquer une amélioration significative du temps d'exécution de la requête si les index sont utilisés de manière efficace. Vous pouvez aussi vérifier les Coûts associés aux différentes étapes dans le plan d'exécution, qui devraient être plus bas.
+Explained.
+
+SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+Plan hash value: 1589693907
+
+--------------------------------------------------------------------------------
+-----------------------
+
+| Id | Operation | Name | Rows | Bytes |
+Cost (%CPU)| Time |
+
+--------------------------------------------------------------------------------
+-----------------------
+
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+| 0 | SELECT STATEMENT | | 120 | 23280 |
+ 10 (20)| 00:00:01 |
+
+| 1 | HASH GROUP BY | | 120 | 23280 |
+ 10 (20)| 00:00:01 |
+
+|* 2 | HASH JOIN | | 120 | 23280 |
+ 9 (12)| 00:00:01 |
+
+| 3 | TABLE ACCESS FULL | LIGNE_COMMANDE4 | 120 | 3120 |
+ 6 (0)| 00:00:01 |
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+
+| 4 | TABLE ACCESS BY INDEX ROWID| COMMANDE4 | 2 | 52 |
+ 1 (0)| 00:00:01 |
+
+| 5 | NESTED LOOPS | | 48 | 8064 |
+ 2 (0)| 00:00:01 |
+
+| 6 | INDEX FULL SCAN | IX_CLIENT_ID_NOM | 20 | 2840 |
+ 1 (0)| 00:00:01 |
+
+|* 7 | INDEX RANGE SCAN | IX_COMMANDE_CLIENT_ID | 2 | |
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+ 0 (0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+-----------------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 2 - access("CO"."COMMANDE_ID"="L"."COMMANDE_ID")
+ 7 - access("C"."CLIENT_ID"="CO"."CLIENT_ID")
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+24 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 2137789089
+
+--------------------------------------------------------------------------------
+-------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU
+)| Time |
+
+--------------------------------------------------------------------------------
+-------------
+
+| 0 | SELECT STATEMENT | | 2024 | 4048 | 18 (0
+)| 00:00:01 |
+
+| 1 | COLLECTION ITERATOR PICKLER FETCH| DISPLAY | | |
+ | |
+
+--------------------------------------------------------------------------------
+-------------
+
+
+
+Statistics
+----------------------------------------------------------
+ 19 recursive calls
+ 24 db block gets
+ 74 consistent gets
+ 0 physical reads
+ 0 redo size
+ 2077 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 1 sorts (memory)
+ 0 sorts (disk)
+ 24 rows processed
+
+
+
+SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);
5)
+DROP INDEX ix_ligne_commande_commande_id;
+DROP INDEX ix_client_id_nom;
-DROP INDEX ix_client_id ON CLIENT;
-DROP INDEX ix_commande_id ON COMMANDE;
-DROP INDEX ix_ligne_commande_commande_id ON LIGNE_COMMANDE;
-DROP INDEX ix_client_id_nom ON CLIENT;
\ No newline at end of file
+Exo 4 :
+
+1)
+
+SQL> SELECT lc.*
+FROM LIGNE_COMMANDE lc
+WHERE PRODUIT_ID IN (SELECT ID FROM PRODUIT WHERE PRIX_UNITAIRE > 100); 2 3
+
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 10 4 8 9 0
+ 20 10 2 2 0
+ 25 12 2 1 0
+ 32 15 2 8 0
+ 33 16 2 4 0
+ 41 18 2 1 0
+ 50 22 2 9 0
+ 54 23 8 9 0
+ 57 24 8 4 0
+ 67 29 2 9 0
+ 74 32 2 6 0
+
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 80 35 2 8 0
+ 85 38 2 7 0
+ 90 41 8 5 0
+ 97 44 2 5 0
+ 109 46 2 2 0
+ 111 47 8 6 0
+ 116 48 2 5 0
+
+18 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 1106905979
+
+--------------------------------------------------------------------------------
+---------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%C
+PU)| Time |
+
+--------------------------------------------------------------------------------
+---------------
+
+| 0 | SELECT STATEMENT | | 13 | 273 | 7
+(0)| 00:00:01 |
+
+| 1 | NESTED LOOPS | | 13 | 273 | 7
+(0)| 00:00:01 |
+
+| 2 | TABLE ACCESS FULL | LIGNE_COMMANDE | 120 | 1680 | 6
+(0)| 00:00:01 |
+
+|* 3 | TABLE ACCESS BY INDEX ROWID| PRODUIT | 1 | 7 | 1
+(0)| 00:00:01 |
+
+|* 4 | INDEX UNIQUE SCAN | SYS_C00136322 | 1 | | 0
+(0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+---------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 3 - filter("PRIX_UNITAIRE">100)
+ 4 - access("PRODUIT_ID"="ID")
+
+
+Statistics
+----------------------------------------------------------
+ 341 recursive calls
+ 0 db block gets
+ 230 consistent gets
+ 23 physical reads
+ 0 redo size
+ 955 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 5 sorts (memory)
+ 0 sorts (disk)
+ 18 rows processed
+
+2)
+
+SQL> SELECT lc.*
+FROM LIGNE_COMMANDE lc
+JOIN PRODUIT p ON lc.PRODUIT_ID = p.ID
+WHERE p.PRIX_UNITAIRE > 100; 2 3 4
+
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 10 4 8 9 0
+ 20 10 2 2 0
+ 25 12 2 1 0
+ 32 15 2 8 0
+ 33 16 2 4 0
+ 41 18 2 1 0
+ 50 22 2 9 0
+ 54 23 8 9 0
+ 57 24 8 4 0
+ 67 29 2 9 0
+ 74 32 2 6 0
+
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 80 35 2 8 0
+ 85 38 2 7 0
+ 90 41 8 5 0
+ 97 44 2 5 0
+ 109 46 2 2 0
+ 111 47 8 6 0
+ 116 48 2 5 0
+
+18 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 1106905979
+
+--------------------------------------------------------------------------------
+---------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%C
+PU)| Time |
+
+--------------------------------------------------------------------------------
+---------------
+
+| 0 | SELECT STATEMENT | | 13 | 273 | 7
+(0)| 00:00:01 |
+
+| 1 | NESTED LOOPS | | 13 | 273 | 7
+(0)| 00:00:01 |
+
+| 2 | TABLE ACCESS FULL | LIGNE_COMMANDE | 120 | 1680 | 6
+(0)| 00:00:01 |
+
+|* 3 | TABLE ACCESS BY INDEX ROWID| PRODUIT | 1 | 7 | 1
+(0)| 00:00:01 |
+
+|* 4 | INDEX UNIQUE SCAN | SYS_C00136322 | 1 | | 0
+(0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+---------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 3 - filter("P"."PRIX_UNITAIRE">100)
+ 4 - access("LC"."PRODUIT_ID"="P"."ID")
+
+
+Statistics
+----------------------------------------------------------
+ 280 recursive calls
+ 0 db block gets
+ 228 consistent gets
+ 0 physical reads
+ 0 redo size
+ 955 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 3 sorts (memory)
+ 0 sorts (disk)
+ 18 rows processed
+
+3)
+
+SQL> SELECT lc.*
+FROM LIGNE_COMMANDE lc
+WHERE EXISTS (
+ SELECT 1
+ FROM PRODUIT p
+ WHERE p.ID = lc.PRODUIT_ID
+ AND p.PRIX_UNITAIRE > 100
+);
+ 2 3 4 5 6 7 8
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 10 4 8 9 0
+ 20 10 2 2 0
+ 25 12 2 1 0
+ 32 15 2 8 0
+ 33 16 2 4 0
+ 41 18 2 1 0
+ 50 22 2 9 0
+ 54 23 8 9 0
+ 57 24 8 4 0
+ 67 29 2 9 0
+ 74 32 2 6 0
+
+ ID COMMANDE_ID PRODUIT_ID QUANTITE PRIX_TOTAL
+---------- ----------- ---------- ---------- ----------
+ 80 35 2 8 0
+ 85 38 2 7 0
+ 90 41 8 5 0
+ 97 44 2 5 0
+ 109 46 2 2 0
+ 111 47 8 6 0
+ 116 48 2 5 0
+
+18 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 2176195470
+
+--------------------------------------------------------------------------------
+---------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%C
+PU)| Time |
+
+--------------------------------------------------------------------------------
+---------------
+
+| 0 | SELECT STATEMENT | | 24 | 504 | 7
+(0)| 00:00:01 |
+
+| 1 | NESTED LOOPS SEMI | | 24 | 504 | 7
+(0)| 00:00:01 |
+
+| 2 | TABLE ACCESS FULL | LIGNE_COMMANDE | 120 | 1680 | 6
+(0)| 00:00:01 |
+
+|* 3 | TABLE ACCESS BY INDEX ROWID| PRODUIT | 1 | 7 | 1
+(0)| 00:00:01 |
+
+|* 4 | INDEX UNIQUE SCAN | SYS_C00136322 | 1 | | 0
+(0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+---------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 3 - filter("P"."PRIX_UNITAIRE">100)
+ 4 - access("P"."ID"="LC"."PRODUIT_ID")
+
+
+Statistics
+----------------------------------------------------------
+ 1 recursive calls
+ 0 db block gets
+ 37 consistent gets
+ 0 physical reads
+ 0 redo size
+ 955 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 0 sorts (memory)
+ 0 sorts (disk)
+ 18 rows processed
+
+
+4)
+
+ Performance : La version avec la jointure (2) ou avec EXISTS (3) devrait en général être plus performante que celle avec IN (1), surtout dans les cas où la table PRODUIT est volumineuse. Cela est dû au fait que la sous-requête dans IN nécessite une recherche complète et une construction d'une liste d'ID avant de pouvoir être comparée avec chaque ligne de la table LIGNE_COMMANDE. En revanche, une jointure permet de traiter les données de manière plus directe, et EXISTS arrête l'exécution dès qu'une correspondance est trouvée.
+
+ Utilisation d'index : Les versions avec jointure ou EXISTS peuvent être optimisées avec des index sur les colonnes ID, PRODUIT_ID, et PRIX_UNITAIRE. Cela peut réduire les coûts de recherche, contrairement à IN, qui pourrait ne pas bénéficier aussi facilement des index.
+
+ Lisibilité : En termes de lisibilité, la version avec jointure est généralement plus facile à comprendre, car elle ressemble à une simple association de tables. La version EXISTS est aussi valide, mais elle peut sembler un peu plus abstraite.
+
+Exo 5 :
+
+1)
+
+SQL> CREATE INDEX idx_reference ON COMMANDE4 (REFERENCE);
+
+Index created.
+
+2)
+
+SQL> SELECT * FROM COMMANDE4
+WHERE REFERENCE = '001639'; 2
+
+COMMANDE_ID CLIENT_ID DATE_ACHA
+----------- ---------- ---------
+REFERENCE
+--------------------------------------------------------------------------------
+ 41 2 12-FEB-19
+001639
+
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 3046868661
+
+--------------------------------------------------------------------------------
+-------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU
+)| Time |
+
+--------------------------------------------------------------------------------
+-------------
+
+| 0 | SELECT STATEMENT | | 1 | 164 | 2 (0
+)| 00:00:01 |
+
+| 1 | TABLE ACCESS BY INDEX ROWID| COMMANDE4 | 1 | 164 | 2 (0
+)| 00:00:01 |
+
+|* 2 | INDEX RANGE SCAN | IDX_REFERENCE | 1 | | 1 (0
+)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+-------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 2 - access("REFERENCE"='001639')
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+
+Statistics
+----------------------------------------------------------
+ 9 recursive calls
+ 0 db block gets
+ 28 consistent gets
+ 0 physical reads
+ 0 redo size
+ 522 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
+
+3)
+
+
+
+4)
+
+SQL> SELECT * FROM COMMANDE4
+WHERE UPPER(REFERENCE) = '001639'; 2
+
+COMMANDE_ID CLIENT_ID DATE_ACHA
+----------- ---------- ---------
+REFERENCE
+--------------------------------------------------------------------------------
+ 41 2 12-FEB-19
+001639
+
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 591636140
+
+-------------------------------------------------------------------------------
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time |
+-------------------------------------------------------------------------------
+| 0 | SELECT STATEMENT | | 1 | 164 | 6 (0)| 00:00:01 |
+|* 1 | TABLE ACCESS FULL| COMMANDE4 | 1 | 164 | 6 (0)| 00:00:01 |
+-------------------------------------------------------------------------------
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 1 - filter(UPPER("REFERENCE")='001639')
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+
+Statistics
+----------------------------------------------------------
+ 5 recursive calls
+ 0 db block gets
+ 46 consistent gets
+ 0 physical reads
+ 0 redo size
+ 522 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
+
+5)
+
+ Absence d'utilisation de l'index : La fonction UPPER() empêche l'utilisation de l'index directement sur la colonne REFERENCE. En effet, les index sont généralement utilisés pour des comparaisons directes sur les valeurs de colonnes, mais lorsqu'une fonction comme UPPER() est appliquée à la colonne dans la condition WHERE, la base de données ne peut pas utiliser l'index sur la colonne telle quelle, car l'index est basé sur les valeurs d'origine (sans modification comme celle générée par UPPER()).
+
+ Cela peut entraîner un "Table Scan" au lieu d'un "Index Scan", car chaque ligne de la table COMMANDE devra être lue et la fonction UPPER() appliquée à la colonne REFERENCE avant de comparer avec '001639'.
+
+ Performance plus faible : Si la table COMMANDE contient beaucoup d'enregistrements, l'exécution de cette requête pourrait être plus lente que la requête sans la fonction UPPER(), car l'index sur REFERENCE ne peut pas être utilisé efficacement.
+
+Exo 6 :
+
+1)
+
+SELECT * FROM CLIENT4 cl NATURAL JOIN COMMANDE4;
+
+result : to much
+2)
+
+SQL> EXPLAIN PLAN FOR
+SELECT * FROM CLIENT4 cl NATURAL JOIN COMMANDE4; 2
+
+Explained.
+
+SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+Plan hash value: 2682328233
+
+--------------------------------------------------------------------------------
+---------------------
+
+| Id | Operation | Name | Rows | Bytes | Co
+st (%CPU)| Time |
+
+--------------------------------------------------------------------------------
+---------------------
+
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+| 0 | SELECT STATEMENT | | 48 | 33264 |
+ 7 (0)| 00:00:01 |
+
+| 1 | TABLE ACCESS BY INDEX ROWID| COMMANDE4 | 2 | 328 |
+ 1 (0)| 00:00:01 |
+
+| 2 | NESTED LOOPS | | 48 | 33264 |
+ 7 (0)| 00:00:01 |
+
+| 3 | TABLE ACCESS FULL | CLIENT4 | 20 | 10580 |
+ 6 (0)| 00:00:01 |
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+
+|* 4 | INDEX RANGE SCAN | IX_COMMANDE_CLIENT_ID | 3 | |
+ 0 (0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+---------------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+
+PLAN_TABLE_OUTPUT
+--------------------------------------------------------------------------------
+ 4 - access("CL"."CLIENT_ID"="COMMANDE4"."CLIENT_ID")
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+20 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 2137789089
+
+--------------------------------------------------------------------------------
+-------------
+
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU
+)| Time |
+
+--------------------------------------------------------------------------------
+-------------
+
+| 0 | SELECT STATEMENT | | 2024 | 4048 | 18 (0
+)| 00:00:01 |
+
+| 1 | COLLECTION ITERATOR PICKLER FETCH| DISPLAY | | |
+ | |
+
+--------------------------------------------------------------------------------
+-------------
+
+
+
+Statistics
+----------------------------------------------------------
+ 16 recursive calls
+ 12 db block gets
+ 56 consistent gets
+ 0 physical reads
+ 0 redo size
+ 1699 bytes sent via SQL*Net to client
+ 52 bytes received via SQL*Net from client
+ 3 SQL*Net roundtrips to/from client
+ 1 sorts (memory)
+ 0 sorts (disk)
+ 20 rows processed
+
+Nested Loop Join (Boucle imbriquée) :
+
+ Cet algorithme est souvent utilisé lorsqu'une des tables est petite ou lorsque l'index sur la colonne de jointure est efficace. Oracle effectue un balayage de la première table (généralement celle avec un petit nombre de lignes), puis pour chaque ligne, il effectue une recherche dans la deuxième table.
+
+ Utilisation typique : Si la table CLIENT est petite et que la jointure s’effectue sur une colonne indexée, Oracle pourrait choisir cet algorithme.
+
+Sort Merge Join :
+
+ Si les deux tables sont triées par les colonnes utilisées pour la jointure, Oracle pourrait choisir un algorithme de Sort Merge Join. Cet algorithme consiste à trier les deux tables sur la colonne de jointure, puis à les fusionner en une seule étape.
+
+ Utilisation typique : Cet algorithme est souvent utilisé lorsque les tables sont grandes, mais qu'il existe des index permettant de trier les données ou lorsque la jointure se fait sur des colonnes non indexées.
+
+Hash Join :
+
+ Si les tables sont grandes et qu'aucun index n’est disponible ou qu'un tri coûte trop cher, Oracle pourrait utiliser un Hash Join. Ce type de jointure implique la construction d'une table de hachage en mémoire pour l'une des tables, puis la recherche de correspondances dans l'autre table.
+
+ Utilisation typique : Si les tables sont volumineuses et qu'aucune option plus rapide n'est disponible, cet algorithme pourrait être choisi.
+
+3)
+
+SELECT /*+ NO_INDEX(COMMANDE4 <nom_de_l'index>) */ *
+FROM CLIENT4 cl NATURAL JOIN COMMANDE4;
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 2682328233
+
+--------------------------------------------------------------------------------
+---------------------
+
+| Id | Operation | Name | Rows | Bytes | Co
+st (%CPU)| Time |
+
+--------------------------------------------------------------------------------
+---------------------
+
+| 0 | SELECT STATEMENT | | 48 | 33264 |
+ 7 (0)| 00:00:01 |
+
+| 1 | TABLE ACCESS BY INDEX ROWID| COMMANDE4 | 2 | 328 |
+ 1 (0)| 00:00:01 |
+
+| 2 | NESTED LOOPS | | 48 | 33264 |
+ 7 (0)| 00:00:01 |
+
+| 3 | TABLE ACCESS FULL | CLIENT4 | 20 | 10580 |
+ 6 (0)| 00:00:01 |
+
+|* 4 | INDEX RANGE SCAN | IX_COMMANDE_CLIENT_ID | 3 | |
+ 0 (0)| 00:00:01 |
+
+--------------------------------------------------------------------------------
+---------------------
+
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+ 4 - access("CL"."CLIENT_ID"="COMMANDE4"."CLIENT_ID")
+
+Note
+-----
+ - dynamic sampling used for this statement
+
+
+Statistics
+----------------------------------------------------------
+ 7 recursive calls
+ 0 db block gets
+ 89 consistent gets
+ 0 physical reads
+ 0 redo size
+ 2999 bytes sent via SQL*Net to client
+ 74 bytes received via SQL*Net from client
+ 5 SQL*Net roundtrips to/from client
+ 2 sorts (memory)
+ 0 sorts (disk)
+ 48 rows processed
+
+200 rows selected.
+
+
+Execution Plan
+----------------------------------------------------------
+Plan hash value: 3485364153
+
+--------------------------------------------------------------------------------
+-
+
+| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time
+|
+
+--------------------------------------------------------------------------------
+-
+
+| 0 | SELECT STATEMENT | | 200 | 14000 | 54 (0)| 00:00:01
+|
+
+| 1 | MERGE JOIN CARTESIAN| | 200 | 14000 | 54 (0)| 00:00:01
+|
+
+| 2 | TABLE ACCESS FULL | COMMANDE | 10 | 200 | 6 (0)| 00:00:01
+|
+
+| 3 | BUFFER SORT | | 20 | 1000 | 48 (0)| 00:00:01
+|
+
+| 4 | TABLE ACCESS FULL | CLIENT | 20 | 1000 | 5 (0)| 00:00:01
+|
+
+--------------------------------------------------------------------------------
+-
+
+
+
+Statistics
+----------------------------------------------------------
+ 419 recursive calls
+ 0 db block gets
+ 183 consistent gets
+ 43 physical reads
+ 0 redo size
+ 14011 bytes sent via SQL*Net to client
+ 184 bytes received via SQL*Net from client
+ 15 SQL*Net roundtrips to/from client
+ 7 sorts (memory)
+ 0 sorts (disk)
+ 200 rows processed