SIDEBAR SKINS

HEADER SKINS

### Fondamentaux Oracle & Bases de données

###### Maîtrisez les concepts essentiels d'Oracle Database et SQL

Progression: 0/8 leçons

Leçons complétées

0/8

0% du chapitre

Exercices réussis

0/16

Continuez comme ça !

Points gagnés

0

Prêt à commencer ?

Temps passé

0h

Bonne chance !

#### Table des matières

#### Leçon 1 : Qu'est-ce qu'Oracle Database ?

Débutant

Oracle Database est l'un des systèmes de gestion de bases de données relationnelles (SGBDR) les plus puissants et les plus utilisés au monde.

##### Qu'est-ce qu'une base de données ?

Une base de données est un ensemble organisé de données stockées de manière structurée. Elle permet de :

- Stocker de grandes quantités d'informations
- Rechercher rapidement des données spécifiques
- Maintenir l'intégrité et la cohérence des données
- Gérer les accès concurrents (plusieurs utilisateurs en même temps)
- Sécuriser les informations sensibles

##### Oracle Database : Caractéristiques principales

Oracle Database se distingue par plusieurs caractéristiques :

Caractéristique | Description
--- | ---
Fiabilité | Systèmes de sauvegarde et de récupération avancés
Performance | Optimisation des requêtes et gestion efficace de la mémoire
Sécurité | Contrôle d'accès granulaire et chiffrement des données
Scalabilité | Capable de gérer de très grandes quantités de données

##### Architecture simplifiée

Oracle Database est composé de plusieurs éléments :

- Instance : Ensemble de processus et de zones mémoire qui gèrent les données
- Base de données : Ensemble de fichiers physiques qui stockent les données
- SQL : Langage utilisé pour interroger et manipuler les données

À retenir : Oracle Database est un SGBDR (Système de Gestion de Bases de Données Relationnelles) qui utilise le langage SQL pour gérer les données de manière structurée, sécurisée et performante.

##### Exercice 1 : Connexion à Oracle

Créez votre première connexion à Oracle Database en affichant un message simple.

Consigne : Écrivez une requête SQL qui affiche le texte "Hello Oracle Database".
Votre requête SQL :

###### Résultat :

###### Solution :

    SELECT 'Hello Oracle Database' AS message
    FROM dual;

Explication : La clause `SELECT` permet d'afficher des données. `FROM dual` est une table système Oracle utilisée pour les requêtes simples qui ne nécessitent pas de vraie table.

#### Leçon 2 : Différence entre SQL et PL/SQL

Débutant

Comprendre la différence entre SQL et PL/SQL est essentiel pour bien utiliser Oracle Database.

##### SQL : Structured Query Language

SQL est un langage déclaratif utilisé pour :

- Interroger les données : SELECT
- Insérer des données : INSERT
- Modifier des données : UPDATE
- Supprimer des données : DELETE
- Créer des objets : CREATE TABLE, CREATE INDEX...

Exemple SQL :

    -- Sélectionner tous les employés
    SELECT nom, prenom, salaire
    FROM employes
    WHERE departement = 'IT'
    ORDER BY salaire DESC;

##### PL/SQL : Procedural Language/SQL

PL/SQL est une extension procédurale de SQL qui ajoute :

- Structures de contrôle : IF, LOOP, WHILE...
- Variables : Déclaration et manipulation de variables
- Procédures et fonctions : Code réutilisable
- Gestion des erreurs : EXCEPTION handling
- Curseurs : Traitement ligne par ligne

Exemple PL/SQL :

    -- Procédure pour augmenter les salaires
    DECLARE
      v_augmentation NUMBER := 0.10; -- 10%
    BEGIN
      FOR emp IN (SELECT employee_id FROM employes WHERE departement = 'IT') LOOP
        UPDATE employes
        SET salaire = salaire * (1 + v_augmentation)
        WHERE employee_id = emp.employee_id;
      END LOOP;

      COMMIT;
      DBMS_OUTPUT.PUT_LINE('Augmentation appliquée avec succès');
    EXCEPTION
      WHEN OTHERS THEN
        ROLLBACK;
        DBMS_OUTPUT.PUT_LINE('Erreur : ' || SQLERRM);
    END;

