Les applications C++ Builder peuvent utiliser le langage de requêtes SQL pour accéder
aux données suivantes :
- Les tables aux formats Paradox ou dBase.
- Les bases de données gérées par Interbase.
- Les différents serveurs SQL accessibles à distance via SQL Link.
Il faut rappeler que BDE, héritier de Paradox, n'est pas un moteur de base de
données relationnelles, et ne supporte donc pas nativement SQL. Par contre il
comprend le "noyau" normalisé de SQL. Pour accéder aux différents serveurs
SQL ( Oracle, Informix, etc. ) il faut disposer des pilotes natifs fournis par les
éditeurs de ces progiciels pour avoir la possibilité d'utiliser les possibilités
étendues de SQL propres à chaque serveur.
C'est un langage abstrait qui permet de se détacher de l'aspect physique des données
(emplacement du fichier les contenant, taille de l'enregistrement, méthodes de gestion,...). En
effet, SQL est un langage définit selon une norme (norme ANSI) indépendamment de tout
logiciel.
Page XIV.1
Programmation SQL
SQL permet la gestion complète d'une base de données relationnelle selon deux axes
complémentaires :
- Création / Modification / Suppression de la structure de la base de données :
création, suppression ou modification des tables, des clés, des index et définition
des contraintes d'intégrité.
- Création / Modification / Suppression / Visualisation des données contenues dans
les différentes tables de la base.
C'est surtout ces dernières possibilités qui sont utilisées avec l'environnement C++
Builder ( la gestion de la structure de la base étant réalisée par DBD ) mais il ne faut pas
oublier qu'il est toujours possible d'accéder aux possibilité de gestion de la structure ... si l'on
est un expert du langage SQL.
La réponse à cette question est stockée dans une nouvelle table, créée dynamiquement
par le moteur SGBDR, qui comporte tout ou partie des enregistrements initiaux. Les
enregistrements retenus sont ceux correspondant aux critères définis dans la requête. Ils sont
affichés à l'écran sous une forme déterminée volatile ("vue").
Page XIV.2
Programmation SQL
Le SQL de C++ Builder met en place une extension SQL pour permettre de
définir une table par son nom de fichier.
Si le nom d'un champ correspond à un mot réservé de SQL il doit être mis entre
guillemet ou entre apostrophes
CREATE TABLE :
Cet ordre permet de créer une table en définissant, le cas échéant, un index. Il
permet de donner un nom à la table et définit le nom et le type des différents
champs.
Exemple :
ALTER TABLE :
Exemple :
DROP TABLE :
Exemple :
Exemples :
Page XIV.3
Programmation SQL
SELECT :
L'instruction SELECT est utilisée pour afficher un ou plusieurs champs, situés dans
une ou plusieurs tables, à partir de critères spécifiés.
Lorsque plusieurs champs doivent être sélectionnés, il doivent être séparés par une
virgule ' ,' .
Exemple :
FROM :
La clause FROM spécifie la ou les tables dans lesquelles les données doivent être
recherchées.
S'il y a plusieurs tables, elle doivent être séparées par une virgule .
Exemple :
FROM Liste_Personnel
FROM Liste_Personnel, Liste_Véhicule
WHERE :
Une condition s'exprime sur un ou plusieurs champs. On peut utiliser le mot réservé
IN pour indiquer une liste.
Exemple :
ORDER BY :
Page XIV.4
Programmation SQL
La clause, facultative, ORDER BY spécifie le champ dans l'ordre duquel les lignes
qui seront affichées.
Exemple :
ORDER BY Nom
On peut préciser :
ASC pour un ordre ascendant ( ou alphabétique ) ;
DESC pour un ordre descendant ( ou inverse ).
Exemples :
SELECT Nom, Reference, Ville FROM Affiche les champs 'Nom', 'Reference' et
Fournisseurs WHERE Reference = '30' AND 'Ville' de la table 'Fournisseurs' des
Page XIV.5
Programmation SQL
Type Opérateur
Arithmétique +, -, *, /
Comparaison <, >, =, <>, IS NULL, LIKE
Logique AND, OR, NOT
Exemples :
Pour employer l'opérateur LIKE il faut utiliser le caractère '%' signifiant 'n'importe quoi'
( '%Du%' = n'importe quoi précédant 'Du' suivi de n'importe quoi).
LIKE ne distingue pas les majuscules des minuscules, à la différence de ' ='.
TQuery est un composant, du même type que TTable, qui permet de transmettre des
requêtes SQL à BDE ( ou à tout autre serveur de bases de données) et à retransmettre, en retour
les données résultantes à l'application.
Comme TTable , TQuery est un composant invisible qui se pose sur la fiche et qui,
connecté à un composant TDataSource permet le transfert des données, résultat d'une requête,
qui s'affichent dans les différents composants prévus ( TDBGrid en général ).
Page XIV.6
Programmation SQL
Il existe aussi dans ce composant une propriété DataSource mais elle sert à lier le
composant à un autre ensemble de données ( cela sera vu ultérieurement ). En général ce
champ reste vide.
Une fois une requête rédigée, il est possible de créer des objets champs de type TField à
partir d'elle. Pour cela il faut, comme pour le composant TTable, double-cliquer sur le
composant afin d'afficher l'éditeur de champs.
Le fait d'activer la propriété SQL du composant ouvre une boite de dialogue dans lequel
il est possible d'écrire la requête SQL souhaitée.
Page XIV.7
Programmation SQL
Cette méthode est surtout utilisée pour créer des requêtes SQL simples. Elle peut l'être
aussi par les spécialistes du langage SQL souhaitant écrire des requêtes particulièrement
"fines".
QBE est très facile d'emploi mais n'est jamais sorti du monde des SGBD "micros", non
SQL, et est surtout utilisé par Paradox. D'où sa présence dans DBD.
Il n'est donc pas standardisé et il est donc préférable d'utiliser les requêtes SQL.
Lorsque l'on réalise une requête QBE il suffit de sélectionner la table concernée puis de
"cocher" les champs que l'on veut visualiser. On peut éventuellement définir des critères
au niveau de chaque champ sélectionné.
Page XIV.8
Programmation SQL
Il est possible de réaliser des jointures entre deux tables en les sélectionnant toutes les
deux et en indiquant quel est le champ permettant de réaliser la jointure.
Une fois la requête réalisée il est possible de l'exécuter pour vérifier sa validité (bouton
"éclair" de la barre d'icônes).
L'interêt de QBE est qu'on peut convertir directement une requête QBE en requête SQL
par activation du bouton concerné puis, par copier-coller ( en utilisant la combinaison
de touches Maj + Ins ), intégrer le texte SQL généré dans l'éditeur SQL de C++
Builder.
Cette méthode permet de concevoir des requêtes SQL complexes et fiables ( car testées
avant d'être validées ). Les requêtes SQL générées ont une syntaxe normalisées les
rendant très lisibles et très faciles à maintenir.
Cette méthode n'est utilisable que pour les tables de format Paradox ou
dBase.
Page XIV.9
Programmation SQL
Ce générateur permet de visualiser les différentes tables et de définir les liens qui
existent entre elles ( un peu à la manière du produit équivalent proposé, dès ses versions
de base, par Access ).
A partir de là il est possible de générer des requêtes SQL complexes sans avoir à passer
par DBD et QBE.
Page XIV.10
Programmation SQL
- Les requêtes SQL statiques dont le texte de la requête peut être défini entièrement
(dès la phase de conception ou pendant l'exécution ).
- Les requêtes SQL dynamiques dont certaines parties ne sont définies qu'à l'exécution
( en général à l'issue d'un choix fait par l'utilisateur ).
Jusqu'à présent nous n'avons utilisé que des requêtes statiques. Mais la puissance de
SQL ne se révèle que dans la possibilité de réaliser des requêtes dynamiques, seules requêtes
permettant à l'utilisateur de réaliser un choix.
Page XIV.11
Programmation SQL
Pour cela il faut utiliser une boite de dialogue, appelée "éditeur de paramètres" qui
apparaît lorsque l'on active la propriété Params du composant TQuery.
Cette boite permet de définir le nom et le type du, ou des, paramètre(s) qui sera utilisé
dans la requête SQL dynamique. En général il s'agit de la zone de saisie d'un composant
TEdit ou TDBEdit ou bien encore la sélection d'un composant TListBox, TDBListBox,
TComboBox, TDBComboBox, etc.
On peut éventuellement donner une valeur initiale mais ce n'est pas une obligation ( cela
peut-être utile pour faire des tests initiaux ).
:<nom_paramètre>
Exemple :
From Activite
C++ Builder étudie la syntaxe de la requête SQL et propose d'emblée, dans la fenêtre
'Nom du paramètre', le ou les paramètres devant être paramétrés. Il propose aussi un
type à cette variable ( si le champ concerné est l'origine d'un champ objet de type
TField).
Page XIV.12
Programmation SQL
S'il n'y a pas de requêtes SQL pré-rédigée, C++ Builder n'est pas en mesure de faire de
propositions.
Une requête SQL dynamique ne peut être exécutée que par programmation. Il faut pour
cela utiliser la propriété Params [ i ] ou la méthode ParamByName ( ) du composant
TQuery.
Lorsque l'on réalise une requête dynamique, la syntaxe autorisée est réduite :
- On ne peut utiliser la clause ORDER BY.
- On ne peut utiliser de champ calculé dans la clause SELECT.
- La clause WHERE ne comporte que des comparaisons de noms de champs
à des constantes scalaires.
Cette propriété doit alors spécifier le composant DataSource lié à une table ( par son
composant TTable ).
On peut alors utiliser, dans la clause WHERE, des paramètres non initialisés (selon la
syntaxe : <paramètre >). Si le nom du paramètre ainsi spécifié correspond à un des champs de
la table "maître" liée par DataSource, le paramètre prendra la valeur du champ correspondant
de l'enregistrement actif au moment de l'exécution de la requête.
Exemple :
Page XIV.13
Programmation SQL
Comme les deux ensembles de données sont actifs, les requêtes sont exécutées dès le
démarrage de l'application.
Le paramètre :CustNo est initialisé avec la valeur du champ correspondant de
l'enregistrement actif de la table Cust. A chaque fois que l'enregistrement actif est
modifié, la requête est de nouveau exécutée pour mise à jour de la grille.
Page XIV.14