Vous êtes sur la page 1sur 32

Le langage SQL

Utilisation de PostgreSQL

Yannick Estève

Université du Maine Institut Claude Chappe

SQL et PostreSQL

1

PostgreSQL : Présentation

! Projet de SGBDR non commercial le plus avancé

! Projet Open Source toujours en développement

! Existence de distributions commerciales (support technique)

! Version stable actuelle : 7.4.5 (en version béta : 8.0, en TP : 7.3.4)

SQL et PostreSQL

3

PostgreSQL : historique

! Système de gestion de bases de données relationnelles

! Projet débuté en 1977 par l’Université de Berkeley (projet Ingres, développé ensuite et commercialisé par Relational Technologies/Ingres Corporation)

! 1986 : une nouvelle équipe de l’Université de Berkeley continue le développement du projet Ingres, nommé alors Postgres

! 1996 : devient PostgreSQL (après ajout de nouvelles fonctionnalités par la communauté du logiciel libre)

SQL et PostreSQL

2

PostgreSQL : fonctionnalités (1)

! SGBD relationnel-objet

! Hautement extensible : l’utilisateur peut définir des opérateurs, des fonctions, des types de données, …

! Support complet de SQL : reconnaissance de SQL 99 + fonctionnalités avancées

! Intégrité référentielle : validité des données d’une base garantie

SQL et PostreSQL

4

PostgreSQL : fonctionnalités (2)

! Interfaces de programmation souples :

souplesse des API. Interfaces pour Object Pascal, Python, Perl, PHP, ODBC, JDBC, Ruby, TCL, C/C++ et Pike

! Langage de procédures : gestion en interne de langage procéduraux : Perl, Python, TCL ou PL/pgSQL

SQL et PostreSQL

5

SQL : Historique (1)

! Modèle relationnel défini en 1970 (E.F. Codd, chercheur de IBM)

! 1974 : Ancêtre de SQL : SEQUEL (Structured English Query Language) développé lors du projet System/R

! 1977 : intégration des fonctionnalités multi- tables et multi-utilisateurs (SEQUEL/2, rebaptisé SQL)

SQL et PostreSQL

7

PostgreSQL : fonctionnalités (3)

! MVCC : Multi-Version Concurrency Control. Pas de verrouillage inutiles (contrairement à Access ou MySQL). Gestion des transactions

! Architecture client/serveur

! WAL : Write Ahead Logging. Améliore la fiabilité de la base de données en mémorisant les modifications avant leur validation sur la base.

SQL et PostreSQL

6

SQL : Historique (2)

! 1978 : test clients. Succès pour IBM.

! Produits commerciaux d’IBM : SQL/DS (1981), DB2 (1983)

! Autres produits de la même époque reposant sur SQL : Oracle (commercialisé en 1979), Sybase, Ingres

SQL et PostreSQL

8

SQL : Normes

! Fin des années 80, plusieurs normes :

" ANSI en 1986 (X3.135)

" ISO en 1987

" ANSI/ISO en 1989 : SQL89 ou SQL1

! ANSI en 1992, SQL92 ou SQL2 : consolidation de

SQL89, ajout de spécification, 3 niveaux de de conformité (minimale, intermédiaire, totale)

! ANSI/ISO en 1999, SQL99 ou SQL3 : intégration de

parties plus avancées (objet, interface de programmation, gestion de l’intégrité). Deux niveaux de conformité : Core SQL99 (SQL99 minimal) et Enhanced SQL99 (SQL99 amélioré)

SQL et PostreSQL

9

Notion de table

! Une table est formée de colonnes et de lignes, dont l’intersection forme des champs

! Les colonnes décrivent le nom et le type des données qui se trouveront dans les lignes

! Les lignes représentent des enregistrements, décrits par le nom et le type des colonnes correspondantes

SQL et PostreSQL

11

PostgreSQL et SQL

! PostgreSQL 7.3.4 est conforme au niveau minimal de SQL92, ainsi qu’à une très grande partie des niveaux intermédiaire et total

! PostgreSQL 7.3.4 est très proche de SQL99 (PostgreSQL étant un pionnier pour beaucoup des spécificités ajoutées à SQL99)

SQL et PostreSQL

10

Exemple de table : la table livre

id

titre

id_auteur

id_sujet

7808

The shining

4156

9

4513

Dune

1866

15

4267

2001 : A Space Odyssey

2001

15

SQL et PostreSQL

12

Ce que n’est pas SQL ! SQL n’est pas un langage procédural de type Pascal
Ce que n’est pas SQL
! SQL n’est pas un langage procédural de type
Pascal ou C
! Pour résoudre un problème avec SQL, il faut
indiquer ce que l’on veut : pas la peine
d’indiquer au système comment obtenir ce
que l’on veut
! Le SGBD décide de la meilleure manière
d’agir pour répondre à nos attentes
SQL et PostreSQL
13
Commandes SQL essentielles de
PostreSQL (1)
Commande
Description
CREATE DATABASE
Crée une base de données
CREATE INDEX
Crée un index sur une colonne
CREATE SEQUENCE
Crée une séquence dans une BD
CREATE TABLE
Crée une table dans une BD
CREATE TRIGGER
Crée un trigger dans une BD
CREATE VIEW
Crée une vue d’une table
SELECT
Récupère des enregistrements
SQL et PostreSQL
15