##### Comparaison SQL vs PL/SQL

Critère | SQL | PL/SQL
--- | --- | ---
Type | Langage déclaratif | Langage procédural
Exécution | Une instruction à la fois | Bloc d'instructions
Variables | Non supportées | Supportées
Conditions | Limitées (WHERE, CASE) | Complètes (IF, LOOP...)
Utilisation | Requêtes simples | Logique complexe

Astuce : Utilisez SQL pour des opérations simples sur les données. Utilisez PL/SQL lorsque vous avez besoin de logique conditionnelle, de boucles ou de traitement complexe.

##### Exercice 2 : Votre première requête SELECT

Créez une requête SQL pour récupérer des informations depuis la table dual.

Consigne : Écrivez une requête qui affiche la date du jour avec l'alias "date_du_jour".
Votre requête SQL :

###### Résultat :

###### Solution :

    SELECT SYSDATE AS date_du_jour
    FROM dual;

Explication : `SYSDATE` est une fonction Oracle qui retourne la date et l'heure actuelles. `AS date_du_jour` crée un alias pour rendre le résultat plus lisible.

#### Leçon 3 : Schéma Oracle

Intermédiaire

Un schéma est un conteneur logique qui organise les objets de base de données appartenant à un utilisateur.

##### Qu'est-ce qu'un schéma ?

Dans Oracle, un schéma est une collection d'objets de base de données (tables, vues, index, séquences, etc.) qui appartiennent à un utilisateur spécifique.

Important : Dans Oracle, chaque utilisateur possède automatiquement un schéma portant le même nom. Par exemple, l'utilisateur "HR" possède un schéma "HR".

##### Objets contenus dans un schéma

Un schéma peut contenir différents types d'objets :

- Tables : Stockent les données
- Vues : Requêtes SQL enregistrées
- Index : Améliorent les performances
- Séquences : Génèrent des nombres uniques

- Procédures : Code PL/SQL réutilisable
- Fonctions : Retournent une valeur
- Packages : Groupent procédures et fonctions
- Triggers : Code exécuté automatiquement

##### Visualiser les objets d'un schéma

Oracle fournit des vues système pour explorer les schémas :

Exemple : Lister toutes les tables de votre schéma

    -- Voir les tables du schéma actuel
    SELECT table_name
    FROM user_tables
    ORDER BY table_name;

Exemple : Lister tous les objets d'un schéma

    -- Voir tous les objets du schéma actuel
    SELECT object_name, object_type
    FROM user_objects
    ORDER BY object_type, object_name;

##### Accéder aux objets d'un autre schéma

Pour accéder à un objet d'un autre schéma, utilisez la notation :

    -- Syntaxe : schema_name.object_name
    SELECT * FROM HR.employees;
    SELECT * FROM SALES.customers;

Sécurité : Vous devez avoir les privilèges nécessaires pour accéder aux objets d'un autre schéma.

##### Exercice 3 : Explorer votre schéma

Interrogez les vues système pour découvrir votre environnement.

Consigne : Écrivez une requête qui affiche le nom de l'utilisateur actuel (votre schéma).
Votre requête SQL :

###### Résultat :

###### Solution :

    SELECT USER AS nom_utilisateur
    FROM dual;

Explication : La fonction `USER` retourne le nom de l'utilisateur actuellement connecté, qui correspond également au nom de votre schéma.

#### Leçon 4 : Tablespace (notions)

Intermédiaire

Un tablespace est l'unité de stockage logique dans Oracle Database. Il fait le lien entre les structures physiques et logiques.

##### Qu'est-ce qu'un Tablespace ?

Un tablespace est un conteneur logique qui :

- Regroupe un ou plusieurs fichiers de données physiques
- Stocke les objets de base de données (tables, index, etc.)
- Permet de gérer et d'organiser l'espace disque
- Offre une flexibilité dans la gestion du stockage

