https://wiki.freepascal.org/api.php?action=feedcontributions&user=Alcatiz&feedformat=atomLazarus wiki - User contributions [en]2024-03-29T07:50:52ZUser contributionsMediaWiki 1.35.6https://wiki.freepascal.org/index.php?title=TFileStream/fr&diff=111734TFileStream/fr2017-08-30T19:15:02Z<p>Alcatiz: </p>
<hr />
<div>{{TFileStream}}<br />
<br><br />
__TOC__<br />
<br><br />
=Description=<br />
Un '''TFileStream''' est un descendant de [[TStream]] qui lit/écrit ses données depuis/vers un fichier sur disque. Un TFileStream charge l'entièreté des données d'un fichier en mémoire, et vice versa.<br />
<br><br />
=Constantes de création=<br />
{| class="wikitable sortable"<br />
! Constante !! Décimal !! Description<br />
|-<br />
| fmCreate<br />
| 65280<br />
| Crée un nouveau fichier<br />
|-<br />
| fmOpenRead<br />
| 0<br />
| Ouvre un fichier en lecture<br />
|-<br />
| fmOpenWrite<br />
| 1<br />
| Ouvre un fichier en écriture<br />
|-<br />
| fmOpenReadWrite<br />
| 2<br />
| Ouvre un fichier en lecture/écriture<br />
|-<br />
| fmShareDenyWrite<br />
| 32<br />
| Empêche l'écriture si le fichier est déjà ouvert<br />
|}<br />
<br><br />
=Lecture de données=<br />
Lecture du fichier ''fnam'' :<br />
<syntaxhighlight><br />
function readstream( fnam: string ): string;<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
txt: string;<br />
begin<br />
txt := '';<br />
strm := TFileStream.Create( fnam, fmOpenRead or fmShareDenyWrite );<br />
try<br />
n := strm.Size;<br />
SetLength( txt, n );<br />
strm.Read( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
result := txt;<br />
end;<br />
</syntaxhighlight><br />
<br><br />
=Ecriture de données=<br />
Ecriture de ''txt'' dans le fichier ''fnam'' :<br />
<syntaxhighlight><br />
procedure writestream( fnam: string; txt: string );<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
begin<br />
strm := TFileStream.Create( fnam, fmCreate );<br />
n := Length( txt );<br />
try<br />
strm.Position := 0;<br />
strm.Write( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
end;<br />
</syntaxhighlight><br />
<br><br />
=Voir aussi=<br />
* [[doc:rtl/classes/tfilestream.html|Documentation de TFileStream]]<br />
* [[doc:rtl/classes/tstream.html|Documentation de TStream]]<br />
<br />
[[Category:RTL]]<br />
{{AutoCategory}}</div>Alcatizhttps://wiki.freepascal.org/index.php?title=TFileStream/fr&diff=111733TFileStream/fr2017-08-30T19:09:06Z<p>Alcatiz: </p>
<hr />
<div>{{TFileStream}}<br />
<br />
Un '''TFileStream''' est un descendant de [[TStream]] qui lit/écrit ses données depuis/vers un fichier sur disque. Un TFileStream charge l'entièreté des données d'un fichier en mémoire, et vice versa.<br />
<br />
{| class="wikitable sortable"<br />
! Constante !! Décimal !! Description<br />
|-<br />
| fmCreate<br />
| 65280<br />
| Crée un nouveau fichier<br />
|-<br />
| fmOpenRead<br />
| 0<br />
| Ouvre un fichier en lecture<br />
|-<br />
| fmOpenWrite<br />
| 1<br />
| Ouvre un fichier en écriture<br />
|-<br />
| fmOpenReadWrite<br />
| 2<br />
| Ouvre un fichier en lecture/écriture<br />
|-<br />
| fmShareDenyWrite<br />
| 32<br />
| Empêche l'écriture si le fichier est déjà ouvert<br />
|}<br />
<br />
Lecture du fichier ''fnam'' :<br />
<syntaxhighlight><br />
function readstream( fnam: string ): string;<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
txt: string;<br />
begin<br />
txt := '';<br />
strm := TFileStream.Create( fnam, fmOpenRead or fmShareDenyWrite );<br />
try<br />
n := strm.Size;<br />
SetLength( txt, n );<br />
strm.Read( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
result := txt;<br />
end;<br />
</syntaxhighlight><br />
<br />
Ecriture de ''txt'' dans le fichier ''fnam'' :<br />
<syntaxhighlight><br />
procedure writestream( fnam: string; txt: string );<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
begin<br />
strm := TFileStream.Create( fnam, fmCreate );<br />
n := Length( txt );<br />
try<br />
strm.Position := 0;<br />
strm.Write( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
end;<br />
</syntaxhighlight><br />
<br />
== Voir aussi ==<br />
* [[doc:rtl/classes/tfilestream.html|Documentation de TFileStream]]<br />
* [[doc:rtl/classes/tstream.html|Documentation de TStream]]<br />
<br />
[[Category:RTL]]<br />
{{AutoCategory}}</div>Alcatizhttps://wiki.freepascal.org/index.php?title=TFileStream/fr&diff=111732TFileStream/fr2017-08-30T19:08:02Z<p>Alcatiz: Created page with "{{TFileStream}} Un '''TFileStream''' est un descendant de TStream qui lit/écrit ses données depuis/vers un fichier sur disque. Un TFileStream charge l'entièreté des d..."</p>
<hr />
<div>{{TFileStream}}<br />
<br />
Un '''TFileStream''' est un descendant de [[TStream]] qui lit/écrit ses données depuis/vers un fichier sur disque. Un TFileStream charge l'entièreté des données d'un fichier en mémoire, et vice versa.<br />
<br />
{| class="wikitable sortable"<br />
! Constante !! Décimal !! Description<br />
|-<br />
| fmCreate<br />
| 65280<br />
| Crée un nouveau fichier<br />
|-<br />
| fmOpenRead<br />
| 0<br />
| Ouvre un fichier en lecture<br />
|-<br />
| fmOpenWrite<br />
| 1<br />
| Ouvre un fichier en écriture<br />
|-<br />
| fmOpenReadWrite<br />
| 2<br />
| Ouvre un fichier en lecture/écriture<br />
|-<br />
| fmShareDenyWrite<br />
| 32<br />
| Empêche l'écriture si le fichier est déjà ouvert<br />
|}<br />
<br />
Lecture du fichier ''fnam''.<br />
<syntaxhighlight><br />
function readstream( fnam: string ): string;<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
txt: string;<br />
begin<br />
txt := '';<br />
strm := TFileStream.Create( fnam, fmOpenRead or fmShareDenyWrite );<br />
try<br />
n := strm.Size;<br />
SetLength( txt, n );<br />
strm.Read( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
result := txt;<br />
end;<br />
</syntaxhighlight><br />
<br />
Ecriture de ''txt'' dans le fichier ''fnam''.<br />
<syntaxhighlight><br />
procedure writestream( fnam: string; txt: string );<br />
var<br />
strm: TFileStream;<br />
n: longint;<br />
begin<br />
strm := TFileStream.Create( fnam, fmCreate );<br />
n := Length( txt );<br />
try<br />
strm.Position := 0;<br />
strm.Write( txt[1], n );<br />
finally<br />
FreeAndNil( strm );<br />
end;<br />
end;<br />
</syntaxhighlight><br />
<br />
== Voir aussi ==<br />
* [[doc:rtl/classes/tfilestream.html|Documentation de TFileStream]]<br />
* [[doc:rtl/classes/tstream.html|Documentation de TStream]]<br />
<br />
[[Category:RTL]]<br />
{{AutoCategory}}</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Tutorial1/fr&diff=107657SQLdb Tutorial1/fr2017-03-05T14:35:13Z<p>Alcatiz: /* Relier les composants */</p>
<hr />
<div>{{SQLdb Tutorial1}}<br />
<br />
== Introduction ==<br />
<br />
Le présent tutoriel va montrer à l'aide d'un exemple comment mettre en pratique le [[SQLdb Package]]. Il a été conçu pour des débutants. Cependant si vous chercher de l'aide pour les bases de données et SQL, vous n'êtes pas au bon endroit. <br />
Cette exemple utilise Firebird avec sa base de données employee.fdb. Vous pouvez utiliser une autre base. Dans ce cas, les modifications à apporter vous seront signalées au fur et à mesure.<br />
<br />
Si ce texte semble long, c'est que chaque ligne du code nécessaire est expliquée en détails. En fait, la quantité de choses à taper n'est pas si grande qu'il y parait. Les développeurs expérimentés peuvent survoler les instructions, ils comprendront rapidement de quoi il retourne.<br />
De plus, la première partie qui se termine par [[#Exemple simple|Exemple simple]] est suffisante pour disposer d'un programme fonctionnel.<br />
<br />
Vous avez devant les yeux une traduction de la [[SQLdb_Tutorial1|version anglaise]] du tutoriel, elle-même traduction de la [[SQLdb Tutorial1/de|version originale]] de [[User:Swen|Swen]] en allemand. La version anglaise a été enrichie en particulier dans la partie qui suit [[#Exemple simple|Exemple simple]]. [[User:Swen|Swen]] souhaite que la version allemande reste tel que.<br />
<br />
De Swen : Merci à [[User:Loesje|Joost]] et Michael, sans qui tout cela n'aurait probablement pas été possible.<br />
<br />
== Prérequis ==<br />
<br />
Si vous le pouvez, utiliser une version récente de Lazarus version (FPC 2.2.2 ou supérieure). Si le paquet SQLdb n'est pas installé, faites-le maintenant (Package -> Install/Uninstall packages ... -> SQLDBLaz 1.0.1).<br />
<br />
Vous devez disposer également d'une base de données relationnelle SQL, comme [http://sourceforge.net/project/showfiles.php?group_id=9028 Firebird] (si possible en version 2.0 ou supérieure). Le plus simple est d'utiliser les valeurs par défaut (par ex. utilisateur : SYSDBA et mot de passer masterkey) et la base exemple 'employee'.<br />
<br />
Vous pouvez préférer une autre base de données (MySQL, PostgreSQL, Oracle, SQLite ou une autre base interfacée par ODBC) : il vous faudra seulement disposer de la bonne structure base/table (voir ci-dessous) et utiliser le ''TSQLConnector'' approprié (voir ci-dessous également). Si les transactions de votre base sont très différentes, merci de documenter la section correspondante.<br />
Les notes au sujet de SQLite ont été commencé.<br />
<br />
=== Les biblothèques Firebird sous Windows ===<br />
<br />
Sous Windows, il vous faudra les DLLs Firebird, éventuellement dans votre répertoire système, mais de préférence dans le répertoire de votre projet (pendant le développement, dans l'IDE) et dans le répertoire de sortie où est produit l'exécutable (pour faire tourner le programme compilé).<br />
Vous pouvez trouver ces DLLs sur cette page : Firebird Embedded 2.5 [http://www.firebirdsql.org/en/firebird-2-5/].<br />
Décompressez les fichiers dans votre répertoire applicatif :<br />
<syntaxhighlight lang="bash"><br />
fbembed.dll<br />
firebird.msg<br />
ib_util.dll<br />
icudt30.dll<br />
icuin30.dll<br />
icuuc30.dll<br />
Microsoft.VC80.CRT.manifest<br />
msvcp80.dll<br />
msvcr80.dll<br />
</syntaxhighlight><br />
Renommez fbembed.dll en fbclient.dll (c'est le nom ordinaire du client Firebird). La DLL fournie peut également faire fonction de client ordinaire Firebird.<br />
<br />
Assurez-vous que la base de données employee.fdb se trouve bien dans le répertoire de votre projet.<br />
<br />
Enfin, recompilez une fois votre projet (même vide) pour créer le répertoire de sortie et y copier les DLLs.<br />
<br />
=== Les bases de données Firebird sur les autres systèmes ===<br />
<br />
Sous Linux/OSX, il vous faut également les bibliothèques partagées du client Firebird.<br />
Sous Linux, vous pouvez utiliser l'utilitaire de votre distribution pour installer les paquets, comme sous Debian :<br />
<bash><br />
aptitude install libfbclient2<br />
</bash><br />
ou<br />
<bash><br />
sudo apt-get -yqq install libfbclient2<br />
</bash><br />
<br />
=== Si Firebird ou employee.fdb ne sont pas installés ===<br />
<br />
Si vous ne disposez pas de la base de données exemple 'employee' ou si vous mettez en œuvre une autre base de données, voici ce dont la table dont vous devrez disposer pour notre exemple :<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE CUSTOMER<br />
(<br />
CUST_NO INTEGER NOT NULL,<br />
CUSTOMER VARCHAR(25) NOT NULL,<br />
CITY VARCHAR(25),<br />
COUNTRY VARCHAR(15),<br />
CONSTRAINT INTEG_60 PRIMARY KEY (CUST_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
Voici un peu de données pour qu'on voit quelque chose :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('1', 'Lapinou software', 'Lanion', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('2', 'VC Technologies', 'Dallas', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('3', 'Klämpfl, Van Canneyt and Co.', 'Boston', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('4', 'Felipe Bank', 'Manchester', 'England');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('5', 'Joost Systems, LTD.', 'Central Hong Kong', 'Hong Kong');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('6', 'Van der Voort Int.', 'Ottawa', 'Canada');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('7', 'Mrs. Mauvais', 'Pebble Beach', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('8', 'Asinine Vacation Rentals', 'Lihue', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('9', 'Fax', 'Turtle Island', 'Fiji');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('10', 'FPC Corporation', 'Tokyo', 'Japan');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('11', 'Dynamic Intelligence Corp', 'Zurich', 'Switzerland');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('12', '3D-Pad Corp.', 'Paris', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('13', 'Swen Export, Ltd.', 'Milan', 'Italy');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('14', 'Graeme Consulting', 'Brussels', 'Belgium');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('15', 'Klenin Inc.', 'Den Haag', 'Netherlands');<br />
</syntaxhighlight><br />
<br />
Merci de créer la base, la table et d'insérer les données dans votre environnement.<br />
<br />
==== SQLite ====<br />
Si vous utilisez SQLite, vous pouvez créer la base susmentionnée dans le répertoire de votre projet en lançant le code suivant : <br />
<syntaxhighlight lang="bash"><br />
sqlite employee.sqlite<br />
</syntaxhighlight><br />
Il suffit maintenant de copier/coller les instructions 'CREATE TABLE' et 'INSERT' ci-dessus.<br />
Pour tester si les données sont correctement entrée, utilisez la requête :<br />
<syntaxhighlight lang="SQL"><br />
select * from customer;<br />
</syntaxhighlight><br />
Terminer la session à l'aide de la commande : .quit<br />
Un fichier du nom de 'employee.sqlite' devrait être disponible dans le répertoire de votre projet.<br />
<br />
Assurez-vous que les bibliothèques sqlite (dll sous Windows et so sous Linux) sont installées (Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet).<br />
<br />
Compilez une fois votre projet, même vide, pour que soit créer le répertoire de sortie et, sous Windows, copier les DLLs et la base 'employee.sqlite' dans ce répertoire.<br />
<br />
==== PostgreSQL ====<br />
La présente section suppose que vous utilisez un serveur Linux et le shell. Des étapes similaires aboutiront au même résultat sous Windows avec un outil graphique comme pgadmin.<br />
Connectez-vous à votre serveur et basculez sous le compte postgres :<br />
<syntaxhighlight lang=bash><br />
su - postgres -c psql # Démarrage immédiat de l'interpréteur SQL psql<br />
</syntaxhighlight><br />
<br />
Create a user for the database and the tables:<br />
<syntaxhighlight lang=SQL><br />
CREATE USER employee WITH PASSWORD 'hellopassword'; -- Bien sûr, adaptez le mot de passe à votre convenance<br />
-- Un message comme 'CREATE ROLE' devrait sanctionner votre succès.<br />
-- Pour changer votre mot de passe a posteriori, utilisez quelque chose comme :<br />
-- alter user employee with password '<newpasswordhere>';<br />
-- Supprimons la date d'expiration du mot de passe. Ce n'est pas indispensable :<br />
ALTER USER employee VALID UNTIL 'infinity'; --password never expires<br />
-- Maintenant, ajoutons un peu de sécurité,<br />
-- interdisons à l'utilisateur de créer une base de données ou d'autres comptes utilisateurs :<br />
ALTER USER employee NOCREATEDB NOCREATEUSER; -- Restriction de la création d'objet<br />
-- La réponse devrait être quelque chose comme 'ALTER ROLE'.<br />
-- Création de notre base de données :<br />
CREATE DATABASE employee;<br />
-- Réponse : 'CREATE DATABASE'.<br />
-- Assignons tous les droits sur la base funambol à l'utilisateur 'employee' :<br />
GRANT ALL PRIVILEGES ON DATABASE employee TO employee; -- Allocation des droits<br />
-- La réponse devrait être quelque chose comme 'GRANT'.<br />
-- Nous créons la tbla à l'aide du type de données 'serial', numérotation automatique :<br />
CREATE TABLE customer<br />
(<br />
cust_no serial NOT NULL,<br />
customer character varying(25) NOT NULL,<br />
city character varying(25),<br />
country character varying(15),<br />
CONSTRAINT integ_60 PRIMARY KEY (cust_no )<br />
);<br />
-- Maintenant collons les lignes INSERT ci-dessus. Vérifions la saisie avec :<br />
SELECT * FROM customer;<br />
-- Sortons de là :<br />
\q <br />
</syntaxhighlight><br />
<br />
Maintenant, nous devrions être sous le shell, connecté en tant que utilisateur postgres.<br />
<br />
Si votre serveur se trouve sur une machine distante, vérifiez la bon accès réseau à cette machine. Voyez les détails dans la documentation postgresql, mais quelque chose comme ça devrait marcher :<br />
<syntaxhighlight lang=bash><br />
# Nous utilisons 'nano' comme éditeur, mais vous pouvez le remplacer par ce que vous voulez (comme vim, emacs, joe...) et le numéro de la version de postgres dépend de '/etc/postgresql/8.4/main/pg_hba.conf'.<br />
</syntaxhighlight><br />
<br />
Vérifier la présence d'une ligne qui ressemble à ceci (Remplacer 192.168.0.1 par l'étendue d'adresses IP de votre réseau local.<br />
<br />
<nowiki><br />
# Permettre l'acceès du réseau local en utilisant les mots de passe encodés md5 :<br />
<br />
host all all 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Ou de manière plus restrictive :<br />
<br />
<nowiki><br />
# Permettre seulement l'accès à la base 'employee' à l'utilisateur 'employee' :<br />
<br />
host employee employee 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Si vous n'avez pas de ligne de ce type, ajoutez-la à la fin et sortez de votre éditeur.<br />
Pour plus d'information, reportez-vous à la documentation PostgreSQL.<br />
<br />
Rechargez les paramètres de PostgreSQL :<br />
<syntaxhighlight lang=bash> <br />
psql<br />
</syntaxhighlight><br />
Puis<br />
<syntaxhighlight lang=bash> <br />
SELECT pg_reload_conf(); --reload settings...<br />
-- ...and exit back to shell:<br />
\q<br />
</syntaxhighlight><br />
<br />
Essayez le vous connecter à PostgreSQL. <br />
<br />
Note : Par défaut, PostgreSQL tente d'utiliser un socket qui ne permet pas l'usage d'un mot de passe. Pour circonvenir cette propension, nous spécifions le nom de l'hôte pour forcer une connexion TCP/IP :<br />
<syntaxhighlight lang=bash><br />
psql -h 127.0.0.1 -d employee -U employee -W # Connexion par TCP/IP. Précisez votre mot de passe.<br />
</syntaxhighlight><br />
<br />
Assurez-vous que les bibliothèques (dll sous WIndows et so sous Linus) sont bien installées - Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet.<br />
<br />
Compiler une fois votre projet, même vide, de façon à créer le répertoire de sortir et, sous Windows, copier les dlls dans ce répertoire.<br />
<br />
== Exemple simple ==<br />
<br />
=== Projet et composants ===<br />
D'abord, il vous faut créer un nouveau projet Lazarus.<br />
<br />
Pour établir la connexion à votre base, vous avez besoin de une ''TIBConnection'', une ''TSQLTransaction'' et un composant ''[[Working With TSQLQuery|TSQLQuery]]'' que vous trouverez dans l'onglet 'SQLdb' de la palette de composants. <br />
<br />
''TIBConnection'' est le composant de connexion spécifique à Interbase/Firebird (Firebird est un fork d'Interbase).<br />
Si vous utilisez une base de données différente, remplacez ce composant par le composant approprié dans ce même onglet. Par exemple, une ''TSQLite3Connection'' pour une base SQLite, une ''PQConnection'' pour PostgreSQL. Les explications sur l'installation des bibliothèques d'accès à ces bases dépassent l'ambition de ce tutoriel et devrait être trouvées ailleurs (dans [[Databases]] par exemple).<br />
<br />
Placez une ''TIBConnection'' (ou un composant de connexion équivalent) sur votre formulaire et changez son nom en ''DBConnection'' dans l'inspecteur d'objet. C'est généralement une bonne idée de changer le nom de vos composants pour quelque chose qui a du sens dans votre programme (Par ex. ''MainframeDBConnection'').<br />
<br />
Les deux autres composants, ''TSQLTransaction'' et ''TSQLQuery'', sont communs à tous les types de bases qui peuvent être supportés par SQLdb.<br />
<br />
Pour afficher les données, utilisez un composant ''TDBGrid'', que vous trouverez dans l'onglet 'Data Controls'. Pour connecter ce composant à la base de données, on utilise un composant ''TDatasource'' qu'on trouve dans l'onglet 'Data Access'.<br />
<br />
Tous les composants nécessaires à notre premier exemple sont maintenant rassemblés. Vous pouvez agrandir le TDBGrid pour l'affichage de toutes les données.<br />
<br />
=== Relier les composants ===<br />
Maintenant, il nous reste à relier nos composantes. Le moyen le plus simplie consiste à utiliser l'inspecteur d'obet, mais on peut également le faire dans le code source. <br />
<br />
Changez la propriété ''Transaction'' de DBConnection en 'SQLTransaction1'. Cela provoquera le changement automatique de la propriété ''Database'' de SQLTransaction1 en 'DBConnection'. <br />
<br />
Ensuite, changez la propriété ''Database'' de SQLQuery1 en 'DBConnection'. Lazarus ajuste automatiquement la valeur de la propriété 'Transaction'. <br />
<br />
Puis, changez la propriété ''Dataset'' de Datasource1 en 'SQLQuery1'. <br />
<br />
Et, pour finir, changez la propriété ''Datasource'' de DBGrid1 en 'Datasource1'.<br />
<br />
Nous voici avec une connexion qui relie sa transaction par défaut à un composant de transaction. Le composant transaction est reliépar sa propriété 'database' à l'objet de connexion. Ces deux composants sont suffisants pour réalisation la connexion et exécuter les instructions, mais insuffisants pour afficher des requêtes. Pour cela, on utilise le composant SQLQuery qui pointe sur la base de données (database) et fait le lien avec sa transaction par défaut. C'est avec le SQLQuery que nous extrairons plus tard les données et posterons en retour les données vers la base.<br />
<br />
Enfin, le composant 'datasource', qui est relié au composant requête, est une sorte d'interface. Il enregistre la position actuelle dans le dataset et les composants visuels utilisent cette information pour synchroniser l'affichage sur le même enregistrement.<br />
<br />
Si ça vous parait un peu obscur, ne vous inquiétez pas : encore un peu de travail et vous serez capables d'afficher vos premières données.<br />
<br />
=== Connexion avec la base de données ===<br />
Comment pouvons-nous afficher les données de notre base sur l'écran ?<br />
D'abord, nous devons informer DBConnection de l'endroit où se trouve la base employee.fdb (généralement dans le sous répertoires .../examples/empbuild/ de notre installation Firebird). Encore une fois, vous avez le choix : Vous pouvez utiliser l'inspecteur d'objets pour fixer le chemin ou le faire directement dans votre code.<br />
Nous choisissons d'utiliser l'inspecteur d'objet : Positionner la propriété 'HostName' de DBConnection sur le nom du serveur Firebird ou sur l'adresse IP. Utilisez 'localhost' si le serveur Firebird tourne sur votre machine de développement. Laissez le champ vide si vous utilisez un client Firebird embarqué.<br />
Positionner la propriété ''DatabaseName'' de DBConnection sur le chemin d'accès au fichier emplyee.fdb sur le serveur de base de données (par ex. C:\Program Files\Firebird\Firebird_2_0\examples\empbuild\EMPLOYEE.FDB sur une maachine Windows).<br />
Avant que le serveur de base de données ne permette l'accès au données, il vérifie que l'utilisateur et le mot de passe soient autorisés à le faire. Une base de données sérieuse demandera à l'utilisateur ces deux informations au démarrage de l'application, et l'enverra au serveur à la connexion.<br />
Toutefois, pour l'instant, de manière à faire simple, nous utiliserons encore l'inspecteur d'objets pour entrer ces informations ''en dur''. Changez le 'UserName' (nom d'utilisateur) en 'SYSDBA' et 'Password' (mot de passe) en 'masterkey' (bien sûr, faites les ajustements nécessaire si votre installation utilise un nom ou un mot de passe différent).<br />
<br />
==== PostgreSQL ====<br />
Les choses sont très proche qu'avec Firebird. Le nom de la base de données n'a pas de chemin (de partie répertoire) - il suffit de préciser son nom (par ex. 'employee'). PostgreSQl n'a pas de mode embarqué, il est donc indispensable de renseigner la propriété ''HostName'' (nom du serveur) pour que la connexion de test fonctionne.<br />
<br />
==== SQLite ====<br />
Pour ce qui concerne SQLite, vous pouvez laisser les trois propriétés 'HostName', 'UserName', et 'Password' vides. Il faut remplir le nom du fichier SQLite dans 'DatabaseName', par ex. employee.sqlite. Attention : SQLite créera une base vide si le fichier n'existe pas.<br />
<br />
Vous devriez obtenir quelque chose comme l'écran suivant :<br />
[[Image:SQLTut1ComponentsSetUp.png|framed|center|Form and components set up]]<br />
<br />
=== Déterminer la partie des informations à afficher ===<br />
<br />
Bien que la connexion ait été réalisée, les données ne se sont pas affichée. La raison en est simple. Vous n'avez pas précisé au serveur ce qu'il devait vous renvoyer : La base de données employee.fdb contient plusieurs tables et nous n'avons pas informé Firebird quelle table nous voulions regarder. Si vous ne connaissez pas la structure de la base, vous pouvez utiliser des outils comme [http://www.flamerobin.org/index.php FlameRobin] pour afficher les contenus. Lazarus fournit également un outil - le DataDesktop. Vous le trouverez dans le sous-répertoire /tools/lazdatadesktop/ de Lazarus. Sauvegardez votre projet puis ouvrez le projet lazdatadesktop.lpi et compilez-le. <br />
<br />
[[Image:DataDictonary1.png|framed|center|The DataDesktop in action]]<br />
<br />
Retournons à notre exemple. <br />
<br />
Nous voulons afficher toutes les données de la table 'CUSTOMER'. Les instructions SQL pour ce faire sont :<br />
<syntaxhighlight lang="sql"><br />
select * from CUSTOMER<br />
</syntaxhighlight> <br />
<br />
Nous devons affecter cette commande à la propriété 'SQL' de SQLQuery1. Dans le code source de notre projet, ça devrait avoir cet air-là :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
Les instructions SQL doivent être entourées d'apostrophes (se sont des chaînes de caractères au format Pascal). Vous pouvez également lui assigner la valeur d'un autre composant (par ex. Edit1.Text). Ce n'est pas toujours une bonne idée; voir [[Secure programming/fr|Secure programming]] (une documentation plus avancée) pour des informations sur l'injection de code SQL qui constitue un important risque de faille de sécurité.<br />
<br />
Ajoutons sur le formulaire un ''TButton'' (un bouton) depuis l'onglet 'Standard'. Quand l'utilisateur clique sur le bouton, l'extraction de données devrait commencer. Il va nous falloir écrire un peu de code pour faire ça. Double-cliquer sur Button1 (le bouton qu'on vient de placer sur le formulaire). Lazarus crée alors la procédure nécessaire. Nous trouverons dans notre code les lignes suivantes :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Entre ''begin'' et ''end'', vous devez taper les instructions nécessaire à l'affichage des données... ce qui a évidemment quelque chose à voir avec SQLQuery1.<br />
<br />
La propriété 'SQL' de SQLQUery1 peut seulement être modifiée quand SQL est inactive. C'est pourquoi nous fermons d'abord le composant :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
</syntaxhighlight><br />
Puis nous assignons notre instruction SQL à la propriété 'SQL', écrasant du même coup un éventuel contenu préalable :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
<br />
Il nous faut maintenant établir la connexion à la base, activer la transaction et ouvrir la requête :<br />
<syntaxhighlight><br />
DBConnection.Connected := True;<br />
SQLTransaction1.Active := True;<br />
SQLQuery1.Open;<br />
</syntaxhighlight><br />
Vous pouvez omettre les deux premières instruction, car elles seront automatiquement invoquées par la troisième. Si vous compiler le projet à ce point, vous pourrez déjà voir les données de la table 'CUSTOMER'. <br />
<br />
Toutefois, une application qui se veut sérieuse doit s'assurer que les connexions à la base de données sont proprement fermée quand elle ne sont plus utiles. Sinon des effets secondaires imprévisibles peuvent survenir. Donc, nous utilisons l'événement 'OnClose' du formulaire (créez-le en double-cliquant dans l'inspecteur d'objets :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Pour fermer la connexion, nous utiliserons l'ordre inverse de l'ouverture :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
SQLTransaction1.Active := False;<br />
DBConnection.Connected := False;<br />
</syntaxhighlight><br />
<br />
== Résumé ==<br />
Jusqu'à maintenant, nous avons appris a connecté la base de données en utilisant le paquet SQLdb pour afficher le contenu d'une table sur l'écran.<br />
Si vous voulez ajouter plus de fonctionnalités, comme l'édition des données, vous pouvez continuer avec [[SQLdb Tutorial2]]<br />
<br />
Si vous avez suivi ces différentes étapes, votre code devrait ressemble à ceci :<br />
<syntaxhighlight><br />
unit Unit1; <br />
<br />
{$mode objfpc}{$H+}<br />
<br />
interface<br />
<br />
uses<br />
Classes, SysUtils, IBConnection, sqldb, db, FileUtil, Forms, Controls,<br />
Graphics, Dialogs, DBGrids, StdCtrls;<br />
<br />
type<br />
<br />
{ TForm1 }<br />
<br />
TForm1 = class(TForm)<br />
Button1: TButton;<br />
Datasource1: TDatasource;<br />
DBGrid1: TDBGrid;<br />
DBConnection: TIBConnection;<br />
SQLQuery1: TSQLQuery;<br />
SQLTransaction1: TSQLTransaction;<br />
procedure Button1Click(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
private<br />
{ private declarations }<br />
public<br />
{ public declarations }<br />
end; <br />
<br />
var<br />
Form1: TForm1; <br />
<br />
implementation<br />
<br />
{$R *.lfm}<br />
<br />
{ TForm1 }<br />
<br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
SQLQuery1.Close;<br />
SQLQuery1.SQL.Text:= 'select * from CUSTOMER';<br />
DBConnection.Connected:= True;<br />
SQLTransaction1.Active:= True;<br />
SQLQuery1.Open;<br />
end;<br />
<br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
SQLQuery1.Close;<br />
SQLTransaction1.Active:= False;<br />
DBConnection.Connected:= False;<br />
end;<br />
<br />
end. <br />
</syntaxhighlight><br />
<br />
<br />
== Voir aussi ==<br />
* [[SQLdb Tutorial0/fr]] : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.<br />
* [[SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.<br />
* [[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.<br />
* [[SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.<br />
* [[Lazarus Database Overview]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.<br />
* [[SQLdb Package]] : Information sur le paquetage SQLdb.<br />
* [[SQLdb Programming Reference]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.<br />
* [[SqlDBHowto]] : Information sur l'utilisation du paquetage SQLdb.<br />
* [[Working With TSQLQuery]] : Information sur TSQLQuery.<br />
<br />
[[Category:Databases]]<br />
[[Category:Tutorials]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Tutorial1/fr&diff=107645SQLdb Tutorial1/fr2017-03-05T10:33:39Z<p>Alcatiz: /* Projet et composants */</p>
<hr />
<div>{{SQLdb Tutorial1}}<br />
<br />
== Introduction ==<br />
<br />
Le présent tutoriel va montrer à l'aide d'un exemple comment mettre en pratique le [[SQLdb Package]]. Il a été conçu pour des débutants. Cependant si vous chercher de l'aide pour les bases de données et SQL, vous n'êtes pas au bon endroit. <br />
Cette exemple utilise Firebird avec sa base de données employee.fdb. Vous pouvez utiliser une autre base. Dans ce cas, les modifications à apporter vous seront signalées au fur et à mesure.<br />
<br />
Si ce texte semble long, c'est que chaque ligne du code nécessaire est expliquée en détails. En fait, la quantité de choses à taper n'est pas si grande qu'il y parait. Les développeurs expérimentés peuvent survoler les instructions, ils comprendront rapidement de quoi il retourne.<br />
De plus, la première partie qui se termine par [[#Exemple simple|Exemple simple]] est suffisante pour disposer d'un programme fonctionnel.<br />
<br />
Vous avez devant les yeux une traduction de la [[SQLdb_Tutorial1|version anglaise]] du tutoriel, elle-même traduction de la [[SQLdb Tutorial1/de|version originale]] de [[User:Swen|Swen]] en allemand. La version anglaise a été enrichie en particulier dans la partie qui suit [[#Exemple simple|Exemple simple]]. [[User:Swen|Swen]] souhaite que la version allemande reste tel que.<br />
<br />
De Swen : Merci à [[User:Loesje|Joost]] et Michael, sans qui tout cela n'aurait probablement pas été possible.<br />
<br />
== Prérequis ==<br />
<br />
Si vous le pouvez, utiliser une version récente de Lazarus version (FPC 2.2.2 ou supérieure). Si le paquet SQLdb n'est pas installé, faites-le maintenant (Package -> Install/Uninstall packages ... -> SQLDBLaz 1.0.1).<br />
<br />
Vous devez disposer également d'une base de données relationnelle SQL, comme [http://sourceforge.net/project/showfiles.php?group_id=9028 Firebird] (si possible en version 2.0 ou supérieure). Le plus simple est d'utiliser les valeurs par défaut (par ex. utilisateur : SYSDBA et mot de passer masterkey) et la base exemple 'employee'.<br />
<br />
Vous pouvez préférer une autre base de données (MySQL, PostgreSQL, Oracle, SQLite ou une autre base interfacée par ODBC) : il vous faudra seulement disposer de la bonne structure base/table (voir ci-dessous) et utiliser le ''TSQLConnector'' approprié (voir ci-dessous également). Si les transactions de votre base sont très différentes, merci de documenter la section correspondante.<br />
Les notes au sujet de SQLite ont été commencé.<br />
<br />
=== Les biblothèques Firebird sous Windows ===<br />
<br />
Sous Windows, il vous faudra les DLLs Firebird, éventuellement dans votre répertoire système, mais de préférence dans le répertoire de votre projet (pendant le développement, dans l'IDE) et dans le répertoire de sortie où est produit l'exécutable (pour faire tourner le programme compilé).<br />
Vous pouvez trouver ces DLLs sur cette page : Firebird Embedded 2.5 [http://www.firebirdsql.org/en/firebird-2-5/].<br />
Décompressez les fichiers dans votre répertoire applicatif :<br />
<syntaxhighlight lang="bash"><br />
fbembed.dll<br />
firebird.msg<br />
ib_util.dll<br />
icudt30.dll<br />
icuin30.dll<br />
icuuc30.dll<br />
Microsoft.VC80.CRT.manifest<br />
msvcp80.dll<br />
msvcr80.dll<br />
</syntaxhighlight><br />
Renommez fbembed.dll en fbclient.dll (c'est le nom ordinaire du client Firebird). La DLL fournie peut également faire fonction de client ordinaire Firebird.<br />
<br />
Assurez-vous que la base de données employee.fdb se trouve bien dans le répertoire de votre projet.<br />
<br />
Enfin, recompilez une fois votre projet (même vide) pour créer le répertoire de sortie et y copier les DLLs.<br />
<br />
=== Les bases de données Firebird sur les autres systèmes ===<br />
<br />
Sous Linux/OSX, il vous faut également les bibliothèques partagées du client Firebird.<br />
Sous Linux, vous pouvez utiliser l'utilitaire de votre distribution pour installer les paquets, comme sous Debian :<br />
<bash><br />
aptitude install libfbclient2<br />
</bash><br />
ou<br />
<bash><br />
sudo apt-get -yqq install libfbclient2<br />
</bash><br />
<br />
=== Si Firebird ou employee.fdb ne sont pas installés ===<br />
<br />
Si vous ne disposez pas de la base de données exemple 'employee' ou si vous mettez en œuvre une autre base de données, voici ce dont la table dont vous devrez disposer pour notre exemple :<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE CUSTOMER<br />
(<br />
CUST_NO INTEGER NOT NULL,<br />
CUSTOMER VARCHAR(25) NOT NULL,<br />
CITY VARCHAR(25),<br />
COUNTRY VARCHAR(15),<br />
CONSTRAINT INTEG_60 PRIMARY KEY (CUST_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
Voici un peu de données pour qu'on voit quelque chose :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('1', 'Lapinou software', 'Lanion', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('2', 'VC Technologies', 'Dallas', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('3', 'Klämpfl, Van Canneyt and Co.', 'Boston', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('4', 'Felipe Bank', 'Manchester', 'England');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('5', 'Joost Systems, LTD.', 'Central Hong Kong', 'Hong Kong');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('6', 'Van der Voort Int.', 'Ottawa', 'Canada');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('7', 'Mrs. Mauvais', 'Pebble Beach', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('8', 'Asinine Vacation Rentals', 'Lihue', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('9', 'Fax', 'Turtle Island', 'Fiji');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('10', 'FPC Corporation', 'Tokyo', 'Japan');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('11', 'Dynamic Intelligence Corp', 'Zurich', 'Switzerland');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('12', '3D-Pad Corp.', 'Paris', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('13', 'Swen Export, Ltd.', 'Milan', 'Italy');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('14', 'Graeme Consulting', 'Brussels', 'Belgium');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('15', 'Klenin Inc.', 'Den Haag', 'Netherlands');<br />
</syntaxhighlight><br />
<br />
Merci de créer la base, la table et d'insérer les données dans votre environnement.<br />
<br />
==== SQLite ====<br />
Si vous utilisez SQLite, vous pouvez créer la base susmentionnée dans le répertoire de votre projet en lançant le code suivant : <br />
<syntaxhighlight lang="bash"><br />
sqlite employee.sqlite<br />
</syntaxhighlight><br />
Il suffit maintenant de copier/coller les instructions 'CREATE TABLE' et 'INSERT' ci-dessus.<br />
Pour tester si les données sont correctement entrée, utilisez la requête :<br />
<syntaxhighlight lang="SQL"><br />
select * from customer;<br />
</syntaxhighlight><br />
Terminer la session à l'aide de la commande : .quit<br />
Un fichier du nom de 'employee.sqlite' devrait être disponible dans le répertoire de votre projet.<br />
<br />
Assurez-vous que les bibliothèques sqlite (dll sous Windows et so sous Linux) sont installées (Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet).<br />
<br />
Compilez une fois votre projet, même vide, pour que soit créer le répertoire de sortie et, sous Windows, copier les DLLs et la base 'employee.sqlite' dans ce répertoire.<br />
<br />
==== PostgreSQL ====<br />
La présente section suppose que vous utilisez un serveur Linux et le shell. Des étapes similaires aboutiront au même résultat sous Windows avec un outil graphique comme pgadmin.<br />
Connectez-vous à votre serveur et basculez sous le compte postgres :<br />
<syntaxhighlight lang=bash><br />
su - postgres -c psql # Démarrage immédiat de l'interpréteur SQL psql<br />
</syntaxhighlight><br />
<br />
Create a user for the database and the tables:<br />
<syntaxhighlight lang=SQL><br />
CREATE USER employee WITH PASSWORD 'hellopassword'; -- Bien sûr, adaptez le mot de passe à votre convenance<br />
-- Un message comme 'CREATE ROLE' devrait sanctionner votre succès.<br />
-- Pour changer votre mot de passe a posteriori, utilisez quelque chose comme :<br />
-- alter user employee with password '<newpasswordhere>';<br />
-- Supprimons la date d'expiration du mot de passe. Ce n'est pas indispensable :<br />
ALTER USER employee VALID UNTIL 'infinity'; --password never expires<br />
-- Maintenant, ajoutons un peu de sécurité,<br />
-- interdisons à l'utilisateur de créer une base de données ou d'autres comptes utilisateurs :<br />
ALTER USER employee NOCREATEDB NOCREATEUSER; -- Restriction de la création d'objet<br />
-- La réponse devrait être quelque chose comme 'ALTER ROLE'.<br />
-- Création de notre base de données :<br />
CREATE DATABASE employee;<br />
-- Réponse : 'CREATE DATABASE'.<br />
-- Assignons tous les droits sur la base funambol à l'utilisateur 'employee' :<br />
GRANT ALL PRIVILEGES ON DATABASE employee TO employee; -- Allocation des droits<br />
-- La réponse devrait être quelque chose comme 'GRANT'.<br />
-- Nous créons la tbla à l'aide du type de données 'serial', numérotation automatique :<br />
CREATE TABLE customer<br />
(<br />
cust_no serial NOT NULL,<br />
customer character varying(25) NOT NULL,<br />
city character varying(25),<br />
country character varying(15),<br />
CONSTRAINT integ_60 PRIMARY KEY (cust_no )<br />
);<br />
-- Maintenant collons les lignes INSERT ci-dessus. Vérifions la saisie avec :<br />
SELECT * FROM customer;<br />
-- Sortons de là :<br />
\q <br />
</syntaxhighlight><br />
<br />
Maintenant, nous devrions être sous le shell, connecté en tant que utilisateur postgres.<br />
<br />
Si votre serveur se trouve sur une machine distante, vérifiez la bon accès réseau à cette machine. Voyez les détails dans la documentation postgresql, mais quelque chose comme ça devrait marcher :<br />
<syntaxhighlight lang=bash><br />
# Nous utilisons 'nano' comme éditeur, mais vous pouvez le remplacer par ce que vous voulez (comme vim, emacs, joe...) et le numéro de la version de postgres dépend de '/etc/postgresql/8.4/main/pg_hba.conf'.<br />
</syntaxhighlight><br />
<br />
Vérifier la présence d'une ligne qui ressemble à ceci (Remplacer 192.168.0.1 par l'étendue d'adresses IP de votre réseau local.<br />
<br />
<nowiki><br />
# Permettre l'acceès du réseau local en utilisant les mots de passe encodés md5 :<br />
<br />
host all all 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Ou de manière plus restrictive :<br />
<br />
<nowiki><br />
# Permettre seulement l'accès à la base 'employee' à l'utilisateur 'employee' :<br />
<br />
host employee employee 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Si vous n'avez pas de ligne de ce type, ajoutez-la à la fin et sortez de votre éditeur.<br />
Pour plus d'information, reportez-vous à la documentation PostgreSQL.<br />
<br />
Rechargez les paramètres de PostgreSQL :<br />
<syntaxhighlight lang=bash> <br />
psql<br />
</syntaxhighlight><br />
Puis<br />
<syntaxhighlight lang=bash> <br />
SELECT pg_reload_conf(); --reload settings...<br />
-- ...and exit back to shell:<br />
\q<br />
</syntaxhighlight><br />
<br />
Essayez le vous connecter à PostgreSQL. <br />
<br />
Note : Par défaut, PostgreSQL tente d'utiliser un socket qui ne permet pas l'usage d'un mot de passe. Pour circonvenir cette propension, nous spécifions le nom de l'hôte pour forcer une connexion TCP/IP :<br />
<syntaxhighlight lang=bash><br />
psql -h 127.0.0.1 -d employee -U employee -W # Connexion par TCP/IP. Précisez votre mot de passe.<br />
</syntaxhighlight><br />
<br />
Assurez-vous que les bibliothèques (dll sous WIndows et so sous Linus) sont bien installées - Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet.<br />
<br />
Compiler une fois votre projet, même vide, de façon à créer le répertoire de sortir et, sous Windows, copier les dlls dans ce répertoire.<br />
<br />
== Exemple simple ==<br />
<br />
=== Projet et composants ===<br />
D'abord, il vous faut créer un nouveau projet Lazarus.<br />
<br />
Pour établir la connexion à votre base, vous avez besoin de une ''TIBConnection'', une ''TSQLTransaction'' et un composant ''[[Working With TSQLQuery|TSQLQuery]]'' que vous trouverez dans l'onglet 'SQLdb' de la palette de composants. <br />
<br />
''TIBConnection'' est le composant de connexion spécifique à Interbase/Firebird (Firebird est un fork d'Interbase).<br />
Si vous utilisez une base de données différente, remplacez ce composant par le composant approprié dans ce même onglet. Par exemple, une ''TSQLite3Connection'' pour une base SQLite, une ''PQConnection'' pour PostgreSQL. Les explications sur l'installation des bibliothèques d'accès à ces bases dépassent l'ambition de ce tutoriel et devrait être trouvées ailleurs (dans [[Databases]] par exemple).<br />
<br />
Placez une ''TIBConnection'' (ou un composant de connexion équivalent) sur votre formulaire et changez son nom en ''DBConnection'' dans l'inspecteur d'objet. C'est généralement une bonne idée de changer le nom de vos composants pour quelque chose qui a du sens dans votre programme (Par ex. ''MainframeDBConnection'').<br />
<br />
Les deux autres composants, ''TSQLTransaction'' et ''TSQLQuery'', sont communs à tous les types de bases qui peuvent être supportés par SQLdb.<br />
<br />
Pour afficher les données, utilisez un composant ''TDBGrid'', que vous trouverez dans l'onglet 'Data Controls'. Pour connecter ce composant à la base de données, on utilise un composant ''TDatasource'' qu'on trouve dans l'onglet 'Data Access'.<br />
<br />
Tous les composants nécessaires à notre premier exemple sont maintenant rassemblés. Vous pouvez agrandir le TDBGrid pour l'affichage de toutes les données.<br />
<br />
=== Relier les composants ===<br />
Maintenant, il nous reste à relier nos composantes. Le moyen le plus simplie consiste à utiliser l'inspecteur d'obet, mais on peut également le faire dans le code source. <br />
<br />
Changez la propriété ''Transaction'' de DBConnection en 'SQLTransaction1'. Cela provoquera le changement automatique de la propriété ''Database'' de SQLTransaction1 en 'DBConnection'. <br />
<br />
Ensuite, changez la propriété ''Database'' de SQLQuery1 en 'DBConnection'. Lazarus ajuste automatiquement la valeur de la propriété 'Transaction'. <br />
<br />
Puis, changez la propriété ''Dataset'' de Datasource1 en 'SQLQuery1'. <br />
<br />
Et, pour finir, changez la propriété ''Datasource'' de DBGrid1 en 'Datasource1'.<br />
<br />
Nous voici avec une connexion qui relie sa transaction par défaut à un composant de transaction. Le composant transaction est reliépar sa propriété 'database' à l'objet de connexion. Ces deux composants sont suffisants pour réalisation la connexion et exécuter les instructions, mais insuffisants pour afficher des requêtes. Pour cela, on utilise le composant SQLQuery qui pointe sur la base de données (database) et fait le lien avec sa transaction par défaut. C'est avec le SQLQuery que nous extrairons plus tard les données et posterons en retour les données vers la base.<br />
<br />
Enfin, le composant 'datasource', qui est relié au composant requête, est une sorte d'interface. Il enregistre la position actuelle dans le dataset et les composants visuels utilisent cette information pour synchroniser l'affichage sur le même enregistrement.<br />
<br />
Finally, the datasource component, which is linked to the query component, is a sort of place holder. It keeps track of where in the query dataset we are and the GUI components are linked to that so they all show the same record.<br />
<br />
Si ça vous parait un peu obscur, ne vous inquiétez pas : encore un peu de travail et vous serez capables d'afficher vos premières données.<br />
<br />
=== Connexion avec la base de données ===<br />
Comment pouvons-nous afficher les données de notre base sur l'écran ?<br />
D'abord, nous devons informer DBConnection de l'endroit où se trouve la base employee.fdb (généralement dans le sous répertoires .../examples/empbuild/ de notre installation Firebird). Encore une fois, vous avez le choix : Vous pouvez utiliser l'inspecteur d'objets pour fixer le chemin ou le faire directement dans votre code.<br />
Nous choisissons d'utiliser l'inspecteur d'objet : Positionner la propriété 'HostName' de DBConnection sur le nom du serveur Firebird ou sur l'adresse IP. Utilisez 'localhost' si le serveur Firebird tourne sur votre machine de développement. Laissez le champ vide si vous utilisez un client Firebird embarqué.<br />
Positionner la propriété ''DatabaseName'' de DBConnection sur le chemin d'accès au fichier emplyee.fdb sur le serveur de base de données (par ex. C:\Program Files\Firebird\Firebird_2_0\examples\empbuild\EMPLOYEE.FDB sur une maachine Windows).<br />
Avant que le serveur de base de données ne permette l'accès au données, il vérifie que l'utilisateur et le mot de passe soient autorisés à le faire. Une base de données sérieuse demandera à l'utilisateur ces deux informations au démarrage de l'application, et l'enverra au serveur à la connexion.<br />
Toutefois, pour l'instant, de manière à faire simple, nous utiliserons encore l'inspecteur d'objets pour entrer ces informations ''en dur''. Changez le 'UserName' (nom d'utilisateur) en 'SYSDBA' et 'Password' (mot de passe) en 'masterkey' (bien sûr, faites les ajustements nécessaire si votre installation utilise un nom ou un mot de passe différent).<br />
<br />
==== PostgreSQL ====<br />
Les choses sont très proche qu'avec Firebird. Le nom de la base de données n'a pas de chemin (de partie répertoire) - il suffit de préciser son nom (par ex. 'employee'). PostgreSQl n'a pas de mode embarqué, il est donc indispensable de renseigner la propriété ''HostName'' (nom du serveur) pour que la connexion de test fonctionne.<br />
<br />
==== SQLite ====<br />
Pour ce qui concerne SQLite, vous pouvez laisser les trois propriétés 'HostName', 'UserName', et 'Password' vides. Il faut remplir le nom du fichier SQLite dans 'DatabaseName', par ex. employee.sqlite. Attention : SQLite créera une base vide si le fichier n'existe pas.<br />
<br />
Vous devriez obtenir quelque chose comme l'écran suivant :<br />
[[Image:SQLTut1ComponentsSetUp.png|framed|center|Form and components set up]]<br />
<br />
=== Déterminer la partie des informations à afficher ===<br />
<br />
Bien que la connexion ait été réalisée, les données ne se sont pas affichée. La raison en est simple. Vous n'avez pas précisé au serveur ce qu'il devait vous renvoyer : La base de données employee.fdb contient plusieurs tables et nous n'avons pas informé Firebird quelle table nous voulions regarder. Si vous ne connaissez pas la structure de la base, vous pouvez utiliser des outils comme [http://www.flamerobin.org/index.php FlameRobin] pour afficher les contenus. Lazarus fournit également un outil - le DataDesktop. Vous le trouverez dans le sous-répertoire /tools/lazdatadesktop/ de Lazarus. Sauvegardez votre projet puis ouvrez le projet lazdatadesktop.lpi et compilez-le. <br />
<br />
[[Image:DataDictonary1.png|framed|center|The DataDesktop in action]]<br />
<br />
Retournons à notre exemple. <br />
<br />
Nous voulons afficher toutes les données de la table 'CUSTOMER'. Les instructions SQL pour ce faire sont :<br />
<syntaxhighlight lang="sql"><br />
select * from CUSTOMER<br />
</syntaxhighlight> <br />
<br />
Nous devons affecter cette commande à la propriété 'SQL' de SQLQuery1. Dans le code source de notre projet, ça devrait avoir cet air-là :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
Les instructions SQL doivent être entourées d'apostrophes (se sont des chaînes de caractères au format Pascal). Vous pouvez également lui assigner la valeur d'un autre composant (par ex. Edit1.Text). Ce n'est pas toujours une bonne idée; voir [[Secure programming/fr|Secure programming]] (une documentation plus avancée) pour des informations sur l'injection de code SQL qui constitue un important risque de faille de sécurité.<br />
<br />
Ajoutons sur le formulaire un ''TButton'' (un bouton) depuis l'onglet 'Standard'. Quand l'utilisateur clique sur le bouton, l'extraction de données devrait commencer. Il va nous falloir écrire un peu de code pour faire ça. Double-cliquer sur Button1 (le bouton qu'on vient de placer sur le formulaire). Lazarus crée alors la procédure nécessaire. Nous trouverons dans notre code les lignes suivantes :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Entre ''begin'' et ''end'', vous devez taper les instructions nécessaire à l'affichage des données... ce qui a évidemment quelque chose à voir avec SQLQuery1.<br />
<br />
La propriété 'SQL' de SQLQUery1 peut seulement être modifiée quand SQL est inactive. C'est pourquoi nous fermons d'abord le composant :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
</syntaxhighlight><br />
Puis nous assignons notre instruction SQL à la propriété 'SQL', écrasant du même coup un éventuel contenu préalable :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
<br />
Il nous faut maintenant établir la connexion à la base, activer la transaction et ouvrir la requête :<br />
<syntaxhighlight><br />
DBConnection.Connected := True;<br />
SQLTransaction1.Active := True;<br />
SQLQuery1.Open;<br />
</syntaxhighlight><br />
Vous pouvez omettre les deux premières instruction, car elles seront automatiquement invoquées par la troisième. Si vous compiler le projet à ce point, vous pourrez déjà voir les données de la table 'CUSTOMER'. <br />
<br />
Toutefois, une application qui se veut sérieuse doit s'assurer que les connexions à la base de données sont proprement fermée quand elle ne sont plus utiles. Sinon des effets secondaires imprévisibles peuvent survenir. Donc, nous utilisons l'événement 'OnClose' du formulaire (créez-le en double-cliquant dans l'inspecteur d'objets :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Pour fermer la connexion, nous utiliserons l'ordre inverse de l'ouverture :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
SQLTransaction1.Active := False;<br />
DBConnection.Connected := False;<br />
</syntaxhighlight><br />
<br />
== Résumé ==<br />
Jusqu'à maintenant, nous avons appris a connecté la base de données en utilisant le paquet SQLdb pour afficher le contenu d'une table sur l'écran.<br />
Si vous voulez ajouter plus de fonctionnalités, comme l'édition des données, vous pouvez continuer avec [[SQLdb Tutorial2]]<br />
<br />
Si vous avez suivi ces différentes étapes, votre code devrait ressemble à ceci :<br />
<syntaxhighlight><br />
unit Unit1; <br />
<br />
{$mode objfpc}{$H+}<br />
<br />
interface<br />
<br />
uses<br />
Classes, SysUtils, IBConnection, sqldb, db, FileUtil, Forms, Controls,<br />
Graphics, Dialogs, DBGrids, StdCtrls;<br />
<br />
type<br />
<br />
{ TForm1 }<br />
<br />
TForm1 = class(TForm)<br />
Button1: TButton;<br />
Datasource1: TDatasource;<br />
DBGrid1: TDBGrid;<br />
DBConnection: TIBConnection;<br />
SQLQuery1: TSQLQuery;<br />
SQLTransaction1: TSQLTransaction;<br />
procedure Button1Click(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
private<br />
{ private declarations }<br />
public<br />
{ public declarations }<br />
end; <br />
<br />
var<br />
Form1: TForm1; <br />
<br />
implementation<br />
<br />
{$R *.lfm}<br />
<br />
{ TForm1 }<br />
<br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
SQLQuery1.Close;<br />
SQLQuery1.SQL.Text:= 'select * from CUSTOMER';<br />
DBConnection.Connected:= True;<br />
SQLTransaction1.Active:= True;<br />
SQLQuery1.Open;<br />
end;<br />
<br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
SQLQuery1.Close;<br />
SQLTransaction1.Active:= False;<br />
DBConnection.Connected:= False;<br />
end;<br />
<br />
end. <br />
</syntaxhighlight><br />
<br />
<br />
== Voir aussi ==<br />
* [[SQLdb Tutorial0/fr]] : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.<br />
* [[SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.<br />
* [[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.<br />
* [[SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.<br />
* [[Lazarus Database Overview]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.<br />
* [[SQLdb Package]] : Information sur le paquetage SQLdb.<br />
* [[SQLdb Programming Reference]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.<br />
* [[SqlDBHowto]] : Information sur l'utilisation du paquetage SQLdb.<br />
* [[Working With TSQLQuery]] : Information sur TSQLQuery.<br />
<br />
[[Category:Databases]]<br />
[[Category:Tutorials]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Tutorial1/fr&diff=104577SQLdb Tutorial1/fr2016-10-23T16:29:41Z<p>Alcatiz: /* Voir aussi */</p>
<hr />
<div>{{SQLdb Tutorial1}}<br />
<br />
== Introduction ==<br />
<br />
Le présent tutoriel va montrer à l'aide d'un exemple comment mettre en pratique le [[SQLdb Package]]. Il a été conçu pour des débutants. Cependant si vous chercher de l'aide pour les bases de données et SQL, vous n'êtes pas au bon endroit. <br />
Cette exemple utilise Firebird avec sa base de données employee.fdb. Vous pouvez utiliser une autre base. Dans ce cas, les modifications à apporter vous seront signalées au fur et à mesure.<br />
<br />
Si ce texte semble long, c'est que chaque ligne du code nécessaire est expliquée en détails. En fait, la quantité de choses à taper n'est pas si grande qu'il y parait. Les développeurs expérimentés peuvent survoler les instructions, ils comprendront rapidement de quoi il retourne.<br />
De plus, la première partie qui se termine par [[#Exemple simple|Exemple simple]] est suffisante pour disposer d'un programme fonctionnel.<br />
<br />
Vous avez devant les yeux une traduction de la [[SQLdb_Tutorial1|version anglaise]] du tutoriel, elle-même traduction de la [[SQLdb Tutorial1/de|version originale]] de [[User:Swen|Swen]] en allemand. La version anglaise a été enrichie en particulier dans la partie qui suit [[#Exemple simple|Exemple simple]]. [[User:Swen|Swen]] souhaite que la version allemande reste tel que.<br />
<br />
De Swen : Merci à [[User:Loesje|Joost]] et Michael, sans qui tout cela n'aurait probablement pas été possible.<br />
<br />
== Prérequis ==<br />
<br />
Si vous le pouvez, utiliser une version récente de Lazarus version (FPC 2.2.2 ou supérieure). Si le paquet SQLdb n'est pas installé, faites-le maintenant (Package -> Install/Uninstall packages ... -> SQLDBLaz 1.0.1).<br />
<br />
Vous devez disposer également d'une base de données relationnelle SQL, comme [http://sourceforge.net/project/showfiles.php?group_id=9028 Firebird] (si possible en version 2.0 ou supérieure). Le plus simple est d'utiliser les valeurs par défaut (par ex. utilisateur : SYSDBA et mot de passer masterkey) et la base exemple 'employee'.<br />
<br />
Vous pouvez préférer une autre base de données (MySQL, PostgreSQL, Oracle, SQLite ou une autre base interfacée par ODBC) : il vous faudra seulement disposer de la bonne structure base/table (voir ci-dessous) et utiliser le ''TSQLConnector'' approprié (voir ci-dessous également). Si les transactions de votre base sont très différentes, merci de documenter la section correspondante.<br />
Les notes au sujet de SQLite ont été commencé.<br />
<br />
=== Les biblothèques Firebird sous Windows ===<br />
<br />
Sous Windows, il vous faudra les DLLs Firebird, éventuellement dans votre répertoire système, mais de préférence dans le répertoire de votre projet (pendant le développement, dans l'IDE) et dans le répertoire de sortie où est produit l'exécutable (pour faire tourner le programme compilé).<br />
Vous pouvez trouver ces DLLs sur cette page : Firebird Embedded 2.5 [http://www.firebirdsql.org/en/firebird-2-5/].<br />
Décompressez les fichiers dans votre répertoire applicatif :<br />
<syntaxhighlight lang="bash"><br />
fbembed.dll<br />
firebird.msg<br />
ib_util.dll<br />
icudt30.dll<br />
icuin30.dll<br />
icuuc30.dll<br />
Microsoft.VC80.CRT.manifest<br />
msvcp80.dll<br />
msvcr80.dll<br />
</syntaxhighlight><br />
Renommez fbembed.dll en fbclient.dll (c'est le nom ordinaire du client Firebird). La DLL fournie peut également faire fonction de client ordinaire Firebird.<br />
<br />
Assurez-vous que la base de données employee.fdb se trouve bien dans le répertoire de votre projet.<br />
<br />
Enfin, recompilez une fois votre projet (même vide) pour créer le répertoire de sortie et y copier les DLLs.<br />
<br />
=== Les bases de données Firebird sur les autres systèmes ===<br />
<br />
Sous Linux/OSX, il vous faut également les bibliothèques partagées du client Firebird.<br />
Sous Linux, vous pouvez utiliser l'utilitaire de votre distribution pour installer les paquets, comme sous Debian :<br />
<bash><br />
aptitude install libfbclient2<br />
</bash><br />
ou<br />
<bash><br />
sudo apt-get -yqq install libfbclient2<br />
</bash><br />
<br />
=== Si Firebird ou employee.fdb ne sont pas installés ===<br />
<br />
Si vous ne disposez pas de la base de données exemple 'employee' ou si vous mettez en œuvre une autre base de données, voici ce dont la table dont vous devrez disposer pour notre exemple :<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE CUSTOMER<br />
(<br />
CUST_NO INTEGER NOT NULL,<br />
CUSTOMER VARCHAR(25) NOT NULL,<br />
CITY VARCHAR(25),<br />
COUNTRY VARCHAR(15),<br />
CONSTRAINT INTEG_60 PRIMARY KEY (CUST_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
Voici un peu de données pour qu'on voit quelque chose :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('1', 'Lapinou software', 'Lanion', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('2', 'VC Technologies', 'Dallas', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('3', 'Klämpfl, Van Canneyt and Co.', 'Boston', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('4', 'Felipe Bank', 'Manchester', 'England');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('5', 'Joost Systems, LTD.', 'Central Hong Kong', 'Hong Kong');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('6', 'Van der Voort Int.', 'Ottawa', 'Canada');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('7', 'Mrs. Mauvais', 'Pebble Beach', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('8', 'Asinine Vacation Rentals', 'Lihue', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('9', 'Fax', 'Turtle Island', 'Fiji');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('10', 'FPC Corporation', 'Tokyo', 'Japan');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('11', 'Dynamic Intelligence Corp', 'Zurich', 'Switzerland');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('12', '3D-Pad Corp.', 'Paris', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('13', 'Swen Export, Ltd.', 'Milan', 'Italy');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('14', 'Graeme Consulting', 'Brussels', 'Belgium');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES ('15', 'Klenin Inc.', 'Den Haag', 'Netherlands');<br />
</syntaxhighlight><br />
<br />
Merci de créer la base, la table et d'insérer les données dans votre environnement.<br />
<br />
==== SQLite ====<br />
Si vous utilisez SQLite, vous pouvez créer la base susmentionnée dans le répertoire de votre projet en lançant le code suivant : <br />
<syntaxhighlight lang="bash"><br />
sqlite employee.sqlite<br />
</syntaxhighlight><br />
Il suffit maintenant de copier/coller les instructions 'CREATE TABLE' et 'INSERT' ci-dessus.<br />
Pour tester si les données sont correctement entrée, utilisez la requête :<br />
<syntaxhighlight lang="SQL"><br />
select * from customer;<br />
</syntaxhighlight><br />
Terminer la session à l'aide de la commande : .quit<br />
Un fichier du nom de 'employee.sqlite' devrait être disponible dans le répertoire de votre projet.<br />
<br />
Assurez-vous que les bibliothèques sqlite (dll sous Windows et so sous Linux) sont installées (Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet).<br />
<br />
Compilez une fois votre projet, même vide, pour que soit créer le répertoire de sortie et, sous Windows, copier les DLLs et la base 'employee.sqlite' dans ce répertoire.<br />
<br />
==== PostgreSQL ====<br />
La présente section suppose que vous utilisez un serveur Linux et le shell. Des étapes similaires aboutiront au même résultat sous Windows avec un outil graphique comme pgadmin.<br />
Connectez-vous à votre serveur et basculez sous le compte postgres :<br />
<syntaxhighlight lang=bash><br />
su - postgres -c psql # Démarrage immédiat de l'interpréteur SQL psql<br />
</syntaxhighlight><br />
<br />
Create a user for the database and the tables:<br />
<syntaxhighlight lang=SQL><br />
CREATE USER employee WITH PASSWORD 'hellopassword'; -- Bien sûr, adaptez le mot de passe à votre convenance<br />
-- Un message comme 'CREATE ROLE' devrait sanctionner votre succès.<br />
-- Pour changer votre mot de passe a posteriori, utilisez quelque chose comme :<br />
-- alter user employee with password '<newpasswordhere>';<br />
-- Supprimons la date d'expiration du mot de passe. Ce n'est pas indispensable :<br />
ALTER USER employee VALID UNTIL 'infinity'; --password never expires<br />
-- Maintenant, ajoutons un peu de sécurité,<br />
-- interdisons à l'utilisateur de créer une base de données ou d'autres comptes utilisateurs :<br />
ALTER USER employee NOCREATEDB NOCREATEUSER; -- Restriction de la création d'objet<br />
-- La réponse devrait être quelque chose comme 'ALTER ROLE'.<br />
-- Création de notre base de données :<br />
CREATE DATABASE employee;<br />
-- Réponse : 'CREATE DATABASE'.<br />
-- Assignons tous les droits sur la base funambol à l'utilisateur 'employee' :<br />
GRANT ALL PRIVILEGES ON DATABASE employee TO employee; -- Allocation des droits<br />
-- La réponse devrait être quelque chose comme 'GRANT'.<br />
-- Nous créons la tbla à l'aide du type de données 'serial', numérotation automatique :<br />
CREATE TABLE customer<br />
(<br />
cust_no serial NOT NULL,<br />
customer character varying(25) NOT NULL,<br />
city character varying(25),<br />
country character varying(15),<br />
CONSTRAINT integ_60 PRIMARY KEY (cust_no )<br />
);<br />
-- Maintenant collons les lignes INSERT ci-dessus. Vérifions la saisie avec :<br />
SELECT * FROM customer;<br />
-- Sortons de là :<br />
\q <br />
</syntaxhighlight><br />
<br />
Maintenant, nous devrions être sous le shell, connecté en tant que utilisateur postgres.<br />
<br />
Si votre serveur se trouve sur une machine distante, vérifiez la bon accès réseau à cette machine. Voyez les détails dans la documentation postgresql, mais quelque chose comme ça devrait marcher :<br />
<syntaxhighlight lang=bash><br />
# Nous utilisons 'nano' comme éditeur, mais vous pouvez le remplacer par ce que vous voulez (comme vim, emacs, joe...) et le numéro de la version de postgres dépend de '/etc/postgresql/8.4/main/pg_hba.conf'.<br />
</syntaxhighlight><br />
<br />
Vérifier la présence d'une ligne qui ressemble à ceci (Remplacer 192.168.0.1 par l'étendue d'adresses IP de votre réseau local.<br />
<br />
<nowiki><br />
# Permettre l'acceès du réseau local en utilisant les mots de passe encodés md5 :<br />
<br />
host all all 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Ou de manière plus restrictive :<br />
<br />
<nowiki><br />
# Permettre seulement l'accès à la base 'employee' à l'utilisateur 'employee' :<br />
<br />
host employee employee 192.168.0.1/24 md5<br />
</nowiki><br />
<br />
Si vous n'avez pas de ligne de ce type, ajoutez-la à la fin et sortez de votre éditeur.<br />
Pour plus d'information, reportez-vous à la documentation PostgreSQL.<br />
<br />
Rechargez les paramètres de PostgreSQL :<br />
<syntaxhighlight lang=bash> <br />
psql<br />
</syntaxhighlight><br />
Puis<br />
<syntaxhighlight lang=bash> <br />
SELECT pg_reload_conf(); --reload settings...<br />
-- ...and exit back to shell:<br />
\q<br />
</syntaxhighlight><br />
<br />
Essayez le vous connecter à PostgreSQL. <br />
<br />
Note : Par défaut, PostgreSQL tente d'utiliser un socket qui ne permet pas l'usage d'un mot de passe. Pour circonvenir cette propension, nous spécifions le nom de l'hôte pour forcer une connexion TCP/IP :<br />
<syntaxhighlight lang=bash><br />
psql -h 127.0.0.1 -d employee -U employee -W # Connexion par TCP/IP. Précisez votre mot de passe.<br />
</syntaxhighlight><br />
<br />
Assurez-vous que les bibliothèques (dll sous WIndows et so sous Linus) sont bien installées - Par ex. sous Windows, 'sqlite3.dll' devrait se trouver dans le répertoire de votre projet.<br />
<br />
Compiler une fois votre projet, même vide, de façon à créer le répertoire de sortir et, sous Windows, copier les dlls dans ce répertoire.<br />
<br />
== Exemple simple ==<br />
<br />
=== Projet et composants ===<br />
D'abord, il vous faut créer un nouveau projet Lazarus.<br />
<br />
Pour établir la connexion à votre base, vous avez besoin de une ''TIBConnection'', une ''TSQLTransaction'' et un composant ''[[Working With TSQLQuery|TSQLQuery]]'' que vous trouverez dans l'onglet 'SQLdb' de la palette de composants. <br />
<br />
''TIBConnection'' est me composant de connexion spécifique à Interbase/Firebird (Firebird est un fork d'Interbase).<br />
Si vous utilisez une base de données différente, remplacer ce composant par le composant approprié dans ce même onglet. Par exemple, une ''TSQLite3Connection'' pour une base SQLite, une ''PQConnection'' pour PostgreSQL. Les explications sur l'installation des bibliothèques d'accès à ces bases dépassent l'ambition de ce tutoriel et devrait être trouvées ailleurs (dans [[Databases]] par exemple).<br />
<br />
Placez une ''TIBConnection'' (ou un composant de connexion équivalent) sur votre formulaire et changez son nom en ''DBConnection'' dans l'inspecteur d'objet. C'est généralement une bonne idée de changer le nom de vos composants pour quelque chose qui fait sens dans votre programme (Par ex. ''MainframeDBConnection'').<br />
<br />
Les deux autres composants, ''TSQLTransaction'' and ''TSQLQuery'', sont communs à toutes les types de bases qui peuvent être supportés par SQLdb.<br />
<br />
Pour afficher les données, utilisez un composant ''TDBGrid'' que vous trouverez dans l'onglet 'Data Controls'. Pour connecter ce composant à la base de données, on utilise un composant ''TDatasource'' qu'on trouve dans l'onglet 'Data Access'.<br />
<br />
Tous les composants nécessaires à notre premier exemple sont maintenant rassemblés. Vous pouvez agrandir le TDBGrid pour l'affichage de toutes les données.<br />
<br />
=== Relier les composants ===<br />
Maintenant, il nous reste à relier nos composantes. Le moyen le plus simplie consiste à utiliser l'inspecteur d'obet, mais on peut également le faire dans le code source. <br />
<br />
Changez la propriété ''Transaction'' de DBConnection en 'SQLTransaction1'. Cela provoquera le changement automatique de la propriété ''Database'' de SQLTransaction1 en 'DBConnection'. <br />
<br />
Ensuite, changez la propriété ''Database'' de SQLQuery1 en 'DBConnection'. Lazarus ajuste automatiquement la valeur de la propriété 'Transaction'. <br />
<br />
Puis, changez la propriété ''Dataset'' de Datasource1 en 'SQLQuery1'. <br />
<br />
Et, pour finir, changez la propriété ''Datasource'' de DBGrid1 en 'Datasource1'.<br />
<br />
Nous voici avec une connexion qui relie sa transaction par défaut à un composant de transaction. Le composant transaction est reliépar sa propriété 'database' à l'objet de connexion. Ces deux composants sont suffisants pour réalisation la connexion et exécuter les instructions, mais insuffisants pour afficher des requêtes. Pour cela, on utilise le composant SQLQuery qui pointe sur la base de données (database) et fait le lien avec sa transaction par défaut. C'est avec le SQLQuery que nous extrairons plus tard les données et posterons en retour les données vers la base.<br />
<br />
Enfin, le composant 'datasource', qui est relié au composant requête, est une sorte d'interface. Il enregistre la position actuelle dans le dataset et les composants visuels utilisent cette information pour synchroniser l'affichage sur le même enregistrement.<br />
<br />
Finally, the datasource component, which is linked to the query component, is a sort of place holder. It keeps track of where in the query dataset we are and the GUI components are linked to that so they all show the same record.<br />
<br />
Si ça vous parait un peu obscur, ne vous inquiétez pas : encore un peu de travail et vous serez capables d'afficher vos premières données.<br />
<br />
=== Connexion avec la base de données ===<br />
Comment pouvons-nous afficher les données de notre base sur l'écran ?<br />
D'abord, nous devons informer DBConnection de l'endroit où se trouve la base employee.fdb (généralement dans le sous répertoires .../examples/empbuild/ de notre installation Firebird). Encore une fois, vous avez le choix : Vous pouvez utiliser l'inspecteur d'objets pour fixer le chemin ou le faire directement dans votre code.<br />
Nous choisissons d'utiliser l'inspecteur d'objet : Positionner la propriété 'HostName' de DBConnection sur le nom du serveur Firebird ou sur l'adresse IP. Utilisez 'localhost' si le serveur Firebird tourne sur votre machine de développement. Laissez le champ vide si vous utilisez un client Firebird embarqué.<br />
Positionner la propriété ''DatabaseName'' de DBConnection sur le chemin d'accès au fichier emplyee.fdb sur le serveur de base de données (par ex. C:\Program Files\Firebird\Firebird_2_0\examples\empbuild\EMPLOYEE.FDB sur une maachine Windows).<br />
Avant que le serveur de base de données ne permette l'accès au données, il vérifie que l'utilisateur et le mot de passe soient autorisés à le faire. Une base de données sérieuse demandera à l'utilisateur ces deux informations au démarrage de l'application, et l'enverra au serveur à la connexion.<br />
Toutefois, pour l'instant, de manière à faire simple, nous utiliserons encore l'inspecteur d'objets pour entrer ces informations ''en dur''. Changez le 'UserName' (nom d'utilisateur) en 'SYSDBA' et 'Password' (mot de passe) en 'masterkey' (bien sûr, faites les ajustements nécessaire si votre installation utilise un nom ou un mot de passe différent).<br />
<br />
==== PostgreSQL ====<br />
Les choses sont très proche qu'avec Firebird. Le nom de la base de données n'a pas de chemin (de partie répertoire) - il suffit de préciser son nom (par ex. 'employee'). PostgreSQl n'a pas de mode embarqué, il est donc indispensable de renseigner la propriété ''HostName'' (nom du serveur) pour que la connexion de test fonctionne.<br />
<br />
==== SQLite ====<br />
Pour ce qui concerne SQLite, vous pouvez laisser les trois propriétés 'HostName', 'UserName', et 'Password' vides. Il faut remplir le nom du fichier SQLite dans 'DatabaseName', par ex. employee.sqlite. Attention : SQLite créera une base vide si le fichier n'existe pas.<br />
<br />
Vous devriez obtenir quelque chose comme l'écran suivant :<br />
[[Image:SQLTut1ComponentsSetUp.png|framed|center|Form and components set up]]<br />
<br />
=== Déterminer la partie des informations à afficher ===<br />
<br />
Bien que la connexion ait été réalisée, les données ne se sont pas affichée. La raison en est simple. Vous n'avez pas précisé au serveur ce qu'il devait vous renvoyer : La base de données employee.fdb contient plusieurs tables et nous n'avons pas informé Firebird quelle table nous voulions regarder. Si vous ne connaissez pas la structure de la base, vous pouvez utiliser des outils comme [http://www.flamerobin.org/index.php FlameRobin] pour afficher les contenus. Lazarus fournit également un outil - le DataDesktop. Vous le trouverez dans le sous-répertoire /tools/lazdatadesktop/ de Lazarus. Sauvegardez votre projet puis ouvrez le projet lazdatadesktop.lpi et compilez-le. <br />
<br />
[[Image:DataDictonary1.png|framed|center|The DataDesktop in action]]<br />
<br />
Retournons à notre exemple. <br />
<br />
Nous voulons afficher toutes les données de la table 'CUSTOMER'. Les instructions SQL pour ce faire sont :<br />
<syntaxhighlight lang="sql"><br />
select * from CUSTOMER<br />
</syntaxhighlight> <br />
<br />
Nous devons affecter cette commande à la propriété 'SQL' de SQLQuery1. Dans le code source de notre projet, ça devrait avoir cet air-là :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
Les instructions SQL doivent être entourées d'apostrophes (se sont des chaînes de caractères au format Pascal). Vous pouvez également lui assigner la valeur d'un autre composant (par ex. Edit1.Text). Ce n'est pas toujours une bonne idée; voir [[Secure programming]] (une documentation plus avancée) pour des informations sur l'injection de code SQL qui constitue un important risque de faille de sécurité.<br />
<br />
Ajoutons sur le formulaire un ''TButton'' (un bouton) depuis l'onglet 'Standard'. Quand l'utilisateur clique sur le bouton, l'extraction de données devrait commencer. Il va nous falloir écrire un peu de code pour faire ça. Double-cliquer sur Button1 (le bouton qu'on vient de placer sur le formulaire). Lazarus crée alors la procédure nécessaire. Nous trouverons dans notre code les lignes suivantes :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Entre ''begin'' et ''end'', vous devez taper les instructions nécessaire à l'affichage des données... ce qui a évidemment quelque chose à voir avec SQLQuery1.<br />
<br />
La propriété 'SQL' de SQLQUery1 peut seulement être modifiée quand SQL est inactive. C'est pourquoi nous fermons d'abord le composant :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
</syntaxhighlight><br />
Puis nous assignons notre instruction SQL à la propriété 'SQL', écrasant du même coup un éventuel contenu préalable :<br />
<syntaxhighlight><br />
SQLQuery1.SQL.Text := 'select * from CUSTOMER';<br />
</syntaxhighlight><br />
<br />
Il nous faut maintenant établir la connexion à la base, activer la transaction et ouvrir la requête :<br />
<syntaxhighlight><br />
DBConnection.Connected := True;<br />
SQLTransaction1.Active := True;<br />
SQLQuery1.Open;<br />
</syntaxhighlight><br />
Vous pouvez omettre les deux premières instruction, car elles seront automatiquement invoquées par la troisième. Si vous compiler le projet à ce point, vous pourrez déjà voir les données de la table 'CUSTOMER'. <br />
<br />
Toutefois, une application qui se veut sérieuse doit s'assurer que les connexions à la base de données sont proprement fermée quand elle ne sont plus utiles. Sinon des effets secondaires imprévisibles peuvent survenir. Donc, nous utilisons l'événement 'OnClose' du formulaire (créez-le en double-cliquant dans l'inspecteur d'objets :<br />
<br />
<syntaxhighlight><br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
<br />
end; <br />
</syntaxhighlight><br />
<br />
Pour fermer la connexion, nous utiliserons l'ordre inverse de l'ouverture :<br />
<syntaxhighlight><br />
SQLQuery1.Close;<br />
SQLTransaction1.Active := False;<br />
DBConnection.Connected := False;<br />
</syntaxhighlight><br />
<br />
== Résumé ==<br />
Jusqu'à maintenant, nous avons appris a connecté la base de données en utilisant le paquet SQLdb pour afficher le contenu d'une table sur l'écran.<br />
Si vous voulez ajouter plus de fonctionnalités, comme l'édition des données, vous pouvez continuer avec [[SQLdb Tutorial2]]<br />
<br />
Si vous avez suivi ces différentes étapes, votre code devrait ressemble à ceci :<br />
<syntaxhighlight><br />
unit Unit1; <br />
<br />
{$mode objfpc}{$H+}<br />
<br />
interface<br />
<br />
uses<br />
Classes, SysUtils, IBConnection, sqldb, db, FileUtil, Forms, Controls,<br />
Graphics, Dialogs, DBGrids, StdCtrls;<br />
<br />
type<br />
<br />
{ TForm1 }<br />
<br />
TForm1 = class(TForm)<br />
Button1: TButton;<br />
Datasource1: TDatasource;<br />
DBGrid1: TDBGrid;<br />
DBConnection: TIBConnection;<br />
SQLQuery1: TSQLQuery;<br />
SQLTransaction1: TSQLTransaction;<br />
procedure Button1Click(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
private<br />
{ private declarations }<br />
public<br />
{ public declarations }<br />
end; <br />
<br />
var<br />
Form1: TForm1; <br />
<br />
implementation<br />
<br />
{$R *.lfm}<br />
<br />
{ TForm1 }<br />
<br />
procedure TForm1.Button1Click(Sender: TObject);<br />
begin<br />
SQLQuery1.Close;<br />
SQLQuery1.SQL.Text:= 'select * from CUSTOMER';<br />
DBConnection.Connected:= True;<br />
SQLTransaction1.Active:= True;<br />
SQLQuery1.Open;<br />
end;<br />
<br />
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);<br />
begin<br />
SQLQuery1.Close;<br />
SQLTransaction1.Active:= False;<br />
DBConnection.Connected:= False;<br />
end;<br />
<br />
end. <br />
</syntaxhighlight><br />
<br />
<br />
== Voir aussi ==<br />
* [[SQLdb Tutorial0/fr]] : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.<br />
* [[SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.<br />
* [[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.<br />
* [[SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.<br />
* [[Lazarus Database Overview]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.<br />
* [[SQLdb Package]] : Information sur le paquetage SQLdb.<br />
* [[SQLdb Programming Reference]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.<br />
* [[SqlDBHowto]] : Information sur l'utilisation du paquetage SQLdb.<br />
* [[Working With TSQLQuery]] : Information sur TSQLQuery.<br />
<br />
[[Category:Databases]]<br />
[[Category:Tutorials]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Tutorial0/fr&diff=104531SQLdb Tutorial0/fr2016-10-16T14:52:35Z<p>Alcatiz: </p>
<hr />
<div>{{SQLdb Tutorial0}}<br />
[[Category:Français]]<br />
<br />
{{Infobox databases}}<br />
== Introduction ==<br />
<br />
Cet article vous aidera à configurer votre environnement de base de données avec des exemples de tables et de données utilisés dans les tutoriels SQLdb 1, 2, 3 et 4.<br />
<br />
Malgré que cette page soit assez longue, vous n'en parcourrez que quelques sections, puisque cet article contient des instructions pour divers systèmes de bases de données.<br />
<br />
Si vous voulez être rapidement opérationnel(le), je suggère que vous installiez le serveur Firebird et la base de données d'exemple comme décrit ci-dessous.<br />
<br />
== Pré-requis ==<br />
Ce tutoriel a été écrit pour être utilisé avec des versions récentes de Lazarus (1.0) ; il devrait aussi convenir pour de plus anciennes versions (0.9.30).<br />
<br />
En outre, vous avez besoin d'une base de données SQL relationnelle comme [http://sourceforge.net/project/showfiles.php?group_id=9028 Firebird] (si possible version 2.0 ou plus). C'est plus facile si vous utilisez des paramètres standard (par exemple, SYSDBA comme nom d'utilisateur et masterkey comme mot de passe), et si vous avez installé la base de données d'exemple "employee".<br />
<br />
Vous pouvez utiliser une autre base de données (par exemple, Microsoft SQL Server, MySQL, PostgreSQL, Oracle, SQLite, Sybase ASE ou une autre base utilisant ODBC). Veuillez vous assurer que vous disposez des bibliothèques requises de client base de données (voyez les différents articles du wiki sur les bases de données). Voyez ci-dessous la section '''Firebird ou employee.fdb non installé ?''' pour la manière de configurer vos tables.<br />
<br />
== Installation de Firebird ==<br />
Au cas où vous n'auriez pas encore installé Firebird ou la base de données d'exemple utilisée dans ces tutoriels, vous trouverez des instructions ci-dessous.<br />
<br />
=== Installation du client/serveur Firebird ===<br />
Si vous n'avez encore rien installé, vous pouvez télécharger et exécuter l'installeur sur www.firebirdsql.org, et installer le serveur (par exemple, "32-bit Classic, Superclassic & Superserver").<br />
<br />
=== Bibliothèques de bases de données Firebird sur Windows ===<br />
Après installation sur Windows, les DLLs du client Firebird doivent être présentes ;<br />
* soit dans votre répertoire système (disponibles pour tous les programmes) ;<br />
* soit dans votre répertoire Lazarus (pour la conception dans l'IDE) et dans le répertoire de destination où se trouve l'exécutable (pour exécuter le programme compilé).<br />
<br />
Si vous n'avez pas installé le serveur Firebird, une manière simple d'obtenir les DLLs du client est de télécharger Firebird Embedded 2.5 sur [http://www.firebirdsql.org/en/firebird-2-5/].<br />
Extrayez ces fichiers dans le répertoire de votre application :<br />
<syntaxhighlight lang="bash"><br />
fbclient.dll # uniquement si vous utilisez le serveur<br />
# ou<br />
fbembed.dll # uniquement si vous utilisez Firebird Embedded <br />
firebird.msg<br />
ib_util.dll<br />
icudt30.dll<br />
icuin30.dll<br />
icuuc30.dll<br />
Microsoft.VC80.CRT.manifest<br />
msvcp80.dll<br />
msvcr80.dll<br />
</syntaxhighlight><br />
Renommez fbembed.dll en fbclient.dll (le nom d'un client Firebird normal, client-serveur - c'est utile sur de plus anciennes versions de Lazarus). La DLL de Firebird Embedded peut également fonctionner comme un client Firebird normal.<br />
<br />
Assurez-vous que la base de données employee.fdb se trouve dans le répertoire de votre projet. Vous pouvez la copier depuis le répertoire examples/empbuild/ du serveur Firebird 2.5.<br />
<br />
Pour finir, compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et copiez les DLLs ainsi que la base de données employee.fdb dans ce répertoire.<br />
<br />
=== Bibliothèques de bases de données Firebird sur d'autres systèmes ===<br />
<br />
Sur Linux/OSX, vous aurez aussi besoin des bibliothèques partagées du client Firebird.<br />
Sur Linux, vous pouvez utiliser le gestionnaire de paquets de votre distribution pour récupérer les paquets du client Firebird ; par exemple, sur Debian :<br />
<syntaxhighlight lang="bash"><br />
aptitude install libfbclient2 firebird-dev # nous avons besoin de la version dev car FPC 2.6 et précédents chercheront libfbclient.so<br />
</syntaxhighlight><br />
<br />
== Firebird ou employee.fdb non installé ? ==<br />
<br />
Si la base de données d'exemple employee n'est pas installée, ou si vous utilisez une base de données différente, voici une version minimale de la table que nous utiliserons (note : vous trouverez ci-dessous des directives pour des bases de données spécifiques).<br />
<br />
=== Création automatique ===<br />
La méthode de configuration la plus simple est de créer une base de données vide sur votre système et de vous y connecter avec le programme utilitaire d'exemple TSQLScriptSample. <br />
Ce programme est inclus dans les versions de développement courantes de Lazarus, dans le répertoire <tt>./examples/database/tsqlscript</tt>, mais il peut également être téléchargé sur : http://svn.freepascal.org/svn/lazarus/trunk/examples/database/tsqlscript/<br />
<br />
Compilez et exécutez le programme, puis connectez-vous à la base de données :<br />
<br />
[[image:tsqlscriptsample connect.png]]<br />
<br />
Cliquez ensuite sur le bouton ''Copy table creation script'', et ''Run script'' :<br />
<br />
[[image:tsqlscriptsample runfirstscript.png]]<br />
<br />
Le programme doit normalement indiquer que l'opération est couronnée de succès.<br />
Faites à présent la même chose pour ''Copy sample data script'', et ''Run script''.<br />
<br />
En cas de problème, vous pouvez essayer les étapes manuelles ci-dessous.<br />
<br />
=== Création manuelle ===<br />
Nous allons créer les tables CUSTOMER et EMPLOYEE qui seront utilisées dans un prochain tutoriel.<br />
<br />
Exécutez ces commandes SQL dans votre éditeur/utilitaire de base de données :<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE CUSTOMER<br />
(<br />
CUST_NO INTEGER NOT NULL,<br />
CUSTOMER VARCHAR(25) NOT NULL,<br />
CITY VARCHAR(25),<br />
COUNTRY VARCHAR(15),<br />
CONSTRAINT CT_CUSTOMER_PK PRIMARY KEY (CUST_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE EMPLOYEE<br />
(<br />
EMP_NO INTEGER NOT NULL,<br />
FIRST_NAME VARCHAR(15) NOT NULL,<br />
LAST_NAME VARCHAR(20) NOT NULL,<br />
PHONE_EXT VARCHAR(4),<br />
JOB_CODE VARCHAR(5) NOT NULL,<br />
JOB_GRADE INTEGER NOT NULL,<br />
JOB_COUNTRY VARCHAR(15) NOT NULL,<br />
SALARY NUMERIC(10,2) NOT NULL,<br />
CONSTRAINT CT_EMPLOYEE_PK PRIMARY KEY (EMP_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
Quelques données pour pouvoir au moins montrer quelque chose... D'abord quelques clients :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (1, 'Michael Design', 'San Diego', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (2, 'VC Technologies', 'Dallas', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (3, 'Klämpfl, Van Canneyt', 'Boston', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (4, 'Felipe Bank', 'Manchester', 'England');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (5, 'Joost Systems, LTD.', 'Central Hong Kong', 'Hong Kong');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (6, 'Van der Voort Int.', 'Ottawa', 'Canada');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (7, 'Mrs. Mauvais', 'Pebble Beach', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (8, 'Asinine Vacation Rentals', 'Lihue', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (9, 'Fax', 'Turtle Island', 'Fiji');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (10, 'FPC Corporation', 'Tokyo', 'Japan');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (11, 'Dynamic Intelligence Corp', 'Zurich', 'Switzerland');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (12, '3D-Pad Corp.', 'Paris', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (13, 'Swen Export, Ltd.', 'Milan', 'Italy');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (14, 'Graeme Consulting', 'Brussels', 'Belgium');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (15, 'Klenin Inc.', 'Den Haag', 'Netherlands');<br />
</syntaxhighlight><br />
<br />
Puis quelques employés :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (1,'William','Shatner','1702','CEO',1,'USA',48000);<br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (2,'Ivan','Rzeszow','9802','Eng',2,'Russia',38000);<br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (3,'Erin','Powell','1703','Admin',2,'USA',45368);<br />
</syntaxhighlight><br />
<br />
Créez la base de données, les tables et insérez les données dans votre environnement de bases de données.<br />
<br />
== SQLite ==<br />
Si vous utilisez SQLite, vous pouvez créer la base de données mentionnée plus haut dans le répertoire de votre projet, en lançant l'exécutable SQLite :<br />
<syntaxhighlight lang="bash"><br />
sqlite employee.sqlite<br />
</syntaxhighlight><br />
Copiez et collez à présent les commandes CREATE TABLE et INSERT ci-avant.<br />
Pour tester si les bonnes données sont présentes, entrez cette requête :<br />
<syntaxhighlight lang="SQL"><br />
select * from customer;<br />
</syntaxhighlight><br />
Terminez votre session avec<br />
<syntaxhighlight lang="SQL"><br />
.quit<br />
</syntaxhighlight><br />
<br />
Un fichier appelé employee.sqlite devrait maintenant être créé dans le répertoire de votre projet.<br />
<br />
Assurez-vous que les DLL/so SQLite requises soient installées - par exemple, sur Windows, sqlite3.dll devrait être présent dans<br />
* votre répertoire Lazarus + projet de destination, ou<br />
* votre répertoire système.<br />
<br />
En outre, si vous avez une DLL SQLite 32 bits, assurez-vous d'avoir la version 32 bits de Lazarus.<br />
<br />
Compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et (sour Windows) copiez-y la DLL ainsi que la base de données employee.sqlite.<br />
<br />
== PostgreSQL ==<br />
Dans cette section, nous partons du principe que vous utilisez un serveur Linux et la console ; les étapes équivalentes peuvent être réalisées sous Windows et avec des outils GUI comme PGAdmin.<br />
<br />
Connectez-vous à votre serveur et basculez vers le compte PostgreSQL :<br />
<syntaxhighlight lang=bash><br />
su - postgres -c psql # démarrage immédiat de l'interpréteur SQL psql<br />
</syntaxhighlight><br />
<br />
Créez un utilisateur pour la base de données et pour les tables :<br />
<syntaxhighlight lang=SQL><br />
CREATE USER employee WITH PASSWORD 'hellopassword'; -- bien sûr, mettez un mot de passe à votre goût<br />
-- Quelque chose comme 'CREATE ROLE' devrait s'afficher pour indiquer le succès de l'opération.<br />
-- Pour changer ultérieurement le mot de passe, vous pouvez utiliser quelque chose comme<br />
-- alter user employee with password '<newpasswordhere>';<br />
<br />
-- Nous allons empêcher le mot de passe d'expirer ; si vous souhaitez plus de sécurité, passez cette étape :<br />
ALTER USER employee VALID UNTIL 'infinity'; -- le mot de passe n'expire jamais<br />
<br />
-- Nous allons encore un peu resserrer les choses :<br />
-- ne pas permettre à un utilisateur de créer une base de données ou d'autres utilisateurs :<br />
ALTER USER employee NOCREATEDB NOCREATEUSER; -- restreint la création d'objets<br />
-- Quelque chose comme 'ALTER ROLE' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Créons notre base de données :<br />
CREATE DATABASE employee;<br />
-- Quelque chose comme 'CREATE DATABASE' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Attribuons tous les privilèges sur la base de données employee à l'utilisateur employee :<br />
GRANT ALL PRIVILEGES ON DATABASE employee TO employee; -- attribue à l'utilisateur toutes les permissions sur la base de données<br />
-- Quelque chose comme 'GRANT' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Créons la table customer, utilisant un type de donnée serial - aka autonumber/autoincrement :<br />
CREATE TABLE customer<br />
(<br />
cust_no serial NOT NULL,<br />
customer character varying(25) NOT NULL,<br />
city character varying(25),<br />
country character varying(15),<br />
CONSTRAINT integ_60 PRIMARY KEY (cust_no)<br />
);<br />
<br />
-- Créons alors la table employee :<br />
CREATE TABLE EMPLOYEE<br />
(<br />
EMP_NO SERIAL NOT NULL,<br />
FIRST_NAME VARCHAR(15) NOT NULL,<br />
LAST_NAME VARCHAR(20) NOT NULL,<br />
PHONE_EXT VARCHAR(4),<br />
JOB_CODE VARCHAR(5) NOT NULL,<br />
JOB_GRADE INTEGER NOT NULL,<br />
JOB_COUNTRY VARCHAR(15) NOT NULL,<br />
SALARY NUMERIC(10,2) NOT NULL,<br />
CONSTRAINT CT_EMPLOYEE_PK PRIMARY KEY (EMP_NO)<br />
);<br />
<br />
-- À présent, copiez et collez les commandes INSERT de la section ci-dessus pour insérer les données.<br />
<br />
-- Pour tester si les bonnes données sont présentes, entrez cette requête :<br />
SELECT * FROM customer;<br />
-- Vous devriez voir quelques clients.<br />
<br />
-- Sortie de psql :<br />
\q <br />
</syntaxhighlight><br />
<br />
À présent, vous devriez être dans la console, connecté comme utilisateur Postgres.<br />
<br />
Si votre serveur est une autre machine que celle de développement, assurez-vous d'autoriser l'accès réseau à la base de données. Consultez votre documentation PostgreSQL pour les détails, mais quelque chose comme ceci devrait fonctionner :<br />
<syntaxhighlight lang=bash><br />
# Remplacez nano (p.ex. vim, emacs, joe...) et le numéro de version Postgres selon votre environnement<br />
nano /etc/postgresql/8.4/main/pg_hba.conf<br />
</syntaxhighlight><br />
<br />
Vérifiez la présence d'une ligne comme (remplacez 192.168.0.1 par votre propre adresse IP, ou range) :<br />
<syntaxhighlight lang="bash"><br />
# Permet l'accès depuis le réseau local, en utilisant des mots de passe crypyés en MD5 :<br />
host all all 192.168.0.1/24 md5<br />
</syntaxhighlight><br />
<br />
Ou, plus restrictif :<br />
<br />
<syntaxhighlight lang="bash"><br />
# Permet uniquement l'accès réseau à la base de données employee par l'utilisateur employee :<br />
host employee employee 192.168.0.1/24 md5<br />
</syntaxhighlight><br />
<br />
Si une telle ligne n'existe pas, ajoutez-la à la fin, enregistrez et fermez votre éditeur.<br />
Consultez la documentation PostgreSQL pour plus de détails.<br />
<br />
Rechargez les réglages PostgreSQL :<br />
<syntaxhighlight lang=bash> <br />
psql<br />
</syntaxhighlight><br />
puis<br />
<syntaxhighlight lang=SQL> <br />
SELECT pg_reload_conf(); -- recharge les réglages...<br />
-- ... et retourne au shell :<br />
\q<br />
</syntaxhighlight><br />
<br />
Testez la connexion à PostgreSQL.<br />
<br />
Note : par défaut, PostgreSQL essaie un login ident/unix domain socket qui n'autorise pas les mots de passe. Nous spécifions donc à l'hôte de forcer le login TCP/IP :<br />
<syntaxhighlight lang=bash><br />
psql -h 127.0.0.1 -d employee -U employee -W # Login via TCP/IP. Entrez votre mot de passe.<br />
</syntaxhighlight><br />
<br />
Assurez-vous que les DLL/so PostgreSQL et les autres bibliothèques requises soient installées - par exemple, sur Windows, elles devraient se trouver soit :<br />
* dans votre répertoire Lazarus + projet de destination, soit<br />
* dans votre répertoire système.<br />
<br />
Compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et (sur Windows) copiez-y les DLLs.<br />
<br />
== Fin ==<br />
Maintenant que vous avez configuré votre base de données, vous pouvez aller vers [[SQLdb Tutorial1|le premier "vrai" tutoriel]].<br />
<br />
== Voir aussi ==<br />
* [[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.<br />
* [[SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.<br />
* [[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.<br />
* [[SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.<br />
* [[Lazarus Database Overview]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.<br />
* [[SQLdb Package]] : Information sur le paquetage SQLdb.<br />
* [[SQLdb Programming Reference]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.<br />
* [[SqlDBHowto]] : Information sur l'utilisation du paquetage SQLdb.<br />
* [[Working With TSQLQuery]] : Information sur TSQLQuery.<br />
<br />
[[Category:Databases]]<br />
[[Category:Tutorials]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Tutorial0/fr&diff=104530SQLdb Tutorial0/fr2016-10-16T14:51:43Z<p>Alcatiz: Created page with "{{Tutoriel SQLdb 0}} Category:Français {{Infobox databases}} == Introduction == Cet article vous aidera à configurer votre environnement de base de données avec des e..."</p>
<hr />
<div>{{Tutoriel SQLdb 0}}<br />
[[Category:Français]]<br />
<br />
{{Infobox databases}}<br />
== Introduction ==<br />
<br />
Cet article vous aidera à configurer votre environnement de base de données avec des exemples de tables et de données utilisés dans les tutoriels SQLdb 1, 2, 3 et 4.<br />
<br />
Malgré que cette page soit assez longue, vous n'en parcourrez que quelques sections, puisque cet article contient des instructions pour divers systèmes de bases de données.<br />
<br />
Si vous voulez être rapidement opérationnel(le), je suggère que vous installiez le serveur Firebird et la base de données d'exemple comme décrit ci-dessous.<br />
<br />
== Pré-requis ==<br />
Ce tutoriel a été écrit pour être utilisé avec des versions récentes de Lazarus (1.0) ; il devrait aussi convenir pour de plus anciennes versions (0.9.30).<br />
<br />
En outre, vous avez besoin d'une base de données SQL relationnelle comme [http://sourceforge.net/project/showfiles.php?group_id=9028 Firebird] (si possible version 2.0 ou plus). C'est plus facile si vous utilisez des paramètres standard (par exemple, SYSDBA comme nom d'utilisateur et masterkey comme mot de passe), et si vous avez installé la base de données d'exemple "employee".<br />
<br />
Vous pouvez utiliser une autre base de données (par exemple, Microsoft SQL Server, MySQL, PostgreSQL, Oracle, SQLite, Sybase ASE ou une autre base utilisant ODBC). Veuillez vous assurer que vous disposez des bibliothèques requises de client base de données (voyez les différents articles du wiki sur les bases de données). Voyez ci-dessous la section '''Firebird ou employee.fdb non installé ?''' pour la manière de configurer vos tables.<br />
<br />
== Installation de Firebird ==<br />
Au cas où vous n'auriez pas encore installé Firebird ou la base de données d'exemple utilisée dans ces tutoriels, vous trouverez des instructions ci-dessous.<br />
<br />
=== Installation du client/serveur Firebird ===<br />
Si vous n'avez encore rien installé, vous pouvez télécharger et exécuter l'installeur sur www.firebirdsql.org, et installer le serveur (par exemple, "32-bit Classic, Superclassic & Superserver").<br />
<br />
=== Bibliothèques de bases de données Firebird sur Windows ===<br />
Après installation sur Windows, les DLLs du client Firebird doivent être présentes ;<br />
* soit dans votre répertoire système (disponibles pour tous les programmes) ;<br />
* soit dans votre répertoire Lazarus (pour la conception dans l'IDE) et dans le répertoire de destination où se trouve l'exécutable (pour exécuter le programme compilé).<br />
<br />
Si vous n'avez pas installé le serveur Firebird, une manière simple d'obtenir les DLLs du client est de télécharger Firebird Embedded 2.5 sur [http://www.firebirdsql.org/en/firebird-2-5/].<br />
Extrayez ces fichiers dans le répertoire de votre application :<br />
<syntaxhighlight lang="bash"><br />
fbclient.dll # uniquement si vous utilisez le serveur<br />
# ou<br />
fbembed.dll # uniquement si vous utilisez Firebird Embedded <br />
firebird.msg<br />
ib_util.dll<br />
icudt30.dll<br />
icuin30.dll<br />
icuuc30.dll<br />
Microsoft.VC80.CRT.manifest<br />
msvcp80.dll<br />
msvcr80.dll<br />
</syntaxhighlight><br />
Renommez fbembed.dll en fbclient.dll (le nom d'un client Firebird normal, client-serveur - c'est utile sur de plus anciennes versions de Lazarus). La DLL de Firebird Embedded peut également fonctionner comme un client Firebird normal.<br />
<br />
Assurez-vous que la base de données employee.fdb se trouve dans le répertoire de votre projet. Vous pouvez la copier depuis le répertoire examples/empbuild/ du serveur Firebird 2.5.<br />
<br />
Pour finir, compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et copiez les DLLs ainsi que la base de données employee.fdb dans ce répertoire.<br />
<br />
=== Bibliothèques de bases de données Firebird sur d'autres systèmes ===<br />
<br />
Sur Linux/OSX, vous aurez aussi besoin des bibliothèques partagées du client Firebird.<br />
Sur Linux, vous pouvez utiliser le gestionnaire de paquets de votre distribution pour récupérer les paquets du client Firebird ; par exemple, sur Debian :<br />
<syntaxhighlight lang="bash"><br />
aptitude install libfbclient2 firebird-dev # nous avons besoin de la version dev car FPC 2.6 et précédents chercheront libfbclient.so<br />
</syntaxhighlight><br />
<br />
== Firebird ou employee.fdb non installé ? ==<br />
<br />
Si la base de données d'exemple employee n'est pas installée, ou si vous utilisez une base de données différente, voici une version minimale de la table que nous utiliserons (note : vous trouverez ci-dessous des directives pour des bases de données spécifiques).<br />
<br />
=== Création automatique ===<br />
La méthode de configuration la plus simple est de créer une base de données vide sur votre système et de vous y connecter avec le programme utilitaire d'exemple TSQLScriptSample. <br />
Ce programme est inclus dans les versions de développement courantes de Lazarus, dans le répertoire <tt>./examples/database/tsqlscript</tt>, mais il peut également être téléchargé sur : http://svn.freepascal.org/svn/lazarus/trunk/examples/database/tsqlscript/<br />
<br />
Compilez et exécutez le programme, puis connectez-vous à la base de données :<br />
<br />
[[image:tsqlscriptsample connect.png]]<br />
<br />
Cliquez ensuite sur le bouton ''Copy table creation script'', et ''Run script'' :<br />
<br />
[[image:tsqlscriptsample runfirstscript.png]]<br />
<br />
Le programme doit normalement indiquer que l'opération est couronnée de succès.<br />
Faites à présent la même chose pour ''Copy sample data script'', et ''Run script''.<br />
<br />
En cas de problème, vous pouvez essayer les étapes manuelles ci-dessous.<br />
<br />
=== Création manuelle ===<br />
Nous allons créer les tables CUSTOMER et EMPLOYEE qui seront utilisées dans un prochain tutoriel.<br />
<br />
Exécutez ces commandes SQL dans votre éditeur/utilitaire de base de données :<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE CUSTOMER<br />
(<br />
CUST_NO INTEGER NOT NULL,<br />
CUSTOMER VARCHAR(25) NOT NULL,<br />
CITY VARCHAR(25),<br />
COUNTRY VARCHAR(15),<br />
CONSTRAINT CT_CUSTOMER_PK PRIMARY KEY (CUST_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="sql"><br />
CREATE TABLE EMPLOYEE<br />
(<br />
EMP_NO INTEGER NOT NULL,<br />
FIRST_NAME VARCHAR(15) NOT NULL,<br />
LAST_NAME VARCHAR(20) NOT NULL,<br />
PHONE_EXT VARCHAR(4),<br />
JOB_CODE VARCHAR(5) NOT NULL,<br />
JOB_GRADE INTEGER NOT NULL,<br />
JOB_COUNTRY VARCHAR(15) NOT NULL,<br />
SALARY NUMERIC(10,2) NOT NULL,<br />
CONSTRAINT CT_EMPLOYEE_PK PRIMARY KEY (EMP_NO)<br />
);<br />
</syntaxhighlight><br />
<br />
Quelques données pour pouvoir au moins montrer quelque chose... D'abord quelques clients :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (1, 'Michael Design', 'San Diego', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (2, 'VC Technologies', 'Dallas', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (3, 'Klämpfl, Van Canneyt', 'Boston', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (4, 'Felipe Bank', 'Manchester', 'England');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (5, 'Joost Systems, LTD.', 'Central Hong Kong', 'Hong Kong');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (6, 'Van der Voort Int.', 'Ottawa', 'Canada');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (7, 'Mrs. Mauvais', 'Pebble Beach', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (8, 'Asinine Vacation Rentals', 'Lihue', 'USA');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (9, 'Fax', 'Turtle Island', 'Fiji');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (10, 'FPC Corporation', 'Tokyo', 'Japan');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (11, 'Dynamic Intelligence Corp', 'Zurich', 'Switzerland');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (12, '3D-Pad Corp.', 'Paris', 'France');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (13, 'Swen Export, Ltd.', 'Milan', 'Italy');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (14, 'Graeme Consulting', 'Brussels', 'Belgium');<br />
INSERT INTO CUSTOMER (CUST_NO, CUSTOMER, CITY, COUNTRY) VALUES (15, 'Klenin Inc.', 'Den Haag', 'Netherlands');<br />
</syntaxhighlight><br />
<br />
Puis quelques employés :<br />
<syntaxhighlight lang="sql"><br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (1,'William','Shatner','1702','CEO',1,'USA',48000);<br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (2,'Ivan','Rzeszow','9802','Eng',2,'Russia',38000);<br />
INSERT INTO employee(emp_no, first_name, last_name, phone_ext, job_code, job_grade, <br />
job_country, salary)<br />
VALUES (3,'Erin','Powell','1703','Admin',2,'USA',45368);<br />
</syntaxhighlight><br />
<br />
Créez la base de données, les tables et insérez les données dans votre environnement de bases de données.<br />
<br />
== SQLite ==<br />
Si vous utilisez SQLite, vous pouvez créer la base de données mentionnée plus haut dans le répertoire de votre projet, en lançant l'exécutable SQLite :<br />
<syntaxhighlight lang="bash"><br />
sqlite employee.sqlite<br />
</syntaxhighlight><br />
Copiez et collez à présent les commandes CREATE TABLE et INSERT ci-avant.<br />
Pour tester si les bonnes données sont présentes, entrez cette requête :<br />
<syntaxhighlight lang="SQL"><br />
select * from customer;<br />
</syntaxhighlight><br />
Terminez votre session avec<br />
<syntaxhighlight lang="SQL"><br />
.quit<br />
</syntaxhighlight><br />
<br />
Un fichier appelé employee.sqlite devrait maintenant être créé dans le répertoire de votre projet.<br />
<br />
Assurez-vous que les DLL/so SQLite requises soient installées - par exemple, sur Windows, sqlite3.dll devrait être présent dans<br />
* votre répertoire Lazarus + projet de destination, ou<br />
* votre répertoire système.<br />
<br />
En outre, si vous avez une DLL SQLite 32 bits, assurez-vous d'avoir la version 32 bits de Lazarus.<br />
<br />
Compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et (sour Windows) copiez-y la DLL ainsi que la base de données employee.sqlite.<br />
<br />
== PostgreSQL ==<br />
Dans cette section, nous partons du principe que vous utilisez un serveur Linux et la console ; les étapes équivalentes peuvent être réalisées sous Windows et avec des outils GUI comme PGAdmin.<br />
<br />
Connectez-vous à votre serveur et basculez vers le compte PostgreSQL :<br />
<syntaxhighlight lang=bash><br />
su - postgres -c psql # démarrage immédiat de l'interpréteur SQL psql<br />
</syntaxhighlight><br />
<br />
Créez un utilisateur pour la base de données et pour les tables :<br />
<syntaxhighlight lang=SQL><br />
CREATE USER employee WITH PASSWORD 'hellopassword'; -- bien sûr, mettez un mot de passe à votre goût<br />
-- Quelque chose comme 'CREATE ROLE' devrait s'afficher pour indiquer le succès de l'opération.<br />
-- Pour changer ultérieurement le mot de passe, vous pouvez utiliser quelque chose comme<br />
-- alter user employee with password '<newpasswordhere>';<br />
<br />
-- Nous allons empêcher le mot de passe d'expirer ; si vous souhaitez plus de sécurité, passez cette étape :<br />
ALTER USER employee VALID UNTIL 'infinity'; -- le mot de passe n'expire jamais<br />
<br />
-- Nous allons encore un peu resserrer les choses :<br />
-- ne pas permettre à un utilisateur de créer une base de données ou d'autres utilisateurs :<br />
ALTER USER employee NOCREATEDB NOCREATEUSER; -- restreint la création d'objets<br />
-- Quelque chose comme 'ALTER ROLE' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Créons notre base de données :<br />
CREATE DATABASE employee;<br />
-- Quelque chose comme 'CREATE DATABASE' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Attribuons tous les privilèges sur la base de données employee à l'utilisateur employee :<br />
GRANT ALL PRIVILEGES ON DATABASE employee TO employee; -- attribue à l'utilisateur toutes les permissions sur la base de données<br />
-- Quelque chose comme 'GRANT' devrait s'afficher pour indiquer le succès de l'opération.<br />
<br />
-- Créons la table customer, utilisant un type de donnée serial - aka autonumber/autoincrement :<br />
CREATE TABLE customer<br />
(<br />
cust_no serial NOT NULL,<br />
customer character varying(25) NOT NULL,<br />
city character varying(25),<br />
country character varying(15),<br />
CONSTRAINT integ_60 PRIMARY KEY (cust_no)<br />
);<br />
<br />
-- Créons alors la table employee :<br />
CREATE TABLE EMPLOYEE<br />
(<br />
EMP_NO SERIAL NOT NULL,<br />
FIRST_NAME VARCHAR(15) NOT NULL,<br />
LAST_NAME VARCHAR(20) NOT NULL,<br />
PHONE_EXT VARCHAR(4),<br />
JOB_CODE VARCHAR(5) NOT NULL,<br />
JOB_GRADE INTEGER NOT NULL,<br />
JOB_COUNTRY VARCHAR(15) NOT NULL,<br />
SALARY NUMERIC(10,2) NOT NULL,<br />
CONSTRAINT CT_EMPLOYEE_PK PRIMARY KEY (EMP_NO)<br />
);<br />
<br />
-- À présent, copiez et collez les commandes INSERT de la section ci-dessus pour insérer les données.<br />
<br />
-- Pour tester si les bonnes données sont présentes, entrez cette requête :<br />
SELECT * FROM customer;<br />
-- Vous devriez voir quelques clients.<br />
<br />
-- Sortie de psql :<br />
\q <br />
</syntaxhighlight><br />
<br />
À présent, vous devriez être dans la console, connecté comme utilisateur Postgres.<br />
<br />
Si votre serveur est une autre machine que celle de développement, assurez-vous d'autoriser l'accès réseau à la base de données. Consultez votre documentation PostgreSQL pour les détails, mais quelque chose comme ceci devrait fonctionner :<br />
<syntaxhighlight lang=bash><br />
# Remplacez nano (p.ex. vim, emacs, joe...) et le numéro de version Postgres selon votre environnement<br />
nano /etc/postgresql/8.4/main/pg_hba.conf<br />
</syntaxhighlight><br />
<br />
Vérifiez la présence d'une ligne comme (remplacez 192.168.0.1 par votre propre adresse IP, ou range) :<br />
<syntaxhighlight lang="bash"><br />
# Permet l'accès depuis le réseau local, en utilisant des mots de passe crypyés en MD5 :<br />
host all all 192.168.0.1/24 md5<br />
</syntaxhighlight><br />
<br />
Ou, plus restrictif :<br />
<br />
<syntaxhighlight lang="bash"><br />
# Permet uniquement l'accès réseau à la base de données employee par l'utilisateur employee :<br />
host employee employee 192.168.0.1/24 md5<br />
</syntaxhighlight><br />
<br />
Si une telle ligne n'existe pas, ajoutez-la à la fin, enregistrez et fermez votre éditeur.<br />
Consultez la documentation PostgreSQL pour plus de détails.<br />
<br />
Rechargez les réglages PostgreSQL :<br />
<syntaxhighlight lang=bash> <br />
psql<br />
</syntaxhighlight><br />
puis<br />
<syntaxhighlight lang=SQL> <br />
SELECT pg_reload_conf(); -- recharge les réglages...<br />
-- ... et retourne au shell :<br />
\q<br />
</syntaxhighlight><br />
<br />
Testez la connexion à PostgreSQL.<br />
<br />
Note : par défaut, PostgreSQL essaie un login ident/unix domain socket qui n'autorise pas les mots de passe. Nous spécifions donc à l'hôte de forcer le login TCP/IP :<br />
<syntaxhighlight lang=bash><br />
psql -h 127.0.0.1 -d employee -U employee -W # Login via TCP/IP. Entrez votre mot de passe.<br />
</syntaxhighlight><br />
<br />
Assurez-vous que les DLL/so PostgreSQL et les autres bibliothèques requises soient installées - par exemple, sur Windows, elles devraient se trouver soit :<br />
* dans votre répertoire Lazarus + projet de destination, soit<br />
* dans votre répertoire système.<br />
<br />
Compilez votre projet une fois (même s'il est vide), pour créer le répertoire de destination, et (sur Windows) copiez-y les DLLs.<br />
<br />
== Fin ==<br />
Maintenant que vous avez configuré votre base de données, vous pouvez aller vers [[SQLdb Tutorial1|le premier "vrai" tutoriel]].<br />
<br />
== Voir aussi ==<br />
* [[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.<br />
* [[SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.<br />
* [[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.<br />
* [[SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les data modules.<br />
* [[Lazarus Database Overview]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.<br />
* [[SQLdb Package]] : Information sur le paquetage SQLdb.<br />
* [[SQLdb Programming Reference]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.<br />
* [[SqlDBHowto]] : Information sur l'utilisation du paquetage SQLdb.<br />
* [[Working With TSQLQuery]] : Information sur TSQLQuery.<br />
<br />
[[Category:Databases]]<br />
[[Category:Tutorials]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Programming_Reference/fr&diff=104514SQLdb Programming Reference/fr2016-10-15T14:45:06Z<p>Alcatiz: </p>
<hr />
<div>{{SQLdb Programming Reference}}<br />
[[category:Français]]<br />
<br />
{{Infobox databases}}<br />
==Documentation==<br />
Veuillez consulter la documentation officielle sur [http://www.freepascal.org/docs-html/fcl/sqldb/index.html SQLDB documentation]. <br />
<br />
Cet article va tenter de donner davantage de détails sur SQLdb ; toutefois, la documentation officielle fait autorité.<br />
<br />
==Structure des classes==<br />
Le diagramme suivant montre la hiérarchie et les liens entre les PRINCIPAUX composants entrant en jeu dans SQLdb. Il n'est certainement pas exhaustif ni n'utilise de structure "propre" de diagramme, donc ne pensez pas y trouver trop. J'espère qu'il vous aidera à trouver quels morceaux du code source vous devez aller scruter pour vraiment en comprendre le fonctionnement.<br />
<br />
[[Image:Laz SqlDB components.png]]<br />
<br />
====Notes====<br />
* Le lien de TDatabase vers TTransaction s'appelle Transactions ; c'est une liste, ce qui implique que plusieurs transactions sont possibles pour une base de données donnée. Toutefois, un nouveau lien est défini de TSQLConnection vers TSQLTransaction, qui est Transaction - une transaction unique par base de données. Cela ne cache pas réellement le lien précédent, mais seul le nouveau lien est publié et il est probablement déconseillé d'utiliser le lien de l'ancêtre.<br />
* Certains des liens hérités nécessitent d'être transtypés vers les nouveaux types pour être utilisables. Vous ne pouvez pas appeler SQLQuery.Transaction.Commit, puisque Commit est seulement définie dans TSQLTransaction. Appelez SQLTransaction.Commit, ou "(SQLQuery.Transaction as TSQLTransaction).Commit".<br />
<br />
==Interaction==<br />
===TConnection===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnection.html TSQLConnection documentation]<br />
<br />
Un [[TConnection]] représente une connexion vers une base de données SQL. <br />
Habituellement, vous utiliserez le descendant correspondant à une base de données spécifique (par exemple, TIBConnection pour Interbase/Firebird), mais il est possible d'utiliser TConnection si vous essayez d'écrire des applications indépendantes de toute base de données (note : il est probablement plus avisé d'utiliser [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnector.html TSQLConnector]).<br />
Dans cet objet, vous définissez les paramètres de connexion tels que nom d'hôte, nom d'utilisateur et mot de passe.<br />
Finalement, vous vous connectez ou déconnectez (en utilisant la propriété .Active ou .Connected).<br />
<br />
La plupart des bases de données permettent de multiples connexions du même programme/utilisateur.<br />
<br />
===TSQLTransaction===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqltransaction.html TSQLTransaction]<br />
<br />
Cet objet représente une transaction avec la base de données. En pratique, au moins une transaction doit être active pour une base de données, même si vous ne l'utilisez que pour y lire des données.<br />
Lorsque vous utilisez une transaction simple, affectez la propriété TConnection.Transaction à la transaction, pour définir la transaction par défaut pour la base de données ; la propriété TSQLTransaction.Database correspondante devrait alors pointer automatiquement vers la connexion.<br />
<br />
Le fait d'affecter à une [[TSQLTransaction]] .Active/calling .StartTransaction démarre une transaction ; l'appel de .Commit ou .RollBack exécute (sauve) ou ignore (oublie/annule) la transaction. Vous devriez les utiliser pour encadrer vos transactions avec la base de données, à moins que vous utilisiez .Autocommit ou CommitRetaining.<br />
<br />
===TSQLQuery===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlquery.html TSQLQuery documentation]<br />
<br />
Voir [[Working With TSQLQuery]] pour plus de détails.<br />
<br />
[[TSQLQuery]] est un objet qui contient un dataset issu d'une paire connexion/transaction, utilisant sa propriété SQL pour déterminer quelles données sont transférées de la base de données vers le dataset.<br />
<br />
Lorsque vous l'utilisez, vous devez donc spécifier au moins les propriétés transaction, connexion et SQL.<br />
Le TSQLQuery est un maillon important de la chaîne qui lie les contrôles à la base de données. La propriété SQL détermine quelle requête SELECT est exécutée envers la base de données pour recevoir les données.<br />
FPC essaiera de déterminer quelle commande SQL INSERT, UPDATE et DELETE correspondante doit être utilisée afin d'exécuter les modifications générées par l'utilisateur/programme.<br />
Si nécessaire, le programmeur peut régler cela finement et fixer manuellement les propriétés InsertSQL, UpdateSQL et DeleteSQL.<br />
<br />
===DataSource===<br />
Un objet [[TDataSource]] garde trace d'où les composants liés aux données se trouvent dans un dataset (comme TSQLQuery). <br />
Le programmeur doit spécifier l'objet TSQLQuery correspondant pour que cela fonctionne.<br />
<br />
===Contrôles liés aux données tels DBGrid===<br />
Ces contrôles doivent être liés à une DataSource. Ils possèdent souvent des propriétés indiquant quels champs de la DataSource ils affichent.<br />
<br />
==Data modules==<br />
Les [[Data module]]s peuvent être utilisés pour stocker des composants non visuels tels que '''T*Connection''', '''TSQLTransaction''', '''TSQLQuery''', etc. <br />
Les Data modules vous permettent également de partager des composants entre forms.<br />
<br />
Voir [[SQLdb Tutorial4]].<br />
<br />
[[Category:Databases]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Programming_Reference/fr&diff=104513SQLdb Programming Reference/fr2016-10-15T13:54:11Z<p>Alcatiz: </p>
<hr />
<div>{{SQLdb Programming Reference}}<br />
[[category:Français]]<br />
<br />
{{Infobox databases}}<br />
==Documentation==<br />
Veuillez consulter la documentation officielle sur [http://www.freepascal.org/docs-html/fcl/sqldb/index.html SQLDB documentation]. <br />
<br />
Cet article va tenter de donner davantage de détails sur SQLDb ; toutefois, la documentation officielle fait autorité.<br />
<br />
==Structure des classes==<br />
Le diagramme suivant montre la hiérarchie et les liens entre les PRINCIPAUX composants entrant en jeu dans SQLdb. Il n'est certainement pas exhaustif ni n'utilise de structure "propre" de diagramme, donc ne pensez pas y trouver trop. J'espère qu'il vous aidera à trouver quels morceaux du code source vous devez aller scruter pour vraiment en comprendre le fonctionnement.<br />
<br />
[[Image:Laz SqlDB components.png]]<br />
<br />
====Notes====<br />
* Le lien de TDatabase vers TTransaction s'appelle Transactions ; c'est une liste, ce qui implique que plusieurs transactions sont possibles pour une base de données donnée. Toutefois, un nouveau lien est défini de TSQLConnection vers TSQLTransaction, qui est Transaction - une transaction unique par base de données. Cela ne cache pas réellement le lien précédent, mais seul le nouveau lien est publié et il est probablement déconseillé d'utiliser le lien de l'ancêtre.<br />
* Certains des liens hérités nécessitent d'être transtypés vers les nouveaux types pour être utilisables. Vous ne pouvez pas appeler SQLQuery.Transaction.Commit, puisque Commit est seulement définie dans TSQLTransaction. Appelez SQLTransaction.Commit, ou "(SQLQuery.Transaction as TSQLTransaction).Commit".<br />
<br />
==Interaction==<br />
===TConnection===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnection.html TSQLConnection documentation]<br />
<br />
Un [[TConnection]] représente une connexion vers une base de données SQL. <br />
Habituellement, vous utiliserez le descendant correspondant à une base de données spécifique (par exemple, TIBConnection pour Interbase/Firebird), mais il est possible d'utiliser TConnection si vous essayez d'écrire des applications indépendantes de toute base de données (note : il est probablement plus avisé d'utiliser [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnector.html TSQLConnector]).<br />
Dans cet objet, vous définissez les paramètres de connexion tels que nom d'hôte, nom d'utilisateur et mot de passe.<br />
Finalement, vous vous connectez ou déconnectez (en utilisant la propriété .Active ou .Connected).<br />
<br />
La plupart des bases de données permettent de multiples connexions du même programme/utilisateur.<br />
<br />
===TSQLTransaction===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqltransaction.html TSQLTransaction]<br />
<br />
Cet objet représente une transaction avec la base de données. En pratique, au moins une transaction doit être active pour une base de données, même si vous ne l'utilisez que pour y lire des données.<br />
Lorsque vous utilisez une transaction simple, affectez la propriété TConnection.Transaction à la transaction, pour définir la transaction par défaut pour la base de données ; la propriété TSQLTransaction.Database correspondante devrait alors pointer automatiquement vers la connexion.<br />
<br />
Le fait d'affecter à une [[TSQLTransaction]] .Active/calling .StartTransaction démarre une transaction ; l'appel de .Commit ou .RollBack exécute (sauve) ou ignore (oublie/annule) la transaction. Vous devriez les utiliser pour encadrer vos transactions avec la base de données, à moins que vous utilisiez .Autocommit ou CommitRetaining.<br />
<br />
===TSQLQuery===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlquery.html TSQLQuery documentation]<br />
<br />
Voir [[Working With TSQLQuery]] pour plus de détails.<br />
<br />
[[TSQLQuery]] est un objet qui contient un dataset issu d'une paire connexion/transaction, utilisant sa propriété SQL pour déterminer quelles données sont transférées de la base de données vers le dataset.<br />
<br />
Lorsque vous l'utilisez, vous devez donc spécifier au moins les propriétés transaction, connexion et SQL.<br />
Le TSQLQuery est un maillon important de la chaîne qui lie les contrôles à la base de données. La propriété SQL détermine quelle requête SELECT est exécutée envers la base de données pour recevoir les données.<br />
FPC essaiera de déterminer quelle commande SQL INSERT, UPDATE et DELETE correspondante doit être utilisée afin d'exécuter les modifications générées par l'utilisateur/programme.<br />
Si nécessaire, le programmeur peut régler cela finement et fixer manuellement les propriétés InsertSQL, UpdateSQL et DeleteSQL.<br />
<br />
===DataSource===<br />
Un objet [[TDataSource]] garde trace d'où les composants liés aux données se trouvent dans un dataset (comme TSQLQuery). <br />
Le programmeur doit spécifier l'objet TSQLQuery correspondant pour que cela fonctionne.<br />
<br />
===Contrôles liés aux données tels DBGrid===<br />
Ces contrôles doivent être liés à une DataSource. Ils possèdent souvent des propriétés indiquant quels champs de la DataSource ils affichent.<br />
<br />
==Data modules==<br />
Les [[Data module]]s peuvent être utilisés pour stocker des composants non visuels tels que '''T*Connection''', '''TSQLTransaction''', '''TSQLQuery''', etc. <br />
Les Data modules vous permettent également de partager des composants entre forms.<br />
<br />
Voir [[SQLdb Tutorial4]].<br />
<br />
[[Category:Databases]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=SQLdb_Programming_Reference/fr&diff=104512SQLdb Programming Reference/fr2016-10-15T13:49:39Z<p>Alcatiz: Created page with "{{SQLdb Programming Reference/FR}} {{Infobox databases}} ==Documentation== Veuillez consulter la documentation officielle sur [http://www.freepascal.org/docs-html/fcl/sqldb/i..."</p>
<hr />
<div>{{SQLdb Programming Reference/FR}}<br />
<br />
{{Infobox databases}}<br />
==Documentation==<br />
Veuillez consulter la documentation officielle sur [http://www.freepascal.org/docs-html/fcl/sqldb/index.html SQLDB documentation]. <br />
<br />
Cet article va tenter de donner davantage de détails sur SQLDb ; toutefois, la documentation officielle fait autorité.<br />
<br />
==Structure des classes==<br />
Le diagramme suivant montre la hiérarchie et les liens entre les PRINCIPAUX composants entrant en jeu dans SQLdb. Il n'est certainement pas exhaustif ni n'utilise de structure "propre" de diagramme, donc ne pensez pas y trouver trop. J'espère qu'il vous aidera à trouver quels morceaux du code source vous devez aller scruter pour vraiment en comprendre le fonctionnement.<br />
<br />
[[Image:Laz SqlDB components.png]]<br />
<br />
====Notes====<br />
* Le lien de TDatabase vers TTransaction s'appelle Transactions ; c'est une liste, ce qui implique que plusieurs transactions sont possibles pour une base de données donnée. Toutefois, un nouveau lien est défini de TSQLConnection vers TSQLTransaction, qui est Transaction - une transaction unique par base de données. Cela ne cache pas réellement le lien précédent, mais seul le nouveau lien est publié et il est probablement déconseillé d'utiliser le lien de l'ancêtre.<br />
* Certains des liens hérités nécessitent d'être transtypés vers les nouveaux types pour être utilisables. Vous ne pouvez pas appeler SQLQuery.Transaction.Commit, puisque Commit est seulement définie dans TSQLTransaction. Appelez SQLTransaction.Commit, ou "(SQLQuery.Transaction as TSQLTransaction).Commit".<br />
<br />
==Interaction==<br />
===TConnection===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnection.html TSQLConnection documentation]<br />
<br />
Un [[TConnection]] représente une connexion vers une base de données SQL. <br />
Habituellement, vous utiliserez le descendant correspondant à une base de données spécifique (par exemple, TIBConnection pour Interbase/Firebird), mais il est possible d'utiliser TConnection si vous essayez d'écrire des applications indépendantes de toute base de données (note : il est probablement plus avisé d'utiliser [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnector.html TSQLConnector]).<br />
Dans cet objet, vous définissez les paramètres de connexion tels que nom d'hôte, nom d'utilisateur et mot de passe.<br />
Finalement, vous vous connectez ou déconnectez (en utilisant la propriété .Active ou .Connected).<br />
<br />
La plupart des bases de données permettent de multiples connexions du même programme/utilisateur.<br />
<br />
===TSQLTransaction===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqltransaction.html TSQLTransaction]<br />
<br />
Cet objet représente une transaction avec la base de données. En pratique, au moins une transaction doit être active pour une base de données, même si vous ne l'utilisez que pour y lire des données.<br />
Lorsque vous utilisez une transaction simple, affectez la propriété TConnection.Transaction à la transaction, pour définir la transaction par défaut pour la base de données ; la propriété TSQLTransaction.Database correspondante devrait alors pointer automatiquement vers la connexion.<br />
<br />
Le fait d'affecter à une [[TSQLTransaction]] .Active/calling .StartTransaction démarre une transaction ; l'appel de .Commit ou .RollBack exécute (sauve) ou ignore (oublie/annule) la transaction. Vous devriez les utiliser pour encadrer vos transactions avec la base de données, à moins que vous utilisiez .Autocommit ou CommitRetaining.<br />
<br />
===TSQLQuery===<br />
Documentation : [http://www.freepascal.org/docs-html/fcl/sqldb/tsqlquery.html TSQLQuery documentation]<br />
<br />
Voir [[Working With TSQLQuery]] pour plus de détails.<br />
<br />
[[TSQLQuery]] est un objet qui contient un dataset issu d'une paire connexion/transaction, utilisant sa propriété SQL pour déterminer quelles données sont transférées de la base de données vers le dataset.<br />
<br />
Lorsque vous l'utilisez, vous devez donc spécifier au moins les propriétés transaction, connexion et SQL.<br />
Le TSQLQuery est un maillon important de la chaîne qui lie les contrôles à la base de données. La propriété SQL détermine quelle requête SELECT est exécutée envers la base de données pour recevoir les données.<br />
FPC essaiera de déterminer quelle commande SQL INSERT, UPDATE et DELETE correspondante doit être utilisée afin d'exécuter les modifications générées par l'utilisateur/programme.<br />
Si nécessaire, le programmeur peut régler cela finement et fixer manuellement les propriétés InsertSQL, UpdateSQL et DeleteSQL.<br />
<br />
===DataSource===<br />
Un objet [[TDataSource]] garde trace d'où les composants liés aux données se trouvent dans un dataset (comme TSQLQuery). <br />
Le programmeur doit spécifier l'objet TSQLQuery correspondant pour que cela fonctionne.<br />
<br />
===Contrôles liés aux données tels DBGrid===<br />
Ces contrôles doivent être liés à une DataSource. Ils possèdent souvent des propriétés indiquant quels champs de la DataSource ils affichent.<br />
<br />
==Data modules==<br />
Les [[Data module]]s peuvent être utilisés pour stocker des composants non visuels tels que '''T*Connection''', '''TSQLTransaction''', '''TSQLQuery''', etc. <br />
Les Data modules vous permettent également de partager des composants entre forms.<br />
<br />
Voir [[SQLdb Tutorial4]].<br />
<br />
[[Category:Databases]]<br />
[[Category:Lazarus]]</div>Alcatizhttps://wiki.freepascal.org/index.php?title=Code_Conversion_Guide/fr&diff=36932Code Conversion Guide/fr2009-07-19T13:59:31Z<p>Alcatiz: /* Où trouver le code pour convertir */</p>
<hr />
<div>{{Code Conversion Guide}}<br />
<br />
Cette page traite de la façon de convertir le code existant en Delphi ou Kylix pour fonctionner avec le compilateur [[Free Pascal]] et l'IDE Lazarus. Bien que Lazarus et le compilateur Free Pascal ont des aspects en commun avec Delphi et Kylix, ce ne sont pas des clones. Il y a un certain nombre de différences de convention et d'appel de bibliothèque ... et dans quelques secteurs , FPC est amélioré et peut être plus exigeant sur une syntaxe correcte . Veuillez voir le guide [[Lazarus For Delphi Users]] pour une description de quelques unes des différences fonctionnelles . <br />
<br />
Le but de ce guide est de documenter certaines des différences spécifiques qui sont fréquemment rencontrées pendant le processus de conversion de code en traduisant le code existant de Delphi à Lazarus.<br />
<br />
Ce document a été placé dans la base de connaissance du wiki ainsi il pourrait être facilement complété par n'importe qui qui avait rencontré un problème unique et voudrait le signaler pour que d'autres s'en rendent compte.<br />
<br />
== Choix d'un composant ou d'une bibliothèque pour la conversion ==<br />
<br />
=== Où trouver le code pour convertir ===<br />
<br />
Il y a beaucoup de code disponible sur le net qui peut être converti pour être utilisé par FPC et Lazarus . Voici une [[Page Of Code Sites/fr|Page de sites avec du code]] qui est juste un début. S'il vous plaît, complétez-le si vous connaissez d'autres bonnes adresses. TurboPower Software a récemment réalisé son offre commerciale entièrement sous MPL (Licence publique de Mozilla). Une liste de paquets disponibles peut être trouvée [http://sourceforge.net/users/tpsfadmin/ ici ].<br />
<br />
Pour éviter un double effort, les paquets qui ont été déjà convertis sont listés sur la page [[Components and Code examples/fr|composants et Exemples de code ]]. Si vous avez converti un paquet ou travaillez sur un, veuillez ajouter une note sur la page [[Current conversion projects/fr|Projets en cours de conversion ]].<br />
<br />
=== Autorisation ===<br />
<br />
Il existe des licences depuis le Freeware (domaine public) jusqu’à des versions plus restrictives interdisant toute modification, redistribution ou usage commercial. Avant d’entreprendre toute conversion, il est nécessaire d’examiner les droits attachés au code. Le type de la licence de protection est essentiel lorsque l’on colle sur une Form un composant imposant des droits incompatibles avec l’ensemble de l’application concernée. <br />
<br />
Lors de la traduction de composants, respectez les souhaits de l’auteur et conservez les copyrights et les entêtes des licences avec les adresses E-mail et les url. De même, il souhaitable d'informer l'auteur que ses composants sont en cours de conversion ... Surtout si le composant est sous une License restrictive. Dans le cas de composants oubliés et plus exploités, les auteurs révisent souvent les droits associés.<br />
<br />
Généralement le domaine public (Freeware) et le LGPL/MPL sont les plus souples pour la diffusion de composants. Pour obtenir plus d’information concernant la[Définition Open Source http://www.opensource.org/docs/definition.php] est un bon commencement. Vous trouverez aussi d’autres types de licences et leur impact sur le code y étant attaché.<br />
<br />
=== Dépendances ===<br />
<br />
Une autre étape avant de commencer à travailler sur une conversion est vérifier que le code n'a pas des dépendances profondes avec d'autres paquets qui pourraient ne pas être disponibles ou qui représente un défi considérable de conversion . Quelques offres de freeware sont liées à ou bien prolongent les paquets propriétaires qui ne sont fréquemment plus disponible ou viennent avec des licences inadéquates .<br />
<br />
=== Problèmes liés au Compilateur ===<br />
<br />
Voir :<br />
* [http://www.freepascal.org/probs.html Problèmes connus]<br />
* [http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed Bogues non résolus]<br />
<br />
=== Questions sur l'OS et de plate-forme ===<br />
<br />
Lazarus et le compilateur Free Pascal sont des outils de developpement multi plate-forme et multi-architecture. En revanche , la plupart du code existant Delphi a été spécifiquement conçu pour fonctionner sur un processeur Intel sous Win32 . Si votre composant candidat a beaucoup de code spécifique Win32 , il pourrait être sage d'essayer et de trouver une plateforme alternative . Mais ne laissez pas ceci vous stopper... c'est véritablement étonnant ce que la LCL supporte!<br />
<br />
== Faire la conversion ==<br />
<br />
=== Paramétrer l'environnement de Lazarus pour un projet de conversion ===<br />
<br />
====Créer un projet test====<br />
* Placer le code à convertir dans un sous-répertoire (par exemple: convertdir)<br />
* Lancer Lazarus<br />
* Fichier->Tout Enregistrer vers le sous-répertoire convertdir. Les noms significatifs pour le Projet et l'unité par défaut sont optionnels.<br />
* Ouvrir l'unité « principale » à convertir dans convertdir<br />
* L'ajouter au projet : Projet->Ajouter le fichier de l'éditeur au Projet<br />
* Lancer Outils->Vérification rapide de la syntaxe ou lancer Executer->Construire Tout pour commencer .<br />
<br />
====Choses initiales à regarder====<br />
* Les noms de fichier sont sensibles à la casse avec les versions de compileurs 1.0.x . Si vous travaillez avec cette version , faire que tout vos noms de fichiers soient en minuscule. Vous obtiendrez les erreurs "fichiers non trouvées" si vous ne le faites pas .<br />
<br />
====Sources Delphi VCL, Kylix CLX dans Lazarus====<br />
<br />
En convertissant des sources Delphi/Kylix, il est souvent utile de trouver des déclarations pour voir , ce qu'une fonction spécifique fait. L'IDE Lazarus peut analyser les sources Delphi/Kylix. Pour faire ceci il en a besoin de quelques chemins de recherche et paramètres du compilateur. Vous pouvez facilement paramétrer ceci dans Configuration->Editeur des directives des outils de code...->Inserer un modèle<br />
<br />
=== Problèmes de conversion et solutions ===<br />
<br />
==== Fichier Delphi / Kylix équivalents dans Lazarus ====<br />
{|border="1" width="800" <br />
! Delphi / Kylix !! Description !! Lazarus !! Description<br />
|- <br />
|valign="top"| .pas<br />
<br />
.dfm/.xfm,<br />
<br />
.dcu/.dpu,<br />
<br />
.dpr(main project file),<br />
<br />
.res,<br />
<br />
.dof/.kof<br />
<br />
---<br />
<br />
---<br />
<br />
---<br />
<br />
|valign="top"| Delphi Source File,<br />
Delphi Form,<br />
<br />
Delphi Compiled Unit,<br />
<br />
Delphi Project,<br />
<br />
Windows Resource File,<br />
<br />
Delphi Option File<br />
<br />
|valign="top"| .pas, .pp<br />
.lfm,<br />
<br />
.o,<br />
<br />
.lpr<br />
<br />
---<br />
<br />
---<br />
<br />
.lrs,<br />
<br />
.lpi(main project file),<br />
<br />
.ppu<br />
<br />
|valign="top"| Pascal unit file,<br />
<br />
Form data file,<br />
<br />
Compiled unit file,<br />
<br />
Project file,<br />
<br />
Resource file,<br />
<br />
Project options file,<br />
<br />
Lazarus resource file,<br />
<br />
Lazarus project information file,<br />
<br />
FPC unit description file<br />
|}<br />
<br />
==== Convertir les projets/fiches/unités Delphi vers Lazarus ====<br />
<br />
Renommez ou copiez le fichier .dpr vers un fichier .lpr. Mettre en commentaire ou enlevez la directive {$R *.res} et ajouter une directive {$mode delphi}{$H+} ou {$mode objfpc}{$H+} au fichier .lpr. L'IDE Lazarus peut vous assister dans cette conversion à travers l'item du menu outils "Convertir un projet Delphi en projet Lazarus...". Il demande un fichier .dpr (projet Delphi) et le convertit en .lpr; en outre, il crée le fichier .lpi et convertis toutes les unités .<br />
<br />
Beaucoup de fiches existantes de Delphi peuvent être converties pour fonctionner avec Lazarus en employant le convertisseur de fiche .dfm vers .lfm intégré de l'IDE. Il peut être trouvé sous le menu outils à l'item "Convertir un fichier DFM en LFM...". Faire appel à la boite de dialogue fichier, sélectionnez le(s) fichier(s) dfm et le convertisseur fera le reste .<br />
<br />
Si vous devez convertir l'unité entière (avec ou sans une fiche), Lazarus inclut également un item intégré "Convertir une unité Delphi en unité Lazarus..." qui fera ce qui suit pour vous -<br />
<br />
# fixe le cas des noms de fichier include et des sections uses.<br />
# converti les fichiers .dfm vers les fichiers .lfm (actuellement sans contrôler le contenu, juste le format)<br />
# crée un fichier vide .lrs (le contenu sera créé plus tard )<br />
# Ajoute la directive {$mode delphi}<br />
# Remplace l'unité windows par LCLIntf<br />
# Ajoute l'unité LResources si nécessaire (c.-à-d. , si l'unité .lrs doit être utilisée; uses LResources peut être dans la partie implémentation )<br />
# Enlève l'unité de variantes <br />
# Enlève la directive {$R *.dfm}<br />
# Ajoute la section d'initialisation et la directive {$i unit.lrs}<br />
<br />
Ceci permet la conversion rapide et facile de la plupart des unités du format Delphi au format Lazarus. Il ne fait aucun contrôle de validité, ou changements automatiques de syntaxe, aussi tout les changements de syntaxe que vous devez faire, les changements additionnels d'unité/de nom d'unité, ou les changements de fichier dfm/pas pour les contrôles/les différences de composants, doivent toujours être fait manuellement, bien que dans le temps quelques assistants(wizards) facilitant une partie de ceci, particulièrement la réparation des fiches converties(lfm), puissent devenir disponible .<br />
<br />
==== Choix du bon mode du compilateur ====<br />
<br />
Le compilateur [[Free Pascal/fr|Free Pascal]] supporte 5 modes Pascal différents. Par exemple TP pour turbo pascal, vous laisse compiler des unités en turbo pascal. Il y a également un mode de compatibilité DELPHI qui peut être choisi pour rendre le code existant plus facile à convertir. Lazarus préfère le mode OBJFPC, qui est presque égal au mode DELPHI, mais est moins ambigu que la syntaxe de Delphi. Voici les points importants :<br />
<br />
Le mode peut être choisi en ligne de commande ou au début de la source . Employer la ligne de commande a l'avantage , que vous n'avez pas besoin de changer la source, mais l'inconvénient , que les autres doivent être renseignés .<br />
<br />
La plupart des unités Delphi peuvent être compilées par le compilateur [[Free Pascal/fr|Free Pascal]] en ajoutant <br />
{$IFDEF FPC}<br />
{$MODE DELPHI}<br />
{$ENDIF}<br />
juste après le nom de l'unité .<br />
<br />
Pour plus de détails à propos des modes de [[Free Pascal/fr|Free Pascal]] voir la [http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html Documentation de Free Pascal]<br />
<br />
==== Considérations sur les logiciels multiplate-formes ====<br />
<br />
* L'assembleur inline est toujours un problème parce qu'il liera le code à l'architecture Intel. Quelques développeurs font des prototypes d'algorithme en Pascal et utilisent la directive IFDEF avec leur assembleur optimisé. Heureusement TurboPower a fait ceci dans de nombreux endroits avec leur code . Si c'est le cas avec le paquet que vous convertissez , remettez la directive sur Pascal.<br />
* Ne pas mettre en référence des endroits de mémoire spécifique comme le secteur de données du BIOS. Découvrez ce dont le code a besoin et essayez de trouver une alternative multiplate-forme .<br />
* Ne pas faire les tours spécifiques du processeur (comme employer le compteur temporel d'Intel (time stamp counter)) sans insérer votre code dans une directive IFDEF pour la plate-forme que le code nécessite ... et fournissant une alternative pour des environnements qui n'ont pas les possibilités matérielles .<br />
* Si vous avez besoin de quelque code spécifique au système d'exploitation(OS) , alors vous pouvez employer la directive IFDEF. Voir ci-dessous pour une liste des macros .<br />
<br />
==== Les variables utiles pour le compilateur ====<br />
<br />
Pour écrire du code, qui se comporte sur divers systèmes différemment, vous pouvez employer les directives {$IFDEF Name}.<br />
<br />
* {$IfDef LCL} <br />
Cette variable est définie en utilisant le paquet LCL. Utile pour écrire du code qui fonctionne avec la bibliothèque LCL et Delphi.<br />
* {$IfDef LCLGtk}, {$IfDef LCLWin32}, {$IfDef LCLQt}, ...<br />
Cette variable est définie en utilisant le paquet LCL et le jeux de composants spécifique est actuellement employé. Utile pour écrire du code qui fonctionne avec la bibliothèque LCL sur une plate-forme spécifique.<br />
* {$IfDef FPC}<br />
Cette variable est définie, en utilisant le compilateur FPC. Utile pour écrire du code, qui fonctionne avec FPC et Delphi.<br />
* {$IfDef Unix}, {$IfDef Win32}, ...<br />
Défini par FPC pour le système d'exploitation cible courant. Delphi définit "Linux", "Win32" et "MSWindows". [[Free Pascal/fr|Free Pascal]] s'exécute sur beaucoup plus de plate-formes et ainsi on lui recommande d'employer l'item le plus courant. Par exemple "Unix" est défini pour Linux, FreeBSD, NetBSD et OpenBSD, là où Lazarus s'exécute déjà .<br />
Utilisez <br />
{$IfDef Linux}<br />
{$Define Unix}<br />
{$EndIf}<br />
pour travailler autour de ceci pour Kylix .<br />
<br />
Pour plus de détails voir la [http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21 Documentation de Free Pascal].<br />
'''Texte gras'''<br />
<br />
==== Trouver un identificateur manquant ====<br />
<br />
Il y a des différences dans la façon dont la bibliothèque LCL est organisée en comparaison avec la bibliothèque VCL de Delphi . Si vous obtenez une erreur "not found" du compilateur au sujet d'une classe ou d'un identificateur important, les chances sont bonnes qu'il/elle soit dans une unité différente. Une correspondance complète peut être trouvée en utilisant la commande grep avec le sous répertoire lazarus/docs/xml ou lcl.<br />
<br />
Par exemple la classe tbutton utilisée généralement donne typiquement une erreur dans le code Delphi parce qu'il est placé dans une unité appelée buttons.pp. La commande suivante trouve l'unité correcte très rapidement (dans le répertoire source de Lazarus ):<br />
<br />
grep -in ' tbutton =' lcl/*<br />
<br />
==== Différences principales d'unité entre Lazarus et Delphi ====<br />
<br />
'''Please add to this topic!'''<br />
<br />
* Windows->Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)<br />
<br />
Comme la bibliothèque LCL n'est pas spécifique dédiée windows, le code qui est dans l'unité Windows de Delphi pour accéder directement à l'API Win32, est placé dans des interfaces distinctes, lequel se situe dans l'unité LCLIntf. Gardez à l'esprit que Lazarus n'émule pas win32. Beaucoup de fonctions sont absentes et certaines ne fonctionnent pas comme leur homologues win32 . Ces fonctions existent seulement pour la compatibilité avec Delphi et devrait seulement être employées pour un portage rapide. la bibliothèque LCL modifie plusieurs des types , ainsi souvent LCLType, et parfois VCLGlobals sont exigés . LCLProc contient également quelques fonctions ce qui peut être utile pour la manipulation de plus bas niveau comme "FreeThenNil", comme c'est le cas dans Delphi 5 (et plus). Utilisez "DeleteAmpersands" pour enlever des esperluètes additionnelles d'une chaîne de caractère pour les contrôles(& contre && etc). L'unité interfaces doit être incluse dans le fichier .lpr pour initialiser les jeux de composants graphiques appropriés .<br />
<br />
* Messages->LMessages<br />
<br />
Les messages Tcontrol des evenements callback de win32 au format WM_CALLBACK et leurs structures associées sont généralement situés dans DELPHI dans l’unité Messages. Dans la LCL ce type de messages et leurs structures se trouvent dans Lmessages, avec en général le changement de « WM » en « LM ». Par exemple WM_MOUSEENTER devient LM_MOUSEENTER et TWMMouse devient TLMMouse.<br />
<br />
* Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls<br />
<br />
Afin de simplifier les référencements multiples et circulaires d’unités quelques nouveaux types ont été définis dans une unité appelée GraphType regroupant des éléments qui, dans Delphi, sont placés dans Graphics ou Controls (par exemple le BvNone des Panels). Vous aurez donc parfois à l’utiliser. De même, GraphMath est une autre unité, qui bien qu’incompatible avec Delphi inclue d’autres fonctionnalités utiles. Elle prend en compte la précision TfloatPoint, diverses routines de Beziers, les lignes, les arcs, la surcharge d’opérateur telle que Point1=Point2+Point3 et la comparaison de Trects : <br />
If (Rect1=Rect2) then …<br />
<br />
* Mask->MaskEdit<br />
<br />
Afin de la nommer plus intelligement l’unité des TmaskEdit est nommée [MaskEdit] au lieu du nébuleux Mask de beaucoup de versions de Delphi.<br />
<br />
* StdCtrls->StdCtrls,Buttons<br />
<br />
Dans beancoup de versions de Delphi, Tbutton est situé dans StdCtrls, alors que TspeedButton et TbitBtn sont dans Buttons. Plus simplement, la LCL place tous les types de boutons dans Buttons, ce qui peut occasionnellement interrompre la traduction du code. Il est donc préférable de l’inclure systématiquement.<br />
<br />
==== Différences des Propriétés et methodes entre Delphi et FPC/LCL ====<br />
* TBitmap inclu un Canvas dans la LCL<br />
<br />
====Différence sémentique====<br />
<br />
=====Ordre d'évaluation des paramètres=====<br />
<br />
Delphi garantit que tous les paramètres sont évalués de la gauche vers la droite. FPC ne présente pas cette garantie et peut evaluer les paramètres dans n’importe quel ordre afin de générer un code optimal.<br />
<br />
=====Nested procedures/functions as procedural variables=====<br />
<br />
Delphi passes the framepointer of the parent procedure always on the stack, and has the caller remove it again. This means that as long as you do not access variables from a parent procedure, you can pass the address of a nested function to another function which then can call it like any other procedural variable.<br />
<br />
FPC on the other hand always passes the framepointer of the parent procedure as a hidden first parameter according to the current calling convention, which means that if you call a nested procedure like a regular procedural variable, all parameters will be "shifted" one position.<br />
<br />
In short, do not call nested procedures via procedural variables.<br />
<br />
==== différence de syntaxe====<br />
<br />
'''Please add to this topic!'''<br />
<br />
A cause de restrictions propres à FPC, des changements de synthaxe sont nécessaires.<br />
La directive {$Mode Delphi} autorise, comme Delphi, moins de rigueur. Aussi adaptez votre règles synthaxiques avec {$Mode ObjFPC} au plus vite, même si le code doit être partagé par Delphi et LCL. Certaines sont simplement de meilleurs pratiques<br />
<br />
<br />
<br />
=====When assigning an event handling entry point, prefix it with an "@"=====<br />
<br />
For instance, you might assign a button callback manually <br />
<br />
{| border="1" width="800"<br />
! Delphi !! FPC<br />
|-<br />
|<delphi><br />
begin<br />
if not Assigned(MyButton.OnClick) then <br />
MyButton.OnClick:= SomeFunction;<br />
//@ not required<br />
//more code...<br />
end;<br />
</delphi><br />
|<delphi><br />
begin<br />
if not Assigned(MyButton.OnClick) then<br />
MyButton.OnClick:= @SomeFunction;<br />
//@ IS required<br />
//more code...<br />
end;<br />
</delphi><br />
|}<br />
<br />
=====When calling a procedure variable use this syntax: theprocname()=====<br />
<br />
In Delphi there is no difference between a function result and a variable, however there is in FPC, so to call a function, even if it has no parameters, you must append parenthesis. For Example -<br />
<br />
<br />
{| border="1" width="800"<br />
! Delphi !! FPC<br />
|-<br />
|<delphi><br />
With (SomeObject) do <br />
begin<br />
If Assigned(OnMyCallback) then<br />
OnMyCallback;<br />
//parenthesis not required<br />
end;<br />
</delphi><br />
|<delphi><br />
With (SomeObject) do <br />
begin<br />
If Assigned(OnMyCallback) then<br />
OnMyCallback();<br />
//parenthesis required<br />
end;<br />
</delphi><br />
|}<br />
<br />
=====Pointeur de record=====<br />
<br />
Dans Delphi , lorqu’on tente d’acceder aux membres d’un Record, il n’est pas necessaire de faire la différence entre le pointeur du Record et le Record lui-même. FPC fait la distinction :<br />
<br />
<br />
{| border="1" width="800"<br />
! Delphi !! FPC<br />
|-<br />
|<delphi><br />
Function GetSomeValue(ARecord: PMyRecord):Integer;<br />
begin<br />
If Assigned(ARecord) then<br />
Result:=ARecord.SomeValue<br />
else<br />
Result:=0;<br />
end;<br />
</delphi><br />
|<delphi><br />
Function GetSomeValue(ARecord: PMyRecord):Integer;<br />
begin<br />
If Assigned(ARecord) then<br />
Result:=ARecord^.SomeValue<br />
else<br />
Result:=0;<br />
end;<br />
</delphi><br />
|}<br />
<br />
=====Des parenthèses pour acceder aux chars d'une propriété string d'un objet =====<br />
<br />
Il est possible avec Delphi de traiter les propriétés commes des variables, meme pour acceder directement aux valeurs particulières des Char d’un String. C’est impossible avec FPC, notamment lorsque des propriétés sont indexées (traitées comme des tableaux). Dans ce cas, la propriété appelée doit être comprise dans des parenthèses. Même ce n’est pas toujour le cas il est préférable de s’y astreindre systématiquement. Exemple :<br />
<br />
{| border="1" width="800"<br />
! Delphi !! FPC<br />
|-<br />
|<delphi><br />
Type TSomeComponent=class(TComponent)<br />
//More code...<br />
Published<br />
Property MyString:String index 3 read GetMyString;<br />
//More code...<br />
End;<br />
<br />
var<br />
MyChar:char;<br />
begin<br />
If Length(MyString)>2 then<br />
//no parenthesis needed<br />
MyChar:= MyString[3];<br />
//More code...<br />
end;<br />
</delphi><br />
|<delphi><br />
Type TSomeComponent=class(TComponent)<br />
//More code...<br />
Published<br />
Property MyString:String index 3 read GetMyString;<br />
//More code...<br />
End;<br />
<br />
var<br />
MyChar:char;<br />
begin<br />
If Length(MyString)>2 then<br />
//parenthesis sometimes needed<br />
MyChar:= (MyString)[3];<br />
//More code...<br />
end;<br />
</delphi><br />
|}<br />
<br />
===== Ne confondez pas le pointeur et ce qui est pointé=====<br />
<br />
Parfois dans Delphi vous pouvez obtenir un pointeur, adressant un objet avec une valeur nule. Alors que ce type de situation semble complexe, c’est tres souvant le cas dans les grands paquets de composants afin de réduire les imbrications d’objets de différentes unités.Il est donc possible dans Delphi d’envoyer un pointeur nul à une fonction attendant un objet, sans se soucier du type d’objet associé au pointeur. En FPC vous ne devez pas confondre l’objet et son pointeur. Exemple :<br />
<br />
For example -<br />
{| border="1" width="800"<br />
! Delphi !! FPC<br />
|-<br />
|<delphi><br />
Unit 1<br />
Type <br />
TSomeObject=class(TComponent)<br />
//More code...<br />
End;<br />
<br />
Procedure DoSomething(Value: TSomeObject);<br />
Function GetSomeObject: TSomeObject;<br />
<br />
Unit 2<br />
Type <br />
TSomeComponent=class(TComponent)<br />
//More code...<br />
Published SomeObject: Pointer;<br />
//More code...<br />
End;<br />
<br />
Application<br />
var <br />
MyComponent: TSomeComponent;<br />
begin<br />
MyComponent.SomeObject:=GetSomeObject;<br />
//More code...<br />
DoSomething(MyComponent.SomeObject);<br />
end;<br />
</delphi><br />
|<delphi><br />
Unit 1<br />
Type <br />
TSomeObject=class(TComponent)<br />
//More code...<br />
End;<br />
<br />
Procedure DoSomething(Value: TSomeObject);<br />
Function GetSomeObject: TSomeObject;<br />
<br />
Unit 2<br />
Type TSomeComponent=class(TComponent)<br />
//More code...<br />
Published SomeObject: Pointer;<br />
//More code...<br />
End;<br />
<br />
Application<br />
var <br />
MyComponent: TSomeComponent;<br />
begin<br />
MyComponent.SomeObject:=Pointer(GetSomeObject);<br />
//More code...<br />
DoSomething(TSomeObject(MyComponent.SomeObject));<br />
end;<br />
</delphi><br />
|}<br />
<br />
==== Resources ====<br />
<br />
Delphi resource files are win32 specific and not compatible with Lazarus, so you'll have to recreate and compile them using the lazres. Lazres can be found in the lazarus/tools subdirectory. If you've downloaded the Lazarus sources, you'll need to compile it first.<br />
* cd lazarus/tools<br />
* make install<br />
To add a resource to your application:<br />
* lazres myresource.lrs mypix.xpm anotherpix.xpm<br />
* Add the LResources unit to your Uses clause<br />
* Include the .lrs file you created under the initialization block<br />
Example:<br />
<br />
<delphi><br />
function TForm1.LoadGlyph(const GlyphName: String): TBitMap;<br />
begin<br />
Result:= TPixmap.Create;<br />
Result.LoadFromLazarusResource(GlyphName);<br />
end;<br />
//More code...<br />
begin<br />
Speedbutton1.glyph:= LoadGlyph('mypix');<br />
//More code...<br />
end;<br />
<br />
initialization<br />
{$I unit1.lrs}<br />
{$I myresource.lrs}<br />
end.<br />
</delphi><br />
<br />
===Another method to convert a Delphi or Kylix project to Lazarus===<br />
<br />
* Rename or copy all .dfm or .xfm files to .lfm (Early Delphi versions do not produce a text-based .dfm file. The convert utility, if present in the \bin folder can be used to covert the .dfm first))<br />
* Rename or copy .dpr file to .lpr<br />
* Make necessary changes to .lpr file:<br />
# Add {$mode delphi}{$H+} or {$mode objfpc}{H+} directives<br />
# Add 'Interfaces' to uses clause<br />
# Comment out or delete {$R *.res} or directive<br />
* Make necessary changes to all .pas unit files:<br />
# Add {$mode delphi}{$H+} or {$mode objfpc}{H+} directives<br />
# Add 'LResources', and if the form has buttons, add 'Buttons' to uses clause<br />
# Comment out or delete {$R *.dfm} or {$R *.xfm} directive<br />
# Add 'Initialization' section at the end of each unit file, and add {$I unitname.lrs} directive in it<br />
* Select Project->New Project form file<br />
* Select the .lpr file<br />
* At 'Create a new project' window, choose 'Application'<br />
* Build project and make further necessary corrections to get proper compilation, at this point the .lpi file is generated automaticaly. You may also get 'Error reading Form' messages, click on 'Continue Loading' if you do. <br />
* Save all, and you have a Lazarus project :-)<br />
<br />
== Getting Help ==<br />
<br />
If you encounter a problem during conversion that you just can't solve, there are a wide variety of places to get help. For pure Object Pascal and FPC issues, the best place to start is the Free Pascal [http://www.freepascal.org/docs-html/ Documentation] by Michaël Van Canneyt and Florian Klämpfl. For more Lazarus oriented problems, the Lazarus Project Documentation in the Lazarus-CCR Knowledgebase [[Main Page]] is the next place to look. Finally you can post a question on any of the [http://www.freepascal.org/maillist.html mailing lists for the Free Pascal Compiler] or the [http://community.freepascal.org:10000/bboard/ FPC forums] where a lot of experts are subscribed.<br />
<br />
There are some outstanding search and knowledge bases online that can also be a great help for learning new techniques and solving problems. Tamarack Associates operates a fast [http://www.tamaracka.com/search.htm search] engine specifically for the Borland usenet archives. Mer Systems Inc. provides a similar search [http://www.mers.com/searchsite.html engine]. Another outstanding source of information along with a sitewide [http://www.efg2.com/Lab/search.htm search] capability is Earl F. Glynn's Computer Lab and Reference [http://www.efg2.com/ Library].<br />
<br />
== Packaging and Releasing your component ==<br />
<br />
=== Creating a Lazarus package for your component(s) ===<br />
<br />
Creating a package makes installing the code you've converted a much easier process... especially if you're providing more then one component. Mattias Gärtner has written an overview of [[Lazarus Packages]] that should be read before beginning this process.<br />
<br />
=== Documentation ===<br />
<br />
The purpose of this site and the wiki format is to make the generation of professional documentation an easy and quick process. The wiki also makes it possible to see the results of your posting immediately and make any changes you'd like in real time.<br />
<br />
Using the Lazarus-CCR wiki to create nice looking documentation is very easy. If you've never used wiki markup before, you can get familiar with it in the [[Sand Box]] practice area.<br />
<br />
=== Creating a Code Release Page ===<br />
<br />
The Code Release Page contains vital information about your component that a potential downloader will need to know, such as license, intended platform, status (alpha, beta, stable...), where to download it, who wrote it, is support available... etc.<br />
<br />
The following procedure will let you create a Code Release Page with your browser: <br />
<br />
* Go to the [[Release new component]]<br />
* Type the name of your component in the textbox and click on ''Create Article''<br />
* Fill in the template and hit save.<br />
* Edit the [[Components and Code examples]] page and add the link to your newly created page to the "Released Components" section. Save the modified page.<br />
<br />
=== Submitting the component ===<br />
<br />
If you're a release technician on the project, upload your component to the SourceForge File Release System and add it to the list of release packages. Otherwise send it to one of the project administrators ([[User:Tom |Tom Lisjac]] or [[User:Vincent |Vincent Snijders]]) and we'll add it to the repository. Before we upload it to SourceForge, you have to create a ''Code Release Page'' to describe your component. You can use the [[Release new component]] page, to start creating such a page.<br />
<br />
If you think you need to continue to develop on the component, we can also put it into SVN so you'll continue to have access to it. If we get tired from submitting your patches, we will give you write access to the SVN, so you can commit your patches yourself. For details see [[Using the Lazarus-ccr SVN repository]].<br />
<br />
== Contributors and Changes ==<br />
<br />
This page has been converted from the epikwiki [http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide version].<br />
* Initial version by Tom Lisjac and Mattias Gärtner - 9/22/2003 [[User:Tom | VlxAdmin]]<br />
* Moved Getting help from the main page. T. Lisjac - 9/24/2003 [[User:Tom | VlxAdmin]]<br />
* Added documentation templates, procedure and links. 9/25/2003 [[User:Tom | VlxAdmin]]<br />
* LCLLinux was renamed to LCLIntf, [[User:Jesusrmx | Jesus Reyes]], 9/27/2003<br />
* added more information on Unit changes, [http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson AndrewJohnson] 9/27/2003<br />
* Updated Syntax differences, including some examples, [http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson AndrewJohnson] 9/27/2003<br />
* FPC 1.0.x doesn't support interfaces, [[User:Vincent | Vincent Snijders]] 9/28/2003<br />
* Fixed some of the examples per new WikiWord definition, 9/28/2003 [[User:Tom | VlxAdmin]]<br />
* Made code more consistant to remove last accidental Pascal WikiWord definitions, [http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson AndrewJohnson] 9/27/2003<br />
* Use tables for code examples for nice blocks, and easy side by side view of Delphi->FPC differences, [http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson AndrewJohnson] 10/17/2003<br />
* Use pascal stylesheet to make example code more readable, [http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson AndrewJohnson] 10/18/2003<br />
* Added 'Another method to convert a Delphi or Kylix project to Lazarus' section , [[User:Glober | George Lober]], 2/17/2006</div>Alcatiz