sqlplus nom_utilisateur/mot_de_passe@nom_service

CREATE USER mon_utilisateur IDENTIFIED BY mon_mot_de_passe;

GRANT CONNECT, RESOURCE TO mon_utilisateur;

Voici un aperçu des types de requêtes SQL que tu peux utiliser dans Oracle, avec
des exemples pour chacune. Cela ne couvre pas chaque aspect, mais donne une bonne
base.

### 1. **Requêtes de Sélection (SELECT)**

- **Sélectionner toutes les colonnes :**

```sql
SELECT * FROM nom_table;
```

- **Sélectionner des colonnes spécifiques :**

```sql
SELECT colonne1, colonne2 FROM nom_table;
```

- **Avec des conditions :**

```sql
SELECT * FROM nom_table WHERE condition;
```

- **Tri des résultats :**

```sql
SELECT * FROM nom_table ORDER BY colonne1 ASC;
```

### 2. **Insertion de Données (INSERT)**

- **Insérer une ligne :**

```sql
INSERT INTO nom_table (colonne1, colonne2) VALUES (valeur1, valeur2);
```

- **Insérer plusieurs lignes :**

```sql
INSERT ALL
INTO nom_table (colonne1, colonne2) VALUES (valeur1a, valeur2a)
INTO nom_table (colonne1, colonne2) VALUES (valeur1b, valeur2b)
SELECT * FROM dual;
```

### 3. **Mise à Jour de Données (UPDATE)**

- **Mettre à jour une ligne :**

```sql
UPDATE nom_table SET colonne1 = nouvelle_valeur WHERE condition;
```

- **Mettre à jour plusieurs lignes :**

```sql
UPDATE nom_table SET colonne1 = nouvelle_valeur WHERE condition;
 ```

### 4. **Suppression de Données (DELETE)**

- **Supprimer une ligne :**

```sql
DELETE FROM nom_table WHERE condition;
```

- **Supprimer toutes les lignes :**

```sql
DELETE FROM nom_table; -- attention, cela supprime toutes les données
```

### 5. **Création de Table (CREATE TABLE)**

- **Créer une nouvelle table :**

```sql
CREATE TABLE nom_table (
colonne1 type_donnees,
colonne2 type_donnees,
...
);
```

### 6. **Modification de Table (ALTER TABLE)**

- **Ajouter une colonne :**

```sql
ALTER TABLE nom_table ADD colonne_nouvelle type_donnees;
```

- **Modifier une colonne :**

```sql
ALTER TABLE nom_table MODIFY colonne1 nouveau_type;
```

- **Supprimer une colonne :**

```sql
ALTER TABLE nom_table DROP COLUMN colonne1;
```

### 7. **Suppression de Table (DROP TABLE)**

- **Supprimer une table :**

```sql
DROP TABLE nom_table;
```

### 8. **Gestion des Index (CREATE INDEX)**

- **Créer un index :**

```sql
CREATE INDEX nom_index ON nom_table (colonne);
```

### 9. **Gestion des Vues (CREATE VIEW)**

- **Créer une vue :**

 ```sql
CREATE VIEW nom_vue AS SELECT colonne1, colonne2 FROM nom_table WHERE condition;
```

### 10. **Transactions**

- **Commencer une transaction :**

```sql
BEGIN;
```

- **Valider une transaction :**

```sql
COMMIT;
```

- **Annuler une transaction :**

```sql
ROLLBACK;
```

### 11. **Fonctions d'Agrégation**

- **Utiliser COUNT, SUM, AVG, MIN, MAX :**

```sql
SELECT COUNT(*), SUM(colonne), AVG(colonne), MIN(colonne), MAX(colonne) FROM
nom_table;
```

### 12. **Jointures (JOIN)**

- **Jointure interne :**

```sql
SELECT * FROM table1 JOIN table2 ON [Link] = [Link];
```

- **Jointure externe :**

```sql
SELECT * FROM table1 LEFT JOIN table2 ON [Link] = [Link];
```

### 13. **Sous-requêtes**

- **Sous-requête dans une clause WHERE :**

```sql
SELECT * FROM nom_table WHERE colonne IN (SELECT colonne FROM autre_table WHERE
condition);
```

### 14. **Fonctions**

- **Fonctions définies par l'utilisateur :**

