SQLite/es: what changed

Revision 1 to 2. 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		-	~~<figure>~~
14		-	~~<img src="sqldbcomponents.png" title=" center" />~~
15		-	~~<figcaption> center</figcaption>~~
16		-	~~</figure>~~
	13	+	![](/wiki-images/c/cc/Sqldbcomponents.png)
17	14
18	15		Win64: por favor ver las advertencias [[Windows Programming Tips\|aquí]] sobre no usar ciertas versiones de FPC/Lazarus Win64.
19	16
20	17		### Acceso directo a SQLite (Producto Comercial)
21	18
22	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.
23	20
24	21		#### Soporte para Spatialite
25	22
26	23		Spatialite son extensiones GIS (Geographic Information System) para SQLite que se pueden utilizar dentro de SQLDB. Ver [[Spatialite]].
27	24
28	25		#### Soporta de encriptación para SQLite
29	26
30	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.
31	28
32	29		Ejemplos:
33	30
34	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).
35	32
36	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)
37	34
38	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>)
39	36
40	37		### Zeos
41	38
42	39		También se puede utilizar el paquete Zeos con bases de datos SQLite con FreePascal / Lazarus.
43	40
44	41		- [Zeos](http://zeos.firmos.at)
45	42
46	43		### SQLitePass
47	44
48	45		- Componentes [SqlitePass](http://source.online.free.fr/). Estado: desconocido.
49	46
50	47		### TSQLite3Dataset y TSQLiteDataset
51	48
52	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/).
53	50
54	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).
55	52
56	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.
57	54
58	55		Ventajas:
59	56
60	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.
61	58
62	59		Desventajas:
63	60
64	61		- El cambio hacia otras bases de datos es más difícil que si se utilizan componentes SQLDB o Zeos.
65	62
66	63		## Utilizando componentes SQLdb con SQLite
67	64
68	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.
69	66
70	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]].
71	68
72	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.
73	70
74	71		TSQLite3Connection se puede encontrar en la unidad sqlite3conn, si necesitas declararla por ti mismo o si estás trabajando en FreePascal.
75	72
76	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.
77	74
78	75		A continuación se explica como configurar los componentes:
79	76
80	77		##### TSQLite3Connection
81	78
82	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.
83	80
84	81		Por ejemplo bajo Linux:
85	82
86	83		``` pascal
87	84		SQLiteLibraryName:='./sqlite3.so';
88	85		```
89	86
90	87		o bien bajo Windows:
91	88
92	89		``` pascal
93	90		SQLiteLibraryName:='./sqlite3.dll';
94	91		```
95	92
96	93		##### TSQLQuery
97	94
98	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:
99	96
100	97		``` SQL
101	98		SELECT * FROM foo
102	99		```
103	100
104	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 !).
105	102
106	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:
107	104
108	105		``` SQL
109	106		SELECT campo1, campo2, campo5 FROM foo where campo3 = campo4
110	107		```
111	108
112	109		.
113	110
114	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.
115	112
116	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.
117	114
118	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).
119	116
120	117		- Si estás utilizando campos lookup
121	118
122	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.
123	120
124	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]].
125	122
126	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.
127	124
128	125		##### Creando una Base de Datos
129	126
130	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:
131	128
132	129		(Código estraido del ejemplo sqlite_encryption_pragma que se incluye a partir de Lazarus 1.3)
133	130
134	131		``` pascal
135	132		var
136	133		newFile : Boolean;
137	134		begin
138	135
139	136		SQLite3Connection1.Close; // Asegura que connection está cerrado al inicio (al ser una base de datos monousuario).
140	137
141	138		try
142	139		// Ya que estamos creando la base de datos por primera vez,
143	140		// chequeamos opr si ya existiese ya que nos daría error si es así.
144	141
145	142		newFile := not FileExists(SQLite3Connection1.DatabaseName);
146	143
147	144		if newFile then
148	145		begin
149	146		// Crear la base de datos y las tablas.
150	147		try
151	148		SQLite3Connection1.Open; // Abrimos la conexión
152	149		SQLTransaction1.Active := true; // Establecemos activa la transacción.
153	150
154	151		// Aquí es donde establecemos una tabla llamada "DATA" dentro de la base de datos con ExecuteDirect.
155	152
156	153		SQLite3Connection1.ExecuteDirect('CREATE TABLE "DATA"('+
157	154		' "id" Integer NOT NULL PRIMARY KEY AUTOINCREMENT,'+
158	155		' "Current_Time" DateTime NOT NULL,'+
159	156		' "User_Name" Char(128) NOT NULL,'+
160	157		' "Info" Char(128) NOT NULL);');
161	158
162	159		// En este caso crea la tabla Data con id como llave primaria, que no admite entradas NULL y que se autoincrementa.
163	160		// Crea 3 campos adicionales que no admite entrada NULL uno de tipo DateTime otro dos 128 caracteres.
164	161
165	162		// Creando un índice UNICO basado en id en la tabla DATA.
166	163
167	164		SQLite3Connection1.ExecuteDirect('CREATE UNIQUE INDEX "Data_id_idx" ON "DATA"( "id" );');
168	165
169	166		SQLTransaction1.Commit; // Enviamos y hacemos efectivo lo anterior.
170	167
171	168		ShowMessage('Base de datos Creada Correctamente.');
172	169		except
173	170		ShowMessage('No se ha podido crear la nueva Base de Datos');
174	171		end;
175	172		end;
176	173		except
177	174		ShowMessage('No ha sido posible chequear si el fichero de Base de Datos existe');
178	175		end;
179	176		end;
180	177		```
181	178
182	179		### Creando collations definidos por el usuario
183	180
184	181		``` pascal
185	182		// utf8 case-sensitive compare callback function
186	183		function UTF8xCompare(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
187	184		var S1, S2: AnsiString;
188	185		begin
189	186		SetString(S1, data1, len1);
190	187		SetString(S2, data2, len2);
191	188		Result := UnicodeCompareStr(UTF8Decode(S1), UTF8Decode(S2));
192	189		end;
193	190
194	191		// utf8 case-insensitive compare callback function
195	192		function UTF8xCompare_CI(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
196	193		var S1, S2: AnsiString;
197	194		begin
198	195		SetString(S1, data1, len1);
199	196		SetString(S2, data2, len2);
200	197		Result := UnicodeCompareText(UTF8Decode(S1), UTF8Decode(S2));
201	198		end;
202	199
203	200		// register collation using SQLite3 API (requires sqlite3dyn unit):
204	201		sqlite3_create_collation(SQLite3.Handle, 'UTF8_CI', SQLITE_UTF8, nil, @UTF8xCompare_CI);
205	202		// or using method of TSQLite3Connection:
206	203		CreateCollation('UTF8_CI',1,nil,@UTF8xCompare_CI);
207	204
208	205		// now we can use case-insensitive comparison in SQL like:
209	206		// SELECT * FORM table1 WHERE column1 COLLATE UTF8_CI = 'á'
210	207
211	208		// but this does not work for LIKE operator
212	209		// in order to support also LIKE operator we must overload default LIKE function using sqlite3_create_function()
213	210		// http://www.sqlite.org/lang_corefunc.html#like
214	211		```
215	212
216	213		### Creando funciones definidas por el usuario
217	214
218	215		``` pascal
219	216		// ejemplo de sobrecarga de la funcion LOWER() de SQLite con una función creada por el usuario
220	217		procedure UTF8xLower(ctx: psqlite3_context; N: cint; V: ppsqlite3_value); cdecl;
221	218		var S: AnsiString;
222	219		begin
223	220		SetString(S, sqlite3_value_text(V[0]), sqlite3_value_bytes(V[0]));
224	221		S := UTF8Encode(AnsiLowerCase(UTF8Decode(S)));
225	222		sqlite3_result_text(ctx, PAnsiChar(S), Length(S), sqlite3_destructor_type(SQLITE_TRANSIENT));
226	223		end;
227	224
228	225		// registro de la nueva funccion LOWER() usando la API de SQLite3 (requiere la unidad sqlite3dyn):
229	226		sqlite3_create_function(SQLite3.Handle, 'lower', 1, SQLITE_UTF8 or SQLITE_DETERMINISTIC, nil, @UTF8xLower, nil, nil);
230	227		```
231	228
232	229		### SQLite3 y Fechas
233	230
234	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>.
235	232
236	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'.
237	234
238	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
239	236
240		-	- 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 <b>string</b>, y dependerá por tanto de como se haya almacenado el valor del dato.
	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.