Exemple de requête SQL

SELECT titre FROM livre WHERE id_sujet=15 ;

SQL et PostreSQL

14

Commandes SQL essentielles de PostreSQL (2)

Commande

Description

INSERT INTO

Ajoute un ou des enregistrements

UPDATE

Modifie un ou des enregistrements

DELETE

Supprime un ou des enregistrements

DROP DATABASE

Supprime une BD

DROP INDEX

Supprime un index d’une table

DROP SEQUENCE

Supprime une séquence

DROP TABLE

Supprime une table

SQL et PostreSQL

16

Commandes SQL essentielles de PostreSQL (3)

Commande

Description

DROP TRIGGER

Supprime un trigger

DROP VIEW

Supprime une vue

CREATE USER

Ajoute une compte utilisateur

ALTER USER

Modifie un compte utilisateur

DROP USER

Supprime un compte utilisateur

GRANT

Donne des droits sur un objet

REVOKE

Supprime ces droits

SQL et PostreSQL

17

Mots-clés et identificateurs

! Les mots-clés sont tous les termes réservés de SQL (commandes, opérateurs, …)

! Identificateurs : objets définis en interne (nom de table, de fonction, etc.)

! Mots-clés et identificateurs :

" Longueur maxi 31 caractères (au-delà, tronqués)

" Les identificateurs commencent par une lettre ou par un blanc souligné. Les mots-clés ne commencent que par une lettre. Dans les 2 cas, les caractères suivants peuvent être des lettres, des chiffres ou des blancs soulignés

SQL et PostreSQL

19

Commandes SQL essentielles de PostreSQL (4) Commande Description CREATE FUNCTION Crée une fonction SQL dans
Commandes SQL essentielles de
PostreSQL (4)
Commande
Description
CREATE FUNCTION
Crée une fonction SQL dans une BD
CREATE LANGUAGE
Défini un langage dans une BD
CREATE OPERATOR
Défini un opérateur dans une BD
CREATE TYPE
Défini un type SQL dans une BD
SQL et PostreSQL
18
Types de données
SQL : Langage fortement typé
SQL et PostreSQL
20

Booléens et binaires

 

Type

Description

Norme

boolean, bool

Valeur unique : true ou false

SQL99

bit(n)

Chaîne de bits de longueur n

SQL92

bit varying(n),

chaîne de bits de longueur n variable (n=taille max)

SQL92

varbit(n)

 

SQL et PostreSQL

21

Types numériques (1)

 

Type

Description

Norme

smallint, int2

Entier sur 2 octets

SQL89

integer, int, int4

Entier sur 4 octets

SQL92

bigint, int8

Entier sur 8 octets (jusqu’à 18 chiffres)

Spécif.

P_SQL

 

SQL et PostreSQL

23

Types caractères

 

Type

Description

Norme

character(n), char

Chaîne de caractères de

SQL89

(n)

longueur n

character varying (n), varchar(n)

Chaîne de caractères de longueur n variable

SQL92

text

Chaîne de caractères de longueur variable et illimitée

Spécificité

PostgreSQL

 

SQL et PostreSQL

22

Types numériques (2)

 

Type

Description

 

Norme

real, float4

Flottant sur 4 octets

 

SQL89

double precision, float8, float

Flottant sur 8 octets

 

SQL89

numeric(p,s),

Type numérique exact avec

Spécif.

decimal(p,s)

précision p quelconque et facteur d’échelle s

 

P_SQL

 

SQL et PostreSQL

24

Types numériques (3) Type Description Norme money Valeur monétaire de type US, obsolète Spécif. P_SQL
Types numériques (3)
Type
Description
Norme
money
Valeur monétaire de type US, obsolète
Spécif.
P_SQL
serial
Entier sur 4 octets avec
incrémentation automatique
Spécif.
P_SQL
SQL et PostreSQL
25
Autres types
! D’autres types existent spécifiques à
PostgreSQL :
" Types géométriques : box, line, lseq, circle,
path, point, polygon
" Types pour le réseau : cidr (Adresse/masque
IP), inet (Adresse IP), macadr (Adresse MAC,
ex. adresse Ethernet)
" Types pour système : oid, xid
SQL et PostreSQL
27
 

Date et heure

Type

Description

Norme

date

Date du calendrier (jour, mois, année)

SQL92

time

Heure

SQL92

time with time zone

Heure avec les informations sur la zone horaire

SQL92

interval

Délai quelconque

SQL92

 

SQL et PostreSQL

26

 

Opérateurs

SQL et PostreSQL

28

