SqlDBHowto/fr

From Lazarus wiki
Jump to: navigation, search

Deutsch (de) English (en) español (es) français (fr) Nederlands (nl) 中文(中国大陆)‎ (zh_CN)

Portail de la base de données

Références:

Tutoriels/articles pratiques :

Bases de données

Advantage - MySQL - MSSQL - Postgres - Interbase - Firebird - Oracle - ODBC - Paradox - SQLite - dBASE - MS Access - Zeos

Ce texte est conçu comme un 'comment-faire'. Je veux répondre à un nombre de question une par une, et expliquer comment vous pouvez utiliser les diverses classes. Toutes ces questions sont posées l'une après l'autre et forme une sorte de tutoriel.

Je vais essayer de le dire de telle façon que le texte peut être utilisé pour Lazarus ainsi que FreePascal. Cependant, les exemples sont écrits pour FreePascal (c'est-à-dire qu'ils sont des applications de type console).

Où puis-je trouver la documentation officielle ?

Veuillez voir la documentation officielle à la page SQLDB documentation.

Comment se connecter à un serveur de base de données ?

SqlDB ne se connecte pas directement à un serveur de base de données mais utilise un client qui correspond au serveur de base de données employé. SqlDB envoie les commandes à la bibliothèque cliente ; la bibliothèque cliente se connecte au serveur de base de données et transfert les commandes. Ce qui veut dire que la bibliothèque cliente doit être installée pour faire la connection à la base de données. Sous Windows le client est souvent une .dll, sous Linux un .so et sous OS/X une .dylib.

Quand la bibliothèque cliente est installée convenablement, vous pouvez vous connecter à la base de données en utilisant un composant TSQLConnection. Divers composants TSQLConnection sont disponibles pour les différents serveurs de bases de données (voir SQLdb_Package) :

Note pour MySQL - Il y a plusieurs différences entre les versions de clients qui font que les connections ne peuvent être interchangées. Si une bibliothèque cliente version 4.1 est installée, vous devez utiliser un TMySQL41Connection. Ce n'est pas lié au serveur MySQL ; en utilisant une bibliothèque cliente MySQL 4.1, vous pouvez probablement vous connecter à un serveur MySQL 5.0 (voir la documentation MySQL concernant les combinaisons supportées).

Bien que les détails diffèrent entre les les diverses bases de données, en général, vous aurez besoin de définir quatre propriétés pour vous connecter au serveur de base de données :

  • Le nom du serveur ou l'adresse IP
  • Le nom de la base de données
  • Le nom de connection
  • Le mot de passe

Quand ces propriétés sont définies, vous pouvez créer une connection avec la méthode 'open'. Si la connection échoue, une exception EDatabaseError est levée. Utilisez la propriété 'connected' pour savoir si la connection a été établie avec le serveur de base données. Utilisez la méthode 'close' pour mettre fin à la connection avec le serveur.

Program ConnectDB;
 
{$mode objfpc}{$H+}
 
uses
  IBConnection;
 
function CreateConnection: TIBConnection;
begin
  result := TIBConnection.Create(nil);
  result.Hostname := 'localhost';
  result.DatabaseName := '/opt/firebird/examples/employee.fdb';
  result.UserName := 'sysdba';
  result.Password := 'masterkey';
end;
 
var   
  AConnection : TIBConnection;
 
begin
  AConnection := CreateConnection;
  AConnection.Open;
  if Aconnection.Connected then
    writeln('Successful connect!')
  else
    writeln('This is not possible, because if the connection failed, ' +
            'an exception should be raised, so this code would not ' +
            'be executed');
  AConnection.Close;
  AConnection.Free;
end.

Si une exception est levée, lisez le message attentivement. Il se peut que le serveur ne soit pas en cours d'exécution, le nom de connection et/ou le mot de passe est incorrect ou le nom de base de données ou l'adresse IP sont mal orthographiés. Si le message d'erreur indique que la bibliothèque cliente n'est pas trouvée, alors il faut contrôler que le client est correctement installé. Souvent, le message d'erreur donne le nom du fichier recherché.

Comment exécuter des requêtes directes/créer une base de données ?