241	238
242	239		#### Valores por defecto para hora local en lugar de UTC
243	240
244	241		CURRENT_TIME, CURRENT_DATE y CURRENT_TIMESTAMP retornan la fecha y/u hora UTC. Para fecha y/o hora local podemos utilizar:
245	242
246	243		` DEFAULT (datetime('now','localtime')) para valores de fecha-hora (datetime) formateados como YYYY-MM-DD HH:MM:SS`\
247	244		` DEFAULT (date('now','localtime')) para valores de fecha formateada como YYYY-MM-DD`\
248	245		` DEFAULT (time('now','localtime')) para valores de hora formateados como HH:MM:SS`
249	246
250	247		### Resolución de problemas sobre SQLDB y SQLite
251	248
252	249		- Tener presente que para trabajar en tiempo de diseño (campos, etc) Lazarus debe poder encontrar sqlite3.dll.
253	250		- 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.
254	251
255	252		- 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:
256	253
257	254		``` pascal
258	255		interface
259	256		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);overload;
260	257		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);overload;
261	258
262	259		implementation
263	260
264	261		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);
265	262		// Este procedimineto refres ca un conjunto de datos (un 'dataset') y sitúa el cursor en el último registro
266	263		// Se usa cuando el no se sabe si el 'dataset' está ordenado por una clave primaria autoeincrementada
267	264		var
268	265		vLastID: Integer;
269	266		vUpdateStatus : TUpdateStatus;
270	267		begin
271	268		vUpdateStatus := pDataset.UpdateStatus;
272	269		//Get last inserted ID in the database
273	270		pDataset.ApplyUpdates;
274	271		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
275	272		// Ahora vuelve a la fila respectiva.
276	273		if vUpdateStatus = usInserted then begin
277	274		pDataset.Refresh;
278	275		// Refrescar y vuelve a la fila respectiva.
279	276		pDataset.Locate(pKeyField,vLastID,[]);
280	277		end;
281	278		end;
282	279
283	280		procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);
284	281		// Este procedimineto refres ca un conjunto de datos (un 'dataset') y sitúa el cursor en el último registro
285	282		// Se usa cuando el 'dataset' está ordenado por una clave primaria autoeincrementada
286	283		var
287	284		vLastID: Integer;
288	285		vUpdateStatus : TUpdateStatus;
289	286		begin
290	287		vUpdateStatus := pDataset.UpdateStatus;
291	288		pDataset.ApplyUpdates;
292	289		vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
293	290		if vUpdateStatus = usInserted then begin
294	291		pDataset.Refresh;
295	292		//Dangerous!
296	293		pDataSet.Last;
297	294		end;
298	295		end;
299	296
300	297		procedure TDataModule1.SQLQuery1AfterPost(DataSet: TDataSet);
301	298		begin
302	299		RefreshADatasetAfterInsert(Dataset as TSQLQuery); //Si el conjunto de datos está ordenado por la clave primaria
303	300		end;
304	301
305	302		procedure TDataModule1.SQLQuery2AfterPost(DataSet: TDataSet);
306	303		begin
307	304		RefreshADatasetAfterInsert(Dataset as TSQLQuery, 'ID'); // Si no se está seguro de si los datos están ordenados por la clave primaria
308	305		end;
309	306		```
310	307
311	308		### Vacuum y otras operaciones que deben realizarse fuera de una transacción
312	309
313	310		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:)
314	311
315	312		``` pascal
316	313		// commit cualquier operación pendiente y utilizar una sqlconnection "fresca".
317	314		Conn.ExecuteDirect('End Transaction'); // Finalizar la transacción iniciada por SQLdb
318	315		Conn.ExecuteDirect('Vacuum'); // Realizar el Vacuum.
319	316		Conn.ExecuteDirect('Begin Transaction'); // Comenzar una nueva transacción para utilizar con SQLdb.
320	317		```
321	318
322	319		### Tips
323	320
324	321		- Utiliza el procedimiento TSQLite3Connection.CreateDB para crear una nueva base de datos SQLite.
325	322
326	323		## Utilizando TSQLite3Dataset
327	324
328	325		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
329	326
330	327		#### Requerimientos
331	328
332	329		- Para bases de datos sqlite2 (heredado):
333	330		- FPC 2.0.0 or higher
334	331		- Lazarus 0.9.10 o superior.
335	332		- SQLite versión 2.8.15 o superior*
336	333
337	334		- SQLite2 ya no está en fase de mantenimiento y el fichero binario ya no se encuentra en el sitio de sqlite.
338	335
339	336		- Para bases e datos SQLite3:
340	337		- FPC 2.0.2 o superior.
341	338		- Lazarus 0.9.11 (svn revisión 8443) o superior.
342	339		- SQLite versión 3.2.1 o superior (mira en [www.sqlite.org](http://www.sqlite.org))
343	340
344	341		Antes de iniciar un proyecto Lazarus, asegúrate de que:
345	342
346	343		- La librería de SQLite está en cualquiera de estos dos sitios:
347	344		- En la variable PATH del sistema.
348	345		- En el directorio donde se genera el ejecutable (del proyecto actual) - esta opción puede que funcione solamente bajo Windows.
349	346		- Bajo Linux, sitúa cmem como primera unidad en la claúsula uses del programa principal.
350	347		- 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).
351	348
352	349		#### Como utilizar (utilización básica)
353	350
354	351		Instalar el paquete que se encuentra en el directorio /components/sqlite (ver instrucciones [[Install Packages/es\|aquí]])
355	352
356	353		En tiempo de diseño, establecer las siguientes propiedades:
357	354
358	355		- FileName: trayecto al fichero sqlite \[requerido\]
359	356		- TableName: nombre de la table utilizado en la sentencia sql \[requerido\]
360	357		- SQL: a SQL select statement \[opcional\]
361	358		- SaveOnClose: el valor por defecto es false, lo cual significa que los cambios no se guardan. Se puede cambiar a true. \[opcional\]
362	359		- Active: necesita ser establecido en tiempo de diseño o al comienzo del programa. \[requerido\]
363	360
364	361		Creando una tabla (Dataset)
365	362
366	363		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.
367	364
368	365		Estos son todos los tipos soportados por TSqliteDataset y TSqlite3Dataset:
369	366
370	367		- Integer
371	368		- AutoInc
372	369		- String
373	370		- Memo
374	371		- Bool
375	372		- Float
376	373		- Word
377	374		- DateTime
378	375		- Date
379	376		- Time
380	377		- LargeInt
381	378		- Currency
382	379
383	380		Recabando los datos
384	381
385	382		Después de crear la tabla o con una tabla creada previamente, abrir el dataset con el método Open.
386	383
387	384		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:
388	385
389	386		``` pascal
390	387		SQL := 'Select * from TABLENAME';
391	388		```
392	389
393	390		Applying changes to the underlying datafile
394	391
395	392		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)
396	393
397	394		Es posible hacer esto de dos maneras:
398	395
399	396		- Establecer la propiedad de la clave primaria (PrimaryKey) con el nombre del campo de la clave primaria (Primary Key).
400	397		- 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)).
401	398
402	399		Si se establece una de las dos condiciones, entonces simplemente llamar a
403	400
404	401		``` pascal
405	402		ApplyUpdates;
406	403		```
407	404
408	405
409	406
410	407
411	408
412	409		##### Master/detail example
413	410
414	411		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.
415	412
416	413		#### Remarks
417	414
418	415		- 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).
419	416		- El mismo fichero de datos (Filename property) puede albergar varias tablas/conjuntos de datos (datasets).
420	417		- Se pueden crear simultaneamente varios conjuntos de datos (diferentes combinaciones de campos) utilizando la misma tabla.
421	418		- 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.
422	419		- 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.
423	420
424	421		- 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.
425	422
426	423		Se pueden econtrar ejemplo genéricos en el directorio SVN fpc/fcl-db/src/sqlite.
427	424
428	425		#### Utilidades de apoyo
429	426
430	427		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:
431	428
432	429		- DB Browser for SQLite: <https://github.com/sqlitebrowser/sqlitebrowser>
433	430
434	431		- LazSQLX: <https://sourceforge.net/directory/os:windows/?q=lazsqlx>
435	432
436	433		## See also
437	434
438	435		- [[SQLdb Tutorial1/es\|Tutorial de Sqldb]]
439	436		- [[SqlDBHowto/es\|Información General sobre Bases de Datos SQL]]
440	437		- [[Working With TSQLQuery/es\|Información sobre TSQLQuery y Bases de Datos SQL]]
441	438		- [Sitio oficial de SQLite](http://www.sqlite.org)
442	439
443	440		---
444	441		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).
445	442		Category: Castellano
446	443		Category: Español

Back to history