Difference between revisions of "SqlDBHowto/fr"

From Free Pascal wiki
(Lazarus)
(Lazarus (ou : la manière rapide))
Line 406: Line 406:
  
 
=== Lazarus (ou : la manière rapide) ===
 
=== Lazarus (ou : la manière rapide) ===
Finally, the description above is the FPC way of doing things as indicated in the introduction; if using Lazarus, a quicker way is to assign an event handler to the TSQLConnection's OnLog event.
+
Au final, la description du dessus est la manière FPOC de faire les choses comme annoncé dans l'introduction ; si vous utilisez Lazarus, une façon plus raoide est d'affecter le gestionnaire d'événement dans l'événement OnLog de TSQLConnection.
  
 
== Voir aussi ==
 
== Voir aussi ==
 
* [[Working With TSQLQuery/fr|Travailler avec TSQLQuery]]
 
* [[Working With TSQLQuery/fr|Travailler avec TSQLQuery]]
 
<br/>
 
<br/>

Revision as of 12:55, 14 March 2017

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;
 
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. 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. La procédure 'CreateConnection' est définie dans le code d'exemple dans #Comment se connecter à un serveur de base de données ? en haut.

program CreateTable;
 
function CreateTransaction(pDB: TIBConnection): TSQLTransaction;
begin
  result := TSQLTransaction.Create(pDB);
  result.Database := pDB;
end;
 
var 
  AConnection : TSQLConnection;
  ATransaction : TSQLTransaction;

begin
  AConnection := CreateConnection;
  ATransaction := CreateTransaction(AConnection);
  AConnection.Transaction := ATransaction;
  AConnection.Open;
  ATransaction.StartTransaction;
  AConnection.ExecuteDirect('create table TBLNAMES (ID integer, NAME varchar(40));'); 
   
  // Some database-server types need a commit before you can use a newly created table. (Firebird)
  // With .Commit you also close the transaction
  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;
  AConnection.Free;
  ATransaction.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 ?

To change the data in a record, the TDataset (from which TSQLQuery is derived) must be set to edit mode. To enter edit mode call the '.Edit', '.Insert' or '.Append' methods. Use the '.Edit' method to change the current record. Use '.Insert' to insert a new record before the current record. Use '.Append' to insert a new record at the end of the table. In edit mode you can change field values through the 'Fields' property. Use 'Post' to validate the new data, if the data is valid then the edit mode is left. If you move to another record - for example by using '.Next' - and the dataset is in edit mode, then first '.Post' is called. Use '.Cancel' to discard all changes you made since the last '.Post' call and leave the edit mode.

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

The above is not the complete story yet. TSQLQuery is derived from TBufDataset which makes use of buffered updates. Buffered update means that after you called 'Post' the changes in the dataset are visible immediately, but they are not sent to the database server. What does happen is that the changes are maintained in a change log. When the '.ApplyUpdates' method is called, then all changes in the change log are sent to the database. Only then will database server know of the changes. The changes are sent to the server within a transaction of TSQLTransaction. Make sure to properly set the transaction before 'ApplyUpdates'. After applying the updates, a commit must be executed to save the changes on the database server.

The below is an example of changing the data in a table, sending the changes to the server and comitting the 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.

For a discussion of 'UpdateMode' continue reading.

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

In the code example in #How to change data in a table?, you will find the line

Query.UpdateMode := upWhereAll;

without explanation of what it does. The best way to find out what that line does is to leave it out. If you leave out the statement and the followed this howto precisely, then you will receive the following error message:

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

To understand what went wrong, you must understand how changes are sent to the database server. The only way to get data in a SQL server is by executing SQL queries. SQL has three types of queries for three different ways of manupulating a record. To create a new record, change or delete a record insert, update and delete statements are executed respectively. An update statement may be as follows:

update TBLNAMES set NAME='Edited name' where ID=1;

To send a change to the database server, Sqldb must assemble an update query. To assemble the query, three things are needed:

The name of the table 
The table name is retrieved from parsing the select query, although this doesn't always work.
UPDATE or INSERT clause 
These contain the fields that must be changed.
WHERE clause 
This contains the fields that determine which records should be changed.

Every field (each TField in Fields) has a ProviderFlags property. Only fields with pfInUpdate in ProviderFlags will be used in the update or insert cluase of a query. By default all fields have pfInUpdate set in their ProviderFlags property.