SQlDB - le nom dit tout - fonctionne uniquement avec des serveurs de bases de données qui font usage de SQL. SQL signifie Langage Structuré de Requête (Structured Query Language), il est un langage développé pour permettre de travailler avec des bases de données relationnelles. Virtuellement chaque SGDBR (Système de Gestion de Bases de Données Relationnelles) a son propre dialecte, mais une grande partie des ordres SQL est la même pour tous les SGBDR.

Dans FPC, il y a une différence entre :

  • des instructions qui retournent de l'information (un DataSet). Pour ceci, vous utiliserez un composant TSQLQuery ; voir #Comment lire de la donnée depuis une table ?.
  • des instructions qui ne retournent pas d'information mais font quelque chose d'autre p.ex. mettre à jour des données. Pour ceci, vous pouvez aussi utiliser la méthode 'ExecuteDirect' de TSQLConnection (Vous pouvez également utiliser cette option si vous récupérez un jeu de données, mais que vous n'êtes pas intéressé par les résultats, par exemple dans une procédure stockée pouvant être sélectionnée).

La plupart des SGBDR exécute des ordres SQL dans une transaction. Si vous voulez rendre les changements dans une transaction disponibles dans d'autres transactions, ou avoir ces changements disponibles après la fermeture de la transaction, alors vous devez faire un 'commit' de la transaction.

Pour supporter les transactions, SqlDB contient un composant TSQLTransaction. Un ordre SQL qui est exécuté par SqlDB doit toujours être exécuté au sein d'une transaction, même si le SGBDR ne supporte pas les transactions. Aussi, il y a des SGBD qui supporte la transaction et pour lequel TSQLConnection ne supporte pas (encore) la transaction. Même là, vous devez employer le composant TSQLTransaction.

Pour utiliser TSQLConnection.ExecuteDirect pour exécuter un ordre SQL, vous devez spécifier quelle 'transaction' doit être utilisée. A son tour, pour utiliser TSQLTransaction, vous devez spécifier quel composant TSQLConnection doit être utilisé.

L'exemple suivant crée une table 'TBLNAMES' avec des champs 'NAME' et 'ID' et insère deux enregistrements. Cette fois en utilisant SQLite. Les ordres SQL employés ne sont pas expliqués. Pour plus d'information sur les ordres SQL, leur emploi et syntaxe, veuillez vous référer à la documentation du SGBDR. Remarquez que cet exemple ne tente pas d'intercepter les exceptions, ce qui est une mauvaise chose ! Regardez dans Exceptions.

program CreateTable;
{$mode objfpc} {$ifdef mswindows}{$apptype console}{$endif}
uses
  sqldb, sqlite3conn; 
 
var 
  AConnection : TSQLite3Connection;
  ATransaction : TSQLTransaction;
 
begin
  AConnection := TSQLite3Connection.Create(nil);
  AConnection.DatabaseName := 'test_dbase';
 
  ATransaction := TSQLTransaction.Create(AConnection);
  AConnection.Transaction := ATransaction;
  AConnection.Open;
  ATransaction.StartTransaction;
  AConnection.ExecuteDirect('create table TBLNAMES (ID integer, NAME varchar(40));'); 
 
  ATransaction.Commit;
 
  ATransaction.StartTransaction;
  AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (1,''Name1'');'); 
  AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (2,''Name2'');'); 
  ATransaction.Commit; 
  AConnection.Close;
  ATransaction.Free;	
  AConnection.Free;
end

Comment lire de la donnée depuis une table ?

Utilisez le composant TSQLQuery pour lire la donnée depuis une table. Un composant TSQLQuery doit être connecté à un composant TSQLConnection et à un composant TSQLTransaction pour réaliser sa tâche. La configuration de TSQLConnection et TSQLTransaction est discutée dans #Comment se connecter à un serveur de base de données ? et #Comment exécuter des requêtes directes/créer une base de données ?.

Quand les TSQLConnection, TSQLTransaction et TSQLQuery sont connectés, alors TSQLQuery demande davantage de configuration pour fonctionner. TSQLQuery possède une propriété 'SQL' contenant un objet TStrings. La propriété TStrings contient un ordre SQL qui doit être exécuté. Si toutes les données de la table tablename doivent être lues, alors la propriété SQL doit contenir :

'SELECT * FROM tablename;'
.

Utilisez 'Open' pour lire la table du serveur et mettre les données dans le DataSet TSQLQuery. La donnée peut être accédée à travers TSQLQuery jusqu'à ce que la requête soit fermée en utilisant 'Close'.

TSQLQuery est une sous-classe de TDataset. TDataset possède une collection de 'Fields' (champs) qui contiennent toutes les colonnes de la table. Le DataSet garde aussi la trace de l'enregistrement courant. Utilisez 'First', 'Next', 'Prior' et 'Last' pour changer l'enregistrement courant. 'Bof' retourne 'True' si le premier enregistrement est atteint et 'Eof' retourne 'True' si le dernier enregistrement est atteint. Pour lire la valeur d'un champ dans l'enregistrement courant, trouvez d'abord le bon objet 'TField' et alors utilisez 'AsString', AsInteger', etc.

Exemple : Lecture de donnée depuis une table

Ci-dessous se trouve un exemple qui affiche toutes les valeurs de la table tel que cela est fait au dessus #Comment exécuter des requêtes directes/créer une base de données ?.

Program ShowData;
 
function CreateQuery(pConnection: TIBConnection; pTransaction: TSQLTransaction): TSQLQuery;
begin
  result := TSQLQuery.Create(nil);
  result.Database := pConnection;
  result.Transaction := pTransaction
end;
 
var 
  AConnection  : TSQLConnection;
  ATransaction : TSQLTransaction;
  Query        : TSQLQuery;
 
begin
  AConnection := CreateConnection;
  ATransaction := CreateTransaction(AConnection);
  Query := CreateQuery(AConnection, ATransaction);
  Query.SQL.Text := 'select * from tblNames';
  AConnection.Open;
  Query.Open;
  while not Query.Eof do
  begin
    Writeln('ID: ', Query.FieldByName('ID').AsInteger, 'Name: ' +
                                  Query.FieldByName('Name').AsString);
    Query.Next;
  end;
  Query.Close;
  AConnection.Close;
  Query.Free;
  ATransaction.Free;
  AConnection.Free;
end.

(le code du dessus n'est bien sûr pas tout à fait terminé. Il manque des blocs 'try...finally'. Il s'agit de montrer le code d'accès à la base de données, la finition est mise de côté.) Veuillez remarquer que 'TSQLTransaction.StartTransaction' n'est pas utilisé. Ce n'est pas nécessaire. Quand TSQLQuery est ouverte, l'ordre SQL est exécuté et si aucune transaction n'est disponible alors une transaction est automatiquement démarrée. Le développeur n'a pas besoin de démarrer une transaction explicitement. La même chose s'applique à la connection maintenue par TSQLConnection. La connection est ouverte au besoin, La ligne 'Aconnection.Open' n'est pas vraiment requise. Si un TSQLTransaction est détruit, un 'RollBack' automatique sera exécuté. Des modifications de données contenues dans la transaction pourront être perdues.

Pourquoi TSQLQuery.RecordCount retourne toujours 10 ?

Pour compter les enregistrements dans un DataSet, utilisez la propriété '.RecordCount'. Pourtant, remarquez que '.RecordCount' montre le nombre d'enregistrements qui sont déjà chargés depuis le serveur. Pour des raisons de performance, SqlDB ne lit pas tous les enregistrements à l'ouverture du TSQLQuery par défaut, seulement les 10 premiers. Ce n'est que lorsque le onzième enregistrement est accédé que le prochain ensemble de 10 enregistrements sera chargé, etc. En utilisant '.Last', tous les enregistrements seront chargés.

Quand vous voulez savoir le nombre effectif d'enregistrements sur le serveur, vous pouvez appeler '.Last' puis appeler '.RecordCount'.

Une alternative est disponible. Le nombre d'enregistrements retourné par le serveur est définie par la propriété '.PacketRecords'. La valeur par défaut est 10, si vous la mettez à -1 alors tous les enregistrements seront chargés en une seule fois.

Dans la version stable actuelle de FPC, '.RecordCount' ne prend pas en considération les filtres, i.e. montre le total non filtré.

Si vous avez besoin du nombre exact d'enregistrement, il est mieux de demander directement le nombre d'enregistrements dans une autre requête SQL, mais vous devez faire cela dans la même transaction, car d'autres transaction ont pu modifier ce nombre dans l'entre-temps.

Lazarus

Lazarus possède divers composants pour montrer les données d'un DataSet sur une fiche. A la place d'une boucle while et d'appels WriteLn comme ci-dessus, vous pouvez utiliser des composants pour montrer les données dans une table. Placez les bons composant TSQLConnection, TSQLTransaction et TSQLQuery sur une fiche, connectez-les et configurez-les convenablement. En plus, vous aurez besoin d'un TDataSource ; mettez dans la propriété 'TDatasource.Dataset' le composant TSQLQuery que vous utilisez.

(Remarque ne définissez pas la propriété 'TSQLQuery.Datasource' par le composant TDatasource que vous utilisez. Cette propriété est réservée à la mise en place de realtion maître/détail entre tables - voir MasterDetail). Par la suite, vous pouvez poser un TDBGrid sur la fiche et définir la propriété 'DataSource' de la grille avec le composant TDataSource que vous avez ajouté auparavant.

Pour voir si tout marche, mettez à 'True' la propriété 'Connected' du TSQLConnection dans l'EDI de Lazarus. L'EDI tentera de se connecter au serveur de base de données immédiatement. Si cela marche, mettez à 'True' la proriété 'TSQLQuery.Active'. Si tout est bon, vous verrez - dans l'EDI - toutes les données de la table immédiatement à l'écran.

Comment modifier de la donnée dans une table ?

Pour modifier les données dans un enregistrement, les TDataSet (duquel est dérivé TSQLQuery) doit être mis en mode édition. Pour ce faire, appelez l'une des méthodes '.Edit', '.Insert' ou '.Append'. Utilisez '.Edit' pour modifier les valeurs de l'enregistrement courant. Utilisez '.Insert' pour insérer un nouvel enregistrement avant l'enregistrement courant. Utilisez '.Append' pour ajouter un nouvel enregistrement en fin de la table. En mode Edit, vous pouvez changer les valeurs des champs grâce à la propriété 'Fields'. Utilisez la méthode '.Post' pour valider les nouvelles données, si les données sont valides, le mode Edit est abandonné. Si vous vous déplacez vers un autre enregistrement - par exemple en appelant '.Next' - et que le DataSet est en mode Edit, alors '.Post' est d'abord appelé. Utilisez '.Cancel' pour annuler tous les changements apportés depuis le dernier appel à '.Post' et quitter le mode Edit.

Query.Edit;
Query.FieldByName('NAME').AsString := 'Edited name';
Query.Post;

Ce qu'il y a au dessus n'est pas encore complet. TSQLQuery est dérivé de TBufDataset qui fait des mises à jour tamponnées (buffered updates). Les mises à jour tamponnées veulent dire qu'après l'appel à '.Post', les modifications sont visibles immédiatement dans l'ensemble de données mais pas envoyées au serveur de base de données. Il se passe que les modifications sont maintenues dans un journal des modifications. Quand la méthode '.ApplyUpdates' est appelée, tous les changements sont envoyés à la base de données. C'est à ce moment seulement que la base de données connaîtra les modifications. Les changements sont envoyés au serveur dans une transaction de TSQLTransaction. Assurez-vous de définir correctement la transaction avant d'appeler '.ApplyUpdates'. Après avoir appliquer les mises à jour, un commit doit être exécuté pour enregistrer les modifications sur le serveur de base de données.

Ci-dessous est un exemple de modification de données dans une table, d'envoi les modifications et de commit de la transaction.

Program EditData;
 
var 
  AConnection : TSQLConnection;
  ATransaction : TSQLTransaction;
  Query : TSQLQuery;
 
begin
  AConnection := CreateConnection;
  ATransaction := CreateTransaction(AConnection);
  AConnection.Transaction := ATransaction;
  Query := CreateQuery(AConnection, ATransaction);
  Query.SQL.Text := 'select * from tblNames';
  Query.Open;
  Query.Edit;
  Query.FieldByName('NAME').AsString := 'Edited name';
  Query.Post;
  Query.UpdateMode := upWhereAll;
  Query.ApplyUpdates;
  ATransaction.Commit;
  Query.Free;
  ATransaction.Free;
  AConnection.Free;
end.

Pour une discussion sur 'UpdateMode', continuer la lecture.

Comment SqlDB envoie les modifications aux serveur de base de données ?

Dans l'exemple de code dans #Comment modifier de la donnée dans une table ?, vous trouverez la ligne :

Query.UpdateMode := upWhereAll;

Sans explication de ce que cela fait. La meilleure façon de savoir ce que cette ligne fait est de la laisser de côté. Si vous laissez de côté l'instruction et suivez ce Comment-faire précisément, alors vous recevrez ce message d'erreur :

No update query specified and failed to generate one. (No fields for inclusion in where statement found)

Pour comprendre ce qui n'a pas marché, vous devez comprendre comment les modifications sont envoyées au serveur. La seule façon d'obtenir des données dans un serveur SQL est d'exécuter des requêtes. SQL a trois types de requêtes pour trois différentes façons de manipuler un enregistrement. Pour créer un nouvel enregistrement, modifier ou supprimer un enregistrement, les ordres insert, update et delete sont exécutés respectivement. Un ordre de mise à jour peut être comme ce qui suit :

UPDATE TBLNAMES SET NAME='Edited name' WHERE ID=1;

Pour envoyer le changement au serveur de base de données, SqlDB doit assembler une requête update. Pour ce faire, trois choses sont nécessaires :

Le nom de la table 
La nom de la table est récupéré par l'analyse de la requête de sélection, même si cela ne marche pas toujours.
Clause UPDATE ou INSERT 
Celle-ci contient les champs qui doivent être changés.
Clause WHERE 
Celle-ci contient les champs qui détermine quels enregistrements devraient être changés.

Chaque champ (chaque TField dans Fields) possède une propriété ProviderFlags. Seuls les champs avec pfInUpdate dans ProviderFlags seront utilisés dans la clause update ou insert d'une requête. Par défaut, pfInUpdate est mis pour tous les champs dans leur proriété ProviderFlags.

Le choix des champs utilisés dans la clause WHERE dépend de la propriété UpdateMode de la requête et de la propriété ProviderFlags des champs. Les champs avec pfInkey dans leur ProviderFlags sont toujours utilisés dans la clause WHERE. Un champ aura le drapeau pfInKey défini automatiquement si le champ fait partie de la clé primaire de la table et 'TSQLQuery.UsePrimaryKeyAsKey' retourne 'True'.

La valeur par défaut de UpdateMode de la requête est upWhereKeyOnly. Dans le mode update, seuls les champs avec pfInkey dans leur propriété ProviderFlags sont utilisés dans la clause WHERE. Si aucun des champs n'a de drapeau pfInKey mis, alors aucun champ n'est disponible pour la clause WHERE et le message d'erreur du début de la section sera retourné. Vous pouvez résoudre ce problème en :

  • En ajoutant une clé primaire à la table et mettre TSQLQuery.UsePrimaryKeyAsKey à 'True', ou
  • en définissant le drapeau pfInkey pour un ou plusieurs champs dans le code.

La propriété UpdateMode connaît deux autres valeurs. 'upWhereAll' peut être utilisée pour ajouter tous les champs avec le drapeau 'pfInWhere' mis à la clause WHERE. Par défaut, tous les champs ont ce drapeau mis. 'upWhereChanged' peut être utilisé pour ceux des champs qui ont le drapeau 'pfInWhere' mis et dont la valeur a été changée dans l'enregistrement courant.

Comment exécuter une requête en utilisant TSQLQuery ?

À côté des instructions qui renvoient un DataSet (voir #Comment lire de la donnée depuis une table ?, SQL a des ordres qui ne retournent pas de donnée. P.ex., les ordres INSERT, UPDATE et DELETE. Ces ordres peuvent être exécutés en utilisant TSQLConnection.ExecuteDirect, mais TSQLQuery peut être aussi utilisé. Si vous n'attendez pas de donnée en retour, utilisez TSQLQuery.ExecSQL au lieu de TSQLQuery.Open. Comme indiqué précédemment, utilisez TSQLQuery.Open pour ouvrir le DataSet retourné par l'ordre SQL.

La procédure suivante crée une table et insère deux enregistrements en utilisant TSQLQuery.

procedure CreateTable;
 
var 
  Query : TSQLQuery;
 
begin
  Query := CreateQuery(AConnection, ATransaction);
  Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
  Query.ExecSQL;
 
  Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (1,''Name1'');';
  Query.ExecSQL;
 
  Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (2,''Name2'');';
  Query.ExecSQL;
 
  Query.Close;
  Query.Free;
end;

Comment utiliser des paramètres dans une requête ?

Dans l'exemple de code de #Comment exécuter une requête en utilisant TSQLQuery ?, la même requête est utilisée deux fois, seules les valeurs à insérer diffèrent. Une meilleure façon pour faire cela consiste à utiliser des paramètres dans la requête.

La syntaxe des paramètres dans les requêtes est différente selon le SGBDR, mais les différences sont traitées par TSQLQuery. Remplacez les valeurs dans la requête avec un caractère deux-points suivi du nom du paramètre que vous voulez utiliser. Par exemples :

Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';

Cette requête créera deux paramètres : 'ID' et 'NAME'. Pour déterminer les paramètres, la requête est analysée au moment où le texte de TSQLQuery.SQL est affecté ou modifié. Tous les paramètres existants seront supprimés et les nouveaux paramètres seront ajoutés à la propriété 'TSQLQuery.Params'. L'affectation d'une valeur à un paramètre est similaire à l'affectation d'un champ dans un DataSet :

Query.Params.ParamByName('Name').AsString := 'Name1';

Vous ne pouvez pas savoir depuis la requête quel type de donnée doit être stocké dans le paramètre. Le type de donnée est déterminé au moment où une valeur est en premier affectée à un paramètre. En affectant une valeur en utilisant '.AsString', le paramètre est affecté du type 'ftString'. Vous pouvez déterminer le type de donnée directement en définissant la propriété 'DataType'. Si un type de donnée incorrect est affecté au paramètre alors des problèmes surviendront lors de l'ouverture ou de l'exécution de la requête. Voir Type de champ de base de données pour plus d'information sur les types de donnée.

Requête de sélection

Un exemple de requête de sélection avec des paramètres changera quelque chose comme ceci :

  Query.SQL.Text := 'select ID,NAME from TBLNAMES where NAME = '''+Edit1.Text+''' ORDER BY NAME ';

en quelque chose comme cela :

  Query.SQL.Text := 'select ID,NAME from TBLNAMES where NAME = :NAMEPARAM ORDER BY NAME ';
  Query.Params.ParamByName('NAMEPARAM').AsString := Edit1.Text;

Exemple

L'exemple suivant crée la même table que l'exemple précédent, mais maintenant des paramètres sont utilisés :

procedure CreateTableUsingParameters;
 
var 
  Query : TSQLQuery;
 
begin
  Query := CreateQuery(AConnection, ATransaction);
  Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
  Query.ExecSQL;
 
  Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';
  Query.Prepare;
 
  Query.Params.ParamByName('ID').AsInteger := 1;
  Query.Params.ParamByName('NAME').AsString := 'Name1';
  Query.ExecSQL;
 
  Query.Params.ParamByName('ID').AsInteger := 2;
  Query.Params.ParamByName('NAME').AsString := 'Name2';
  Query.ExecSQL;
 
  //Query.UnPrepare; // no need to call this; should be called by Query.Close
  Query.Close;
  Query.Free;
end;

Remarquez que cet exemple demande plus de code que l'exemple sans paramètre. Alors, à quoi sert l'utilisation de paramètres?

La vitesse est une des raisons. L'exemple avec des paramètres est plus rapide, parce que le serveur de base de donnée analyse la requête une seule fois (dans l'instruction '.Prepare' ou à la première exécution). Une autre raison pour employer les instructions préparées est la prévention des injections SQL (voir aussi Programmation sécurisée).

Finalement, dans certains cas, ils simplifient le codage.

Dépannage : Journalisation par TSQLConnection

Vous pouvez laisser un journal TSQLConnection à ce qu'il fait. Cela peut être pratique pour voir ce que votre programme Lazarus envoie à la base de données exactement, pour déboguer les composants de base de données eux-mêmes et peut-être pour optimiser vos requêtes.
NB : Si vous utilisez des ordres préparés/requêtes paramétrées (vois la section du dessus), les paramètres sont souvent envoyées en binaire par le descendant de TSQLConnection (p.ex. TIBConnection), donc vous ne pouvez juste copier/coller le SQL journalisé dans un outil d'interrogation de la base de données. Indépendamment, la journalisation de la connection peut donner beaucoup d'indication sur ce que le programme fait.

Les alternatives sont :

  1. vous pouvez utiliser le débogueur pour passer le code de base données si vous avez construit FPC (et Lazarus) avec le débogage activé.
  2. si vous utilisez les pilotes ODBC (au moins sous Windows), vous pourrez activer la sortie tracelog depuis le panneau de contrôle ODBC.
  3. plusieurs SGBD vous permettent de contrôler tous les ordres envoyés vers lui depuis une adresse IP/une connection.

Si vous utilisez la jouranlisation TSQLConnection, deux choses sont requises :

  1. indiquer quels sont les types d'événement que TSQLConnection doit journaliser.
  2. associer TSQLConnection à une fonction qui reçoit les événements et les traite (les enregistre dans un fichier, les affiche à l'écran, etc.).

Cette fonction doit être du type TDBLogNotifyEvent (voir sqldb.pp), donc elle doit avoir la signature :

TDBLogNotifyEvent = Procedure (Sender : TSQLConnection; EventType : TDBEventType; Const Msg : String) of object;

FPC (ou : la façon manuelle)

Un extrait de code illustre ceci :

uses
...
TSQLConnection, //or a child object like TIBConnection, TMSSQLConnection
...
var
type 
  TMyApplication = class(TCustomApplication); //this is our application that uses the connection
...
  private
    // This example stores the logged events in this stringlist:
    FConnectionLog: TStringList;
...
  protected
    // This procedure will receive the events that are logged by the connection:
    procedure GetLogEvent(Sender: TSQLConnection; EventType: TDBEventType; Const Msg : String);
...
  procedure TMyApplication.GetLogEvent(Sender: TSQLConnection;
    EventType: TDBEventType; const Msg: String);
  // The procedure is called by TSQLConnection and saves the received log messages
  // in the FConnectionLog stringlist
  var
    Source: string;
  begin
    // Nicely right aligned...
    case EventType of
      detCustom:   Source:='Custom:  ';
      detPrepare:  Source:='Prepare: ';
      detExecute:  Source:='Execute: ';
      detFetch:    Source:='Fetch:   ';
      detCommit:   Source:='Commit:  ';
      detRollBack: Source:='Rollback:';
      else Source:='Unknown event. Please fix program code.';
    end;
    FConnectionLog.Add(Source + ' ' + Msg);
  end;
 
...
  // We do need to tell our TSQLConnection what to log:
    FConnection.LogEvents:=LogAllEvents; //= [detCustom, detPrepare, detExecute, detFetch, detCommit, detRollBack]
    // ... and to which procedure the connection should send the events:
    FConnection.OnLog:=@Self.GetLogEvent;
...
  // now we can use the connection and the FConnectionLog stringlist will fill with log messages.

Vous pouvez aussi utiliser GlobalDBLogHook de TSQLConnection au lieu de journaliser depuis de multiples connections.

Lazarus (ou : la manière rapide)

Au final, la description du dessus est la manière FPC de procéder comme annoncé dans l'introduction ; si vous utilisez Lazarus, une façon plus rapide est d'affecter le gestionnaire d'événement dans l'événement OnLog de TSQLConnection.

Voir aussi

  • SQLdb Tutorial0 : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.
  • SQLdb Tutorial1 : 1re partie de la série de tutoriels sur les bases de données, montrant comment configurer un grid pour afficher les données.
  • SQLdb Tutorial2 : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.
  • SQLdb Tutorial3 : 3e partie de la série de tutoriels, montrant comment développer pour des bases de données multiples et utiliser une form de login.
  • SQLdb Tutorial4 : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.
  • Vue d'ensemble des bases de données pour Lazarus : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.
  • Paquet SQLdb : Information sur le paquetage SQLdb.
  • Référence de programmation SQLdb : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.
  • SqlDBHowto : Information sur l'utilisation du paquet SQLdb.
  • Travailler avec TSQLQuery : Informations sur TSQLQuery.