Opérateurs ! Opérateurs sur les chaînes de caractères ! Opérateurs sur les nombres ! Opérateurs
Opérateurs
! Opérateurs sur les chaînes de caractères
! Opérateurs sur les nombres
! Opérateurs logiques
SQL et PostreSQL
29
Opérateurs de comparaison sur les
chaînes de caractères (suite)
Opérateur
Description
LIKE, ILIKE
Exemple : a LIKE b
Teste si la chaîne a correspond au motif b
SQL et PostreSQL
31
Opérateurs de comparaison sur les chaînes de caractères Opérateur Description = teste l’égalité (true si
Opérateurs de comparaison sur les
chaînes de caractères
Opérateur
Description
=
teste l’égalité (true si égalité)
!=
teste l’inégalité (true si inégal)
<>
idem !=
<
teste l’ordre alphabétique (ex. : a<b vraie si a
placé avant b dans l’ordre alphabétique
<=
teste l’ordre alphabétique
>
teste l’ordre alphabétique
>=
teste l’ordre alphabétique
SQL et PostreSQL
30
Concaténation de chaînes
! Opérateur ||
! Exemple :
SELECT ‘Le Titre : ‘ || titre || ‘, par’ ||
!
prenom || ‘ ‘ || nom AS info_livre
FROM livres NATURAL JOIN auteurs;
!
!
SQL et PostreSQL
32

Opérateurs mathématiques

 

Opérateur

Description

+

addition

-

soustraction

*

multiplication

/

division

^

exposant (a ^b)

SQL et PostreSQL

33

Opérateurs de comparaisons numériques

 

Opérateur

Description

<

strictement plus petit

>

strictement plus grand

<=

inférieur ou égal

>=

supérieur ou égal

=

égalité

<> ou !=

inégalité

SQL et PostreSQL

35

Opérateurs mathématiques (suite) Opérateur Description |/ racine carrée (|/a) ||/ racine cubique (||/a) ! et
Opérateurs mathématiques (suite)
Opérateur
Description
|/
racine carrée (|/a)
||/
racine cubique (||/a)
!
et !!
factorielle (!a ou !!a)
@
valeur absolue (@a)
SQL et PostreSQL
34
Opérateurs logiques
AND (et booléen)
OR (ou booléen)
NOT (non booléen)
SQL et PostreSQL
36

Fonctions agrégats

! Fonctions portant sur plusieurs lignes

SELECT avg(sal) FROM employe;

SELECT grade, avg(sal) FROM employe GROUP BY grade ORDER BY avg DESC;

SQL et PostreSQL

37

Fonctions de conversion de types

Fonction

Description

bitfromint4(n)

Convertit une valeur numérique en chaîne de bits

bittoint4(b)

Convertit une chaîne de bit dans sa représentation décimale

to_char(n, f)

Convertit une valeur numérique n en une chaîne de caractère selon le format f

to_date(s, f)

Convertit une chaîne de caractères s en type date sous le format f

to_number(s, f)

Convertit la chaîne s en une valeur de type numéric selon le format f

SQL et PostreSQL

39

Fonctions agrégats (2)

Fonction

Description

avg(expression)

Moyenne pour toutes les lignes d’un groupe

count(expression)

Nombre de valeurs, par groupe de lignes, non NULL

max(expression)

Valeur maximale dans un groupe de ligne

min(expression)

Valeur minimale

stddev(expression)

Renvoie l’écart-type

sum(expression)

Renvoie la somme

variance(expression)

Renvoie la variance

SQL et PostreSQL

38

Fonctions de conversion de types (suite)

Fonction

Description

to_timestamp(s,

Convertit la chaîne de caractères s en une valeur

f)

de type timestamp selon le format f

timestamp(d)

Convertit d, de type date, en valeur de type timestamp

timestamp(d, t)

Renvoie une valeur de type timestamp construite à partir de d et t, respectivement de type date et time

SQL et PostreSQL

40

Exemple de conversion

SELECT to_char(123456789, ‘999G999G999D99’) AS formaté, to_char(123456789, ‘999999999’) AS chi" res_seuls, to_char(123456789, ‘00999999999’) AS avec_zeros;

formaté | chiffres_seuls | avec_zeros

---------------------+---------------------+------------------------------------

123.456.789,00 | 123456789 | 00123456789

SQL et PostreSQL

41

Select

! La commande SELECT est au cœur de toutes les requêtes SQL

! Les données renvoyées forment un ensemble résultat formé de lignes et de colonnes

! L’ensemble résultat n’est pas stocké sur disque : résultat temporaire

! Commande SELECT : commande certainement la plus complexe

SQL et PostreSQL

43

Récupération de lignes avec SELECT SQL et PostreSQL 42 Syntaxe de SELECT SELECT [ ALL
Récupération de lignes
avec SELECT
SQL et PostreSQL
42
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
)
] ]
* | cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
[
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
44
Syntaxe de SELECT : détails " ALL : inutile, juste pour la lisibilité " DISTINCT
Syntaxe de SELECT : détails
" ALL : inutile, juste pour la lisibilité
" DISTINCT [ ON ( expression [, …] ) ] : précise
que l’on ne renverra qu’une ligne en cas de
valeurs dupliquées de expression
" cible [ AS nom ] [, …] : nom de colonne,
constante, identificateur, ou fonction. Peut
être renommée en nom (alias) avec la clause
AS
SQL et PostreSQL
45
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
) ]
]
* | cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
47

Syntaxe de SELECT : détails (suite)

" FROM source [, …] : indique la source dans laquelle chercher les cibles voulues. source est un nom de table ou une sous-requête.

" WHERE condition : cette clause contraint l’ensemble résultat de l’instruction SELECT en fonction de critères définis par condition

SQL et PostreSQL

46

Syntaxe de SELECT : détails (suite)

" GROUP BY expression [, …] : regroupe des lignes selon le critère de expression

" HAVING condition : teste les conditions sur les ensembles groupés par GROUP BY au lieu de le faire sur chaque ligne

SQL et PostreSQL