Analogie : Pensez au tablespace comme un disque dur virtuel dans lequel Oracle stocke vos données. Chaque tablespace peut contenir plusieurs fichiers réels sur le disque.

##### Types de Tablespaces

Type | Description | Utilisation
--- | --- | ---
SYSTEM | Tablespace système principal | Dictionnaire de données Oracle
SYSAUX | Tablespace système auxiliaire | Composants et outils Oracle
USERS | Tablespace par défaut pour les utilisateurs | Objets créés par les utilisateurs
TEMP | Tablespace temporaire | Opérations de tri et jointures temporaires
UNDO | Tablespace de rollback | Gestion des transactions (COMMIT/ROLLBACK)

##### Visualiser les Tablespaces

Oracle fournit des vues pour consulter les tablespaces :

Exemple : Lister tous les tablespaces

    -- Vue simplifiée des tablespaces
    SELECT tablespace_name, status, contents
    FROM user_tablespaces;

Exemple : Vérifier l'espace utilisé

    -- Espace utilisé par tablespace
    SELECT
      tablespace_name,
      ROUND(SUM(bytes)/1024/1024, 2) AS size_mb
    FROM dba_data_files
    GROUP BY tablespace_name;

##### Création d'un Tablespace

Les administrateurs peuvent créer de nouveaux tablespaces :

Exemple de création

    -- Créer un tablespace (nécessite des privilèges DBA)
    CREATE TABLESPACE app_data
      DATAFILE '/u01/oradata/mydb/app_data01.dbf'
      SIZE 100M
      AUTOEXTEND ON
      NEXT 10M
      MAXSIZE 500M;

Note : La création de tablespaces nécessite des privilèges DBA. En tant qu'utilisateur standard, vous utilisez les tablespaces existants.

##### Exercice 4 : Connaître son tablespace

Découvrez quel est votre tablespace par défaut.

Consigne : Cette leçon est informative. Retenez que les tablespaces organisent le stockage physique de vos données.
À retenir : Les tablespaces sont gérés par les DBA. Vous devez simplement savoir qu'ils existent et qu'ils organisent le stockage de vos objets.

#### Leçon 5 : Tables, lignes et colonnes

Débutant

Les tables sont les structures fondamentales pour stocker les données dans Oracle. Comprendre leur organisation est essentiel.

##### Structure d'une Table

Une table est composée de :

- Colonnes : Définissent les types de données stockées
- Lignes (ou enregistrements) : Contiennent les données réelles

Analogie : Une table est comme un tableur Excel :

- Les colonnes sont les en-têtes (Nom, Prénom, Age...)
- Les lignes sont les enregistrements (Jean Dupont, 25 ans...)

##### Types de données courants

Type | Description | Exemple
--- | --- | ---
VARCHAR2(n) | Chaîne de caractères variable | VARCHAR2(100) - 'Jean Dupont'
NUMBER(p,s) | Nombre avec précision | NUMBER(10,2) - 1234.56
DATE | Date et heure | '2026-01-10'
CHAR(n) | Chaîne fixe | CHAR(5) - 'ABCDE'
CLOB | Texte volumineux | Documents, descriptions longues

##### Créer une Table

Syntaxe de création

    CREATE TABLE employes (
      employee_id   NUMBER(6)      NOT NULL,
      nom           VARCHAR2(50)   NOT NULL,
      prenom        VARCHAR2(50),
      email         VARCHAR2(100)  UNIQUE,
      telephone     VARCHAR2(20),
      date_embauche DATE           DEFAULT SYSDATE,
      salaire       NUMBER(10,2),
      departement   VARCHAR2(30)
    );

##### Consulter la structure d'une Table

Commande DESCRIBE

    -- Afficher la structure de la table
    DESCRIBE employes;

    -- Ou en SQL
    SELECT column_name, data_type, nullable
    FROM user_tab_columns
    WHERE table_name = 'EMPLOYES';

