El documento habla sobre las bases de datos SQLite para dispositivos móviles. SQLite es una librería de código abierto que permite almacenar y acceder a datos de forma sencilla en dispositivos móviles y de escritorio. Ofrece funcionalidades como creación de tablas, vistas, inserción de datos, y permite realizar consultas SQL de manera portable entre plataformas.

1. R I V A S M A L D O N A D O G E R A L D I N E 1 1 3 1 0 7 1 7 6
B A S E S D E D A T O S P A R A D I S P O S I T I V O S M Ó V I L E S
1 4 / 0 4 / 2 0 1 5

3. • La demanda de bases de datos para dispositivos
móviles ha crecido en los últimos años debido a la
necesidad de las empresas de tener la información
al instante de lo que sucede en el campo y así
responder más rápidamente ante la competencia.
Esta necesidad ha provocado que el
almacenamiento de los datos en estos dispositivos
haya mejorado tanto en capacidad como en
herramientas.
• Actualmente contamos con diversas opciones de
manejadores de bases de datos para móviles.

5. • SQLite es una librería escrita en C que implementa un motor
de base de datos para SQL92 empotrable.
Por lo tanto SQLite es una librería escrita en lenguaje C que
implementa un manejador de base de datos SQL embebido.
• Los programas que se enlacen con la librería SQLite pueden
tener acceso a una base de datos SQL, sin tener que ejecutar
un programa de RDBMS separado.
• SQLite es Software Libre por lo tanto el código fuente es del
dominio públicoy licencia GPL.
• Ademas se puede entender como bases de datos
empotradas aquellas que no inician un servicio en nuestra
máquina independiente de la aplicación, pudiendose
enlazar directamente a nuestro código fuente o bien utilizarse
en forma de librería (include)".

6. • SQLite es una herramienta de software libre, que permite
almacenar información en dispositivos empotrados de una
forma sencilla, eficaz, potente, rápida y en equipos con
pocas capacidades de hardware, como puede ser una PDA
o un teléfono celular. SQLite implementa el estándar SQL92 y
también agrega extensiones que facilitan su uso en cualquier
ambiente de desarrollo. Esto permite que SQLite soporte
desde las consultas más básicas hasta las más complejas del
lenguaje SQL, y lo más importante es que se puede usar tanto
en dispositivos móviles como en sistemas de escritorio, sin
necesidad de realizar procesos complejos de importación y
exportación de datos, ya que existe compatibilidad al 100%
entre las diversas plataformas disponibles, haciendo que la
portabilidad entre dispositivos y plataformas sea transparente.

