Table des matières
Création de la base de données-------------------------------------------------------------------------------------------3
Création d'un programme exploitant une base de données déjà créée à l'aide de l'expert fiche base
de données : -------------------------------------------------------------------------------------------------------------------6 (sans l'aide de l'expert fiche base de données) --------------------------------------------------------------------- 10
Modifier le contenu des champs par programmation.------------------------------------------------------------ 13
Se déplacer dans une base de données; ------------------------------------------------------------------------------ 15
Création d'un index secondaire; tri de la base ---------------------------------------------------------------------- 17
Faire une recherche dans une base de donnée --------------------------------------------------------------------- 20
Filtrer une base de données --------------------------------------------------------------------------------------------- 22 Utilisation d'un DataModule--------------------------------------------------------------------------------------------- 23
Lier deux tables Relation maître-détail ou relation un-à-plusieurs entre deux tables-------------------- 25
Que veut on faire ?--------------------------------------------------------------------------------------------------- 25 Création des 2 tables :----------------------------------------------------------------------------------------------- 25
Utilisation d'un DataModule------------------------------------------------------------------------------------------ 26
Connexions à nos tables ----------------------------------------------------------------------------------------------- 26
Liaison des deux tables------------------------------------------------------------------------------------------------- 28
Faisons le point sur l'architecture--------------------------------------------------------------------------------- 30
Test du programme -------------------------------------------------------------------------------------------------- 30
Utilisation d'une liste de choix pour rentrer une donnée--------------------------------------------------------- 32
Le DBCombobox----------------------------------------------------------------------------------------------------- 32
Indiquer le contenu de la liste déroulante du DBComboBox---------------------------------------------- 32
Indiquer la table et le champ à modifier ------------------------------------------------------------------------ 34
Le DBLookUpComboBox ou comment remplir la liste à l'aide d'une table --------------------------- 34
Création de la table -------------------------------------------------------------------------------------------------- 34
Indiquez le contenu de la liste déroulante du DBLookUpComboBox.---------------------------------- 36
Indiquez la table et le champ de cette base qui doivent être modifiés suite au choix dans cette liste déroulante. ------------------------------------------------------------------------------------------------------------- 36 Quelle valeur s'affiche dans le DBLookUpCombobox ? --------------------------------------------------- 36
Trier, filtrer, la liste de choix-------------------------------------------------------------------------------------- 37
SQL Structured Query Language ---------------------------------------------------------------------------------------- 38
Construction d'un exemple----------------------------------------------------------------------------------------- 39
Modification de la requête SQL à l'exécution. Requêtes paramétrées SQL. -------------------------------- 43
Solution pour adapter la requête SQL à une entrée utilisateur sans utiliser les requêtes SQL
paramétrées. ----------------------------------------------------------------------------------------------------------- 43 Utilisation des requêtes paramétrées.---------------------------------------------------------------------------- 44
Utilisation du composant TDataBase ---------------------------------------------------------------------------------- 46
Utilisation : ------------------------------------------------------------------------------------------------------------ 47
Exemple : Suppression de la demande de mot de passe ---------------------------------------------------- 48
Utilisation d'une base ACCESS à l'aide de ODBC + BDE.----------------------------------------------------------- 49
Déclaration de la base de donnée dans l'ODBC :------------------------------------------------------------- 49
Utilisation d'une base ACCESS à l'aide d'ADO.----------------------------------------------------------------------- 52
Connexion de la base : ---------------------------------------------------------------------------------------------- 52
Test de la connection------------------------------------------------------------------------------------------------ 53
Utilisation des composants DbExpress pour lire une base MySQL (D6 et plus). ---------------------------- 54
Introduction :---------------------------------------------------------------------------------------------------------- 54
Lecture d'une base MySQL existante :----------------------------------------------------------------------------- 54
Connexion à la base :------------------------------------------------------------------------------------------------ 54
Connection d'un ensemble de données (DataSet) à l'aide d'un SQLClientDataSet------------------- 56
Accéder aux données. ----------------------------------------------------------------------------------------------- 57
Testez.------------------------------------------------------------------------------------------------------------------- 57
Rendre les données modifiables. --------------------------------------------------------------------------------- 58
Nota :-------------------------------------------------------------------------------------------------------------------- 58
Questions a qui a une réponse :--------------------------------------------------------------------------------- 59
Utilisation de QuickReport pour faire des impressions d'éléments d'une base de données.------------ 60
Introduction :---------------------------------------------------------------------------------------------------------- 60
Un premier programme--------------------------------------------------------------------------------------------- 60
Aller plus loin avec QuickReport -------------------------------------------------------------------------------- 62
Utilisation d'Excel comme base de données. ------------------------------------------------------------------------ 64
Introduction :---------------------------------------------------------------------------------------------------------- 64
Constitution de notre base :---------------------------------------------------------------------------------------- 64
Accès à notre base par Delphi :----------------------------------------------------------------------------------- 66
dernière mise à jour le : mercredi 30 octobre 2002
Ce premier programme va être fait en deux temps :
• Création de la base de données elle même
• Création du programme Delphi permettant de voir, ajouter, supprimer des éléments de la base. Cette création se fera à l'aide de l'assistant Expert fiche
• Création de la base de données
• Choisir dans le menu : Outils / Module base de données. Le module de gestion de base de données se charge. (Dans Delphi 2 ouvrir directement le module base de données à partir du menu démarrer de windows).
Création d'un alias:
Un alias sera équivalent à un chemin. Par exemple, on peut définir que TEST sera équivalent à c:\basededonnees\mabase
Dans le module de gestion de base de données, faire Outils / Gestionnaire d'alias puis cliquez sur le bouton Nouveau
• Dans la case Alias de la base, entrez TEST, puis cliquez sur parcourir pour entrer le chemin d'accès. Cliquez alors sur provisoire puis sur enregistrer sous sans rien changer pour enregistrer le changement (l'ajout de l'alias).
Création de la table :
• Faire Fichier / Nouveau / Table puis choisir Paradox 7
• Entrez alors la composition des champs telle que dans cette image :
?
Les types représentent les types des valeurs associées aux champs ex: A comme alphabétique ou N comme numérique. Vous pouvez voir tous les types disponibles en cliquant avec le bouton droit dans la colonne Type. Le type + permet une incrémentation numérique automatique. Dans notre exemple, ce champ servira d'index primaire (clé) à notre base. Ce champ permet de distinguer les enregistrements les uns des autres. Par défaut la base sera triée selon cette clé. Double cliquez dans la colonne index ligne Num pour dire que Num est un index.
La taille représente le nombre de caractères que pourra avoir le contenu des champs ( ex: ici, les noms pourront être rentrés sur maximum 15 caractères).
• Faire enregistrer sous puis dans alias, choisir TEST. Donner un nom à votre base ex: annuaire0. Sauver.
• Vous pouvez sortir du module de gestion de base de données.
Voilà, votre base de données est créée. Il nous reste à l'exploiter.
Création d'un programme exploitant une base de données déjà créée à l'aide de l'expert fiche base de données :
dernière mise à jour le : mercredi 30 octobre 2002
Votre base de données doit déjà être créée. Si ce n'est pas le cas, cliquez ici
Dans le menu de Delphi, faire Fichier / Nouveau. Déplacer les onglets à l'aide des petites flèches pour aller chercher l'onglet "Affaires". Pour Delphi 2, dans le menu de delphi faire Base de données / Expert fiche.
Une boite de dialogue s'ouvre vous demandant "Quelle type de fiche voulez vous que l'expert crée ?
Laissez les réponses par défaut (créer une fiche simple et créer une fiche avec TTable). Cliquez sur suite.
Dans la case Lecteur ou nom d'alias, choisissez l'alias que nous avons créé
("TEST"). Cliquez alors sur le nom de votre table (). Cliquez sur suite.
Vous devez alors indiquer quels sont les champs de la base que vous souhaitez utiliser. Vous pouvez les sélectionner tous en cliquant sur le bouton ">>". Cliquez sur suite.
Choisissez alors une disposition pour les champs
?Horizontalement ou
?Verticalement (à choisir pour avoir des résultats similaires dans la suite de l'exemple) ou
• Dans une grille.
• Faire "suite"
Choisir si vous voulez les libellés à gauche ou à droite (pour l'exemple : prendre à gauche)
Faire "suite" puis terminer en laissant coché "générer une fiche maître" et pour génération de fiche : "fiche seulement".
Delphi vous a généré une fiche :
Votre programme est terminé !!
Lancez le avec F9 Vous remarquerez que vous n'avez pas le droit de modifier le champ NumOrdre. Ce champ (rappelez vous il est en auto incrémentation), est en lecture seule.
Ce que Delphi a fait automatiquement pour vous :
• Delphi a placé un composant TTable sur la fiche. Ce composant nous donne un accès à notre base de données. Sa propriété DataBaseName contient notre alias TEST et sa propriété TableName contient le nom de notre base de données ().
• Delphi a également inséré un Composant TDataSource Ce
composant sert de canal (d'intermédiaire) entre le composant TTable et d'autres composants. Ces derniers permettent par exemple de visionner le contenu de la table. Ce sont par exemple les TDBEdit et liaison avec le composant TTable est matérialisé par sa propriété DataSet que Delphi a rempli pour vous avec le nom de votre composant TTable c'est à dire "Table1"
• Delphi a inséré autant de TDBEdit que de champ. Il les a nommés Edit suivi du nom du champ. Les TDBEdit sont reliés au TDataSource par l'intermédiaire de leur propriété DataSource. Delphi a rempli cette propriété pour vous (en y écrivant "DataSource1" qui est le nom de notre TDataSource). Delphi a également rempli la propriété DataField avec le nom du champ de notre base de données dont le contenu sera afficher dans le TDBEdit.
• Delphi a inséré un composant
TDBNavigator ce composant permet de se déplacer parmi les enregistrements de la base de données et même d'en ajouter ou d'en retirer. Ce composant est également relié à notre base de données par l'intermédiaire de sa propriété DataSource qui doit contenir le nom d'un TDataSource (ici : "DataSource1").
• Exercice pratique : rajoutez sur la fiche un DBGrid (Onglet
ContrôleBD de la barre des composants de Delphi) Entrez DataSource1 dans sa propriété DataSource. Vous avez ainsi créé le pont entre le DBGrid et votre base de données. Observez : si vous mettez la propriété Active de votre Table1 à true, vous voyez immédiatement le contenu de votre base de données sous forme d'un tableau dans le DBGrid ! Lancez votre programme
A ce stade, votre programme doit ressembler à ce source.
dernière mise à jour le : dimanche 26 août 2001
Votre base de données doit déjà être créée. Si ce n'est pas le cas, cliquez ici Rappelez-vous le schéma vu à la leçon précédente :
• Dans l'onglet AccèsBD, prenez un composant Table et placez le sur votre fiche (Form1). Ce composant nous donne un accès à notre base de données.
• Entrez dans sa propriété DatabaseName le nom de votre
alias (TEST si vous avez suivi la création de la base tel que décrite dans ce tutorial).
• Dans sa propriété TableName, entrez le nom de votre table
• Rendez actif le composant Table1 en mettant sa propriété Active à "True"
• Toujours dans l'onglet AccèsBD, prenez un composant DataSource et placez le sur votre fiche. Ce composant sert de canal (d'intermédiaire) entre le composant TTable et d'autres composants. Ces derniers permettent par exemple de visionner le contenu de la table. Ce sont par exemple les TDBEdit et TDBNavigator.
• Entrez "Table1" dans sa propriété DataSet . Cela assure sa liaison avec le composant Table.
Il faut maintenant ajouter les composants qui vont nous permettre de visualiser et modifier notre base de données.
• Dans l'onglet ContrôleBD, prenez un composant DBNavigator et
placez le sur la fiche. ce composant permet
de se déplacer parmi les enregistrements de la base de données et même d'en ajouter ou d'en retirer.
• Reliez ce ContrôleBD à notre DataSource en affectant DataSource1 à sa propriété DataSource
• Toujours dans l'onglet ContrôleBD, prenez un composant DBEdit et placez le sur la fiche. Affectez sa propriété DataSource à
DataSource1 et sa propriété DataField au nom de
l'un des champs de notre base de données par exemple
"Nom"
• Refaire la même manip avec deux autres DBEdit et ce, pour les autres champs de notre base (NumOrdre, Prénom et Age).
Votre programme est terminé !!
Lancez le avec F9. Vous remarquerez que vous n'avez pas le droit de modifier le champ NumOrdre. Ce champ (rappelez vous il est en auto incrémentation), est en lecture seule.
Exercice pratique : rajoutez sur la fiche un DBGrid (Onglet ContrôleBD de la barre des composants de Delphi). Entrez DataSource1 dans sa propriété
DataSource. Vous avez ainsi créé le pont entre le DBGrid et votre base de données. Lancez votre programme. Le DBGrid représente votre base sous forme d'un tableau.
dernière mise à jour le : samedi 18 mars 2000
Reprenez l'exemple créé précédemment à l'aide de l'expert (avec ajout du DBGrid) ou téléchargez le ici (ce source ne peut marcher que si vous avez créé votre base de données conformément à la leçon 1)
Il existe deux façons d'accéder (lire ou écrire) au contenu des champs: par le n° du champ ou par son nom.
Accès par le n° du champ
Les objets TTable possèdent un tableau de champs Fields. Attention, ce tableau commence à l'indice 0.
Dans notre exemple, si on fait UneVariable:=Table1.Field[0].AsString Une Variable contiendra la valeur du premier champ.
AsString est une propriété qui permet de convertir le type natif du champ en string..
Il existe AsInteger, AsFloat, AsBoolean, AsCurrency, AsDateTime et AsVariant. Si on met par exemple UneVariable:=Table1.Field[0].AsFloat et si le champ contient un string, cela déclenche une exception.
Si ce n'est déjà fait : dans la clause uses de la Form2, ajoutez l'unité Dialogs (pour pouvoir utiliser un ShowMessage)
Ajouter un bouton à votre projet. Implémentez sa méthode OnClick avec la ligne suivante:
procedure TForm2.Button1Click(Sender: TObject); begin
ShowMessage(Table1.Fields[0].AsString); end;
Lancez votre programme pour le tester
Par la même méthode, vous avez un accès en écriture. Ajoutez un bouton et implémentez sa méthode OnClick avec les lignes suivantes:
procedure TForm2.Button2Click(Sender: TObject); begin
;
Table1.Fields[0].AsString:= 'coucou';
end;
permet de se mettre en mode Edition. C'est indispensable pour pouvoir modifier un champ.
Lancez votre programme pour le tester
L'inconvénient de cette méthode est qu'il faut connaître l'emplacement des champs. Si on modifie l'ordre des champs, notre programme ne fonctionnera plus correctement. il est donc préférable d'accéder par le nom du champ.
Accès par le nom du champ
La fonction FieldByName nous permet un accès par le nom du champ : function FieldByName(const FieldName: string): TField;
Cette fonction nous permet d'accéder directement aux propriétés et méthodes spécifiques d'un champ dont on connaît le nom.
On peut donc modifier l'implémentation de l'événement OnClick de notre premier bouton:
procedure TForm2.Button1Click(Sender: TObject); begin
ShowMessage(Table1.FieldByName('Nom').AsString); end; et l'implémentation de l'événement OnClick de notre second bouton :
procedure TForm2.Button2Click(Sender: TObject); begin
;
Table1.FieldByName('Nom').AsString:= 'coucou'; end;
Lancez votre programme pour le tester
dernière mise à jour le : samedi 29 janvier 2000
Se déplacer dans la base
Reprenez l'exemple créé précédemment à l'aide de l'expert (avec ajout du DBGrid) ou téléchargez le ici (ce source ne peut marcher que si vous avez créé votre base de données conformément à la leçon 1)
Le but de cette leçon est de découvrir les procédures qui servent à se déplacer dans une base de données sans passer par le composant DBNavigator.
Le composant TTable dispose de plusieurs méthodes permettant de se déplacer dans la base:
|
Par exemple, sur votre fiche, ajoutez un bouton. Affectez sa propriété caption à First. Double cliquez dessus afin d'implémenter l'événement OnClick ainsi :
procedure TForm2.Button1Click(Sender: TObject); begin
Table1.First; end;
Rajoutez d'autres boutons afin de tester les autres méthodes. Pour la méthode MoveBy, ajouter un TEdit afin de pouvoir faire varier le I.
A ce stade, votre projet doit ressembler à ceci : source du projet. (ce source ne peut marcher que si vous avez créé votre base de données conformément à la leçon 1)
Se déplacer dans la base de données afin d'effectuer un traitement dans un champ
Les modes de déplacement expliqués ci-dessus permettent également d'examiner tous les enregistrements afin d'en effectuer un traitement.
Exemple: Nous allons mettre en majuscule tous les caractères des champs Nom.
Pour cela, nous allons nous servir en plus des méthodes ci dessus, des méthodes suivantes:
| ||||||||||||||||||||||||||||
Ajoutez sur votre fiche un bouton. Implémentez sa méthode OnClick :
procedure TForm2.Button6Click(Sender: TObject); begin
Table1.DisableControls;//rend inactif les contrôles try
Table1.First; // se place sur le premier enregistrement while notdo begin
; // se place en mode édition;
Table1.FieldByName('Nom').AsString:=AnsiUpperCase(Table1.FieldByName('Nom')
.AsString);
;// va à l'enregistrement suivant end;
finally // le try finally permet d'être sur que l'on remet les contrôles
actifs même s'il y a une exeption
Table1.EnableControls;// remet actif les contrôles end;
Voilà, c'est tout compilez, testez . le source doit maintenant ressembler à ceci : le source du projet
dernière mise à jour le : samedi 12 janvier 2002
Reprenez l'exemple créé précédemment à l'aide de l'expert (avec ajout du DBGrid) ou téléchargez le ici (ce source ne peut marcher que si vous avez créé votre base de données conformément à la leçon 1)
Par défaut, votre base de donnée est triée dans l'ordre donné par notre index principal c'est à dire dans notre exemple, par n° d'ordre.
La création d'un index vous permettra de trier les enregistrements selon un autre ordre et de faciliter les recherches au sein de la base de données.
Ajout d'un index secondaire
L'ajout d'un index secondaire va se faire à partir du Module de base de données (le programme qui nous avait permis de créer notre base de données).
Avant de rentrer dans le ce Module de base de données, il faut mettre à False la propriété "active" du Table1 de notre programme (si ce n'est pas déjà fait) sous peine de ne pouvoir modifier la base de données (car déjà prise par notre application).
• Ouvrez le Module de base de données (menu Outils / Module base de données) puis icône de gauche "Ouverture d'une table".
• Dans la case alias, choisissez TEST et dans Nom choisissez "". Choisissez Table / Restructurer. Dans la liste déroulante sous "propriétés de la table:" sélectionnez "index secondaires".
• Cliquez sur le bouton "définir". En utilisant les boutons "flèches gauche et droite", vous pouvez choisir les champs qui seront indexés. Choisissez Nom et Age comme Champs indexés.
• Vérifiez que la case "maintenu" est cochée.
• Sortez en cliquant sur OK. Donnez par exemple "Index Nom et age" comme nom d'index.
Trier les enregistrements
Pour trier les enregistrements, il suffit d'affecter
• la valeur "Index Nom et Age" à la propriété IndexName de notre Table1 ? ou "Nom;Age" à la propriété IndexFieldNames.
Il n'y a pas besoin de compiler le programme pour voir l'effet obtenu : l'effet est immédiat si la propriété active du composant Table1est à true et ce, dès la modification dans l'inspecteur d'objet. On remarquera que si on affecte une valeur à IndexFieldNames, la valeur de IndexName est mis à blanc. Réciproquement si vous affectez une valeur à IndexName, IndexFieldNames est mis à blanc.
Nos champs indexés étaient dans l'ordre Nom puis Age. Par conséquent, le tri obtenu est un tri selon le nom. Pour les enregistrements ayant le même nom on a un tri par âge.
On peut définir plusieurs index secondaires et par conséquent obtenir différents tris en fonction de l'index utilisé.
On peut, bien sur, affecter ces propriétés par programmation.
Exemple : ajouter un bouton et implémentez sa méthode OnClick de la façon suivante :
procedure TForm2.Button1Click(Sender: TObject); begin
Table1.indexName:='Index Nom et age';// tri par nom puis âge; utilisation de indexName end;
Ajoutez un autre bouton et implémentez sa méthode OnClick de la façon suivante :
procedure TForm2.Button2Click(Sender: TObject); begin
Table1.IndexFieldNames:='NumOrdre';
//revient au tri donné par l'index principal; utilisation de IndexFieldNames end;
A ce stade, votre source doit ressembler à : source
Lancez votre programme pour le tester
dernière mise à jour le : samedi 12 janvier 2002
Reprenez l'exemple créé dans la leçon 6 ou téléchargez son source
Une fonction FindKey et une procédure FindNearest permettent de rechercher un enregistrement dans une base de données.
• Pour FindKey comme pour FindNearest, la recherche se fait par rapport au champ indexé. Si l'on veut par exemple chercher le premier enregistrement dont le champ Nom contient DUPONT, il faudra s'assurer que notre base de données est indexée sur le champ Nom avant de déclencher FindKey ou FindNearest.
• FindKey recherche un enregistrement dont le(s) champ(s) correspondant à l'index sont strictement égaux à la (aux) valeur(s) passée(s) en paramètre.
Par exemple, si l'on a indexé à l'aide de l'index 'Nom et age':
Table1.FindKey([]) cherchera l'enregistrement dont la valeur contenue dans le champ Nom est égale à .
Rappelez vous : Nom et age est un index qui correspond dans l'ordre aux champs indexées Nom et Age. On peut donc faire une recherche à la fois sur le nom et sur l'age. Table1.FindKey([,10]) cherchera l'enregistrement dont la valeur contenue dans le champ Nom est égale à et dont la valeur du champ age est égale à 10.
FindKey est une fonction qui renvoie true si l'enregistrement recherché a été trouvé, false sinon.
Exemple : Dans la clause uses, ajoutez l'unité Dialogs (pour pouvoir utiliser un ShowMessage) puis placez un bouton et un TEdit (pour pouvoir entrer le nom) sur votre fiche et implémentez l'événement OnClick du bouton de la façon suivante :
procedure TForm2.Button3Click(Sender: TObject); begin
Table1.indexName:='Index Nom et age'; // ainsi la recherche se fera sur le champ Nom if not Table1.FindKey([]) then ShowMessage ('non trouvé');
// FindKey recherche l'enregistrement qui contient dans //le champ Nom le contenu de Edit1
end;
Pour tester la possibilité de faire une recherche sur le nom et l'age : ajouter un bouton et deux TEdit (un pour le nom (Edit2) et un pour l'age( Edit3) ) puis implémentez l'événement OnClick du bouton :
procedure TForm2.Button4Click(Sender: TObject); begin
Table1.indexName:='Index Nom et age'; // ainsi la recherche se fera sur le champ Nom if not Table1.FindKey([,StrToInt()]) then ShowMessage ('non trouvé');
// FindKey recherche l'enregistrement qui contient dans
// le champ Nom le contenu de Edit1 end;
? FindNearest fonctionne d'une façon similaire à FindKey mais il recherche l'enregistrement le plus proche de la valeur entrée. Pour le tester, ajoutez un bouton et un TEdit puis implémentez son événement OnClick :
procedure TForm2.Button4Click(Sender: TObject); begin
Table1.IndexFieldNames:='NumOrdre';
// ainsi la recherche se fera sur le n° d'ordre
Table1.FindNearest([StrToInt()]);
// FindNearest permet de se placer sur l'enregistrement
//qui correspond au mieux au critère
// ici : que le champ NumOrdre contient la valeur numérique
//écrite dans . end;
A ce stade, le source doit ressembler à ceci : source.
dernière mise à jour le : vendredi 24 août 2001
Reprenez l'exemple créé dans la leçon 6 ou téléchargez son source Si ce n'est déjà fait, mettez la propriété de Table1 à True.
Les propriétés de TTable permettant de filtrer
• La propriété Filtered permet de rendre le filtre opérant. Placez le à True
• La propriété Filter (de type string) permet de mettre un filtre afin de ne prendre en compte qu'une partie de la base de données.
Par exemple, dans l'inspecteur d'objet, affectez à la propriété Filter la chaîne de caractère 'D*' et mettez la propriété Filtered à True. Vous ne voyez plus dans le DBGrid que les enregistrements dont le contenu du champ Nom commence par D. Vous pouvez également utiliser utiliser des filtres du type : Nom='D*' or Age=40
• La propriété FilterOptions permet d'indiquer si l'on veut tenir compte de la case (majuscule minuscule). Pour cela, double cliquez sur la propriété puis mettez à True foCaseInsensitive. FilterOptions prend alors la valeur [foCaseInsensitive].
Si par exemple vous avez mis dans la propriété Filter Nom='d*', le DBGrid vous affiche tous les enregistrements dont le contenu du champ Nom commence par D ou par d.
Pour bien comprendre ces notions, vous pouvez télécharger l'exemple suivant : source.
dernière mise à jour le : dimanche 26 août 2001
A l'utilisation, mettre nos composants servant à atteindre nos bases de données (les DataSource, Table ) sur une ou des form se servant de ces bases peut se révèler pas être très pratique.
Delphi nous permet, si on le désire, de regrouper tous ces composants non visuel non pas sur une form mais sur un DataModule. A l'image d'une Form, un DataModule permet d'y déposer des composants. Le DataModule, contrairement à une Form n'est pas visuel. On ne peut donc y déposer des composants visuels. Comme pour une Form, A chaque DataModule correspond une Unit.
Concrètement, allez dans fichiers / nouveaux (suivi de autres si vous êtes en D6) puis onglet Nouveaux : choisir Module de données
Sur ce DataModule, vous pouvez y placer des DataSource, Table etc
Attention, il faut se rappeler que ce DataModule correspond à une Unit (par exemple Unit2).
Pour pouvoir utiliser les composants qui y sont placés à partir d'une autre Unit, par exemple un DBGrid placé sur la form1, il faut placer Unit2 dans la clause Uses de l'Unit comportant le DBGrid.
uses
Windows, Forms, Dialogs, Unit2;
Suite du tutorial sur les DataModule à venir (en construction)
dernière mise à jour le : samedi 13 octobre 2001
Supposez la cas suivant :
Vous êtes bibliothécaire et vous devez créer un programme qui gère les prêts de vos livres.
Vous avez besoin de connaître en permanence :
• Vos clients (coordonnés, n° de leur carte d'adhérant ). Ces renseignement figureront dans une table.
• Les mouvements de vos livres (qui les a emprunté, quand, sont ils rendus ). Ces mouvements feront l'objet d'une autre table.
Vous souhaitez, lorsque vous consultez les mouvements de vos livres, voir en même temps les coordonnés de l'emprunteur. Vous voulez donc qu'à chaque fois que vous vous placez sur un enregistrement de la table contenant un mouvements, la table contenant les clients se place automatiquement sur l'enregistrement correspondant au client correspondant.
C'est une relation un-à-plusieurs car à un client ne correspondra qu'un seul enregistrement de la table des clients (c'est en fait un champ indexé). Par contre, il peut y avoir plusieurs enregistrements de la table des mouvements qui contiennent le même client dans le champ correspondant.
Pour les créer, se référer au tutorial sur ce sujet en conservant l'alias TEST
• Une pour vos clients que l'on nommera Annuaire.
Bien mettre les champ NumClient et Nom en Index
• Une qui stockera les mouvements et que l'on nommera Mouvements
Pour cet exemple, bien que ce ne soit pas indispensable, nous allons utiliser un DataModule. Placez le tel que vu dans le tutorial sur ce sujet.
Sur ce DataModule, placez 2 composants Table et 2 composants DataSource
Entrez le nom de l'Alias de notre base de donné dans le champ DataBaseName de Table1 et Table2
Faisons pointer Table1 vers la table modifiant sa propriété TableName :
Faisons de même pour Table2 mais en le faisant pointer vers :
Reste à "brancher" nos DataSources vers leur table respective. Affecter Table1 à la propriété DataSet de DataSource1
et Table2 à la propriété DataSet de DataSource2
Nous avons donc fini de placer les composants qui servent à accéder à nos tables. Il faut maintenant placer des composants qui nous permettrons de visualiser, modifier ces tables.
Dans la Form1, placez deux DBGrid (Onglet ContrôleBD de la palette de composants).
Nous allons utiliser leur propriété DataSource pour "brancher" chaque DBGrid vers leur DataSource respectif. Ils pourront ainsi afficher respectivement les contenus de la Table 1 et de la Table2.
Observez la propriété DataSource de l'un deux, Delphi ne nous en propose aucun.
Normal, nos DataSources sont placés à l'extérieur de notre Form1. Dans le uses de l'Unit1, il faut ajouter l' Unit2
uses
Windows, Forms, Dialogs, Unit2;
Affecter DataSource1 à la propriété DataSource du DBGrid1
et DataSource2 à la propriété DataSource du DBGrid2.
Dès maintenant, mettez à true la propriété Active de Table1 et Table2, vous devez voir vos tables (sans doute vides chez vous ). Profitez-en pour lancer votre programme et commencer à remplir la base. Pour la suite de l'exemple, faite attention à ce que les n° des clients rentrés dans les mouvements correspondent à un NumClient existant de l'annuaire.
Affectons DataSource2 à la propriété MasterSource de Table1 (ainsi, Table1 est lié à DataSource2 qui lui même est lié à Table2
Il nous reste à désigner quel champ de Table1 servira de lien avec quel champ de Table2.
Pour cela, cliquez sur les à droite de la propriété MasterFields de notre Table1
Delphi nous affiche à gauche les champs indexé de Table1 et à droite, tous les champs de Table2.
Cliquez sur le champ NumClient de la colonne Champs Détail et sur NumClient de la colonne Champs maître, puis sur le bouton Ajouter.
Le lien est fait : un enregistrement de Table2 sera lié à un enregistrement de Table1 : celui qui a le même n° de client
A noter que cela a changé les propriétés MasterFields et IndexFieldNames de Table1. MasterFields a pris le nom du champ de Table2 (Client) qui doit être lié avec le champ de Table1 désigné par la valeur d'IndexFieldNames (NumClient).
• Table1 et Table2 pointent respectivement vers et vers à travers leurs propriétés DataBaseName et TableName.
• DataSource1 et DataSource2 pointent respectivement vers Table1 et Table2 et donc en fait vers et . Il le font par le biais de leur propriété DataSet
• Table1, et donc en réalité la table , sait qu'il a une liaison de type maître-détail (ou "liaison un-à-plusieurs" si vous préférez) avec la table puisque l'on a placé DataSource2 dans sa propriété MasterSource.
• Table1, et donc en réalité la table , sait que le champ NumClient de la table et le champ Client de la table sont liés. Il le sait par l'intermédiaire de ses champs MasterFields et IndexFieldNames.
Vérifiez que les propriétés Active de Table1 et Table2 sont à True. Lancez le programme (F9). A chaque fois que l'on se déplace dans Table2, Table1 se place automatiquement sur l'enregistrement correspondant. Le DBGrid1 n'affiche plus que lui.
dernière mise à jour : samedi 13 octobre 2001
Dans les bases de données, il arrive fréquemment de vouloir que le choix de l'utilisateur se limite à un certain nombre de possibilités. Si on reprend l'exemple de notre bibliothèque, on ne souhaite pouvoir entrer dans les mouvements (entrées, sorties de livres) que des livres présents dans notre inventaire. Cela évitera par exemple de saisir Delphi deux au lieu de Delphi2
Le DBCombobox va nous permettre de rentrer "en dur" la liste de choix par l'intermédiaire de sa propriété Items.
Reprenez la base de donnée vue à la leçon 10 ou téléchargez la. Le cas échéant, donnez lui "TEST" comme nom d'alias (cf leçon 1 pour se rappeler comment on donne un nom d'alias).
Reprenez le projet construit à la leçon 10 ou téléchargez le.
Ajoutez un DBCombobox (onglet ContrôleBD) sur la form1
Il faut maintenant remplir la liste qui se déroulera. Cliquez sur les à droite de la
propriété Items et rentrez la liste de livre de votre inventaire.
Lancez le programme (F9). Cliquez sur de votre DBComboBox. Vous voyez la liste de choix se dérouler.
A ce stade, même si vous sélectionnez une valeur, cela ne rentrera rien dans votre base de donnée car on a pas encore indiqué la table et le champ qu'il faudra modifier. Si vous sélectionnez une valeur, le DBComboBox reste vide
Il reste vide car ce qu'il affiche est justement la donnée du champ de la table concernée. Pas de table indiquée => rien d'affiché.
Choisissez le DataSource qui correspond à la table concernée à l'aide de la propriété DataSource du DBCombobox (ici DataSource2).
Choisissez le Champ concerné à l'aide de la propriété DataField (ici
LivreEmprunte)
Lancez le programme. Déplacez-vous dans le DBGrid, vous verrez que ce qui s'affiche dans le DBCombobox est bien la valeur du champ LivreEmprunte de l'enregistrement courant.
Inversement, vous pouvez modifier la valeur en question par le biais de la liste de choix du DBCombobox.
La plupart d'entre vous sont en train de se dire que c'est bien gentil tout cela, mais il va falloir recompiler à chaque fois que l'on ajoute un livre dans l'inventaire ! Effectivement, la solution DBCombobox est certainement bien pour rentrer par exemple "vrai ou faux" ou "oui ou non" et encore, si on a pas de problème de langue, mais ce n'est certainement pas la bonne solution pour gérer notre bibliothèque. La bonne solution est d'afficher le contenu d'un champ d'une table. C'est le rôle du DBLookUpComboBox.
Créons une nouvelle table pour notre base de données nommées (voir Leçon 1) :
Respectez les indications suivantes. Commencez à la remplir. Pour gagner du temps, vous pouvez la télécharger. Placez bien ce fichier dans le même dossier que les autres tables utilisées pour ce tutorial (L'alias reste ainsi valide pour cette table)
La liste déroulante du DBLookUpComboBox va être remplie à l'aide d'un champ de la table livre.
• Placez un TTable (qui se nommera Table3) et un DataSource (DataSource3) sur notre DataModule.
• Connectez Table3 à la Base TEST en choisissant la
Table Livre
• Connectez le DataSource3 à Table3 par l'intermédiaire de sa propriété DataSet.
• Mettez la propriété Active du Table3 à True.
Placez un DBLookUpComboBox (onglet ContrôleBD) sur la
Form1. Ce composant est l'équivalent d'un DBComboBox, mais il permet de remplir la liste déroulante à partir d'une table.
• Indiquez au DBLookUpComboBox qu'il doit remplir sa liste à l'aide des données que lui fournira le DataSource3 : Modifiez la propriété ListSource du DBLookUpComboBox
• Indiquez le ou les champ à afficher dans la liste déroulante à l'aide de sa
propriété ListField. Ici, par exemple, on verra les champ NumLivre et NomLivre. (Séparer les champ par un ";").
• Il faut maintenant indiquer quel champ sera transmis suite à la sélection par l'utilisateur d'un élément dans la liste déroulante :
• Exactement de la même façon que pour le DBCombobox, indiquez quel champ de quelle Table doit recevoir cette donnée.
.
Le champ pointé par DataField doit être du même type que le champ pointé par KeyField.
Lancez le programme, testez.
Actuellement, la liste déroulante apparaît ainsi :
On voit bien, dans la liste, les champs NumLivre et NomLivre.
Ce qui s'affiche dans le DBLookUpComboBox est le premier des champs décrits par la propriété ListField et donc le champ NumLivre. Il est probable que vous préféreriez voir le nom du livre et non un simple numéro.
• La propriété ListFieldIndex permet d'indiquer lequel des champs pointés par ListField doit s'afficher dans cette partie. 0 affichera le premier (ici NumLivre) 1 affichera le 2° (ici NomLivre) etc Pour continuer l'exemple, entrez 1 dans cette propriété ListFieldIndex.
Ce qui est affiché dans est l'élément de la liste
déroulante qui a une valeur telle que, pour l'enregistrement en cours, son champ pointé par KeyField est égal à la valeur du champ pointé par ListField. En d'autres termes, si vous vous déplacez dans votre DBGrid, vous ne verrez une valeur
s'afficher dans que si le nom du livre contenu dans
l'enregistrement en cours du DBGrid existe dans la liste déroulante du
DBLookUpComboBox.
Petite expérience : si vous avez suivi le cours depuis le début sans rien modifier, vous avez la possibilité de rentrer dans la table "Livres" des noms de livres de 30 caractères alors que dans le champ "LivreEmprunte" de la table "Mouvements", vous êtes limité à 15 caractères. Lancez le programme, et sélectionnez dans la liste déroulante un nom de livre supérieur à 15 caractères. Seulement les 15 premiers caractères du nom sont pris par la table "LivreEmprunte" et donc seulement les 15 premiers caractères apparaissent dans le DBGrid. Résultat, on a pas la même chaîne de caractère dans "NomLivre" que dans le champ "LivreEmprunte". On ne verra donc pas de valeur s'afficher dans le
DBLookUpComboBox
Il est évident que pour un cas réel, il aurait fallu que le nombre de caractères autorisés pour LivreEmprunte et NomLivre soit le même.
Il aurait même mieux valu, dans le champ LivreEmprunte, non pas stocker le nom du livre mais un numérique correspondant au champ NumLivre de la table Livres.
On aurait alors mis NumLivre dans la propriété KeyField du
DBLookUpComboBox avec toujours LivreEmprunte dans la propriété DataField.
Pour trier la liste de choix, il suffit d'utiliser un index. Créez par exemple un index secondaire nommé IndexNomLivre indexant le champ NomLivre (cf leçon 6) affectez IndexNomLivre à la propriété IndexName de table3. Si vous relancez le programme, la liste de choix est triée par ordre alphabétique.
Pour des filtres / tris plus subtils, vous pouvez utiliser un Query au lieu de la table3.
Pour plus d'explications et mieux comprendre les Query : cf Leçon 11
Source du programme
dernière mise à jour : lundi 15 octobre 2001
SQL est un langage d'interrogation de bases de données relationnelles telles que Oracle, Sybase, Microsoft SQL Server, Access etc
Le propos de ce tutorial n'est pas de donner une vue exhaustive de ce langage mais d'indiquer comment utiliser ce langage avec Delphi. Un site de référence pour le
langage SQL :
Vous pourrez aussi utiliser le constructeur SQL fournis avec Delphi.
Souvenez-vous, une architecture d'accès à une base de données telles qu'on l'a vue précédemment était de ce style:
Table1 est relié à la base de donnée par l'intermédiaire de sa propriété
DataBaseName et TableName. Table1 représente donc directement une table.
DataSource1 est relié à des données par l'intermédiaire de sa propriété DataSet.
Les composants tels que les DBGrid qui voudront accéder aux données le feront au travers du DataSource.
On vient de voir que SQL est un langage d'interrogation des bases de données.
C'est donc un composant qui se "place" entre la base de données et le DataSource. Query1 "représente" les données au même titre que Table1 représentait des données. DataSource permet de les exploiter; d'y accèder.
En cliquant sur la propriété SQL du Query1, on va pouvoir entrer nos requêtes SQL qui permettront de filtrer joindre etc
Dans cet exemple, on considérera que vous avez déjà créé votre base de données et que son alias se nomme TEST. La base de données utilisée est celle de la leçon "lier 2 tables"
• Commencez un nouveau projet. Ajoutez-y un DataModule
• Placez-y un DataSource et un Query (onglet AccèsBD)
• Affectez TEST à la propriété DataBaseName de Query1
• Affectez Query1 à la propriété DataSet de DataSource1. D'où le nouveau schéma
:
• Il faut maintenant pouvoir afficher les valeurs que nous renverra la base suite à une requête SQL.
Placez un DBGrid sur la Form1.
Dans l'unit1, déclarez l'Unit2 dans le Uses.
Affectez DataModule2.DataSource1 à sa propriété DataSource.
• Cliquez à droite de la propriété SQL de Query1
Entrez une requête SQL. Par exemple
qui permettra de sélectionner et donc d'afficher via le DBGrid tous les champs (*) de la table mouvements en filtrant pour ne voir que le client 1002
Pour voir le résultat, il suffit de mettre la propriété Active du Query1 à True.
Résultat :
Pouvoir modifier les donnés d'une table affiché par l'intermédiaire d'une reqête SQL
Si vous testez le programme actuel, vous verrez qu'à l'exécution, il vous est impossible de modifier les données. Pour pouvoir les modifier, il faut mettre la propriété RequesLive à True. Attention, seuls les données issu d'une requête SQL simple pourront être modifiées. En particulier, les requêtes faisant appel à plusieurs tables ne permettront pas la modification des données.
Version Entreprise uniquement :
Une autre façon de faire pour rentrer les requêtes SQL dans la propriété SQLdu Query1 est de se servir du constructeur SQL. Pour cela, cliquez avec le bouton de droite sur le composant Query1 puis sélectionnez Constructeur SQL.
Les entrées ci-dessus vont nous donner la requête suivante :
dernière mise à jour : samedi 15 décembre 2001
Retour au sommaire
Reprenons l'exemple du chapitre portant sur le SQL.
Nous avions donner l'exemple de requête :
SELECT client FROM mouvements WHERE livreemprunte="Delphi2"
Cette requête est fixée en dur dans le programme. Il serait souhaitable de pouvoir permettre par exemple à l'utilisateur de rentrer le nom du livre recherché dans un Edit.
Une des solutions, est de lire par exemple un Edit puis de fabriquer une nouvelle requête SQL par un simple traitement de chaîne de caractère du type :
( 'SELECT * FROM mouvements');
('WHERE Upper(LivreEmprunte) LIKE
"'+UpperCase() +'%"');
Cette requête affichera les enregistrements de la table mouvements dont le contenu de mis en majuscule sera égal au début du champ LivreEmprunte mis en majuscule. Concrétement, si vaut "delphi", la dernière ligne de la requête SQL contenu dans vaudra :
WHERE Upper(LivreEmprunte) LIKE "delphi%");
Par conséquent, les livres Delphi 1, Delphi2 etc seront affichés.
Pour tester cet exemple, partez de l'exemple que vous avez construit au chapitre portant sur le SQL. Ajoutez un bouton sur la fiche puis implémentez son événement OnClick comme suit :
procedure TForm1.Button1Click(Sender: TObject); begin
DataModule2.Query1.Active:=False;
.Clear;
( 'SELECT * FROM mouvements'); ('WHERE upper(LivreEmprunte) LIKE
"'+UpperCase() +'%"');
DataModule2.Query1.Active:=True; end;
Nous allons rentrer, dans la propriété SQL de notre Query, une requête contenant un paramètre. Il suffira de modifier le contenu de ce paramètre pour avoir une requête adaptée à l'entré d'une valeur dans un Edit.
La première chose à faire est de rajouter un paramètre dans la liste des paramètres de notre Query. Ce paramètre pourra alors être utilisé dans une requête SQL.
• Dans la DataModule, cliquez sur le Query puis, cliquez droit sur Params puis sur Ajouter un élément.
• Dans l'inspecteur d'objet, Affectez ParamNomLivre à sa propriété Name ? Mettez la propriété DataType à FtString.
• Dans la propriété SQL du Query, entrez :
SELECT *
FROM mouvements
WHERE Upper(LivreEmprunte) LIKE :ParamNomLivre
Notez les points (:) devant ParamLivre. En SQL, cela indique que ce qui suit est un paramètre. SQL remplacera, avant d'effectuer la requête, :ParamNomLivre par le contenu de ce paramètre.
Notre programme n'aura plus qu'à s'occuper de changer la valeur du paramètre ParamLivre (atteignable par Quey1.Param[0] ) pour faire varier la requête SQL.
• Pour cela, ajoutez un bouton sur form1 et implémentez sa méthode OnClick comme suit :
procedure TForm1.Button2Click(Sender: TObject); begin
DataModule2.Query1.Active:=False;
DataModule2.Query1.Params[0].AsString :=UpperCase()+'%';
DataModule2.Query1.Active:=True; end;
• Lancez le programme entre une valeur dans l'Edit, testez
Sources du programme
Retour au sommaire
Jusqu'à présent, nous utilisions une architecture simplifiée dans laquelle les composants Table pointaient directement sur des tables de la base de données par l'intermédiaire de ses propriétés DataBaseName et TableName.
Pour plusieurs raisons, il peut être judicieux faire pointer les composants TTable nom pas directement vers 'une base mais par l'intermédiaire d'un composant TDataBase.
Par exemple, lorsque notre base comporte un grand nombre de table il sera plus facile de changer d'Alias dans cette nouvelle architecture (une seule propriété d'un seul composant à modifier)
En fait, TDatabase permet, dans une application de base de données, de contrôler précisément la connexion avec une base de données basée sur le BDE.
Utilisez un objet TDatabase quand une application de base de données basée sur le BDE nécessite l'une des options suivantes sur la connexion avec une base de données :
• Connexion persistante avec la base de données.
• Accès personnalisé à un serveur de bases de données.
• Contrôle des transactions.
• Alias BDE spécifique à l'application
Il n'y a pas vraiment d'inconvénient à l'utilisation de cette architecture. Elle a l'avantage de faciliter certaines évolution de votre programme.
A noter que pour du SQL, le sghéma suivant est tout à fait valable :
Placez les 3 composants suivants sur votre form ou votre DataModule:
Propriétés de DataBase1 :
Donnez un "nom de base de données" en modifiant la propriété DataBaseName du composant DataBase1. Ce nom ne correspond pas à un alias existant. Ce peut être ce que vous voulez, n'importe quelle chaîne de caractère. Par exemple "toto" ou "BaseTest". Choisissons pour l'exemple BaseTEST
Indiquez à DataBase1 la base de données qu'il devra utiliser.
Propriétés de Table1
Pour le composant Table1, d'habitude, on entrait directement l'alias de la base dans sa propriété DataBaseName. Cette fois ci, nous allons rentrer le "nom de base de données" que l'on avait informée pour la propriété DataBaseName du DataBase1 (ici, "BaseTest").
Cliquez à droite de la propriété DataBaseName du Table1. Vous verrez qu'il vous propose de BaseTest.
C'est ainsi que vous créez la jonction entre le Table1 et le DataBase1.
Il faut, comme d'habitude, lui indiquer la table de cette base que l'on va vouloir exploiter. Modifier la propriété TableName comme suit :
Propriétés de DataSource1
Pas de nouveauté, choisir Table1pour sa propriété DataSet.
Test
Placez par exemple un DBGrid et connectez le à DataSource1 en choisissant DataSource1 dans la propriété DataSource du composant DBGrid1.
Mettez à True la propriété Active de Table1 et vous verrez le contenu de votre table dans DBGrid1.
On a vu que le composant TDataBase représente la base de données. On peut donc par l'intermédiaire de ses propriétés modifier certains comportements. Par exemple, si on utilise une base Access, on peut faire en sorte qu'il ne nous demande plus le mot de passe s'il n'y en a pas besoin.
Pour cela, il suffit de mettre la propriété LoginPrompt à False.
dernière mise à jour : mardi 16 avril 2002
Retour au sommaire
Une des solutions pour utiliser une base Access est de passer par le BDE et ODBC.
• Allez dans le panneau de configuration de Windows (Démarrer, Paramètre, Panneau de configuration).
• Cliquez sur
• Choisissez l'onglet System DSN
• Cliquez sur Add, Sélectionnez "Microsoft Access Driver (*.mdb)".
• Cliquez sur Terminer.
• Entrez un nom dans "Data Source Name" (ici TestOdbcBdeAccess)
• Entrez une description (ici Test)
• Cliquez sur Select pour choisir votre fichier base de donnée (ici ) et enfin cliquez sur OK
A partir de cet instant, on en est rammené au cas normal d'utilisation du BDE. En effet, allez dans l'administrateur BDE (Panneau de configuration/ administrateur BDE). TestOdbcBdeAccess y est bien présent.
Dernière mise à jour : mardi 16 avril 2002
Retour au sommaire
Une des solutions pour utiliser une base Access est de passer par ADO.
• Placez un composant ADOConnection (Onglet ADO) sur la Form.
• Cliquez sur la propriété ConnectionString
• Cliquez sur Construire
• Choisissez dans l'onglet fournisseur "Microsoft Jet 4.0 OLEDB Provider" puis cliquez sur suivant.
• Sélectionnez votre base de données Access.
• Cliquez sur "tester la connexion"
• Si vous n'avez pas de mot de passe à votre base, placez la propriété LoginPrompt de votre ADOConnection à False. Cela évitera qu'il ne vous pose la question du mot de passe.
• Validez pour sortir.
• Vérifiez que la propriété connected de l'ADOConnection est à True.
?
• Sélectionnez ADOConnection1 pour sa propriété Connection. ADOTable1 est alors relié à notre base par l'intermédiaire de ADOConnection1.
• Sélectionnez le nom de votre table dans sa propriété TableName. ? Rendez-le actif via sa propriété Active.
• relié à notre ADOTable via sa propriété
DataSet
• Placez un DBGrid
• Reliez le à la source de donnée grâce à sa propriété
DataSource
• Vous devez voir apparaître le contenu de votre Table. Si ce n'est pas le cas, vérifiez la propriété connected de l'ADOConnection et la propriété Active de l'ADOTable.
Retour au sommaire
Bon, j'ai pas mal galéré pour réussir à faire quelque chose qui donne satisfaction. Les composants DBExpress sont relativement nouveaux pour moi. L'aide n'est pas très explicite et je n'ai rien trouvé de satisfaisant sur le net. Bref, pas mal de tâtonnements. Il faut donc considérer ce tutorial comme étant en BétaTest. Je suis preneur de toutes les observations. Je m'interroge en particulier sur 2 trucs (voir en fin de cette page).
Depuis la version 6 (pro et +), Borland a introduit des composants DbExpress. Ces composants permettent entre autres d'attaquer des bases MySQL.
Le site étant entièrement basé sur du PHP + MySQL, j'ai voulu tester la chose.
Pré-requis :
• Avoir une version de Delphi qui possède les composants DbExpress (D6 pro et +)
• Avoir MySQL installé sur votre poste. Personnellement, je l'avais installé via le "pack" EasyPHP (gratuit) sur Pour télécharger uniquement MySQL :
• Avoir créé une base de données qui vous servira de support à l'exemple suivant.
Personnellement, pour ce genre de manip, j'utilise phpMyAdmin livré avec EasyPHP.
Comme d'habitude, on va construire un exemple.
• Ouvrez Delphi, commencez un nouveau projet.
• Allez, on va prendre de bonnes habitudes, on va ouvrir un DataModule.
(Fichier, Nouveau, Module de données).
• Sur ce Module de données, placez un composant
SQLConnection.
Dans la "vue arborescente des objets", on voit notre SQLConnection mais avec un point d'interrogation devant. Normal, il n'est pour l'instant connecté
à aucune base.
• Vérifiez que votre votre serveur MySQL est lancé.
• Double cliquez sur votre SQLConnection
• Cliquez sur pour créer une nouvelle connexion
• Donnez MYSQL comme nom de pilote. Choisissez un nom pour votre
connexion (ici : testmysql)
• Dans le champ Database, placez le nom de votre base de donnée (ici
MaBaseMySQL). Il faut se rappeler que le nom d'une base de données en MySQL est en réalité le nom du dossier dans lequel sont placés ses fichiers.
• Dans le champ HostName, entrez le nom réseau de l'ordi qui contient la base. Si c'est l'ordi sur lequel tourne le programme, vous pouvez mettre localhost comme nom.
• Effacez la valeur qui se trouve dans le champ LocaleCode. (à noter qu'un lecteur m'a fait la remarque suivante : Sans mettre un nom de user, la manip plante, alors qu'en mettant simplement le user à root, la connexion se fait. Chez moi, pas besoin
?
?
:
• A noter que le point d'interrogation a disparu et que
Delphi a rempli pour vous, entre autres, les champs ConnectionName, DriverName de votre SQLConnection.
• Si vous n'en avez pas besoin et si vous ne souhaitez pas voir s'afficher la boite de dialogue demandant l'utilisateur et le mot de passe, mettrez à False sa propriété LoginPrompt.
Placez un SQLClientDataSet sur le DataModule
• Indiquez-lui, via sa propriété DBConnection, qu'il doit utiliser votre SQLConnection pour se connecter à la base .
• Placez un SELECT dans la propriété CommandText du SQLClientDataSet. Par exemple : SELECT * FROM unetable où unetable est une table de votre base.
Là, on en est à un stade déjà vu dans les autres tutoriaux BDD :
• Placez un DataSource sur notre dataModule et le connecter à notre SQLClientDataSet via sa propriété DataSet.
Actuellement, le diagramme de nos connexions correspond à ceci
:
• Sur votre fiche (Form1) placez un DBGrid et un DBNavigator.
• Dans le uses de la form1, ajoutez le nom de l'unit corespondant à votre
DataModule2 (Unit2 si vous n'avez rien renommé)
• Dans la propriété DataSource du DBNavigator, sélectionez votre DataSource.
• Dans la propriété DataSource du DBGrid, sélectionez votre DataSource.
Vérifiez que la propriété Connected de votre SQLConnection est à True. Placez la propriété Active de votre SQLDataSet à True. Vous devez voir vos DBEdit se remplir.
i vous avez un message d'erreur du style , vérifiez la clef LocaleCode en double cliquant sur le SQLConnection (l'effacer). Vérifiez également la valeur de LocaleCode dans la propriété Params du SQLConnection (l'effacer).
• Pour être plus propre, et prendre de bonnes habitudes, remettez Connected du SQLConnection à False. Cela fait également passer la propriété Active du SQLDataSet à False.
• Dans l'événement OnShow de la fiche Form1, placez le code suivant :
procedure TForm1.FormShow(Sender: TObject); begin
DataModule2.SQLConnection1.Connected:=True;
DataModule2.SQLClientDataSet1.Active:=True; end;
Actuellement, si vous modifiez une donnée dans votre DBGrid, vous aurez beau cliquer sur le V (validation) du DBNavigate, lorsque vous fermez le programme et que vous l'ouvrez de nouveau, vous voyez que vos modifications n'ont pas été écrites dans la base.
Ajoutez un bouton sur votre fiche. Implémentez son événement OnClick comme suit :
| procedure TForm1.Button1Click(Sender: TObject); var MaxErrors:integer; begin MaxErrors:=1; {extrait de l'aide : MaxErrors indique le nombre maximum d'erreurs tolérées par le fournisseur avant d'interrompre l'opération d'actualisation. Initialisez MaxErrors à –1 pour indiquer qu'il n'y a pas de limite au nombre d'erreurs.} {Pour MySQL, à ce que l'on m'a dit, MySQL ne tolère qu'une seule erreur.} DataModule2.SQLClientDataSet1.ApplyUpdates(MaxErrors); end; |
En cliquant sur le bouton, les éléments modifiés iront vers la base de données.
Dans cette configuration, si vous voulez ajouter un DBEdit ou autres DBMemo sur votre fiche, pour le connecter, il faudra, comme pour le DBGrid, sélectionner le datasource pour sa propriété DataSource. Il faudra aussi sélectionner le champ que vous voulez voir, et ce via sa propriété DataField.
Attention, vous ne pourez voir les champs sélectionnables dans la liste de choix et donc vous ne pourrez sélectionner ce champ que si le SQLConnection1.connected est à true et le SQLClientDataSet1.Active est à true (les modifier dans l'inspecteur d'objet. Une fois la manip faite, les remettre à False.)
Je l'ai dit au départ, il faut donc considérer ce tutorial comme étant en BétaTest. Je suis preneur de toutes les observations. Je m'interroge en particulier sur 2 trucs :
• Pourquoi, dans le DBNavigator, lorsque l'on clique sur , on a un message d'erreur :
• A quoi sert exactement la clef LocalCode ?
Retour au sommaire
QuickReport est un ensemble de composants édités par
qusoft qui permettent d'imprimer des états issus de vos bases de données. QuickReport est fourni avec les Delphi pro et +
La page de base. Placer un logo et un titre:
• Commencez un nouveau projet,
• Placez un composant QuickReport,
• Développez sa propriété Bands. Placez HasTitle à True.
• Une bande apparaît en haut de la page du composant QuickReport
Le contenu de cette bande apparaîtra sur la première
page de notre rapport.
• Placez un TQRLabel dans cette bande. Mettez par exemple 'Titre du rapport' dans sa propriété Caption. Ajustez comme vous le désirez sa propriété Color, Font etc
• Cliquez avec le bouton droit de la souris sur le QuickRep. Cliquez sur Prévisualiser.
• Pour améliorer votre Première page, vous pouvez ajouter une image (typiquement le logo de votre compagnie). Placez un TQRimage dans la bande. Ajustez sa taille. Choisissez votre image via la propriété Picture et enfin, placez si besoin sa propriété Stretch à true.
Afficher les données de la base de données.
• Nous allons ajouter une bande qui affichera ces données. Pour cela, développez la propriété Bands du QuickRep1 et placez la propriété
HasDetail à True.
• Il va falloir indiquer à cette Bande ce que l'on veut voir y apparaître. Plus particulièrement, les données de quelle Table de quelle Base de Données. Pour l'exemple, nous allons utiliser la base de données démo de Delphi.
Placez un composant TTable sur la Form1. Choisissez l'alias DBDemos
pour sa propriété DataBaseName et pour sa propriété TableName.
• Placez un QRDBText dans la bande Détail.
.
• Il faut maintenant indiquer que le contenu du QRDBText sera un enregistrement contenu dans la table. Sélectionnez Table1 pour la propriété DataSet du QRDBText et Company pour sa propriété SataField.
• Faites un clic droit sur le TQuickReport. Sélectionnez 'Préview'. Vous
obtenez On a bien notre image et notre
titre en haut. La bande détail apparait avec le premier enregistrement de notre table et pour le champ sélectionné (company). La bande se répète autant de fois que l'on a d'enregistrement. Dans la prévisualisation, vous pouvez aller voir toutes le pages.
• Entraînez-vous à formater un peu tout ça : On peut jouer sur les couleurs, les polices, rajouter du texte .
Lancer la prévisualisation et l'impression à l'exécution
• Ajoutons deux boutons : Un pour la prévisualisation et un autre pour l'impression directe.
• Implémentons leurs évènemenyts OnClick ainsi :
| procedure TForm1.Button2Click(Sender: TObject); begin QuickRep1.Preview; end; procedure TForm1.Button1Click(Sender: TObject); begin QuickRep1.Print; end; |
• Testez, ça marche
• Double cliquez sur le notre QuickRep1. Vous obtenez la fenêtre "Paramètres de l'état"
• Mettez 2 à "nombre de colonnes". Cliquez sur Appliquer puis sur Prévisualiser. Vous verrez que vos résultats apparaissent maintenant sur 2 colonnes.
• Cochez Bas de page et En-tête de page. Cliquez sur OK. vous verrez que Delphi vous a ajouté 2 bandes. Placez un QRLabel sur chacune de ces bandes. Donnez une valeur distincte dans leur caption respectif, par exemple "Bas de page" et "Entete de page". Lancez une prévisualisation. Vous constatez que vos pages ont maintenant une entète et un pied de page. A noter que les deux bandes auraient pu être ajoutées en placant deux QRBand sur le TQuickRep et en donnant respectivement à leur propriété BandType les valeurs rbPageHeader et rbPageFooter.
• Toujours dans la fenêtre Paramètres de l'état, cochez En-tête de colonne et récapitulatif. Dans chacune des 2 bandes qui viennent d'être créées, placez un QRLabel de façon à pouvoir voir, à l'aide d'une previsualisation ce que QuickReport en fait. Vous constaterez que l'entête de colonne, comme son nom l'indique est placé en haut de chaque colonne de chaque page. Le récapitulatif est placé à la fin du document.
Charger le source de l'exemple
Retour au sommaire
Microsoft nous met à disposition un Driver ODBC pour Excel. Ne rêvons pas, cela ne va pas remplacer SQL Serveur ou autre. Par contre, cela peut être très pratique pour récupérer des données d'une feuille Excel vers une autre base de données.
Ouvrez une nouvelle feuille Excel et entrez les libellés suivants :
Ces libellés correspondent à des têtes de colonne. Ce sont les nom des champs de notre table. Les lignes sous cette ligne seront nos enregistrements.
• Remplissez la colonne indice (par exemple 1 sur la ligne 1 2 sur la ligne 2 etc..). L'important est de ne pas avoir deux lignes identiques.
• Donnez un nom à la zone constituée de cette ligne et des lignes en dessous qui représenteront nos enregistrements : Insertion / Nom / Définir
• Donnez un nom à notre table : ici, TableAnnuaire.
• Sauvez votre Feuille Excel par exemple sous .
• Dans Démarrer / Panneau de configuration, cliquez sur
• Dans l'onglet "source de données utilisateur", cliquez sur "ajouter" et sélectionnez le driver Microsoft Excel Driver:
• Cliquez sur "Terminer"
• Remplissez les Edit comme suit :
• Cliquez sur Options et décochez lecture seule
• Cliquez sur sélectionnez un classeur et indiquez le chemin et le nom de votre fichier excel.
• Cliquez sur OK.
• Pour éviter des messages d'erreur, laissez l'Excel ouvert avant de charger et de lancer l'exemple.
• On est maintenant ramené au cas classique d'accès à une Base de données par Delphi. Si vous le souhaitez, vous pouvez télécharger le source de l'exemple