##### Insérer des données

Insertion d'une ligne

    INSERT INTO employes
      (employee_id, nom, prenom, email, salaire, departement)
    VALUES
      (1, 'Dupont', 'Jean', 'jean.dupont@company.com', 3500.00, 'IT');

##### Sélectionner des données

Récupérer des lignes

    -- Toutes les colonnes
    SELECT * FROM employes;

    -- Colonnes spécifiques
    SELECT nom, prenom, salaire
    FROM employes
    WHERE departement = 'IT';

##### Exercice 5 : Compter les lignes

Utilisez la fonction COUNT pour compter le nombre de lignes.

Consigne : Écrivez une requête qui compte le nombre de tables dans votre schéma en utilisant la vue user_tables.
Votre requête SQL :

###### Résultat :

###### Solution :

    SELECT COUNT(*) AS nombre_tables
    FROM user_tables;

Explication : La fonction `COUNT(*)` compte le nombre de lignes retournées. Ici, elle compte le nombre de tables dans votre schéma.

#### Leçon 6 : Clés primaires et clés étrangères

Intermédiaire

Les clés sont essentielles pour garantir l'intégrité des données et créer des relations entre les tables.

##### Clé Primaire (Primary Key)

Une clé primaire est une colonne (ou un ensemble de colonnes) qui :

- Identifie de manière unique chaque ligne
- Ne peut jamais être NULL
- Ne peut pas contenir de doublons
- Est généralement indexée automatiquement

Exemple de création avec clé primaire

    CREATE TABLE employes (
      employee_id   NUMBER(6)     PRIMARY KEY,
      nom           VARCHAR2(50)  NOT NULL,
      prenom        VARCHAR2(50),
      email         VARCHAR2(100)
    );

    -- Ou en nommant la contrainte
    CREATE TABLE employes (
      employee_id   NUMBER(6),
      nom           VARCHAR2(50)  NOT NULL,
      prenom        VARCHAR2(50),
      email         VARCHAR2(100),
      CONSTRAINT pk_employes PRIMARY KEY (employee_id)
    );

##### Clé Étrangère (Foreign Key)

Une clé étrangère est une colonne qui :

- Fait référence à la clé primaire d'une autre table
- Crée une relation entre deux tables
- Garantit l'intégrité référentielle
- Empêche les incohérences dans les données

Exemple de relation avec clé étrangère

    -- Table parente
    CREATE TABLE departements (
      dept_id       NUMBER(4)     PRIMARY KEY,
      nom_dept      VARCHAR2(50)  NOT NULL
    );

    -- Table enfant avec clé étrangère
    CREATE TABLE employes (
      employee_id   NUMBER(6)     PRIMARY KEY,
      nom           VARCHAR2(50)  NOT NULL,
      dept_id       NUMBER(4),
      CONSTRAINT fk_emp_dept
        FOREIGN KEY (dept_id)
        REFERENCES departements(dept_id)
    );

##### Intégrité Référentielle

L'intégrité référentielle garantit que :

- On ne peut pas insérer un employé avec un dept_id inexistant
- On ne peut pas supprimer un département qui a des employés

Options de suppression

    -- CASCADE : supprime aussi les employés
    FOREIGN KEY (dept_id)
      REFERENCES departements(dept_id)
      ON DELETE CASCADE;

    -- SET NULL : met dept_id à NULL
    FOREIGN KEY (dept_id)
      REFERENCES departements(dept_id)
      ON DELETE SET NULL;

##### Visualiser les contraintes

Consulter les clés primaires et étrangères

    -- Toutes les contraintes
    SELECT constraint_name, constraint_type, table_name
    FROM user_constraints
    WHERE table_name = 'EMPLOYES';

    -- P = Primary Key, R = Foreign Key, U = Unique, C = Check

Bonne pratique : Toujours nommer vos contraintes (pk_*, fk_*, uk_*) pour faciliter la maintenance.

##### Exercice 6 : Comprendre les clés

