Difference between revisions of "Working With TSQLQuery/es"

From Lazarus wiki
(TSQLQuery.InsertSQL, TSQLQuery.UpdateSQL and TSQLQuery.DeleteSQL: Basic Use of Parameters)
(Parameters in TSQLQuery.SQL)
Line 101: Line 101:
 
&nbsp;&nbsp;&nbsp;Dejamos como ejercicio para el lector que use los valores de campo actuales y los valores antiguos de los campos en una sentencia <tt>DELETE</tt>.
 
&nbsp;&nbsp;&nbsp;Dejamos como ejercicio para el lector que use los valores de campo actuales y los valores antiguos de los campos en una sentencia <tt>DELETE</tt>.
  
===Parameters in TSQLQuery.SQL===
+
===Parámetros en TSQLQuery.SQL===
&nbsp;&nbsp;&nbsp;In most situations, the SQL property of TSQLQuery will contain the select statement which again in most situations doesn't need parameters. However, even the SQL property can contain parameters. Where the ''InsertSQL'', ''UpdateSQL'' and ''DeleteSQL'' properties can use predefined parameters for current and old field values the ''SQL'' property does not. You can create your own parameters in the ''Params'' property.
+
&nbsp;&nbsp;&nbsp;En la mayoría de situaciones, la propiedad SQL de TSQLQuery contendrá la instrucción de selección que a su vez en la mayoría de situaciones no necesita parámetros. Sin embargo, incluso la propiedad SQL puede contener parámetros. Aunque las propiedades ''InsertSQL'', ''UpdateSQL'' y ''DeleteSQL'' pueden utilizar parámetros predefinidos para el campo actual y los valores viejos la propiedad ''SQL'' no lo hace. Puedes crear tus propios parámetros en la propiedad ''Params'' .
  
&nbsp;&nbsp;&nbsp;The use of parameters may help performance of the database. Most databases support prepared statements, which means that the statement is prepared and cached in the database. A prepared statement can be used more than once and doesn't require parsing and planning every time it is used, only the parameters are changed each time it is used. In situations where the same statement is used a large number of times -with only an exchange of parameters - prepared statements can help performance considerably.
+
&nbsp;&nbsp;&nbsp;El uso de parámetros puede mejorar el rendimiento de la base de datos. La mayoría de las bases de datos soportan sentencias preparadas, lo que significa que la declaración se prepara y se almacena en la base de datos. Una declaración preparada se puede utilizar más de una vez y no requiere de análisis y planificación cada vez que se utiliza, sólo los parámetros se cambian cada vez que se utiliza. En situaciones donde se utiliza la misma instrucción a un gran número de veces, -con sólo un cambio de parámetros- las sentencias preparadas pueden mejorar el rendimiento considerablemente.
  
&nbsp;&nbsp;&nbsp;Although [[SqlDBHowto/nl]] contains a brief discussion in Dutch on this subject. I don't understand the technology and properties that can be set enough to discuss it in more detail.
+
&nbsp;&nbsp;&nbsp;[[SqlDBHowto/es]], contiene una breve discusión en inglés sobre este tema.  
 
[[Category:Databases]]
 
[[Category:Databases]]

Revision as of 23:09, 2 June 2010

English (en) español (es) français (fr) 中文(中国大陆)‎ (zh_CN)

   Para una referencia general de cómo trabajar con Bases de Datos ver Bases de Datos en Lazarus

Trabajando con TSQLQuery

   El conjunto de datos (DataSet) que devuelve TSQLQuery se puede ver con una instancia de TDBGrid, pero no es muy recomendable para editar los campos de los registros individuales. Para realizar esto en conveniente poner varios componentes ligados a datos para registros individuales, cómo TDBEdit en el formulario, y poner su propiedad DataSource con el valor de nombre de la fuente de datos utilizada. En la propiedad DataField seleccionaremos el nombre del campo (v.gr. 'IDENTIDAD') o una expresión que resulte en una cadena aceptable.

   Si añadimos un componente de navegación TDBNavigator Lazarus TDBNavigator.png resultará muy fácil moverse por los registros y seleccionarlos para editarlos. Cuándo un registro es seleccionado mediante un TDBNavigator o moviendo el cursor en el DBGrid los datos correspondientes del registro se mostrarán en el TDBEdity si se pulsa el botón de Editar Lazarus TDBNavigator.Editar.png, su contenido puede ser modificado. Con el botón Post Lazarus TDBNavigator.Guardar.png podemos confirmar la edición o bien desechar los cambios con Cancelar Lazarus TDBNavigator.Cancelar.png.

   En general el proceso es el siguiente:

  1. Sitúa un componente TSQLQuery en el formulario o móulo de datos, da los valores adecuados a las propiedadesDatabase, Transaction y SQL.
  2. Sitúa un componente TDatasource, haz que su propiedad Dataset apunte a la instancia de TSQLQuery.
  3. Sitúa un componente TDBGrid en el formulario, selecciona en su propiedad Datasource el nombre dado al componente TDatasource anterior.
  4. Opcionalmente sitúa un componente TDBNavigator y da valor a su propiedad Datasource para usar el TDatasource.

   Tras esto poner la propiedad Active a verdadero (True), y podremos ver los datos suministrados por la consulta.

   Los componentes TSQLConnection y TSQLTransaction, que también hemos puesto en el formulario, tienen su propiedad Active a verdadera.