```sql
CREATE OR REPLACE FUNCTION nom_fonction (param1 TYPE) RETURN TYPE IS
BEGIN
-- Logic
END;
```
Cette liste n'est pas exhaustive, mais elle couvre la plupart des opérations
courantes en SQL sur Oracle. Si tu as besoin d'exemples ou d'informations
supplémentaires sur un aspect particulier, fais-le moi savoir !

--------------------------DECLARATIONS-----------------------------------------
Voici des exemples de déclaration de variables en PL/SQL pour différents types de
données courants dans Oracle :

### 1. **Types de Données Numériques**

- **NUMBER**
```plsql
DECLARE
v_number NUMBER(10, 2); -- Nombre avec 10 chiffres au total, 2 décimales
BEGIN
v_number := 12345.67;
END;
```

- **INTEGER**
```plsql
DECLARE
v_integer INTEGER; -- Nombre entier
BEGIN
v_integer := 100;
END;
```

### 2. **Types de Données Caractères**

- **VARCHAR2**
```plsql
DECLARE
v_varchar VARCHAR2(50); -- Chaîne de caractères jusqu'à 50 caractères
BEGIN
v_varchar := 'Bonjour, PL/SQL!';
END;
```

- **CHAR**
```plsql
DECLARE
v_char CHAR(10); -- Chaîne fixe de 10 caractères
BEGIN
v_char := 'A'; -- Rempli avec des espaces jusqu'à 10
END;
```

### 3. **Types de Données Date/Heure**

- **DATE**
```plsql
DECLARE
 v_date DATE; -- Type de données date
BEGIN
v_date := SYSDATE; -- Date et heure actuelles
END;
```

### 4. **Types de Données Booléennes**

- **BOOLEAN** (disponible uniquement dans PL/SQL)

```plsql
DECLARE
v_boolean BOOLEAN; -- Type de données booléen
BEGIN
v_boolean := TRUE;
END;
```

### 5. **Types de Données de Longueur Variable**

- **CLOB** (Character Large Object)

```plsql
DECLARE
v_clob CLOB; -- Grand objet de caractères
BEGIN
v_clob := 'Texte très long...';
END;
```

### 6. **Types de Données Binaire**

- **BLOB** (Binary Large Object)

```plsql
DECLARE
v_blob BLOB; -- Grand objet binaire
BEGIN
-- Opérations sur BLOB
END;
```

### 7. **Types de Données Tableaux Associatifs**

- **TABLE**
```plsql
DECLARE
TYPE t_varchar_array IS TABLE OF VARCHAR2(50) INDEX BY PLS_INTEGER; --
Tableau associatif
v_array t_varchar_array; -- Déclaration du tableau associatif
BEGIN
v_array(1) := 'Premier élément';
v_array(2) := 'Deuxième élément';
END;
```

### 8. **Types de Données Enregistrements**

- **RECORD**
```plsql
DECLARE
TYPE t_person IS RECORD (
 nom VARCHAR2(50),
age NUMBER(3)
);
v_person t_person; -- Déclaration d'un enregistrement
BEGIN
v_person.nom := 'Alice';
v_person.age := 30;
END;
```

### 9. **Types de Données Objets**

- **OBJECT**
```plsql
DECLARE
TYPE t_address IS OBJECT (
rue VARCHAR2(100),
ville VARCHAR2(50)
);
v_address t_address; -- Déclaration d'un objet
BEGIN
v_address := t_address('123 Rue Exemple', 'Paris');
END;
```

Ces exemples montrent comment déclarer des variables de différents types de données
en PL/SQL. Si tu as besoin de précisions ou d'exemples supplémentaires, fais-le moi
savoir !

-------------------------QUELQUES CREATIONS------------------------------------
Voici un ensemble d'exemples de code PL/SQL pour créer des tables avec diverses
contraintes, des séquences, des triggers et des vues dans Oracle.

### 1. **Création d'une Table Simple**

```sql
CREATE TABLE Employe (
id_employe NUMBER PRIMARY KEY,
nom VARCHAR2(50) NOT NULL,
prenom VARCHAR2(50),
salaire NUMBER CHECK (salaire >= 0)
);
```

### 2. **Création d'une Table avec Clé Étrangère et Contraintes**

