Com accedir a bases de dades SQLite amb Python

En l'exercici d'avui, presento el mòdul pysqlite2 que proporciona una senzilla interfície per a utilitzar SQLite amb Python.

A l'Ubuntu, per a afegir aquest mòdul  n'hi ha prou amb anar al Centre de Programari de l'Ubuntu i instal·lar els paquets python-pysqlite2 i python-pysqlite2-doc.

Cal anar amb compte perquè els números de versió poden crear confusió: trobarem també els mòduls python-pysqlite, però aquests són per a taules de l'anterior SQLite2. Els python-pysqlite2, corresponen a SQLite3, que és la versió actual.

Primer de tot crearé una base de dades SQLite3 de proves amb una taula diccionari. amb tres columnes: id, PK, numèric amb autoincrement; nom, text; valor, text. 

La taula es pot crear de forma senzilla amb l'aplicació gràfica SQLiteman, que permet operar amb taules d'SQLite3. En tot cas, també es pot crear la taula de proves amb la interfície en mode text que proporciona el mateix SQLite3. En cas de no disposar de SQLiteman, aquest es pot instal·lar, com tota la resta, des del Centre de Programari de l'Ubuntu.

L'esquema  

CREATE TABLE "diccionari" (

    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,

    "nom" TEXT NOT NULL,

    "valor" TEXT NOT NULL

);

CREATE TABLE sqlite_sequence(name,seq);

Un cop creada la taula, la informo amb dades de prova. 

I, a continuació, el codi per a afegir, cercar, esborrar...amb Python i pysqlite2.

#!/usr/bin/python

# coding: latin-1

# python i sqlite

from pysqlite2 import dbapi2 as sqlite

# es connecta a una base de dades

con = sqlite.connect("./prova-sqlite.db")

# itera a través de la taula diccionari amb un cursor

cursor = con.cursor()

# executa el cursor

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

# obtenir-ne només resultat un: 

print "\n-------------------------------"

print "estat inicial"

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: " + str(iddic) + "; nom: " + nom + "; valor: " + valor

# inserta noves files, amb una seqüència

print "\n-------------------------------"

print "insereix 3 files"

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom6","valor6") )

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom7","valor7") )

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom8","valor8") )

# commit

con.commit();

# a veure què ha fet...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra (un mètode alternatiu)

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

# amb un mapeig

print "\n-------------------------------"

print "insereix 3 files més"