Actualización de datos

   Si es necesario poder Borrar o modificar registros, la Base de datos tiene que

  1. Tener una columna con la Clave Primaria.
  2. Tener un conjunto de campos que individualicen cada registro, que normalmente serán parte del índice único. Este índice no es imprescindible, pero contribuirá a que las consultas sean más rápidas.

   Si no existen ni el campo primario ni esos campos que individualizan un registro será necesario añadir un registro de clave primaria. Esto se realiza preferiblemente al diseñar la estructura de la tabla en el momento de crearla, pero podemos añadirla posteriormente.

   El siguiente código en un cliente MySQL, por ejemplo, añadirá un índice único para su tabla. <delphi> alter table ejemplo1

 add column autoidentificador int 
 primary key auto_increment;</delphi>

   La adición del campo no estropeará nada y permitirá a tus aplicaciones para actualizarlo.

Cambios diferidos (cached)

   El componente TSQLQuery guarda los cambios en un espacio de memoria intermedia. Es decir, los cambios no son enviados inmediatamente a la Base de datos, si no que se mantienen en memoria hasta que llamamos al método ApplyUpdates. En ese momento los cambios se transforman en sentencias DML de SQL, y son aplicadas a la Base de datos. Si no se utiliza el método ApplyUpdates, la Base de datos no será actualizada con los cambios locales realizados.

Campos de Clave primaria

   Cuándo se actualizan registros, TSQLQuery necesita conocer que campos constituyen la clave primaria que se utiliza para modificar un registro y cuáles son los campos que se van a modificar: basándose en esta información construirá la sentencia SQL adecuada UPDATE, INSERT o DELETE.

   La creación de la sentencia SQL se controla con las propiedades UsePrimaryKeyAsKey y ProviderFlags.

   La propiedad Providerflags está compuesta de 3 indicadores:

   pfInkey
El campo forma parte de la clave primaria
   pfInWhere
El campo puede utilizarse en la cláusula WHERE de una sentencia SQL.
   pfInUpdate
LAs modificaciones o inserciones deben incluir este campo.

   Por defecto, ProviderFlags tiene puesto el indicador de pfInUpdate.

   Si la tabla dispone de un clave primaria (cómo se describe más arriba) es necesario poner la propiedad UsePrimaryKeyAsKey a verdadera True y lo tendremos todo hecho. De esta forma, se establecerá el indicador pfInKey para los campos de la clave primaria.

   Si la tabla no dispone de un clave primaria, pero existen campos que permiten individualizar los registros se deberá incluir el indicador pfInKey en la propiedad ProviderFlags de todos los registros que identifican el registro cómo único.

   La propiedad UpdateMode determina los registros que pueden ser utilizados en la cláusula WHERE:

   upWhereKeyOnly
En el momento de construir una cláusula WHERE TSQLQuery lista todos los campos que tienen el indicador pfInKey en su propiedad ProviderFlags y utiliza los valores para crear la cláusula WHERE que determina el registro cómo único para modificar sus valores -- normalmente esto sólo es necesario para las sentencias UPDATE y DELETE.
   upWhereChanged
Además de los campos con el indicador pfInKey en su propiedad ProviderFlags, los campos con el indicador pfInWhere y que han sido modificados, se incluyen en la cláusula WHERE.
   upWhereAll
Los campos con el indicador pfInWhere en su propiedad ProviderFlags serán también incluidos para crear las cláusula WHERE.

Controlando los cambios

   Es posible especificar que campos pueden ser modificados: se mencionó antes: Únicamente los campos que tienen el indicador pfInUpdate en su propiedad ProviderOptions se pueden incluir en sentencias SQL UPDATE o INSERT. Por defecto el indicador pfInUpdate está presente en la propiedad ProviderOptions.

Customizing the SQL in TSQLQuery

   Normally TSQLQuery will use generic SQL statements based on properties as discussed above. However, the generic SQL created by sqldb may not be correct for your situation. TSQLQuery allows you to customize SQL statements used for the various actions, to work best in your situation with your database. For this purpose you use the properties SQL, InsertSQL, UpdateSQL and DeleteSQL.

   All these properties are of type TStringList, a list of strings, that accepts multiple lines of SQL. All four come with a property editor in the IDE. In the IDE, select the property and open de editor by clicking the ellipsis button. In code, use for example InsertSQL.Text or InsertSQL.Add() to set or add lines of SQL statements. One statement may span several lines and ends with a semicolon.

   Also, all four properties accept parameters explained further below.

