SQLite/es

From Free Pascal wiki
Jump to: navigation, search

English (en) español (es) français (fr)

Soporte para SQLite en FPC/Lazarus

   SQLite es una base de datos embebida (sin servidor) monousuario que puede ser utilizada en aplicaciones FPC y Lazarus. Se pueden utilizar varios drivers para el acceso a SQLite desde programas FPC/Lazarus.

   Es necesario que dichos drivers 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.

Win64: por favor ver las advertencias here sobre no usar ciertas versiones de FPC/Lazarus Win64.

Acceso directo a SQLite (Producto Comercial)

   Puedes utilizar una forma sencialla 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, Mac OS X, iOS, Android, Linux y FreeBSD tanto para plataformas de 32 como de 64 bits. LietDAC 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.


SQLDB incluido con Lazarus / FreePascal

   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.

Ver más abajo para más detalles.

sqldbcomponents.png

Soporte para Spatialite

   Spatialite son extensiones GIS (Geographic Information System) para SQLite que se pueden utilizar dentro de SQLDB. Ver Spatialite.

Soporta de encriptación para SQLite

   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 llave de encriptación.

   Ejemplos:

  • SQLCipher: código abierto (open source), e.g. binarios Windows no disponibles sin cargo, no son libres (tienes que compilarlos por ti mismo).
  • System.Data.SQLite: 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)

Zeos

También se puede utilizar el paquete Zeos para ulitizar bases de datos SQLite con FreePascal / Lazarus.

SQLitePass

TSQLite3Dataset y TSQLiteDataset

   Existen paquetes diferenciados tales como TSQLiteDataset (unit sqliteds) y TSQLite3Dataset (unit 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.

   TSqliteDataset y TSqlite3Dataset son descendientes de TDataset que acceden, respectivamente a bases de datos SQLite2.8.x y 3.x.x. Para nuevos proyectos debería utilizarse presumiblemente TSQlite3Dataset como SQLite 3.x (es la versión actual).

   A continuación se muestra un listado de las principales ventajas y desventajas en comparación con otros drivers/métodos de acceso de FPC/Lazarus.

   Ventajas:

  • 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.

   Desventajas:

  • El cambio hacia otras bases de datos es más difícil que si se utilizan componentes SQLDB o Zeos.
Note-icon.png

Nota: Dicho esto, bastantes programadores utilizarán SQLDB o Zeos dadas las ventajas que aportan a menos que necesiten un menor nivel de acceso a la librería SQLite

Utilizando componentes SQLdb con SQLite

   Estas instrucciones se centran en SQLDB (la TSQLite3Connection) específicamente para SQLite. Para una visión general, echa un vistazo a SqlDBHowto la cual tiene bastante información útil sobre componentes SQLdb.

   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.

   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.

   TSQLite3Connection se puede encontrar en la unidad sqlite3conn, si necesitas declararla por ti mismo o si estás trabajando en FreePascal.

   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.

   A continuación se explica como configurar los componentes:

TSQLite3Connection
  • 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.
Note-icon.png

Nota: para establecer el trayecto completo a la librería (si ubicas tu sqlite dll/so/dylib en un lugar donde el sistema operativo no lo encuentra por defecto, tal como el directorio application en Linux/OSX), puedes establecer la propiedad SQLiteLibraryName (ANTES de que se realice la conexión e.g. en el evento OnCreate del formulario principal), tal como esto:

Por ejemplo bajo Linux:

 SQLiteLibraryName:='./sqlite3.so';

o bien bajo Windows:

 SQLiteLibraryName:='./sqlite3.dll';
TSQLQuery
  • 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:


 SELECT * FROM foo


  • 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 !).


  • 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:


 SELECT campo1, campo2, campo5 FROM foo WHERE campo3 = campo4
.


  • 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.


  • "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.


  • 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).


  • Si estás utilizando campos lookup


    • 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.


    • 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#TSQLQuery.InsertSQL.2C_TSQLQuery.UpdateSQL_and_TSQLQuery.DeleteSQL:_Basic_Use_of_Parameters.


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.

