|
Interbase dbExpress.NET - John COLIBRI. |
- abstract: utilisation de dbExpress avec Interbase et Delphi 8.
- mots clé:tutorial - Interbase - dbExpress - Delphi 8 - VCL.NET - DataSnap - Midas
- logiciel utilisé: Windows XP, Delphi 8, Interbase 6, 7 ou Firebird 1 ou 1.5
- matériel utilisé: Pentium 1.400Mhz, 256 M de mémoire
- champ d'application: Delphi 8 - .NET
- niveau: développeur Delphi et Base de Données
- plan:
1 - Introduction Cet article va vous indiquer comment gérer des données en utiliser Interbase
fourni avec Delphi 8 en utilisant dbExpress. Nous avons présenté les autres façons d'utiliser Interbase: - le tutorial interbase: comment utiliser des bases
de données en mode Client Serveur (Delphi 6, Ibx). L'article d'initiation le plus complet
- Interbase dbExpresss: le mode dbExpress
(Delphi 6, dbExpress). Le mode qui permet le mieux de comprendre l'architecture Ado.Net qui en est directement issue
- Interbase Ibx.Net: le portage sous .Net de la mécanique Ibx (Delphi 8, Ibx.Net). Le moyen le plus simple d'utiliser
Interbase et Delphi 8. Contient aussi un comparatif de toutes ces architectures avec les schémas correspondants
- Delphi 8 Ado.Net: sous Windows Forms, en l'absence de couche spécifique à Interbase nous pouvons utiliser une
mécanique similaire à Odbc et proche d'Ado sous Win32. Cet article présente ce fonctionnement
- Interbase Borland Data Provider: la voie royale sous Windows Forms, et pour toutes les base, même pour tous
les langages
La présentation des différentes possibilités ne sera pas reprise ici. Nous nous concentrerons sur l'utilisation de dbExpress.Net.
Nous nous adressons pour ce tutorial à un programmeur Delphi ayant:
- une idée élémentaire de Delphi: Palette, Inspecteur, OnClick.
- déjà pratiqué un peu la gestion de données avec SQL: SELECT, INSERT
INTO, UPDATE . Si tel n'est pas le cas, reportez vous aux articles précédents (le tutorial Interbase pour les
techniques SQL, Interbase dbExpress pour le détail de dbExpress en mode Win32 ou Interbase
Ibx.Net) pour les traitements sous Vcl.Net.
Notre but étant ici de vous montrer comment utiliser dbExpress en Delphi 8, nous n'avons pas présenté un tutorial intégral. Les articles précédents
contiennent aussi des exemples plus nombreux (automatisation, script) ou programmés de façon légèrement différente (sous procédures différentes). Parcourez-les au besoin avant ou après cet article.
2 - Connection, Création de table, Insertion 2.1 - Préparation La création de la base ne peut être réalisée par des composants dbExpress: il
faut utiliser un utilitaire propre à chaque moteur (IbConsole pour Interbase) ou les contrôles Interbase Express. Reportez-vous aux articles sur dbExpress pour voir comment faire.
Pour cette présentation, nous allons simplement utiliser une base crée auparavant. Nous pourrions utiliser celle installée par Borland, mais le chemin dépendant de votre machine ("program files" avec Windows US ou
"fichiers communs" avec Windows Français), nous préférons rapatrier la base dans un chemin proche de notre projet Delphi. Nos exemples utiliseront la base INSTITUT_PASCAL.GDB de nos articles
précédents. Vous pouvez aussi utiliser la base démonstration de Borland EMPLOYEE.GDB. Comme nous créons intégralement les tables, il suffira de changer le nom de la base. Par conséquent:
- vérifier qu'il existe un répertoire ..\_data (dossier au même niveau que le dossier contenant le .DPR)
- copiez la base dans ce dossier
- renommez la base INSTITUT_PASCAL_4.GDB (le changement de nom d'une base
local par un Explorateur Windows n'empêche pas son utilisation. Si cette base est connectée, débranchez-la auparavant. Si vous n'y arrivez pas, utilisez-la telle quelle, mais changez les noms dans les exemples ci-dessous)
2.2 - La connection Pour nous connecter à une base Interbase nous allons utiliser un composant SqlConnection. Ce composant doit être initialisé avec: - dans DriverName, le nom du pilote Interbase:
Interbase
- dans ConnectionName le nom de la connexion:
IbLocal
- dans Params les paramètres propres à Interbase, tels que le nom
d'utilisateur, le mot de passe, le chemin où se trouve le fichier .GDB etc
Pour spécifier l'endroit où se trouve le fichier .GDB, nous fournissons: - soit le chemin, si nous travaillons en local:
c:\programs\interbase\data\Institut_Pascal.gdb
ou
..\data\Institut_Pascal.gdb
- soit l'URL du PC qui héberge le Serveur:
127.0.0.1\ c:\programs\interbase\data\Institut_Pascal.gdb
HostName\ c:\programs\interbase\data\Institut_Pascal.gdb
www.jcolibri.com\ c:\programs\interbase\data\Institut_Pascal.gdb
Pour initialiser tous ces paramètres, nous employons l'éditeur de tSqlConnection:
Notez que: - lorsque nous avons créé la base, nous avons choisi le "dialecte 3". C'est la version Sql du moteur
- lorsque nous connectons la base, nous avons choisi le "dialecte 3": c'est le dialecte du client Interbase.
- la connection est le test IMPERATIF pour vérifier que nous pouvons travailler en Interbase. Nous recommandons d'effectuer cette connection systématiquement avant de poser des tonnes de composants sur la tForm ou
d'écrire des milliers de lignes
- si nous connectons la base en mode conception, Delphi ouvrira aussi la base lorsque l'exécution sera lancée. Ces deux connections sont comptabilisés par
le gestionnaire de licences Interbase comme 2 connections séparées (ce sont bien deux processus Windows).
Si vous travaillez en utilisant la version Delphi d'Interbase, il vaut
mieux fermer la connection en mode conception, puis la rouvrir lors de l'exécution. En fait, chaque accès à Interbase ouvrira automatiquement la connexion. Nous pouvons donc:
- soit laisse dbExpress ouvrir automatiquement la connexion
- soit ouvrir la connexion lors de l'exécution en appelant;
tSqlConnection.Connected:= True;
Nous allons donc fermer la connexion en mode conception:  | sélectionnez SqlConnection1, sélectionnez dans l'Inspecteur d'Objet
la propriété Connected et basculez sa valeur sur False
|
3 - Créer et remplir une Table 3.1 - Principe
Nous allons créer une table contenant pour chaque formation: - un code (par exemple 8)
- un nom (par exemple "Delphi Interbase")
- le nombre de jours (par exemple 3)
- un prix (par exemple 1.400)
Pour cela nous devons envoyer une requête en langage SQL vers le Serveur Interbase. La syntaxe de cette requête est:
CREATE TABLE formations
(f_numero INTEGER, f_nom CHARACTER(11), f_jours
INTEGER, f_prix NUMERIC(5, 2) ) | Il suffit donc de choisir un nom de table, et le nom de chaque colonne avec son type.
Parmi les types autorisés par Interbase citons: - INTEGER pour les valeurs entières 32 bits
- SMALLINT pour les valeurs entières 16 bits
- NUMERIC(decimales, précision) pour une valeur numérique flottante
- DATE pour une date
- CHARACTER(taille) pour des caractères
Pour envoyer cette requête vers le Serveur: - nous utilisons un tSqlConnection qui assurera la connection vers le Serveur
- nous utilisons un tSqlQuery
- nous le relions à tSqlConnection
- nous plaçons la requête SQL dans sa propriété ISqlQuery.SQL (via l'Inspecteur ou en code)
- nous appelons tSqlQuery.ExecSql
3.2 - Utilisation de SQL
La requête à envoyer au Serveur est placée dans tSqlQuery.Sql. tSqlQuery.Sql est un descendant de tStrings. Nous pouvons donc utiliser, par exemple:
SqlQuery1.Sql.Add('CREATE TABLE formations (f_numero INTEGER, f_nom CHARACTER(11))');
| Pour construire la requête: - nous pouvons utiliser Add pour ajouter une ligne de requête, Text pour affecter une requête, Clear pour purger tout texte antérieur, ou même
LoadFromFile pour lire un fichier .txt contenant la requête:
SqlQuery1.Sql.LoadFromFile('cree_formation.txt');
|
La mise en page n'a aucune importance pour le Serveur: la requête peut être répartie en plusieurs lignes:
SqlQuery1.Sql.Add('CREATE TABLE');
SqlQuery1.Sql.Add(' formations ');
SqlQuery1.Sql.Add(' (f_numero INTEGER, f_nom CHARACTER(11))');
|
l_requete:= 'CREATE TABLE '+ Edit1.Text+ ' (';
l_requete:= l_requete+ Edit2.Text+ ')';
SqlQuery1.Sql.Add(l_requete);
|
3.3 - L'application Pour créer notre table | | créez une nouvelle application et appelez-la "p_net_dbx_create_table" |
| | sélectionnez dans la page "dbExpress" de la Palette le composant SqlConnection: et posez-le sur la tForm
| | |
Cliquez deux fois sur SqlConnection1, renseignez "Driver Name", "Connection Name", "DataBase", "Dialect", "User Name" et "Pass Word" Sélectionnez la propriété LoginPrompt et basculez sa valeur sur False
Vérifiez la connection en basculant SqlConnection1.Connected sur True, puis fermez la connection (pour éviter de monopoliser un utilisateur). La connection sera ouverte avant l'envoi de la requête | |
| sélectionnez dans la page "dbExpress" de la Palette le composant SqlQuery: | | |
sélectionnez sa propriété SqlConnection et initialisez-la à SqlConnection1 | | |
placez un tButton sur la Forme et créez sa méthode OnClick. Placez-y les instructions de création:
|
procedure TForm2.create_table_Click(Sender: TObject);
begin
with SqlQuery1 do
begin
Close;
with Sql do
begin
Clear;
Add('CREATE TABLE '+ k_table_name);
Add(' ('
+' f_numero INTEGER,');
Add(' f_nom CHAR(28),');
Add(' f_jours SMALLINT,');
Add(' f_prix NUMERIC(5, 2)');
Add(' )');
end; // with Sql
Try
SqlConnection1.Open;
ExecSql;
display(' ok');
except
on e: Exception do
display(' *** pb_create '+ e.Message);
end;
end; // with SqlQuery1
end; // create_table_Click
|
| |
compilez, exécutez, et cliquez le bouton
|
Vous pouvez télécharger le sources du projet "net_dbx_create_table.zip".
3.4 - Vérifier la création
Nous pouvons vérifier que la création a été effectuée en utilisant l'explorateur de bases de données Delphi, ou en lisant les données ce cette table dans notre application. Pour lire les données il suffit d'envoyer la requête
au moteur. Comme les instructions pour envoyer du SQL vers le moteur sont toujours les
mêmes (SqlQuery.Sql.Clear, SqlQuery.Sql.Add, SqlQuery.ExeSql) et que seul le texte de la requête change, nous avons crée un procédure paramétrée:
procedure execute_sql_request(p_sql_request: String);
begin
with Form2, SqlQuery1 do
begin
Close;
with Sql do
begin
Clear;
Add(p_sql_request);
end; // with Sql
Try
SqlConnection1.Open;
ExecSql;
display(' ok');
except
on e: Exception do
display(' *** pb_create '+ e.Message);
end;
end; // with SqlQuery1
end; // execute_sql_request
|
Par conséquent, pour vérifier la création de notre table |
| tapez cette procédure dans votre unité
| | |
placez un second tButton sur la Forme et placez-y la requête de lecture:
|
procedure TForm2.open_table_Click(Sender: TObject);
begin
execute_sql_request('SELECT * FROM '+ k_table_name);
end; // open_table_Click
|
| |
compilez, exécutez, et cliquez le bouton
|
Notre requête ouvre la table, mais n'affiche rien: si notre table existe tout se passe bien, sinon nous aurons une exception. Nous verrons d'ailleurs comment
afficher une Table SELECT en détail plus bas.
3.5 - Effacer une table Pour supprimer une Table, il faut exécuter la requête:
Donc: | |
placez un autre tButton sur la Forme et placez-y la requête de suppression:
procedure TForm2.drop_table_Click(Sender: TObject);
begin
execute_sql_request('DROP TABLE '+ k_table_name);
end; // drop_table_Click
|
| | |
compilez, exécutez, et cliquez le bouton
|
3.6 - Ajouter des Données Pour ajouter un enregistrement 3, Interbase Delphi l'instruction SQL à exécuter est:
INSERT INTO formations
(f_numero, f_nom)
VALUES (3, 'Interbase Delphi') | L'ajout d'enregistrement va modifier les données du Serveur, donc nous
utiliserons tSqlQuery.ExecSql. Par conséquent nous pouvons utiliser notre procédure générique précédente en lui fournissant cette requête comme paramètre. De façon détaillée: |
| placez un tButton sur la Forme et créez sa méthode OnClick. Placez-y les instructions d'ajout:
procedure TForm2.insert_one_Click(Sender: TObject);
begin
execute_sql_request(
'INSERT INTO '+ k_table_name
+ ' (f_numero, f_nom, f_jours, f_prix)'
+ ' VALUES (6, '+ QuotedStr('Asp et Delphi')+ ', 3, 1400.40)')
end; // insert_one_Click
| | | |
compilez, exécutez, et cliquez le bouton
|
Nous pouvons aussi paramétrer l'insertion pour ajouter plusieurs lignes plus facilement:
procedure TForm2.fill_table_Click(Sender: TObject);
// -- insert several hard coded values in a row
procedure insert_generic(p_number: Integer; p_name: String; p_days: Integer; p_cost: Double);
begin
DecimalSeparator:= '.';
execute_sql_request(
'INSERT INTO '+ k_table_name
+ ' (f_numero, f_nom, f_jours, f_prix)'
+ ' VALUES ('
+ IntToStr(p_number)+ ', '+ QuotedStr(p_name)
+ ', '+ IntToStr(p_days)+ ', '+ FloatToStr(p_cost)+ ')');
DecimalSeparator:= ',';
end; // insert_generic
begin // fill_table_Click
insert_generic(1, 'Initiation Delphi', 3, 1400);
insert_generic(2, 'Bases de Données Delphi', 3, 1400);
insert_generic(3, 'Interbase Delphi', 3, 1400);
insert_generic(4, 'Composants Delphi', 3, 1400);
insert_generic(5, 'UML et Patterns en Delphi', 3, 1400);
insert_generic(6, 'Initiation Pascal', 4, 1900);
end; // fill_table_Click
|
Vous pouvez télécharger les sources du projet "ib_dbx_insert_data.zip".
4 - Lire et Afficher 4.1 - Principe de dbExpress Les traitements précédents sont quasiment identiques à ceux que nous effectuons lorsque nous utilisons les composants IBX:
- SqlConnection a remplacé IbDatabase
- SqlQuery a remplacé IbSql
- les transactions sont gérées automatiquement par dbExpress, au lieu d'utiliser un IbTransaction explicite
Pour la lecture nous utilisons de même un composant tClientDataset qui, comme IbQuery stocke les données en mémoire, mais qui possède des propriété supplémentaires, comme la possiblité de stocker temporairement des données dans
un fichier local indépendant d'Interbase. La mécanique est la suivante: - SqlConnection s'occupe de la connexion avec le Client Interbase
- SqlQuery traite les requêtes Sql mais ne tamponne pas les données en lecture
- le données échangées avec le Serveur utilisent:
- un composent tDataSetProvider qui met les données sous forme de paquets
pour normaliser les échanges avec le Client
- un tClientDataSet qui se charge de tamponner les données
- les tDataSource tDdbGrid usuels se chargent de la visualisation et la saisie
L'organisation des composants est la suivante: Au niveau fonctionnement: - lorsque nous ouvrons le tClientDataset, celui-ci propage la demande au
tDatasetProvider, qui la transmet au tSqlQuery.
- le tSqlQuery envoie alors la requête "SELECT ..." au Serveur:
- le Serveur construit l'ensemble des données correspondant à la requête et renvoie les paquets de lignes vers le Client
dbExpress possède aussi deux extensions:
- il est possible de séparer
- d'une part SqlConnection, SqlQuery et DataSetProvider sur une machine intermédiaire, placée entre le Serveur et les Clients
- de l'autre les Clients contenant chacun un ClientDataset, et les composants de contrôle visuel
Il s'agit alors d'une application 3 niveaux, utilisant pour communiquer entre le PC du milieu et les Clients des composants de communications. Nous n'utiliserons pas cette séparation, et laisserons tous les composants sur le
poste Client
- il est possible de travailler sans aucune connexion au Serveur: le ClientDataSet travaille en mémoire pure, en sauvegardant le contenu de son
cache dans un fichier du Client (à un format binaire ou XML n'ayant rien à voir avec Interbase). Il s'agit du travail nomade, illustré par ce schéma:
Ce type de traitement est appelé aussi par Borland "MyBase".
Nous allons nous intéresser dans la suite de cet article aux lectures et modifications de tables Interbase en utilisant le tClientDataSet.
4.2 - Lecture dans un tClientDataSet Voici notre première application pour afficher les données:
Notez l'ordre de chaînage des composants:
 Cet ordre provient des multiplicités possibles: - une tSqlConnection peut être reliée à plusieurs tSqlQueries
- un tSqlQuery peut être relié à plusieurs tDatasetProviders
- un tDataSetProvider peut alimenter plusieurs tClientDatasets
- un tClientDataSet peut être relié à plusieurs tDataSource
- un tDataSource peut être relié à plusieurs composants visuels tels que la tdbGrid
Si Delphi avait proposé au développeur programmeur de relier tSqlConnection à ses tSqlQueries, il aurait fallu prévoir une LISTE de tSqlQueries associés,
alors que dans l'ordre inverse, chaque tSqlQuery ne peut avoir qu'une tSqlConnection, donc une seule ligne dans l'Inspecteur d'Objet.
Vous pouvez télécharger le sources du projet "p_net_dbx_clientdatase.zip".
5 - Le mode nomade 5.1 - Principe Nous pouvons sauvegarder les données stockées dans un tClientDataset dans un fichier disque, dans un format .XML ou un format binaire équivalent. Pour cela,
il suffit d'appeler tClientDataset.SaveToFile(nom_fichier); Ces données peuvent ensuite être rechargées par l'instruction symétrique:
tClientDataset.LoadFromFile(nom_fichier); Bien plus intéressant encore, les modifications apportées aux données, que
celles-ci proviennent d'un chargement depuis le Serveur ou depuis un fichier local, sont sauvegardées en mémoire, et mémorisées sur disque. Pour modifier les données du Serveur, il suffit d'appeler:
tClientDataset.ApplyUpdates(nombre_erreurs);
5.2 - La sauvegarde Commençons par présenter la sauvegarde: | |
dans l'application précédente, posez un autre tButton sur la Forme, nommez-le "save_cds_" et placez-y l'instruction de sauvegarde:
const k_save_dataset_name= '..\_data\save_formation.xml';
procedure TForm2.save_to_file_Click(Sender: TObject);
begin
ClientDataset1.SaveToFile(k_save_dataset_name);
end; // save_to_file_Click
|
| 5.3 - Le chargement
Pour bien démontrer que le travail en mode nomade ne nécessite aucune connexion, nous allons construire une nouvelle application qui charge, modifie, et sauve les données, sans aucun lien avec le Serveur Interbase. Un peu comme
un commercial qui, après avoir sauvegardé le matin les données de ses clients sur son portable, va récupérer les commandes chez ses clients durant la journée. Pour cela: |
| créez une nouvelle application et appelez-la "p_net_dbx_clientdataset" | | | sélectionnez dans la page "Data Access" de la Palette le composant
ClientDataSet et posez-le sur la tForm. | | | sélectionnez dans la page "Data Access" de la Palette le composant DataSource:
- Posez-le sur la tForm.
- dans sa propriété DataSet sélectionnez ClientDataSet1
| | |
sélectionnez dans la page "Data Controls" de la Palette le composant dbGrid: - Posez-le sur la tForm.
- dans sa propriété DataSource sélectionnez DataSource1
| |
| dans l'application précédente, posez un autre tButton sur la Forme, nommez-le "load_cds_" et placez-y l'instruction de chargement:
const k_save_dataset_name= '..\_data\save_formation.xml';
procedure TForm2.load_cds_Click(Sender: TObject);
begin
ClientDataset1.LoadFromFile(k_save_dataset_name);
end; // load_cds_Click
| | | |
compilez et exécutez. Cliquez sur le bouton: les données sont chargées depuis le fichier: 
| 5.4 - affichage .XML
Nous souhaitons, à titre de vérification, pouvoir examiner le contenu du fichier .XML. Nous avons pour cela crée une classe Delphi qui analyse le fichier et en extrait les données. Cette classe a été présenté dans l'article
display ClientDataset .XML. Nous l'avons simplement aménagée pour Delphi 8: - utilisation des unités _net_ pour l'affichage
- remplacement des FILE par des tFileStream.
Le reste étant identique, nous ne ferons que l'utiliser ici. Pour cela: | |
ajoutez l'importation des unités u_c_net_cds_table et u_c_net_cds_analyze_cds
| | |
posez un autre tButton sur la Forme, nommez-le "display_xml_" et placez-y l'instruction d'affichage du fichier .XML:
uses u_c_net_display, u_c_net_log
, u_c_net_text_buffer
, u_c_net_cds_analyze_xml
, u_c_net_cds_table
;
procedure TForm2.display_xml_Click(Sender: TObject);
var l_c_table: c_table;
begin
with c_cds_analyze_xml.create_cds_analyze_xml('xml', k_save_dataset_name) do
begin
l_c_table:= c_table.create_table('table');
analyze_xml(l_c_table);
display_line;
l_c_table.display_formatted_line_list;
l_c_table.Free;
Free;
end; // with c_analyze_xml
end; // display_xml_Click
| | | |
compilez et exécutez. Cliquez sur le bouton: les données du fichier .XML sont affichées dans Memo1: 
|
5.5 - Modifications
Pour pouvoir sauvegarder les modifications effectuées en mode nomade, il faut aussi pouvoir sauvegarder: | |
dans l'application précédente, posez un autre tButton sur la Forme, nommez-le "save_cds_" et placez-y l'instruction de sauvegarde, comme pour la précédente application:
const k_save_dataset_name= '..\_data\save_formation.xml';
procedure TForm2.save_to_file_Click(Sender: TObject);
begin
ClientDataset1.SaveToFile(k_save_dataset_name);
end; // save_to_file_Click
|
| Nous allons maintenant modifier le contenu de notre ClientDataset: Nous pouvons vérifier le nouveau contenu du fichier .XML: | | cliquez "display_xml_":
| Nous voyons que le fichier .XML conserve: - l'ancienne ligne ("Asp et Delphi")
- la ligne modifiée ("Delphi 8 Asp.Net")
Cette sauvegarde dans le fichier .XML permet - la restauration des états antérieurs si nous le souhaitons
- la mise à jour en envoyant vers le serveur du changement entre la version initiale et la dernière mise à jour
Nous aurions de même des enregistrements additionnels si nous ajoutons des données ou si nous supprimons des lignes. Voyons donc comment notre brave VRP va mettre à jour le Serveur Interbase lorsqu'il rentrera le soir au bureau.
6 - Mise à jour du Serveur Interbase 6.1 - Principe Les modifications, qu'elles soient effectuées en direct à un tClientDataset
connecté au Serveur (via tDatasetProvider etc) ou qu'elles proviennent du chargement d'un fichier local .XML sont envoyées vers le Serveur par tClientDataset.ApplyUpdates.
6.2 - ApplyUpdates
Voici une application qui effectue cette mise à jour. Installons d'abord la chaîne allant du tSqlConnection au tDbGrid: Puis | | posez un tButton sur la Forme, nommez-le "load_cds_" et placez-y l'instruction de chargement:
ClientDataset1.LoadFromFile(k_save_dataset_name); | | |
posez un tButton sur la Forme, nommez-le "apply_updates_", et tapez le code qui envoient les modifications vers le Serveur:
procedure TForm2.apply_updates_Click(Sender: TObject);
var l_error_count: Integer;
begin
l_error_count:= ClientDataset1.ApplyUpdates(-1);
end; // apply_updates_Click
|
|
Pour surveiller ce qui va se passer, nous allons afficher les instructions Sql échangées en utilisant un composant SqlMonitor: | |
sélectionnez dans la page "dbExpress" de la Palette le composant SqlMonitor:  - posez-le sur la tForm.
- sélectionnez sa propriété SqlConnection et initialisez-la à SqlConnection1
- sélectionnez sa propriété Active et basculez la sur True
- créez son événement OnLogTrace et affichez dans Memo1 les traces Sql:
var g_trace_count: Integer= 0;
procedure TForm2.SQLMonitor1LogTrace(Sender: TObject;
var CBInfo: SQLTRACEDesc);
begin
with SQLMonitor1, TraceList do
while g_trace_count< Count do
begin
display(Strings[g_trace_count]);
Inc(g_trace_count);
end;
end; // SQLMonitor1LogTrace
|
|
Et finalement pour détecter les erreurs que ApplyUpdates pourrait provoquer, nous demandons à notre application de surveiller la mise à jour:
A présent, en avant: Vous pouvez d'ailleurs vous assurer que le Serveur a bien tenu compte des
modifications en fermant l'application et en la relançant: "open_cds_" récupèrera bien les valeurs modifiées. Nous n'avons pas traité ici la gestion des erreurs (essentiellement ce qui se
passe si quelqu'un d'autre a modifié les données avant nous) ou si nous souhaitons affiner les règles de mise à jour. Voyez l'articles sur Interbase dbExpress à ce sujet
7 - Télécharger les Exemples Voici les programmes de cet article: Ces .ZIP comprennent: - le .DPR, la forme principale, les formes annexes eventuelles
- les fichiers de paramètres (le schéma et le batch de création)
- dans chaque .ZIP, toutes les librairies nécessaires à chaque projet (chaque .ZIP est autonaume)
Ces .ZIP contiennent des chemins RELATIFS. Par conséquent:
- créez un répertoire n'importe où sur votre machine
- placez le .ZIP dans ce répertoire
- dézippez et les sous-répertoires nécessaires seront crées
- compilez et exécutez
Ces .ZIP ne modifient pas votre PC (pas de changement de la Base de Registre, de DLL ou autre). Pour supprimer le projet, effacez le répertoire.
Comme d'habitude:
- nous vous remercions de nous signaler toute erreur, inexactitude ou problème de téléchargement en envoyant un e-mail à jcolibri@jcolibri.com. Les corrections
qui en résulteront pourront aider les prochains lecteurs
- tous vos commentaires, remarques, questions, critiques, suggestion d'article, ou mentions d'autres sources sur le même sujet seront de même
les bienvenus à jcolibri@jcolibri.com.
- plus simplement, vous pouvez taper (anonymement ou en fournissant votre e-mail pour une réponse) vos commentaires ci-dessus et nous les envoyer en
cliquant "envoyer" :
- et si vous avez apprécié cet article, faites connaître notre site,
ajoutez un lien dans vos listes de liens ou citez-nous dans vos blogs ou réponses sur les messageries. C'est très simple: plus nous aurons de visiteurs et de références Google, plus nous écrirons d'articles.
8 - Conclusion Lors de cette présentation de dbExpress, nous avons indiqué comment installer Interbase, créer une base, des tables, ajouter, lire, modifier et effacer des données.
Si vous avez des questions, vous pouvez: - vous reporter au livre Delphi dBase qui présente, par le détail, la gestion des composants visuels et les techniques
de traitement des données (formatage, vérfications, calculs...)
- pour les blobs, voyez Blobs Interbase
- pour l'utilisation d'Interbase en mode Client Serveur, sans utiliser le BDE, voyez le Tutorial Interbase
- l'affichage du contenu d'un fichier .XML correspondant à la sauvegarde locale d'un tClientDataset est présenté dans Affichage ClientDataset XML
- la présentation Architecture du Moteur Interbase présente l'organisation du programme Interbase, correspondant
aux sources fournies par Borland pour la version 6.
- je présenterai à la conférence Borcon France 2004 le
panorama des techniques d'accès aux données Interbase: les API isc, le BDE, Interbase Express, dbExpress, et pour Delphi 8, IBX.NET en mode
VCL.NET et ADO.NET en mode Windows Forms.
- vous pouvez aussi m'adresser vos questions par e-mail à jcolibri@jcolibri.com
Nous n'avons pas essayé d'être exhaustif dans la présentation. Lors des stages que j'anime personnellement à l'Institut Pascal, j'entre beaucoup plus dans le détail: - la gestion des multiples erreurs et exceptions qui interviennent lors
d'applications utilisant des bases de données
- les possibilités d'installer Interbase depuis Delphi, et d'interroger les paramètres de la Base ou du schéma depuis un programme Delphi, de lister les tables, les champs etc
- le traitement des contraintes (clé primaires, intégrité référentielle, intégrité sémantique)
- la manipulation détaillée des valeurs extraite d'une Table, en utilisant les
tFields et les différents composants visuels tDb_xxx, ainsi que les traitements spécifiques aux chaînes, aux dates, aux blobs
- les techniques de validation de saisie essentielles pour toute application de gestion
- le traitement spécifiques à dbExpress:
- l'utilisation de tClientDataset avec ses multiples possibilités
- les paramétrage du tDatasetProvider
- la gestion des erreurs de réconciliation et le traitement d'utilisateurs multiples
- l'étude approfondie du langage SQL, qui est au coeur de tout traitement avec des Serveurs Sql
- les triggers, les procédures cataloguées (tStoredProc), les générateurs
- la gestion de Serveur (sauvegarde / restauration, statistiques, réglage)
Pour examiner le programme détaillé de cette formation, cliquez
Client Serveur Interbase. Nous
proposons de plus d'autres formations présentées dans ces
pages (programme, dates des prochaines sessions,
conditions, transparents, abonnement à la lettre d'information...). Finalement j'interviens aussi pour des missions d'audit, de réalisation de
projet, de portage et maintenance, et de tutorat.
9 - L'auteur John COLIBRI est passionné par le développement Delphi et les applications de Bases de Données. Il a écrit de nombreux livres
et articles, et partage son temps entre le développement de projets (nouveaux projets, maintenance, audit, migration BDE, migration Xe_n,
refactoring) pour ses clients, le conseil (composants, architecture, test) et la
formation. Son site contient des articles
avec code source, ainsi que le programme et le calendrier des stages de formation Delphi, base de données, programmation objet, Services Web, Tcp/Ip et
UML qu'il anime personellement tous les mois, à Paris, en province ou sur site client.
|