item = {"nom": "nom9", "valor": "valor9"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

item = {"nom": "nom10", "valor": "valor10"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

item = {"nom": "nom11", "valor": "valor11"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

# commit

con.commit();

# tornem a veure què ha fet...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra 

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

#finalment, ho deixo tot com estava al començament

cursor.execute("delete from diccionari where id > 5") 

con.commit()

# ho verifica...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files, un mètode alternatiu amb fetchone

print "\n-------------------------------"

print "ho deixa com estava a l'inici"

fila = cursor.fetchone()

while (not (fila is None)):

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

fila = cursor.fetchone()

# tanca el cursor

cursor.close()

# tanca la connexió

con.close()

Els comentaris del codi en proporcionen les explicacions. Només en destacaria les alternatives idiomàtiques que ofereix Python per a realitzar diverses accions:

Per exemple: un print de diferents variables, i l'alternativa a l'estil del printf de C:

print "id: " + str(iddic) + "; nom: " + nom + "; valor: " + valor

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

O aquesta altre: la iteració a través d'un cursor amb for, i uns alternativa amb while 

 

amb for

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra 

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

amb while:

fila = cursor.fetchone()

while (not (fila is None)):

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

fila = cursor.fetchone()

Instruccions "preparades" i l'ús de '?', o de variables vinculades a l'insert

amb '?'

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom6","valor6") )

amb variables vinculades

item = {"nom": "nom11", "valor": "valor11"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

I, a continuació, una execució del programa   

albert@atenea:~/wk-python/prova-sqlite$ python prova-sqlite.py 

-------------------------------

estat inicial

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

-------------------------------

insereix 3 files

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

id: 45; nom: nom6; valor: valor6

id: 46; nom: nom7; valor: valor7

id: 47; nom: nom8; valor: valor8

-------------------------------

insereix 3 files més

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

id: 45; nom: nom6; valor: valor6

id: 46; nom: nom7; valor: valor7

id: 47; nom: nom8; valor: valor8

id: 48; nom: nom9; valor: valor9

id: 49; nom: nom10; valor: valor10

id: 50; nom: nom11; valor: valor11

-------------------------------

ho deixa com estava a l'inici

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

albert@atenea:~/wk-python/prova-sqlite$ 

Per saber-ne més, una cerca a Google ens proporcionarà un munt d'enllaços. Tanmateix, cal explicitar la referència fonamental: el lloc de la documentació de Python (http://docs.python.org).

En particular, l'apartat de SQLite 3: http://docs.python.org/library/sqlite3.html

API C per a SQLite3

En aquest post presento un exemple de com fer servir l'API de C per a SQLite3 a Ubuntu 10.04.

L'API de C per a SQLite3 ens proporciona una interfície eficient per a programar aplicacions amb aquesta base de dades.

Per una banda crearé una base de dades nova. Fem servir l'SQLite Database Browser (es pot instal·lar des del Centre de Programari de l'Ubuntu).

Creo la 'taula1' amb tres columnes: id, del tipus integer; i valor i traduccio, les dues del tipus varchar.

Informo la taula amb algunes dades de prova:

Desenvolupo l'exemple fent servir la IDE Anjuta (si cal, es pot instal·lar des del centre de programari de l'Ubuntu). Creo un projecte C nou del tipus genèric (mínim).
Fins i tot sent un projecte "mínim" la quantitat de fitxers que genera Anjuta és important. Tanmateix, només ens caldrà modificar-ne dos: el main.c i el Makefile.am.

Li dono la ubicació del projecte i al fitxer main.c hi posem el següent codi

/*
 * main.c
 * Copyright (C) albert 2011 <stsoftlliure@gmail.com>
 *
 * c-sqlite is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * c-sqlite is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <sqlite3.h>
int main(void) {
    /* variables */
    sqlite3 *conn;
    sqlite3_stmt *stmtResultSet;
    int iError=0;
    int iComptador=0;
    const char *tail;
   
    /* obre  la connexió a la bd*/
    /* int sqlite3_open(
    /*     const char *filename,   /* Database filename (UTF-8) */
    /*     sqlite3 **ppDb          /* OUT: SQLite db handle */
    /* );
    /*****/
    iError = sqlite3_open("/home/albert/databases/sqlite3/prova-sqlite2/prova2.db3",
                          &conn);
    if (iError) {
        puts("No pot obrir la base de dades");
        exit(0);
    }
   
    /* crea una instrucció per a executar-la, en aquest cas un update */
    /* int sqlite3_exec(
    /*     sqlite3*,                                  /* An open database */
    /*     const char *sql,                           /* SQL to be evaluated */
    /*     int (*callback)(void*,int,char**,char**),  /* Callback function */
    /*     void *,                                    /* 1st argument to callback */
    /*     char **errmsg                              /* Error msg written here */
    /* );
    /*****/
    iError = sqlite3_exec(conn,
                          "update taula1 set traduccio=\'nova traducció\' where id=5",
                          0,0,0);
    if (iError) {
        puts("Error en fer update");
        exit(0);
    }
   
    /* fa una query i obté un "resultset" */
    /*
    /* int sqlite3_prepare_v2(
    /*     sqlite3 *db,            /* Database handle */
    /*    const char *zSql,       /* SQL statement, UTF-8 encoded */
    /*    int nByte,              /* Maximum length of zSql in bytes. */
    /*    sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
    /*    const char **pzTail     /* OUT: Pointer to unused portion of zSql */
    /* );
    /*****/
    iError = sqlite3_prepare_v2(conn,
                                "select id, valor, traduccio from taula1 order by id",
                                1000,
                                &stmtResultSet,
                                &tail);
    if (iError != SQLITE_OK) {
        puts("No pot obtenir dades");
        exit(0);
    }
   
    puts("---------------------------------------");
   
    /* mostra els resultats obtinguts iterant pas a pas pel pel "ResultSet" */
    /*
        int sqlite3_step(sqlite3_stmt*);
        After a prepared statement has been prepared using either sqlite3_prepare_v2() 
        this function must be called one or more times to evaluate the statement.
        If the SQL statement being executed returns any data,
        then SQLITE_ROW is returned each time a new row of data is ready
        for processing by the caller.
        The values may be accessed using the column access functions.
        sqlite3_step() is called again to retrieve the next row of data.
       
        Result Values From A Query:
        int sqlite3_column_int(sqlite3_stmt*, int iCol);
        const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
    */                   
    while(sqlite3_step(stmtResultSet) == SQLITE_ROW) {
        /* en la fila actual, obté els valors de les columnes */
        printf("%d |", sqlite3_column_int(stmtResultSet, 0)); /* id,  decimal */
        printf("%s |", sqlite3_column_text(stmtResultSet, 1)); /* valor, varchar */
        printf("%s \n", sqlite3_column_text(stmtResultSet, 2)); /* traducció, varchar */
        iComptador++;
    }
    printf("Total de registres: %d\n", iComptador);
   
    /* tanca el resultset */
    /*
    /* int sqlite3_finalize(sqlite3_stmt *pStmt);
    /* The sqlite3_finalize() function is called to delete a prepared statement.
    /*****/
    sqlite3_finalize(stmtResultSet);
   
    /* tanca la connexió */
    /*
    /* int sqlite3_close(sqlite3 *);
    /* The sqlite3_close() routine is the destructor for the sqlite3 object.
    /*****/
    sqlite3_close(conn);
   
    return (0);
}

Per a poder compilar el codi anterior, és necessari enllaçar-lo amb la llibreria de l'SQLite3. Per a fer això, modifico {nom-projecte}_LDFLAGS = -lsqlite3.
Com a alternativa, també hauria pogut generar un makefile particular.

Inclús en tindríem prou amb una instrucció del tipus:
gcc ./main.c -o prova-csqlite.exe -lsqlite3

Finalment, podem compilar i muntar amb l'Anjuta; i executem:

EXECUTING:
/home/albert/wk-c/prova-c-sqlite/c_sqlite
----------------------------------------------
1 |valor1 |traducció 1
2 |valor2 |traducció 2
3 |valor3 |traducció 3
4 |valor4 |traducció 4
5 |valor5 |nova traducció
Total de registres: 5

----------------------------------------------
Program exited successfully with errcode (0)
Press the Enter key to close this terminal ...

Com sempre, diposar de la documentació és clau per a poder reeixir en els desenvolupaments. La documentació està disponible al lloc de SQLite a Internet. D'aquesta altre adreça en podem descarregar un zip amb la documentació.

Com accedir a SQLite amb Lazarus / 27 juliol 2010

Com accedir a SQLite amb Lazarus

Aquest post és una rèplica de l'anterior, però canviant d'eina RAD. En aquest cas faig servir Lazarus que és una IDE d'aspecte similar al Delphi.

Lazarus funciona com una IDE de desenvolupament ràpid basat en components que fa servir el llenguatge Free Pascal (mireu també el site oficial)

Lazarus i Free Pascal es poden instal·lar directament des del  Centre de Programari de l'Ubuntu (jo faig servir una Ubuntu 10.04 - Lucid Lynx).

Tanmateix, amb la instal·lació per defecte, el component de connexió al SQLite  ve precarregat però no està activat. Cal anar a Package - Paquets instal·lats i allà triar en la caixa de paquets disponibles (la de la dreta) el paquet sqlite3laz 0.4 i prémer  el botó per desar i remuntar l'IDE. Amb això disposaré a la pestanya Data Access d'un component DataSet de connexió a bases de dades del tipus SQLite3. Podria triar un component de connexió a bases  de dades SQLite2, però no semblen conviure bé.

El que faré serà el mateix que en el post anterior:

Creo una base de dades SQLite 3. Aquest cop puc fer servir SQLite Database Browser, per exemple o bé la el client  en mode text (a la consola escriu sqlite3, si només poso sqlite se m'activa el client d'SQLite2).

Creo una taula taula1, amb tres camps: id (integer i PK), valor (varchar de 20) i traducció (varchar de 20)

Pel que he vist, Es necessari que el fitxer de base de dades tingui permisos 777. A més també cal que tingui permisos de lectura i escriptura la carpeta on s'ubica el fitxer de base de dades.

A continuació creo un formulari al que incorporo un SQLite3Dataset i un Datasource.
A les propietats del dataset indico:
Filename:  /home/albert/databases/sqlite3/prova-sqlite2/prova2.db3
TableName: taula1 (que és el mateix que posar a la propietat SQL: Select * from taula1;
i activo

Al Datasource li poso a la propietat Dataset el nom del component SQLite3Dataset

A continuació completo el formulari amb els botons Mostrar, Netejar i Sortir i un camp memo (que és l'equivalent a la textbox multilinea del VB). El funcionament dels botons es:
Mostrar: carrega les dades de la taula i les mostra al camp memo.
Netejar: esborra el camp memo.
Sortir: atura l'aplicació.

Per exemple, una cosa així:


El codi de la unitat queda de la següent forma:



unit unProvaSQLite3_03;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Sqlite3DS, db, odbcconn, sqldb, sqlite3conn, FileUtil,
  LResources, Forms, Controls, Graphics, Dialogs, DbCtrls, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    Datasource1: TDatasource;
    Memo1: TMemo;
    Sqlite3Dataset1: TSqlite3Dataset;
    Sqlite3Dataset1id: TLongintField;
    Sqlite3Dataset1traduccio: TMemoField;
    Sqlite3Dataset1valor: TMemoField;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;

implementation

{ TForm1 }

procedure TForm1.Button3Click(Sender: TObject);
begin
  Application.Terminate;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  { ShowMessage('esborra'); }
  Memo1.Clear;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  sId,sValor,sTraduccio: String;
  sLinea: String;
begin
  Sqlite3Dataset1.Open;
  Sqlite3Dataset1.First;
  while not Sqlite3Dataset1.EOF do begin
    sId := Sqlite3Dataset1id.AsString;
    sValor := Sqlite3Dataset1valor.AsString;
    sTraduccio := Sqlite3Dataset1traduccio.AsString;

    sLinea := sId  + '; ' + sValor + '; ' + sTraduccio;
    Memo1.Append(sLinea);
    Sqlite3Dataset1.Next;
  end;
  Sqlite3Dataset1.Close;
end;

initialization
  {$I unprovasqlite3_03.lrs}

end.


El més interessant és el mètode del botó mostrar (el procedure TForm1.Button1Click)

Obrim el dataset
Sqlite3Dataset1.Open;

anem al primer element del dataset
Sqlite3Dataset1.First;

mentre no arribem a la fi del dataset fem
while not Sqlite3Dataset1.EOF do begin

agafaem els valors dels camps de la fila actual del dataset. A diferència del Gambas, cada camp del dataset ha de tenir un objecte que el representi explícitament. El valor es torna com cadena per a facilitar-ne el tractament però hi han mètodes específics per aretornar int, long...
    sId := Sqlite3Dataset1id.AsString;
    sValor := Sqlite3Dataset1valor.AsString;
    sTraduccio := Sqlite3Dataset1traduccio.AsString;

formata una línia per mostrar amb els valors dels camps
sLinea := sId  + '; ' + sValor + '; ' + sTraduccio;

afegeix la línia al camp memo
Memo1.Append(sLinea);

avança a la següent fila del dataset
Sqlite3Dataset1.Next;

I quan ha recorregut tot el dataset, el tanca.
Sqlite3Dataset1.Close;

Aquest és el HelloWorld de Lazarus + SQLite.

Com accedir a SQLlite amb Gambas2 / 26 juliol 2010

Com accedir a SQLlite amb Gambas

Gambas és un llenguatge Basic per a Linux. El més interessant és que ens proporciona un entorn RAD (Rapid Application Development) de l'estil del Visual Basic prou eficient.

Qualsevol aplicació professional acaba atacant a una base de dades. Una opció interessant a Linux és fer servir SQLite.

La combinació de Gambas i SQLite és, doncs, una possibilitat a tenir en compte a l'hora de desenvolupar aplicacions sobre Linux.

Com utilitzar Gambas i SQLite conjuntament? faré un experiment

Primer de tot crearé una base de dades de SQLite, en aquet cas, d'SQLite2 (podria ser SQLite3)
La base de dades tindrà una taula taula1, amb dues columnes: ID (integer, clau primària) i VALOR (text)

Per a crear la DB podem fer servir la utilitat Gambas2 DB Manager que es proporciona juntament amb la instal·lació de Gambas.

També podria fer servir el client en mode text de SQLite.

Informo algunes dades de prova a taula1

Al Gambas:

Creo un formulari amb una textbox i tres botons (Obtenir, Netejar i Sortir)
Obtenir: mostra el contingut de la taula1
Netejar: esborra la textbox
Sortir: acaba l'aplicació.

Per exemple, alguna cosa així:




El codi BASIC seria el següent:

' Gambas class file
PRIVATE conConnexio AS Connection
PRIVATE trTaulaResultats AS Result
 
PUBLIC SUB _new()
  ' res
END

PUBLIC SUB Form_Open()
  ' res
END

PUBLIC SUB Button1_Click()
  PRINT ("[Button1_Click] Connecta")
  conConnexio = NEW Connection
  conConnexio.Type = "sqlite2"
  conConnexio.Host = "/home/albert/databases/sqlite2"
  conConnexio.Name = "proves.db"
  TRY conConnexio.Open()
  IF ERROR THEN
    Message.Error("Error al connectar amb la base de dades.")
    conConnexio = NULL
  ELSE
    trTaulaResultats = conConnexio.Exec("Select * from taula1")
    Neteja
    WHILE trTaulaResultats.Available
        MostrarCamps
        trTaulaResultats.MoveNext
    WEND
    conConnexio.Close()
  END IF
END

PUBLIC SUB Button2_Click()
  FMain.Close()
  STOP EVENT
END

PUBLIC SUB Button3_Click()
  Neteja
END

PUBLIC SUB MostrarCamps()
  TextArea1.text = TextArea1.text & "id: " & trTaulaResultats["id"] & "; valor: " & trTaulaResultats["valor"] & Chr(13)
END

PUBLIC SUB Neteja()
  TextArea1.text = ""
END
No hi ha pèrdua possible:

   crea un objecte de connexió
  conConnexio = NEW Connection

  indica que és una connexió del tipus SQLite2, podria ser d'altres: SQLite3, MySQL, Postgres, FireBird...   conConnexio.Type = "sqlite2"

  indica l'ubicació de la BD a obrir   conConnexio.Host = "/home/albert/databases/sqlite2"
  conConnexio.Name = "proves.db"

  i obre la connexió. Fixem-nos com obre la connexió dins d'un TRY.   TRY conConnexio.Open()

  Si hi ha un error, ho indica;   IF ERROR THEN
    Message.Error("Error al connectar amb la base de dades.")
    conConnexio = NULL
  ELSE
    ...

  i si no, mostra les dades:
   Obté el resultset (fent servir terminologia java), dataset (delphi) o recordset (VB).    trTaulaResultats = conConnexio.Exec("Select * from taula1")
       mentres tingui files per mostrar disponibles (available)
    WHILE trTaulaResultats.Available
   mostra la fila
        MostrarCamps
   avança fins la següent fila
        trTaulaResultats.MoveNext
    WEND
    quan ha recorregut tot el conjunt de resultats, tanca la connexió
    conConnexio.Close()
Per mostrar els resultats recupera el valor de cada columna per nom, els concatena amb una mica de format i afegeix un salt de línea amb Chr(13). tot plegat ho afegeix al contingut preexistent a la textbox

TextArea1.text = TextArea1.text & "id: " & trTaulaResultats["id"] & "; valor: " & trTaulaResultats["valor"] & Chr(13)

Aquest seria el HelloWorld!  de Gambas2+SQLite.

Com accedir a bases de dades SQLite des d'OpenOffice en Linux / 18 juliol 2010

Com accedir a bases de dades SQLite des d'OpenOffice en Linux

Primer de tot, què és SQLite? Segons la Viquipèdia: SQLite és una base de dades relacional continguda en una llibreria escrita C. A diferència d'altres bases de dades relacionals, SQLite no és un sistema de gestió de base de dades que funcioni amb un paradigma client-servidor. SQLite no és un procés autònom, sinó que s'integra dins d'altres programes.

Les bases de dades SQLite s'emmagatzemen en un fitxer que conté tant la definició de l'estructura de les dades com les dades mateixes.

Aquesta sistema ens recorda a les bases de dades d'Access (els fitxers .mdb).
OpenOffice Base fa servir un sistema de bases de dades del mateix estil, però basat en la HyperSonic DB.

SQLite és una tria intressant perquè a Linux disposem d'entorns RAD de programació com Gambas2, o Lazarus (Free Pascal) que permeten accedir fàcilment a aquesta base de dades. A l'hora de distribuir les nostres aplicacions, és molt senzill empaquetar la base de dades juntament amb l'aplicatiu.

De versions de SQLite a Ubuntu 10 en podem trobar dues de principals: la SQLite2 i la SQLite3. Per a la SQLite3, la més moderna, existeixen aplicacions gràfiques com SQLiteman o l'SQLite Database Browser (tots dos disponibles al "Centre de programari Ubuntu") que permeten dissenyar taules i fer consultes.

Per a la SQLite2 no serveixen les aplicacions anteriors i cal fer servir el client de línia d'ordres per a les tasques de disseny i administració.

Per a l'SQLite2, si tenim instal·lat el Gambas2 podem fer servir l'eina gambas2-database-manager.gambas.

Posats a triar entre SQLite3 i SQLite2 la versió més moderna és l'elecció obvia. Jo ho veig així. Tanmateix, en el cas de l'Ubuntu 10.04, per alguna raó que desconec, no s'ha incorporat el paquet php5-sqlite3 al "Centre de programari Ubuntu". Evidentment, és possible configurar el PHP per a accedir a BD del tipus sqlite3 però això implica alguna tasca addicional. Amb els paquets "out of the box" el que sí que funciona a la primera amb PHP és l'SQLite2.
Per la rao anterior potser hi haurà algun usuari d'Ubuntu 10.04 que preferirà muntar SQLite2 d'entrada en comptes de l'elecció més natural SQLite3.
OpenOffice Base a més de les pròpies bases de dades del tipus HyperSonic DB també permet accedir directament a altres tipus de bases de dades com MySQl, Oracle... i indirectament a totes aquelles per a les que es pugui trobar un driver JDBC, o drivers ODBC.

SQLite no és accessible directament sinó mitjançant un pas intermedi. En el meu cas, Ubuntu 10.04, és necessari configurar l'accés mitjançant ODBC.

Es tracta, doncs, d'instal·lar des del "Centre de programari de l'Ubuntu":
1. el paquet unixodbc-bin  (Unix ODBC)
2. el paquet libsqliteodbc (el driver Unix ODBC  per a SQLite)

Aleshores podrem utilitzar l'aplicació ODBCConfig per a configurar un DSN (DataSource Name, nomenclatura Microsoft!) al fitxer SQLite de base de dades que ens interessi.

Ara, des del nostre OpenOffice Base, ja podrem accedir a la base de dades SQLite sense més que fer "Nou" i accedir a una BD existent del tipus ODBC. Se'ns obrirà el ODBCConfig des del que podrem triar quin DSN volem fer servir.

I si accedim a una SQLite2, de pas, ara podrem fer servir l'OpenOffice Base com un excel·lent client gràfic per a crear taules, consultes i exportar-ne on importar-ne les dades