SQLite/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## SQLite et prise en charge par FPC/Lazarus
2	2
3	3		SQLite est une base de données mono-utilisateur incorporée (sans server) qui peut être utilisée dans des applications FPC et Lazarus (mais pas seulement). Divers pilotes peuvent être utilisés pour accéder à SQLite depuis des programmes FPC/Lazarus. Tous les pilotes demandent la bibliothèque/dll SQLite dans le répertoire de l'application qui, pour fonctionner, peut être votre répertoire de projet ou p.ex. (projectdir)/lib/architecture/ selon vos réglages de projet Lazarus et distribué avec votre exécutable.
4	4
5	5		Win64: veuillez voir l'avertissement [[Windows Programming Tips/fr\|ici]] sur l'impossibilité d'utiliser certaines versions de FPC/Lazarus Win64.
6	6
7	7		### Accès direct à SQLite
8	8
9	9		Vous pouvez utiliser une manière simple pour vous connecter à SQLite avec Lazarus. Les SQLite Data Access Components (LiteDAC) sont une bibliothèque de composants qui fournissent une connectivité native à SQLite depuis Lazarus (et Free Pasacal) sur Windows, Mac OS X, iOs, Androïd, Linux et FreeBSD à la fois pour les plates-formes 32-bit et 64-bit. LiteDAC est conçu pour les programmeurs pour développer des applications de bases de données SQLite de bureau ou mobiles réellement multi plate-forme sans nécessité de déployer des bibliothèques supplémentaires.
10	10
11	11		Vous pouvez télécharger une version d'essai du produit commercial depuis [Composants Lazarus](https://www.devart.com/litedac/download.html).
12	12
13	13		### SQLDB intégré
14	14
15	15		FPC/Lazarus offre des composants SQLdb intégrés qui incluent la prise en charge des bases de données SQLite ([[TSQLite3Connection/fr\|TSQLite3Connection]]) depuis l'[[SQLdb tab/fr\|onglet SQLdb]] de la [[Component Palette/fr\|palette de composants]], ce qui vous permet par exemple de créer des IHM avec des composants de base de données tels que des [[TDBGrid/fr\|TDBGrids]]. L'avantage est qu'il devient très facile de passer à une autre base de données telle que Firebird ou PostgreSQL sans trop changer votre programme. Voir plus bas pour des détails.
16	16
17	17		#### Prise en charge de Spatialite
18	18
19	19		Spatialite sont des extensions SIG à SQLite que vous pouvez utiliser à partir de SQLdb. Voyez [[Spatialite/fr\|Spatialite]].
20	20
21	21		#### Prise en charge du chiffrement
22	22
23	23		Dans les versions récentes de FOC (implémentée en mas 2012), SQLdb inclut la prise en charge de certaines versions étendues de SQLite qui crypte le fichier de base de données de SQLite en utilisant l'algorithme AES. Utilisez la propriété Password pour définir le clé de chiffrement.
24	24
25	25		Exemples:
26	26
27	27		- [SQLCipher](http://sqlcipher.net/) : open source, mais les binaires ne sont pas libres (vous devez les compilez vous-mêmes).
28	28		- [System.Data.SQLite](http://system.data.sqlite.org/) : open source, binaires Windows (32, 64, CE) disponibles, téléchargez p.ex. un des binaires précompilés et renommez SQLite.Interop.dll en sqlite3.dll (Si vous en utilisez un statiquement lié, vous devriez probablement renommer system.Data.SQLite.DLL en sqlite3.dll).
29	29		- [wxSQLite3](http://wxcode.sourceforge.net/docs/wxsqlite3/): open source, certains binaires Linux sont disponibles (ex: <https://launchpad.net/ubuntu/oneiric/+package/libwxsqlite3-2.8-0>)
30	30
31	31		#### sqlite3backup
32	32
33	33		sqlite3backup est une unité avec FPC (pas dasn Lazarus pais peut être utilisé par programmation) qui fournit une fonctionnalité de sauvegarde/restauration pour SQLite3. Elle utilise sqlite3conn de SQLdb.
34	34
35	35		### Cas de Debian Jessie
36	36
37	37		(Décrit depuis Lazarus 1.8RC3 + FPC 3.0.3, à vérifier pour d'autres versions) L'installation du paquet sqlite3laz.0.4 depuis la Debian Jessie pose problème. En effet, lors de la reconstruction de l'EDI, une erreur générique de liaison bloquante survient alors. Il s'avère que le fichier /usr/share/fpcsrc/3.0.3/packages/sqlite/src/sqlite3.inc attend la nom de bibliothèque libsqlite3.so mais la Debian Jessie ne propose que le lien symbolique libsqlite3.so.0. Deux solutions :
38	38
39	39		- soit changer le nom dans le source du fichier .inc, mais cela est risqué et devra être fait à nouveau à chaque réinstallation de Lazarus et induit une différence non pertinente avec la version officielle.
40	40		- soit créer un lien symbolique avec ce nom dans le répertoire des bibliothèques (/usr/lib/x86_64-linux-gnu pour mon cas).
41	41
42	42		`sudo ln -s libsqlite3.so.0 libsqlite3.so `
43	43
44	44		La contrainte réside dans le déploiement, il faut en effet s'assurer que le lien ou nom de fichier direct existe sur le système cible et au besoin le créer.
45	45
46	46		Cela résoud aussi les problèmes rencontrés lors de l'installation de la bibliotèque ZeosLib qui provoquait la même erreur.
47	47
48	48		### Zeos
49	49
50	50		[Zeos](https://sourceforge.net/projects/zeoslib/)
51	51
52	52		### SQLitePass
53	53
54	54		Composants [SqlitePass](http://source.online.free.fr/) . Etat: inconnu.
55	55
56	56		### TSQLite3Dataset et TSQLiteDataset
57	57
58	58		Il y a des paquets séparés pour TSQLiteDataset (unité sqliteds) et TSQLite3Dataset (unité sqlite3ds) ; voyez ci-dessous pour une description sur la façon de les utiliser. Visitez la [sqlite4fpc page d'accueil](http://sqlite4fpc.yolasite.com/) pour trouver l'API de référence et plus de tutoriels.
59	59
60	60		TSqliteDataset et TSqlite3Dataset sont des descendants de [[TDataSet/fr\|TDataSet]] qui accèdent, respectivement aux bases de données SQLite 2.8.x et 3.x.x. Pour de nouveaux projets, vous supposeriez utiliser TSQlite3Dataset en tant que version actuelle de SQLite 3.x.
61	61
62	62		Ci-dessous est une liste des principaux avantages et inconvénients comparés à d'autres méthodes d'accès/pilotes SQLite pour FPC/Lazarus :
63	63
64	64		Avantages :
65	65
66	66		- Flexible : Les programmeurs peuvent choisir d'utiliser ou pas le langage SQL, leur permettant de travailler avec un schéma de simple table ou des schémas plus compliqués tels que SQLite le permet.
67	67
68	68		Inconvénients :
69	69
70	70		- Le changement vers une autre base de données est plus difficile si vous utilisez les composants SQLDB ou Zeos.
71	71
72	72		> Note: Selon ci-dessus, des utilisateurs utiliseront SQLdb ou Zeos pour leurs avantages à moins d'avoir besoin des accès bas-niveaux de la bibliothèque SQLite
73	73
74	74		## Utilisation des composants SQLdb avec SQLite
75	75
76	76		Ces directives font le point sur les spécificités de SQLdb pour SQLDB (le composant TSQLite3Connection). Pour une vue d'ensemble, jetez un œil sur [[SqlDBHowto/fr\|SqlDBHowto]] qui continet des informations intéressantes sur les composants SQLdb.
77	77
78	78		Voyez le [[SQLdb Tutorial1/fr\|SQLdb_Tutorial1]] pour un tutoriel sur la création d'un programme IHM relié aux données qui est écrit pour SQLite/SQLDB (et tout aussi bien pour Firebird/SQLDB, PostgreSQL/SQLDB, et d'une façon générale pour tout SGBDR que SQLDB prend en charge).
79	79
80	80		Nous utiliserons une combinaison de trois composants dans l'onglet SQLdb : TSQLite3Connection, TSQLTransaction et TSQLQuery. Le TSQLQuery agit comme notre TDataSet ; dans le cas le plus simple il représente juste une de nos tables. Par simplicité, assurez-vous d'avoir une base de données SQLite et de ne pas avoir besoin d'en créer une maintenant. TSQLite3Connection peut être trouvé dans l'unité sqlite3conn, si vous voulez le déclarez vous-mêmes ou si vous travaillez avec FreePascal.
81	81
82	82		Les trois composants sont connectés entre eux comme d'habitude : dans l'ensemble TSQLQuery, définissez les propriétés Database et Transaction, dans le TSQLTransaction, définissez la propriété Database. Il n'y a pas grand chose d'autre à faire dans les composants Transaction et Connection, les choses les plus intéressantes seront faites dans le TSQLQuery. Configurez les composants comme suit :
83	83
84	84		TSQLite3Connection :
85	85
86	86		- DatabaseName : mettez-y le nom (avec un chemin absolu!) de votre fichier SQLite. Malheureusement, vous ne pouvez pas simplement utiliser un chemin relatif qui resterait inchangé à la conception et à l'exécution * est-ce toujours vrai ? Ne pouvez-vous pas seulement copier le fichier de base de données à l'aide d'un script post-construction ou définir un lien symbolique ? *. Vous devrez vous assurer que quand l'application démarre, le chemin vers le fichier est défini correctement par programmation, sans tenir compte de la valeur de conception.
87	87
88	88		Note : Pour définir le chemin d'accès complet à la bibliothèque (si vous placez votre dll/so/dylib de SQLite où votre système ne le trouvera pas, telle que le dossier de l'application dans Linux ou OS/X), vous pouvez employer la propriété SQLiteLibraryName (avant qu'une connexion ne soit établie p.ex. dans l'événement OnCreate de la fiche principale), comme ceci :
89	89
90	90		``` pascal
91	91		SQLiteLibraryName:='./sqlite3.so';
92	92		```
93	93
94	94		TSQLQuery :
95	95
96	96		- SQL : placez-y une simple rerquête SELECT sur l'une de vos tables. P.ex., si vous avez une table 'foo' et voulez que le DataSet représente cette table, mettez-y seulement :
97	97		``` SQL
98	98		SELECT * FROM foo
99	99		```
100	100
101	101		- Active : Mettez-la à True depuis l'EDI pour voir si tout marche correctement. Cela active automatiquement les objets transaction et connexion. Si vous recevez une erreur, soit le Databasename de la connection n'est pas correct ou la requête SQL est fausse. Plus tard, lorsque nous finissons d'ajouter les champs (voir ci-dessous), tous les objets sont de nouveau inactifs, nous ne voulons pas que l'IDE verrouille la base de données SQLite (un seul utilisateur!) Lors du test de l'application.
102	102
103	103		- Sans doute pas nécessaire pour une opération propre - devra être contrôlé (juin 2012) Maintenant nous pouvons ajouter des champs à notre TSQLQuery. Pendant que le composant est toujours actif , cliquez-droit et "Editer les champs..." . Cliquez sur le le bouton "+" et ajoutez les champs. Cela ajoutera tous les champs que votre requêtes SQL a retourné. Ajouté chaque chaque dont vous avez besoin, vous pouvez aussi ajouter des champs de référence (lookup fields) ici ; dans ce cas assurez d'avoir ajouter tous les champs requis dans les autres DataSets avant d'ajouter les champs qui leur feront référence. Si votre table a des champs qui ne vous intéresse pas, vous pouvez les enlever, vous pouvez aussi rendre votre requête un peu plus spécifique (remplacez SELECT * par un SELECT avec la liste des champs voulus).
104	104
105	105		- Dans votre code, vous avez besoin d'appeler SQLQuery.ApplyUpdates et SQLTransaction.Commit, les événements TSQLQuery.AfterPost et AfterInsert sont les bons endroits pour cela quand vous utilisez des contrôles sensibles aux données mais bien sûr, vous pouvez aussi remettre à plus tard ces appels. Si vous ne les appelez pas, la base de données ne sera pas mise à jour.
106	106
107	107		- Database is locked" : L'EDI pourrait encore bloquer la base de données (SQLite est une base de données mono-utilisateur), vous avez sans doute oublié de mettre les composants à inactif et de vous déconnecter après avoir défini tous les champs de vos objets TSQLQuery. Utilisez l'événement OnCreate de la fiche pour définir le chemin d'accès et activer les objets à l'exécution seulement. La plupart des choses que vous réglez dans TSQLQuery depuis l'EDI ne nécessitent pas (et même ne le permettent pas pour certaines) qu'il soit actif en conception, la seule exception est quand vous voulez lire la structure de la table, ainsi l'état normal en conception est inactif.
108	108
109	109		- Vos tables devraient toutes avoir une clé primaire et vous devez vous assurez que les champs correspondants ont pfInKey et rien d'autre dans leurs PoviderFlags (ces drapeaux contrôlent comment et où le champ est utilisé en cas de construction automatique de requêtes de mise à jour et de suppression).
110	110
111	111		- Si vous utilisez des champs de référence :
112	112		- Assurez-vous que le ProviderFlags pour le champ de référence est complétement vide, comme ça, son nom ne sera pas utilisé dans une requête de mise à jour. Le champ de référence lui-même n'est pas un champ de données, il agit seulement sur la valeur d'un autre champ, le champ clé correspondant, et seulement ce champ clé sera plus tard utilisé dans les requêtes de mise à jour. Vous pouvez masquer le champ clé car la plupart du temps vous ne voudrez pas le voir dans votre interface utilisateur mais il doit être défini.
113	113		- LookupCache doit être mise à True. Au moment de la rédaction, pour certaines raisons, le champ Lookup n'affichera rien d'autre (mais fonctionnera encore) et étrangement à l'exact opposé du TSQLite3Dataset ou d'autres composants TXXXDataset pour lesquels elle doit être mise à False. Je ne suis pas encore sûr de savoir si cela est un comportement intentionnel ou un bug.
114	114
115	115		- Habituellement avec de simples tables, vous n'aurez besoin de définir aucune des propriétés InsertSQL, UpdateSQL et DeleteSQL, il suffit de les laisser vides. Si vous avez défini correctement les propriétés ProviderFlags de tous vos champs, les requêtes seront créées à la volée. Pour plus de détails sur InsertSQL, UpdateSQL et DeleteSQL, voyez [[http://wiki.lazarus.freepascal.org/Working With TSQLQuery/fr\|http://wiki.lazarus.freepascal.org/Working_With_TSQLQuery/fr#InsertSQL.2C_UpdateSQL_et_DeleteSQL_-_Utilisation_basique_des_param.C3.A8tres]].
116	116
117	117		Après que ce qui précède est correctement mis en place, vous devriez maintenant être capable d'utiliser le TSQLQuery comme tout autre TDataSet, soit en le manipulant par code soit en plaçant un TDataSource sur la fiche, le connectant à un TDataSet et en utilisant un contrôle comme une grille etc.
118	118
119	119		### Création d'une base de données
120	120
121	121		La méthode [TSQLite3Connection.CreateDB](http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnection.createdb.html) héritée de la classe parent ne fait actuellement rien ; pour créer une base de données si aucun fichier n'existe, vous devez simplement écrire les données de la table comme dans l'exemple suivant :
122	122
123	123		(Code extrait de l'exemple sqlite_encryption_pragma fourni avec Lazarus 1.3)
124	124
125	125		``` pascal
126	126		var
127	127		newFile : Boolean;
128	128		begin
129	129
130	130		SQLite3Connection1.Close; // Ensure the connection is closed when we start
131	131
132	132		try
133	133		// Since we're making this database for the first time,
134	134		// check whether the file already exists
135	135		newFile := not FileExists(SQLite3Connection1.DatabaseName);
136	136
137	137		if newFile then
138	138		begin
139	139		// Create the database and the tables
140	140		try
141	141		SQLite3Connection1.Open;
142	142		SQLTransaction1.Active := true;
143	143
144	144		// Here we're setting up a table named "DATA" in the new database
145	145		SQLite3Connection1.ExecuteDirect('CREATE TABLE "DATA"('+
146	146		' "id" Integer NOT NULL PRIMARY KEY AUTOINCREMENT,'+
147	147		' "Current_Time" DateTime NOT NULL,'+
148	148		' "User_Name" Char(128) NOT NULL,'+
149	149		' "Info" Char(128) NOT NULL);');
150	150
151	151		// Creating an index based upon id in the DATA Table
152	152		SQLite3Connection1.ExecuteDirect('CREATE UNIQUE INDEX "Data_id_idx" ON "DATA"( "id" );');
153	153
154	154		SQLTransaction1.Commit;
155	155
156	156		ShowMessage('Succesfully created database.');
157	157		except
158	158		ShowMessage('Unable to Create new Database');
159	159		end;
160	160		end;
161	161		except
162	162		ShowMessage('Unable to check if database file exists');
163	163		end;
164	164		end;
165	165		```
166	166
167	167		### Création de collations personnalisées
168	168
169	169		``` pascal
170	170		// utf8 case-sensitive compare callback function
171	171		function UTF8xCompare(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
172	172		var S1, S2: AnsiString;
173	173		begin
174	174		SetString(S1, data1, len1);
175	175		SetString(S2, data2, len2);
176	176		Result := UnicodeCompareStr(UTF8Decode(S1), UTF8Decode(S2));
177	177		end;
178	178
179	179		// utf8 case-insensitive compare callback function
180	180		function UTF8xCompare_CI(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
181	181		var S1, S2: AnsiString;
182	182		begin
183	183		SetString(S1, data1, len1);
184	184		SetString(S2, data2, len2);
185	185		Result := UnicodeCompareText(UTF8Decode(S1), UTF8Decode(S2));
186	186		end;
187	187
188	188		// register collation using SQLite3 API (requires sqlite3dyn unit):
189	189		sqlite3_create_collation(SQLite3.Handle, 'UTF8_CI', SQLITE_UTF8, nil, @UTF8xCompare_CI);
190	190		// or using method of TSQLite3Connection:
191	191		CreateCollation('UTF8_CI',1,nil,@UTF8xCompare_CI);
192	192
193	193		// now we can use case-insensitive comparison in SQL like:
194	194		// SELECT * FORM table1 WHERE column1 COLLATE UTF8_CI = 'á'
195	195
196	196		// but this does not work for LIKE operator
197	197		// in order to support also LIKE operator we must overload default LIKE function using sqlite3_create_function()
198	198		// http://www.sqlite.org/lang_corefunc.html#like
199	199		```
200	200
201	201		### Création de fonctions personnalisées
202	202
203	203		``` pascal
204	204		// example overloading default LOWER() function with user supplied function
205	205		procedure UTF8xLower(ctx: psqlite3_context; N: cint; V: ppsqlite3_value); cdecl;
206	206		var S: AnsiString;
207	207		begin
208	208		SetString(S, sqlite3_value_text(V[0]), sqlite3_value_bytes(V[0]));
209	209		S := UTF8Encode(AnsiLowerCase(UTF8Decode(S)));
210	210		sqlite3_result_text(ctx, PAnsiChar(S), Length(S), sqlite3_destructor_type(SQLITE_TRANSIENT));
211	211		end;
212	212
213	213		// register function LOWER() using SQLite3 API (requires sqlite3dyn unit):
214	214		sqlite3_create_function(SQLite3.Handle, 'lower', 1, SQLITE_UTF8 or SQLITE_DETERMINISTIC, nil, @UTF8xLower, nil, nil);
215	215		```
216	216
217	217		### SQLite3 et les dates
218	218
219	219		- SQLite 3 ne stocke pas les dates comme des valeurs spéciales. Il peut les stocker comme des String, de Double or Integer - voyez [1](http://www.sqlite.org/datatype3.html#datetime).
220	220		- Dans les String, le séparateur de date est '-' comme dans la norme SQL ISO 8601. Ainsi, vous pouvez faire un INSERT en utilisant la fonction intégrée DATE, ce sera stocké en quelque chose comme 'YYYY-MM-DD'.
221	221		- La lecture d'une valeur DateTime peut causer des problèmes pour DataSets si elles sont enregistrées sous forme de String : la propriété .AsDateTime peut se bloquer sur une 'string date' de SQLite, mais cela peut être surmonté en utilisant quelque chose comme `strftime(``%d/%m/%Y``,recdate) AS sqlite3recdate` dans votre ordre SQL, ce qui force SQLite3 à retourner l'enregistrement Date dans un format spécifique (la chaîne de format %d/%m/%d correspond à votre configuration locale de date que .AsDateTime comprendra) ==\> veuillez ouvrir une rapport de bug avec un exemple d'application démontrant le problème si cela est la cas.
222		-	- En comparant des dates enregistrées en chaîne (en utilisant p.ex. la fonction BETWEEN), souvenez-vous que la comparaison sera toujours une comparaison de <b>string</b>, et donc dépendra de comment vous avez enregistré la valeur de date.
	222	+	- En comparant des dates enregistrées en chaîne (en utilisant p.ex. la fonction BETWEEN), souvenez-vous que la comparaison sera toujours une comparaison de string, et donc dépendra de comment vous avez enregistré la valeur de date.
223	223
224	224		#### Valeurs par défaut en temps local au lieu de UTC
225	225
226	226		CURRENT_TIME, CURRENT_DATE et CURRENT_TIMESTAMP retournent la date UTC et/ou l'heure. Pour des dates et/ou heures locales, vous pouvez utilisez :
227	227
228	228		` DEFAULT (datetime('now','localtime')) pour les valeurs datetime formatées en YYYY-MM-DD HH:MM:SS`\
229	229		` DEFAULT (date('now','localtime')) pour les valeurs date formatées en YYYY-MM-DD`\
230	230		` DEFAULT (time('now','localtime')) pour les valeurs time formatées en HH:MM:SS.`
231	231
232	232		### Résolution de problème sur SQLDB et SQLite
233	233
234	234		- Gardez à l'esprit que pour pouvoir fonctionner en conception (champs, inidex etc), Lazarus doit trouver sqlite3.dll aussi.
235	235		- La même chose pour le nom de fichier de la base de données. Utilisez toujours des chemins absolus si vous utilisez des composants pour extraire p.exe les noms des champs en conception. Sinon, l'EDI créera un fichier vide dans son dossier. En cas de problème, vérifiez si le dossier /lazarus détient une copie vide du fichier de base de données.
236	236		- Si vous avez une relation maître/détail, vous avez besoin de rafraichir le DataSet maître après chaque insertion, en vue d'obtenir la valeur de la clé étrangère pour le DataSet détail. Vous pouvez faire cela dans l'événement AfterPost du DataSet maître, en appelant l'une de ces méthodes redéfinies :
237	237
238	238		``` pascal
239	239		interface
240	240		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);overload;
241	241		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);overload;
242	242
243	243		implementation
244	244
245	245		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);
246	246		//This procedure refreshes a dataset and positions cursor to last record
247	247		//To be used if Dataset is not guaranteed to be sorted by an autoincrement primary key
248	248		var
249	249		vLastID: Integer;
250	250		vUpdateStatus : TUpdateStatus;
251	251		begin
252	252		vUpdateStatus := pDataset.UpdateStatus;
253	253		//Get last inserted ID in the database
254	254		pDataset.ApplyUpdates;
255	255		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
256	256		//Now come back to respective row
257	257		if vUpdateStatus = usInserted then begin
258	258		pDataset.Refresh;
259	259		//Refresh and go back to respective row
260	260		pDataset.Locate(pKeyField,vLastID,[]);
261	261		end;
262	262		end;
263	263
264	264		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);
265	265		//This procedure refreshes a dataset and positions cursor to last record
266	266		//To be used only if DataSet is guaranteed to be sorted by an autoincrement primary key
267	267		var
268	268		vLastID: Integer;
269	269		vUpdateStatus : TUpdateStatus;
270	270		begin
271	271		vUpdateStatus := pDataset.UpdateStatus;
272	272		pDataset.ApplyUpdates;
273	273		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
274	274		if vUpdateStatus = usInserted then begin
275	275		pDataset.Refresh;
276	276		//Dangerous!
277	277		pDataSet.Last;
278	278		end;
279	279		end;
280	280
281	281		procedure TDataModule1.SQLQuery1AfterPost(DataSet: TDataSet);
282	282		begin
283	283		RefreshADatasetAfterInsert(Dataset as TSQLQuery); //If your dataset is sorted by primary key
284	284		end;
285	285
286	286		procedure TDataModule1.SQLQuery2AfterPost(DataSet: TDataSet);
287	287		begin
288	288		RefreshADatasetAfterInsert(Dataset as TSQLQuery, 'ID'); //if you are not sure that the dataset is always sorted by primary key
289	289		end;
290	290		```
291	291
292	292		### Vacuum et autres opérations qui doivent être faites en dehors d'une transaction
293	293
294	294		SQLdb semble demander toujours une connexion, mais certaines opérations comme Pragma et Vacuum doivent être faite en dehors de toute transaction. L'astuce consiste à mettre fin à la transaction, exécuter ce que vous devez et redémarrer la transaction (ainsi SQLdb ne sera pas perdu) :
295	295
296	296		``` pascal
297	297		// commit any pending operations or use a "fresh" sqlconnection
298	298		Conn.ExecuteDirect('End Transaction'); // End the transaction started by SQLdb
299	299		Conn.ExecuteDirect('Vacuum');
300	300		Conn.ExecuteDirect('Begin Transaction'); //Start a transaction for SQLdb to use
301	301		```
302	302
303	303		## En utilisant TSQLite3Dataset
304	304
305	305		Cette section détaille comment utiliser les composants TSQLite2Dataset et TSQLite3Dataset pour accéder aux bases de données SQLite. par Luiz Américo luizmed(at)oi(dot)com(dot)br
306	306
307	307		#### Pré-requis
308	308
309	309		- Pour les bases de données sqlite2 (système "patrimonial") :
310	310		- FPC 2.0.0 ou supérieur
311	311		- Lazarus 0.9.10 ou supérieur
312	312		- Bibliothèque d'exécution SQLite 2.8.15 ou supérieure
313	313
314	314		- Sqlite2 n'est plus maintenu et le binaire ne peut pas être trouvé sur le site Web SQLite.
315	315
316	316		- Pour les bases de données sqlite3 :
317	317		- FPC 2.0.2 ou supérieur
318	318		- Lazarus 0.9.11 (révision svn 8443) ou supérieur
319	319		- Bibliothèque d'exécution SQLite 3.2.1 ou supérieure (obtenez-la depuis [www.sqlite.org](http://www.sqlite.org))
320	320
321	321		Avant de commencer un projet Lazarus, assurez-vous que :
322	322
323	323		- la bibliothèque sqlite est soit
324	324		- dans le chemin système PATH ou
325	325		- dans le dossier de sortie de l'exécutable et dans le dossier de Lazarus (ou dans le projet courant) - cette option pourrait marcher dans Windows seulement.
326	326		- Sous Linux, mettre `cmem` comme première unité dans la clause Uses de votre programme principal.
327	327		- Dans Debian, Ubuntu et autre distro dérivée de Debian, en vue de construire l'EDI de Lazarus, vous devez ajouter le paquet libsqlite-dev/libsqlite3-dev, et pas seulement sqlite/sqlite3 (s'applique aussi à OpenSuse).
328	328
329	329		#### Comment l'utiliser (Usage basique)
330	330
331	331		Installez le paquet trouvé dans le répertoire /components/sqlite directory (voir les instructions [[Install Packages/fr\|ici]]).
332	332
333	333		En conception, définissez les propriétés suivantes :
334	334
335	335		- FileName : chemin vers le fichier sqlite \[requis\]
336	336		- TableName : nom de la table utilisée dans l'ordre SQL \[requis\]
337	337		- SQL : un ordre SELECT en SQL \[optionnel\]
338	338		- SaveOnClose : La valeur par défaut est False, ce qui signifie que les changements ne sont pas enregistrés. On peut le changer à vrai. \[optionnel\]
339	339		- Active : Demande à être mis à True en conception ou au démarrage du programme. \[requis\]
340	340
341	341		Création d'une table (Dataset)
342	342
343	343		Double-cliquez sur l'icône du composant ou utilisez l'entrée 'Create Table' du menu surgissant (clic droit). Un simple éditeur de table intuitif sera affiché.
344	344
345	345		Voici tous les types de champ pris en charge par TSqliteDataset et TSqlite3Dataset :
346	346
347	347		- Integer
348	348		- AutoInc
349	349		- String
350	350		- Memo
351	351		- Bool
352	352		- Float
353	353		- Word
354	354		- DateTime
355	355		- Date
356	356		- Time
357	357		- LargeInt
358	358		- Currency
359	359
360	360		Récupération des données
361	361
362	362		Après avoir créer la table ou avec une table déjà créée, ouvrez le DataSet avec la méthode Open.
363	363
364	364		Si la propriété SQL n'était pas définie alors tous les champs de tous les enregistrement seront récupérés, comme si vous aviez passé l'ordre SQL :
365	365
366	366		``` pascal
367	367		SQL := 'Select * from TABLENAME';
368	368		```
369	369
370	370		Application des mises à jour au fichier de données sous-jacent
371	371
372	372		Pour utiliser la fonction ApplyUpdates, le DataSet doit contenir au moins un champ qui remplit les conditions pour une clé primaire (ses valeurs doivent être UNIQUES et non NULLES).
373	373
374	374		Il est possible de faire ceci de deux façons :
375	375
376	376		- Définissez la propriété PrimaryKey avec le nom du champ de clé primaire.
377	377		- Ajoutez un champ AutoInc (ce qui est plus facile depuis que le TSqliteDataSet le manipule automatiquement comme une clé primaire).
378	378
379	379		Si l'une de ces conditions est satisfaite, appelez seulement :
380	380
381	381		``` pascal
382	382		ApplyUpdates;
383	383		```
384	384
385	385		> Note: Si les deux conditions sont satisfaites, le champ correspondant à la clé primaire est utilisé pour appliquer les mise à jour.
386	386
387	387		> Note: Définir PrimaryKey à un champ qui n'est pas une clé primaire amènera à des pertes de données si ApplyUpdates est appelée, assurez-vous donc que le champ choisi contient bien des valeurs uniques et non nulles avant de l'utiliser.
388	388
389	389		##### Exemple de relation maître/détail
390	390
391	391		Divers exemples de realtions maître/détail (p.ex. la relation entre client et commandes) :
392	392
393	393		- la manière générique de SQLdb pour faire ceci utilise le [[TDataSource/fr\|TDataSource]] et la propriété [[MasterDetail/fr\|MasterDetail]]
394	394		- un exemple spécifique TSQLite3 utilisant locate: [[TSqlite3 Master Detail Example/frf\|Exemple de maître/détail avec TSqlite3]].
395	395
396	396		#### Remarques
397	397
398	398		- Bien que cela ait été testé avec 10 000 enregistrements et ait fonctionné très bien, TSqliteDataset conserve toutes les données en mémoire, aussi gardez en mémoire de ne récupérer que les données nécessaire en mémoire (en particulier avec les champs Memo).
399	399		- Le même fichier de données (propriété FileName) peut héberger plusieurs tables/DataSets.
400	400		- Plusieurs DataSets (différentes combinaisons de champs) peurvent être créés en utilisant en même temps la même table (ce sont des copies des données en mémoire).
401	401		- Il est possible de filtrer les données en utilisant les clauses WHERE dans le SQL, en fermant et réouvrant le DataSet (ou en appelant la méthode RefetchData). Mais dans ce cas, l'ordre et le nombre des champs doit rester le même (i.e. on ne "bricole" la liste de champs du SELECT).
402	402		- Il est possible d'utiliser des ordres SQL complexes en utilisant des alias, des jointures, des vues pour de multiples tables (rappelez-vous qu'elle doivent résider dans le même fichier de données), mais dans ce cas ApplyUpdates ne fonctionnera pas.
403	403		- La définition du nom du fichier vers une fichier de données SQLite mais pas créé par TSqliteDataset et l'ouverture est permise mais le type de certains champs ne sera pas détecté correctement. Ils seront traités comme des champs de type String.
404	404
405	405		Des exemples génériques peuvent être trouvés dans le répertoire SVN fpc/fcl-db/src/sqlite.
406	406
407	407		## Voir aussi
408	408
409	409		- [[SQLdb Tutorial1/fr\|Tutoriel 1 sur SQLdb]] Tutoriel pour Sqlite
410	410		- [[SqlDBHowto/fr\|SqlDBHowto]] Information générale sur SQLDB
411	411		- [[Working With TSQLQuery/fr\|Travailler avec le TSQLQquery]] Informations sur le TSQLQuery de SQLDB.
412	412		- [Site SQLite](http://www.sqlite.org)
413	413
414	414		---
415	415		From the Free Pascal wiki, page "SQLite/fr", as it stood on 2021-09-09 after a change by Jpasj, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history