TSQLQuery.SQL:Personalización básica de SQL

   La propiedad SQL se utiliza normalmente para recuperar los datos de la base de datos. El SQL genérico para esta propiedad es SELECT * FROM fpdev donde fpdev es la tabla que figura en la base de datos.

   El conjunto de datos que devuelve la instrucción SQL genérica está sin pulir. Si muestras el resultado en un TDBGrid, el orden de los registros puede parecer al azar, el orden de las columnas puede no ser lo que quieres y los nombres de campo pueden ser técnicamente correctos, pero no fáciles de usar. Utilizar SQL personalizado puede mejorar esta situación.

   SELECT id AS 'ID', NombreUsuario AS 'Usuario', InstEmail AS 'e-Correo' FROM fpdev ORDER BY id;

   La tabla de la base de datos tiene las columnas id, NombreUsuario y InstEmail. El conjunto de datos que resulta de la consulta anterior utiliza los nombres de campo, tal como figura en la consulta (ID, Usuario y e-Correo), el orden de las columnas, tal como figura en la consulta y los registros son ordenados por su id.

TSQLQuery.InsertSQL, TSQLQuery.UpdateSQL and TSQLQuery.DeleteSQL: Utilización básica de parámetros

   Las sentencia InsertSQL, UpdateSQL y DeleteSQL aceptan parámetros. Los nombres de campo utilizados en estas declaraciones deben ser exactamente los mismos que los nombres de campo utilizados en el conjunto de datos. Los nombres de campo en el conjunto de datos pueden ser diferentes de los nombres de columna en la tabla, en función de la sentencia SELECT (ver arriba). Los campos de valores deben ser escritos como el nombre de campo precedido por dos puntos. Por ejemplo:

   INSERT INTO fpdev(id, UserName, InstEmail) VALUES(:id,:UserName,:InstEmail);

   Esta sentencia insertará los valores de id, NombreUsuario y InstEmail del registro actual del conjunto de datos en los campos correspondientes de la tabla fpdev.

   La sentencia INSERT anterior es una sentencia genérica INSERT y sería de uso limitado en TSQLQuery ya que será el mismo que el SQL generado con slqdb por sí mismo. La declaración dada puede dar lugar a errores cuando el campo ID es un campo de incremento automático con clave única. Diversas bases de datos solucionan este problema de diferentes maneras. Por ejemplo, lo siguiente funciona para MySQL.

   INSERT INTO fpdev(id, UserName, InstEmail) VALUES(0,:UserName,:InstEmail)    ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID();

   La sentencia anterior intenta insertar un nuevo registro, usando 0 (cero) para el campo ID. Si es cero ya se utiliza como clave, entonces la duplicidad es detectada y el ID se actualiza para usar el último ID insertado. Bueno, en realidad un identificador de un incremento mayor que el último utilizado.

   Para una sentencia INSERT es posible que desee utilizar los valores del campo actual del registro seleccionado. Para una sentencia UPDATE, tendrás que usar los valores de los campos como estaban antes de la edición en la cláusula WHERE. Esto también es posible. Los valores de los campos antes de editar deben ser escritas como el nombre del campo precedidon por :old_. Por ejemplo, lo siguiente funciona para MySQL:

   UPDATE fpdev SET UserName=:UserName, InstEmail=:InstEmail WHERE UserName=:Old_UserName;

   La sentencia anterior actualiza los campos UserName y InstEmail de todos los registros en los que UserName es igual al valor anterior de UserName.

   Dejamos como ejercicio para el lector que use los valores de campo actuales y los valores antiguos de los campos en una sentencia DELETE.

Parámetros en TSQLQuery.SQL

   En la mayoría de situaciones, la propiedad SQL de TSQLQuery contendrá la instrucción de selección que a su vez en la mayoría de situaciones no necesita parámetros. Sin embargo, incluso la propiedad SQL puede contener parámetros. Aunque las propiedades InsertSQL, UpdateSQL y DeleteSQL pueden utilizar parámetros predefinidos para el campo actual y los valores viejos la propiedad SQL no lo hace. Puedes crear tus propios parámetros en la propiedad Params .

   El uso de parámetros puede mejorar el rendimiento de la base de datos. La mayoría de las bases de datos soportan sentencias preparadas, lo que significa que la declaración se prepara y se almacena en la base de datos. Una declaración preparada se puede utilizar más de una vez y no requiere de análisis y planificación cada vez que se utiliza, sólo los parámetros se cambian cada vez que se utiliza. En situaciones donde se utiliza la misma instrucción a un gran número de veces, -con sólo un cambio de parámetros- las sentencias preparadas pueden mejorar el rendimiento considerablemente.

   SqlDBHowto/es, contiene una breve discusión en inglés sobre este tema.