Vous êtes sur la page 1sur 16

LANGAGES

LDD / LMD
"Impedance
mismatch"
L'écriture d'une application
nécessite
l'utilisation de deux Langages :

1 Un langage de requêtes (SQL)


2 Un langage de programmation
(C,...)

Pourquoi ?

• SQL : seul moyen d'interaction avec un


SGBD
• SQL n'est pas complet
Impedance mismatch
(2)

Difficulté de communication
entre les deux Langages

SGBD :

• Ont leurs propres types de donnée


(Relations, Tuples, types de base)
• Algèbre ensembliste
• Langage déclaratif.

Langages de programmation :

• Ont leurs propres types.


• Travaillent un enregistrement à la
fois
• Langages impératifs
Connection
Langage de programmation/
Système relationnel

• Correspondance entre espaces des noms :


Faire correspondre deux systèmes séparés

• Conversions de données :
Types du SGBD à ceux du Langage

• Utilisation d'un curseur


Mode ensembliste / mode enregistrement

• Appels de procédures
Transmettre le travail au SGBD

• Actions spécifiques
Contrôle d'intégrité, ...
Problèmes engendrés

• Apprendre deux Langages

• Contrôler les transferts de données entre


le programme d'application et
la base de données

• Décider ou effectuer certaines taches

• Contrôle de type
=> précompilation faisant appel au SGBD

A L'EXECUTION

• Communication entre deux processus.


=> Overhead

• Est-il souhaitable de faire autrement ?


D'ou vient cette situation ?

• Les premiers SGBD étaient ciblés pour


écrire des applications en COBOL

=> Ecrire des requêtes ad hoc était


impossible certaines requêtes engendraient
des programmes compliqués.

En réaction les systèmes relationnels ont


proposé des langages déclaratifs en omettant
les problèmes pour écrire des applications.

=> Les L4G tentent de rattraper


cette situation.
Exemple : O2
Types et classes

1) Systèmes OO : une classe doit être définie


pour chaque type de valeur complexe

O2 : simplification : la hiérarchie de classes ne


doit contenir que les types partagés par différents
modules

2) Classe : les instances sont des objets


encapsulés
Type : les instances sont des valeurs

3) A chaque classe est associé un type


4) O2 effectue du contrôle de type

Types :
a) types atomiques : integer, float, string, char,
...
b) constructeurs de types : set, list, tuple

c) classes du schéma

Types complexes :
application récursive de constructeurs à des
types de base, des types construits ou des
classes

ex: tuple ( name : string, map : Bitmap,


hotels : set ( Hotel ) )
Classes
Un schéma correspond à une collection de classes reliées entre
elles par des liens d'héritage et/ou de composition

Définition d'une classe :


class City
type tuple ( name : string,
map : Bitmap,
hotels : set ( Hotel ) )
method Init ( name : string, map : Bitmap,
hotels : set (Hotel) )
end ;
method public Maj_Nom (nom : string)
in class City;

SOUS-TYPAGE ET HERITAGE

•Notion de sous-typage sur les types, avec une relation de


sous-typage pour chaque constructeur
•Héritage sur les classes, basé sur la relation de sous-typage

•Héritage multiple, avec une résolution explicite des conflits

class Historical_hotel inherit


Monument, Hotel ;
Persistance
Réalisée par nommage

Les objets ou les valeurs peuvent être persistants

name Tour_Eiffel : Monument;

Objet persistant

name Paris_monuments : set ( Monument );

Valeur persistante

valeur
• Chaque objet nommé est persistant

valeur valeur
• Chaque objet composant d'un objet persistant
est persistant

• La gestion d'extensions de classe persistantes


est à la charge du programmeur :

name Cities : set (City);


name Cities_Charentes : set (City);
LMD : O2C
CORPS D'UNE METHODE

method body Maj_Nom (nom : string ) in class City


{ self-> name = nom ;
}
objet auquel est appliquée la méthode

APPEL D'UNE METHODE

Technique d'envoi de message


recepteur -> selecteur ( arguments )
Paris-> Maj_Nom ("Paris")

CREATION D'OBJETS

Tour_Eiffel = new Monument


initialisé avec la valeur par défaut propre à
la classe

ITERATEUR ( manipulation les listes et les ensembles)


for ( X in S where < condition > ) {< instruction >};

Exemple : O2 City C ; // déclare une variable O2


for ( C in Cities_Charentes
where ( strcmp ( C->name,"Jarnac" ) )
{ C -> display } ;
Manipulations de
valeurs
Les valeurs peuvent être construites en appliquant les
constructeurs ensemble, tuple, liste

MANIPULATION D'OBJETS

Tour_Eiffel est un objet

correspond à l'identifiant de cet objet


*Tour_Eiffel est la valeur associée à cet objet

*Tour_Eiffel = tuple
(nom : "Tour Eiffel",
adresse : Adr_Tour_Eiffel,
description : "Monument de l'exposition universelle",
jours de fermeture : list ("Noel",
"Paques",
"15 Aout" )
droit d'entrée : 25 ) ;

Accès à un attribut d'un tuple : notation pointée

*Tour_Eiffel. jours de fermeture += list ( "6 Juin" ) ;


Schéma exemple :
O2QUERY

class Auteur
type tuple ( nom : string,
adr : tuple ( no : integer,
rue : string,
ville : string ),
livres : set (Livre) )

method Init (nom : string),


public Nb_livres : integer
end;
public type in class Auteur;

name Auteurs : set (Auteur);

class Livre
type tuple ( titre : string,
prix : float,
auteurs : set (Auteur) )
end;
Filtrage ensemble /
liste

Quels sont les noms des auteurs habitant Paris


et dont un livre coute plus de 200,00 F

select a.nom
from a in Auteurs, l in a.livres
where a.adr.ville = "Paris"
and l.prix > 200.0

Quels sont les noms et les villes de résidences


des auteurs ayant écrit pllus de 10 livres

select tuple (nom : a.nom,


ville : a.adr.ville)
from a in Auteurs
where a->Nb_livres > 10
Composition de
requêtes
Quels sont les auteurs habitant Paris et
ayant écrit des livres
chers (prix > 200 F) et quels sont ces livres ?

select tuple ( nom : a.nom,


livreschers :
select l.titre
from l in a.livres
where l.prix > 200.0 )
from a in Auteurs
where a.adr.ville = "Paris"

define Livres_Chers (a)


as select l.titre
from l in a.livres
where l.prix > 200.0

select tuple ( nom : a->nom,


livreschers : Livres_Chers (a) )
from a in Auteurs
where a->adr.ville = "Paris"
Requête dans un programme

En mode programmé O2C,


une requête est passée sous forme de string,
comme paramètre de la fonction o2query
qui retourne un status d'exécution

{ o2 set (Auteur) Auteurs_Ma_Ville;


o2 Auteur amv;
o2 string Ma_Ville = "Paris";
o2query ( Auteurs_Ma_Ville,
select a
from a in Auteurs
where a.adr.ville = $1 ",
Ma_Ville);

for amv in Auteurs_Ma_Ville


{ amv->Edit };

};

Vous aimerez peut-être aussi