Identifiez l'importance des clés dans l'intégrité des données.

Quiz : Pourquoi utilise-t-on une clé primaire ?

1. Pour identifier de manière unique chaque ligne ✓
2. Pour créer un index automatique ✓
3. Pour garantir qu'aucune valeur n'est nulle ✓

#### Leçon 7 : Les Contraintes

Intermédiaire

Les contraintes sont des règles appliquées aux colonnes pour garantir la qualité et la cohérence des données.

##### Types de Contraintes

Contrainte | Description | Exemple
--- | --- | ---
NOT NULL | La colonne ne peut pas être vide | nom VARCHAR2(50) NOT NULL
UNIQUE | Toutes les valeurs doivent être uniques | email VARCHAR2(100) UNIQUE
PRIMARY KEY | Identifiant unique (NOT NULL + UNIQUE) | id NUMBER PRIMARY KEY
FOREIGN KEY | Référence vers une autre table | REFERENCES departements(id)
CHECK | Condition personnalisée | age NUMBER CHECK (age >= 18)
DEFAULT | Valeur par défaut | statut VARCHAR2(10) DEFAULT 'ACTIF'

##### Contrainte NOT NULL

Exemple

    CREATE TABLE employes (
      employee_id NUMBER(6)    NOT NULL,
      nom         VARCHAR2(50) NOT NULL,  -- Obligatoire
      prenom      VARCHAR2(50),           -- Optionnel
      email       VARCHAR2(100) NOT NULL
    );

##### Contrainte UNIQUE

Exemple

    CREATE TABLE employes (
      employee_id NUMBER(6)     PRIMARY KEY,
      email       VARCHAR2(100) UNIQUE,  -- Pas de doublons
      telephone   VARCHAR2(20)  UNIQUE
    );

##### Contrainte CHECK

Validation personnalisée

    CREATE TABLE employes (
      employee_id NUMBER(6)    PRIMARY KEY,
      nom         VARCHAR2(50) NOT NULL,
      age         NUMBER(3)    CHECK (age >= 18 AND age <= 65),
      salaire     NUMBER(10,2) CHECK (salaire > 0),
      sexe        CHAR(1)      CHECK (sexe IN ('M', 'F')),
      CONSTRAINT chk_email CHECK (email LIKE '%@%.%')
    );

##### Contrainte DEFAULT

Valeurs par défaut

    CREATE TABLE commandes (
      order_id      NUMBER(10)   PRIMARY KEY,
      date_commande DATE         DEFAULT SYSDATE,
      statut        VARCHAR2(20) DEFAULT 'EN_ATTENTE',
      priorite      NUMBER(1)    DEFAULT 1
    );

##### Ajouter une contrainte après création

ALTER TABLE

    -- Ajouter NOT NULL
    ALTER TABLE employes MODIFY (telephone VARCHAR2(20) NOT NULL);

    -- Ajouter CHECK
    ALTER TABLE employes
      ADD CONSTRAINT chk_salaire CHECK (salaire >= 1500);

    -- Ajouter UNIQUE
    ALTER TABLE employes
      ADD CONSTRAINT uk_email UNIQUE (email);

##### Supprimer une contrainte

DROP CONSTRAINT

    ALTER TABLE employes DROP CONSTRAINT chk_salaire;

Attention : Les contraintes peuvent ralentir les insertions/modifications car Oracle doit les vérifier. Utilisez-les judicieusement.

##### Exercice 7 : Maîtriser les contraintes

Testez votre compréhension des contraintes.

Quiz : Quelle contrainte empêche les valeurs NULL et les doublons ?

- ✓ PRIMARY KEY (combine NOT NULL + UNIQUE)
- ✗ UNIQUE seul (autorise NULL)
- ✗ NOT NULL seul (autorise les doublons)

#### Leçon 8 : SQL Standard vs SQL Oracle

Intermédiaire

Bien que SQL soit un standard, chaque SGBD a ses spécificités. Découvrez les particularités d'Oracle.

##### SQL : Un standard avec des variantes

