select distinct ar_ref AS "Code Article", * from F_DOCLIGNE

select top 5 ar_refcompose, * from F_DOCLIGNE

select top 10 coalesce(ar_refcompose, ''), ar_ref, * from F_DOCLIGNE

exec sp_help f_docligne

select (DL_qte*Dl_PrixUnitaire) as Total, ar_ref, do_type from

F_DOCLIGNE

SELECT CONCAT(ar_ref, ' ', ar_design) as "Code et Libelle", * from

f_article

select * from f_article where ar_ref like '4_%2'

select FA_CodeFamille as "Famille Article", CONCAT(AVG(ar_prixven), '

', 'FCFA') as "Prix Moyen (FCFA)"
from f_article where ar_prixven > 0
group by FA_CodeFamille

SELECT SUM(S.Nombre_article)
from (SELECT fa_codeFamille, count(*) as Nombre_Article from f_article
group by FA_CodeFamille) S
select count(*) from f_article

SELECT FA_CODEFAMILLE, SUM(ar_prixven) as Total_Prix_Par_Famille,

count(*) as Nombre_Article,
MAX(ar_prixven) as Prix_Maximal, MIN(ar_prixven) as Prix_Minimal from
f_article
where ar_prixven > 0 group by FA_CodeFamille having (MIN(ar_prixven) >
100 or MAX(ar_prixven) < 50000)

select fa_codefamille, max(ar_prixven), min(ar_prixven),

sum(ar_prixven) from f_article
group by FA_CodeFamille
select len(AR_Design) as Longueur_Libellé, ar_ref, * from f_article --
where FA_CodeFamille = 'ATR'
select UPPER(ar_design) as "Nom MAJ", LOWER(ar_design) as "Nom MIN"
from f_article

select SUBSTRING(ar_design, 5,10), ar_ref, ar_design from f_article

select LTRIM(ar_design), AR_Design from f_article
select LTRIM(' champ') --select LTRIM('xxxChamp','x')
select RTRIM('champ x') --select RTRIM('xxxChamp','x')
select RIGHT('Informatique', 4)
select LEFT('Informatique', 4)
select REPLACE('Consultation', 'o', 'E') -- select REPLACE(ar_ref, 'A',
'XXX') from f_article
select 'Larticle dont le code est ' + ar_ref + ' a un prix de vente : '
+ CAST(ar_prixven AS varchar)
from f_article
select GETDATE() as Date_Système
select DATEPART(YEAR, do_date) as Année, DATEPART(MONTH, do_date) as
Mois, DATEPART(DAYOFYEAR, do_date) AS Jour_Année,
DATEPART(DAY, do_date) AS Jour_du_mois, DATEPART(WEEK, do_date) AS
Semaine, do_date,GETDATE(),
GETDATE()-Do_date as Time from F_DOCENTETE
select DATEDIFF(YEAR, do_date, GETDATE()), do_date, GETDATE() from
F_DOCENTETE
select DATEDIFF(YEAR, GETDATE(), DATEADD(YEAR, 5, do_date)), do_date
from F_DOCENTETE
select DATEADD(MONTH, 5, do_date), do_date from F_DOCENTETE
select YEAR(do_date) as Année, MONTH(do_date) as Mois, DAY(do_date) as
Jour, do_date from F_DOCENTETE
select SQRT(9) as racine, POWER(9, 2) as Puissance, ABS(-10) as
Val_Abs, SQUARE(9) as carré, SIGN(-10), SIGN(10)
select 'Le périmètre du cercle de rayon 3 est :'+ CAST(2*PI()*3 as
CHAR)
select SIN(30) as Sinus, COS(60) as Cosinus, TAN(45) as tangente,
LOG(10) as Log, EXP(3) as Exponentielle

select count(*) from f_comptet where ct_type != 1 and CT_Type != 0

select S.* from f_comptet T,
(select ct_num, ct_intitule,
CASE ct_type
WHEN 1 THEN 'Fournisseur'
WHEN 0 THEN 'Client'
ELSE 'Autre'
END as Type_Compte
from f_comptet ) S
Where S.ct_num = T.ct_num
and S.ct_intitule = T.ct_intitule AND S.Type_Compte = 'Autre'

/* REQUETES MULTI-TABLES*/
/* Clé primaire de la table parent en association avec celle étrangère
de la table fille
PRODUIT CARTESIEN : résultat d'une jointure sans condition. Il
multiplie le nombre de lignes de la table1 par celle de la table 2
NB : Il est très dangereux de l'utiliser

JOINTURES AVEC CONDITIONS */

--Syntaxe non normalisée :
select champ1, champ2, ... from table1 as T1, table2 as T2, ... where
table1.champ1 = table2.champ2

select top 10 * from F_DOCLIGNE --select count(*) from f_docligne

select top 10 * from f_comptet
select L.do_domaine, L.Do_type, L.Do_piece, L.Do_date, C.Ct_intitule
from F_DOCLIGNE L, F_COMPTET C
where L.CT_Num = C.CT_Num

--Syntaxe normalisée
select champ1, champ2, ... from table1 as T1 [JOIN] table2 as T2 [ON]
T1.champ1 = T2.champ2

select L.do_domaine, L.Do_type, L.Do_piece, L.Do_date, C.Ct_intitule

from F_DOCLIGNE L JOIN F_COMPTET C
ON L.CT_Num = C.CT_Num

/* JOINTURES EXTERNES */
/* Afficher les lignes d'une table qui ne correspondent pas à la
condition de jointure, cad les enregistrements d'une table
qui ne se trouvent pas dans l'autre table */
--Syntaxe normalisée :
select champ1, champ2, ... from table1 as T1 {LEFT | RIGHT | FULL}
[OUTER JOIN] table2 as T2 [ON] T1.champ1 = T2.champ2
/* LEFT : les données de la table de gauche se trouvent priviligiées.
Donc même si les records de la table de gauche ne sont pas référencés
dans l'autre table, alors elles seront affichées
RIGHT : l'inverse
FULL : affiche tous les records de la table1 qui ne se trouvent pas
dans l'autre et inversement */
select count(*) from f_comptet
select L.Ct_Num as "Numéro Compte",
CASE
WHEN Do_domaine = 0 THEN 'VENTES'
WHEN DO_Domaine = 1 THEN 'ACHATS'
WHEN DO_Domaine = 2 THEN 'STOCK'
END as "Domaine du Document",
CASE L.Do_type
WHEN 6 THEN 'Facture Non Comptabilisée'
WHEN 7 THEN 'Facture Comptabilisée'
WHEN NULL THEN 'Aucun document'
ELSE 'RAS'
END as Type_Document
, COALESCE(L.Do_piece, 'Pas de facture'), C.Ct_intitule
from F_COMPTET C LEFT OUTER JOIN F_DOCLIGNE L
ON L.CT_Num = C.CT_Num
--where L.[DO_Domaine] = 3
select distinct ct_num from F_DOCLIGNE

/* AUTO-JOINTURE*/
--Réaliser la jointure d'une table sur elle-même en utilisant des alias

select * from f_comptet

select A.CT_Num as No_Client, A.CT_Intitule as Lib_Client, A.ct_type as
Type_Client,
B.CT_Num as No_Fournisseur, B.CT_Intitule as Lib_Fournisseur, B.ct_type
as Type_Fournisseur from f_comptet A
inner join f_comptet B on A.ct_num = B.ct_num
--where A.ct_type = 0 or B.ct_type = 1

/* LES OPERATEURS ENSEMBLISTES

UNION : obtenir un ensemble de lignes provenant de plusieurs requêtes.
UNION ALL permet d'afficher les doublons qui viennent de chaque requete
Ex : requete1 UNION [ALL] requete2

INTERSECT : obtenir les lignes communes de plusieurs requetes.

Récupère les lignes de la req1 qui sont aussi présentes dans req2
requete1 INTERSECT [ALL] requete2 ([ALL] affiche les doublons)
EXCEPT : obtenir les lignes présentes dans les résultats de req1 et
qui ne le sont pas dans les résultats de req2
requete1 EXCEPT [ALL] requete2
CONTRAINTES :
- Tous les <SELECT> doivent avoir le même champ
- Tous les champs doivent être de types compatibles
- Exclusions des champs de type <BFILE>, <LONG>, <BLOG>, <CLOB>
(format des images, musiques, videos)
- Suppression auto des doublons (à moins d'utiliser le [ALL])
- Les noms des colonnes et alias sont de l'ordre du premier SELECT
- La largeur de chaque champ est donnée par la plus grande de tous
ordres SELECT confondus (taille du champ le plus important)
- Si une clause ORDER BY est utilisée, il faut spécifier le numéro du
champ et non son nom */

select top 5 * from F_DOCENTETE

select top 5 * from F_DOCLIGNE
--UNION
select top 10 do_date, Do_domaine, do_type, do_piece, do_ref, 'ENTETES'
as Provenance from F_DOCENTETE
UNION ALL
select top 10 do_date, Do_domaine, do_type, do_piece, do_ref, 'LIGNES'
as Provenance from F_DOCLIGNE
order by 1 desc
--INTERSECT
select Do_date, do_domaine, do_type, Do_piece from F_DOCENTETE
INTERSECT
select Do_date, do_domaine, do_type, DO_Piece from F_DOCLIGNE
--EXCEPT
select do_piece, do_date from F_DOCENTETE
EXCEPT
select do_piece, DO_Date from F_DOCLIGNE
order by 2 desc

select do_piece, do_date from F_DOCLIGNE

EXCEPT
select do_piece, DO_Date from F_DOCENTETE

/* SOUS-REQUETES MONO-LIGNES : renvoyer une seule valeur

Imbriquer une requête SELECT dans une requete SELECT, INSERT, UPDATE
Il faut utiliser des opérateurs : =, <, >, <=, >=, <>, !=
-Syntaxe : SELECT champ1, champ2, ... from table where OPERATEUR(sous-
requete)
NB : La sous-requete est d'abord évaluée en premier */

select * from f_docligne where DL_MontantTTC >=(select

AVG(dl_montantTTC) from F_DOCLIGNE)

/* SOUS-REQUETES MULTI-LIGNES : renvoyer plusieurs lignes

-Syntaxe : SELECT champ1, champ2, ... from table where [NOT] IN (sous-
requete) */

select top 10 ar_ref, do_date, * from F_DOCLIGNE where ar_ref in

(select ar_ref from f_article where FA_CodeFamille = 'CUU' and ar_ref
not like 'C%')
select * from F_FAMILLE

/* SOUS-REQUETES DANS LA CLAUSE FROM

Imbriquer un SELECT dans la clause FROM
-Syntaxe : select champ1, champ2, ... from (sous_requete) */

SELECT AVG(DL_montantTTC) from f_docligne

SELECT top 100 A.ar_ref, A.ar_design, D.DL_montantTTC from (select
ar_ref, DL_MontantTTC from f_docligne where
dl_montantTTC > (SELECT AVG(DL_montantTTC) from f_docligne )) as D
Inner join f_article as A
On A.ar_ref = D.ar_ref

select * from f_depot

SELECT D.DE_NO as 'No_Depot_Dept', L.de_no as 'No_Depot_Ligne',
D.DE_INTITULE as "Nom du dépot", L.Do_piece, L.Do_date from f_depot as
D
inner join (select do_piece, do_date, de_no from f_docligne where
do_type in (20, 21, 22, 23) and do_ref is not NULL) as L
on D.de_no = L.de_no

/*LANGAGE DE MANIPULATION (LMD)*/

/*COMMANDE INSERT*/

CREATE TABLE utilisateur

(
ID INT PRIMARY KEY NOT NULL,
nom VARCHAR(100),
prenom VARCHAR(100),
email VARCHAR(255),
date_naissance DATE,
pays VARCHAR(255),
ville VARCHAR(255),
code_postal VARCHAR(5),
nombre_achat INT
)

select * from utilisateur

INSERT INTO utilisateur values (1, 'MANDJO', 'Maxime',
'[email protected]', CAST('1990-01-01' as DATE), 'Cameroun',
'Douala', '550', 0)
INSERT INTO utilisateur values (2, 'PETANG', 'Donald',
'[email protected]', CAST('1991-05-11' as DATE), 'Cameroun',
'Douala', '1000', 30)
INSERT INTO utilisateur values (3, 'KENGNE', 'Sylvie',
'[email protected]', CAST('1992-10-14' as DATE), 'Cameroun',
'Douala', '587', 40)
INSERT INTO utilisateur values (4, 'MANGA', 'Arnaud',
'[email protected]', CAST('1993-11-06' as DATE), 'Cameroun',
'Douala', '85922', 5)
INSERT INTO utilisateur values (5, 'NDONGO', 'Rachelle',
'[email protected]', CAST('1994-08-30' as DATE), 'Cameroun',
'Douala', '2587', 36)
INSERT INTO utilisateur values (6, 'DANG', 'Aline',
'[email protected]', CAST('1995-02-25' as DATE), 'Cameroun',
'Douala', '3569', 25)

INSERT INTO utilisateur (ID, nom, prenom, date_naissance, pays, ville)

values (7, 'ABONG', 'Jules', '1987-05-18', 'Italie', 'Milan')
INSERT INTO utilisateur (ID, nom, prenom, date_naissance, pays, ville,
code_postal, nombre_achat, email)
values (8, 'KAMTO', 'Romeo', '1997-05-10', 'Gabon', 'LibreVille',
DEFAULT, NULL, '[email protected]')

INSERT INTO utilisateur values id = 8, nom = 'ZANGA', prenom =

'Collins', email = '[email protected]', CAST('1970-07-19' as
DATE),
pays = 'Cameroun', ville = 'Yaoundé', nombre_achat = 4

/*INSERER PLUSIEURS LIGNES*/

--Table users sera crée et contiendra les mêmes infos de celle
utilisateur
SELECT * INTO users from utilisateur
select * from users

INSERT INTO users (id, nom, prenom, email, date_naissance, pays, ville,
code_postal, nombre_achat)
SELECT * from utilisateur where pays = 'Gabon'

INSERT INTO users SELECT * from utilisateur where pays = 'Italie'

INSERT INTO utilisateur values

(9, 'YASSA', 'Fany', '[email protected]', CAST('1980-07-11' as
DATE), 'Italie', 'Rome', '154', 20),
(10, 'BATA', 'Karim', '[email protected]', CAST('1998-03-01' as
DATE), 'Gabon', 'Portgentil', '258', 10)

/*COMMANDE UPDATE*/
select * from utilisateur

UPDATE utilisateur SET pays = 'Espagne', ville = 'Barcelone' where nom

= 'KAMTO'
UPDATE utilisateur SET email = '[email protected]' where nom =
'ABONG'
UPDATE utilisateur SET nombre_achat = nombre_achat*2 where ID = 4

SELECT AVG(nombre_achat) from utilisateur --21

UPDATE utilisateur
SET nombre_achat = (SELECT AVG(nombre_achat) from utilisateur)
WHERE ID = 8

/*COMMANDE DELETE*/
select * from users

INSERT INTO users select * from utilisateur where pays = 'Cameroun'

DELETE from Users where ID = 7
DELETE from users where nombre_achat > (select AVG(nombre_achat) + 10
from utilisateur)

/*LANGAGE DE DEFINITION DES DONNEES*/

/*TYPES DE DONNEES*/
--CARACTERES
CHAR(n) : chaine de caractères de longueur fixe (n<16383)
VARCHAR(n) : chaine de caractères de n caractères maximum (n<16383)
NCHAR(n) : valeur alpha de longueur fixe (max 4000) unicode
NVARCHAR(n) : valeur alphanumérique de longueur maximale fixée sur le
jeu de caractère du pays
NB : NCHAR et NVARCHAR sont codés sur 04 octets tandis que CHAR et
VARCHAR sont codés sur 02 octets

--NUMERIQUES
NUMERIC(n,d) : nbre de n chiffres et d nbre de chiffres après la
virgule
INTEGER ou INT : entier signé (avec chiffres négatifs inclus) de 32
bits (-2E31 à 2E31-1)
SMALLINT : entier court signé de 16 bits (-32768 à 32757)
FLOAT : réel à virgule flottante à échelle et précision obligatoire (à
n chiffres de 1 à 53)
REAL : réel à virgule flottante de faible précision
DOUBLE PRECISION : réel à virgule flottante de grande précision
(calculs scientifiques)
BIT : chaine de bit de longueur fixe
BIT VARYING : chaine de bit de longueur maximale

CREATE TABLE voitures

(
IMMAT VARCHAR(20),
PRIX NUMERIC(10, 2)
)

--DATE
DATE : date du calendrier grégorien (AAA-MM-JJ)
TIME : heure sous la forme 12:54:22:56
TIMESTAMP : date et heure

SELECT CAST(GETDATE() as timestamp)

/*LES CONTRAINTES*/

/*
Une clause qui va contraindre la modification dans une table. Assure la
cohérence des données. Spécifiée dès la création de la table ou après
(ALTER TABLE)
CREATE TABLE nom_table (noù_champ CONTRAINTE [...])
ALTER TABLE ADD CONSTRAINT nom_contrainte TYPE CONTRAINTE
- NOT NULL : la colonne ne porte pas de valeur vide (NULL)
- PRIMARY KEY : définir un identifiant clé primaire (on ne peut avoir
deux objets de même champ clé primaire). NB : un index unique sera
automatiquement
créé. Une seule clé primaire par table et ne doit jamais être NULL, pas
de doublon possible.
- UNIQUE : même caractéristique que la clé primaire à l'exception qu'on
peut avoir plusieurs contraintes UNIQUE sur une table et les champs
peuvent avoir
des valeurs NULL
- REFERENCES : clé étrangère qui fait référence d'un champ sur une
autre table. Donc les données qui y seront insérées doivent provenir
d'un champ d'une
autre table
- DEFAULT : préciser la valeur positionnée si aucune information n'a
été définie par défaut
- CHECK : définit les règles de validation. Spécifier les valeurs qui
doivent être insérées dans un champ
*/

CREATE TABLE CONDUCTEURS

(
CODE_CONDUCTEUR INTEGER NOT NULL,
NOM CHAR(50) NOT NULL,
PRENOM CHAR(50) NOT NULL,
AGE INTEGER CHECK (AGE BETWEEN 18 AND 70), /* l'age doit être compris
entre 18 et 70 ans */
MAIL VARCHAR(50) NOT NULL,
DATE_LOCATION DATE DEFAULT GETDATE(), /* Si aucune valeur n'est
spécifiée, la date du système sera celle par défaut */
ADRESSE VARCHAR(50) NULL,
DEPARTEMENT INTEGER NOT NULL,
CONSTRAINT PK_CODE_CONDUCTEUR PRIMARY KEY (CODE_CONDUCTEUR), /* NB :
il n'est pas obligé de mettre un nom sur la contrainte de la PK */
CONSTRAINT UN_MAIL UNIQUE (MAIL)
)
ALTER TABLE CONDUCTEURS ADD CONSTRAINT CHK_DEPARTEMENT CHECK
(DEPARTEMENT BETWEEN 1 AND 95)

INSERT INTO CONDUCTEURS VALUES (1, 'Harabazan', 'Adduck', 40,

'[email protected]', default, NULL, 95)
SELECT * FROM CONDUCTEURS

CREATE TABLE VEHICULES

(
IMMAT VARCHAR(10) NOT NULL PRIMARY KEY,
CODE_CONDUCTEUR INTEGER NOT NULL,
MARQUE CHAR(20) NOT NULL,
MODELE VARCHAR(50) NOT NULL,
NBR_PLACE INTEGER NOT NULL,
CONSTRAINT FK_CODE_CONDUCTEUR FOREIGN KEY (CODE_CONDUCTEUR) REFERENCES
CONDUCTEURS(CODE_CONDUCTEUR), /* Clé étrangère sur un champ de
CONDCUTEURS */
CONSTRAINT CHK_NBR_PLACE CHECK (NBR_PLACE BETWEEN 1 AND 7)
)

select * from CONDUCTEURS

select * from VEHICULES
INSERT INTO VEHICULES VALUES ('LTTR 786', 1, 'RENAULT X5', '874 HR', 2)
select * from CONDUCTEURS C
INNER JOIN VEHICULES V
ON C.CODE_CONDUCTEUR = V.CODE_CONDUCTEUR

/* COMMANDES LDD DE GESTION DES TABLES */

CREATE TABLE TOTO

(
CHAMP1 INTEGER NOT NULL,
CHAMP2 VARCHAR(50) NULL,
CHAMP3 INTEGER CHECK (CHAMP3 > 5)
)

-- AJOUT D'UNE COLONNE

ALTER TABLE CONDUCTEURS ADD PAYS CHAR(10)
-- MODIFICATION D'UNE COLONNE ALTER (SQL) /MODIFIY (oracle ou mysql)
ALTER TABLE CONDUCTEURS ALTER COLUMN PAYS VARCHAR(40)
-- SUPPRESSION D'UNE COLONNE
ALTER TABLE CONDUCTEURS DROP COLUMN PAYS
-- SUPPRIMER UNE TABLE
DROP TABLE VEHICULES
/* NB : Quand un champ d'une table1 est une référence d'une autre
table2, alors c'est impossible de supprimer la table1 */
--Il faudrait d'abord supprimer la contrainte de références (FK) :
ALTER TABLE VEHICULES DROP CONSTRAINT FK_CODE_CONDUCTEUR

/* LES VUES
- Un objet logique auquel est rattaché une requête SQl (SELECT)
- A chaque utilisation de la vue, la requête associée est exécutée
(cacher la complexité d'une requête/permettre l'utilisation
mutuelle de la vue)
- Aucun stockage physique des données de la vue

AVANTAGES
- cacher la complexité de la requête
- la description de la vue est sauvegardée dans la BD (nom, requête
associée)
- une restriction d'accès à la table pour l'user (droits sur les users
sur la vue (pas en modification par exemple) )
- centralisation des requêtes (si elle est modifiée, elle l'est pour
tous les users)
- un groupement d'infos au sein d'une entité (pour le même résultat)

SYNTAXE : CREATE VIEW nom_vue (colonnes) AS SELECT...

SUPPRIMER : DROP VIEW nom_vue */

select top 10 * from f_comptet

select top 1000 * from F_DOCENTETE

--Liste de factures par clients

CREATE VIEW Factures_Clients

AS
SELECT V.Do_piece as Num_Doc, V.Do_date as Date_Doc, C.CT_Intitule as
Nom_Client,
CASE
WHEN V.DO_Domaine = 0 THEN 'VENTES'
WHEN V.Do_Domaine = 1 THEN 'ACHATS'
WHEN V.Do_Domaine = 3 THEN 'STOCKS'
END AS 'Domaine Document',
CASE
WHEN V.Do_type = 6 THEN 'Facture Vente NC'
WHEN V.Do_type = 7 THEN 'Facture Vente CO'
WHEN V.Do_type = 16 THEN 'Facture Achat NC'
WHEN V.Do_type = 17 THEN 'Facture Achat CO'
END AS 'Nature Document'
 FROM F_DOCENTETE V
INNER JOIN F_COMPTET C
ON C.CT_NUM = V.Do_Tiers
WHERE V.Do_Type in (6, 7, 16, 17)

-- Nbre facture par clients

CREATE VIEW Nbre_facture_par_client (client, nombre_facture) /* Les

champs entre parenthèses ne sont pas obligatoire */
AS SELECT C.CT_Intitule, count(*) AS Nbre from F_DOCENTETE V
INNER JOIN F_COMPTET C
ON C.CT_NUM = V.DO_tiers
GROUP BY C.CT_Intitule

SELECT * FROM Nbre_facture_par_client

SELECT * FROM Factures_Clients

/* AUTRES OBJECTS D'UNE BD

SEQUENCES
Objets qui permettent de générer des séries de numéros séquences
uniques. Compteur qui s'incrémente avec un pas d'incrémention
Elles sont des objets à part entière, et peuvent être utilisées sur
plusieurs tables

SYNTAXE
CREATE SEQUENCE nom_sequence --Nom unique
[START WITH <constant>] --Spécifier la valeu de départ du N° de
séquence. Par défaut = valeur dans l'option MINVALUE (séqu ascendante)
[INCREMENT BY <constant>] --Spécifier le pas d'incrémentation du N° de
séquence (positif comme négatif)
[{MINVALUE [<constant>]} | {NO MINVALUE}] --Spécifier la valeur limite
basse (valeur minimale)
[{MAXVALUE [<constant>]} | {NO MAXVALUE}] --Spécifier la valeur limite
haute (valeur maximale)
[CYCLE | {NO CYCLE}] --Spéficier que doit faire la séquence lorsque le
N° séq atteint la valeur MAX (MAXVALUE). Il reveint à MINVALUE et
repart avec le compteur
[{CACHE [<constant>]} | {NO CACHE}] --Forcer l'anticipation de la
génération des valeurs de la séquence en mémoire

MODIFICATION
ALTER SEQUENCE nom_sequence [..]
SUPPRIMER
DROP SEQUENCE nom_sequence (si des champs référencent cette séquence,
impossible de la supprimer)
*/

CREATE SEQUENCE seq_1

START WITH 5
INCREMENT BY 5
MINVALUE 5
MAXVALUE 10000
CYCLE -- Lorsqu'on atteindra 10000, alors le programme repartira à
partir de la valeur MINVALUE 5 et s'incrémentera
CACHE 3 -- reserver 03 valeurs de compteur supplémentaire dans le cache

--NB : On verra cela dans BD - Table - Programmabilité - Séquence

SELECT NEXT VALUE FOR seq_1 --Afficher la prochaine valeur à utiliser

create table t1
(
num integer DEFAULT (NEXT VALUE FOR seq_1),
nom char(20)
)

create table t2
(
num integer DEFAULT (NEXT VALUE FOR seq_1),
nom char(20)
)
--Test des valeurs du compteur
insert into t1 values (default, 'test seq_1 sur t1') --Plus on insère,
plus le compteur augmente
select * from t1

insert into t2 values (default, 'test seq_1 sur t2')

select * from t2

drop table t1, t2

DROP SEQUENCE seq_1

/*
SYNONYMES : alias donné à un objet dans la base de données. Aucun
stockage physique dans le SGBDR
CREATE SYNONYM nom_synonym FOR nom_objet
DROP SYNONYM nom_synonym
*/
--Créer un synonyme pour la table
CREATE SYNONYM documents FOR F_DOCENTETE
CREATE SYNONYM lignes_doc FOR F_DOCLIGNE
CREATE SYNONYM comptes FOR F_COMPTET

SELECT * FROM documents

SELECT * FROM lignes_doc
DROP SYNONYM documents
DROP SYNONYM lignes_doc
DROP SYNONYM comptes

/*
LES INDEX

- objet physique appartenant à une BD. Il occupe de l'espace dans la BD

- est créé d'une manière explicite (CREATE INDEX) ou lors de la
définition d'un champ comme PRIMARY KEY
- peut être positionné sur une ou plusieurs colonnes (index composés)
- permet un accès plus rapide aux données lors des opérations de
SELECT, INSERT, UPDATE, DELETE
- réduit le temps d'accès à la localisation d'une ligne
NB: Plus il y a d'index, plus cela ralenti aussi les opérations

En général on indexe un champ lorsqu'il est utlisé dans une clause

WHERE et quand la requête est un peu lente
ROWID (champ rajouté après création d'un index) adresse de la page qui
contient un enregistrement. C'est un bloc
de données dans la BD et c'est une adresse (qui référence directement
la valeur de l'enregistrement recherché)
Sans index, le système fait un parcours séquentiel de l'ensemble des
données une par une pour renvoyer l'info cherchée
Il chargera toute la table ne mémoire pourtant avec l'index, il charge
juste l'adresse du bloc physique qui contient
la donné recherchée

QUAND UTILISER UN INDEX ?

- sur des tables volumineuses
- sur des colonnes utilisées dans la clause WHERE
RQ : Trop d'index c'est pas bon (occupation disque et mémoire) et
toujours vérifier qu'un index est bien utilisé

SYNTAXE
CREATE [UNIQUE] INDEX nom_index
ON nom_table (nom_champ [ASC/DESC], ...) --Un ou plusieurs champs.

*/
CREATE TABLE TEST_PERF
(
num numeric(10),
nom varchar(50)
)

--Creation d'un boucle (T-SQL) qui va charger 100K lignes dans la table

DECLARE @i INT
SELECT @i = 1
WHILE (@i < 1000001)
BEGIN
INSERT INTO TEST_PERF VALUES (@i, 'Test index LANGAGE SQL');
SELECT @i = @i+1
END

select top 10 * from test_perf

--Avant d'exécuter, aller sur QUERY - Include actual execution plan

SELECT num FROM TEST_PERF WHERE num = 1000000

CREATE INDEX IDX_num ON TEST_PERF (num);

DROP INDEX TEST_PERF.IDX_num

DECLARE @i INT
SELECT @i = 1000001
WHILE (@i < 10000000001)
BEGIN
INSERT INTO TEST_PERF VALUES (@i, 'Test index LANGAGE SQL');
SELECT @i = @i+1
END