```sql
CREATE TABLE Departement (
id_departement NUMBER PRIMARY KEY,
nom_departement VARCHAR2(50) UNIQUE NOT NULL
);

CREATE TABLE Projet (

id_projet NUMBER PRIMARY KEY,
nom_projet VARCHAR2(100) NOT NULL,
id_departement NUMBER,
FOREIGN KEY (id_departement) REFERENCES Departement(id_departement)
);
```

### 3. **Création d'une Séquence**

```sql
CREATE SEQUENCE seq_employe
START WITH 1
INCREMENT BY 1
NOCACHE;
```

### 4. **Création d'un Trigger**

```sql
CREATE OR REPLACE TRIGGER trg_before_insert_employe
BEFORE INSERT ON Employe
FOR EACH ROW
BEGIN
:NEW.id_employe := seq_employe.NEXTVAL; -- Assigner un nouvel ID avant
l'insertion
END;
```

### 5. **Création d'une Vue**

```sql
CREATE VIEW vue_employe_departement AS
SELECT [Link], [Link], d.nom_departement
FROM Employe e
JOIN Departement d ON e.id_departement = d.id_departement;
```

### 6. **Ajout de Contraintes à une Table Existante**

Pour ajouter une contrainte UNIQUE à la table `Employe` :

```sql
ALTER TABLE Employe
ADD CONSTRAINT uq_nom_prenom UNIQUE (nom, prenom);
```

### 7. **Ajout d'une Colonne avec une Contrainte CHECK**

```sql
ALTER TABLE Employe
ADD colonne_age NUMBER CHECK (colonne_age BETWEEN 18 AND 65);
```

### 8. **Exemple Complet**

Voici un exemple complet regroupant tout cela :

```sql
-- Création de la table Département
CREATE TABLE Departement (
id_departement NUMBER PRIMARY KEY,
nom_departement VARCHAR2(50) UNIQUE NOT NULL
);

-- Création de la table Employé

CREATE TABLE Employe (
id_employe NUMBER PRIMARY KEY,
nom VARCHAR2(50) NOT NULL,
prenom VARCHAR2(50),
salaire NUMBER CHECK (salaire >= 0),
id_departement NUMBER,
FOREIGN KEY (id_departement) REFERENCES Departement(id_departement)
);

-- Création de la table Projet

CREATE TABLE Projet (
id_projet NUMBER PRIMARY KEY,
nom_projet VARCHAR2(100) NOT NULL,
id_departement NUMBER,
FOREIGN KEY (id_departement) REFERENCES Departement(id_departement)
);

-- Création de la séquence pour les employés

CREATE SEQUENCE seq_employe
START WITH 1
INCREMENT BY 1
NOCACHE;

-- Création d'un trigger avant l'insertion d'un employé

CREATE OR REPLACE TRIGGER trg_before_insert_employe
BEFORE INSERT ON Employe
FOR EACH ROW
BEGIN
:NEW.id_employe := seq_employe.NEXTVAL; -- Assigner un nouvel ID
END;

-- Création de la vue pour les employés et départements

CREATE VIEW vue_employe_departement AS
SELECT [Link], [Link], d.nom_departement
FROM Employe e
JOIN Departement d ON e.id_departement = d.id_departement;
```

Ces exemples couvrent la création de tables avec des clés primaires et étrangères,
des contraintes, des séquences, des triggers et des vues. Si tu as besoin de
détails supplémentaires ou d'autres exemples, n'hésite pas à demander !
-------------------------------CREATE DATABASE? IDK----------------------------
CREATE DATABASE nom_de_la_base
USER SYS IDENTIFIED BY mot_de_passe
USER SYSTEM IDENTIFIED BY mot_de_passe
LOGFILE GROUP 1 ('/chemin/vers/[Link]') SIZE 50M,
GROUP 2 ('/chemin/vers/[Link]') SIZE 50M
MAXLOGFILES 10
MAXLOGFILESIZE 50M
MAXDATAFILES 100
CHARACTER SET UTF8
NATIONAL CHARACTER SET AL16UTF16
DATAFILE '/chemin/vers/nom_de_la_base.dbf' SIZE 200M
EXTENT MANAGEMENT LOCAL
UNDO TABLESPACE undotbs1
DATAFILE '/chemin/vers/[Link]' SIZE 200M
DEFAULT TEMPORARY TABLESPACE temp
TEMPFILE '/chemin/vers/[Link]' SIZE 100M;