48

Syntaxe de SELECT SELECT [ ALL | DISTINCT [ ON ( expression [, ] )
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
) ]
]
* | cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
49
Syntaxe de SELECT :
Jointures produits
" FROM source1 CROSS JOIN source2
$ Produit cartésien de source1 et source2
$ Equivalent à : FROM source1, source2
SQL et PostreSQL
51

Syntaxe de SELECT : détails (suite)

" FROM source1 [ NATURAL ] type_jointure source2 ON ( condition [, …] ) USING ( colonne [, …] )

# 3 types de jointures :

$ jointures produits ( CROSS JOIN ),

$ jointures internes ( [INNER JOIN] )

$ jointures externes ( LEFT [OUTER] JOIN, RIGHT [OUTER] JOIN, FULL [OUTER] JOIN )

SQL et PostreSQL

50

Syntaxe de SELECT :

Jointures internes

" FROM source1 [NATURAL] [INNER] JOIN source2 ON ( condition, [, …] ) USING ( colonne, [, …] )

$ Produit cartésien de source1 et source2, mais seules les lignes qui respectent les contraintes explicitées dans ON ( condition …) sont conservées.

$ USING détermine les noms de colonnes identiques pour lesquelles il faut que les valeurs soient égales pour effectuer la jointure

$ L’utilisation de NATURAL indique que toutes les colonnes de noms identiques doivent contenir la même valeur pour être jointe

SQL et PostreSQL

52

Exemple de jointure interne

SELECT * FROM stock NATURAL INNER JOIN editions;

| prix_achat | prix_vente | stock | id_livre | edition | id_editeur | parution | type

------------+------------+------------+-------+----------+---------+------------+------------+------

isbn

0385121679

|

29.00 |

36.95 |

65 |

7808 |

2 |

 

75 | 1993-10-01 | h

039480001X |

30.00 |

32.95 |

31 |

1608 |

1

|

59 | 1957-03-01 | h

0394800753 |

16.00 |

16.95 |

4 |

1590 |

1

|

59 | 1949-03-01 | p

0394900014

|

23.00 |

23.95 |

0 |

1608 |

1

|

59 | 1957-01-01 | p

044100590X |

36.00 |

45.95 |

89 |

4513 |

3

|

99 | 1999-10-01 | h

0441172717

|

17.00 |

21.95 |

77 |

4513 |

2 |

99 | 1998-09-01 | p

SQL et PostreSQL

53

Syntaxe de SELECT :

Jointures externes

" FROM source1 [NATURAL] LEFT | RIGHT | FULL [OUTER] JOIN source2 ON ( condition, [, …] ) USING ( colonne, [, …] )

$ Une jointure externe peut conserver les lignes pour lesquelles il n’a pas été trouvé de correspondance entre les ensembles joints : les colonnes manquantes sont alors remplies avec la valeur NULL

$ LEFT, RIGHT ou FULL précise qu’au moins une instance de chaque ligne de l’ensemble situé à gauche (ou à droite, ou des 2 cotés) du mot-clé JOIN sera présente

SQL et PostreSQL

55

Exemple de jointure externe SELECT titre, isbn FROM livres LEFT OUTER JOIN editions ON (livres.id=editions.id_livre);
Exemple de jointure externe
SELECT titre, isbn FROM livres LEFT OUTER JOIN editions
ON (livres.id=editions.id_livre);
titre
|
isbn
-----------------------------+------------
The Tell-Tale Heart
The Tell-Tale Heart
Little Women
The Velveteen Rabbit
The Shining
Franklin in the Dark
Practical PostgreSQL
Programming Python
Learning Python
Perl Cookbook
| 1885418035
| 0929605942
| 0760720002
| 0679803335
| 0451160916
| 0590445065
|
| 0596000855
|
|
SQL et PostreSQL
54
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
)
] ]
* | cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
56

Syntaxe de SELECT : détails (suite)

" {UNION | INTERSECT | EXCEPT} [ALL] sous- requete : effectue l’une des trois opérations ensemblistes entre le résultat de l’instruction SELECT et celui d’une autre requête. Les lignes dupliquées sont supprimées sauf si le mot-clé ALL est utilisé

SQL et PostreSQL

57

Syntaxe de SELECT : détails (suite)

" ORDER BY expression : Trie le résultat de l’instruction SELECT selon expression

" ASC : croissant

" DESC : décroissant

" USING < (ou USING >)

" LIMIT { nombre | ALL } : limite le nombre de lignes renvoyées à nombre

" OFFSET debut : indique à partir de quel numéro de ligne commence l’affichage du résultat

SQL et PostreSQL

59

