SQLite Latino America

SQLite Articulo en PDF

2011-04-12T17:39:00.001-07:00

Hola Amigos , aqui les traemos una pequeño articulo de SQLite
SQLite

Concatenación - UNION - uso de LIKE - Nombre de columnas con espacios

2009-04-06T14:56:00.001-07:00

CONCATENACIÓN DE CAMPOS

Es posible unir dos o mas cadenas usando un operador de concatenación. El estandar de SQL dice que se deberia usar ||, pero hay muchas diferencias entre los principales proveedores.

SELECT codigo || nombre
FROM departamentos

UNION. Uso de UNION para armar una unica vista con diferentes tablas.

Para crear una vista con datos provenientes de diferentes tablas, debe usar sentencias SELECT separadas por la palabra reservada UNION.
Asegurese de que se enumeraron la misma cantidad de columnas en cada una de las sentencias SELECT.

SELECT nombre FROM Clientes
UNION
SELECT nombre FROM Empleados
UNION
SELECT nombre from artistas

LIKE. Uso del comando LIKE en una sentencia SELECT.

El comando LIKE permite el uso de caracteres comodines:
% Se usa para reemplazar una cadena
_ Se usa para reemplazar un solo caracter.

En el siguiente ejemplo se listan los paises que comienzan con Z. El país Zambia se ajusta al criterio de elección, ya que 'ambia' se iguala con %.

SELECT nombre
FROM paises
WHERE nombre LIKE 'Z%'

BUSQUEDA EN TEXTO COMPLETO

El método "Fuerza bruta" consiste en usar el operador LIKE en cualquiera de los campos a ser inspeccionados.
Esto sería relativamente caro, pero lo suficientemente bueno en la mayoria de los casos. El término a buscar debe escribirse entre dos caracteres comodines y rodeado por comillas simples.
Se deberia construir la cadena literal en algun lenguaje de script - ¡No olvidar las comillas simples!

SELECT nombre FROM gisq.cia
WHERE nombre LIKE '%el%'

FUNCIONES DE AGREGADO. Mostrar un nombre de columna para una funcion de agregado

Cuando uno de los resultados a devolver es calculado (por ejemplo una suma) el nombre de la columna se asignará arbitrariamente. Es posible especificar uno particular, del siguiente modo:

SELECT region, SUM(poblacion) AS Poblacion
FROM cia GROUP BY region

NOMBRES DE COLUMNAS CON ESPACIOS.

Es posible definir nombre de columnas con espacios y estas pueden ser accedidas en las consultas. Por ejemplo:

CREATE TABLE MonstruoEspacial("Balance de cuenta" INT);
INSERT INTO MonstruoEspacial VALUES (42);
SELECT "Balance de cuenta" FROM MonstruoEspacial

traduccido por Monica Galarza

EQUI-JOIN (inner join) - SELF JOIN

2009-04-06T14:54:00.000-07:00

Saludos, a los integrantes de la comunidad, con este post iniciamos una serie de articulos mediante los cuales acercaremos material traducido desde sitios en inglés.
Comenzaremos este proyecto poniendo a disposición la traducción del contenido en el sitio SQLzoo.net.
Las traducciones no son literales, en algunos casos se han interpretados los textos a fin de poder proveer una mejor explicación de los ejemplos contenidos.
Si desean que se traduzca el contenido de algun otro sitio, seran bienvenidas sus sugerencias.
Bueno manos a la obra ...

Como usar un EQUI_JOIN (inner join) para relacionar dos tablas con el mismo nombre

Supongamos que tenemos una tabla empleados en donde guardamos los datos de los empleados y de los jefes de departamento.
Queremos armar una consulta que muestre el identificador de empleado, nombre del empleado, identificador de su jefe, nombre de su jefe y el departamento al que pertenece su jefe.
Para esto, deberemos relacionar la tabla empleados consigo misma mediante un "self join".
A cada copia de la tabla le asignamos un "alias", en este caso usamos e para los empleados y j para los jefes y a partir de alli podemos tratarlas como tablas diferentes.

Por defecto la unión obtenida es interna (inner join), esto significa que Ruben (Un empleado sin jefe) no se muestra en los resultados.

CREATE TABLE empleados( id_empleado INTEGER PRIMARY KEY,
nbre_empleado VARCHAR(10),
id_dpto VARCHAR(10),
id_jefe INTEGER REFERENCES empleados
);

INSERT INTO empleados VALUES (1,'Ruben','Ing',NULL);
INSERT INTO empleados VALUES (2,'Juan','SoC',1);
INSERT INTO empleados VALUES (3,'Andres','SoC',2);
INSERT INTO empleados VALUES (4,'Alicia','SoC',2);

SELECT e.nombre as empleado, j.nombre as jefe, j.id_dpto as dpto_jefe FROM empleados e, empleados j WHERE e.jefe_id = j.empleado_id

Traducido por Monica Galarza

FISL 10 - Edicion Especial -

2009-03-27T06:52:00.000-07:00

Se está acercando uno de los eventos de Software Libre más grandes del mundo, la decima edición del "Fórum Internacional de Software Livre" - FISL 10 -
Algunos de los panelista que pasaron por FISL fueron Ian Murdock -Debian - , Rasmus Lerdorf -PHP-, Richard Stallman -FSF- , Eric S. Raymond, Jon “maddog” Hall -Linux.org-
Esta edicion Especial se realizara del 24 al 27 de junio de 2009, en Porto Alegre, Rio Grande do Sul, Brasil.
SQLite Latino no se podia quedar fuera de este importante evento, por ello invitamos a la comunidad a visitar el web site del FISL , a traves del banner que esta en el sitio..
un Abrazo Gerardo Antonio

Adelantos del nuevo e-Book de SQLite por El Tribuno

2009-02-23T14:32:00.000-08:00

Hoy 23 de Febrero del 2009 apareció en la portada de uno de los más reconocidos periódicos reconocidos en el noroeste Argentino como es El Tribuno, una entrevista al sr. Gerardo Cabero, integrante fundador de la comunidad SQLite – Latino, dando a conocer algunos adelantos de los proyectos que ya están encaminados y en edición para toda la comunidad, se trata de un eBook para conocer SQLite a fondo, llamado "La Cocina de SQLite".

Desde ya están invitados a leer esta entrevista, sin dejar de agradecer tanto al Periódico El Tribuno como así también a su periodista Fernando Quiros, por el apoyo a este proyecto y la difusión del mismo.

Para más información les dejamos el blog de Fernando Quiros contando más detalles

+ colaboradores

2009-02-16T14:08:00.000-08:00

Bienvenido, Welcome, Welkon, Benvenuto, Witamy, ect..

En esta oportunidad queremos anunciar al llegada de dos nuevos colaboradores que pasana a formara parte de la comunidad asi como tambien darle la bienvenida formal a Marcos Mansilla.

@Marcos Mansilla (Marcos Mansilla - Arg)

@Monica Galarza (monica- Arg)

@Alejandro Sandoval (estepario - Chile)

Un Fuerte Abrazo A TODOS!!! BIENVENIDOS!!!

Entrevista a Daniel Maldonado de SQLite-Latino

2009-02-14T13:11:00.000-08:00

Esta entrevista fue realizada hace algun tiempo, por el Sr. Franco Rivero de la Revista TuxInfo .
www.tuxinfo.com.ar , desde ya Agrademos que nos dejen publicar dicha Entrevista....

Estuvimos con el Sr. Daniel Maldonado, quien junto con Gerardo Cabero están llevando adelante este interesante proyecto desde hace unos meses.

Franco Rivero: FR
Daniel Maldonado: DM

FR: Daniel, contanos un poco de que se trata este nuevo proyecto

DM:SQLite-Latino trata de dar a conocer esta excelente herramienta para el desarrollo de aplicaciones ya sea consideradas de complejidad media como así también los de grandes proyectos o sistemas.
Queremos hacer llegar a toda la gente de habla hispana la información referida a SQLite,
con respecto a sus características, ventajas, compatibilidad con diversos Lenguajes de Programación y demás curiosidades de lo que hemos denominado como el Pseudo Motor de Bases de Datos SQLite.

FR:Para los que no saben de que hablamos ¿Qué es SQLite?