7. DE DONDE SE DESCARGA
• https://www.sqlite.org/download.html
Su instalación es muy sencilla (Archivos
Fuentes: http://www.hwaci.com/sw/sqlite/), requiere
únicamente los pasos habituales de tar, configure, make y
make install. Los desarrolladores recomiendan estos pasos:
$ tar zxvf sqlite.tar.gz
$ mkdir bld
$ cd bld
$ ../sqlite/configure
$ make
$ make install

8. COMANDOS
• SQLite, cuenta con una utilidad llamada sqlite que
nos permitirá ejecutar comandos SQL contra una
base de datos SQLite en modo consola. Desde
aquí podemos crear nuestra base de datos, realizar
consultas, insertar datos, etc.

9. CREANDO MI BASE DE DATOS
Para crear es simple desde el símbolo de sistema
escribimos
C:>sqlite3.exe nombrebasededatos.db
Y nos aparecerá lo siguiente:
Código SQL:
1 SQLite version 3.6.17
2 Enter ".help" FOR instructions
3 Enter SQL statements TERMINATED WITH a ";"
4 sqlite>

10. CREANDO TABLAS
• CREATE TABLE tb1
• (
• id_tb1 INTEGER PRIMARY KEY NOT NULL,
• texto text
• );
• CREATE TABLE tb2
• (
• id_tb2 INTEGER PRIMARY KEY NOT NULL,
• texto VARCHAR (50),
• id_tb1FK INTEGER NOT NULL CONSTRAINT fk_id_tb1FK REFERENCES a(id_tb1) ON
UPDATE CASCADE
• );
• CREATE TABLE tb3
• (
• id_tb3 INTEGER PRIMARY KEY NOT NULL,
• informacion text,
• id_tb2_FK INTEGER NOT NULL CONSTRAINT fk_id_tb2FK REFERENCES a(id_tb2) ON
DELETE CASCADE
• );

11. • CREATE TABLE tb4
• (
• id_tb4 INTEGER PRIMARY KEY NOT NULL,
• otrodato VARCHAR (25)
• );
• CREATE TABLE intermedia
• (
• id_intermedia INTEGER PRIMARY KEY NOT NULL,
• id_tb2FK INTEGER NOT NULL CONSTRAINT fk_id_tb2FK
REFERENCES a(id_tb2) ON DELETE CASCADE,
• id_tb4FK INTEGER NOT NULL CONSTRAINT fk_id_tb4FK
REFERENCES a(id_tb4) ON DELETE CASCADE
• );

12. • Ahora si queremos realizar un UPDATE
Supongamos que modifico el id_tb1 y esta le pasa la
referencia a la tb2 sería algo asi:
Código SQL:
• CREATE TRIGGER update_tb1_tb2
• BEFORE UPDATE ON tb2
• FOR EACH ROW
• BEGIN
• SELECT RAISE (ROLLBACK, ’No se puede insertar el
registro’)
• WHERE (SELECT id_tb1 FROM tb1 WHERE id_tb1=
NEW.id_tb1FK) IS NULL;
• END;

13. • Para un DELETE es algo parecido pero más
especifico:
Código SQL:
• CREATE TRIGGER delete_tb1_tb2
• BEFORE DELETE ON tb1
• FOR EACH ROW BEGIN
• DELETE FROM tb2 WHERE id_tb2FK = OLD.id_tb1;
• END;
• Aquí si eliminamos un registro de la tb1 también se
elimina en la tb2.

14. • Por ejemplo, supongamos que tenemos un archivo llamado
tablas.sql con los siguientes comandos:
CREATE TABLE MAQUINAS (
ID INTEGER UNIKE PRIMARY KEY,
NOMBRE VARCHAR(30),
IP VARCHAR(15),
USUARIO VARCHAR(30)
);
INSERT INTO MAQUINAS (NOMBRE, IP, USUARIO)
VALUES ('maquina1','192.168.1.10','Jose');
INSERT INTO MAQUINAS (NOMBRE, IP, USUARIO)
VALUES ('maquina2','192.168.0.1', 'Pedro');
INSERT INTO MAQUINAS (NOMBRE, IP, USUARIO)
VALUES ('maquina3','192.168.0.100','Carlos');
?>

15. • Si ejecutamos:
$ sqlite base.db
observamos que nos crea un solo archivo(base.db), mescla de binario y
ASCII, el cual contiene la definición de la base de datos, tabla y datos.
Algunas operaciones sobre esta base serian:
$ sqlite base.db "select * from maquinas"
que dará como salida:
1|maquina1|192.168.1.10|Jose
2|maquina2|192.168.0.1|Pedro
3|maquina3|192.168.0.100|Carlos
de similar forma se ejecuta el resto de los comandos como ser: INSERT,
UPDATE, DELETE, etc.
Observese que SQLite retorna todo el resultado de la consulta separados
por el símbolo "|“.

16. • Una vista es un aspecto específico de los datos a
partir de una o más tablas. Puede organizar los
datos en un orden específico, higlight u ocultar
algunos datos. Una vista consiste en una consulta
almacenada accesible como una tabla virtual
compuesto por el conjunto de resultados de una
consulta. A diferencia de las tablas ordinarias
objeto no forma parte del esquema físico. Se trata
de una tabla dinámica, virtual calculado o
cotejada de los datos en la base de datos.

17. • El comando CREATE VIEW asigna un nombre a un pre-envasados SELECT
comunicado. Una vez creada la vista, se puede utilizar en la cláusula FROM de
otra SELECT en lugar de un nombre de tabla.
• Si el "TEMP" o palabra clave "TEMPORAL" se produce en medio de "crear" y "Ver" y
luego la opinión de que se crea es sólo visible a la conexión de base de datos que
creó y se borra automáticamente cuando la conexión de base de datos se cierra.
• Si se especifica un <database-name>, se crea la vista en la base de datos
llamada. Es un error especificar tanto un <database-name> y la palabra clave
TEMP en una vista, a menos que el <database-name> es "temp". Si no se
especifica ningún nombre de base de datos, y la palabra clave TEMP no está
presente, la vista se crea en la base de datos principal.
• No se puede BORRAR , INSERT , o ACTUALIZAR una vista. Vistas son de sólo lectura
en SQLite. Sin embargo, en muchos casos, se puede utilizar un desencadenador
INSTEAD OF en la vista a lograr lo mismo. Vistas se eliminan con el DROP VIEW
comandos.

18. • Ahora que ya tenemos nuestras RESTRICCIONES,
UPDATES y DELETE veamos cómo hacer una VISTA.
• Código SQL:
• CREATE VIEW info AS SELECT * FROM tb2 JOIN
• (SELECT * FROM tb3 )ON id_tb2_FK= id_tb2;
• Esta vista nos une las dos tablas prácticamente
dando como resultado:
• id_tb2, texto, id_tb1FK , id_tb3, informacion,
id_tb2_FK

19. • Ahora una vista sobre otra vista (dirán una vista sobre
otra. pues si se pudo).
• Esto quedaría así más o menos:
• Código SQL:
• CREATE VIEW detalles AS SELECT * FROM tb4
• JOIN (SELECT *FROM intermedia JOIN (SELECT * FROM
info) ON id_tb2=id_tb2FK)
• ON id_tb4FK =id_tb4;
• Dando como resultado todos los datos campos de la
tb2, tb3, intermedia y tb4

20. • Para restringir una vista que solo quieres que te
mande a llamar un solo registro es fácil pones:
• Código SQL:
• SELECT * FROM info WHERE id_tb2=1;
• Y solo te muestra los registros de la tb2 con el valor
1y los correspondientes de la tb3.

21. • En el siguiente ejemplo, se crea una vista simple.
sqlite> SELECT * FROM Cars;
Id Nombre Costo
------------------------------
1 Audi 52642
2 Mercedes 57127
3 Skoda 9000
4 Volvo 29000
5 Bentley 350000
6 Citroen 21000
7 Hummer 41400
8 Volkswagen 21600
Se trata de nuestros datos, en los que creamos la vista.

22. • sqlite> CREAR CheapCars Ver como SELECT
Nombre de los coches donde el costo <30000;
sqlite> SELECT * FROM CheapCars;
Nombre
----------
Skoda
Volvo
Citroen
Volkswagen

23. • http://www.somoslibres.org/modules.php?name=N
ews&file=article&sid=183
• http://es.wikipedia.org/wiki/SQLite
• http://sg.com.mx/revista/17/sqlite-la-base-datos-
embebida#.VS0IdvmG_9s
• https://mx.answers.yahoo.com/question/index?qid
=20130824181732AAPnD5S
• https://www.sqlite.org/lang_createview.html
• http://www.forosdelweb.com/f21/mini-tutorial-
sqlite-zegaz-800653/