SqlDBHowto/es: what changed

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

Old	New		Line
1	1		## Introducción
2	2
3	3		Este texto se configura como un "cómo-hacer". Pretende responder a una serie de preguntas una por una, explicando cómo se pueden utilizar las distintas clases. Todas estas cuestiones puestas una detrás de otra forman una especie de tutoría.
4	4
5	5		Voy a tratar de esccribir de tal manera que el texto pueda ser utilizado para Lazarus, así como FreePascal. Sin embargo, los ejemplos son para FreePascal (es decir, son aplicaciones de consola)
6	6
7	7		## ¿Cómo conectarse a un servidor de base de datos?
8	8
9	9		SQLdb no se conecta a un servidor de base de datos directamente sino que utiliza el cliente correspondiente al servidor de base de datos utilizado. SQLdb envía los comandos a la librería de cliente, la cual se conecta a la base de datos y le pasa los comandos. Esto significa que una librería de cliente debe ser instalada en el equipo para establecer una conexión con una base de datos. En Windows un cliente suele ser una .dll, bajo Linux un .so y bajo OS/X una .dylib.
10	10
11	11		Cuando la librería de cliente se ha instalado correctamente puede conectarse a un servidor de base de datos utilizando un componente TSQLConnection. Hay disponibles componentes TSQLConnection para diferentes servidores de base de datos ( [[SQLdb Package/es\|ver paquete SQLdb]]) - siendo el listado de las disponibles el siguiente:
12	12
13	13		- Firebird/Interbase: TIBConnection ([[Firebird\|ver enlace]])
14	14		- MS-SQL: TMSSQLConnection (disponible desde la versión 2.6.1 de FPC,[[Lazarus Database Overview\|ver enlace]])se puede crear una conexión con el método open. Si
15	15		- MySQL v4.0: TMySQL40Connection ([[mysql\|ver enlace]])
16	16		- MySQL v4.1: TMySQL41Connection ([[mysql\|ver enlace]])
17	17		- MySQL v5.0: TMySQL50Connection ([[mysql\|ver enlace]])
18	18		- MySQL v5.1: TMySQL51Connection (disponible desde la versión 2.5.1 de FPC,[[mysql\|ver enlace]])
19	19		- MySQL v5.5: TMySQL55Connection (disponible desde la versión 2.?.? [[mysql\|ver enlace]])
20	20		- ODBC: TODBCConnection ([[ODBCConn\|ver enlace]])
21	21		- Oracle: TOracleConnection (Oracle)
22	22		- PostgreSQL: TPQConnection ([[postgresql\|ver enlace]])
23	23		- Sqlite3: TSQLite3Connection (disponible desde la versión 2.2.2 de FPC, [[SQLite\|ver enlace]])
24	24		- Sybase ASE: TSybaseConnection (disponible desde la versión 2.6.1 de FPC, [[Lazarus Database Overview\|ver enlace]])
25	25
26		-	~~<figure>~~
27		-	~~<img src="Conectores_BBDD.png" title="Conectores_BBDD.png" />~~
28		-	~~<figcaption>Conectores_BBDD.png</figcaption>~~
29		-	~~</figure>~~
	26	+	![](/wiki-images/8/8f/Conectores_BBDD.png)