Creando una Base de Datos

   El método TSQLite3Connection.CreateDB 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:


   (Código estraido del ejemplo sqlite_encryption_pragma que se incluye a partir de Lazarus 1.3)

 var
  newFile : Boolean;
 begin
 
  SQLite3Connection1.Close; // Asegura que connection está cerrado al inicio (al ser una base de datos monousuario).
 
  try
    // Ya que estamos creando la base de datos por primera vez,
    // chequeamos opr si ya existiese ya que nos daría error si es así.
 
    newFile := not FileExists(SQLite3Connection1.DatabaseName);
 
    if newFile then
    begin
      // Crear la base de datos y las tablas.
      try
        SQLite3Connection1.Open;  // Abrimos la conexión
        SQLTransaction1.Active := true; // Establecemos activa la transacción.
 
        // Aquí es donde establecemos una tabla llamada "DATA" dentro de la base de datos con ExecuteDirect.
 
        SQLite3Connection1.ExecuteDirect('CREATE TABLE "DATA"('+
                    ' "id" Integer NOT NULL PRIMARY KEY AUTOINCREMENT,'+
                    ' "Current_Time" DateTime NOT NULL,'+
                    ' "User_Name" Char(128) NOT NULL,'+
                    ' "Info" Char(128) NOT NULL);');
 
        // En este caso crea la tabla Data con id como llave primaria, que no admite entradas NULL y que se autoincrementa.
        // Crea 3 campos adicionales que no admite entrada NULL uno de tipo DateTime otro dos 128 caracteres.
 
        // Creando un índice UNICO basado en id en la tabla DATA.
 
        SQLite3Connection1.ExecuteDirect('CREATE UNIQUE INDEX "Data_id_idx" ON "DATA"( "id" );');
 
        SQLTransaction1.Commit; // Enviamos y hacemos efectivo lo anterior.
 
        ShowMessage('Base de datos Creada Correctamente.');
      except
        ShowMessage('No se ha podido crear la nueva Base de Datos');
      end;
    end;
  except
    ShowMessage('No ha sido posible chequear si el fichero de Base de Datos existe');
  end;
 end;

Creando collations definidos por el usuario

