SQLite/es: what changed

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

Old	New		Line
1	1		## Soporte para SQLite en FPC/Lazarus
2	2
3	3		SQLite es una base de datos embebida (sin servidor) monousuario que puede ser utilizada en aplicaciones FPC y Lazarus. Se pueden utilizar varios controladores para el acceso a SQLite desde programas FPC/Lazarus.
4	4
5	5		Es necesario que dichos controladores de SQLite (librerias .dll / .so / .dylib) se ubiquen bien sea en el directorio de proyecto donde se encuentre el ejecutable para que funcione (no debemos por tanto olvidarnos de incluirlos con el programa a la hora de distribuirlo), bien en un directorio incluido en la variable PATH del sistema.
6	6
7	7		### SQLDB incluido con Lazarus / FreePascal
8	8
9	9		FPC/Lazarus incluyen componentes SQLDB que aportan soporte para bases de datos SQLite (TSQLite3Connection) de la solapa SQLdb en la paleta de componentes, permitiendo por ejemplo crear interfaces gráficos (GUIS) con componentes tales como DBGrids. La ventaja de utilizar SQLDB es que resulta bastante fácil el cambio a otra base de datos diferente como puede ser Firebird o PostgreSQL sin tener por ello que realizar grandes cambios.
10	10
11	11		Ver más abajo para más detalles.
12	12
13	13		![](/wiki-images/c/cc/Sqldbcomponents.png)
14	14
15	15		Win64: por favor ver las advertencias [[Windows Programming Tips\|aquí]] sobre no usar ciertas versiones de FPC/Lazarus Win64.
16	16
17	17		### Acceso directo a SQLite (Producto Comercial)
18	18
19	19		Puedes utilizar una forma sencilla para conectar SQLite con Lazarus. Estos componentes se llaman LiteDAC, SQLite Data Access Components (LiteDAC) es una librería de componentes que aportan conectividad nativa con SQLite desde Lazarus y FreePascal bajo Windows, macOS, iOS, Android, Linux y FreeBSD tanto para plataformas de 32 como de 64 bits. LiteDAC está diseñado para programadores que quieran diseñar aplicaciones de bases de datos en plataforma cruzada tanto para escritorio como móvil sin tener que desplegar librerías adicionales. Puedes descargar una versión de prueba de este producto comercial en componentes Lazarus.
20	20
21	21		#### Soporte para Spatialite
22	22
23	23		Spatialite son extensiones GIS (Geographic Information System) para SQLite que se pueden utilizar dentro de SQLDB. Ver [[Spatialite]].
24	24
25	25		#### Soporta de encriptación para SQLite
26	26
27	27		En versiones recientes de FPC (implementadas en Marzo de 2012), SQLDB incluye soporte para algunas versiones extendidas de SQLite3 que encriptan la base de datos SQLite mediante el algoritmo AES. Utiliza la propiedad password para establecer la clave de encriptación.
28	28
29	29		Ejemplos:
30	30
31	31		- [SQLCipher](http://sqlcipher.net/): código abierto (open source), e.g. binarios Windows no disponibles sin coste, no son libres (tienes que compilarlos por ti mismo).
32	32
33	33		- [System.Data.SQLite](http://system.data.sqlite.org): código abierto (open source), binarios disponibles para Windows (32, 64, CE), descarga e.g uno de los binarios precompilados y renombra SQLite.Interop.dll como sqlite3.dll (si estás utilizando los enlazados estáticamente, presumiblemente necesitas renombrar System.Data.SQLite.DLL como sqlite3.dll)
34	34
35	35		- [wxSQLite3](http://wxcode.sourceforge.net/docs/wxsqlite3): open source, disponibles algunos binarios para Linux (ex: <https://launchpad.net/ubuntu/oneiric/+package/libwxsqlite3-2.8-0>)
36	36
37	37		### Zeos
38	38
39	39		También se puede utilizar el paquete Zeos con bases de datos SQLite con FreePascal / Lazarus.
40	40
41	41		- [Zeos](http://zeos.firmos.at)
42	42
43	43		### SQLitePass
44	44
45	45		- Componentes [SqlitePass](http://source.online.free.fr/). Estado: desconocido.
46	46
47	47		### TSQLite3Dataset y TSQLiteDataset
48	48
49	49		Existen paquetes diferenciados tales como TSQLiteDataset (unidad sqliteds) y TSQLite3Dataset (unidad sqlite3ds); leer más abajo para una descripción sobre como utilizarlos. Para encontrar la API de referencia y más tutoriales puedes visitar el [sitio de sqlite4fpc](http://sqlite4fpc.yolasite.com/).
50	50
51	51		TSqliteDataset y TSqlite3Dataset son descendientes de TDataset que acceden, respectivamente a bases de datos SQLite 2.8.x y 3.x.x. Para nuevos proyectos debería utilizarse presumiblemente TSQlite3Dataset como SQLite 3.x (es la versión actual).
52	52
53	53		A continuación se muestra un listado de las principales ventajas y desventajas en comparación con otros controladores/métodos de acceso de FPC/Lazarus.
54	54
55	55		Ventajas:
56	56
57	57		- Flexible: los programadores pueden escoger entre utilizar o no el lenguaje SQL, permitiendo trabajar con esquemas de tablas simples o con esquemas más complejos que permite SQL/SQLite.
58	58
59	59		Desventajas:
60	60
61	61		- El cambio hacia otras bases de datos es más difícil que si se utilizan componentes SQLDB o Zeos.
62	62
63	63		## Utilizando componentes SQLdb con SQLite
64	64
65	65		Estas instrucciones se centran en SQLDB (la TSQLite3Connection) específicamente para SQLite. Para una visión general, echa un vistazo a [[SqlDBHowto\|SqlDBHowto/es]] la cual tiene bastante información útil sobre componentes SQLdb.
66	66
67	67		Para un tutorial sobre como crear un programa de base de datos con interface gráfica de usuario (GUI) escrita para SQLite/SQLDB (así como para Firebird/SQLDB, PostgreSQL/SQLDB, básicamente soporta cualquier RDBMS SQLDB)se puede visitar [[SQLdb Tutorial1/es]].
68	68
69	69		Utilizaremos una combinación de tres componentes de la pestaña SQLdb de Lazarus: TSQLite3Connection, TSQLTransaction y TSQLQuery. TSQLQuery actúa como nuestro TDataset; en el caso más simple representa una de nuestras tablas. En pos de la simplicidad: asegúrate de tener previamente una base de datos SQLite y que no tienes que crear una nueva en ese instante.
70	70
71	71		TSQLite3Connection se puede encontrar en la unidad sqlite3conn, si necesitas declararla por ti mismo o si estás trabajando en FreePascal.
72	72
73	73		Los tres componentes están conectados entre ellos como es habitual: en TSQLQuery hay que establecer las propiedades Database y Transaction, en TSQLTransaction la propiedad Database. No hay mucho más que hacer en los componentes Transaction y Connection, la mayor parte de las cosas interesantes se realizarán en el componente TSQLQuery.
74	74
75	75		A continuación se explica como configurar los componentes:
76	76
77	77		##### TSQLite3Connection
78	78
79	79		- DatabaseName: establecer esta propiedad con el nombre del fichero SQLite (¡trayecto absoluto!). Desafortunadamente, no se puede simplemente utilizar un trayecto relativo que trabaje sin cambios tanto en tiempo de ejecución como de diseño *¿es esto todavía cierto? ¿No puedes simplemente copiar el fichero de base de datos en un post-build shell scrip o enlace simbólico al mismo?*. Deberías asegurarte que la aplicación comienza con la ruta correcta al fichero de forma programática, sin problema de lo que contenga en tiempo de diseño.
80	80
81	81		Por ejemplo bajo Linux:
82	82
83	83		``` pascal
84	84		SQLiteLibraryName:='./sqlite3.so';
85	85		```
86	86
87	87		o bien bajo Windows:
88	88
89	89		``` pascal
90	90		SQLiteLibraryName:='./sqlite3.dll';
91	91		```
92	92
93	93		##### TSQLQuery
94	94
95	95		- SQL: Establécelo a una simple consulta de selección sobre cualquiera de tus tablas. Por ejemplo, si tienes una tabla llamada 'foo' y necesitas que este dataset represente a dicha tabla entonces utiliza lo siguiente:
96	96
97	97		``` SQL
98	98		SELECT * FROM foo
99	99		```
100	100
101	101		- Active: establécelo a True desde el IDE para testear si todo está configurado correctamente. Esto además activará automáticamente los objetos transaction y connection. Si recibes un mensaje de error entonces o bien DatabaseName de la conexión no es correcta o la query de SQL está mal. Posteriormente, cuando terminemos de añadir todos los campos (ver más abajo) establecemos transaction y connection nuevo como inactivos. No queremos que el IDE bloquee la base de datos SQLite cuando testeamos la aplicación (recuerda: ¡ monousuario !).
102	102
103	103		- Probablemente no sea necesario para el funcionamiento adecuado - tendrá que ser verificado (June 2012) Ahora ya podemos añadir campos a nuestro TSQLQuery. Mientras los componentes están todavía establecidos como activos haz un click en el pulsador derecho y "Edición de campos...". Add Click en el pulsador "+" y añade campos. Esto listará todos los campos retornados por la consulta SQL. Añade cuantos campos necesites, también puedes añadir aquí campos lookupAdd; en este caso asegúrate de que tienes ya definidos todos los campos necesarios en el otro dataset antes de comenzar a añadir campos lookup que hagan referencias a los mismos. Si la tabla tiene muchas columnas y no las necesitas todas, pudes especificar únicamente las que quieres, puedes además hace un poco más específica la consulta SQL, por ejemplo:
104	104
105	105		``` SQL
106	106		SELECT campo1, campo2, campo5 FROM foo where campo3 = campo4
107	107		```
108	108
109	109		.
110	110
111	111		- En el código hay que lamar a SQLQuery.ApplyUpdates y SQLTransaction.Commit (o CommitRetaining para que nuestros controles visuales sigan mostrando nuestros datos), los eventos TSQLQuery.AfterPost y AfterInsert son buenos candidatos para esta tarea cuando se utlizan con controles enlazados a datos(data aware controls), pero se pueden posponer estas llamadas para otro momento. Si no se realizan estas llamadas, las tablas no serán actualizadas.
112	112
113	113		- "La Base de datos está bloqueada": El IDE todavía podría estar bloqueando la base de datos (SQLite es una base de datos de monousuario), es probable que olvidaras de poner los componentes inactivos y desconectados de nuevo después de terminar la definición de los campos de los objetos TSQLQuery. Utiliza el evento OnCreate del formulario para establecer la ruta y activar los objetos en tiempo de ejecución. La mayor parte de las cosas que ha establecido en el TSQLQuery desde el IDE no requieren (y algunos ni siquiera lo permiten) estar activos en tiempo de diseño, la única excepción es la definición de los campos en que quieres leer el diseño de la tabla, en tiempo de diseño estar inactivos debe ser el estado normal.
114	114
115	115		- Tus tablas deberían tener todas una primary key (llave primaria) y asegurarse de que el correspondiente campo tenga pfInKey y nada más en sus PoviderFlags (estos flags controlan como y donde se utiliza el campo cuando se contruyen automáticamente las consultas update y delete).
116	116
117	117		- Si estás utilizando campos lookup
118	118
119	119		- - asegurate de que ProviderFlags para el campo lookup se encuentra completamente vacío de forma que no trate de utilizar su nombre en una consulta update. El campo lookup por si mismo no es un campo de datos, únicamente actúa sobre el valor de otro campo, el correspondiente campo llave, y únicamente se utilizará posteriormente este campo llave en las consultas update. Puedes establecer el campo key a oculto porque lo habitual es que no necestes que se muestre en tu DBGrid pero si que necesta estar definido.
120	120
121	121		- - LookupCache debe establecerse a True. A fecga de escribir esto por alguna razón el campo lookup no muestran anything otherwise (pero todavía funciona) y extrañamente lo opuesto es el caso cuando se trabaja con TSQLite3Dataset u otros componentes TXXXDataset, aquí deben establecerse a False. No estoy todavía seguro de como es el comportamiento adecuado o de si se trata de un error. Si tienes los ProviderFlags de todos tus campos establecidos correctamente entonces debería ser posible crear el SQL que necesitemos sobre la marcha. Para más detalles sobre InsertSQL, UpdateSQL y DeleteSQL, ver [[Working With TSQLQuery\|Working_With_TSQLQuery#TSQLQuery.InsertSQL.2C_TSQLQuery.UpdateSQL_and_TSQLQuery.DeleteSQL:_Basic_Use_of_Parameters/es]].
122	122
123	123		Después de tener todo lo anteriormente configurado correctamente ya se debería poder utilizar TSQLQuery como con cualquier otro TDataSet, tanto manipulando los datos mediante programación o emplaando un TDataSource en el formulario, conectándolo con TSQLQuery y entonces utilizando controles como TDBGrid, etc.
124	124
125	125		##### Creando una Base de Datos
126	126
127	127		El método [TSQLite3Connection.CreateDB](http://www.freepascal.org/docs-html/fcl/sqldb/tsqlconnection.createdb.html) heredados de la clase padre actulamente no hace nada; para crear una base de datos, si es que no existe una ya, simplemente tiene que escribir la tabla de datos de forma similar a la del siguiente ejemplo:
128	128
129	129		(Código estraido del ejemplo sqlite_encryption_pragma que se incluye a partir de Lazarus 1.3)
130	130
131	131		``` pascal
132	132		var
133	133		newFile : Boolean;
134	134		begin
135	135
136	136		SQLite3Connection1.Close; // Asegura que connection está cerrado al inicio (al ser una base de datos monousuario).
137	137
138	138		try
139	139		// Ya que estamos creando la base de datos por primera vez,
140	140		// chequeamos opr si ya existiese ya que nos daría error si es así.
141	141
142	142		newFile := not FileExists(SQLite3Connection1.DatabaseName);
143	143
144	144		if newFile then
145	145		begin
146	146		// Crear la base de datos y las tablas.
147	147		try
148	148		SQLite3Connection1.Open; // Abrimos la conexión
149	149		SQLTransaction1.Active := true; // Establecemos activa la transacción.
150	150
151	151		// Aquí es donde establecemos una tabla llamada "DATA" dentro de la base de datos con ExecuteDirect.
152	152
153	153		SQLite3Connection1.ExecuteDirect('CREATE TABLE "DATA"('+
154	154		' "id" Integer NOT NULL PRIMARY KEY AUTOINCREMENT,'+
155	155		' "Current_Time" DateTime NOT NULL,'+
156	156		' "User_Name" Char(128) NOT NULL,'+
157	157		' "Info" Char(128) NOT NULL);');
158	158
159	159		// En este caso crea la tabla Data con id como llave primaria, que no admite entradas NULL y que se autoincrementa.
160	160		// Crea 3 campos adicionales que no admite entrada NULL uno de tipo DateTime otro dos 128 caracteres.
161	161
162	162		// Creando un índice UNICO basado en id en la tabla DATA.
163	163
164	164		SQLite3Connection1.ExecuteDirect('CREATE UNIQUE INDEX "Data_id_idx" ON "DATA"( "id" );');
165	165
166	166		SQLTransaction1.Commit; // Enviamos y hacemos efectivo lo anterior.
167	167
168	168		ShowMessage('Base de datos Creada Correctamente.');
169	169		except
170	170		ShowMessage('No se ha podido crear la nueva Base de Datos');
171	171		end;
172	172		end;
173	173		except
174	174		ShowMessage('No ha sido posible chequear si el fichero de Base de Datos existe');
175	175		end;
176	176		end;
177	177		```
178	178
179	179		### Creando collations definidos por el usuario
180	180
181	181		``` pascal
182	182		// utf8 case-sensitive compare callback function
183	183		function UTF8xCompare(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
184	184		var S1, S2: AnsiString;
185	185		begin
186	186		SetString(S1, data1, len1);
187	187		SetString(S2, data2, len2);
188	188		Result := UnicodeCompareStr(UTF8Decode(S1), UTF8Decode(S2));
189	189		end;
190	190
191	191		// utf8 case-insensitive compare callback function
192	192		function UTF8xCompare_CI(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
193	193		var S1, S2: AnsiString;
194	194		begin
195	195		SetString(S1, data1, len1);
196	196		SetString(S2, data2, len2);
197	197		Result := UnicodeCompareText(UTF8Decode(S1), UTF8Decode(S2));
198	198		end;
199	199
200	200		// register collation using SQLite3 API (requires sqlite3dyn unit):
201	201		sqlite3_create_collation(SQLite3.Handle, 'UTF8_CI', SQLITE_UTF8, nil, @UTF8xCompare_CI);
202	202		// or using method of TSQLite3Connection:
203	203		CreateCollation('UTF8_CI',1,nil,@UTF8xCompare_CI);
204	204
205	205		// now we can use case-insensitive comparison in SQL like:
206	206		// SELECT * FORM table1 WHERE column1 COLLATE UTF8_CI = 'á'
207	207
208	208		// but this does not work for LIKE operator
209	209		// in order to support also LIKE operator we must overload default LIKE function using sqlite3_create_function()
210	210		// http://www.sqlite.org/lang_corefunc.html#like
211	211		```
212	212
213	213		### Creando funciones definidas por el usuario
214	214
215	215		``` pascal
216	216		// ejemplo de sobrecarga de la funcion LOWER() de SQLite con una función creada por el usuario
217	217		procedure UTF8xLower(ctx: psqlite3_context; N: cint; V: ppsqlite3_value); cdecl;
218	218		var S: AnsiString;
219	219		begin
220	220		SetString(S, sqlite3_value_text(V[0]), sqlite3_value_bytes(V[0]));
221	221		S := UTF8Encode(AnsiLowerCase(UTF8Decode(S)));
222	222		sqlite3_result_text(ctx, PAnsiChar(S), Length(S), sqlite3_destructor_type(SQLITE_TRANSIENT));
223	223		end;
224	224
225	225		// registro de la nueva funccion LOWER() usando la API de SQLite3 (requiere la unidad sqlite3dyn):
226	226		sqlite3_create_function(SQLite3.Handle, 'lower', 1, SQLITE_UTF8 or SQLITE_DETERMINISTIC, nil, @UTF8xLower, nil, nil);
227	227		```
228	228
229	229		### SQLite3 y Fechas
230	230
231	231		- SQLite 3 no almacena las fechas como un valor especial DateTime. Las puede almacenar como strings, doubles o integers - ver <http://www.sqlite.org/datatype3.html#datetime>.
232	232
233	233		- En cadenas el separador de fecha es '-' acorde al estandar SQL ISO 8601. POr tanto, si realizas un INSERT utilizando la función interna DATE, entonces almacenará algo similar a 'YYYY-MM-DD'.
234	234
235	235		- La lectura de un valor DateTime puede causar problemas para DataSets si se almacena como cadena: el cualificador .AsDateTime puede 'pero puede resolverse utilizando algo como `strftime(``%d/%m/%Y``,recdate) AS sqlite3recdate` en tu sentencia SQL SELECT, lo cual fuerza a SQLite3 a retornar el campo date en un formato específico. (el formato de cadena %d/%m/%d corresponde al formato de tu fecha local .AsDateTime que pueda ser entendida) ==\> Por favor abrir un reporte de error con una aplicación de ejemplo demostrativo si alguien detecta un error en este aspecto
236	236
237	237		- Cuando se comparar fechas almacenadas en cadenas (utilizando por ejemplo la función BETWEEN)recordar que la comparación deberá ser siempre una comparación de string, y dependerá por tanto de como se haya almacenado el valor del dato.
238	238
239	239		#### Valores por defecto para hora local en lugar de UTC
240	240
241	241		CURRENT_TIME, CURRENT_DATE y CURRENT_TIMESTAMP retornan la fecha y/u hora UTC. Para fecha y/o hora local podemos utilizar:
242	242
243		-	~~` DEFAULT (datetime('now','localtime')) para valores de fecha-hora (datetime) formateados como YYYY-MM-DD HH:MM:SS`\~~
244		-	~~` DEFAULT (date('now','localtime')) para valores de fecha formateada como YYYY-MM-DD`\~~
245		-	~~` DEFAULT (time('now','localtime')) para valores de hora formateados como HH:MM:SS`~~
	243	+	```text
	244	+	DEFAULT (datetime('now','localtime')) para valores de fecha-hora (datetime) formateados como YYYY-MM-DD HH:MM:SS
	245	+	DEFAULT (date('now','localtime')) para valores de fecha formateada como YYYY-MM-DD
	246	+	DEFAULT (time('now','localtime')) para valores de hora formateados como HH:MM:SS
	247	+	```
246	248
247	249		### Resolución de problemas sobre SQLDB y SQLite
248	250
249	251		- Tener presente que para trabajar en tiempo de diseño (campos, etc) Lazarus debe poder encontrar sqlite3.dll.
250	252		- Lo mismo cuenta para el nombre de fichero de la base de datos. Simpre utlizar trayectos absolutos si se utilizan componentes para extraer, e.g nombres de campos en tiempo de diseño. De otra manera la el IDE, al realizar la conexión, creará un fichero vacío en el directorio. En caso de problemas, comprobar si el directorio utilizado contiene una copia de tamaño 0 bytes para el fichero de base de datos.
251	253
252	254		- Si se tiene una relación maestro/detalle será necesario refrescar el dataset maestro después de realizar cada mandato insert para obtener el valor del campo de la clave ajena para el dataset detalle. Se puede realizar en el evento AfterPost del dataset maestro, usando RefreshADatasetAfterInsert para ello:
253	255
254	256		``` pascal
255	257		interface
256	258		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);overload;
257	259		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);overload;
258	260
259	261		implementation
260	262
261	263		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);
262	264		// Este procedimineto refres ca un conjunto de datos (un 'dataset') y sitúa el cursor en el último registro
263	265		// Se usa cuando el no se sabe si el 'dataset' está ordenado por una clave primaria autoeincrementada
264	266		var
265	267		vLastID: Integer;
266	268		vUpdateStatus : TUpdateStatus;
267	269		begin
268	270		vUpdateStatus := pDataset.UpdateStatus;
269	271		//Get last inserted ID in the database
270	272		pDataset.ApplyUpdates;
271	273		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
272	274		// Ahora vuelve a la fila respectiva.
273	275		if vUpdateStatus = usInserted then begin
274	276		pDataset.Refresh;
275	277		// Refrescar y vuelve a la fila respectiva.
276	278		pDataset.Locate(pKeyField,vLastID,[]);
277	279		end;
278	280		end;
279	281
280	282		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);
281	283		// Este procedimineto refres ca un conjunto de datos (un 'dataset') y sitúa el cursor en el último registro
282	284		// Se usa cuando el 'dataset' está ordenado por una clave primaria autoeincrementada
283	285		var
284	286		vLastID: Integer;
285	287		vUpdateStatus : TUpdateStatus;
286	288		begin
287	289		vUpdateStatus := pDataset.UpdateStatus;
288	290		pDataset.ApplyUpdates;
289	291		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
290	292		if vUpdateStatus = usInserted then begin
291	293		pDataset.Refresh;
292	294		//Dangerous!
293	295		pDataSet.Last;
294	296		end;
295	297		end;
296	298
297	299		procedure TDataModule1.SQLQuery1AfterPost(DataSet: TDataSet);
298	300		begin
299	301		RefreshADatasetAfterInsert(Dataset as TSQLQuery); //Si el conjunto de datos está ordenado por la clave primaria
300	302		end;
301	303
302	304		procedure TDataModule1.SQLQuery2AfterPost(DataSet: TDataSet);
303	305		begin
304	306		RefreshADatasetAfterInsert(Dataset as TSQLQuery, 'ID'); // Si no se está seguro de si los datos están ordenados por la clave primaria
305	307		end;
306	308		```
307	309
308	310		### Vacuum y otras operaciones que deben realizarse fuera de una transacción
309	311
310	312		SQLdb parece requerir siempre una transacción, pero algunas operaciones tales como Pragma y Vacuum se deben realizar fuera de una transacción. Para ello hay que finalizar la transacción, ejecutar lo que se necesite y volver a iniciar la transacción nuevamente (de modo que SQLdb no quede confundido:)
311	313
312	314		``` pascal
313	315		// commit cualquier operación pendiente y utilizar una sqlconnection "fresca".
314	316		Conn.ExecuteDirect('End Transaction'); // Finalizar la transacción iniciada por SQLdb
315	317		Conn.ExecuteDirect('Vacuum'); // Realizar el Vacuum.
316	318		Conn.ExecuteDirect('Begin Transaction'); // Comenzar una nueva transacción para utilizar con SQLdb.
317	319		```
318	320
319	321		### Tips
320	322
321	323		- Utiliza el procedimiento TSQLite3Connection.CreateDB para crear una nueva base de datos SQLite.
322	324
323	325		## Utilizando TSQLite3Dataset
324	326
325	327		Esta sección detalla como utilizar los componentes TSQLite3Dataset y TSQLite3Dataset para acceder a bases de datos SQlite. por Luiz Américo luizmed(at)oi(dot)com(dot)br
326	328
327	329		#### Requerimientos
328	330
329	331		- Para bases de datos sqlite2 (heredado):
330	332		- FPC 2.0.0 or higher
331	333		- Lazarus 0.9.10 o superior.
332	334		- SQLite versión 2.8.15 o superior*
333	335
334	336		- SQLite2 ya no está en fase de mantenimiento y el fichero binario ya no se encuentra en el sitio de sqlite.
335	337
336	338		- Para bases e datos SQLite3:
337	339		- FPC 2.0.2 o superior.
338	340		- Lazarus 0.9.11 (svn revisión 8443) o superior.
339	341		- SQLite versión 3.2.1 o superior (mira en [www.sqlite.org](http://www.sqlite.org))
340	342
341	343		Antes de iniciar un proyecto Lazarus, asegúrate de que:
342	344
343	345		- La librería de SQLite está en cualquiera de estos dos sitios:
344	346		- En la variable PATH del sistema.
345	347		- En el directorio donde se genera el ejecutable (del proyecto actual) - esta opción puede que funcione solamente bajo Windows.
346	348		- Bajo Linux, sitúa cmem como primera unidad en la claúsula uses del programa principal.
347	349		- En Debian, Ubuntu y otras distros basadas en Debian, en orden a contruir el IDE de Lazarus debes instalar los paquetes libsqlite-dev/libsqlite3-dev, no solamente sqlite/sqlite3 (Esto también se aplica a OpenSuSe).
348	350
349	351		#### Como utilizar (utilización básica)
350	352
351	353		Instalar el paquete que se encuentra en el directorio /components/sqlite (ver instrucciones [[Install Packages/es\|aquí]])
352	354
353	355		En tiempo de diseño, establecer las siguientes propiedades:
354	356
355	357		- FileName: trayecto al fichero sqlite \[requerido\]
356	358		- TableName: nombre de la table utilizado en la sentencia sql \[requerido\]
357	359		- SQL: a SQL select statement \[opcional\]
358	360		- SaveOnClose: el valor por defecto es false, lo cual significa que los cambios no se guardan. Se puede cambiar a true. \[opcional\]
359	361		- Active: necesita ser establecido en tiempo de diseño o al comienzo del programa. \[requerido\]
360	362
361	363		Creando una tabla (Dataset)
362	364
363	365		Haz doble click en el icono del componenete o utiliza el elemento 'Create Table' de menú emergente que aparece cuando se cliquea el pulsador derecho del ratón. Se mostrará un editor de tabla auto-explicable.
364	366
365	367		Estos son todos los tipos soportados por TSqliteDataset y TSqlite3Dataset:
366	368
367	369		- Integer
368	370		- AutoInc
369	371		- String
370	372		- Memo
371	373		- Bool
372	374		- Float
373	375		- Word
374	376		- DateTime
375	377		- Date
376	378		- Time
377	379		- LargeInt
378	380		- Currency
379	381
380	382		Recabando los datos
381	383
382	384		Después de crear la tabla o con una tabla creada previamente, abrir el dataset con el método Open.
383	385
384	386		Si la propiedad SQL no se ha establecido a un valor entonces se recogen todos los registros de todos los campos, lo mismo que si se establece SQL a:
385	387
386	388		``` pascal
387	389		SQL := 'Select * from TABLENAME';
388	390		```
389	391
390	392		Applying changes to the underlying datafile
391	393
392	394		Para utilizar la función ApplyUpdates, el dataset debe contener al menos un campo que cumpla completamente los requerimientos de clave primaria (Primary Key) (los valores deben ser por tanto ÚNICOS y distintos de NULL)
393	395
394	396		Es posible hacer esto de dos maneras:
395	397
396	398		- Establecer la propiedad de la clave primaria (PrimaryKey) con el nombre del campo de la clave primaria (Primary Key).
397	399		- Añadir un campo autoincrementable (AutoInc) (Esto es lo más fácil dado que TSqliteDataSet automáticamente lo maneja como una clave primaria (Primary Key)).
398	400
399	401		Si se establece una de las dos condiciones, entonces simplemente llamar a
400	402
401	403		``` pascal
402	404		ApplyUpdates;
403	405		```
404	406
405	407
406	408
407	409
408	410
409	411		##### Master/detail example
410	412
411	413		AUn ejemplo de implementación master/detail (customer/orders) using locate can be found here: [[TSqlite3 Master Detail Example]]. Implementing master/detail with locate se puee hacer también en SQLDB y probablemente en Zeos.
412	414
413	415		#### Remarks
414	416
415	417		- A pesar de haberse testeado con 10.000 registros y haber funcionado bien, hay que tener en cuenta que TSqliteDataset mantiene todos los datos en memoria, por tanto recuerda que hay que recabar solamente los datos necesarios (especialmente con campos tipo Memo).
416	418		- El mismo fichero de datos (Filename property) puede albergar varias tablas/conjuntos de datos (datasets).
417	419		- Se pueden crear simultaneamente varios conjuntos de datos (diferentes combinaciones de campos) utilizando la misma tabla.
418	420		- Es posible filtrar los datos mediante el uso de sentencias WHERE de SQL, cerrando y reabriendo el dataset (o llamando al método RefetchData ). En este caso el orden y número de campos deben permanecer igual.
419	421		- Es posible además utilizar complejas sentencias SQL recurriendo a los alias, joins, views y tablas múltiples (recuerda que deben residir en el mismo fichero de datos) pero en este caso ApplyUpdates no funcionará. Si alguien necesita utilizar consultas complejas y aplicar los cambios al fichero de datos, envíame un correo y te daré algunas sugerencias de como hacerlo.
420	422
421	423		- Estableciendo el nombre de fichero a un fichero de datos sqlite no creado por el TSqliteDataset y abriéndolo está permitido pero algunos campos no tendrán detectado correctamente el tipo de campo. Estos serán tratados como campos String.
422	424
423	425		Se pueden econtrar ejemplo genéricos en el directorio SVN fpc/fcl-db/src/sqlite.
424	426
425	427		#### Utilidades de apoyo
426	428
427	429		Como ayuda a la hora de manejar bases de datos SQLite tenemos a nuestra disposición algunas utilidades que nos pueden facilitar el trabajo de su creación / visualización / mantenimiento a la hora de crear un programa, para ello se listan las siguientes:
428	430
429	431		- DB Browser for SQLite: <https://github.com/sqlitebrowser/sqlitebrowser>
430	432
431	433		- LazSQLX: <https://sourceforge.net/directory/os:windows/?q=lazsqlx>
432	434
433	435		## See also
434	436
435	437		- [[SQLdb Tutorial1/es\|Tutorial de Sqldb]]
436	438		- [[SqlDBHowto/es\|Información General sobre Bases de Datos SQL]]
437	439		- [[Working With TSQLQuery/es\|Información sobre TSQLQuery y Bases de Datos SQL]]
438	440		- [Sitio oficial de SQLite](http://www.sqlite.org)
439	441
440	442		---
441	443		From the Free Pascal wiki, page "SQLite/es", as it stood on 2023-12-07 after a change by Iskraelectrica, 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).
442	444		Category: Castellano
443	445		Category: Español

Back to history