Syntaxe de SELECT SELECT [ ALL | DISTINCT [ ON ( expression [, ] )
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
)
] ]
*
| cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
58
Syntaxe de SELECT
SELECT [ ALL | DISTINCT [ ON ( expression [,
]
)
] ]
*
| cible [ AS nom ] [,
]
[
FROM source [,
]
]
[
[ NATURAL ] type_jointure
ON condition ] | USING ( liste_colonnes ) ] ]
[, …]
[
[
WHERE condition ]
[
GROUP BY expression [,
]
]
[
HAVING condition [,
]
]
[
{ UNION | INTERSECT | EXCEPT } [ ALL ] sous-requete ]
[
ORDER BY expression
[
ASC | DESC | USING operateur ]
[,
]
]
[
LIMIT { nombre | ALL } ]
[
OFFSET debut ]
[
FOR UPDATE [ OF nom_table [,
]
] ]
SQL et PostreSQL
60

Syntaxe de SELECT : détails (suite)

! FOR UPDATE [ OF nom_table [, …] ] : effectue un verrouillage exclusif sur les lignes renvoyées jusqu’à ce que la transaction soit validée. Pendant qu’elles sont verrouillées, les lignes ne peuvent pas être modifiées par d’autres transactions

SQL et PostreSQL

61

Modification de lignes avec UPDATE

UPDATE [ ONLY ] nom_table SET colonne = expression

[,

]

[

FROM source ]

[

WHERE condition ]

! La clause SET peut être suivie de plusieurs expressions de type colonne=expression

! FROM : extension non standard de PostgreSQL permettant d’utiliser des colonnes d’autres tables pour pouvoir mettre à jour la table nom_table

! WHERE : permet de déterminer les lignes concernées par la mise à jour

SQL et PostreSQL

63

Création de tables à partir d’autres tables

SELECT cibles INTO [ TABLE ] nouvelle_table FROM table_existante;

! La table indiquée dans la clause INTO ne doitpas déjà exister ou la requete produira une erreur et les valeurs ne seront pas insérées

SQL et PostreSQL

62

Exemple de modification

UPDATE stock SET prix_vente=prix_vente+0.1*prix_vente WHERE stock<10;

SQL et PostreSQL

64

Suppression de lignes avec DELETE

DELETE FROM [ONLY] nom_table [WHERE condition]

! WHERE condition : cette clause décrit la condition que doivent remplir les lignes qui seront supprimées. Si cette clause est omise, toutes les lignes de la table seront supprimées (DANGER !)

SQL et PostreSQL

65

Notion de vue

! Une vue fonctionne comme une table virtuelle

! On peut considérer qu’une vue est une requête stockée, dont le contenu est dynamique

! Les vues ajoutent de la souplesse en allégeant des requêtes trop lourdes

SQL et PostreSQL

67

Exemple de suppression de lignes

DELETE FROM stock WHERE stock=0;

SQL et PostreSQL

66

Création d’une vue

CREATE VIEW nom_vue AS requete

! nom_vue : nom de la vue (!), son identificateur

! requete : il s’agit d’une requête SELECT complète

SQL et PostreSQL

68

Exemple de création de vue

CREATE VIEW expeditions_recentes AS SELECT count(*) AS nb_expedies, max(date_exp), titre FROM expedition JOIN editions USING (isbn) NATURAL JOIN livres AS l (id_livre) GROUP BY l.titre ORDER BY nb_expedies DESC;

SQL et PostreSQL

69

Correction de quelques exercices de TP

SQL et PostreSQL

71

Suppression d’une vue

DROP VIEW nom_vue

! Exemple :

DROP VIEW expeditions_recentes

SQL et PostreSQL

70

TP1. Question 9

A combien s’élèverait le bénéfice virtuel si tout le stock de livres était vendu ! ? Bien entendu, ce montant doit être trouvé en une seule requête (on n’utilise pas les résultats des deux questions précédentes).

SQL et PostreSQL

72

 

Rappel table stock

 

Table "public.stock"

 

Column

|

Type

| Modifiers

------------+--------------

 

+-----------

 

isbn

| text

| not null

prix_achat | numeric(5,2) |

 

prix_vente | numeric(5,2) |

stock

| integer

|

Indexes: stock_pkey primary key btree (isbn)

 
 

SQL et PostreSQL

73

 

TP1. Question 10

 

Quel est le nom de l’auteur qui a écrit le plus de livres qui se trouvent en stock !?

 

SQL et PostreSQL

75

Réponse

SELECT sum( (prix_vente-prix_achat)*stock ) AS benefice FROM stock;

benefice

----------

2721.40

(1 row)

SQL et PostreSQL

74

Rappel table editions

Table "public.editions"

Column

|

Type

| Modifiers

------------+--------------+-----------

isbn

| text

| not null

id_livre

| integer

|

edition

| integer

|

id_editeur | integer

|

parution

| date

|

type

| character(1) |

Indexes: pkey primary key btree (isbn) Check constraints: "integrity" ((id_livre IS NOT NULL) AND (edition IS NOT NULL)) Rules: sync_stock_with_editions

SQL et PostreSQL

76

Rappel table livres

Table "public.livres"

Column

|

Type

| Modifiers

-----------+---------+-----------

id

titre

| integer | not null

| text

| not null

id_auteur | integer | id_sujet | integer | Indexes: livres_id_pkey primary key btree (id), livres_titre_idx btree (titre)

SQL et PostreSQL

77

Solution 1

SELECT nom FROM auteurs, livres, editions NATURAL JOIN stock WHERE auteurs.id=livres.id_auteur AND livres.id=editions.id_livre GROUP BY auteurs.id, nom ORDER BY sum(stock) DESC, nom ASC LIMIT 1;

SQL et PostreSQL

79

Rappel table auteurs Table "public.auteurs" Column|Type|Modifiers id|integer|not null nom|text| prenom|text|
Rappel table auteurs
Table "public.auteurs"
Column|Type|Modifiers
id|integer|not null
nom|text|
prenom|text|
Indexes: auteurs_pkey primary key btree (id)
SQL et PostreSQL
78
Solution 2
SELECT nom
FROM auteurs, livres, editions NATURAL JOIN stock
WHERE auteurs.id=livres.id_auteur
AND livres.id=editions.id_livre
GROUP BY auteurs.id, nom
HAVING sum(stock) >= ALL (
SELECT sum(stock)
FROM auteurs, livres, editions NATURAL JOIN stock
WHERE auteurs.id=livres.id_auteur
AND livres.id=editions.id_livre
GROUP BY auteurs.id, nom
);
SQL et PostreSQL
80

TP1. Question 11

Donnez le nombre de titres différents édités par chaque éditeur, classé par ordre décroissant du nombre de titres différents par éditeur.

SQL et PostreSQL

81

Solution

! 1ère étape : création d’une vue

CREATE VIEW titre_par_editeur AS SELECT id_editeur, id_livre FROM editions GROUP BY id_editeur, id_livre;

SQL et PostreSQL

83

 

Rappel table editeurs

Table "public.editeurs"

 

Column | Type

 

| Modifiers

---------+---------+-----------

 

id

| integer | not null

nom

| text

|

adresse | text

 

|

Indexes: editeurs_pkey primary key btree (id),

 

unique_editeur_idx unique btree (nom)

 

SQL et PostreSQL

82

 

Contenu de la vue

id_editeur | id_livre

 

------------+----------

 

59

|

1590

59

|

1608

62

|

2038

65

|

1501

75

|

7808

91

|

190

99

|

4513

101

|

4267

102

|

1234

113

|

41473

150

|

25908

163

|

156

171

|

156

 

(13 rows)

 
 

SQL et PostreSQL

84

Solution (suite et fin)

! 2ème étape : requête utilisant la vue créée

SELECT e.nom, count(*) Nbre_titres_différents FROM editeurs e, titre_par_editeur WHERE e.id=titre_par_editeur.id_editeur GROUP BY e.id, e.nom ORDER BY Nbre_titres_différents DESC;

SQL et PostreSQL

85

CREATE TABLE : Syntaxe

CREATE [ LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name ( { column_name data_type [ DEFAULT

default_expr ] [ column_constraint [,

)

| table_constraint } [,

SQL et PostgreSQL

]

] ]

87

Création de tables

SQL et PostgreSQL

86

CREATE TABLE : Exemple

Exemple :

CREATE TABLE avion ( id_avion integer NOT NULL, id_type integer NOT NULL, ville_localisation integer NOT NULL, Constraint avion_pkey Primary Key (id_avion)

);

SQL et PostgreSQL

88

Contrainte de colonne : syntaxe

[ CONSTRAINT constraint_name ] { NOT NULL | NULL | UNIQUE | PRIMARY KEY | CHECK (expression) | REFERENCES reftable [ ( refcolumn ) ] [ ON DELETE action ] [ ON UPDATE action ] }

SQL et PostgreSQL

89

Modification de la structure d’une table

! Il est possible de modifier la structure d’une table après sa création, même si des données sont déjà intégrées

! Les modifications peuvent concerner n’importe quel objet de la table : colonnes, contraintes, propriétaire, …

SQL et PostgreSQL

91

Contrainte de table : syntaxe [ CONSTRAINT constraint_name ] { UNIQUE ( column_name [, ]
Contrainte de table : syntaxe
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [,
] ) |
PRIMARY KEY ( column_name [,
CHECK ( expression ) |
FOREIGN KEY ( column_name [,
] ) |
] )
REFERENCES reftable [ ( refcolumn [,
] ) ]
[ ON DELETE action ] [ ON UPDATE action ] }
SQL et PostgreSQL
90
ALTER TABLE : Syntaxes
ALTER TABLE [ ONLY ] table [ * ]
ADD [ COLUMN ] column type
[ column_constraint [
] ]
ALTER TABLE [ ONLY ] table [ * ]
DROP [ COLUMN ] column [ RESTRICT |
CASCADE ]
SQL et PostgreSQL
92

ALTER TABLE : Syntaxes (2)

ALTER TABLE [ ONLY ] table [ * ] ALTER [ COLUMN ] column { SET DEFAULT value | DROP DEFAULT }

ALTER TABLE [ ONLY ] table [ * ] ALTER [ COLUMN ] column { SET | DROP } NOT NULL

SQL et PostgreSQL

93

ALTER TABLE : Syntaxes (4)

ALTER TABLE [ ONLY ] table [ * ] ADD table_constraint

ALTER TABLE [ ONLY ] table [ * ] DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]

SQL et PostgreSQL

95

ALTER TABLE : Syntaxes (3)

ALTER TABLE [ ONLY ] table [ * ] RENAME [ COLUMN ] column TO new_column

ALTER TABLE table RENAME TO new_table

SQL et PostgreSQL

94

ALTER TABLE : Syntaxes (5)

ALTER TABLE table OWNER TO new_owner

SQL et PostgreSQL

96

Suppression de table DROP TABLE name [, ] [ CASCADE | RESTRICT ] SQL et
Suppression de table
DROP TABLE name [,
]
[ CASCADE | RESTRICT ]
SQL et PostgreSQL
97
Création de fonctions : Syntaxe
CREATE [ OR REPLACE ] FUNCTION nom ( [ argtype
[,
]
]
)
RETURNS rettype
AS ‘definition’
LANGUAGE ‘nom_langage’
[ WITH ( attribut [,
]
) ]
SQL et PostgreSQL
99

Création de fonctions

! PostgreSQL offre la possibilité d’étendre ses capacités en permettant la création de nouvelles fonctions

! Ces fonctions peuvent simplifier l’élaboration des requêtes SQL

! Chaque fonction devient liée à une base déterminée (comme tous les autres objets d’une base de données : tables, vues, …)

SQL et PostgreSQL

98

Création de fonctions : Syntaxe (2)

CREATE FUNCTION nom ( [ argtype [,

] ] )

! nom est le nom de la fonction

! argtype, … sont les types des paramètres attendus lors de l’appel de la fonction

! Il peut ne pas y avoir de paramètre, mais les parenthèses sont obligatoires pour l’appel d’une fonction

SQL et PostgreSQL

100

Création de fonctions : Syntaxe (3)

RETURNS rettype

! Indique le type de données simple renvoyé par la fonction

AS definition

! Définit le code de la fonction elle-même. Pour les langage procéduraux de type PL/pgSQL, il s’agit du code de la fonction

! Pour les fonctions écrites en C et compilées, il s’agit du chemin absolu menant au fichier contenant le code objet sur le système

SQL et PostgreSQL

101

Création de fonctions : Surcharge

! Il est possible de surcharger une fonction :

" plusieurs fonctions peuvent porter le même nom

" leurs listes de paramètres doivent être différentes les unes des autres

SQL et PostgreSQL

103

Création de fonctions : Syntaxe (4)

[ WITH ( attribut [,

! attribut : iscachable. Possibilité de pré-évaluer un appel de fonction si celle-ci a déjà été évaluée avec les mêmes paramêtres : optimisation

! attribut : isstrict. Force la fonction à toujours renvoyer NULL si un de ses paramètres vaut NULL. La fonction n’est même pas exécutée

] ) ]

SQL et PostgreSQL

102

Exemple de fonction

CREATE FUNCTION isbn_titre (text) RETURNS text AS ‘SELECT titre FROM livres JOIN edition AS e (isbn, id) USING (id) WHERE isbn=$1’ LANGUAGE ‘SQL’;

! Remarque : une fonction SQL utilise des paramètres positionnels pour identifier les paramètres passés à l’appel de la fonction.

SQL et PostgreSQL

104

Exemple d’utilisation d’une fonction SELECT isbn_titre(‘0929605942’); isbn_titre ------------------------ The
Exemple d’utilisation d’une fonction
SELECT isbn_titre(‘0929605942’);
isbn_titre
------------------------
The Tell-Tale Heart
SQL et PostgreSQL
105
Exemple de création
d’une fonction C
int est_nul(int a) {
if (a==0) return 1;
return 0;
}
gcc -shared est_nul.c -o est_nul.so
SQL et PostgreSQL
107

Créations de fonctions C

! Il est possible de charger dynamiquement du code C compilé

! Seuls les administrateurs peuvent utilisés la commande CREATE FUNCTION pour établir un lien vers une fonction C : ceci pour des raisons de sécurité

! Avec gcc, il faut utiliser l’option -shared lors de la compilation du code C

SQL et PostgreSQL

106

Exemple de création d’une fonction C (suite)

CREATE FUNCTION est_nul(int4) RETURNS boolean AS ‘/home/esteve/exemple_SQL/est_nul.so’ LANGUAGE ‘C’;

SQL et PostgreSQL

108

Fonctions prédéfinies :

 

fonctions mathématiques (1)

abs(x)

valeur absolue

acos(x)

arc cosinus

asin(x)

arc sinus

atan(x)

arc tangente

atan2(x,y)

arc tangente du quotient x/y

cbrt(x)

racine cubique

ceil(x)

arrondi au supérieur

cos(x)

cosinus

cot(x)

cotangente

 

SQL et PostgreSQL

109

Fonctions prédéfinies :

 

fonctions mathématiques (3)

radians(d)

valeur en radians de d en degrés

random()

tirage aléatoire entre 0.0 et 1.0

round(x)

arrondi à l’entier le plus proche

round(x,s)

arrondi à s décimales

sin(x)

sinus

sqrt(x)

racine carrée

tan(x)

tangente

trunc(x)

renvoie x sans sa partie décimale

trunc(x,s)

idem, en gardant s décimales

 

SQL et PostgreSQL

111

Fonctions prédéfinies :

fonctions mathématiques (2)

degrees(r)

valeur en degré de r en radians

exp(x)

e

exposant x

floor(x)

arrondi inférieur

ln(x)

log népérien

log(b,x)

log de x en base b

log(x)

log 10

mod(x,y)

x

modulo y

pi()

pi

pow(x,x)

x

puissance y

SQL et PostgreSQL

110

Fonctions prédéfinies :

fonctions chaînes de caractères (1)

ascii(s)

code ascii du premier caractère de s

btrim(s[,t])

renvoie s sans les lettres de t qui se trouvent en début ou fin de s

char_length(s)

renvoient la longueur de s

length(s)

chr(n)

renvoie le caractère de code ASCII n

s

like(f)

renvoient ‘true’ si le motif f correspond à

s

ilike(f)

s (ilike ne tient pas compte de la casse)

initcap(s)

renvoie s, les initiales de chaque mot étant mises en majuscule

SQL et PostgreSQL

112

Fonctions prédéfinies : fonctions chaînes de caractères (2) lower(s) renvoie s avec tous les caractères
Fonctions prédéfinies :
fonctions chaînes de caractères (2)
lower(s)
renvoie s avec tous les caractères de s en minuscule
upper(s)
renvoie s avec tous les caractères de s en
majuscule
ltrim(s[,t])
rtrim(s[,t])
comme btrim, mais ne concernent que les
caractères de début (ltrim) ou de fin (rtrim)
position (b IN s)
renvoient la position de la sous-chaîne b dans s (en
comptant à partir de 1)
substr(s, n [,l])
Renvoie une sous-chaîne de s commençant au n-ième
caractère de s et de longueur maximale l
SQL et PostgreSQL
113
Triggers (suite)
! Pour faciliter la gestion d’évènements SQL
devant intervenir lors de la mise en œuvre
d’actions bien définies, PostgreSQL offre
l’utilisation de triggers (déclencheurs)
! Les triggers affectent les événements SQL
suivant :
" INSERT
" UPDATE
" DELETE
SQL et PostgreSQL
115

Triggers

! Une action donnée doit souvent être précédée ou suivie d’évènements SQL connus à l’avance :

" vérification de la cohérence des données à insérer

" formatage des données

" mise à jour de tables après la modification ou la suppression de lignes d’une table particulière

SQL et PostgreSQL

114

Triggers (suite 2)

! Pour créer un trigger, il faut d’abord créé la fonction qu’il utilisera

! Attention ! Les triggers sont une extension de SQL offerte par PostgreSQL : pas de portabilité (Oracle propose également des triggers mais ils sont gérés différemment)

SQL et PostgreSQL

116

Création de trigger : syntaxe

CREATE TRIGGER nom { BEFORE | AFTER }

{ évènement [OR

] }

ON table FOR EACH { ROW | STATEMENT } EXECUTE PROCEDURE func ( arguments )

SQL et PostgreSQL

117

Transactions (suite)

! PostgreSQL offre un système de gestion des transactions efficace : le MVCC (Multi-Version Concurrency Control)

! Par défaut chaque opération est validée et est elle- même une transaction

! Pour spécifier qu’un groupe d’opérations doit être considéré comme une transaction, il faut déclarer explicitement l’entrée dans un bloc transactionnel

SQL et PostgreSQL

119

Transactions

! La gestion de transactions permet d’assurer l’intégrité des données

! Une transaction peut être considérée comme un groupe d’opérations qui forment une unité indivisible

! Les opérations d’une transaction sont donc toutes effectuées, ou aucune n’est effectuée

SQL et PostgreSQL

118

Bloc transactionnel

! Un bloc transactionnel est un ensemble d’opérations indivisibles : ce type de bloc détermine le contenu d’une transaction

! Tant que la fin d’un bloc transactionnel n’est pas atteinte, les éventuelles modifications de la base de données ne sont pas validées au niveau des données partagées par tous les utilisateurs

SQL et PostgreSQL

120

Bloc transactionnel (suite)

! Le début d’un bloc transactionnel est déclarée de la manière suivante :

BEGIN [WORK | TRANSACTION]

! WORK et TRANSACTION ne servent à rien (bruit)

SQL et PostgreSQL

121

ROLLBACK et COMMIT :

Exemple

BEGIN ;

UPDATE licence_pilote SET licence=‘BO’ WHERE

id_pilote=4;

INSERT INTO VILLE (id_ville, ville) VALUES (9, ‘LE MANS’);

COMMIT;

SQL et PostgreSQL

123

ROLLBACK et COMMIT ! A la fin d’un bloc transactionnel, les opérations sont validées, ou
ROLLBACK et COMMIT
! A la fin d’un bloc transactionnel, les
opérations sont validées, ou annulées.
! Validation :
COMMIT [WORK | TRANSACTION]
! Annulation :
ROLLBACK [WORK | TRANSACTION]
SQL et PostgreSQL
122
Gestion des privilèges :
GRANT (don de privilèges)
GRANT privilege [,…] ON objet [,…] TO
{ username | GROUP groupname | PUBLIC }
[,
]
!
privilèges :
" SELECT (lecture)
" INSERT (insertion de lignes)
" UPDATE (modification de colonnes)
" DELETE (suppression de lignes)
" ALL
SQL et PostgreSQL
124

Gestion des privilèges :

GRANT

GRANT privilège [,…] ON objet [,…] TO

{ username | GROUP groupname | PUBLIC }

[,

]

! objets :

" table : ON [TABLE] nom_table

" fonctions : ON FUNCTION nom_fonction

" bases de données : ON DATABASE nom_bd

" langage : ON LANGUAGE nom_langage

" schéma : ON SCHEMA nom_schema

SQL et PostgreSQL

125

Gestion des privilèges :

REVOKE

REVOKE privilège [,…] ON objet [,…] FROM { username | GROUP groupname | PUBLIC }

[,

]

! Au contraire de GRANT, REVOKE supprime des privilèges à un utilisateur ou un ensemble d’utilisateurs

SQL et PostgreSQL

126