Le SQL (Structured Query Language) est standardisé par l'ISO/ANSI, mais chaque éditeur de SGBD ajoute ses extensions :

- Oracle : PL/SQL, ROWNUM, DUAL, etc.
- Microsoft SQL Server : T-SQL, TOP, etc.
- MySQL : LIMIT, AUTO_INCREMENT, etc.
- PostgreSQL : RETURNING, SERIAL, etc.

##### Spécificités Oracle

###### 1. La table DUAL

Oracle utilise DUAL pour les requêtes sans table

    -- Oracle (avec DUAL)
    SELECT SYSDATE FROM dual;
    SELECT 1 + 1 FROM dual;

    -- Standard SQL / PostgreSQL (sans FROM)
    SELECT CURRENT_DATE;
    SELECT 1 + 1;

###### 2. Pagination avec ROWNUM vs LIMIT

Oracle utilise ROWNUM (avant 12c)

    -- Oracle (ROWNUM - complexe)
    SELECT * FROM (
      SELECT nom, salaire, ROWNUM AS rn
      FROM employes
      ORDER BY salaire DESC
    )
    WHERE rn <= 10;

    -- Oracle 12c+ (FETCH FIRST - standard SQL)
    SELECT nom, salaire
    FROM employes
    ORDER BY salaire DESC
    FETCH FIRST 10 ROWS ONLY;

    -- MySQL / PostgreSQL (LIMIT)
    SELECT nom, salaire
    FROM employes
    ORDER BY salaire DESC
    LIMIT 10;

###### 3. Séquences vs AUTO_INCREMENT

Oracle utilise des séquences

    -- Oracle (Séquence)
    CREATE SEQUENCE emp_seq START WITH 1 INCREMENT BY 1;

    INSERT INTO employes (id, nom)
    VALUES (emp_seq.NEXTVAL, 'Dupont');

    -- MySQL (AUTO_INCREMENT)
    CREATE TABLE employes (
      id INT AUTO_INCREMENT PRIMARY KEY,
      nom VARCHAR(50)
    );

    INSERT INTO employes (nom) VALUES ('Dupont');

###### 4. Concaténation de chaînes

Différentes syntaxes

    -- Oracle (double pipe ||)
    SELECT nom || ' ' || prenom AS nom_complet
    FROM employes;

    -- Standard SQL (CONCAT)
    SELECT CONCAT(nom, ' ', prenom) AS nom_complet
    FROM employes;

    -- SQL Server (opérateur +)
    SELECT nom + ' ' + prenom AS nom_complet
    FROM employes;

###### 5. Gestion des NULL

Fonction NVL spécifique à Oracle

    -- Oracle (NVL)
    SELECT nom, NVL(telephone, 'Non renseigné')
    FROM employes;

    -- Standard SQL (COALESCE)
    SELECT nom, COALESCE(telephone, 'Non renseigné')
    FROM employes;

    -- SQL Server (ISNULL)
    SELECT nom, ISNULL(telephone, 'Non renseigné')
    FROM employes;

##### Tableau comparatif

Fonctionnalité | Oracle | MySQL/PostgreSQL | SQL Server
--- | --- | --- | ---
Date actuelle | SYSDATE | NOW(), CURRENT_DATE | GETDATE()
Limite de lignes | ROWNUM, FETCH FIRST | LIMIT | TOP
Auto-incrémentation | SEQUENCE | AUTO_INCREMENT, SERIAL | IDENTITY
Concaténation | || | CONCAT(), || | +, CONCAT()
Gestion NULL | NVL, NVL2 | COALESCE, IFNULL | ISNULL, COALESCE

Conseil : Privilégiez les fonctions SQL standard (COALESCE, CONCAT, FETCH FIRST) pour faciliter la portabilité de votre code entre différents SGBD.
Félicitations ! Vous avez terminé le chapitre "Fondamentaux Oracle & Bases de données". Vous maîtrisez maintenant les concepts essentiels pour travailler avec Oracle Database.