Which fields are used in the WHERE clause depends on the UpdateMode property of the query and the ProviderFlags property of the fields. Fields with pfInkey in their ProviderFlags are always used in the WHERE clause. A field will have the pfInKey flag set automatically if the field is part of the primary key of the table and 'TSQLQuery.UsePrimaryKeyAsKey' returns 'True'.

The default value for UpdateMode of the query is upWhereKeyOnly. In this update mode only fields with pfInkey in their ProviderFlags property are used in the WHERE clause. If none of the fields have their pfInKey flag set, then no fields are available for the WHERE clause and the error message from the beginning of this section will be returned. You can solve the issue by:

  • Adding a primary key to the table and set TSQLQuery.UsePrimaryKeyAsKey to 'True', or
  • Setting the pfInkey flag for one or more fields in code.

The UpdateMode property knows two more possible values. 'upWhereAll' can be used to add all fields with the 'pfInWhere' flag set to the WHERE clause. By default all fields have this flag set. 'upWhereChanged' can be used to add only those fields that have the 'pfInWhere' flag set and that are changed in the current record.

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

Next to statements that return a dataset (see #How to read data from a table?) SQL has statements that do not return data. For example INSERT, UPDATE and DELETE statements do not return data. These statements can be executed using TSQLConnection.ExecuteDirect, but TSQLQuery can also be used. If you do not expect return data use TSQLQuery.ExecSQL instead of TSQLQuery.Open. As mentioned earlier, use TSQLQuery.Open to open the dataset returned by the SQL statement.

The following procedure creates a table and inserts two records using 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 ?

In the code example of #How to execute a query using TSQLQuery? the same query is used twice, only the values to be inserted differ. A better way to do this is by using parameters in the query.

The syntax of parameters in queries is different per database system, but the differences are handled by TSQLQuery. Replace the values in the query with a colon followed by the name of the parameter you want to use. For example:

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

This query will create two parameters: 'ID' and 'NAME'. To determine the parameters, the query is parsed at the moment the text of TSQLQuery.SQL is assigned or changed. All existing parameters will be removed and the new parameters will be added to the 'TSQLQuery.Params' property. Assigning a value to a parameter is similar to assigning a value to a field in the dataset:

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

You can't tell from the query what kind of data must be stored in the parameter. The data type of the parameter is determined at the moment a value is first assigned to the parameter. By assigning a value using '.AsString', the parameter is assigned the data type 'ftString'. You can determine the data type directly by setting the 'DataType' property. If an incorrect datatype is assigned to the parameter, then problems will occur during opening or executing the query. See Database field type for more information on data types.

Requête de sélection

An example of a select query with parameters would be to change something like this:

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

to something like this:

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

Exemple

The following example creates the same table as the previous example, but now parameters are used:

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;

Notice that this example requires more code than the example without the parameters. Then what is the use of using parameters?

Speed is one of the reasons. The example with parameters is faster, because the database server parses the query only once (in the .Prepare statement or at first run).

Another reason to use prepared statements is prevention of SQL-injection (see also Secure programming.

Finally, in some cases it just simplifies coding.

Dépannage : Connection par TSQLConnection

You can let a TSQLConnection log what it is doing. This can be handy to see what your Lazarus program sends to the database exactly, to debug the database components themselves and perhaps to optimize your queries. NB: if you use prepared statements/parametrized queries (see section above), the parameters are often sent in binary by the TSQLConnection descendent (e.g. TIBConnection), so you can't just copy/paste the logged SQL into a database query tool. Regardless, connection logging can give a lot of insight in what your program is doing.

Alternatives are:

  1. you can use the debugger to step through the database code if you have built FPC (and Lazarus) with debugging enabled.
  2. if you use ODBC drivers (at least on Windows) you could enable tracelog output in the ODBC control panel.
  3. many databases allow you to monitor all statements sent to it from a certain IP address/connection.


If you use TSQLConnection logging, two things are required:

  1. indicate which event types your TSQLConnection should log
  2. point TSQLConnection at a function that receives the events and processes them (logs them to file, prints them to screen, etc.).

That function must be of type TDBLogNotifyEvent (see sqldb.pp), so it needs this signature:

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

FPC (ou : la façon manuelle)

A code snippet can illustrate this:

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.

You can also use TSQLConnection's GlobalDBLogHook instead to log everything from multiple connections.

Lazarus (ou : la manière rapide)

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

Voir aussi