30	27
31	28		Las diferencias entre las versiones de cliente MySQL son grandes, en la medida que los clientes y las conexiones no se pueden intercambiar. Con un cliente MySQL versión 4.1 instalado, tienes que utilizar un TMySQL41Connection. Si se utiliza la misma versión de librería que de cliente probablemente con la 4.1 se podría conectar a un servidor MySQL 5.0, pero el requerimiento de correspondencia librería-conector a la misma versión es necesario.
32	29
33	30		Aunque los detalles difieren entre las distintas base de datos, por lo general hay que establecer cuatro propiedades para conectarse a un servidor de base de datos:
34	31
35	32		- El nombre del servidor o su dirección IP.
36	33		- El nombre de la base de datos.
37	34		- El usuario.
38	35		- La contraseña.
39	36
40	37		Cuando estas propiedades se establecen, se puede crear una conexión con el método, open. Si falla la conexión se lanza una excepción EDatabaseError. Utiliza la propiedad connected para comprobar si la conexión se ha establecido con el servidor de base de datos. Utiliza el método close para finalizar la conexión con el servidor.
41	38
42	39		``` pascal
43	40		Program ConectaDB
44	41
45	42		var UnaConexion : TSQLConnection;
46	43
47	44		Procedure CrearConexion;
48	45		begin
49	46		UnaConexion := TIBConnection.Create(nil);
50	47		UnaConexion.Hostname := 'localhost';
51	48		UnaConexion.DatabaseName := '/opt/firebird/examples/employee.fdb';
52	49		UnaConexion.UserName := 'sysdba';
53	50		UnaConexion.Password := 'contraseñamaestra';
54	51		end;
55	52
56	53		begin
57	54		CrearConexion;
58	55		UnaConexion.Open;
59	56		if UnaConexion.Connected then
60	57		writeln('¡Conexión realizada!')
61	58		else
62	59		writeln('¡Imposible!, porque si la conexión falla, '+
63	60		'una excepción debe ser lanzada, por lo que este código no '+
64	61		'será Ejecutado');
65	62		UnaConexion.Close;
66	63		UnaConexion.Free;
67	64		end.
68	65		```
69	66
70	67		Si se produce una excepción, lea atentamente el mensaje de error. Tal vez el servidor de base de datos no está funcionando, el nombre de usuario o la contraseña son incorrectos o el nombre o la dirección IP de base de datos estan escritos de forma incorrecta. Si el mensaje de error indica que la librería cliente no puede ser encontrada, comprueba si el cliente está instalado correctamente. A menudo, el mensaje de error muestra literalmente el nombre del archivo buscado. También es buena idea verificar en la documentación si alguna de estas propiedades está o no soportada para un conector concreto puesto que es posible que en algún caso deban dejarse sin rellenar (no me refiero a la documentación de la BBDD sino de la unidad que conecta).
71	68
72	69		## ¿Cómo ejecutar consultas directas o crear una tabla?
73	70
74	71		SQLdb -el nombre lo dice todo- sólo funciona con servidores de base de datos que hacen uso de SQL. SQL significa Structured Query Language (Lenguaje estructurado de consulta). SQL es un lenguaje desarrollado para permitir trabajar con bases de datos relacionales. Prácticamente todos los sistemas de base de datos tiene su propio dialecto, pero un gran número de sentencias SQL son iguales en todos los sistemas de base de datos. Podemos hacer una diferencia entre las sentencias SQL que devuelven la información y sentencias que no devuelven información. Si desea utilizar la información que devuelve la sentencias SQL, tienes que utilizar el componente TSQLQuery (ver ¿Cómo leer datos de una tabla?). Si no piensas utilizar la información devuelta por la consulta SQL, entonces también puedes usar el método ExecuteDirect de un TSQLConnection.
75	72
76	73		La mayoría de sistemas de base de datos ejecutan las sentencias SQL dentro de una transacción. Si desea que los cambios realizados dentro de una transacción estén disponible en otras transacciones, o disponer de los cambios disponible incluso después de cerrar la transacción, entonces tienes que realizar el commit de la transacción. Para soportar las operaciones SQLdb tiene el componente TSQLTransaction. Una sentencia SQL que se ejecuta por SQLdb siempre debe ser ejecutada dentro de una transacción. Incluso si el sistema de base de datos no soporta las transacciones. Además, hay sistemas de bases de datos que soportan transacciones para los que TSQLConnection no (todavía) soporta la transacción. Incluso entonces, debes utilizar el componente TSQLTransaction.
77	74
78	75		Para utilizar `TSQLConnection.ExecuteDirect` para ejecutar una sentencia SQL debes especificar que Transaction se debe utilizar. A su vez, al utilizar `TSQLTransaction` debes especificar que TSQLConnection se debe utilizar.
79	76
80	77		En el ejemplo siguiente se crea una tabla 'TBLNOMBRE' con los campos NOMBRE y nID e inserta dos registros. Las instrucciones SQL utilizadas no se explican. Para obtener más información acerca de las instrucciones SQL, su uso y su sintaxis, consulte la documentación del sistema de base de datos. El procedimiento CreateConnection se define en el ejemplo de código de ¿Cómo conectarse a un servidor de base de datos?.
81	78
82	79		``` pascal
83	80		program CreateTable;
84	81
85	82		var AConnection : TSQLConnection;
86	83		ATransaction : TSQLTransaction;
87	84
88	85		procedure CreateTransaction;
89	86		begin
90	87		ATransaction := TSQLTransaction.Create;
91	88		ATransaction.Database := AConnection;
92	89		end;
93	90
94	91		begin
95	92		CreateConnection;
96	93		CreateTransaction;
97	94		AConnection.Transaction := ATransaction;
98	95		AConnection.Open;
99	96		ATransaction.StartTransaction;
100	97		AConnection.ExecuteDirect('create table TBLNAMES (ID integer, NAME varchar(40));');
101	98
102	99		// Some database-server types need a commit before you can use a newly created table. (Firebird)
103	100		// With .Commit you also close the transaction
104	101		ATransaction.Commit;
105	102
106	103		ATransaction.StartTransaction;
107	104		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (1,'Name1');');
108	105		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (2,'Name2');');
109	106		ATransaction.Commit;
110	107		AConnection.Close;
111	108		AConnection.Free;
112	109		ATransaction.Free;
113	110		end.
114	111		```
115	112
116	113		## ¿Cómo leer datos de una tabla?
117	114
118	115		Utiliza el componente TSQLQuery para leer datos de una tabla. Un componente TSQLQuery debe estar enlazado a un componente TSQLConnection y a un componente TSQLTransaction para hacer su trabajo. El ajuste de TSQLConnection y de TSQLTransaction se discute en ¿Cómo conectarse a un servidor de base de datos? y en ¿Cómo ejecutar consultas directas o crear una tabla?.
119	116
120	117		Cuando TSQLConnection, TSQLTransaction y TSQLQuery están conectados, entonces TSQLQuery necesita más ajustes. TSQLQuery tiene una propiedad SQL que contiene un objeto TStrings. La propiedad 'SQL' contiene la sentencia SQL que debe ejecutarse. Si todos los datos de una tabla debe ser leídos establece la propiedad SQL a SELECT FROM nombretabla;. Utiliza open* para leer la tabla desde el servidor y poner los datos en el conjunto de datos TSQLQuery. Los datos se pueden acceder a través de TSQLQuery hasta que la consulta se cierra con close.
121	118
122	119		TSQLQuery es una subclase de TDataset. TDataset tiene una colección Fields que contiene todas las columnas de la tabla. El TDataset también mantiene una marca del registro actual. Utiliza First, Next, Prior y Last para cambiar el registro actual. Bof devuelve true (verdadero) si se llegó al primer registro, y Eof devuelve true si se llegó al último registro. Para leer el valor de un campo en el registro actual, en primer lugar hayamos el objeto TField adecuado y luego usar 'AsString', 'AsInteger', etc.
123	120
124	121		A continuación se muestra un ejemplo que muestra todos los valores de la tabla como se hizo en ¿Cómo ejecutar consultas directas o crear una tabla?.
125	122
126	123		``` pascal
127	124		Program ShowData;
128	125
129	126		var AConnection : TSQLConnection;
130	127		ATransaction : TSQLTransaction;
131	128
132	129		procedure GetQuery : TSQLQuery;
133	130		var AQuery : TSQLQuery;
134	131		begin
135	132		AQuery := TSQLQuery.Create;
136	133		AQuery.Database := FConnection;
137	134		AQuery.Transaction := FTransaction;
138	135		Result := AQuery;
139	136		end;
140	137
141	138		var Query : TSQLQuery;
142	139
143	140		begin
144	141		CreateConnection;
145	142		CreateTransaction;
146	143		Query := GetQuery;
147	144		Query.SQL.Text := 'select * from tblNames';
148	145		AConnection.Open;
149	146		Query.Open;
150	147		while not Query.Eof do
151	148		begin
152	149		Writeln('ID: ', Query.FieldByName('Name').AsInteger, 'Name: ' +
153	150		Query.FieldByName('Name').AsString);
154	151		Query.Next;
155	152		end;
156	153		Query.Close;
157	154		AConnection.Close;
158	155		Query.Free;
159	156		ATransaction.Free;
160	157		AConnection.Free;
161	158		end.
162	159		```
163	160
164	161		(El código anterior, por supuesto, no está terminado, se echa de menos bloques try ... finally. Sin embargo, el código anterior tiene la intención de mostrar el código para base de datos y por lo tanto los toques finales son dejados de lado.) Ten en cuenta que TSQLTransaction.StartTransaction no se utiliza. Esto no es necesario. Cuando TSQLQuery se abre, la instrucción SQL se ejecuta y si no hay ninguna transacción está disponible, esta se inicia automáticamente. El programador no necesita iniciar la transacción explícitamente. Lo mismo se aplica para la conexión gestionada por TSQLConnection. La conexión se abre según sea necesario, la línea Aconnection.Open no es realmente necesaria.
165	162
166	163		Si se destruye un TSQLTransaction, un rollback (deshacer) automático será ejecutado. Los posibles cambios a los datos contenidos en la transacción se perderán.
167	164
168	165		### ¿Por qué TSQLQuery.RecordCount siempre devuelve 10?
169	166
170	167		Para contar los registros de un dataset, usaremos RecordCount. Sin embargo, observa que RecordCount muestra el número de registros que se ha cargado desde el servidor. SQLdb no lee todos los registros al abrir un TSQLQuery de forma predeterminada, sólo los 10 primeros. Sólo cuando se accede al undécimo registro entonces el siguiente conjunto de 10 registros se carga. Usando .Last todos los registros se cargarán.
171	168
172	169		Si desea conocer el número real de registros en el servidor hay que llamar primero '.Last' y luego llamar a .RecordCount. Hay una alternativa disponible. El número de registros devueltos por el servidor está determinado por el valor de la propiedad PacketRecords. El valor por defecto es 10, si se pone a -1 entonces todos los registros serán cargados a la vez.
173	170
174	171		### Lazarus
175	172
176	173		Lazarus tiene diversos componentes para mostrar datos de un TDataset en un formulario. En lugar de un bucle while y declaraciones Writeln usados en el ejemplo, puedes utilizar componentes para mostrar los datos de una tabla. Coloca los adecuados componentes TSQLConnection, TSQLTransaction y TSQLQuery en un formulario, a continuación, se conectan y configuran correctamente. Además se necesita un TDataSource, ajusta la propiedad TDatasource.Dataset al componente TSQLQuery utilizado. (Nota no establecer la propiedad TSQLQuery.Datasource al componente TDataSource. La propiedad TSQLQuery.Datasource se utiliza solamente en tablas maestro/detalle) A continuación puedes poner un TDBGrid en el formulario y establece la propiedad Datasource de la rejill (grid) al componente TDataSource agregado antes.
177	174
178	175		Para ver si funciona todo, establece la propiedad Connected del TSQLConnection a True en el IDE de Lazarus. El IDE intenta conectar con el servidor de base de datos inmediatamente. Si funciona se puede establecer la propiedad TSQLQuery.Active a 'True'. Si todo está correcto, podrás ver -en el IDE- todos los datos de la tabla inmediatamente en la pantalla.
179	176
180	177		## ¿Cómo cambiar los datos en una tabla?
181	178
182	179		Para cambiar datos en un registro, el TDataset (del que se deriva TSQLQuery) debe ponerse en modo de edición. Para activar el modo de edición podemos llamar a los métodos .Edit, . Inserto .Append. Utiliza el método .Edita para modificar el registro actual. Utiliza .Insert para crear un nuevo registro antes del registro actual. Utiliza .Append paara añadir un nuevo registro al final de la tabla. En modo edición puedes cambiar el valor de los campos a través de la propiedad Fields. Utiliza Post para validar los nuevos datos, si los datos son válidos entonces se abandona el modo de edición. Si se cambia a un nuevo registro -por ejemplo, utilizando .Next- y el conjunto de datos está en modo de edición, se llamará a .Post antes. Utiliza .Cancel para descartar todos los cambios realizados desde la última llamada a .Post y termina el modo de edición.
183	180
184	181		``` pascal
185	182		Query.Edit;
186	183		Consulta.FieldByName('NOMBRE').AsString := 'Nombre editado';
187	184		Consulta.Post;
188	185		```
189	186
190	187		Lo anterior no es la historia completa todavía. TSQLQuery se deriva de TBufDataset que hace uso de actualizaciones en un buffer. Actualización en buffer significa que después de llamado Post los cambios en el conjunto de datos son visibles de inmediato, pero no se envían al servidor de base de datos. Lo que sucede es que los cambios se mantienen en un registro de cambios. Cuando se llama al método .ApplyUpdates todos los cambios en el registro de cambios se envían al servidor de base de datos. Sólo entonces el servidor de base de datos conoce todos los cambios. Los cambios se envían al servidor en una transacción de TSQLTransaction. Asegúrese de establecer correctamente la transacción antes de ApplyUpdates. Después de aplicar las actualizaciones, se debe ejecutar commit para publicar o guardar los cambios.
191	188
192	189		El siguiente es un ejemplo de la cambio de datos en una tabla, envío de los cambios al servidor y confirmación de la transacción.
193	190
194	191		``` pascal
195	192		Program EditarDatos;
196	193
197	194		var unaConexion : TSQLConnection;
198	195		unaTransaccion : TSQLTransaction;
199	196		Consulta : TSQLQuery;
200	197
201	198		begin
202	199		CrearConexion;
203	200		CrearTransaccion;
204	201		unaConexion.Transaction := unaTransaccion;
205	202		Consulta := GetQuery;
206	203		Consulta.SQL.Text := 'select * from tblNombres';
207	204		Consulta.Open;
208	205		Consulta.Edit;
209	206		Consulta.FieldByName('NOMBRE').AsString := 'Nombre editado';
210	207		Consulta.Post;
211	208		Consulta.UpdateMode := upWhereAll;
212	209		Consulta.ApplyUpdates;
213	210		AConnection.Transaction.Commit;
214	211		Consulta.Free;
215	212		unaTransaccion.Free;
216	213		unaConexion.Free;
217	214		end.
218	215		```
219	216
220	217		Para una discusión de UpdateMode sigue leyendo.
221	218
222	219		## ¿Cómo SQLdb envia los cambios al servidor de base de datos?
223	220
224	221		En el ejemplo de código de ¿Cómo cambiar los datos en una tabla?, se encuentra la línea.
225	222
226	223		``` pascal
227	224		Consulta.UpdateMode := upWhereAll;
228	225		```
229	226
230	227		sin ninguna explicación de lo que hace. La mejor manera de averiguar lo que esa línea hace es quitarla. Si se omite la orden y se sigue esta guía con precisión, se recibirá el siguiente mensaje de error:
231	228
232	229		``` pascal
233	230		No update query specified and failed to generate one. (No fields for inclusion in where statement found)
234	231		```
235	232
236	233		Para entender lo que salió mal, debes entender cómo los cambios se envían al servidor de base de datos. La única manera de obtener datos en un servidor SQL es mediante la ejecución de consultas SQL. SQL tiene tres tipos de consultas para tres maneras diferentes de manipular un registro. Para crear un nuevo registro, cambiar o eliminar un registro las sentencias insert, update y delete se ejecutan, respectivamente. Una sentencia de actualización (update) puede ser así:
237	234
238	235		``` pascal
239	236		update TBLNAMES set NAME='Edited name' where ID=1;
240	237		```
241	238
242	239		Para enviar un cambio al servidor de base de datos, SQLdb debe crear una consulta de actualización. Para crearla consulta, se necesitan tres cosas:
243	240
244	241		El nombre de la tabla
245	242		El nombre de la tabla se obtiene de analizar la consulta de selección, aunque esto no siempre funciona.
246	243
247	244		Una clásula `UPDATE` o `INSERT`
248	245		Estas contienen los campos que se deben cambiar.
249	246
250	247		Una clásula `WHERE`
251	248		Esta contiene los campos que determinan qué registros se deben cambiar.
252	249
253	250		Todos los campos (cada TField en Fields) tiene una propiedad ProviderFlags. Sólo los campos con pfInUpdate en ProviderFlags se utilizarán en la clásula de actualización o inserción de la consulta. Por defecto todos los campos tienen pfInUpdate puesto en su propiedad ProviderFlags.
254	251
255	252		Qué campos se utilizan en la clásula `WHERE` depende de la propiedad UpdateMode de la consulta y la propiedad ProviderFlags de los campos. Los campos con pfInkey en su ProviderFlags siempre se utilizan en la clásula`WHERE`. Un campo tendrá el indicador pfInKey establecido de forma automática si el campo es parte de la clave principal de la tabla y TSQLQuery.UsePrimaryKeyAsKey devuelve True.
256	253
257	254		El valor predeterminado para UpdateMode de la consulta es upWhereKeyOnly. En este modo se actualizan los campos sólo con pfInkey en su propiedad ProviderFlags 'se utilizan en la clásula `WHERE`. Si ninguno de los campos tienen el indicador pfInKey establecido, entonces no hay campos disponibles para la cláusula `WHERE` y el mensaje de error del principio de esta sección será devuelto. Puede resolver el problema así:
258	255
259	256		- `Añadir una clave principal a la tabla y poner ``TSQLQuery.UsePrimaryKeyAsKey`` a 'True', o`
260	257		- `Poner el indicador ``pfInkey`` para uno o varios campos en el código.`
261	258
262	259		La propiedad UpdateMode puede tener dos posible valores más. UpWhereAll puede usarse para agregar todos los campos con el indicador pfInWhere establecido para la cláusula `WHERE`. Por defecto todos los campos tienen este indicador establecido. UpWhereChanged puede usarse para agregar sólo los campos que tienen el indicador pfInWhere establecido y que se han modificado del registro actual.
263	260
264	261		## ¿Cómo ejecutar una consulta mediante TSQLQuery?
265	262
266	263		Junto a las declaraciones que devuelven un conjunto de datos (ver ¿Cómo leer datos de una tabla?) SQL tiene sentencias que no devuelven datos. Por ejemplo `INSERT`, `UPDATE` y `DELETE` no devuelven datos. Estas sentencias se pueden ejecutar mediante TSQLConnection.ExecuteDirect, pero TSQLQuery puede utilizarse también. Si no esperas devolver datos utiliza TSQLQuery.ExecSQL en lugar de TSQLQuery.Open. Utiliza TSQLQuery.Open para abrir el conjunto de datos devuelto por la consulta SQL.
267	264
268	265		El siguiente procedimiento crea una tabla y se insertan dos registros utilizando TSQLQuery.
269	266
270	267		``` pascal
271	268		procedure CrearTabla;
272	269
273	270		var Consulta : TSQLConsulta;
274	271
275	272		begin
276	273		Consulta := GetConsulta;
277	274		Consulta.SQL.Text := 'create table TBLNOMBRES (ID integer, NOMBRE varchar(40));';
278	275		Consulta.ExecSQL;
279	276
280	277		Consulta.SQL.Text := 'insert into TBLNOMBRES (ID,NOMBRE) values (1,'Nombre1');';
281	278		Consulta.ExecSQL;
282	279
283	280		Consulta.SQL.Text := 'insert into TBLNOMBRES (ID,NOMBRE) values (2,'Nombre2');';
284	281		Consulta.ExecSQL;
285	282
286	283		Consulta.Close;
287	284		Consulta.Free;
288	285		end;
289	286		```
290	287
291	288		## ¿Cómo utilizar parámetros en una consulta?
292	289
293	290		En el código de ejemplo de ¿Cómo ejecutar una consulta mediante TSQLQuery? la misma consulta se utiliza dos veces, sólo difieren en los valores que se insertan. Una manera mejor de hacerlo es mediante el uso de parámetros en la consulta.
294	291
295	292		La sintaxis de los parámetros en las consultas es diferente en cada sistema de base de datos, pero las diferencias las maneja TSQLQuery. Coloca de nuevo los valores en la consulta con dos puntos precediendo al nombre del parámetro que desea utilizar. Por ejemplo:
296	293
297	294		``` pascal
298	295		Consulta.SQL.Text := 'insert into TBLNOMBRES (ID,NOMBRE) values (:ID,:NOMBRE);';
299	296		```
300	297
301	298		Esta consulta crea dos parámetros: 'ID' y 'NOMBRE'. Para determinar los parámetros, la consulta se analiza en el momento en que se asigna o modifica el texto de TSQLQuery.SQL. Todos los parámetros existentes se eliminarán y los nuevos parámetros se añadirán a la propiedad TSQLQuery.Params. Asignar un valor a un parámetro es similar a asignar un valor a un campo en el conjunto de datos:
302	299
303	300		``` pascal
304	301		Query.Params.ParamByName('Nombre').AsString := 'Name1';
305	302		```
306	303
307	304		No se puede saber desde consulta qué tipo de datos deben ser almacenados en el parámetro. El tipo de datos del parámetro se determina en el momento en que un valor se asigna al parámetro. Al asignar un valor utilizando . AsString, el parámetro se asigna al tipo de datos ftString. Puede determinar el tipo de datos directamente mediante el establecimiento de la propiedad DataType. Si un tipo de datos incorrecto se asigna al parámetro, entonces los problemas se producirán durante la apertura o ejecución de la consulta.
308	305
309	306		En el ejemplo siguiente se crea la misma tabla del ejemplo anterior, pero ahora se utilizan parámetros:
310	307
311	308		``` pascal
312	309		procedure CrearTablaUsandoParametros;
313	310
314	311		var Consulta : TSQLQuery;
315	312
316	313		begin
317	314		Consulta := GetQuery;
318	315		Consulta.SQL.Text := 'create table TBLNOMBRES (ID integer, NOMBRE varchar(40));';
319	316		Consulta.ExecSQL;
320	317
321	318		Consulta.SQL.Text := 'insert into TBLNOMBRES (ID,NOMBRE) values (:ID,:NOMBRE);';
322	319
323	320		Consulta.Params.ParamByName('ID').AsInteger := 1;
324	321		Consulta.Params.ParamByName('NOMBRE').AsString := 'Nombre1';
325	322		Consulta.ExecSQL;
326	323
327	324		Consulta.Params.ParamByName('ID').AsInteger := 2;
328	325		Consulta.Params.ParamByName('NOMBRE').AsString := 'Nombre2';
329	326		Consulta.ExecSQL;
330	327
331	328		Consulta.Close;
332	329		Consulta.Free;
333	330		end;
334	331		```
335	332
336	333		Observa que este ejemplo requiere más código que el ejemplo sin parámetros. Entonces, ¿qué es el ventaja de la utilización de parámetros? La velocidad es una de las razones. El ejemplo con parámetros es más rápido porque la consulta se analiza solamente una vez. TSQLQuery sólo analiza la consulta una vez, pero también el servidor de base de datos analiza la consulta una sola vez. La mayoría de los sistemas de base de datos soportan parámetros. Siempre que una consulta se utiliza más de una vez con diferentes valores para el parámetro cada vez, entonces el servidor de base de datos sólo analiza la consulta y los planes de la consulta una sola vez haciendo la ejecución considerablemente más rápida.
337	334
338	335		Utiliza TSQLQuery.Prepare para determinar el momento en que se analiza y se planifica la consulta por el servidor de base de datos. Utiliza TSQLQuery.UnPrepare para asegurarse de que la consulta se analiza y se planifica cada vez por el servidor de datos.
339	336
340	337		Otra razón para usar sentencias preparadas es la prevención de [inyección de SQL](http://en.wikipedia.org/wiki/SQL_injection), pero en algunos casos únicamente simplifica la codificación.
341	338
342	339		## Solución de problemas:
343	340
344	341		### Registro de sucesos de TSQLConnection
345	342
346	343		Puedes hacer que TSQLConnection registre lo que está haciendo. Esto puede ser útil para ver exactamente lo que tu programa envía a la base de datos, para depurar los propios componentes de base de datos y también para optimizar las consultas.
347	344
348	345		Nota: si utilizas comandos preparados o consultas parametrizadas (ver la sección anterior), los parámetros son a menudo enviados en binario por el descendiente de TSQLConnection (por ejemplo, TIBConnection), por lo que no se puedes simplemente copiar o pegar el código SQL registrado en una herramienta de consulta de la base de datos.
349	346
350	347		En cualquier caso, el registro de la activad de la conexión puede dar una gran cantidad de información sobre lo que está haciendo tu programa.
351	348
352	349		Otras alternativas son:
353	350
354	351		1. utilizar el depurador para recorrer el código base de datos si se ha construido el FPC o Lazarus con la depuración habilitada.
355	352		2. si utilizas controladores ODBC (al menos en Windows) puedes habilitar la salida tracelog en el panel de control de ODBC.
356	353		3. muchas bases de datos permiten controlar todas las ordennes que se le envían desde una determinada dirección IP o conexión.
357	354
358	355		Para utilizar el registro de actividad de TSQLConnection, se requieren dos cosas:
359	356
360	357		1. indicar qué tipos de eventos del TSQLConnection deben registrarse
361	358		2. apuntar TSQLConnection a la función que recibe los eventos y los procesa (los registra en un archivo, que se imprima en la pantalla, etc)
362	359
363	360		Esta función debe ser de tipo TDBLogNotifyEvent (ver sqldb.pp), por lo que seguirá este patrón:
364	361
365	362		``` pascal
366	363		TDBLogNotifyEvent = Procedure (Sender : TSQLConnection; EventType : TDBEventType; Const Msg : String) of object;
367	364		```
368	365
369	366		Este fragmento de código puede ilustrar esto:
370	367
371	368		``` pascal
372	369		uses
373	370		...//
374	371		TSQLConnection, //o un objeto heredero tal que TIBConnection, TMSSQLConnection
375	372		...//
376	373		var
377	374		type
378	375		TMyApplication = class(TCustomApplication); //esta es nuestra aplicación, la que utiliza la conexión
379	376		...//
380	377		private
381	378		// Este ejemplo guarda el registro en un stringlist:
382	379		FConnectionLog: TStringList;
383	380		...//
384	381		protected
385	382		// Este procedimiento recibe los eventos que registra la conexión:
386	383		procedure GetLogEvent(Sender: TSQLConnection; EventType: TDBEventType; Const Msg : String);
387	384		...
388	385		procedure TMyApplication.GetLogEvent(Sender: TSQLConnection;
389	386		EventType: TDBEventType; const Msg: String);
390	387		// El procedimineto es llamado por TSQLConnection y guarda los mensajes recibidos
391	388		// en la lista de cadenas FConnectionLog
392	389		var
393	390		Source: string;
394	391		begin
395	392		// Muy bien alineado a la derecha...
396	393		case EventType of
397	394		detCustom: Source:='Custom: ';
398	395		detPrepare: Source:='Prepare: ';
399	396		detExecute: Source:='Execute: ';
400	397		detFetch: Source:='Fetch: ';
401	398		detCommit: Source:='Commit: ';
402	399		detRollBack: Source:='Rollback:';
403	400		else Source:='Evento desconocido. Corrige el código del programa.';
404	401		end;
405	402		FConnectionLog.Add(Source + ' ' + Msg);
406	403		end;
407	404
408	405		...
409	406		// Necesitamos decirle a nuestro TSQLConnection lo que debe registrar:
410	407		FConnection.LogEvents:=LogAllEvents; //= [detCustom, detPrepare, detExecute, detFetch, detCommit, detRollBack]
411	408		// ... y el procedimiento de la conexión que debe enviar los eventos:
412	409		FConnection.OnLog:=@Self.GetLogEvent;
413	410		...
414	411		// Ahora podemos usar la conexión y la lista de cadenas FConnectionLog se llenará con los mensajes de registro.
415	412		```
416	413
417	414		También podemos utilizar GlobalDBLogHook de TSQLConnection en lugar de registrar todo desde múltiples conexiones.
418	415
419	416		Por último, la descripción anterior es la manera de hacer las cosas en FPC como se indica en la introducción, si se utiliza Lazarus, una forma más rápida es asignar un controlador de eventos al evento OnLog de TSQLConnection.
420	417
421	418		## See also
422	419
423	420		`* `[[Working With TSQLQuery/es\|Trabajando con TSQLQuery]]`.`
424	421
425	422		---
426	423		From the Free Pascal wiki, page "SqlDBHowto/es", as it stood on 2020-02-27 after a change by Trev, 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).
427	424		Category: Castellano
428	425		Category: Español

Back to history