// utf8 case-sensitive compare callback function
function UTF8xCompare(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
var S1, S2: AnsiString;
begin
  SetString(S1, data1, len1);
  SetString(S2, data2, len2);
  Result := UnicodeCompareStr(UTF8Decode(S1), UTF8Decode(S2));
end;
 
// utf8 case-insensitive compare callback function
function UTF8xCompare_CI(user: pointer; len1: longint; data1: pointer; len2: longint; data2: pointer): longint; cdecl;
var S1, S2: AnsiString;
begin
  SetString(S1, data1, len1);
  SetString(S2, data2, len2);
  Result := UnicodeCompareText(UTF8Decode(S1), UTF8Decode(S2));
end;
 
// register collation using SQLite3 API (requires sqlite3dyn unit):
sqlite3_create_collation(SQLite3.Handle, 'UTF8_CI', SQLITE_UTF8, nil, @UTF8xCompare_CI);
// or using method of TSQLite3Connection:
CreateCollation('UTF8_CI',1,nil,@UTF8xCompare_CI);  
 
// now we can use case-insensitive comparison in SQL like:
// SELECT * FORM table1 WHERE column1 COLLATE UTF8_CI = 'á'
 
// but this does not work for LIKE operator
// in order to support also LIKE operator we must overload default LIKE function using sqlite3_create_function()
// http://www.sqlite.org/lang_corefunc.html#like

Creating user defined functions

// example overloading default LOWER() function with user supplied function
procedure UTF8xLower(ctx: psqlite3_context; N: cint; V: ppsqlite3_value); cdecl;
var S: AnsiString;
begin
  SetString(S, sqlite3_value_text(V[0]), sqlite3_value_bytes(V[0]));
  S := UTF8Encode(AnsiLowerCase(UTF8Decode(S)));
  sqlite3_result_text(ctx, PAnsiChar(S), Length(S), sqlite3_destructor_type(SQLITE_TRANSIENT));
end;
 
// register function LOWER() using SQLite3 API (requires sqlite3dyn unit):
sqlite3_create_function(SQLite3.Handle, 'lower', 1, SQLITE_UTF8 or SQLITE_DETERMINISTIC, nil, @UTF8xLower, nil, nil);

SQLite3 y Fechas

  • 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'.
  • 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
  • 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.

Valores por defecto para hora local en lugar de UTC

CURRENT_TIME, CURRENT_DATE y CURRENT_TIMESTAMP retornan la fecha y/u hora UTC. Para fecha y/o hora local podemos utilizar:

 DEFAULT (datetime('now','localtime')) para valores de fecha-hora (datetime) formateados como YYYY-MM-DD HH:MM:SS
 DEFAULT (date('now','localtime')) para valores de fecha formateada como YYYY-MM-DD
 DEFAULT (time('now','localtime')) para valores de hora formateados como HH:MM:SS

Resolución de problemas sobre SQLDB y SQLite

  • Tener presente que para trabajar en tiempo de diseño (campos, etc) Lazarus debe poder encontrar sqlite3.dll.
  • 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 el IDE will creará un fichero vacío en el directorio. En caso de problemas, chequear si el directorio utilizado contiene una copia de tamaño 0 bytes para el fichero de base de datos.
  • Si se tiene una master/detail relationship, entonces es necesario refrescar el dataset master después de realizar cada insert para obtener value for slave dataset foreign key field. Se puede realizar mediante el evento AfterPost del dataset mastert, mediante la llamada de alguno de los siguientes procedimientos overloaded:


interface
    procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);overload;
    procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);overload;  
 
implementation
 
procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery; pKeyField: string);
//This procedure refreshes a dataset and positions cursor to last record
//To be used if Dataset is not guaranteed to be sorted by an autoincrement primary key
var
  vLastID: Integer;
  vUpdateStatus : TUpdateStatus;
begin
  vUpdateStatus := pDataset.UpdateStatus;
  //Get last inserted ID in the database
  pDataset.ApplyUpdates;
  vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
  // Ahora vuelve a la fila respectiva.
  if vUpdateStatus = usInserted then begin
    pDataset.Refresh;
    // Refrescar y vuelve a la fila respectiva.
    pDataset.Locate(pKeyField,vLastID,[]);
  end;
end;
 
procedure RefreshADatasetAfterInsert(pDataSet: TSQLQuery);
//This procedure refreshes a dataset and positions cursor to last record
//To be used only if DataSet is guaranteed to be sorted by an autoincrement primary key
var
  vLastID: Integer;
  vUpdateStatus : TUpdateStatus;
begin
  vUpdateStatus := pDataset.UpdateStatus;
  pDataset.ApplyUpdates;
  vLastID:=(pDataSet.DataBase as TSQLite3Connection).GetInsertID;
  if vUpdateStatus = usInserted then begin
    pDataset.Refresh;
    //Dangerous!
    pDataSet.Last;
  end;
end;
 
procedure TDataModule1.SQLQuery1AfterPost(DataSet: TDataSet);
begin
  RefreshADatasetAfterInsert(Dataset as TSQLQuery); //If your dataset is sorted by primary key
end;  
 
procedure TDataModule1.SQLQuery2AfterPost(DataSet: TDataSet);
begin
  RefreshADatasetAfterInsert(Dataset as TSQLQuery, 'ID'); //if you are not sure that the dataset is always sorted by primary key
end;

Vacuum y otras operaciones que deben realizarse fuera de una transacción