DM:: Según D. Richard Hipp )creador de SQLite(, SQLite son librerías escritas en C
que implementa un motor de base de datos para SQL92 empotrable, Wikipedia también comparte y adopta este concepto, pero según el organizador de
esta comunidad )Gerardo Antonio Cabero(, SQLite permite dar otro tipo de enfoque a las bases de datos, y dejar de ser librería para convertirse en Pseudo
Motor - Aparenta ser un motor pero no lo es un nuevo concepto tomado como válido y que lo utilizamos como premisa para la Comunidad SQLite - Latino.
En tal sentido, Gerardo Antonio Cabero dice:
“Siempre he pensado que hay que dar un nuevo enfoque al desarrollo de las Base de datos, dejando a un lado ese carácter de librería para convertirse en algo más complejo como un Pseudo Motor de Bases de Datos.” Te comento que yo he intentado hablar con D. Richard Hipp y le he comentado de las caracterásticas de SQLite y que el da un nuevo enfoque al desarrollo de las bases datos a través de lo que hemos denominado Pseudo Motor . pero no e Tenido Exito...
SQLite tiene varias funcionalidades, que se entiende como las de un Motor de Base de datos Ejemplo, y con la carencias de otras. Tal es el Caso de La
integridad referencial. (La que actualmente se puede Simular)

FR: ¿Cuáles son las expectativas del proyecto SQLite Latino América a corto y a largo plazo?
DM Básicamente las primeras expectativas de este proyecto es dar a conocer las cualidades más destacadas de SQLite a toda Latino América y de algún modo captar su atención y alentarlos a probar este nuevo concepto para el desarrollo no sólo de prototipos de sistemas sino también de sistemas de alta complejidad.
Además, dar un espacio para que los interesados formulen sus preguntas, dudas y de algún modo generar un espacio de debate de usuarios expertos como así también de novatos en un plano .Por eso los invitamos a que nos visiten y nos acompañen a aprender junto a ustedes.

FR: ¿Quienes llevan adelante el proyecto y con que idea se reunieron a trabajar?
DM: El proyecto comenzó de la mano de Gerardo, al comienzo de todo lo tenía un poco bandonado, hasta que nos conocimos en una charla que el dió, sobre SQLite en Jujuy en las II Jornadas de Software Libre y luego al volver a tener contacto nuevamente en las II Jornadas de Software Libre en Salta. De ese modo realizó, como Gerardo la llamó, “la propuesta Indecente” de ser un administrador y formar juntos y con más fuerza la Comunidad de SQLite Latino y de algún modo continuar colaborando con la comunidad de Software Libre.

FR: Por último, ¿Cómo pueden colaborar los interesados?
DM: Bueno a todos los interesados desde ya le agradecemos sus visitas a la comunidad http://sqlite-latino.blogspot.com, Otro modo de colaborar con este fin es ayudando a traducir la documentación, enviarnos sus Review de SQLite y el comportamiento con otros lenguajes de programación y fomentando el uso de SQLite en el desarrollo de sistemas.

Desde ya agradecemos a Daniel por su tiempo, y queremos ofrecerles desde Tuxinfo a todos los proyectos independientes un espacio para que puedan difundir su trabajo y sus pensamientos, desde nuestra revista alentamos los proyectos que tanto bien hacen a nuestra comunidad y sepan que aquí tienen un espacio para la difusión....
Realizado por : Franco Rivero
Revista: TuxInfo www.tuxinfo.com.ar

Uso de SQLite por Alejandro Sandoval

2009-01-25T18:31:00.000-08:00

Hola Comunidad de SQLite Latino, Feliz comienzo de año 2009. hace unos dias El Sr. Alejandro Sandoval nos envio un articulo relacionado con SQLite. Agradecemos su aporte, Asi tambien todo estan invitados a participar de SQLite Latino

Espero que sea de su agradao. Hasta la proxima

Uso de SQLite

SQLite es un pequeño 'sistema' de base de datos: es una biblioteca que sobre un archivo almacena el esquema de la base de datos y los datos propiamente tal. En términos generales presenta un buen rendimiento, y está aconsejada para quienes requieren almacenar un volumen medio de datos en sus aplicaciones, utilizando un esquema relacional.En el caso de querer incluir la API SQLite en tu proyecto de programación, puedes incluir en tu programa C/C++ a sqlite.h, compilar a sqlite.c y listo.

Dentro de lo que podemos llamar una desventaja de SQLite es que no implementa la integridad referencial, es decir, no disponemos de claves foráneas (puedes declararlas, pero el intérprete ignorará tu declaración). De todas formas, SQLite si implementa triggers, así que hay algunas formas de implementar la integridad referencial de esa forma.

¿Un ejemplo? Pero con mucho gusto... de todas maneras, el ejemplo está pensado solo para mostrar las características de SQLite, así que no esperes un buen diseño ni nada por el estilo...

Por ejemplo, imagínese una pequeña empresa de buses que requiere almacenar información acerca de sus viajes. Para ello, supongamos que tenemos la tabla buses (con información de los buses), viaje (con los datos de un viaje) y pasajero (con los datos de un pasajero). Una propuesta entonces podría ser la siguiente:

create table buses(

id integer primary key not null autoincrement,

matricula text not null,

ano integer not null,

capacidad integer not null);

create table pasajero(

cedula text primary key not null,

nacimiento date not null);

create table viaje(

id_bus integer not null,

cedula text not null);

Bueno, hay algunas cosas por explicar de acá:

SQLite implementa el incremento automático de un campo (autoincrement), el que perfectamente pude indicarse para el primary key.

Las claves foráneas, como ya mencioné, no están implementadas aún en SQLite, así que no las agrego.

La primary key de la tabla viaje será su OID.

SQLite, para almacenar una tupla en una tabla, utiliza el sistema de OID, es decir, asigna secretamente un identificador para cada tupla, que facilita su búsqueda en el arbol B (la estructura de datos usada por SQLite para almacenar los datos en archivo). No necesito declarar el OID, pero puedo consultarlo en cualquier tabla; pronto un ejemplo de eso.

Ahora, insertemos algunos datos, para hacer las pruebas.

insert into buses values(null, 'ABCD-01', 2008, 40);

insert into buses values(null, 'JANO-05', 2007, 27);

insert into buses values(null, 'INSQ-35', 2007, 20);

insert into pasajero values('123ASD-K', 1980-05-23);

insert into pasajero values('237QSD-3', 1970-03-28);

insert into pasajero values('135QTW-3', 1989-08-05);

Con esos datos, podemos ver en acción el sistema de los OID:

sqlite>select oid,* from buses;

1|1|ABCD-01|2008|40

2|2|JANO-05|2007|27

3|3|INSQ-35|2007|20

sqlite>select oid,* from pasajero;

1|123ASD-K|1980-05-23

2|135QTW-3|1989-08-05

3|237QSD-3|1970-03-28

Puede parecer extraño lo que ocurre con la tabla buses, puesto que ya existe su primary key, y esta se autoincrementa. Bien, pues de todas formas se genera un OID... pero cuando se define una primary key autoincrementable de tipo integer, el OID tendrá el mismo valor que dicha clave. No ocurre lo mismo en la tabla pasajero, puesto que su primary key es un texto, y no un entero. Nota también que en los campos que se autoincrementan, el siguiente valor se genera insertando un null.

Gracias a esta característica es que he definido la tabla viajes sin primary key: confío en el OID (lo que no es recomendado, por cierto).

Ahora, la parte artística: ¿y las claves foraneas? Como mencioné, para eso disponemos de los triggers...

create trigger fki_viaje_buses

before insert on viaje

for each row

begin

select raise(rollback, 'Inserción en viaje viola restricción fki_viaje_buses')

where (select id from buses where id=new.id_bus) is null;

end;

Luego de eso, intentemos insertar un viaje para un bus no válido:

sqlite> insert into viaje values(5, '123ASD-K');

SQL error: Inserción en viaje viola restricción fki_viaje_buses

El trigger para la actualización (update) es exactamente igual, pero en el caso de la eliminación tenemos un problema: si quiero eliminar un bus ¿qué hago con los viajes? Por como se definió la base de datos, no se pueden eliminar buses o pasajeros mientras hayan viajes, así que manos al trigger:

create trigger fkd_viaje buses

before delete on buses

for each row

begin

select raise(rollback, 'No se puede eliminar bus')

where (select id_bus from viaje where old.id = id_bus) is not null;

end;

Ahora, si yo he insertado los siguientes datos de viaje

insert into viaje values(1, '135QTW-3');

insert into viaje values(1, '123ASD-K');

el trigger impedirá que eliminemos un bus, lo que generaría un estado inconsistente en la base de datos

sqlite> delete from buses where id = 1;

SQL Error: No se puede eliminar bus

Como se puede apreciar, SQLite es una alternativa interesante cuando se necesita un acceso a datos rápido y sencillo. Aunque me parece que SQLite es muy bueno, no me atrevería aún a usarlo en un entorno más de producción... aunque en la medida que lo voy usando, más me convence.

Autor: Alejandro Sandoval

Urls : http://esteparioprogramador.bligoo.com

:::NOTA COMPLEMENTARIA:::

Basándose en el ejemplo, el análisis es el siguiente: viaje es una tabla intermedia para la relación de muchos a muchos entre buses y pasajero. Por lo tanto, y siendo los campos de la tabla viaje claves foráneas, no puedo permitir la inserción de un viaje si el bus o el pasajero no existen: si lo permitiera, no tendría integridad referencial, dejando inconsistente la base de datos.

Por esa razón, se crean los triggers, y esa es la lógica que están siguiendo en este caso. Despedacemos el primer trigger pa que quede más claro:

create trigger fki_viaje_buses : Con eso, creo el famosillo trigger, y su nombre es fki_viaje_buses

before insert on viaje : Esto nos asegura la pega: el trigger será ejecutado antes de insertar en la tabla viaje. Eso te garantiza que la inserción no generará un estado inconsistente.

for each row : Está diciendo... puro traducir: repetir el trigger para cada fila insertada. Lo que se va a ejecutar está dentro del begin - end, por si acaso.

select raise(rollback, 'Inserción en viaje viola restricción fki_viaje_buses')

 where (select id from buses where id=new.id_bus) is null;

Aquí está el detallito: le estamos diciendo que lance un error (y ejecute un rollback) cuando se cumpla la condición del where, es decir, si no hay ninguna tupla en la tabla buses que tenga un ID igual al ID del bus que está en la nueva tupla de viaje (la variablenew se ocupa para designar a la tupla que se intenta insertar). Como ves, es exáctamente lo que definimos en palabras antes de comenzar el análisis del problema.

La actualización es la misma situación, puesto que es en el fondo una inserción. De hecho, la única diferencia entre ambos triggers son los mensajes y el nombre.

La eliminación es ligeramente diferente, y pensemos en el caso de eliminar un bus. ¿Qué haré con los viajes asociados?

Las soluciones ahí son:

on delete set null: poner los id_bus de viaje en null (lo que en una tabla intermedia no es factible, puesto que las FK son PK además).
on delete cascade: si elimino un bus, elimino todos sus viajes.
on delete restrict: no puedo eliminar un bus mientras hayan viajes asociados.

El trigger implementado al respecto sigue la última filosofía: no te dejará eliminar un bus mientras hayan viajes registrados con ese bus. En ese esquema, la lógica es al revés: hago el rollback si HAY viajes con el mismo bus_id que tiene old.id (como imaginarás, oldindica la tupla a eliminar).

El tema de los triggers para simular las FK no es tan complejo... pero igual hay que dedicarle su tiempo (en mi caso, significó aprender triggers primero, porque era materia nueva). Aún así, creo que no me demoré mucho en aprender lo necesario.Espero que hayas quedado más claro. Si hay más dudas, pregunta nomás: yo feliz de ayudar dentro de lo que pueda.

Acceso a Bases de Datos SQLite desde Gambas

2008-12-14T19:25:00.000-08:00

Nuevamente volvemos a sumar más documentación integrando el pseudo motor de Bases de Datos SQLite y un lenguaje de programación visual que día a día esta atrapando a más programadores de plataformas libres como es Gambas.

En esta oportunidad les voy a dejar el enlace de la revista digital Tuxinfo Nº12 en la cual Pablo Mileti explica en 8 páginas como acceder y realizar consultas y actualizaciones integrando esta dos herramientas SQLite y Gambas y de alguna manera podemos complementar la información con lo que Marcos hace unas semanas atrás mostraba.

Descargar Tuxinfo Nº12

Integridad Referencial

2008-12-14T17:57:00.000-08:00

La integridad referencial es una propiedad
deseable en las base s de datos. Gracias a la integridad referencial se garantiza que una entidad (fila o registro) siempre se relaciona con otras entidades válidas, es decir, que existen en la base de datos. Implica que en todo momento dichos datos sean correctos, sin repeticiones innecesarias, datos perdidos y relaciones mal resueltas.

Como es sabido por la los desarrolladores de SQLITE , la integridad referencial no esta implementada de forma mativa pero es posible realizar la emulacion de la misma atravez de los trigger.
Extraido de la Wikipedia : www.wikipedia.org

El Siguiente Ejemplo fue extradido de la wiki del "El Server" - http://www.elserver.com/wiki/

=========================================================
La tabla PELICULAS tiene dependencia de otras dos: GENERO y  SOPORTE.

Los triggers antes de insert y antes de update on Peliculas tienen en cuenta estas dos dependencias.
Para antes de delete hacen falta dos triggers: uno en Genero y otro en Soporte.
Estos triggers impiden que se pueda borrar un genero o un soporte, si hay peliculas que lo están
usando.
El código deja claro lo que se haría si la dependencia fuera de más tablas,sólo habría que añadir más OR  y los triggers on delete.
Si la dependencia fuera solo de una tabla,se quitaría un OR y el delete que sobre.

CREATE TABLE [genero] (
[id_gen] INTEGER  PRIMARY KEY NOT NULL,
[nombreGen] VARCHAR(40) UNIQUE NOT NULL
);

CREATE TABLE [soporte] (
[id_sop] INTEGER  NOT NULL PRIMARY KEY,
[nombreSop] VARCHAR(20)  UNIQUE NOT NULL
);

CREATE TABLE [peliculas] (
[id_pel] INTEGER  NOT NULL PRIMARY KEY,
[id_genero] INTEGER  NOT NULL,
[id_soporte] INTEGER  NOT NULL,
[nombrePel] VARCHAR(40)  NOT NULL
);

CREATE TRIGGER film_pel_in before insert on peliculas
for each row
begin
select case
when
(
(new.id_soporte is not null)
and
(new.id_genero is not null)
and
(
((select id_sop from soporte where
 id_sop =new.id_soporte) is null)
or
((select id_gen from genero where
  id_gen = new.id_genero) is null)
               )
)
then raise(abort,'violacion integridad')
end;
end;

CREATE TRIGGER film_pel_up before update on peliculas
for each row begin
select case
when
(
((select id_sop from soporte where
id_sop = new.id_soporte) is null)
or
((select id_gen from genero where
id_gen = new.id_genero) is null)
)
then raise(abort,'violacion integridad')
end;
end;

CREATE TRIGGER film_sop_de before delete on soporte

for each row begin
select case
when
((select id_soporte from peliculas
where id_soporte = old.id_sop) is not null)
then raise(abort,'violacion integridad')
end;
end;

CREATE TRIGGER film_gen_de before delete on genero
for each row begin
select case
when
((select id_genero from peliculas
where id_genero = old.id_gen) is not null)
then raise(abort,'violacion integridad')
end;
end;

Pequeña Consulta en SQLite3 utilizando el lenguaje C

2008-12-01T05:05:00.000-08:00

Hace algunas semanas hemos recivido , de parte de uno de los desarrolladores "Ricardo D. Quiroga" de la comunidad un ejemplo de como implementar SQLite en el Languaje C. A Quien Agradesemos el Envio de este miniComo..

Basado en el ejemplo posteado en http://www.sqlite.org/quickstart.html

Autor: Ricardo D. Quiroga -> l2radamanthys@gmail.com

El codigo fuente posteado aqui esta bajo licencia GPL2 (license.txt)

Codigo fuente Probado usando el Dev-C++ y el Compilador GCC

#include

El autor no se hace responsable del daño que el mismo pudiese causar directa o indirectamente a tu computadora ,novia,, perro, Y/O SUEGRA ,ect. use el mismo bajo su propia responsabilidad.

Se Incluyen los siguientes archivos:

* libreria sqlite

- sqlite3.h

- libsqlite3.a

- sqlite3.dll

* codigo fuente

- main.c (Codigo fuente)

- main.c.html (vercion del codigo fuente para visualizar como html)

- test1.dev (archivo de proyecto (solo para Dev-C++) )

Aunque fue el Codigo fue probado con el Dev-C++ usando el GCC el mismo tambien deveria poderse compilar usando cualquier otro ya que el mismo solo fue escrito en ANSI C

Sobre la BD:

Crear una BD con el nombre 'test.db'(o cambiar el nombre de la bd en el codigo fuente) a la cual luego se le agregara una tabla llamarla 'table1' y colocarle los camposo que ud eligan

Que hace el programa:

Conecxta una base de datos a SQLite realiza una pequeña consulta con SQLite en este ejemplo la consulta es la siguiente "select * from table1;" muestra los resultados en pantalla y cierra la bd.

/*****************************************************************************************

------ Una Simple consulta en SQLITE Usando C ------

Probado con el Dev-C++ Usando el GCC

Por Ricardo D. Quiroga - l2radamanthys@gmail.com

Este ejemplo esta basado en el codigo posteado en http://www.sqlite.org/quickstart.html

Quitando los Comentarios son como 25 lineas

*****************************************************************************************/

#include

#include //libreria para trabajar con SQLite3

static int callback(void *NotUsed, int argc, char **argv, char **azColName){

for( int i=0; i

printf("%s ", argv[i] ? argv[i] : "NULL");

}

printf("\n");

return 0;

}

int main(int argc, char **argv) {

sqlite3 *db; //variable que hara referencia a la Base de Datos que utilzaremos

char *zErrMsg; //string que almacenara el mensaje de error

int rc; //amacenara el resultado del llamado de las funciones de sqlite3.h

/*****************************************************************************************

Abrimos la base de Datos en nuestro caso la BD se llamara 'test.db'

int sqlite3_open(

const char *filename, Nombre de la Base de Datos (UTF-8)

sqlite3 **ppDb Salida SQLite db handle

);

En caso de error la funcion sqlite3_open() devolvera un valor distinto de 0

*****************************************************************************************/

rc = sqlite3_open("test.db", &db);

/*****************************************************************************************

Mostramos el mensaje de error en caso de que no se pudiera abrir la Base de Datos

*****************************************************************************************/

if (rc) {

fprintf(stderr, "No se pudo Abrir la base de Datos: %s\n", sqlite3_errmsg(db));

sqlite3_close(db);

exit(1);

}

/*****************************************************************************************

Strings que alamcenaran las consulta que relizamos en la que Copiaremos la instrucion de

SQLite que queremos ejecutar en la variable 'instrucion' en este caso una simple consulta

a la Base de Datos

*****************************************************************************************/

char instrucion[1024]="";

sprintf(instrucion, "SELECT * FROM table1;");

/*****************************************************************************************

Ejecutamos la instrucion alamcenada en el string instrucion en SQLite3

Esplicacion mas a fondo de la funcion 'sqlite3_exec()'

int sqlite3_exec(

sqlite3*, Base de Datos Abierta

const char *sql, Instrucion de SQl a evaluar

int (*callback)(void*,int,char**,char**), funcion (Callback) ver arrina

void *, 1er agumento de la funcion Callback

char **errmsg variable de mensaje de error (1)

);

si ocurrio un error durante la ejecucion de la instrucion la la funcion devolvera un valor

diferente de la constante SQLITE_OK y el tipo de error sera devuelto en la variable errmsg(1)

*****************************************************************************************/

rc = sqlite3_exec(db, instrucion, callback, 0, &zErrMsg);

/*****************************************************************************************

En caso que ocurriera un error en la ejecucion de la instrucion SQL mostramos el mismo

*****************************************************************************************/

if ( rc!=SQLITE_OK )

{

fprintf(stderr, "SQL error: %s\n", zErrMsg);

}

/*****************************************************************************************

funcion para cerrar la Base de Datos ( Sin comentarios....)

*****************************************************************************************/

sqlite3_close(db);

printf("\n");

system("PAUSE"); //pausamos la ejecucion del programa par aque no se cierre la consola

return EXIT_SUCCESS;

} //fin del programa.....

Este programa fue desarrollado como ejemplo de uso de SQLite para SQLite-Latinoamerica

Ricardo D. Quiroga

Mono + NHibernate + SQLite

2008-11-04T07:40:00.000-08:00

Después de usar por tanto tiempo Gentle.NET, un ORM que ha sido discontinuado, he decidido al fin comenzar a estudiar NHibernate. Los ejemplos que dan en los manuales y páginas son para Windows (con MS .NET) y SQL Server. Trabajando en GNU/Linux, hice las pruebas con SQLite.

El problema es que el driver utilizado por NHibernate para esta base de datos utiliza un binding desactualizado. Además Mono trae una implementación mejor, que soporta el standard ADO.NET 2.0, que es Mono.Data.Sqlite, disponible a partir de la versión 1.2.4.

El post es especialmente útil para aquellos que quieran utilizar en GNU/Linux (yo uso Ubuntu Gutsy), con Mono, NHibernate y SQLite, utilizando el binding Mono.Data.Sqlite. Si bien puede parecer esto tan fácil como seguir el documento QuickStart y cambiar las opciones correspondientes, no lo es si se intenta utilizar SQLite. Por eso, en este post no voy a explicar todas las cosas, ya que no me interesa y se pueden aprender en la documentación, sino que voy a desarrollar un ejemplo muy sencillo y mostrar cómo utilizar SQLite, ya que hay que solucionar unos problemas no muy triviales.

Cabe aclarar que, si bien todavía no lo he probado, los archivos de mapeo (hbm.xml) y el schema SQL se pueden autogenerar.

Primero creo la tabla que almacenerá los objetos en un archivo llamado, por ejemplo, data.db.sql:

DROP TABLE IF EXISTS personas;

CREATE TABLE personas (
id integer PRIMARY KEY,
nombre varchar(20),
apellido varchar(20)
);

Para el ejemplo utilicé la última versión de SQLite. Para crear la base de datos en el archivo data.db, ejecutamos:

$ sqlite3 data.db <>

La clase de ejemplo (Persona.cs):

using System;

namespace PruebaNHibernate
{
public class Persona
{
private int id;
private string nombre;
private string apellido;

public Persona()
{
}

public int Id {
get { return id; }
set { this.id = value; }
}

public string Nombre {
get { return nombre; }
set { this.nombre = value; }
}

public string Apellido { get { return apellido; } set { this.apellido = value; } } } }

Luego hay que escribir el archivo de mapeo, que es un XML.

version="1.0" encoding="utf-8" ?>

xmlns="urn:nhibernate-mapping-2.2"
namespace="PruebaNHibernate" assembly="PruebaNHibernate">

name="Persona" table="personas">
name="Id" column="id" type="Int32">
class="increment" />
>

name="Nombre" column="nombre" />
name="Apellido" column="apellido" />
>
>

Este archivo se debe agregar como recurso en MonoDevelop.

Luego escribimos el archivo de configuración para nuestra aplicación (app.config):

<?xml version="1.0" encoding="utf-8" ?>
>
>

name="nhibernate"
type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
>

>

key="hibernate.connection.provider"
value="NHibernate.Connection.DriverConnectionProvider"
/>

key="hibernate.dialect"
value="NHibernate.Dialect.SQLiteDialect"
/>

key="hibernate.connection.driver_class"
value="PruebaNHibernate.MonoDataSqliteDriver, PruebaNHibernate"
/>

key="hibernate.connection.connection_string"
value="Data Source=data.db,version=3"
/>

key="hibernate.query.substitutions"
value="true=1;false=0"
/>

key="hibernate.use_prox y_validator"
value="false"
/>
>
>

Nota: Debido a problemas con el hosting no puedo colocar, arriba, el string correcto en la última parte. La palabra prohibida “p r o x y” (sin espacios) tiene un espacio de más entre la “x” y la “y”. En fin, deshabilito en esas lineas la comprobación de clases p r o x y.

Luego en un archivo como Main.cs agrego código en el método principal Main para jugar con todo esto:

using System;
using NHibernate;
using NHibernate.Cfg;

namespace PruebaNHibernate
{
class MainClass
{
public static void Main (string[] args)
{
Configuration conf = new Configuration();
/* Con la siguiente línea leo todo los archivos con extensión
* hbm.xml embebidos como recurso en el assembly especificado */
conf.AddAssembly("PruebaNHibernate");

ISessionFactory sessionFactory = conf.BuildSessionFactory();

ISession s = sessionFactory.OpenSession();

ITransaction tx = s.BeginTransaction();

Persona p = new Persona();
p.Nombre = "Milton";
p.Apellido = "Pividori";
s.Save(p);
tx.Commit();

Console.WriteLine("p - Id: " + p.Id);
Console.WriteLine("p - Nombre: " + p.Nombre);
Console.WriteLine("p - Apellido: " + p.Apellido);
Console.WriteLine();

Persona p2 = (Persona)s.Load(typeof(Persona), p.Id);

Console.WriteLine("p2 - Id: " + p2.Id);
Console.WriteLine("p2 - Nombre: " + p2.Nombre);
Console.WriteLine("p2 - Apellido: " + p2.Apellido);
Console.WriteLine();

/* Verifico si son el mismo objeto p y p2, ya que estamos
* dentro de la misma sesión */
if (p == p2)
Console.WriteLine("p y p2 son el mismo objeto");

p2.Apellido = "Paduán";

s.Flush();

s.Close();
}
}
}

En el proyecto agregué estas referencias:

NHibernate.dll
System

Ahora vamos a lo que nos interesa. En el archivo app.config (que al compilar se traducirá a .exe.config en el directorio de salida), observemos estas lineas:

…
key="hibernate.connection.driver_class"
value="PruebaNHibernate.MonoDataSqliteDriver, PruebaNHibernate"
/> …

NHibernate trae un driver para SQLite, como dije al principio, pero que utiliza un provider que fue discontinuado. Por lo tanto, para utilizar Mono.Data.Sqlite, cree una clase en mi assembly (PruebaNHibernate) con el nombre que se indica allí (MonoDataSqliteDriver):

using System;
using NHibernate.Driver;

namespace PruebaNHibernate
{
public class MonoDataSqliteDriver : ReflectionBasedDriver
{
public MonoDataSqliteDriver()
: base("Mono.Data.Sqlite",
"Mono.Data.Sqlite.SqliteConnection",
"Mono.Data.Sqlite.SqliteCommand")
{
}

public override bool UseNamedPrefixInSql
{
get { return true; }
}

public override bool UseNamedPrefixInParameter
{
get { return true; }
}

public override string NamedPrefix
{
get { return "@"; }
}

public override bool SupportsMultipleOpenReaders
{
get { return false; }
}
}
}

En el constructor de la misma le paso a mi clase padre los argumentos que necesita: nombre del assembly (en este caso “Mono.Data.Sqlite”), clase para crear la conexión y ejecutar comandos. Desconozco los detalles de SQLite, así que copié los métodos sobreescritos del driver viejo.

No pude hacer que NHibernate cargue el assembly “Mono.Data.Sqlite” desde el GAC, así que hay que copiarlo al directorio del ejecutable. Es necesario copiar otros archivos, como las dependencias de NHibernate y la base de datos (data.db). Se pueden bajar el proyecto completo para MonoDevelop aquí. El archivo obviamente no es un png, pero sino no lo puedo subir

Ahora bien, hay un problemita… el archivo System.Data.dll que viene con Mono 1.2.4 en Gutsy tiene un bug que hará que el ejemplo no funcione. El mismo ya fue solucionado en la versión 1.2.6. Así que, como workaround, pueden bajarse el paquete de Debian libmono-system-data2.0-cil correspondiente a la versión 1.2.6 de Mono y sobreeescribir ese archivo, que se ubica en /usr/lib/mono/gac/System.Data/2.0.0.0__b77a5c561934e089/. Reporté el problema en Ubuntu, así que quizá lo actualicen dentro de poco.

Con esto podremos utilizar SQLite con NHibernate, bajo Mono, con un binding actualizado.

Autor : Milton Pividori

FUENTE DEL ARTICULO : http://www.miltonpividori.com.ar/2007/12/30/mono-nhibernate-sqlite/

SQLite y Gambas2

2008-11-02T12:33:00.000-08:00

Gambas es otro de los tantos hacks recursivos que se usan, en si el significado es "Gambas Almost Means Basic", pensado como herramienta RAD y con Basic como lenguaje base, pero mejorado, vemos que tambien es multiprosito, en esta ocasión vamos a ver como hacer una conexión a una base de datos SQLite desde Gambas2.

Lo primero que debemos tener disponible para trabajar, ademas de SQLite, es Gambas2, en Debian y derivados:

#apt-get install gambas2

para otras distros podemos encontrar las fuentes en http://gambas.sourceforge.net/
la parte mas importante esta en saber cuales son las herramientas que nos provee el languaje, y los datos de conexión de almacenan en un solo botón, el codigo es el siguiente:

'Instanciamos un objeto de clase Connection
PRIVATE $hConn AS Connection

'Boton de conexión a la base de datos
PUBLIC SUB btnConnect_Click()

DIM sName AS String
DIM hTable AS Table

TRY $hConn.Close

sName = txtName.Text

IF sName <> "" THEN

'Asignamos valores a las propiedades que vamos a usar
WITH $hConn

'Definimos el tipo de base de datos
.Type = "sqlite"

'Definimos el nombre del host
.Host = txtHost.Text

END WITH

'Asignamos el nombre de la conexion
$hConn.Name = sName

'Abrimos la conexion para poder trabajar
$hConn.Open

'Habilitamos los otros formularios
frmDatabase.Enabled = TRUE
frmRequest.Enabled = TRUE

btnConnect.Enabled = FALSE
btnClose.Enabled = TRUE
CATCH

Message.Error(DConv(Error.Text))
ENDIF

END

A continuación capturas de la aplicacion terminada y en diseño.

Antes de terminar debo aclarar que la base de datos debe estar creada, en caso contrario no se realiza la conexión, ademas se debe dar la ruta completa de la ubicación del archivo que contiene dicha base de datos. La aplicación completa para su descarga en el siquiente link:

Descarga

Generador de Trigger

2008-09-30T18:29:00.000-07:00

Todos sabemos que sqlite, carese de integridad referencia, no obstante podemos definirla atraves de los trigger o disparador, su funcion dentro de la DB es ejecutar un evento cuando se cumple una condición establecida al realizar una operación de inserción (INSERT), actualización (UPDATE) o borrado (DELETE).
Aqui les dejamos un link donde puden mirar un par de ejemplos sobre la contruccion de trigger y un generador de triggers.
Si se pregunta por que estamos desaparecidos en Sqlite - Latino. , Nos econtramos preparando un par de sopresas.

Saludos

link data
"Genarador Triggers" :
http://www.rcs-comp.com/site/index.php/view/Utilities-SQLite_foreign_key_trigger_generator
"elserver" :
http://www.elserver.com/wiki/SQLite_relacionar_tablas_con_triggers
"Sqlite" :
http://www.sqlite.org/lang_createtrigger.html
"esteparioprogramador" :
http://esteparioprogramador.bligoo.com/content/view/228771
"justatheory":
http://www.justatheory.com/computers/databases/sqlite/foreign_key_triggers.html

Reunión de la Comunidad SQLite-Latino

2008-09-01T08:39:00.000-07:00

En el marco de las III Jornadas de Software Libre organizado por alumnos de la Universidad Nacional de Jujuy – UNJu, en la Provincia de Jujuy – Argentina, la Comunidad SQLite – Latno tuvo lugar a un encuentro en donde se organizaron algunas cuestiones propias del grupo.

La verdad que es la primera ves que estamos reunidos y charlando sobre los proyectos que se biene de acá en adelante.

Es por ello que la invitación de participar nuevamente se renueva con el fin de incorporar más seguidores y entusiastas a colaborar con esta pequeña comunidad que día a día y gracias a ustedes va creciendo.

Groovy + GSql + SQLite (Parte I)

2008-08-11T16:27:00.000-07:00

Groovy
Es un lenguaje de programación orientado a objetos implementado sobre la plataforma Java. Tiene características similares a Python, Ruby, Perl y Smalltalk. por lo tanto permite escribir código "simple, limpio y corto" -mas info-

GSql Y SQLite

GSql simplifica el acceso a los JDBC, es capas de implementar SQLite, atraves de de la compatibilidad con las librerías de Java, esto lleva aprovechar algunas característica presente en Groovy.
Con estos sencillos pasos podremos llevar a cabo la conexión y previa consulta de datos utilizando Groovy + Gsql + Sqlite

1ro- Descargar las librerías de SQLiteJDBC desde el sitio http://www.zentus.com/sqlitejdbc/, las mismas son totalmente nativas y desarrolladas 100% Java.

2do- Agregar el JDBC sqlitejdbc-v052.jar dento de la configuración de groovy en ~/.groovy/lib. en mi caso

En GNU/Linux = /urs/share/groovy/lib/
En M$ Guindos = archivodeprograma\groovy\lib\

3ro- Se debe de crear la DB con SQLite - Review I y Review II -

4to- Ejecutamos GroovyConsole.

Una ves desplegada la consola de Groovy, lo que debemos de hacer es importar las librerías GSQL y se creara una nueva instanciar de la clase SQL o conexión con los driver JDBC, es muy importante definir la URL de la DB y el el nombre del Driver, como se muestra a continuación :


import groovy.sql.Sql
sql = groovy.sql.Sql.newInstance("jdbc:sqlite:/home/gerardo/sqlitelatino.db","org.sqlite.JDBC")

Ahora crearemos una nueva tabla la cual recibe el nombre de "prueba", dentro de groovy se utiliza el método execute, que se encuentra en la clase sql , este método recibe como parámetro un objeto string que es una sentencia SQL. En este caso Create :


sql.execute("create table prueba(ide,nombre,mail)")

Una ves creada la tabla , realizaremos la inserción de nuevos campos, para ello seguiremos utilizando el método execute, solo que cambiaremos la sentencia Create por Insert. como se muestra a continuación.


sql.execute("insert into comunidad(ide,nombre, mail) values('Gerardo', 'gerard@mail.com')")
sql.execute("insert into comunidad(ide,nombre, mail) values('Daniel',' dan@mail.com')")
sql.execute("insert into comunidad(ide,nombre, mail) values('Marcos', 'big@mail.com')")

Para poder dar un poco de vida a nuestro código, usaremos println para dejar carteles indicando que datos se están mostrando.


println 'SQlite Latino'
println ' Nombre   Email '
println '+--------+--------+'

Ahora utilizaremos el método eachRow el cual me devuelve cada elemento de una consulta determinada y en cada iteración se visualizara el contendido del los elementos.


sql.eachRow('select * from comunidad?)
{ integrante ->println "${integrante.nombre} ${integrante.mail}"
}

Ahora solamente bastar con ir a la barra de menú de GroovyConsole y Ejecutar Run. el cual compilara y ejecuta nuestro código Groovy. Hasta aquí la entrega de Sqlite + Groovy. esperamos realizar muy pronto una nueva entrega.
Un Abrazo , Hasta la proxima...

Ruby - SQLite (Parte II)

2008-08-09T21:21:00.000-07:00

Ahora luego de una pequeña demora, veamos como realizar nuestro primer ejemplo con el lenguaje de programación Ruby y nuestro ya conocido pseudomotor SQLite.

Si aún no tienes instalado el módulo de SQLite para Ruby, te recomiendo que leas el post anterior antes de continuar con este ejemplo.

Lo primero que vamos a realizar es crear un archivo para que lo ejecute luego el intérprete de Ruby, simplemente en nuestro editor de texto favorito creamos un archivo con extensión .rb por ejmplo "prueba01.rb" y vamos a utilizar la base de datos que utilizamos para aprender en las Review I y Review II de SQLite.

# Importamos las librerías de SQLite3
require 'sqlite3'

# Realizamos la correspondiente conexión con la Base de Datos.
# Para ello podemos colocar el Path donde se encuentra el mismo
db = SQLite3::Database.new("BaseDatos.db")

# En la variable sql, realizamos una consulta, simplemente
# por cuestiones de prolijidad y legibilidad.
sql = "SELECT apellido, nombre FROM personal order by id"

# Ejecutamos la consulta ingresada en la variable anterior
# recorriendo el contenido de la misma
db.execute(sql) do |fila|
 p fila
end

# Por último cerramos la conexión
db.close

Por último solo nos va a quedar interpretar y ejecutar el archivo creado, esto es hace de la siguiente manera:

$ ruby prueba01.rb

SQLite 3.6.1

2008-08-07T18:41:00.000-07:00

Hace algunos dias se encuentra libre la version de sqlite la 3.6.1 , la cual a solucionados algunos de los problemas de las antiguas versiones.

# Modificacion del Virtual File System

# La Busqueda ahora es un 15% mas Rapida

Ademas se esperan nuevas mejoras para la version 3.7 como :

1. Los nombres puede ser incluido en [...] para mantener la compatibilidad con Access
y SQLServer.

2. Los nombres puede ser incluido en los acentos graves para la compatibilidad con
MySQL.

Ruby – SQLite

2008-06-26T09:56:00.000-07:00

Después de algunas pruebas y ejemplos vamos a ver, aprender y conocer como manejar SQLite a través de Ruby, un excelente lenguaje de programación.

Nuevamente vamos a ver como se comporta SQLite con diferentes lenguajes, en este caso nos vamos a referir a Ruby, un lenguaje de programación interpretado, multiplataforma, totalmente libre de licencia GNU/GPL (GNU General Public License) creado por Yukihiro Matsumoto. Si deseamos conocer más información sobre este lenguaje les recomiendo que visiten este enlace.

Ruby poco a poco esta captando más usuarios programadores y al igual que Python es totalmente orientado a objeto, fácil de aprender, muy flexible y ágil.

Al igual que en otros How To si se trata de SQLite siempre les recomendamos que ya sepan de antemano algunos manejos de SQLite para ellos les recomendamos que lean las Review I y Review II escritas por la comunidad.

Antes de comenzar a realizar los ejemplo y prácticas preparemos el terreno y el entorno de ejecución.

Como les decía anteriormente Ruby, un lenguaje que día a día pisando más fuerte, es muy probable que ya lo tengamos instalado en nuestra distribución GNU/Linux, en caso que no la tengamos realizamos:

$ sudo apt-get install ruby irb rdoc ir

Con estoy nos instalar el intérprete de Ruby y otras herramientas muy útiles.

Ahora necesitamos instalar la librería que nos va a permitir manipular y manejar a través de objetos las bases de datos creadas por SQLite. Para esto existen muchas maneras de instalar.

Una de las formas exites un concepto en Ruby que nos permite instalar librerías y módulos llamado Gems, la cual se conecta a un repositorio, descarga la librería y la instala, para ello podemos realizar lo siguiente:

gem install --remote sqlite-ruby

Otro método que se los puedo recomendar por que lo utilicé asi, es descargar RubyForge las librerías, descomprimirlas en nuestro sistema, entramos al directorio y realizamos el siguiente comando para instalarlo:

sudo ruby setup.rb

De esta menra podemos decir que ya tenemos instalador y configurado el módulo para manipular las bases de datos SQLite y en su última versión que es la 3.

Una de las ventajas que encontre instalando desde el código fuente, es que en el mismo además de encontrar ejemplos es un FAQ y bastante documentación que nos será útil para dar los primeros pasos.

Hasta aquí la primera entrega de SQLite y Ruby, en próximas entregas vamos a ver las conexiones e implementación sobre este lenguaje.

Quienes nos Visitan

2008-06-16T16:16:00.000-07:00

Nos justaría mucho que dejen su firma en nuestro Visitor Map. de SQlite Latino
Un Abrazo Gerardo Antonio Cabero

Access VS SQLite

2008-06-11T19:38:00.000-07:00

A lo largo de este tiempo es interesante ir recolectando datos y experiencias de usuarios que ya experimentaron con SQLite y comienza a sacar sus propias conclusiones.

Este post encontré navegando por la WWW y en esta oportunidad lo quería compartir con todos ustedes.

QuarkBlog

De hecho te invitamos a que nos cuentes tu experiencia o tus primeros pasos con SQLite

Link Guias JAVA y Sqlite

2008-06-07T13:40:00.000-07:00

Hace algunos dias posteamos un Link de Guias de Php. Aqui le traemos, un par de link para los desarrolladores java .

http://www.zentus.com/sqlitejdbc/
http://www.ch-werner.de/javasqlite/ -ORM-
http://www.ifconfig.com.ar/programacion/sqlite-y-java/
http://www.itwriting.com/sqlitenotes.php
http://www.seraphinux.com/

Link Guias PHP y Sqlite

2008-06-03T16:48:00.000-07:00

Aqui una pequeña lista de sitios, y Blogs para los desarrolladores de PHP , que desaen trabajar con sqlite para sus aplicaciones.. Si teien mas link sobre otros lenguajes seran bienvenidos....

http://es.codepicks.net/phpmanual/ref.sqlite.html

http://www.devshed.com/c/a/PHP/Introduction-to-Using-SQLite-with-PHP-5/1/

http://ar2.php.net/manual/es/book.sqlite.php

http://devzone.zend.com/node/view/id/760

http://code.jenseng.com/db/
http://www.litewebsite.com/?c=49

SQLite de viaje por Argentina

2008-05-24T16:22:00.000-07:00

Hola amigos de SQLITE LATINO AMERICA

Me van a disculpar, anteriormente no tuve tiempo para poner mas info de este evento q se realizo en la ciudad de cordoba en argentina las "2das Jornadas de Software Libre" , organizadas por el Grupo DATA - Grupo de Investigación en Software Libre de la UTN Facultad Regional San Francisco de la Provincia de Córdoba.

Como disertante en los siguientes temas

Superwaba - Desarrollo de Aplicaciones Móviles - ,

Groovy - Lenguaje Dinámico para la VM -

SQLITE "la comunidad SQLITE - LAtino America"

"Fue una experiencia, muy grata tanto para los distantes como para la gente que participo del evento e notado que existe mucha gente que se esa introduciendo lentamente en esto del SL y OpenSource. Los chicos del Grupo Data han logrado su Objetivo, el cual fue la difusión y uso del software libre como herramienta opcional .

En mi charla de Sqlite, comenze a explicar sobre lo que es el proyecto la idea delDR Hipp, Y Comenze a albarle de las ventajas y desventajas . Explieque asimismo el concepto de SeudoMotor y de su funciones dentro de la aplicaciones, Algunas Empresas y Software con Sqlite, casi al final les comente sobre nuestra pequeña comunidad sqlite-latino america.

Me gustaría agradecer a los Organizadores y todas las empresas que han apoyado a que este evento se cumpla, como así también me gustaría mandar un Gran Saludo al Sr. David Casco , quien coordino todo el evento..y fue una de las piezas fundamentales para lograr el éxito..Saludos

Gerardo Antonio Cabero

Sqlite Latino Presente

2008-05-06T18:28:00.000-07:00

Hace algunos meses enviamos nuestro abastrar para estar presentes en Las 2das Jornadas de SL en la localidad de San Francisco provincia de Cordoba , y gracias a Dios nuestra charla a sido seleccionada para este importante evento.

Sqlite en la revista Linux+

2008-05-06T16:32:00.000-07:00

Mucho de este tiempo le hemos dedicado, esfuerzo conjunto, Daniel y Yo. En escribir, una Guia Completa de sqlilte, para la revista linux+ , la mayor revista europea especializada en gnu/linux.

2008-04-26T07:29:00.000-07:00

| View | Upload your own

Introducción a SQLite en Adobe Air

2008-04-09T22:05:00.000-07:00

| View | Upload your own

SQLite y PHP 1

2008-04-01T17:59:00.000-07:00

En la versión 4 de PHP, SQLite se podía utilizar como base de datos instalando un módulo PECL. A partir de la versión 5 de PHP, SQLite está incluido en PHP, por lo que está disponible sin necesidad de realizar ninguna instalación adicional, realmente una ventaja a la hora de programar y se puede observar la gran aceptación de este pseudo motor.
Los nombres de las funciones de PHP que permiten utilizar y manipular SQLite en PHP empiezan por sqlite_ y son similares a los que permiten acceder a otras bases de datos utilizables desde PHP (MySQL, PostgreSQL, etc). El manual de PHP incluye un capítulo dedicado a SQLite, es por ello que nos va a permitir programar mas rápidamente y acostumbrarnos a la sintaxis de una forma casi inmediata.
Creación/Acceso a la base de datos
En SQLite, una base de datos es normalmente un fichero, aunque también pueden abrirse bases de datos en memoria. Este concepto ya lo vimos al principio. Por esta razón necesitamos un mecanismo para poder abrir la base de datos, la función es sqlite_open(). El argumento de sqlite_open() es la ruta del archivo en el servidor (o :memory: en el caso de crear la base de datos en memoria). En caso de que la base de datos no exista, la función se encarga de crear una base de datos nueva. La función devuelve un manejador (handle), que se utiliza en el resto de funciones que acceden a la base de datos. En el siguiente ejemplo, la variable $rutadb almacena la ruta o path de donde se encuentra la base de datos y la variable $db el manejador de la base de datos:
$rutadb = "prueba.db";
$db = sqlite_open($rutadb) or die("No es posible abir la base de datos ");
?>

Historia de Sqlite

2008-04-01T17:38:00.000-07:00

Hace unos dias un grupo de colegas en linea me preguntaron como nace , sqlite , bueno aqui les dejo , una

Breve Historia de SQLite
Cuando D. Richard Hipp trabajaba desarrollando
software para la fuerza naval de los Estados Unidos, comenzó a desarrollar SQLite , según él cuenta con sus propias palabras: SQLite surgió de una necesidad personal, para mi propio uso. En enero de 2000 yo estaba trabajando con un equipo de la General Dynamics en la Fuerza naval de los Estados Unidos, en un proyecto de software, el cual se conectaba a una base de datos Informix, el motor funcionaba muy bien, pero habíamos tenido problemas para hacer una reconfiguración cuando el sistema se reiniciaba. Luego cambiamos a PostgreSQL, pero administrar la base de datos era un problema. Si bien aún estaba luchando para hacer frente a estas cuestiones, surgió la idea de escribir un simple motor de base de datos SQL que permitiera leer los archivos del disco duro, y luego ser llamados en diferentes solicitudes. Cinco meses más tarde, yo estaba sin un contrato por algunos unos meses y por lo que comencé a escribir SQLite, con el pensamiento de que sería útil en algún problema similar, más adelante. (Extracto del Prólogo de SQLite escrito por Richard Hipp).

Hay mas informacion en el Prologo de presentacion en el Sitio oficial.

Richard Hipp en FLOSS

2008-03-13T14:06:00.000-07:00

Hace alguanos dia aparecio este audio comentario de richard hipp en un podcats, el adudio desafortunadamente esta en ingles.. la direccion urls es la siguiente http://www.twit.tv/floss26

Saludos Gerardo Antonio

Adoble se une a la SQLite Consortium

2008-02-28T15:56:00.000-08:00

Adobe se ha unido a Mozilla y a Symbian para soportar el trabajo del SQLite Consortium, que es asegurar el que los desarrolladores de SQLite tienen los recursos ($) suficientes para continuar mejorando esta base de datos tan pequeña como poderosa, flexibile y popular.

Esta decisión coincide oportunamente con el lanzamiento del nuevísimo Adobe Integrated Runtime (AIR), el entorno de ejecución para crear aplicaciones ricas para Internet usando Flash, Flex, HTML y Ajax que también pueden instalarse como aplicaciones para el escritorio, de una manera similar a como también puede hacerlo el Silverlight de Microsoft.

Adobe también usa SQLite en su producto Photoshop Elements desde su versión 6.0 en lugar del Microsoft Access que usaba antes.

Articulo completo The Register

Sqlite Video de Richard Hipp

2008-02-24T17:28:00.000-08:00

Aqui les dejo un video de Richard Hipp el creador de Sqlite, recomiendo que lo vean puesto que explica muchos sobre el funcionamiento interno de sqlite, el unico inconveninete es que tiene subitulos en ingles, desde ya invito a que alguien nos ayude a traducirlo..

Video

Saludos Gerardo Antonio

Sqlite Con Air y Flex

2008-02-07T06:34:00.000-08:00

Hoy navegando en internet me tope con este interesante,un ejemplo de como trabajar con Air y Flex dos tecnologias de Adobe.

Necesitamos Tu Ayuda

2008-02-07T05:37:00.000-08:00

Amigos lectores de Sqlite-Latino , hemos visto que actualmente tenemos muchas visitas de todos los lugares de hablas hispana desde Tierra del Fuego en Argentina , hasta Madrid España Queremos invitarlos a formar parte de la comunidad puesto que actualmente nos econtramos saturardos daniel y yo. Asi mismo tenemos mucha informacion, con de sqlite en ingles y necesitamos que nos ayuden en la traduccion y que se sumen a la movida de sqlite
desde ya muchas gracias
gerardo antonio cabero

SqliteMan

2008-02-03T15:41:00.000-08:00

Es una herramientas, grafica que nos permite Administrar nuestrea base de datos atraves echcas con Sqlite su Instalcion es la siguiente forma:

apt-get install sqliteman

Sqliteman permite Modificar, Actulizar, de una manera rapida.

Documentacion de SqliteMan

Realizar Backup Con Sqlite

2008-01-23T13:51:00.000-08:00

Como venimos esplicando en con sqlite se puden realizar migrar datos, dentre diferente fuentes. en tes caso mostraremos como realizar las copias des segurridad de las tablas de la base de datos usando el comando ".output".>

sqlite> .output backup.sql (Asignamos el nombre del Archivo)

sqlite> .mode insert personal (El modo que trabajaremos sera backup de insercion)

sqlite> .schema personal (Mostraremos el esquema de creacion de la tabla)

sqlite> SELECT * FROM personal ; (selecionamos todos los datos desde la tabla personal)

sqlite> .quit

Y asi optendremos un archivo .sql con todas las entradas listas para ser insertadas nuevamentes y con la estructura de la base de datos.

Como migrar una Base de Datos de Access a SQLite

2008-01-18T18:19:00.001-08:00

A pedido de Guille en donde nos pedia si podíamos ver como migrar de una Base de Datos de Access a SQLite, buscando en internety bueno chequeando la información obtenida les paso a contar como es posible realizar esta acción.

En primer lugar necesitas tener instalado mdbtools, que son un par de herramientas para manipular Bases de Datos de Access. Esto es muy facil de instalar:

$ sudo apt-get install mdbtools

y obviamente descontamos que ya tienes instalado en tu maquina sqlite3.

Para este ejemplo les comento que encontre por ahy un ejemplo de base de dato de Access llamada Empresa.mdb

Ahora veamos como empezar a trabajar, primero vamos a pasar de mdb a sql y lo vamos a llevar a cabo en dos faces, primero por el esquema, donde aparece la definición de los datos y segundo por los datos que contiene nuestra base de datos. Para ello realizamos lo siguiente:

$ mdb-schema Empresa.mdb > esquema.sql

Ahora puedes visualizar el archivo "esquema.sql" y verás como esta la definición de las tablas, los campos, etc.

$ mdb-export -H -I Empresa.mdb Empleados > datos.txt

Lo que hicimos ahora fue migrar el contenido de la tabla "Empleados" al archivo "datos.txt", si se fijan este archivo cuenta con los correspondientes INSERT, VALUES, etc. Pero a todo esto tenemos un pequeño problema cada líne de INSERT no finaliza con un ";" como debería de ser en SQLite, pero esto nuevamente se soluciona muy facilmente:

$ cat datos.txt | sed -e 's/")/");/g' > datos.temp

Ahora bien es el archivo "datos.temp" quien ya fueron formateados los datos para la total migración a SQLite.
Por último nos queda finalizar la migración total a SQLite de la siguiente forma:

$ sqlite3 migracion.db

SQLite version 3.4.2
Enter ".help" for instructions
sqlite> .read esquema.sql
SQL error near line 9: no such table: Empleados
sqlite> .read datos.temp
sqlite> .dump
BEGIN TRANSACTION;
CREATE TABLE Empleados
(
  Clave                   Integer,
  Puesto                  Text (20),
  Nombre                  Text (50),
  Email                   Text (50)
);
INSERT INTO "Empleados" VALUES(1,'Capo','Manuel Caro Quintero','mafia@sinaloa.com');
INSERT INTO "Empleados" VALUES(2,'Comandante','Ventura','PGR@sinaloa.com');
INSERT INTO "Empleados" VALUES(3,'Administrador','Lic. Palma','guero_palma@sinaloa.com');
COMMIT;

vemos como de manera exitosa migramos los datos desde una Base de Datos de Access a SQLite. Para finalizar veamos si realmente contamos con todos los datos y nuevamente revisamos.


sqlite> .tables
Empleados
sqlite> select * from Empleados;
1|Capo|Manuel Caro Quintero|mafia@sinaloa.com
2|Comandante|Ventura|PGR@sinaloa.com
3|Administrador|Lic. Palma|guero_palma@sinaloa.com
sqlite> .quit

Bueno ojalá que le sea útil y como siempre las dudas y preguntas la debatimos entre todos. Muchas Gracias y hasta la proxima...

SQLite Manager

2008-01-15T14:17:00.001-08:00

Es una extension Firefox para minupular bases de datos con SQLite, se ella se puden crear crear tablas e índices, navegar en los archivos ejecutar consultas SQL. y Modificar los registros .
Mas informacion en
http://sqlitemanager.mozdev.org/

Escribiendo datos con Python

2008-01-02T19:09:00.000-08:00

Bueno una ves realizada la conexión como vimos en el primer post de integración entre SQLite y Python, ya estamos dispuestos a crear y guardar datos en nuestra Base de Datos creada. Para hacer esto debemos ejecutar un método de nuestro cursor llamado execute pasándole como parámetro nuestra consulta. En este primer ejemplo vamos a crear un Tabla.

>>>

 cursor.execute('CREATE TABLE personal (id INTEGER PRIMARY KEY, apellido VARCHAR(50), nombre VARCHAR(50), email VARCHAR(100))')

Ahora que ya tenemos creado nuestra tabla podemos comenzar a cargarles información nuevamente convocando el método execute de nuestro objeto cursor.

>>> cursor.execute('INSERT INTO personal VALUES (null, "Ramos", "Juan", "juan_85@gmail.com")')
>>> cursor.execute('INSERT INTO personal VALUES (null, "Juarez", "Martín", "martin58j@gmail.com")')

Estos ejemplos son a modo de visualizar el modo en la cual se pueden almacenar datos en nuestra base de datos, la librería pysqlite nos permite almacenar datos de otra manera utilizando variables que por ejemplo hemos recuperado de algún Form o Widget.

>>> apellido = "Gomes"
>>> nombre = "Carlos"
>>> email = "gcarlos@yahoo.com"

>>> cursor.execute('INSERT INTO personal VALUES (null, ?, ?, ?)', (apellido, nombre, email))

Una ves que terminamos de hacer los cambios debemos almacenar estos datos de manera permanente invocando al método commit del nuestro objeto conexion.

>>> conexion.commit()

Si intentas cerrar una conexión que ha sido modificada sin invocar al metodo commit, pysqlite planteará un error, este comportamiento puede causar problemas, sin embargo si ustedes no desean guardar los cambios que se han efectuado pueden convocar al método rollback de nuestro objeto conexión.

>>> conexion.rollback()

En la siguiente entrega vamos ver diferentes formar de recuperar los datos que almacenamos en nuestra Base de Datos.

FELIZ 2008

2008-01-02T17:56:00.000-08:00

Feliz 2008 les desea SQLite-Latino .
Daniel Maldonado y Gerardo Cabero

ANALYZE

2007-12-27T21:53:00.000-08:00

El comando ANALYZE reúne estadísticas sobre los índices y las almacena en un especial de tablas en la base de datos donde el optimizador de consultas puede utilizar para ayudar a hacer un mejor índice de opciones. Si no se dan argumentos, todos los índices en todas las Bases de Datos adjuntos se analizan. Si un nombre de base de datos se da como argumento, todos los índices en una Base de Datos que se analizan. Si el argumento es un nombre de tabla, entonces sólo los índices asociados a una tabla que se analizan.

Sql-declaración:: = ANALYZE
Sql-declaración:: = ANALYZE nombre de la base de datos
Sql-declaración:: = ANALYZE [nombre de la base de datos.] nombre de la tabla

ALTER TABLE

2007-12-25T11:33:00.000-08:00

En SQLite, la version del comando ALTER TABLE permite al usuario cambiar el nombre o agregar una nueva columna a una Tabla ya existente, no es posible eliminar una columna de una Tabla.

La sintaxis es la siguiente:

Declaracion-sql :: = ALTER TABLE [nombre de la base de datos .] Tabla
Alteración           :: = RENAME TO nuevo nombre de la Tabla
Alteración           :: = ADD [nombre de la columna] descripción

La sintaxis RENAME TO se usa para cambiar el nombre de la Tabla escogida por un nuevo nombre que le queramos asignar. Con este comando no se puede mover una Tabla entre las Bases de Datos adjuntas, sólo para cambiar el nombre de una Tabla dentro de la misma Base de Datos.

El comando ADD [nombre de la columna] se utiliza para gregar una nueva columna o atributo a la Tabla existente. Esta nueva columna es agregada siempre al final de la lista como último atributo.

El tiempo de ejecución del comando ALTER TABLE es independiente de la cantidad de datos en la Tabla. El comando ALTER TABLE se ejecuta con la mayor rapidez sobre una Tabla con 10 millones de filas como lo hace sobre una Tabla con 1 sola fila.

Ejemplo propuesto:

Para este ejemplo vamos a suponer que contamos con una Base de Datos ya creada en la cual además hemos creados otras tablas, ingresamos a la base de datos he intentemos cambiar el nombre y agregar una columna a algunas de sus tablas.

En mi caso les muestro las tablas que tengo ejecutando:

sqlite> .tables
personal
sqlite>

y ahora les muestro cual es su esquema:

sqlite> .schema personal
CREATE TABLE 'personal' (
id smallint primary key,
apellido varchar(100),
nombre varchar(100),
direccion varchar(200)
);
sqlite>

bueno ahora intentemos cambiarle el nombre:

sqlite> ALTER TABLE personal
  ...> RENAME TO personales;
sqlite>

ahora con el nuevo nombre de la Tabla, agreguemos una columna:

sqlite> ALTER TABLE personales
  ...> ADD telefono varchar(15);
sqlite>

Entonces de esta manera tan simple pudimos no solamente modificar el nombre de la tabla si no que además agregarle un campo a la misma.

De SQL a SQLite

2007-12-25T10:40:00.000-08:00

SQLite entiende la mayor parte de la lengua estándar SQL. Lo que pasa es que se omitan algunas características, al mismo tiempo, añadiendo algunas características de su propia.

Lo que vamos a ver a partir de ahora es intenta describir con precisión qué partes del lenguaje SQL son similares a SQLite y cuáles no. Una lista de palabras clave también es proporcionada.

Es por ello que para comenzar a ver estas sintaxis vamos a listar muchas de las palabras claves y comando que vamos a utilizar y de ese modo vamos a particularizarlos a cada uno.

SQLite implementa las siguientes sintaxis:

ALTER TABLE
ANALIYZE
ATTACH DATABASE

Gracias a TuxInfo!!!!

2007-12-20T16:06:00.000-08:00

Les comentamos que en el día de la fecha la gente de la revista digital TuxInfo, nos realizó una antrevista comentando y apoyando esta comunidad de SQLite Latino. Una entrevista en donde tratamos de presentarles e informarles hacerca de este proyecto y la manera en la cual pueden colaborar.

En primer lugar queríamos agradecerles a Franco quien fue el que realizo la entrevista muy amablemente y como una propuesta de él.

Tambíen queremos agradecer a la gente que trabaja en TuxInfo y en especial a Ariel director de la misma por el apoyo constante al Movimiento del Software Libre.

Y por último los invitamos a que vean no solamente la nota sino también que disfruten y se informen con esta revista mensual.

Uso No apropiado con Alto Concurrencia

2007-12-10T18:39:00.000-08:00

SQLite utilizando lector/escritor esclusas de la totalidad del archivo de las Base de Datos. Esto significa que si cualquier proceso es la lectura de cualquier parte de la base de datos, todos los demás procesos se impide a la escritura de cualquier otra parte de la base de datos.

Del mismo modo, si un proceso es cualquier escrito a la base de datos, todos los demás procesos se impide que la lectura de cualquier otra parte de la base de datos. Cada aplicación de Base de Datos hace su trabajo y pasa rápidamente, y no de bloqueo dura más de algunas decenas de milisegundos.

Sin embargo, hay algunas aplicaciones que requieren una mayor concurrencia, y las aplicaciones pueden necesidad de buscar una solución diferente.

Uso No apropiado con Datos muy Grandes

2007-12-10T18:31:00.000-08:00

Cuando se inicia una operación de SQLite (lo que sucede automáticamente antes de cualquier operación de escritura que no está dentro de una explícita BEGIN ... COMMIT) el motor tiene que asignar un mapa de bits de páginas sucias en el archivo de disco para ayudarle a manejar su revertir la revista. SQLite necesidades de 256 bytes de RAM para cada 1MiB de base de datos (asumiendo un 1024 bytes tamaño de página: menos memoria se utiliza con mayor tamaño de la página, por supuesto).

Para bases de datos más pequeñas, la cantidad de memoria necesaria no es un problema, pero cuando la base de datos comenzó a desarrollarse en el multi-gigabyte gama, el tamaño del mapa de bits puede conseguir bastante grande. Si tiene que almacenar y modificar más de algunas decenas de GB de datos, usted debería considerar la posibilidad de utilizar otro Motor de Base de Datos.

Uso No apropiado en Sitios web de Alto Volúmen

2007-12-07T06:29:00.000-08:00

SQLite normalmente funciona bien como el de Base de Datos a un sitio web. Pero si este Sitio Web es tan ocupados que están pensando en su división de componentes fuera de la Base de Datos en una máquina separada, entonces usted debería considerar el uso de un Motor de Base de Datos de tipo cliente/servidor en lugar del Motor de Base de Datos de SQLite.

Usos no Apropiados para usar SQLite - Aplicaciones Cliente/Servidor

2007-12-05T19:59:00.000-08:00

Seguramente si tienes muchos programas clientes que acceden a una Base de Datos común en una Red, usted debería considerar el uso de un Motor de Base de Datos Cliente/Servidor en lugar de SQLite.

SQLite trabajará a través de una red de archivos, pero debido a la latencia asociado con la mayoría de sistemas de archivos de red, el rendimiento no será grande. Asimismo, el bloqueo de archivos lógica de muchos sistemas de ficheros de red contiene errores de aplicación (en ambos Unix y ventanas). Si el bloqueo de ficheros no funciona como debería, podría ser posible que dos o más programas cliente para modificar la misma parte de la misma base de datos al mismo tiempo, la corrupción en la base de datos resultante. Debido a que este problema se debe a fallos en el sistema de ficheros subyacente aplicación, no hay nada SQLite puede hacer para evitarlo.

Una buena regla general es que usted debe evitar el uso de SQLite en situaciones en las que la misma Base de Datos será accesible al mismo tiempo de muchas computadoras a través de una red de archivos.

Java y SQLite - Parte I

2007-12-04T07:22:00.000-08:00

Desde hace mucho tiempo -Varias Lunas- en sqlite-latino, de la mano de daniel se viene realizado la entrega teórica de sqlite, por trabajar con el , ventaja , desventajas, ect. y Las reviws correspondientes del mismo, como hacer un uso eficiente del mismo atraves del conocimiento de sus sintaxis, esto se realizo con el siguiente motivo , para poder dar el enfoque teórico.
Pero desde hace unos días se comenzó con la aplicación de sqlite, en los diferente lenguajes. Ahora es el turno de Java.
Java hace uso de las librerías JDBC para poder realizar la comunicación con la DB. desde hace tiempo están disponibles SqliteJDBC.
En el site SQLiteJDBC (http://www.zentus.com/sqlitejdbc/) podemos encontrar wrappers de SQLite para Java en las plataformas Linux, Max OS, y windows .
Imaginemos la siguiente aplicación "Digamos que se desea crear una lista de todo nuestro amigos y sus fechas de cumpleaños con su correo y sus teléfonos"
Muy Sencillo el problema pero imaginemos como seria la estructura de la base de datos
Para llevar a cabo este ejemplo -Un par de Entregas- necesitaremos realizar una simple conexión, con java, esto se realiza por medio de una clase la cual lameremos "Coneccion" y su Estructura es esta

package pruebaBD; import org.sqlite.*; import java.sql.Connection; import java.sql.Statement;

public class Coneccion { private Connection varConeccion; private Statement varSentencia; public Coneccion(String nombreDB) throws ClassNotFoundException, SQLException{ Class.forName("org.sqlite.JDBC"); this.varConeccion = DriverManager.getConnection("jdbc:sqlite:" + nombreDB); this.varSentencia = this.varConeccion.createStatement(); } }

En Detalle
Class.forName("org.sqlite.JDBC"); : Se indica el nombre de conector que se utilizará.
this.varConeccion = DriverManager.getConnection("jdbc:sqlite:" + nombreDB); : Aquí se indica el driver con que trabajaremos: sqlite y el nombre de la Base de Datos "nombreDB" -En el Ejemplo Lo trafiero por parametro -
this.varSentencia = this.varConeccion.createStatement(); : Abre un canal para realizar las sentencias.
hasta aqui solo hemos creado la clase que realiza la conexión. con Sqlite, en los próximas entregas de realizaremos el resto de las clases.
Link
http://www.pysquared.com/files/Java/JavaSQLiteExample/ http://www.zentus.com/sqlitejdbc/

Configurando Eclipse y SQLite

2007-12-04T06:51:00.000-08:00

Hace algunos dias, recibí un mail donde me preguntaban

"Como configuro eclipse , para trabajar con Sqlite y Java"

Muchos nos hemos complicado alguna ves con la inclusión de los .jar , es muy simple, siguiendo estos pasos se debe de descargar el archivo jdbc desde el sito de SqliteJDBC - (http://www.zentus.com/sqlitejdbc/) -
Una ves obtenido lo descomprimimos , y copiamos el .jar en el nuestro workspace el .jar y luego realizamos clic sobre el .jar y botón derecho y nos vamos a la opción donde dice add build -> Seleccionamos la opcion Add build path.

Si queremos podemos realizarlo de otra manera también seria correcta ir a menú Proyect -> Propiedades -> y luego a la pestaña donde dice -> Add external Jar y de allí seleccionamos el lugar donde se encuentra el .jar , aceptamos y lo tendremos instalado listo par usar.

Nota:
Se deben de copiar también los archivos .so para Linux y .dll para Window$

Python - SQLite

2007-12-01T20:22:00.000-08:00

Bueno, ahora llego el momento de comenzar a ver la parte práctica de SQLite, dijimos en todo este tiempo que las Bases de Datos es compatible con muchos Lenguajes de Programación, en esta oportunidad vamos a ver la integración de SQLite con Python, para aquellos que no están al tanto, Python es un Lenguaje de Programación interpretado creado por Guido van Rossum, en los sistemas GNU/Linux es muy popular, tienen como principal característica que es totalmente orientado a objetos, fácil de aprender y muy potente.

Bueno para poder llevar a cabo la integración necesitamos que en Python tengamos instalado unas librerías que nos va a servir como interface para conectar las Bases de Datos SQLite. Para ello hacemos lo siguiente:

$ sudo apt-get install python-pysqlite2

Con esto ya contamos con estas librerías y podemos realizar la conexión fácilmente.
Para continuar y realizar nuestro primer ejemplo sencillo de esta integración, les recomendamos que vean las Review I y Review II de SQLite y creen una Base de Datos con aunquesea una tabla, a modo de ejemplo.

Vamos a suponer dos cosas: Que la Base de datos o el archivo lo llamamos "prueba.db" y que como les decia a modo de prueba creamos una tabla llamada "personal".

Ahora bien creamos un archivo en python con nuestro editor preferido y lo llamamos "prueba01.py"


# Importa librerias de SQLite
from pysqlite2 import dbapi2 as sqlite

# Realiza la coneccion con la db colocando el Path
# donde se encuentra el archivo de la Base de datos
coneccion = sqlite.connect('prueba.db')

# Crea un objeto cursor para trabajar
cursor = coneccion.cursor()

# Ejecuta la consulta SELECT, tal y como lo haríamos en SQL
cursor.execute('SELECT apellido, nombre FROM personal order by id')

# Muestra todos los datos de la consulta
for (apellido, nombre) in cursor:
    print 'Apeliido y Nombre: %s, %s.' % (apellido, nombre)

Ahora bien una ves almacenado el archivo "prueba01.py" vamos a preceder a ejecutarlo convocando al interprete de la siguiente manera:

$ python2.4 prueba01.py

Bueno, más adelante vamos a continuar con mas ejemplos de aplicación, por el momento con este magnifico Lenguaje de Programación llamado Python.

Base de datos de Pedagogía o Enseñanza

2007-12-01T06:30:00.000-08:00

Porque es fácil de configurar y usar (la instalación es trivial: tan sólo la copia, SQLite o sqlite.exe ejecutable a la máquina de destino y ejecutarlo) SQLite hace un buen Motor de Base de Datos para su utilización en la enseñanza de SQL.

Los estudiantes o aquellas personas que están aprendiendo pueden fácilmente crear tantas Bases de Datos como a ellos les gusta y puede enviarse entre ellos un correo electrónico a las Bases de Datos de instructores para la presentación de observaciones o de clasificación y de eso modo compartirlas de manera muy fácil.

Para los estudiantes más avanzados que están interesados en el estudio de cómo un RDBMS se ejecuta, el modular y bien comentado y documentado SQLite código puede servir como una buena base. Esto no quiere decir que SQLite es un modelo exacto de la forma en que otros motores de bases de datos se apliquen, sino más bien a un estudiante que entiende cómo funciona SQLite pueden comprender más rápidamente los principios operativos de otros sistemas.

Base de Datos durante las pruebas o demostraciones en empresas

2007-12-01T06:23:00.001-08:00

Si está escribiendo una aplicación cliente para el motor de Base de Datos de una empresa, tiene sentido utilizar un genérico de Base de Datos que le permite conectarse a muchos tipos distintos de los Motores de Base de Datos SQL.

Es aún mejor de seguir adelante implementándolo y SQLite incluir en la mezcla de base de datos y el apoyo a linkar o enlazar en el motor SQLite con el cliente. De esa forma, el programa cliente puede ser usado con un archivo de datos SQLite para probar o para manifestaciones.

Bases de Datos Internas o Temporales

2007-11-29T21:44:00.000-08:00

Para los programas que tienen un gran volumen de datos que debe ser ordenado de diversas maneras, a menudo es más fácil y más rápida de cargar los datos en una memoria en la base de datos SQLite y el uso y se une a las preguntas con cláusulas ORDER BY para extraer los datos de la Forma y el orden en lugar de tratar de código de las mismas operaciones manualmente.

El uso de una base de datos SQL internos de esta manera el programa también ofrece una mayor flexibilidad ya que las nuevas columnas (atributos) y los índices pueden ser añadidos sin tener que reprogramar cada consulta.

Sitios Web

2007-11-28T07:25:00.000-08:00

SQLite normalmente trabajará como el gran motor de base de datos de baja y media del tráfico en Internet (es decir, el 99,9% de todos los sitios Web). La cantidad de tráfico web que SQLite puede manejar depende, por supuesto, sobre la forma en el sitio web utiliza en gran medida su base de datos. En general, cualquier sitio que recibe menos de 100.000 visitas / día debe funcionar bien con SQLite. El 100.000 visitas / día cifra es una estimación conservadora, y no de un duro límite superior. SQLite se ha demostrado que trabajar con 10 veces la cantidad de tráfico.

Aplicaciones y Dispositivos Embebidos

2007-11-26T09:22:00.000-08:00

Porque una base de datos SQLite requiere poco o prácticamente nada de la administración, SQLite es una excelente opción para los dispositivos o servicios que deben trabajar sin vigilancia o sin apoyo humano. SQLite es una buena elección para su uso en teléfonos móviles, PDAs, set-top boxes, y / o electrodomésticos. También funciona bien como una Base de Datos incorporados en descargar aplicaciones de consumo.

Aplicación en Formato de Archivo

2007-11-25T20:07:00.000-08:00

Nuevamente mostrando casos de éxitos de SQLite en las cuales cómodamente podría ser reemplazo de los grande Motores de Bases de Datos, tenemos las aplicaciones en formato de archivo.

Este es el caso de las aplicaciones de escritorio que normalmente lo utilizamos para desempeñar una tarea específica, como herramienta de Análisis Financiero, los paquetes de CAD, programas de mantenimientos de registros, etc.

Las tradicionales operación como Archivo/Abrir se realizaría con sqlite3_open(), posteriormente se ejecuta un BEGIN TRANSACTION para obtener un acceso exclusivo al contenido. en la operación Archivo/Guardar se hace con un COMMIT seguido por otro BEGIN TRANSACTIO. Es importante considerar el uso de las transacciones ya que garantiza que las actualizaciones de las aplicaciones sean atómicas, aisladas y por sobre todas las cosas coherentes.

Seguramente más adelante vamos a mostrar mas características de casos exitosos y de las cuales vas a poder sacar tus conclusiones a la hora de pensar en migrar esas aplicaciones con otros motores de base de datos a SQLite.

Los usos apropiados de SQLite

2007-11-24T05:58:00.000-08:00

Quizás este tema lo hablamos pero muy por arriba y ahora llego la oportunidad para explicar mejor las prestaciones de SQLite para los usuarios.

Como ya sabemos SQLite es diferente a la mayoría de los otros motores de Base de Datos SQL en donde ya conocemos estos objetivos:

Simple de Administrar.
Simple para Operar.
Simple para fusionarlo con aplicaciones más amplias.
Fácil de mantener y personalizar.

Las personas que utilicen SQLite encontrarán en él un Pseudo Motor pequeño y rápido, y también van a encontrar que SQLite es muy confiable. La fiabilidad es una consecuencia de la simplicidad. Si bien posee estas características SQLite desde sus inicios se esfuerza por ser por sobre todas las cosas S I M P L E.

La simplicidad de este Pseudo Motor puede ser como ya sabemos una Fortaleza o una debilidad, en función de que es lo que el usuario desea hacer con el mismo. Con el afán de lograr la máxima simplicidad tubo que sacrificar otros aspectos que algunos usuarios los notan útiles, como la alta concurrencia, un rico y amplio conjunto de funciones incorporadas, procedimientos almacenados, etc. Si necesitas algunas de estas características y no cuenta con la complejidad añadida que traen, entonces SQLite NO es probablemente el Motor de Base de Datos. La intención de SQLite no es la de ser una empresa de Motores de Bases de Datos y competir con Oracle o PostgreSQL.

La regla de oro para saber cuando es apropiado utilizar SQLite es la siguiente:

El uso de SQLite en situaciones en la que la sencillez de la administración, implementación y mantenimientos son más importantes que las innumerables características complejas que las empresa proporcionará a los Motores de Bases de Datos.

En la práctica, las situaciones en que la simplicidad es la mejor opción, son más comunes de las que muchos creen.

Review de SQLite - Parte II

2007-11-22T09:10:00.000-08:00

Aprendamos algunos comandos especiales para movernos sobre SQLite

La mayoría de las veces SQLite lee las lineas de entrada y los transforma al de la libreria SQLite para luego ejecutarlas. Si una línea de entrada empieza con un Punto (".") es interpretado inmediatamente por el intérprete de SQLite, estos puntos se utiliza normalmente para cambiar el formato de salidas de las consulta, la cual veremos más adelante

Para obtener una lista de los comandos disponibles, podemos tipear en cualquier momento ".help" y nos arrojaría la siguiente lista:

sqlite> .help

.bail ONOFF Stop after hitting an error. Default OFF
.databases List names and files of attached databases
.dump ?TABLE? ... Dump the database in an SQL text format
.echo ONOFF Turn command echo on or off
.exit Exit this program
.explain ONOFF Turn output mode suitable for EXPLAIN on or off.
.header(s) ONOFF Turn display of headers on or off
.help Show this message
.import FILE TABLE Import data from FILE into TABLE
.indices TABLE Show names of all indices on TABLE
.load FILE ?ENTRY? Load an extension library
.mode MODE ?TABLE? Set output mode where MODE is one of:
csv Comma-separated values
column Left-aligned columns. (See .width)
html HTML code
insert SQL insert statements for TABLE
line One value per line
list Values delimited by .separator string
tabs Tab-separated values
tcl TCL list elements
.nullvalue STRING Print STRING in place of NULL values
.output FILENAME Send output to FILENAME
.output stdout Send output to the screen
.prompt MAIN CONTINUE Replace the standard prompts
.quit Exit this program
.read FILENAME Execute SQL in FILENAME
.schema ?TABLE? Show the CREATE statements
.separator STRING Change separator used by output mode and .import
.show Show the current values for various settings
.tables ?PATTERN? List names of tables matching a LIKE pattern
.timeout MS Try opening locked tables for MS milliseconds
.width NUM NUM ... Set column widths for "column" mode
sqlite>

Realicemos una introducción para poder manipulas las salidas o configurarla, además cabe destacar que SQLite3 es capaz de mostrar los resultados de una consulta en ocho diferentes formatos: "csv", "column", "html", "insert", "line", "tabs", and "tcl". Podes usar en .mode para lograr estas diferentes salidas.

Bueno, comencemos con la modalidad por defecto en la cual SQLite nos muestra los datos tras una consulta realizada previamente, esta consulta estandart es separada por este símbolo (""), este ejemplo que vamos a realizar tomamos como base la Review I.

Para acceder a la base de datos creada anteriormente

$ sqlite3 prueba.db

Una ves dentro de la misma podemos realizar:


sqlite> .mode list
sqlite> select * from personal;
1DanyxMaldoandoYYYXXXZZZ
2LaRepaWebZZZXXXYYY
sqlite>

Ahora bien si utilizas ".separator" va a cambiar el modo de separación de la consulta, por ejemplo lo vamos a hacer cambiar por una coma y un espacio ", "


sqlite> .separator ", "
sqlite> select * from personal;
1, Danyx, Maldoando, YYYXXXZZZ
2, LaRepa, Web, ZZZXXXYYY
sqlite>

Bueno por el momento lo vamos a dejar ahy, de este modo vamos captando la estructura de SQLite3, como decimos un PseudoMotor muy potente y liviano. Será hasta la próxima y muchas gracias por acompañarnos.
Autor: Maldonado Daniel Martin (LaRepaWeb)

SQLite - Extensiones del Lenguaje SQL

2007-11-18T20:44:00.000-08:00

SQLite proporciona una serie de mejoras en el lenguaje SQL, que no se encuentran normalmente en otros Motores de Bases de Datos, sean comerciales o no. SQLite provee declaraciones como REPLACE y ON CONFLICT, clausulas que permiten añadir para el control de la limitación de resolución de conflicto.

SQLite soporta ATTACH y DETACH, que son comando que permiten a múltiple Bases de Datos independientes sean utilizadas en una misma consulta. Por último SQLite define las API que permite al usuario añadir nuevas funciones SQL y el cotejo de las secuencia

SQLite - De dominio PÚBLICO

2007-11-15T20:42:00.000-08:00

Sencillamente el código fuente de SQLite es de dominio público.Ninguna reivindicación se hace de los derechos de autor se hace en cualquier parte del núcleo del código fuente. Todos los contribuyentes que participaron de SQLite, han firmado una declaración jurada específicamente que desmiente cualquier interés de derecho de autor en el código. Esto significa que nadie es capaz de hacer lo que quiera con el código fuente de SQLite.

Existe otros motores de Bases de Datos basados en SQL liberados de licencias que permiten al código ser ampliamente utilizados y libremente. Pero estos motores se siguen rigiendo por la ley de derechos de autor. SQLite es diferente ya que en el derecho de autor la ley simplemente no se aplica.

Los archivos de código fuente para los otros motores de Bases de Datos SQL, generalmente comienzan con un comentario que describe su licencia de derechos para leer y copiar el archivo en cuestión. En SQLite el código fuente no contiene ninguna licencia ya que como decíamos no se rige por el derecho de autor.

En lugar de una licencia el código fuente de SQLite ofrece una bendición:
Hacer el bien y NO el mal.
Se puede encontrar el perdón para ti y perdonar a los demás.
Se puede compartir libremente, no teniendo más de lo que dan.

Review de SQLite - Parte I

2007-11-14T16:50:00.000-08:00

Vamos a comenzar a hacer un HOWTO acerca de SQLite, gracias a un amigo Gerardo Cabero y las influencias de mucha gente involucrada en todo este tema.

Entendamos algunos conceptos antes de comenzar:
SQLite es un sistema de gestión de bases de datos relacional compatible con ACID, y que está contenida en una relativamente pequeña librería en C. SQLite es un proyecto de dominio público creado por D. Richard Hipp.

Rapidamente instalemos nuestro PseudoMotor SQLite en su version 3 (apodado de esa forma por Gerardo), en un sistema GNU/Linyx utilizando alguna Kosole o Terminal

$ sudo apt-get install sqlite3

una ves instalado hagamos algunas pruebas, nos dirijamos hacia algún directorio y ahora a crear una Base de Datos

$ sqlite3 prueba.db
SQLite version 3.3.10
Enter ".help" for instructions
sqlite> CREATE TABLE personal (
...> id smallint primary key,
...> nombre varchar(25),
...> apellido varchar(25),
...> direccion varchar(25)
...> );
sqlite>

Ahora insertemos algunos datos de la siguiente manera:

sqlite> insert into personal values(1, 'Danyx', 'Maldonado', 'YYYXXXZZZ');
sqlite> insert into personal values(2, 'LaRepa', 'Web', 'ZZZXXXYYY');

Hagamos nuestra primera consulta sobre la tabla "personal"

sqlite> select * from personal;
1DanyxMaldoandoYYYXXXZZZ
2LaRepaWebZZZXXXYYY
sqlite>

para poder salir de la edición por consola

sqlite> .quit

Más adelante voy a estar mostrando algunas opciones que nos brinda SQLite y el manejo de este PseudoMotor formatear salidas, exportar, etc.

Este fragmento lo Obtubimos desde del Sitio: LaRepaWeb - Gracias Daniel Maldonado y Luis -

SQLite - Sentencias SQL Compiladas en la Máquina Virtual

2007-11-13T18:14:00.000-08:00

Cada Motor de Base de datos SQL compila cada sentencia SQL en algún tipo de estructura de datos interna que luego se utilizará para llevar a cabo la labor de la declaración. Pero en la mayoría de los Motores SQL interno que la estructura de los datos es una compleja red de estructuras y objetos relacionados entre sí. En SQLite, compilar la forma de las declaraciones es de un breve programa en un lenguaje de máquina como representación. Los usuarios de la base de datos puede ver esta Máquina Virtual de lenguaje por EXPLAIN ante poniéndole esta palabra clave para una consulta. Más adelante veremos estos ejemplos.

El uso de una Máquina Virtual en SQLite ha sido un gran beneficio para el desarrollo de la biblioteca. La Máquina Virtual proporciona una crujiente, bien definido el cruce entre la interfaz de usuario de SQLite (en la parte que analiza las sentencias SQL y genera el código máquina virtual) y la parte de atrás de final (la parte que ejecuta la máquina virtual de código y calcula un resultado. ) La máquina virtual permite a los desarrolladores para ver claramente y en una forma de fácil lectura SQLite es lo que intentamos hacer con cada declaración compila, que es una gran ayuda en la depuración.

Dependiendo de la forma en que se compila, SQLite también tiene la capacidad de rastreo de la ejecución de la máquina virtual de impresión de cada máquina virtual de instrucción y su resultado, ya que se ejecuta.

SQLite - De código Legible

2007-11-09T19:10:00.000-08:00

El código fuente de SQLite estás diseñado y codificado para ser legible y accesible hasta para un programador medio. Todos sus procedimientos, estructuras de datos y variables están cuidadosamente comentadas con información útil e integral para que de esa forma se pueda comprender su estructura y el significado de cada una de las partes de la aplicación.

Elegí tu Banner y ayudanos a difundir la Comunidad SQLite-Latino

2007-11-08T18:06:00.000-08:00

SQLite - Registros de Longitud Variable

2007-11-07T20:09:00.000-08:00

La mayoría de los motores de Bases de Datos SQL, asignan una cantidad fija de espacio en disco para cada fila en la mayoría de los Campos de una determinada Tabla. Tomemos un clásico ejemplo para entender este concepto sencillo, tomemos un Campo de tipo VARCHAR(100), esto significa que el motor de Base de Datos asignará 100 Bytes de espacio en disco fijo, independientemente de la cantidad de de información que se almacene en ese Campo.

SQLite por el contrario, utiliza únicamente la cantidad de espacio de disco necesario para almacenar realmente la información en ese Campo. Tomando el ejemplo anterior, si quisiera almacenar un solo caracter en un Campo definido como VARCHAR(100), entonces solo un único byte de espacio de disco se consume, realmente una característica especial para ahorrar espacios en memorias.

El uso de registros de Longitud Variable por SQLite, tiene una serie de ventajas, entre ellas el resultado de un pequeño archivo de Base de Datos. También hace que la Base de Datos funcione más rápidamente, debido a que hay menos información desperdiciada que leer y recorrer.

SQLite - Tipado Dinámico

2007-11-06T19:08:00.000-08:00

La mayoría de los Motores de Bases de Datos SQL utilizan un tipado estático de datos. ¿Qué significa esto? Un dato se asocia con cada columna de una tabla de valores y solo ese tipo de dato se permite almacenar en esa columna. SQLite, por el contrario rompe con este pensamiento, imponiendo el concepto del Tipado Dinámico, diciendo que el dato es un valor de la propiedad en sí, no de la columna en la que se va a almacenar el valor.

Por lo tanto SQLite permite al usuario almacenar cualquier valor de cualquier dato en cualquier columna, independientemente de la declaración del tipo de la columna.

El uso de este nuevo concepto fue una deliberada decisión de diseño que ha demostrado en la práctica ser más fiable y más fácil de usar, especialmente cuando se utilizan en combinación con lenguajes de programación como Python, Ruby, Tcl entre otros que implementan esta características desde sus inicios.

MiniFAQ - Dudas y Preguntas sobre SQLite

2007-11-04T18:45:00.000-08:00

¿Que es SQLite?

SQLIte es una nueva generacion de Motores de Base Datos llamados ,
Seudo-Motores . 0 Configuracion , Mas Rapido Usar- Vease SeudoMotores -

¿Que tipo de Licencia tiene SQLite?
Dominio Publico - Permite usarlos en productos comeciales y no comerciales -

¿Que tipo de aplicacion esta Orientado SQLite - Alta, Mediana , Baja?
SQLite esta destinado a cualquir tipo de aplicacion, medianas o Semi Complejas ej aplicacioes desktop ,bibliotecas,padrones ,respaldo de datos, web site.

¿Que tamaño max puede tener una Base de datos con SQLite?
2 Tb - TeraBytes-

¿Que tamaño max puede tener una tabla de datos con SQLite?
1 Gb. -GigaByte -

¿SQLite soporta multiUsuarios?
Puden haber varios , usuarios accediendo simultaneamente a la DB pero solo uno podra escribir en un instante de tiempo ,posee un sistema um lock , el cual nos dira si se encuntra ocupado atraves del mensaje SQLITE_BUSY

¿SQLite Vs Oracles, Posgrest , MySql , FireBird?
Podemos sitar e algunas de sus ventajas,
NO tener que esta instalado un servidor de base datos,
NO existe una arquitectura cliente/servidor
Insersiones , Modificaciones, Eliminacion 8 veces mas Rapidas
Facil de Usar

¿Desventaja de SQLite?
No Poser Itegridad referecial -No portada Aun -
Pocas comunidades de usarios

¿SQLite Soporta datos tipo BLOB?
Desde la version 3, podemos asigar este tipo de datos.
Para los que no estan muy familiarizados con el tema los BLOB (Binary Large OBjects, grandes objetos binarios), son elementos utilizados en las Bases de Datos para almacenar datos de gran tamaño que cambian de forma dinámica.

¿SQLite esta escrito en ?
Esta escrito en el Lenguaje de Programación C++

¿SQLite con que Lenjuage puedo utilizarlo?
Podemos hace uso de estos lenguajes:
Java, Groovy,Python, C++, Ruby, Tcl,etc

Cuando usar SQLite

2007-11-04T18:38:00.000-08:00

Situaciones donde SQLite Funciona Bien

Mayoria de los Web Site (menos de 100 mil visitas diarias).
Subtituto de archivos de uso especifico.
Base de datos Internas o Temporarias.
Aplicaciones Locales.
Subtituto de base de Datos de gran porte en pruebas, demostraciones y prototipos.
Formato para archivos de programas.
Dispositivos y programas enbebidos.
Base datos de Respaldo o Backup.

Donde SQLite No rinde un 100 %

Aplicaciones Cliente/Servidor.
Mayoria de los Web Site (mas de 1 millon visitas diarias).
Aplicacione de alto concurrencia.

SQLite - Compacto

2007-11-04T12:14:00.000-08:00

Cuando se pensó en optimizar el código SQLite en cuanto a su tamaño, toda la librería funcional es menor de 225 KiB (medido en una ix86 utilizando el tamaño de utilidad del compilador GNU), de este modo es posible desactivar en tiempo de compilación numerosas características innecesarias para poder reducir aún más el tamaño de la biblioteca llegando mas o menos a 170 KiB

La mayoría de otros motores de Bases de Datos SQL, son muchísimos mas grandes que este. Inclusos motores de Bases de Datos sin todas las características y las funcionalidades e inclusives comprimidos son el doble de pesados que SQLite.

SQLite - Único archivo de Base de Datos

2007-11-01T21:33:00.000-07:00

Una Base de Datos SQLite es un único archivo de disco ordinario y que además puede estar situado en cualquier parte del directorio dentro de las jerarquías de directorios. Esto trae como ventaja que el archivo de Base de Datos puede ser fácilmente copiado en algún dispositivo de memoria por ejemplo en USB o por correo electrónico.

Otros motores de Bases de Datos tienden por lo general a almacenar gran cantidad o colección de archivos, que solo el motor de la Base de Datos puede llegar a tener acceso a las mismas, esto hace que los datos sean más seguro y más difíciles de acceder.

Algunos motores de Base de Datos SQL proporciona la opción de escribir directamente en el disco y pasar por el sistema de ficheros todos juntos. Esto aporta una mayor rendimiento, pero a costa de una considerable complejidad de instalación y mantenimiento.

Presentacion de SQLITE

2007-11-01T17:28:00.000-07:00

Aqui una trasparencia de sqlite...

SQLite - Serverless

2007-11-01T11:49:00.000-07:00

La mayoría de los motores de base de datos SQL se ejecutan como un proceso separado del servidor. Los programas que quieren acceder a la base de datos para comunicarse con el servidor mediante el uso de algún tipo de comunicación (normalmente TCP/IP) para enviar peticiones al servidor y recibir de vuelta los resultados. Entendido esto podemos decir que SQLite no trabaja de esa manera. Con SQLite, el proceso que quiere acceder a la base de datos lee y escribe directamente de los archivos de base de datos en el disco. No existe un intermediario proceso servidor.

Existe muchas ventajas y desventajas con respecto a los servidores, La principal ventaja es que no existe ningún proceso de instalación de servidor, como así también su configuración, inicialización, etc. Por ello es una de las razones por la cuanl SQLite - Configuración [0]. Cualquier programa que sea capaz de acceder al disco se puede utilizar una base de datos SQLite.

Por otro lado, un motor de base de datos que utiliza un servidor puede proporcionar una mejor protección frente a fallos en la aplicación del cliente - se dirige a los punteros en un cliente no puede corromper la memoria en el servidor.

La mayoría de los motores de base de datos SQL son cliente/servidor. De los que son servidores, SQLite es el único que sabe de este autor que permite que múltiples aplicaciones puedan acceder a la misma base de datos al mismo tiempo.

SQLite - Configuración [0]

2007-10-31T12:51:00.000-07:00

Bienvenidos a esta sección de la nueva comunidad SQLite-Latino, Características de este PseudoMotor llamado SQLite.

Comencemos a ver algunas cosas interesantes que a través del tiempo nos vamos a enganchar todos.

Como leyeron en el titulo SQLite Configuración 0 y ahora les explico por es esto: SQLite NO necesita ser "instalado", tampoco tenemos la necesidad de prender, reiniciar o apagar algún servidor e incluso configurarlo.

Otro dato importante, no está la necesidad de que haya algún Adminisitrador de la Base de Datos para crearlas o para asignar o dar permisos de acceso a los usuarios.

No es necesario adoptar medidas para recuperar después de una caída del sistema o la falta de alimentación.

Toda esta información la extraje de aqui

Que es SQLITE

2007-09-03T07:41:00.000-07:00

Segun D. Richard Hipp, Sqlite son librerias escritas en C que implementa un motor de base de datos para SQL92 empotrable.Segun Wikipedia lo define de la misma forma, Pero Segun Quien escribe este blogspot, Sqlite permite dar otro tipo de enfoque a las base de datos , y dejar de ser Libreria para convertirse en PseudoMotor - Aparenta ser un motor pero no lo es -
Luego Subire una trasnsparencias de Sqlite..
Saludos Gerardo antonio

2007-08-28T09:43:00.000-07:00

Bienvenidos a SQLITE LATINO AMERICA EL MEJOR primer SeudoMotor de Base de Datos en el mundo..
Saludos Gerardo Antonio Cabero