SQLDB parece requerir siempre una conexió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:)


  // commit cualquier operación pendiente y utilizar una sqlconnection "fresca".
  Conn.ExecuteDirect('End Transaction');  // Finalizar la transacción iniciada por SQLdb
  Conn.ExecuteDirect('Vacuum'); // Realizar el Vacuum.
  Conn.ExecuteDirect('Begin Transaction'); // Comenzar una nueva transacción para utilizar con SQLdb.

Tips

  • Utiliza el procedimiento TSQLite3Connection.CreateDB para crear una nueva base de datos SQLite.

Utilizando TSQLite3Dataset

   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


Requerimientos

  • Para bases de datos sqlite2 (legado):
    • FPC 2.0.0 or higher
    • Lazarus 0.9.10 o superior.
    • SQLite runtime library 2.8.15 or above*
  • Sqlite2 ya no está en fase de mantenimiento y el fichero binario ya no se encuentra en el sitio de sqlite.
  • Para basesd e datos sqlite3:
    • FPC 2.0.2 o superior.
    • Lazarus 0.9.11 (svn revisión 8443) o superior.
    • sqlite runtime library 3.2.1 or higer (get it from www.sqlite.org)

Antes de iniciar un proyecto Lazarus, asegúrate de que:

  • La librería de sqlite está en cualquiera de estos dos sitios:
    • En la PATH del sistema.
    • En el directorio donde se genera el ejecutable (del proyecto actual) - esta opción puede que funcione solamente bajo Windows.
  • Bajo Linux, sitúa cmem como primera unit en la claúsula uses del programa principal.
    • 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).

Como utilizar (utilización básica)

   Instalar el paquete que se encuentra en el directorio /components/sqlite (ver instrucciones aquí)

   En tiempo de diseño, establecer las siguientes propiedades:

  • FileName: trayecto al fichero sqlite [requerido]
  • TableName: nombre de la table utilizado en la sentencia sql [requerido]
  • SQL: a SQL select statement [opcional]
  • SaveOnClose: el valor por defecto es false, lo cual significa que los cambios no se guardan. Se puede cambiar a true. [opcional]
  • Active: necesita ser establecido en tiempo de diseño o al comienzo del programa. [requerido]

Creando una tabla (Dataset)

   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.

   Estos son todos los tipos soportados por TSqliteDataset y TSqlite3Dataset:

  • Integer
  • AutoInc
  • String
  • Memo
  • Bool
  • Float
  • Word
  • DateTime
  • Date
  • Time
  • LargeInt
  • Currency

Recabando los datos

   Después de crear la tabla o con una tabla creada previamente, abrir el dataset con el método Open.

   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:

 SQL := 'Select * from TABLENAME';

Applying changes to the underlying datafile

   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)

   Es posible hacer esto de dos maneras:

  • Establecer la propiedad de la clave primaria (PrimaryKey) con el nombre del campo de la clave primaria (Primary Key).
  • 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)).
   Si se establece una de las dos condiciones, entonces simplemente llamar a
ApplyUpdates;
   
Note-icon.png

Nota: Si se establecen ambas condiciones, el campo correspondiente a la clave primaria (PrimaryKey) se utiliza para aplicar las actualizacioness.

   
Note-icon.png

Nota: Establecer como PrimaryKey un campo que no es de este tipo conllevará pérdida de datos si se llama a ApplyUpdates, por tanto hay que asegurarse de que el campo escogido no contenga NULL y que los valores sean únicos sin repetición.

Master/detail example

   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.

Remarks

  • 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).
  • El mismo fichero de datos (Filename property) puede albergar varias tablas/conjuntos de datos (datasets).
  • Se pueden crear simultaneamente varios conjuntos de datos (diferentes combinaciones de campos) utilizando la misma tabla.
  • 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.
  • 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.
  • 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.


   Se pueden econtrar ejemplo genéricos en el directorio SVN fpc/fcl-db/src/sqlite.


Utilidades de apoyo

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:

See also