SQLite - Guía rápida

Este capítulo le ayuda a comprender qué es SQLite, en qué se diferencia de SQL, por qué es necesario y la forma en que maneja la base de datos de aplicaciones.

SQLite es una biblioteca de software que implementa un motor de base de datos transaccional SQL autónomo, sin servidor, sin configuración. SQLite es uno de los motores de base de datos de más rápido crecimiento, pero eso es un crecimiento en términos de popularidad, no tiene nada que ver con su tamaño. El código fuente de SQLite es de dominio público.

¿Qué es SQLite?

SQLite es una biblioteca en proceso que implementa un motor de base de datos transaccional SQL autónomo, sin servidor, sin configuración. Es una base de datos, que no está configurada, lo que significa que, al igual que otras bases de datos, no necesita configurarla en su sistema.

El motor SQLite no es un proceso independiente como otras bases de datos, puede vincularlo estática o dinámicamente según sus requisitos con su aplicación. SQLite accede a sus archivos de almacenamiento directamente.

¿Por qué SQLite?

• SQLite no requiere un proceso o sistema de servidor separado para operar (sin servidor).

• SQLite viene con configuración cero, lo que significa que no se necesita configuración ni administración.

• Una base de datos SQLite completa se almacena en un solo archivo de disco multiplataforma.

• SQLite es muy pequeño y liviano, menos de 400 KB completamente configurado o menos de 250 KB con funciones opcionales omitidas.

• SQLite es autónomo, lo que significa que no hay dependencias externas.

• Las transacciones de SQLite son totalmente compatibles con ACID, lo que permite un acceso seguro desde múltiples procesos o subprocesos.

• SQLite admite la mayoría de las funciones del lenguaje de consulta que se encuentran en el estándar SQL92 (SQL2).

• SQLite está escrito en ANSI-C y proporciona una API simple y fácil de usar.

• SQLite está disponible en UNIX (Linux, Mac OS-X, Android, iOS) y Windows (Win32, WinCE, WinRT).

SQLite Una breve historia

• 2000 - D. Richard Hipp diseñó SQLite con el propósito de que no se requiriera administración para operar un programa.

• 2000 - En agosto, SQLite 1.0 se lanzó con GNU Database Manager.

• 2011 - Hipp anunció que agregará la interfaz UNQl a SQLite DB y desarrollará UNQLite (base de datos orientada a documentos).

Limitaciones de SQLite

Hay algunas características no compatibles de SQL92 en SQLite que se enumeran en la siguiente tabla.

No Señor.	Característica y descripción
1	RIGHT OUTER JOIN Solo se implementa LEFT OUTER JOIN.
2	FULL OUTER JOIN Solo se implementa LEFT OUTER JOIN.
3	ALTER TABLE Se admiten las variantes RENAME TABLE y ADD COLUMN del comando ALTER TABLE. No se admiten las opciones DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT.
4	Trigger support Se admiten los disparadores FOR CADA FILA, pero no los disparadores FOR CADA DECLARACIÓN.
5	VIEWs Las VIEWs en SQLite son de solo lectura. No puede ejecutar una instrucción DELETE, INSERT o UPDATE en una vista.
6	GRANT and REVOKE Los únicos permisos de acceso que se pueden aplicar son los permisos de acceso a archivos normales del sistema operativo subyacente.

Comandos SQLite

Los comandos estándar de SQLite para interactuar con bases de datos relacionales son similares a SQL. Son CREAR, SELECCIONAR, INSERTAR, ACTUALIZAR, ELIMINAR y SOLTAR. Estos comandos se pueden clasificar en grupos según su naturaleza operativa:

DDL: lenguaje de definición de datos

No Señor.	Comando y descripción
1	CREATE Crea una nueva tabla, una vista de una tabla u otro objeto en la base de datos.
2	ALTER Modifica un objeto de base de datos existente, como una tabla.
3	DROP Elimina una tabla completa, una vista de una tabla u otro objeto de la base de datos.

DML - Lenguaje de manipulación de datos

No Señor.	Comando y descripción
1	INSERT Crea un registro
2	UPDATE Modifica registros
3	DELETE Elimina registros

DQL - Lenguaje de consulta de datos

No Señor.	Comando y descripción
1	SELECT Recupera ciertos registros de una o más tablas.

SQLite es famoso por su gran característica de configuración cero, lo que significa que no se necesita una configuración o administración complejas. Este capítulo lo llevará a través del proceso de configuración de SQLite en Windows, Linux y Mac OS X.

Instalar SQLite en Windows

• Step 1- Vaya a la página de descarga de SQLite y descargue los binarios precompilados de la sección de Windows.

• Step 2 - Descargue archivos comprimidos sqlite-shell-win32 - *. Zip y sqlite-dll-win32 - *. Zip.

• Step 3 - Cree una carpeta C: \> sqlite y descomprima los dos archivos comprimidos en esta carpeta, lo que le dará los archivos sqlite3.def, sqlite3.dll y sqlite3.exe.

• Step 4 - Agregue C: \> sqlite en su variable de entorno PATH y finalmente vaya al símbolo del sistema y emita el comando sqlite3, que debería mostrar el siguiente resultado.

C:\>sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Instalar SQLite en Linux

Hoy en día, casi todas las versiones del sistema operativo Linux se envían con SQLite. Entonces, simplemente emita el siguiente comando para verificar si ya tiene SQLite instalado en su máquina.

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Si no ve el resultado anterior, significa que no tiene SQLite instalado en su máquina Linux. Los siguientes son los siguientes pasos para instalar SQLite:

• Step 1- Vaya a la página de descarga de SQLite y descargue sqlite-autoconf - *. Tar.gz de la sección de código fuente.

• Step 2 - Ejecute el siguiente comando -

$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502 $./configure --prefix=/usr/local
$make $make install

El comando anterior terminará con la instalación de SQLite en su máquina Linux. Que puede verificar como se explicó anteriormente.

Instalar SQLite en Mac OS X

Aunque la última versión de Mac OS X viene preinstalada con SQLite, pero si no tiene la instalación disponible, simplemente siga estos pasos:

• Step 1- Vaya a la página de descarga de SQLite y descargue sqlite-autoconf - *. Tar.gz de la sección de código fuente.

• Step 2 - Ejecute el siguiente comando -

$tar xvfz sqlite-autoconf-3071502.tar.gz $cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local $make
$make install

El procedimiento anterior terminará con la instalación de SQLite en su máquina Mac OS X. Lo cual puede verificar emitiendo el siguiente comando:

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Finalmente, tiene el símbolo del sistema SQLite donde puede emitir comandos SQLite para sus ejercicios.

Este capítulo lo llevará a través de comandos simples y útiles utilizados por los programadores de SQLite. Estos comandos se denominan comandos de punto de SQLite y la excepción con estos comandos es que no deben terminar con un punto y coma (;).

Comencemos escribiendo un simple sqlite3 comando en el símbolo del sistema que le proporcionará el símbolo del sistema SQLite donde emitirá varios comandos SQLite.

$sqlite3
SQLite version 3.3.6
Enter ".help" for instructions
sqlite>

Para obtener una lista de los comandos de puntos disponibles, puede ingresar ".help" en cualquier momento. Por ejemplo

sqlite>.help

El comando anterior mostrará una lista de varios comandos importantes de SQLite dot, que se enumeran en la siguiente tabla.

No Señor.	Comando y descripción
1	.backup ?DB? FILE Copia de seguridad de la base de datos ("principal" predeterminada) en ARCHIVO
2	.bail ON|OFF Deténgase después de encontrar un error. Desactivado predeterminado
3	.databases Lista de nombres y archivos de bases de datos adjuntas
4	.dump ?TABLE? Volcar la base de datos en un formato de texto SQL. Si se especifica TABLE, solo volcar tablas que coincidan con el patrón LIKE TABLE
5	.echo ON|OFF Activar o desactivar el eco de comando
6	.exit Salir del indicador SQLite
7	.explain ON|OFF Active o desactive el modo de salida adecuado para EXPLAIN. Sin argumentos, activa EXPLAIN
8	.header(s) ON|OFF Activar o desactivar la visualización de encabezados
9	.help Mostrar este mensaje
10	.import FILE TABLE Importar datos de FILE a TABLE
11	.indices ?TABLE? Muestra los nombres de todos los índices. Si se especifica TABLE, solo muestra índices para tablas que coincidan con el patrón LIKE TABLE
12	.load FILE ?ENTRY? Cargar una biblioteca de extensiones
13	.log FILE|off Activa o desactiva el inicio de sesión. FILE puede ser stderr / stdout
14	.mode MODE Establecer el modo de salida donde MODE es uno de: csv - Valores separados por comas column - Columnas alineadas a la izquierda. html - Código HTML <table> insert - Sentencias de inserción SQL para TABLE line - Un valor por línea list - Valores delimitados por .separator string tabs - Valores separados por tabuladores tcl - Elementos de la lista TCL
15	.nullvalue STRING Imprimir STRING en lugar de valores NULL
dieciséis	.output FILENAME Enviar salida a FILENAME
17	.output stdout Enviar salida a la pantalla
18	.print STRING... Imprimir STRING literal
19	.prompt MAIN CONTINUE Reemplazar las indicaciones estándar
20	.quit Salir del indicador SQLite
21	.read FILENAME Ejecutar SQL en FILENAME
22	.schema ?TABLE? Muestre las declaraciones CREATE. Si se especifica TABLE, solo mostrar tablas que coincidan con el patrón LIKE TABLE
23	.separator STRING Cambiar el separador utilizado por el modo de salida y .import
24	.show Muestra los valores actuales para varios ajustes.
25	.stats ON|OFF Activar o desactivar las estadísticas
26	.tables ?PATTERN? Lista de nombres de tablas que coinciden con un patrón LIKE
27	.timeout MS Intente abrir tablas bloqueadas para MS milisegundos
28	.width NUM NUM Establecer anchos de columna para el modo "columna"
29	.timer ON|OFF Activar o desactivar la medición del temporizador de la CPU

Intentemos .show comando para ver la configuración predeterminada para su símbolo del sistema SQLite.

sqlite>.show
     echo: off
  explain: off
  headers: off
     mode: column
nullvalue: ""
   output: stdout
separator: "|"
    width:
sqlite>

Asegúrese de que no haya espacio entre sqlite> prompt y dot command, de lo contrario no funcionará.

Formateo de salida

Puede utilizar la siguiente secuencia de comandos de puntos para formatear su salida.

sqlite>.header on
sqlite>.mode column
sqlite>.timer on
sqlite>

La configuración anterior producirá la salida en el siguiente formato.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
CPU Time: user 0.000000 sys 0.000000

La tabla sqlite_master

La tabla maestra contiene la información clave sobre las tablas de su base de datos y se llama sqlite_master. Puede ver su esquema de la siguiente manera:

sqlite>.schema sqlite_master

Esto producirá el siguiente resultado.

CREATE TABLE sqlite_master (
   type text,
   name text,
   tbl_name text,
   rootpage integer,
   sql text
);

SQLite es seguido por un conjunto único de reglas y pautas llamado Sintaxis. Este capítulo enumera toda la sintaxis básica de SQLite.

Sensibilidad de mayúsculas y minúsculas

El punto importante a señalar es que SQLite es case insensitive, es decir, las cláusulas GLOB y glob tienen el mismo significado en las declaraciones SQLite.

Comentarios

Los comentarios de SQLite son notas adicionales, que puede agregar en su código SQLite para aumentar su legibilidad y pueden aparecer en cualquier lugar; Pueden aparecer espacios en blanco, incluidas expresiones internas y en medio de otras sentencias SQL, pero no se pueden anidar.

Los comentarios SQL comienzan con dos caracteres "-" consecutivos (ASCII 0x2d) y se extienden hasta el siguiente carácter de nueva línea (ASCII 0x0a) o hasta el final de la entrada, lo que ocurra primero.

También puede usar comentarios de estilo C, que comienzan con "/ *" y se extienden hasta el siguiente par de caracteres "* /" incluido o hasta el final de la entrada, lo que ocurra primero. Los comentarios de estilo C pueden abarcar varias líneas.

sqlite> .help -- This is a single line comment

Declaraciones SQLite

Todas las declaraciones de SQLite comienzan con cualquiera de las palabras clave como SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, etc., y todas las declaraciones terminan con un punto y coma (;).

Declaración SQLite ANALYZE

ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;

Cláusula Y / O de SQLite

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;

Declaración SQLite ALTER TABLE

ALTER TABLE table_name ADD COLUMN column_def...;

Sentencia SQLite ALTER TABLE (Cambiar nombre)

ALTER TABLE table_name RENAME TO new_table_name;

Declaración SQLite ATTACH DATABASE

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

Sentencia SQLite BEGIN TRANSACTION

BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

Cláusula BETWEEN de SQLite

SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;

Declaración COMMIT de SQLite

COMMIT;

Sentencia SQLite CREATE INDEX

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

Sentencia SQLite CREATE UNIQUE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

Declaración SQLite CREATE TABLE

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

Declaración SQLite CREATE TRIGGER

CREATE TRIGGER database_name.trigger_name 
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN 
   stmt1; 
   stmt2;
   ....
END;

Sentencia CREATE VIEW de SQLite

CREATE VIEW database_name.view_name AS
SELECT statement....;

Declaración SQLite CREATE VIRTUAL TABLE

CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );

Declaración SQLite COMMIT TRANSACTION

COMMIT;

Cláusula COUNT de SQLite

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

Declaración SQLite DELETE

DELETE FROM table_name
WHERE {CONDITION};

Declaración SQLite DETACH DATABASE

DETACH DATABASE 'Alias-Name';

Cláusula DISTINCT de SQLite

SELECT DISTINCT column1, column2....columnN
FROM table_name;

Declaración SQLite DROP INDEX

DROP INDEX database_name.index_name;

Declaración DROP TABLE de SQLite

DROP TABLE database_name.table_name;

Declaración DROP VIEW de SQLite

DROP INDEX database_name.view_name;

Declaración DROP TRIGGER de SQLite

DROP INDEX database_name.trigger_name;

Cláusula SQLite EXISTS

SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM   table_name );

Declaración EXPLAIN de SQLite

EXPLAIN INSERT statement...;
or 
EXPLAIN QUERY PLAN SELECT statement...;

Cláusula SQLite GLOB

SELECT column1, column2....columnN
FROM table_name
WHERE column_name GLOB { PATTERN };

Cláusula GROUP BY de SQLite

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;

Cláusula HAVING de SQLite

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

Instrucción SQLite INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

Cláusula SQLite IN

SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);

Cláusula similar a SQLite

SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };

Cláusula SQLite NOT IN

SELECT column1, column2....columnN
FROM table_name
WHERE column_name NOT IN (val-1, val-2,...val-N);

Cláusula ORDER BY de SQLite

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};

Declaración SQLite PRAGMA

PRAGMA pragma_name;

For example:

PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);

Declaración de SQLite RELEASE SAVEPOINT

RELEASE savepoint_name;

Declaración SQLite REINDEX

REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;

Declaración SQLite ROLLBACK

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

Declaración SQLite SAVEPOINT

SAVEPOINT savepoint_name;

Declaración SQLite SELECT

SELECT column1, column2....columnN
FROM table_name;

Declaración UPDATE de SQLite

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

Declaración de SQLite VACUUM

VACUUM;

Cláusula WHERE de SQLite

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;

El tipo de datos SQLite es un atributo que especifica el tipo de datos de cualquier objeto. Cada columna, variable y expresión tiene un tipo de datos relacionado en SQLite.

Utilizaría estos tipos de datos al crear sus tablas. SQLite utiliza un sistema de tipo dinámico más general. En SQLite, el tipo de datos de un valor está asociado con el valor en sí, no con su contenedor.

Clases de almacenamiento SQLite

Cada valor almacenado en una base de datos SQLite tiene una de las siguientes clases de almacenamiento:

No Señor.	Clase de almacenamiento y descripción
1	NULL El valor es un valor NULO.
2	INTEGER El valor es un entero con signo, almacenado en 1, 2, 3, 4, 6 u 8 bytes dependiendo de la magnitud del valor.
3	REAL El valor es un valor de coma flotante, almacenado como un número de coma flotante IEEE de 8 bytes.
4	TEXT El valor es una cadena de texto, almacenada usando la codificación de la base de datos (UTF-8, UTF-16BE o UTF-16LE)
5	BLOB El valor es una masa de datos, almacenada exactamente como se ingresó.

La clase de almacenamiento SQLite es un poco más general que un tipo de datos. La clase de almacenamiento INTEGER, por ejemplo, incluye 6 tipos de datos enteros diferentes de diferentes longitudes.

Tipo de afinidad de SQLite

SQLite apoya el concepto de type affinityen columnas. Cualquier columna puede almacenar cualquier tipo de datos, pero la clase de almacenamiento preferida para una columna se llama suaffinity. A cada columna de la tabla en una base de datos SQLite3 se le asigna una de las siguientes afinidades de tipo:

No Señor.	Afinidad y descripción
1	TEXT Esta columna almacena todos los datos utilizando las clases de almacenamiento NULL, TEXT o BLOB.
2	NUMERIC Esta columna puede contener valores que utilicen las cinco clases de almacenamiento.
3	INTEGER Se comporta igual que una columna con afinidad NUMÉRICA, con una excepción en una expresión CAST.
4	REAL Se comporta como una columna con afinidad NUMÉRICA excepto que fuerza valores enteros en representación de punto flotante.
5	NONE Una columna con afinidad NINGUNA no prefiere una clase de almacenamiento sobre otra y no se intenta forzar datos de una clase de almacenamiento a otra.

Nombres de tipo y afinidad de SQLite

La siguiente tabla enumera varios nombres de tipos de datos que se pueden usar al crear tablas SQLite3 con la afinidad aplicada correspondiente.

Tipo de datos	Afinidad
INT INTEGER TINYINT SMALLINT MEDIUMINT BIGINT BIG INT SIN FIRMAR INT2 INT8	ENTERO
CHARACTER(20) VARCHAR(255) CARÁCTER VARIANTE (255) NCHAR(55) PERSONAJE NATIVO (70) NVARCHAR(100) TEXT CLOB	TEXTO
BLOB sin tipo de datos especificado	NINGUNA
REAL DOUBLE PRECISIÓN DOBLE FLOAT	REAL
NUMERIC DECIMAL(10,5) BOOLEAN DATE DATETIME	NUMÉRICO

Tipo de datos booleano

SQLite no tiene una clase de almacenamiento booleana separada. En cambio, los valores booleanos se almacenan como números enteros 0 (falso) y 1 (verdadero).

Tipo de datos de fecha y hora

SQLite no tiene una clase de almacenamiento separada para almacenar fechas y / o horas, pero SQLite es capaz de almacenar fechas y horas como valores TEXT, REAL o INTEGER.

No Señor.	Formato de fecha y clase de almacenamiento
1	TEXT Una fecha en un formato como "AAAA-MM-DD HH: MM: SS.SSS"
2	REAL El número de días desde el mediodía en Greenwich el 24 de noviembre de 4714 a. C.
3	INTEGER El número de segundos desde 1970-01-01 00:00:00 UTC

Puede elegir almacenar fechas y horas en cualquiera de estos formatos y convertir libremente entre formatos utilizando las funciones integradas de fecha y hora.

En SQLite, sqlite3El comando se usa para crear una nueva base de datos SQLite. No es necesario tener ningún privilegio especial para crear una base de datos.

Sintaxis

A continuación se muestra la sintaxis básica del comando sqlite3 para crear una base de datos:

$sqlite3 DatabaseName.db

Siempre, el nombre de la base de datos debe ser único dentro del RDBMS.

Ejemplo

Si desea crear una nueva base de datos <testDB.db>, entonces la declaración SQLITE3 sería la siguiente:

$sqlite3 testDB.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

El comando anterior creará un archivo testDB.dben el directorio actual. Este archivo será utilizado como base de datos por el motor SQLite. Si se ha dado cuenta al crear la base de datos, el comando sqlite3 proporcionará unsqlite> mensaje después de crear un archivo de base de datos con éxito.

Una vez que se crea una base de datos, puede verificarla en la lista de bases de datos utilizando el siguiente SQLite .databases mando.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db

Usarás SQLite .quit comando para salir del indicador de sqlite de la siguiente manera:

sqlite>.quit
$

El comando .dump

Puedes usar .dump dot para exportar la base de datos completa en un archivo de texto usando el siguiente comando SQLite en el símbolo del sistema.

$sqlite3 testDB.db .dump > testDB.sql

El comando anterior convertirá todo el contenido de testDB.db base de datos en declaraciones SQLite y volcarla en un archivo de texto ASCII testDB.sql. Puede realizar la restauración desde el testDB.sql generado de una manera simple de la siguiente manera:

$sqlite3 testDB.db < testDB.sql

En este momento, su base de datos está vacía, por lo que puede probar los dos procedimientos anteriores una vez que tenga pocas tablas y datos en su base de datos. Por ahora, pasemos al siguiente capítulo.

Considere un caso en el que tiene varias bases de datos disponibles y desea utilizar cualquiera de ellas a la vez. SQLiteATTACH DATABASE La declaración se usa para seleccionar una base de datos en particular, y después de este comando, todas las declaraciones SQLite se ejecutarán en la base de datos adjunta.

Sintaxis

A continuación se muestra la sintaxis básica de la declaración SQLite ATTACH DATABASE.

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

El comando anterior también creará una base de datos en caso de que la base de datos aún no esté creada, de lo contrario, simplemente adjuntará el nombre del archivo de la base de datos con la base de datos lógica 'Alias-Name'.

Ejemplo

Si desea adjuntar una base de datos existente testDB.db, entonces la instrucción ATTACH DATABASE sería la siguiente:

sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';

Utilice SQLite .database comando para mostrar la base de datos adjunta.

sqlite> .database
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

Los nombres de la base de datos main y tempestán reservados para que la base de datos primaria y la base de datos contengan tablas temporales y otros objetos de datos temporales. Ambos nombres de base de datos existen para cada conexión de base de datos y no deben usarse para adjuntar, de lo contrario, recibirá el siguiente mensaje de advertencia.

sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database TEMP is already in use

SQLite DETACH DATABASELa declaración se utiliza para separar y disociar una base de datos con nombre de una conexión de base de datos que se adjuntó previamente mediante la declaración ATTACH. Si el mismo archivo de base de datos se adjuntó con varios alias, el comando DETACH desconectará solo el nombre de pila y el resto del adjunto continuará. No puede separar elmain o temp bases de datos.

Si la base de datos es una base de datos en memoria o temporal, la base de datos se destruirá y se perderá el contenido.

Sintaxis

A continuación se muestra la sintaxis básica de la declaración 'Alias-Name' de SQLite DETACH DATABASE.

DETACH DATABASE 'Alias-Name';

Aquí, 'Alias-Name' es el mismo alias que usó al adjuntar la base de datos mediante la instrucción ATTACH.

Ejemplo

Considere que tiene una base de datos, que creó en el capítulo anterior y la adjuntó con 'test' y 'currentDB' como podemos ver usando .database mando.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db
3    currentDB        /home/sqlite/testDB.db

Intentemos separar 'currentDB' de testDB.db usando el siguiente comando.

sqlite> DETACH DATABASE 'currentDB';

Ahora, si revisa el archivo adjunto actual, encontrará que testDB.db todavía está conectado con 'test' y 'main'.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

SQLite CREATE TABLELa declaración se usa para crear una nueva tabla en cualquiera de las bases de datos. Crear una tabla básica implica nombrar la tabla y definir sus columnas y el tipo de datos de cada columna.

Sintaxis

A continuación se muestra la sintaxis básica de la instrucción CREATE TABLE.

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

CREAR TABLA es la palabra clave que le dice al sistema de base de datos que cree una nueva tabla. El nombre o identificador exclusivo de la tabla sigue a la instrucción CREATE TABLE. Opcionalmente, puede especificar database_name junto con table_name .

Ejemplo

A continuación se muestra un ejemplo que crea una tabla EMPRESA con ID como clave principal y NOT NULL son las restricciones que muestran que estos campos no pueden ser NULL al crear registros en esta tabla.

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Creemos una tabla más, que usaremos en nuestros ejercicios en capítulos posteriores.

sqlite> CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Puede verificar si su tabla se ha creado correctamente usando el comando SQLite .tables comando, que se utilizará para enumerar todas las tablas en una base de datos adjunta.

sqlite>.tables
COMPANY     DEPARTMENT

Aquí, puede ver la tabla COMPANY dos veces porque muestra la tabla COMPANY para la base de datos principal y la tabla test.COMPANY para el alias 'prueba' creado para su testDB.db. Puede obtener información completa sobre una tabla utilizando el siguiente SQLite.schema mando.

sqlite>.schema COMPANY
CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

SQLite DROP TABLE La sentencia se utiliza para eliminar una definición de tabla y todos los datos, índices, desencadenantes, restricciones y especificaciones de permisos asociados para esa tabla.

Debe tener cuidado al usar este comando porque una vez que se elimina una tabla, toda la información disponible en la tabla también se perderá para siempre.

Sintaxis

A continuación se muestra la sintaxis básica de la instrucción DROP TABLE. Opcionalmente, puede especificar el nombre de la base de datos junto con el nombre de la tabla de la siguiente manera:

DROP TABLE database_name.table_name;

Ejemplo

Primero verifiquemos la tabla EMPRESA y luego la borraremos de la base de datos.

sqlite>.tables
COMPANY       test.COMPANY

Esto significa que la tabla EMPRESA está disponible en la base de datos, así que déjela caer de la siguiente manera:

sqlite>DROP TABLE COMPANY;
sqlite>

Ahora, si prueba el comando .TABLES, ya no encontrará la tabla COMPANY.

sqlite>.tables
sqlite>

No muestra nada, lo que significa que la tabla de su base de datos se ha eliminado correctamente.

SQLite INSERT INTO La declaración se usa para agregar nuevas filas de datos a una tabla en la base de datos.

Sintaxis

A continuación se muestran las dos sintaxis básicas de la instrucción INSERT INTO.

INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

Aquí, column1, column2, ... columnN son los nombres de las columnas de la tabla en la que desea insertar datos.

Es posible que no necesite especificar el nombre de la (s) columna (s) en la consulta de SQLite si está agregando valores para todas las columnas de la tabla. Sin embargo, asegúrese de que el orden de los valores esté en el mismo orden que las columnas de la tabla. La sintaxis de SQLite INSERT INTO sería la siguiente:

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Ejemplo

Considere que ya ha creado la tabla EMPRESA en su testDB.db de la siguiente manera:

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Ahora, las siguientes declaraciones crearían seis registros en la tabla EMPRESA.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

Puede crear un registro en la tabla EMPRESA utilizando la segunda sintaxis de la siguiente manera:

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

Todas las declaraciones anteriores crearían los siguientes registros en la tabla EMPRESA. En el próximo capítulo, aprenderá a mostrar todos estos registros desde una tabla.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Rellenar una tabla con otra tabla

Puede completar datos en una tabla a través de la instrucción de selección sobre otra tabla siempre que otra tabla tenga un conjunto de campos, que son necesarios para completar la primera tabla. Aquí está la sintaxis:

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

Por ahora, puede omitir la declaración anterior. Primero, aprendamos las cláusulas SELECT y WHERE que se tratarán en los capítulos siguientes.

SQLite SELECTLa declaración se utiliza para obtener los datos de una tabla de base de datos SQLite que devuelve datos en forma de tabla de resultados. Estas tablas de resultados también se denominanresult sets.

Sintaxis

A continuación se muestra la sintaxis básica de la declaración SQLite SELECT.

SELECT column1, column2, columnN FROM table_name;

Aquí, column1, column2 ... son los campos de una tabla, cuyos valores desea obtener. Si desea obtener todos los campos disponibles en el campo, puede usar la siguiente sintaxis:

SELECT * FROM table_name;

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo para obtener y mostrar todos estos registros mediante la instrucción SELECT. Aquí, los primeros tres comandos se han utilizado para configurar una salida formateada correctamente.

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

Finalmente, obtendrás el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Si desea obtener solo los campos seleccionados de la tabla EMPRESA, utilice la siguiente consulta:

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

La consulta anterior producirá el siguiente resultado.

ID          NAME        SALARY
----------  ----------  ----------
1           Paul        20000.0
2           Allen       15000.0
3           Teddy       20000.0
4           Mark        65000.0
5           David       85000.0
6           Kim         45000.0
7           James       10000.0

Configuración del ancho de la columna de salida

A veces, se enfrentará a un problema relacionado con la salida truncada en caso de .mode columnlo que sucede debido al ancho predeterminado de la columna que se mostrará. Lo que puede hacer es establecer el ancho de columna visualizable de la columna usando.width num, num.... comando de la siguiente manera:

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

Lo anterior .width El comando establece el ancho de la primera columna en 10, el ancho de la segunda columna en 20 y el ancho de la tercera columna en 10. Finalmente, la instrucción SELECT anterior dará el siguiente resultado.

ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

Información del esquema

Como todos los dot commands están disponibles en el indicador SQLite, por lo tanto, mientras programa con SQLite, utilizará la siguiente instrucción SELECT con sqlite_master table para enumerar todas las tablas creadas en su base de datos.

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

Suponiendo que solo tiene la tabla EMPRESA en su testDB.db, esto producirá el siguiente resultado.

tbl_name
----------
COMPANY

Puede enumerar la información completa sobre la tabla EMPRESA de la siguiente manera:

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

Suponiendo que solo tiene la tabla EMPRESA en su testDB.db, esto producirá el siguiente resultado.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
)

¿Qué es un operador en SQLite?

Un operador es una palabra reservada o un carácter que se utiliza principalmente en la cláusula WHERE de una declaración SQLite para realizar operaciones, como comparaciones y operaciones aritméticas.

Los operadores se utilizan para especificar condiciones en una declaración SQLite y para servir como conjunciones para múltiples condiciones en una declaración.

• Operadores aritméticos
• Operadores de comparación
• Operadores logicos
• Operadores bit a bit

Operadores aritméticos SQLite

Asumir variable a tiene 10 y variable b contiene 20, entonces los operadores aritméticos de SQLite se usarán de la siguiente manera:

Mostrar ejemplos

Operador	Descripción	Ejemplo
+ (Adición)	Agrega valores a ambos lados del operador	a + b dará 30
- (Resta)	Resta el operando de la derecha del operando de la izquierda	a - b dará -10
* (Multiplicación)	Multiplica los valores a ambos lados del operador	a * b dará 200
/ (División)	Divide el operando de la izquierda por el operando de la derecha	b / a dará 2
% (Módulo)	Divide el operando de la izquierda por el operando de la derecha y devuelve el resto	b% a dará 0

Operadores de comparación SQLite

Asumir variable a tiene 10 y variable b contiene 20, entonces los operadores de comparación SQLite se usarán de la siguiente manera

Mostrar ejemplos

Operador	Descripción	Ejemplo
==	Comprueba si los valores de dos operandos son iguales o no, en caso afirmativo, la condición se cumple.	(a == b) no es cierto.
=	Comprueba si los valores de dos operandos son iguales o no, en caso afirmativo, la condición se cumple.	(a = b) no es cierto.
! =	Comprueba si los valores de dos operandos son iguales o no, si los valores no son iguales, la condición se vuelve verdadera.	(a! = b) es cierto.
<>	Comprueba si los valores de dos operandos son iguales o no, si los valores no son iguales, la condición se vuelve verdadera.	(a <> b) es cierto.
>	Comprueba si los valores del operando izquierdo son mayores que el valor del operando derecho, si es así, la condición se vuelve verdadera.	(a> b) no es cierto.
<	Comprueba si los valores del operando izquierdo son menores que el valor del operando derecho; si es así, la condición se cumple.	(a <b) es cierto.
> =	Comprueba si el valor del operando izquierdo es mayor o igual que el valor del operando derecho, si es así, la condición se convierte en verdadera.	(a> = b) no es cierto.
<=	Comprueba si el valor del operando izquierdo es menor o igual que el valor del operando derecho; si es así, la condición se cumple.	(a <= b) es cierto.
! <	Comprueba si el valor del operando izquierdo no es menor que el valor del operando derecho, en caso afirmativo, la condición se cumple.	(a! <b) es falso.
!>	Comprueba si el valor del operando izquierdo no es mayor que el valor del operando derecho; si es así, la condición se cumple.	(a!> b) es cierto.

Operadores lógicos SQLite

Aquí hay una lista de todos los operadores lógicos disponibles en SQLite.

Mostrar ejemplos

No Señor.	Operador y descripción
1	AND El operador AND permite la existencia de múltiples condiciones en la cláusula WHERE de una instrucción SQL.
2	BETWEEN El operador BETWEEN se utiliza para buscar valores que se encuentran dentro de un conjunto de valores, dado el valor mínimo y el valor máximo.
3	EXISTS El operador EXISTS se utiliza para buscar la presencia de una fila en una tabla especificada que cumpla con ciertos criterios.
4	IN El operador IN se utiliza para comparar un valor con una lista de valores literales que se han especificado.
5	NOT IN La negación del operador IN que se utiliza para comparar un valor con una lista de valores literales que se han especificado.
6	LIKE El operador LIKE se usa para comparar un valor con valores similares usando operadores comodín.
7	GLOB El operador GLOB se usa para comparar un valor con valores similares usando operadores comodín. Además, GLOB distingue entre mayúsculas y minúsculas, a diferencia de LIKE.
8	NOT El operador NOT invierte el significado del operador lógico con el que se utiliza. P.ej. NO EXISTE, NO ENTRE, NO EN, etc.This is negate operator.
9	OR El operador OR se utiliza para combinar varias condiciones en la cláusula WHERE de una instrucción SQL.
10	IS NULL El operador NULL se utiliza para comparar un valor con un valor NULL.
11	IS El operador IS funciona como =
12	IS NOT El operador IS funciona como! =
13	|| Agrega dos cadenas diferentes y crea una nueva.
14	UNIQUE El operador UNIQUE busca en cada fila de una tabla especificada la exclusividad (sin duplicados).

Operadores bit a bit de SQLite

El operador bit a bit trabaja en bits y realiza operaciones bit a bit. A continuación se muestra la tabla de verdad para& y |.

pags	q	p & q	p | q
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

Asume si A= 60; yB = 13, luego en formato binario, serán los siguientes:

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Los operadores Bitwise compatibles con el lenguaje SQLite se enumeran en la siguiente tabla. Asumir variableA tiene 60 y variable B tiene 13, entonces -

Mostrar ejemplos

Operador	Descripción	Ejemplo
Y	El operador AND binario copia un bit al resultado, si existe en ambos operandos.	(A & B) dará 12 que es 0000 1100
|	El operador OR binario copia un bit, si existe en cualquiera de los operandos.	(A | B) dará 61 que es 0011 1101
~	El operador de complemento binario es unario y tiene el efecto de "voltear" bits.	(~ A) dará -61 que es 1100 0011 en forma de complemento a 2 debido a un número binario con signo
<<	Operador binario de cambio a la izquierda. El valor de los operandos de la izquierda se mueve a la izquierda el número de bits especificado por el operando de la derecha.	Un << 2 dará 240 que es 1111 0000
>>	Operador de cambio a la derecha binario. El valor de los operandos de la izquierda se mueve hacia la derecha el número de bits especificado por el operando de la derecha.	A >> 2 dará 15 que es 0000 1111

Una expresión es una combinación de uno o más valores, operadores y funciones SQL que se evalúan como un valor.

Las expresiones SQL son como fórmulas y están escritas en lenguaje de consulta. También puede utilizar para consultar la base de datos para un conjunto específico de datos.

Sintaxis

Considere la sintaxis básica de la instrucción SELECT de la siguiente manera:

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION | EXPRESSION];

A continuación se muestran los diferentes tipos de expresiones SQLite.

SQLite - Expresiones booleanas

Las expresiones booleanas SQLite obtienen los datos sobre la base de un valor único coincidente. A continuación se muestra la sintaxis:

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHTING EXPRESSION;

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestran ejemplos simples que muestran el uso de expresiones booleanas de SQLite:

sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           James        24          Houston   10000.0

SQLite - Expresión numérica

Estas expresiones se utilizan para realizar cualquier operación matemática en cualquier consulta. A continuación se muestra la sintaxis:

SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

Aquí, numerical_expression se usa para expresiones matemáticas o cualquier fórmula. A continuación, se muestra un ejemplo simple que muestra el uso de Expresiones numéricas SQLite.

sqlite> SELECT (15 + 6) AS ADDITION
ADDITION = 21

Hay varias funciones integradas como avg(), sum(), count(), etc., para realizar lo que se conoce como aggregate data calculations contra una tabla o una columna de tabla específica.

sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY; 
RECORDS = 7

SQLite - Expresiones de fecha

Expresiones de fecha devuelve los valores de fecha y hora del sistema actual. Estas expresiones se utilizan en diversas manipulaciones de datos.

sqlite> SELECT CURRENT_TIMESTAMP;
CURRENT_TIMESTAMP = 2013-03-17 10:43:35

SQLite WHERE La cláusula se utiliza para especificar una condición mientras se obtienen los datos de una o varias tablas.

Si se cumple la condición dada, significa verdadera, entonces devuelve el valor específico de la tabla. Tendrá que usar la cláusula WHERE para filtrar los registros y obtener solo los registros necesarios.

La cláusula WHERE no solo se usa en la instrucción SELECT, sino que también se usa en la instrucción UPDATE, DELETE, etc., que se tratarán en capítulos posteriores.

Sintaxis

A continuación se muestra la sintaxis básica de la declaración SQLite SELECT con la cláusula WHERE.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Ejemplo

Puede especificar una condición utilizando Operadores lógicos o de comparación como>, <, =, LIKE, NOT, etc. Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación, se muestran ejemplos simples que muestran el uso de operadores lógicos SQLite. La siguiente instrucción SELECT enumera todos los registros donde EDAD es mayor o igual a 25AND el salario es mayor o igual a 65000,00.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

La siguiente instrucción SELECT enumera todos los registros donde EDAD es mayor o igual a 25 OR el salario es mayor o igual a 65000,00.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

La siguiente instrucción SELECT enumera todos los registros donde AGE no es NULL, lo que significa todos los registros porque ninguno de los registros tiene AGE igual a NULL.

sqlite>  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

La siguiente instrucción SELECT enumera todos los registros donde NAME comienza con 'Ki', no importa lo que venga después de 'Ki'.

sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

La siguiente instrucción SELECT enumera todos los registros donde NAME comienza con 'Ki', no importa lo que venga después de 'Ki'.

sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

La siguiente instrucción SELECT enumera todos los registros donde el valor de AGE es 25 o 27.

sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

La siguiente instrucción SELECT enumera todos los registros donde el valor de AGE no es ni 25 ni 27.

sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

La siguiente instrucción SELECT enumera todos los registros donde el valor de EDAD está ENTRE 25 Y 27.

sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

La siguiente instrucción SELECT hace uso de la subconsulta SQL, donde la subconsulta encuentra todos los registros con el campo AGE que tiene SALARIO> 65000 y luego se usa la cláusula WHERE junto con el operador EXISTS para enumerar todos los registros donde existe AGE de la consulta externa en el resultado devuelto por la subconsulta -

sqlite> SELECT AGE FROM COMPANY 
   WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

AGE
----------
32
25
23
25
27
22
24

La siguiente instrucción SELECT hace uso de la subconsulta SQL donde la subconsulta encuentra todos los registros con el campo AGE que tiene SALARIO> 65000 y luego se usa la cláusula WHERE junto con el operador> para enumerar todos los registros donde la AGE de la consulta externa es mayor que la edad en el resultado devuelto por la subconsulta.

sqlite> SELECT * FROM COMPANY 
   WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

SQLite AND Y ORLos operadores se utilizan para compilar varias condiciones para reducir los datos seleccionados en una declaración SQLite. Estos dos operadores se llamanconjunctive operators.

Estos operadores proporcionan un medio para realizar múltiples comparaciones con diferentes operadores en la misma declaración SQLite.

El operador AND

los ANDEl operador permite la existencia de múltiples condiciones en la cláusula WHERE de una declaración SQLite. Al usar el operador AND, la condición completa se asumirá como verdadera cuando todas las condiciones sean verdaderas. Por ejemplo, [condición1] Y [condición2] serán verdaderas solo cuando tanto condición1 como condición2 sean verdaderas.

Sintaxis

A continuación se muestra la sintaxis básica del operador AND con la cláusula WHERE.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Puedes combinar Nnúmero de condiciones que utilizan el operador AND. Para que la instrucción SQLite lleve a cabo una acción, ya sea una transacción o una consulta, todas las condiciones separadas por AND deben ser VERDADERAS.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

La siguiente instrucción SELECT enumera todos los registros donde EDAD es mayor o igual a 25 AND el salario es mayor o igual a 65000,00.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

El operador OR

El operador OR también se utiliza para combinar varias condiciones en la cláusula WHERE de una declaración SQLite. Al usar el operador OR, la condición completa se asumirá como verdadera cuando al menos alguna de las condiciones sea verdadera. Por ejemplo, [condición1] O [condición2] será verdadera si condición1 o condición2 es verdadera.

Sintaxis

A continuación se muestra la sintaxis básica del operador OR con la cláusula WHERE.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Puedes combinar Nnúmero de condiciones que utilizan el operador OR. Para que la instrucción SQLite tome una acción, ya sea una transacción o una consulta, solo UNA de las condiciones separadas por OR debe ser VERDADERA.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

La siguiente instrucción SELECT enumera todos los registros donde EDAD es mayor o igual a 25 OR el salario es mayor o igual a 65000,00.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite UPDATELa consulta se utiliza para modificar los registros existentes en una tabla. Puede usar la cláusula WHERE con la consulta UPDATE para actualizar las filas seleccionadas; de lo contrario, todas las filas se actualizarían.

Sintaxis

A continuación se muestra la sintaxis básica de la consulta UPDATE con la cláusula WHERE.

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Puedes combinar N número de condiciones que utilizan operadores AND u OR.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación, se muestra un ejemplo, que actualizará la DIRECCIÓN de un cliente cuyo ID es 6.

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;

Ahora, la tabla EMPRESA tendrá los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          Texas       45000.0
7           James       24          Houston     10000.0

Si desea modificar todos los valores de la columna DIRECCIÓN y SALARIO en la tabla COMPAÑÍA, no necesita usar la cláusula DONDE y la consulta ACTUALIZAR será la siguiente:

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

Ahora, la tabla EMPRESA tendrá los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          Texas       20000.0
2           Allen       25          Texas       20000.0
3           Teddy       23          Texas       20000.0
4           Mark        25          Texas       20000.0
5           David       27          Texas       20000.0
6           Kim         22          Texas       20000.0
7           James       24          Texas       20000.0

SQLite DELETELa consulta se utiliza para eliminar los registros existentes de una tabla. Puede usar la cláusula WHERE con la consulta DELETE para eliminar las filas seleccionadas; de lo contrario, se eliminarían todos los registros.

Sintaxis

A continuación se muestra la sintaxis básica de la consulta DELETE con la cláusula WHERE.

DELETE FROM table_name
WHERE [condition];

Puedes combinar N número de condiciones que utilizan operadores AND u OR.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que BORRARÁ un cliente cuyo ID es 7.

sqlite> DELETE FROM COMPANY WHERE ID = 7;

Ahora la tabla EMPRESA tendrá los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

Si desea ELIMINAR todos los registros de la tabla EMPRESA, no necesita usar la cláusula WHERE con la consulta DELETE, que será la siguiente:

sqlite> DELETE FROM COMPANY;

Ahora, la tabla EMPRESA no tiene ningún registro ya que todos los registros han sido eliminados por la instrucción DELETE.

SQLite LIKEEl operador se utiliza para hacer coincidir los valores de texto con un patrón utilizando comodines. Si la expresión de búsqueda puede coincidir con la expresión de patrón, el operador LIKE devolverá verdadero, que es 1. Hay dos comodines que se utilizan junto con el operador LIKE:

• El signo de porcentaje (%)
• El subrayado (_)

El signo de porcentaje representa cero, uno o varios números o caracteres. El guión bajo representa un solo número o carácter. Estos símbolos se pueden utilizar en combinaciones.

Sintaxis

A continuación se muestra la sintaxis básica de% y _.

SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or 
SELECT FROM table_name
WHERE column LIKE '%XXXX%'
or
SELECT FROM table_name
WHERE column LIKE 'XXXX_'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Puedes combinar Nnúmero de condiciones que utilizan operadores AND u OR. Aquí, XXXX podría ser cualquier valor numérico o de cadena.

Ejemplo

La siguiente tabla enumera una serie de ejemplos que muestran la parte DONDE que tiene una cláusula LIKE diferente con los operadores '%' y '_'.

No Señor.	Declaración y descripción
1	WHERE SALARY LIKE '200%' Encuentra cualquier valor que comience con 200
2	WHERE SALARY LIKE '%200%' Encuentra cualquier valor que tenga 200 en cualquier posición
3	WHERE SALARY LIKE '_00%' Encuentra cualquier valor que tenga 00 en la segunda y tercera posiciones
4	WHERE SALARY LIKE '2_%_%' Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de longitud
5	WHERE SALARY LIKE '%2' Encuentra cualquier valor que termine en 2
6	WHERE SALARY LIKE '_2%3' Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con un 3
7	WHERE SALARY LIKE '2___3' Encuentra cualquier valor en un número de cinco dígitos que comienza con 2 y termina con 3

Tomemos un ejemplo real, considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que mostrará todos los registros de la tabla EMPRESA donde EDAD comienza con 2.

sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que mostrará todos los registros de la tabla EMPRESA donde DIRECCIÓN tendrá un guión (-) dentro del texto.

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite GLOBEl operador se usa para hacer coincidir solo valores de texto con un patrón usando comodines. Si la expresión de búsqueda puede coincidir con la expresión del patrón, el operador GLOB devolverá verdadero, que es 1. A diferencia del operador LIKE, GLOB distingue entre mayúsculas y minúsculas y sigue la sintaxis de UNIX para especificar los siguientes comodines.

• El signo de asterisco (*)
• El signo de interrogación (?)

El signo de asterisco (*) representa cero o varios números o caracteres. El signo de interrogación (?) Representa un solo número o carácter.

Sintaxis

A continuación se muestra la sintaxis básica de * y ?.

SELECT FROM table_name
WHERE column GLOB 'XXXX*'
or 
SELECT FROM table_name
WHERE column GLOB '*XXXX*'
or
SELECT FROM table_name
WHERE column GLOB 'XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '????'

Puedes combinar Nnúmero de condiciones que utilizan operadores AND u OR. Aquí, XXXX podría ser cualquier valor numérico o de cadena.

Ejemplo

La siguiente tabla enumera una serie de ejemplos que muestran DONDE la parte tiene una cláusula LIKE diferente con '*' y '?' operadores.

No Señor.	Declaración y descripción
1	WHERE SALARY GLOB '200*' Encuentra cualquier valor que comience con 200
2	WHERE SALARY GLOB '*200*' Encuentra cualquier valor que tenga 200 en cualquier posición
3	WHERE SALARY GLOB '?00*' Encuentra cualquier valor que tenga 00 en la segunda y tercera posiciones
4	WHERE SALARY GLOB '2??' Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de longitud
5	WHERE SALARY GLOB '*2' Encuentra cualquier valor que termine en 2
6	WHERE SALARY GLOB '?2*3' Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con un 3
7	WHERE SALARY GLOB '2???3' Encuentra cualquier valor en un número de cinco dígitos que comience con 2 y termine con 3

Tomemos un ejemplo real, considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que mostrará todos los registros de la tabla EMPRESA, donde EDAD comienza con 2.

sqlite> SELECT * FROM COMPANY WHERE AGE  GLOB '2*';

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que mostrará todos los registros de la tabla EMPRESA donde DIRECCIÓN tendrá un guión (-) dentro del texto -

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  GLOB '*-*';

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite LIMIT La cláusula se usa para limitar la cantidad de datos devueltos por la instrucción SELECT.

Sintaxis

A continuación se muestra la sintaxis básica de la instrucción SELECT con la cláusula LIMIT.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows]

A continuación se muestra la sintaxis de la cláusula LIMIT cuando se usa junto con la cláusula OFFSET.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows] OFFSET [row num]

El motor SQLite devolverá filas a partir de la siguiente fila hasta el DESPLAZAMIENTO dado como se muestra a continuación en el último ejemplo.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación, se muestra un ejemplo, que limita la fila de la tabla de acuerdo con el número de filas que desea obtener de la tabla.

sqlite> SELECT * FROM COMPANY LIMIT 6;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

Sin embargo, en determinadas situaciones, es posible que deba recoger un conjunto de registros de un desplazamiento en particular. Aquí hay un ejemplo, que toma 3 registros a partir de la ^3ª posición.

sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ORDER BY La cláusula se utiliza para ordenar los datos en orden ascendente o descendente, según una o más columnas.

Sintaxis

A continuación se muestra la sintaxis básica de la cláusula ORDER BY.

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Puede utilizar más de una columna en la cláusula ORDER BY. Asegúrese de que cualquier columna que esté usando para ordenar, esa columna debe estar disponible en la lista de columnas.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo, que ordenará el resultado en orden descendente por SALARIO.

sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

A continuación se muestra un ejemplo, que clasificará el resultado en orden descendente por NOMBRE y SALARIO.

sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
5           David       27          Texas       85000.0
7           James       24          Houston     10000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0

A continuación se muestra un ejemplo, que clasificará el resultado en orden descendente por NOMBRE.

sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
1           Paul        32          California  20000.0
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
5           David       27          Texas       85000.0
2           Allen       25          Texas       15000.0

SQLite GROUP BY La cláusula se usa en colaboración con la instrucción SELECT para organizar datos idénticos en grupos.

La cláusula GROUP BY sigue a la cláusula WHERE en una instrucción SELECT y precede a la cláusula ORDER BY.

Sintaxis

A continuación se muestra la sintaxis básica de la cláusula GROUP BY. La cláusula GROUP BY debe seguir las condiciones de la cláusula WHERE y debe preceder a la cláusula ORDER BY si se utiliza una.

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

Puede utilizar más de una columna en la cláusula GROUP BY. Asegúrese de que cualquier columna que esté usando para agrupar, esa columna debe estar disponible en la lista de columnas.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Si desea saber el monto total del salario de cada cliente, la consulta GRUPO POR será la siguiente:

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

Esto producirá el siguiente resultado:

NAME        SUM(SALARY)
----------  -----------
Allen       15000.0
David       85000.0
James       10000.0
Kim         45000.0
Mark        65000.0
Paul        20000.0
Teddy       20000.0

Ahora, creemos tres registros más en la tabla EMPRESA utilizando las siguientes instrucciones INSERT.

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );

Ahora, nuestra tabla tiene los siguientes registros con nombres duplicados.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

Nuevamente, usemos la misma declaración para agrupar todos los registros usando la columna NOMBRE de la siguiente manera:

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

Esto producirá el siguiente resultado.

NAME        SUM(SALARY)
----------  -----------
Allen       15000
David       85000
James       20000
Kim         45000
Mark        65000
Paul        40000
Teddy       20000

Usemos la cláusula ORDER BY junto con la cláusula GROUP BY de la siguiente manera:

sqlite>  SELECT NAME, SUM(SALARY) 
   FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

Esto producirá el siguiente resultado.

NAME        SUM(SALARY)
----------  -----------
Teddy       20000
Paul        40000
Mark        65000
Kim         45000
James       20000
David       85000
Allen       15000

La cláusula HAVING le permite especificar condiciones que filtran qué resultados de grupo aparecen en los resultados finales.

La cláusula WHERE coloca condiciones en las columnas seleccionadas, mientras que la cláusula HAVING coloca condiciones en los grupos creados por la cláusula GROUP BY.

Sintaxis

A continuación se muestra la posición de la cláusula HAVING en una consulta SELECT.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

La cláusula HAVING debe seguir a la cláusula GROUP BY en una consulta y también debe preceder a la cláusula ORDER BY si se usa. A continuación se muestra la sintaxis de la instrucción SELECT, incluida la cláusula HAVING.

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

A continuación se muestra el ejemplo, que mostrará el registro para el que el número de nombres es inferior a 2.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000
5           David       27          Texas       85000
6           Kim         22          South-Hall  45000
4           Mark        25          Rich-Mond   65000
3           Teddy       23          Norway      20000

A continuación se muestra el ejemplo, que mostrará el registro para el que el número de nombres es mayor que 2.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
10          James       45          Texas       5000

SQLite DISTINCT La palabra clave se usa junto con la instrucción SELECT para eliminar todos los registros duplicados y obtener solo los registros únicos.

Puede haber una situación en la que tenga varios registros duplicados en una tabla. Al buscar dichos registros, tiene más sentido buscar solo registros únicos en lugar de buscar registros duplicados.

Sintaxis

A continuación se muestra la sintaxis básica de la palabra clave DISTINCT para eliminar registros duplicados.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

Primero, veamos cómo la siguiente consulta SELECT devuelve registros de salario duplicados.

sqlite> SELECT name FROM COMPANY;

Esto producirá el siguiente resultado.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
James

Ahora, usemos DISTINCT palabra clave con la consulta SELECT anterior y ver el resultado.

sqlite> SELECT DISTINCT name FROM COMPANY;

Esto producirá el siguiente resultado, donde no hay una entrada duplicada.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James

SQLite PRAGMAEl comando es un comando especial que se usa para controlar varias variables ambientales y banderas de estado dentro del entorno SQLite. Se puede leer un valor de PRAGMA y también se puede configurar según los requisitos.

Sintaxis

Para consultar el valor actual de PRAGMA, simplemente proporcione el nombre del pragma.

PRAGMA pragma_name;

Para establecer un nuevo valor para PRAGMA, use la siguiente sintaxis.

PRAGMA pragma_name = value;

El modo establecido puede ser el nombre o el equivalente entero, pero el valor devuelto siempre será un número entero.

auto_vacuum Pragma

los auto_vacuumpragma obtiene o establece el modo de vacío automático. A continuación se muestra la sintaxis simple.

PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;

Dónde mode puede ser cualquiera de los siguientes:

No Señor.	Valor y descripción de Pragma
1	0 or NONE La aspiración automática está desactivada. Este es el modo predeterminado, lo que significa que un archivo de base de datos nunca se reducirá de tamaño a menos que se vacíe manualmente mediante el comando VACUUM.
2	1 or FULL El vacío automático está habilitado y es completamente automático, lo que permite que un archivo de base de datos se reduzca a medida que se eliminan los datos de la base de datos.
3	2 or INCREMENTAL La aspiración automática está habilitada pero debe activarse manualmente. En este modo se mantienen los datos de referencia, pero las páginas libres simplemente se colocan en la lista libre. Estas páginas se pueden recuperar utilizando elincremental_vacuum pragma en cualquier momento.

cache_size Pragma

los cache_sizepragma puede obtener o establecer temporalmente el tamaño máximo de la caché de la página en memoria. A continuación se muestra la sintaxis simple.

PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;

los pagesvalor representa el número de páginas en la caché. La caché de páginas incorporada tiene un tamaño predeterminado de 2000 páginas y un tamaño mínimo de 10 páginas.

case_sensitive_like Pragma

los case_sensitive_likepragma controla la distinción entre mayúsculas y minúsculas de la expresión LIKE incorporada. De forma predeterminada, este pragma es falso, lo que significa que el operador LIKE incorporado ignora las mayúsculas y minúsculas. A continuación se muestra la sintaxis simple.

PRAGMA case_sensitive_like = [true|false];

No hay forma de consultar el estado actual de este pragma.

count_changes Pragma

count_changespragma obtiene o establece el valor de retorno de declaraciones de manipulación de datos como INSERT, UPDATE y DELETE. A continuación se muestra la sintaxis simple.

PRAGMA count_changes;
PRAGMA count_changes = [true|false];

De forma predeterminada, este pragma es falso y estas declaraciones no devuelven nada. Si se establece en verdadero, cada una de las declaraciones mencionadas devolverá una tabla de una columna y una fila que consta de un único valor entero que indica las filas afectadas por la operación.

database_list Pragma

los database_listpragma se utilizará para enumerar todas las bases de datos adjuntas. A continuación se muestra la sintaxis simple.

PRAGMA database_list;

Este pragma devolverá una tabla de tres columnas con una fila por base de datos abierta o adjunta, dando el número de secuencia de la base de datos, su nombre y el archivo asociado.

codificación de Pragma

los encodingpragma controla cómo se codifican y almacenan las cadenas en un archivo de base de datos. A continuación se muestra la sintaxis simple.

PRAGMA encoding;
PRAGMA encoding = format;

El valor de formato puede ser uno de UTF-8, UTF-16leo UTF-16be.

freelist_count Pragma

los freelist_countpragma devuelve un solo entero que indica cuántas páginas de la base de datos están marcadas actualmente como libres y disponibles. A continuación se muestra la sintaxis simple.

PRAGMA [database.]freelist_count;

El valor de formato puede ser uno de UTF-8, UTF-16leo UTF-16be.

index_info Pragma

los index_infopragma devuelve información sobre un índice de base de datos. A continuación se muestra la sintaxis simple.

PRAGMA [database.]index_info( index_name );

El conjunto de resultados contendrá una fila para cada columna contenida en el índice que da la secuencia de la columna, el índice de la columna dentro de la tabla y el nombre de la columna.

index_list Pragma

index_listpragma enumera todos los índices asociados con una tabla. A continuación se muestra la sintaxis simple.

PRAGMA [database.]index_list( table_name );

El conjunto de resultados contendrá una fila para cada índice con la secuencia del índice, el nombre del índice y la bandera que indica si el índice es único o no.

journal_mode Pragma

los journal_modepragma obtiene o establece el modo de diario que controla cómo se almacena y procesa el archivo de diario. A continuación se muestra la sintaxis simple.

PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;

Hay cinco modos de diario admitidos que se enumeran en la siguiente tabla.

No Señor.	Valor y descripción de Pragma
1	DELETE Este es el modo por defecto. Aquí, al final de una transacción, se elimina el archivo de diario.
2	TRUNCATE El archivo de diario se trunca a una longitud de cero bytes.
3	PERSIST El archivo de diario se deja en su lugar, pero el encabezado se sobrescribe para indicar que el diario ya no es válido.
4	MEMORY El registro de diario se guarda en la memoria, en lugar de en el disco.
5	OFF No se mantiene ningún registro de diario.

max_page_count Pragma

los max_page_countpragma obtiene o establece el número máximo de páginas permitido para una base de datos. A continuación se muestra la sintaxis simple.

PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;

El valor predeterminado es 1.073.741.823, que es una giga-página, lo que significa que si el tamaño de página predeterminado es de 1 KB, esto permite que las bases de datos crezcan hasta un terabyte.

page_count Pragma

los page_countpragma devuelve el número actual de páginas de la base de datos. A continuación se muestra la sintaxis simple:

PRAGMA [database.]page_count;

El tamaño del archivo de la base de datos debe ser page_count * page_size.

page_size Pragma

los page_sizepragma obtiene o establece el tamaño de las páginas de la base de datos. A continuación se muestra la sintaxis simple.

PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;

De forma predeterminada, los tamaños permitidos son 512, 1024, 2048, 4096, 8192, 16384 y 32768 bytes. La única forma de alterar el tamaño de la página en una base de datos existente es establecer el tamaño de la página y luego VACÍAR inmediatamente la base de datos.

parser_trace Pragma

los parser_tracepragma controla la impresión del estado de depuración mientras analiza los comandos SQL. A continuación se muestra la sintaxis simple.

PRAGMA parser_trace = [true|false];

De forma predeterminada, se establece en falso, pero cuando se habilita al establecerlo en verdadero, el analizador de SQL imprimirá su estado a medida que analiza los comandos SQL.

activadores_recursivos Pragma

los recursive_triggerspragma obtiene o establece la funcionalidad del disparador recursivo. Si los disparadores recursivos no están habilitados, una acción de disparador no disparará otro disparador. A continuación se muestra la sintaxis simple.

PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];

versión_esquema Pragma

los schema_versionpragma obtiene o establece el valor de la versión del esquema que se almacena en el encabezado de la base de datos. A continuación se muestra la sintaxis simple.

PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;

Este es un valor entero de 32 bits con signo que realiza un seguimiento de los cambios de esquema. Siempre que se ejecuta un comando de modificación de esquema (como CREAR ... o DROP ...), este valor se incrementa.

secure_delete Pragma

los secure_deletepragma se utiliza para controlar cómo se elimina el contenido de la base de datos. A continuación se muestra la sintaxis simple.

PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];

El valor predeterminado para el indicador de eliminación segura normalmente está desactivado, pero esto se puede cambiar con la opción de compilación SQLITE_SECURE_DELETE.

sql_trace Pragma

los sql_tracepragma se utiliza para volcar los resultados del rastreo de SQL en la pantalla. A continuación se muestra la sintaxis simple.

PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];

SQLite debe compilarse con la directiva SQLITE_DEBUG para que se incluya este pragma.

Pragma sincrónico

los synchronouspragma obtiene o establece el modo de sincronización de disco actual, que controla la agresividad con la que SQLite escribirá los datos hasta el almacenamiento físico. A continuación se muestra la sintaxis simple.

PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;

SQLite admite los siguientes modos de sincronización que se enumeran en la tabla.

No Señor.	Valor y descripción de Pragma
1	0 or OFF Sin sincronizaciones en absoluto
2	1 or NORMAL Sincronizar después de cada secuencia de operaciones críticas del disco
3	2 or FULL Sincronizar después de cada operación crítica del disco

temp_store Pragma

los temp_storepragma obtiene o establece el modo de almacenamiento utilizado por los archivos de base de datos temporales. A continuación se muestra la sintaxis simple.

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite admite los siguientes modos de almacenamiento.

No Señor.	Valor y descripción de Pragma
1	0 or DEFAULT Utilice el valor predeterminado en tiempo de compilación. Normalmente ARCHIVO.
2	1 or FILE Utilice almacenamiento basado en archivos.
3	2 or MEMORY Utilice almacenamiento basado en memoria.

temp_store_directory Pragma

los temp_store_directorypragma obtiene o establece la ubicación utilizada para los archivos de base de datos temporales. A continuación se muestra la sintaxis simple.

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

los user_versionpragma obtiene o establece el valor de versión definido por el usuario que se almacena en el encabezado de la base de datos. A continuación se muestra la sintaxis simple.

PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;

Este es un valor entero de 32 bits con signo, que el desarrollador puede establecer con el propósito de rastrear la versión.

writable_schema Pragma

los writable_schemapragma obtiene o establece la capacidad de modificar tablas del sistema. A continuación se muestra la sintaxis simple.

PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];

Si se establece este pragma, se pueden crear y modificar tablas que comienzan con sqlite_, incluida la tabla sqlite_master. Tenga cuidado al usar pragma porque puede provocar una corrupción completa de la base de datos.

Las restricciones son las reglas que se aplican a las columnas de datos de la tabla. Se utilizan para limitar el tipo de datos que pueden incluirse en una tabla. Esto asegura la precisión y confiabilidad de los datos en la base de datos.

Las restricciones pueden ser de nivel de columna o de tabla. Las restricciones a nivel de columna se aplican solo a una columna, mientras que las restricciones a nivel de tabla se aplican a toda la tabla.

A continuación, se muestran las restricciones de uso común disponibles en SQLite.

• NOT NULL Constraint - Asegura que una columna no pueda tener un valor NULL.

• DEFAULT Constraint : Proporciona un valor predeterminado para una columna cuando no se especifica ninguno.

• UNIQUE Constraint - Garantiza que todos los valores de una columna sean diferentes.

• PRIMARY Key - Identifica de forma única cada fila / registro en una tabla de base de datos.

• CHECK Constraint - Garantiza que todos los valores de una columna cumplan determinadas condiciones.

Restricción NOT NULL

De forma predeterminada, una columna puede contener valores NULL. Si no desea que una columna tenga un valor NULL, entonces debe definir dicha restricción en esta columna especificando que NULL ahora no está permitido para esa columna.

Un NULL no es lo mismo que sin datos, sino que representa datos desconocidos.

Ejemplo

Por ejemplo, la siguiente declaración SQLite crea una nueva tabla llamada EMPRESA y agrega cinco columnas, tres de las cuales, ID, NOMBRE y EDAD, especifican no aceptar NULL.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Restricción POR DEFECTO

La restricción DEFAULT proporciona un valor predeterminado a una columna cuando la instrucción INSERT INTO no proporciona un valor específico.

Ejemplo

Por ejemplo, la siguiente instrucción SQLite crea una nueva tabla llamada EMPRESA y agrega cinco columnas. Aquí, la columna SALARIO se establece en 5000,00 de forma predeterminada, por lo tanto, en caso de que la instrucción INSERT INTO no proporcione un valor para esta columna, esta columna se establecerá de forma predeterminada en 5000,00.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

Restricción ÚNICA

La restricción UNIQUE evita que dos registros tengan valores idénticos en una columna en particular. En la tabla EMPRESA, por ejemplo, es posible que desee evitar que dos o más personas tengan la misma edad.

Ejemplo

Por ejemplo, la siguiente instrucción SQLite crea una nueva tabla llamada EMPRESA y agrega cinco columnas. Aquí, la columna EDAD se establece en ÚNICA, por lo que no puede tener dos registros con la misma edad:

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

Restricción de CLAVE PRIMARIA

La restricción PRIMARY KEY identifica de forma única cada registro en una tabla de base de datos. Puede haber más columnas ÚNICAS, pero solo una clave principal en una tabla. Las claves primarias son importantes al diseñar las tablas de la base de datos. Las claves primarias son ID únicos.

Los usamos para referirnos a las filas de la tabla. Las claves primarias se convierten en claves externas en otras tablas, al crear relaciones entre tablas. Debido a una 'supervisión de codificación de larga data', las claves primarias pueden ser NULL en SQLite. Este no es el caso de otras bases de datos.

Una clave primaria es un campo en una tabla que identifica de forma única cada fila / registro en una tabla de base de datos. Las claves primarias deben contener valores únicos. Una columna de clave principal no puede tener valores NULL.

Una tabla solo puede tener una clave principal, que puede constar de uno o varios campos. Cuando se utilizan varios campos como clave principal, se denominancomposite key.

Si una tabla tiene una clave primaria definida en cualquier campo, entonces no puede tener dos registros que tengan el mismo valor de ese campo.

Ejemplo

Ya ha visto varios ejemplos arriba en los que hemos creado la tabla EMPRESA con el ID como clave principal.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

VERIFICAR Restricción

CHECK Constraint habilita una condición para verificar el valor que se ingresa en un registro. Si la condición se evalúa como falsa, el registro viola la restricción y no se ingresa en la tabla.

Ejemplo

Por ejemplo, el siguiente SQLite crea una nueva tabla llamada EMPRESA y agrega cinco columnas. Aquí, agregamos un CHEQUE con la columna SALARIO, para que no pueda tener SALARIO Cero.

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

Dejar caer la restricción

SQLite admite un subconjunto limitado de ALTER TABLE. El comando ALTER TABLE en SQLite permite al usuario cambiar el nombre de una tabla o agregar una nueva columna a una tabla existente. No es posible cambiar el nombre de una columna, eliminar una columna o agregar o eliminar restricciones de una tabla.

SQLite JoinsLa cláusula se utiliza para combinar registros de dos o más tablas en una base de datos. Un JOIN es un medio para combinar campos de dos tablas usando valores comunes a cada uno.

SQL define tres tipos principales de combinaciones:

• LA CRUZ SE UNE
• El INNER JOIN
• LA UNIÓN EXTERIOR

Antes de continuar, consideremos dos tablas EMPRESA y DEPARTAMENTO. Ya hemos visto instrucciones INSERT para completar la tabla EMPRESA. Así que asumamos la lista de registros disponibles en la tabla EMPRESA:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Otra tabla es DEPARTAMENTO con la siguiente definición:

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Aquí está la lista de instrucciones INSERT para completar la tabla DEPARTMENT:

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

Finalmente, tenemos la siguiente lista de registros disponibles en la tabla DEPARTAMENTO:

ID          DEPT        EMP_ID
----------  ----------  ----------
1           IT Billing  1
2           Engineering 2
3           Finance     7

LA CRUZ SE UNE

CROSS JOIN hace coincidir cada fila de la primera tabla con cada fila de la segunda tabla. Si las tablas de entrada tienen filas xey, respectivamente, la tabla resultante tendrá filas x * y. Debido a que los CROSS JOIN tienen el potencial de generar tablas extremadamente grandes, se debe tener cuidado de usarlos solo cuando sea apropiado.

A continuación se muestra la sintaxis de CROSS JOIN:

SELECT ... FROM table1 CROSS JOIN table2 ...

Según las tablas anteriores, puede escribir un CROSS JOIN de la siguiente manera:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

La consulta anterior producirá el siguiente resultado:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Paul        Engineering
7           Paul        Finance
1           Allen       IT Billing
2           Allen       Engineering
7           Allen       Finance
1           Teddy       IT Billing
2           Teddy       Engineering
7           Teddy       Finance
1           Mark        IT Billing
2           Mark        Engineering
7           Mark        Finance
1           David       IT Billing
2           David       Engineering
7           David       Finance
1           Kim         IT Billing
2           Kim         Engineering
7           Kim         Finance
1           James       IT Billing
2           James       Engineering
7           James       Finance

El INNER JOIN

INNER JOIN crea una nueva tabla de resultados combinando valores de columna de dos tablas (table1 y table2) según el predicado de unión. La consulta compara cada fila de table1 con cada fila de table2 para encontrar todos los pares de filas que satisfacen el predicado de unión. Cuando se satisface el predicado de unión, los valores de columna para cada par de filas coincidentes de A y B se combinan en una fila de resultados.

Una INNER JOIN es el tipo de unión más común y predeterminado. Puede utilizar la palabra clave INNER opcionalmente.

A continuación se muestra la sintaxis de INNER JOIN:

SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...

Para evitar la redundancia y mantener la redacción más corta, las condiciones INNER JOIN se pueden declarar con un USINGexpresión. Esta expresión especifica una lista de una o más columnas.

SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...

UN NATURAL JOIN es similar a un JOIN...USING, solo prueba automáticamente la igualdad entre los valores de cada columna que existe en ambas tablas -

SELECT ... FROM table1 NATURAL JOIN table2...

Según las tablas anteriores, puede escribir una INNER JOIN de la siguiente manera:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

La consulta anterior producirá el siguiente resultado:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
7           James       Finance

LA UNIÓN EXTERIOR

OUTER JOIN es una extensión de INNER JOIN. Aunque el estándar SQL define tres tipos de OUTER JOINs: LEFT, RIGHT y FULL, SQLite solo admiteLEFT OUTER JOIN.

Los OUTER JOIN tienen una condición que es idéntica a los INNER JOIN, expresados ​​con una palabra clave ON, USING o NATURAL. La tabla de resultados inicial se calcula de la misma manera. Una vez que se calcula el JOIN primario, un OUTER JOIN tomará las filas no unidas de una o ambas tablas, las rellenará con NULL y las agregará a la tabla resultante.

A continuación se muestra la sintaxis de LEFT OUTER JOIN:

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

Para evitar la redundancia y mantener la redacción más corta, las condiciones OUTER JOIN se pueden declarar con una expresión USING. Esta expresión especifica una lista de una o más columnas.

SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...

Según las tablas anteriores, puede escribir una combinación interna de la siguiente manera:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

La consulta anterior producirá el siguiente resultado:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
            Teddy
            Mark
            David
            Kim
7           James       Finance

SQLite UNION La cláusula / operador se utiliza para combinar los resultados de dos o más sentencias SELECT sin devolver filas duplicadas.

Para usar UNION, cada SELECT debe tener el mismo número de columnas seleccionadas, el mismo número de expresiones de columna, el mismo tipo de datos y tenerlas en el mismo orden, pero no es necesario que tengan la misma longitud.

Sintaxis

A continuación se muestra la sintaxis básica de UNION.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, (a) la tabla EMPRESA como sigue:

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) Otra tabla es DEPARTAMENTO como sigue:

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

Ahora unamos estas dos tablas usando la instrucción SELECT junto con la cláusula UNION de la siguiente manera:

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION
         
         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Esto producirá el siguiente resultado.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

La cláusula UNION ALL

El operador UNION ALL se utiliza para combinar los resultados de dos sentencias SELECT, incluidas las filas duplicadas.

Las mismas reglas que se aplican a UNION se aplican también al operador UNION ALL.

Sintaxis

A continuación se muestra la sintaxis básica de UNION ALL.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Ahora, unamos las dos tablas mencionadas anteriormente en nuestra declaración SELECT de la siguiente manera:

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION ALL

         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Esto producirá el siguiente resultado.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

SQLite NULLes el término utilizado para representar un valor perdido. Un valor NULO en una tabla es un valor en un campo que parece estar en blanco.

Un campo con un valor NULL es un campo sin valor. Es muy importante comprender que un valor NULL es diferente a un valor cero o un campo que contiene espacios.

Sintaxis

A continuación se muestra la sintaxis básica del uso NULL mientras creaba una mesa.

SQLite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Aquí, NOT NULLsignifica que la columna siempre debe aceptar un valor explícito del tipo de datos dado. Hay dos columnas en las que no usamos NOT NULL, lo que significa que estas columnas podrían ser NULL.

Un campo con un valor NULO es uno que se ha dejado en blanco durante la creación del registro.

Ejemplo

El valor NULO puede causar problemas a la hora de seleccionar datos, ya que al comparar un valor desconocido con cualquier otro valor, el resultado siempre es desconocido y no se incluye en los resultados finales. Considere la siguiente tabla, EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Usemos la instrucción UPDATE para establecer algunos valores anulables como NULL de la siguiente manera:

sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

Ahora, la tabla EMPRESA tendrá los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22
7           James       24

A continuación, veamos el uso de IS NOT NULL operador para enumerar todos los registros donde SALARIO no es NULO.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NOT NULL;

La declaración SQLite anterior producirá el siguiente resultado:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

A continuación se muestra el uso de IS NULL operador, que listará todos los registros donde SALARIO es NULO.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

La declaración SQLite anterior producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22
7           James       24

Puede cambiar el nombre de una tabla o columna temporalmente dando otro nombre, que se conoce como ALIAS. El uso de alias de tabla significa cambiar el nombre de una tabla en una declaración SQLite particular. El cambio de nombre es un cambio temporal y el nombre real de la tabla no cambia en la base de datos.

Los alias de columna se utilizan para cambiar el nombre de las columnas de una tabla con el propósito de una consulta SQLite en particular.

Sintaxis

A continuación se muestra la sintaxis básica de table alias.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

A continuación se muestra la sintaxis básica de column alias.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Ejemplo

Considere las siguientes dos tablas, (a) La tabla EMPRESA es la siguiente:

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) Otra tabla es DEPARTAMENTO como sigue:

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

Ahora, a continuación se muestra el uso de TABLE ALIAS donde usamos C y D como alias para las tablas COMPANY y DEPARTMENT respectivamente -

sqlite> SELECT C.ID, C.NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

La declaración SQLite anterior producirá el siguiente resultado:

ID          NAME        AGE         DEPT
----------  ----------  ----------  ----------
1           Paul        32          IT Billing
2           Allen       25          Engineering
3           Teddy       23          Engineering
4           Mark        25          Finance
5           David       27          Engineering
6           Kim         22          Finance
7           James       24          Finance

Considere un ejemplo para el uso de COLUMN ALIAS donde COMPANY_ID es un alias de la columna de ID y COMPANY_NAME es un alias de la columna de nombre.

sqlite> SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

La declaración SQLite anterior producirá el siguiente resultado:

COMPANY_ID  COMPANY_NAME  AGE         DEPT
----------  ------------  ----------  ----------
1           Paul          32          IT Billing
2           Allen         25          Engineering
3           Teddy         23          Engineering
4           Mark          25          Finance
5           David         27          Engineering
6           Kim           22          Finance
7           James         24          Finance

SQLite Triggersson funciones de devolución de llamada de la base de datos, que se ejecutan / invocan automáticamente cuando se produce un evento de base de datos específico. Los siguientes son los puntos importantes sobre los desencadenantes de SQLite:

• Se puede especificar que el disparador de SQLite se active siempre que se produzca un DELETE, INSERT o UPDATE de una tabla de base de datos en particular o cuando se produzca una ACTUALIZACIÓN en una o más columnas especificadas de una tabla.

• En este momento, SQLite solo admite activadores FOR CADA FILA, no activadores FOR CADA DECLARACIÓN. Por lo tanto, especificar explícitamente PARA CADA FILA es opcional.

• Tanto la cláusula WHEN como las acciones desencadenantes pueden acceder a elementos de la fila que se inserta, elimina o actualiza utilizando referencias del formulario NEW.column-name y OLD.column-name, donde nombre-columna es el nombre de una columna de la tabla con la que está asociado el desencadenador.

• Si se proporciona una cláusula WHEN, las sentencias SQL especificadas solo se ejecutan para las filas para las que la cláusula WHEN es verdadera. Si no se proporciona una cláusula WHEN, las sentencias SQL se ejecutan para todas las filas.

• La palabra clave BEFORE o AFTER determina cuándo se ejecutarán las acciones de activación en relación con la inserción, modificación o eliminación de la fila asociada.

• Los activadores se eliminan automáticamente cuando se elimina la tabla a la que están asociados.

• La tabla que se va a modificar debe existir en la misma base de datos que la tabla o vista a la que se adjunta el disparador y se debe usar solo tablename no database.tablename.

• Se puede usar una función SQL especial RAISE () dentro de un programa de activación para generar una excepción.

Sintaxis

A continuación se muestra la sintaxis básica para crear un trigger.

CREATE TRIGGER trigger_name [BEFORE|AFTER] event_name 
ON table_name
BEGIN
 -- Trigger logic goes here....
END;

Aquí, event_namepodría ser INSERT, DELETE y UPDATE la operación de base de datos en la tabla mencionadatable_name. Opcionalmente, puede especificar PARA CADA FILA después del nombre de la tabla.

A continuación se muestra la sintaxis para crear un desencadenante en una operación UPDATE en una o más columnas especificadas de una tabla.

CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name 
ON table_name
BEGIN
   -- Trigger logic goes here....
END;

Ejemplo

Consideremos un caso en el que queremos mantener una prueba de auditoría para cada registro que se inserta en la tabla EMPRESA, que creamos de la siguiente manera (elimine la tabla EMPRESA si ya la tiene).

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Para mantener la prueba de auditoría, crearemos una nueva tabla llamada AUDIT donde se insertarán los mensajes de registro, siempre que haya una entrada en la tabla EMPRESA para un nuevo registro.

sqlite> CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

Aquí, ID es el ID de registro de AUDIT, y EMP_ID es el ID que vendrá de la tabla COMPANY y DATE mantendrá la marca de tiempo cuando se creará el registro en la tabla COMPANY. Ahora creemos un disparador en la tabla EMPRESA de la siguiente manera:

sqlite> CREATE TRIGGER audit_log AFTER INSERT 
ON COMPANY
BEGIN
   INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, datetime('now'));
END;

Ahora, comenzaremos el trabajo real. Comencemos a insertar un registro en la tabla EMPRESA, lo que debería resultar en la creación de un registro de auditoría en la tabla AUDIT. Cree un registro en la tabla EMPRESA de la siguiente manera:

sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

Esto creará un registro en la tabla EMPRESA, que es el siguiente:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

Al mismo tiempo, se creará un registro en la tabla AUDIT. Este registro es el resultado de un desencadenante, que hemos creado en la operación INSERTAR en la tabla EMPRESA. Del mismo modo, puede crear sus activadores en las operaciones ACTUALIZAR y ELIMINAR según sus requisitos.

EMP_ID      ENTRY_DATE
----------  -------------------
1           2013-04-05 06:26:00

Listado de activadores

Puede enumerar todos los desencadenantes de sqlite_master tabla de la siguiente manera:

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger';

La declaración SQLite anterior enumerará solo una entrada de la siguiente manera:

name
----------
audit_log

Si desea enumerar los desencadenadores en una tabla en particular, use la cláusula AND con el nombre de la tabla de la siguiente manera:

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger' AND tbl_name = 'COMPANY';

La declaración SQLite anterior también enumerará solo una entrada de la siguiente manera:

name
----------
audit_log

Soltar disparadores

A continuación se muestra el comando DROP, que se puede usar para eliminar un disparador existente.

sqlite> DROP TRIGGER trigger_name;

Los índices son tablas de búsqueda especiales que el motor de búsqueda de la base de datos puede utilizar para acelerar la recuperación de datos. En pocas palabras, unindexes un puntero a datos en una tabla. Un índice en una base de datos es muy similar a un índice al final de un libro.

Por ejemplo, si desea hacer referencia a todas las páginas de un libro que tratan un tema determinado, primero debe consultar el índice, que enumera todos los temas en orden alfabético y luego se hace referencia a uno o más números de página específicos.

Un índice ayuda a acelerar las consultas SELECT y las cláusulas WHERE, pero ralentiza la entrada de datos, con declaraciones UPDATE e INSERT. Los índices se pueden crear o eliminar sin ningún efecto sobre los datos.

La creación de un índice implica la instrucción CREATE INDEX, que le permite nombrar el índice, especificar la tabla y qué columna o columnas indexar, e indicar si el índice está en orden ascendente o descendente.

Los índices también pueden ser únicos, similar a la restricción ÚNICA, en el sentido de que el índice evita entradas duplicadas en la columna o combinación de columnas en las que hay un índice.

El comando CREATE INDEX

A continuación se muestra la sintaxis básica de CREATE INDEX.

CREATE INDEX index_name ON table_name;

Índices de una sola columna

Un índice de una sola columna es aquel que se crea basándose en una sola columna de la tabla. La sintaxis básica es la siguiente:

CREATE INDEX index_name
ON table_name (column_name);

Índices únicos

Los índices únicos se utilizan no solo para el rendimiento, sino también para la integridad de los datos. Un índice único no permite que se inserten valores duplicados en la tabla. La sintaxis básica es la siguiente:

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Índices compuestos

Un índice compuesto es un índice en dos o más columnas de una tabla. La sintaxis básica es la siguiente:

CREATE INDEX index_name
on table_name (column1, column2);

Ya sea para crear un índice de una sola columna o un índice compuesto, tenga en cuenta las columnas que puede usar con mucha frecuencia en la cláusula WHERE de una consulta como condiciones de filtro.

Si solo se usa una columna, la opción debe ser un índice de una sola columna. Si hay dos o más columnas que se utilizan con frecuencia en la cláusula WHERE como filtros, el índice compuesto sería la mejor opción.

Índices implícitos

Los índices implícitos son índices que el servidor de bases de datos crea automáticamente cuando se crea un objeto. Los índices se crean automáticamente para restricciones de clave primaria y restricciones únicas.

Example

A continuación se muestra un ejemplo en el que crearemos un índice en la tabla EMPRESA para la columna de salario:

sqlite> CREATE INDEX salary_index ON COMPANY (salary);

Ahora, enumeremos todos los índices disponibles en la tabla EMPRESA usando .indices comando de la siguiente manera:

sqlite> .indices COMPANY

Esto producirá el siguiente resultado, donde sqlite_autoindex_COMPANY_1 es un índice implícito que se creó cuando se creó la tabla.

salary_index
sqlite_autoindex_COMPANY_1

Puede enumerar toda la base de datos de índices de la siguiente manera:

sqlite> SELECT * FROM sqlite_master WHERE type = 'index';

El comando DROP INDEX

Se puede eliminar un índice usando SQLite DROPmando. Se debe tener cuidado al eliminar un índice porque el rendimiento se puede ralentizar o mejorar.

A continuación, la sintaxis básica es la siguiente:

DROP INDEX index_name;

Puede utilizar la siguiente declaración para eliminar el índice creado anteriormente.

sqlite> DROP INDEX salary_index;

¿Cuándo se deben evitar los índices?

Aunque los índices están destinados a mejorar el rendimiento de una base de datos, hay ocasiones en las que deben evitarse. Las siguientes pautas indican cuándo debe reconsiderarse el uso de un índice.

Los índices no deben usarse en:

• Mesas pequeñas.
• Tablas que tienen operaciones de inserción o actualización por lotes grandes y frecuentes.
• Columnas que contienen una gran cantidad de valores NULL.
• Columnas que se manipulan con frecuencia.

La cláusula "INDEXED BY index-name" especifica que el índice nombrado debe usarse para buscar valores en la tabla anterior.

Si index-name no existe o no se puede utilizar para la consulta, la preparación de la declaración SQLite falla.

La cláusula "NOT INDEXED" especifica que no se utilizará ningún índice al acceder a la tabla anterior, incluidos los índices implícitos creados por las restricciones UNIQUE y PRIMARY KEY.

Sin embargo, la TECLA PRIMARIA INTEGER todavía se puede utilizar para buscar entradas incluso cuando se especifica "NO INDICE".

Sintaxis

A continuación se muestra la sintaxis de la cláusula INDEXED BY y se puede utilizar con la instrucción DELETE, UPDATE o SELECT.

SELECT|DELETE|UPDATE column1, column2...
INDEXED BY (index_name)
table_name
WHERE (CONDITION);

Ejemplo

Considere la tabla EMPRESA Crearemos un índice y lo usaremos para realizar la operación INDEXADO POR.

sqlite> CREATE INDEX salary_index ON COMPANY(salary);
sqlite>

Ahora, seleccionando los datos de la tabla EMPRESA, puede usar la cláusula INDEXED BY de la siguiente manera:

sqlite> SELECT * FROM COMPANY INDEXED BY salary_index WHERE salary > 5000;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ALTER TABLEEl comando modifica una tabla existente sin realizar un volcado completo y recargar los datos. Puede cambiar el nombre de una tabla usando la instrucción ALTER TABLE y se pueden agregar columnas adicionales en una tabla existente usando la instrucción ALTER TABLE.

No hay otra operación compatible con el comando ALTER TABLE en SQLite, excepto cambiar el nombre de una tabla y agregar una columna en una tabla existente.

Sintaxis

A continuación se muestra la sintaxis básica de ALTER TABLE para CAMBIAR EL NOMBRE de una tabla existente.

ALTER TABLE database_name.table_name RENAME TO new_table_name;

A continuación se muestra la sintaxis básica de ALTER TABLE para agregar una nueva columna en una tabla existente.

ALTER TABLE database_name.table_name ADD COLUMN column_def...;

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Ahora, intentemos cambiar el nombre de esta tabla usando la instrucción ALTER TABLE de la siguiente manera:

sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;

La declaración SQLite anterior cambiará el nombre de la tabla COMPANY a OLD_COMPANY. Ahora, intentemos agregar una nueva columna en la tabla OLD_COMPANY de la siguiente manera:

sqlite> ALTER TABLE OLD_COMPANY ADD COLUMN SEX char(1);

La tabla EMPRESA ahora ha cambiado y la siguiente será la salida de la instrucción SELECT.

ID          NAME        AGE         ADDRESS     SALARY      SEX
----------  ----------  ----------  ----------  ----------  ---
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Cabe señalar que la columna recién agregada se llena con valores NULL.

Desafortunadamente, no tenemos el comando TRUNCATE TABLE en SQLite, pero puede usar SQLite DELETE comando para eliminar datos completos de una tabla existente, aunque se recomienda utilizar el comando DROP TABLE para eliminar la tabla completa y volver a crearla.

Sintaxis

A continuación se muestra la sintaxis básica del comando DELETE.

sqlite> DELETE FROM table_name;

A continuación se muestra la sintaxis básica de DROP TABLE.

sqlite> DROP TABLE table_name;

Si está utilizando el comando DELETE TABLE para eliminar todos los registros, se recomienda utilizar VACUUM comando para limpiar el espacio no utilizado.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra el ejemplo para truncar la tabla anterior:

SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;

Ahora, la tabla EMPRESA se trunca por completo y nada será el resultado de la instrucción SELECT.

Una vista no es más que una declaración SQLite que se almacena en la base de datos con un nombre asociado. En realidad, es una composición de una tabla en forma de una consulta SQLite predefinida.

Una vista puede contener todas las filas de una tabla o filas seleccionadas de una o más tablas. Se puede crear una vista a partir de una o varias tablas, lo que depende de la consulta SQLite escrita para crear una vista.

Vistas que son una especie de tablas virtuales, permiten a los usuarios:

• Estructurar los datos de una manera que los usuarios o clases de usuarios encuentren natural o intuitiva.

• Restrinja el acceso a los datos de modo que un usuario solo pueda ver datos limitados en lugar de una tabla completa.

• Resuma datos de varias tablas, que se pueden utilizar para generar informes.

Las vistas de SQLite son de solo lectura y, por lo tanto, es posible que no pueda ejecutar una instrucción DELETE, INSERT o UPDATE en una vista. Sin embargo, puede crear un desencadenador en una vista que se activa en un intento de ELIMINAR, INSERTAR o ACTUALIZAR una vista y hacer lo que necesite en el cuerpo del desencadenador.

Creando Vistas

Las vistas de SQLite se crean utilizando CREATE VIEWdeclaración. Las vistas de SQLite se pueden crear a partir de una sola tabla, varias tablas u otra vista.

A continuación se muestra la sintaxis básica de CREATE VIEW.

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Puede incluir varias tablas en su instrucción SELECT de manera similar a como las usa en una consulta SELECT de SQL normal. Si la palabra clave TEMP o TEMPORARY opcional está presente, la vista se creará en la base de datos temporal.

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

A continuación se muestra un ejemplo para crear una vista desde la tabla EMPRESA. Esta vista se utilizará para tener solo unas pocas columnas de la tabla EMPRESA.

sqlite> CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

Ahora puede consultar COMPANY_VIEW de forma similar a como consulta una tabla real. A continuación se muestra un ejemplo:

sqlite> SELECT * FROM COMPANY_VIEW;

Esto producirá el siguiente resultado.

ID          NAME        AGE
----------  ----------  ----------
1           Paul        32
2           Allen       25
3           Teddy       23
4           Mark        25
5           David       27
6           Kim         22
7           James       24

Descartar vistas

Para eliminar una vista, simplemente use la instrucción DROP VIEW con el view_name. La sintaxis básica de DROP VIEW es la siguiente:

sqlite> DROP VIEW view_name;

El siguiente comando eliminará la vista COMPANY_VIEW, que creamos en la última sección.

sqlite> DROP VIEW COMPANY_VIEW;

Una transacción es una unidad de trabajo que se realiza en una base de datos. Las transacciones son unidades o secuencias de trabajo realizadas en un orden lógico, ya sea de forma manual por un usuario o automáticamente por algún tipo de programa de base de datos.

Una transacción es la propagación de uno o más cambios en la base de datos. Por ejemplo, si está creando, actualizando o eliminando un registro de la tabla, entonces está realizando una transacción en la tabla. Es importante controlar las transacciones para garantizar la integridad de los datos y manejar los errores de la base de datos.

Prácticamente, agrupará muchas consultas SQLite en un grupo y las ejecutará todas juntas como parte de una transacción.

Propiedades de las transacciones

Las transacciones tienen las siguientes cuatro propiedades estándar, generalmente denominadas con el acrónimo ACID.

• Atomicity- Asegura que todas las operaciones dentro de la unidad de trabajo se completen con éxito; de lo contrario, la transacción se aborta en el punto de falla y las operaciones anteriores se revierten a su estado anterior.

• Consistency - Garantiza que la base de datos cambie correctamente de estado tras una transacción confirmada con éxito.

• Isolation - Permite que las transacciones funcionen de forma independiente y transparente entre sí.

• Durability - Asegura que el resultado o efecto de una transacción comprometida persista en caso de falla del sistema.

Control de transacciones

A continuación se muestran los siguientes comandos que se utilizan para controlar las transacciones:

• BEGIN TRANSACTION - Para iniciar una transacción.

• COMMIT - Para guardar los cambios, alternativamente puede usar END TRANSACTION mando.

• ROLLBACK - Revertir los cambios.

Los comandos de control transaccional solo se utilizan con los comandos DML INSERT, UPDATE y DELETE. No se pueden usar al crear tablas o descartarlas porque estas operaciones se confirman automáticamente en la base de datos.

Comando COMENZAR TRANSACCIÓN

Las transacciones se pueden iniciar usando BEGIN TRANSACTION o simplemente el comando BEGIN. Estas transacciones generalmente persisten hasta que se encuentra el siguiente comando COMMIT o ROLLBACK. Sin embargo, una transacción también se ROLLBACK si la base de datos se cierra o si ocurre un error. A continuación se muestra la sintaxis simple para iniciar una transacción.

BEGIN;
or 
BEGIN TRANSACTION;

Comando COMMIT

El comando COMMIT es el comando transaccional que se utiliza para guardar los cambios invocados por una transacción en la base de datos.

El comando COMMIT guarda todas las transacciones en la base de datos desde el último comando COMMIT o ROLLBACK.

A continuación se muestra la sintaxis del comando COMMIT.

COMMIT;
or
END TRANSACTION;

Comando ROLLBACK

El comando ROLLBACK es el comando transaccional que se utiliza para deshacer transacciones que aún no se han guardado en la base de datos.

El comando ROLLBACK solo se puede utilizar para deshacer transacciones desde que se emitió el último comando COMMIT o ROLLBACK.

A continuación se muestra la sintaxis del comando ROLLBACK.

ROLLBACK;

Example

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Ahora, comencemos una transacción y eliminemos registros de la tabla que tengan edad = 25. Luego, use el comando ROLLBACK para deshacer todos los cambios.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

Ahora, si marca la tabla EMPRESA, todavía tiene los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Comencemos otra transacción y eliminemos registros de la tabla que tengan edad = 25 y finalmente usamos el comando COMMIT para confirmar todos los cambios.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

Si ahora marca la tabla EMPRESA, todavía tiene los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Una subconsulta o consulta interna o consulta anidada es una consulta dentro de otra consulta SQLite e incrustada dentro de la cláusula WHERE.

Una subconsulta se utiliza para devolver datos que se utilizarán en la consulta principal como condición para restringir aún más los datos que se recuperarán.

Las subconsultas se pueden usar con las instrucciones SELECT, INSERT, UPDATE y DELETE junto con los operadores como =, <,>,> =, <=, IN, BETWEEN, etc.

Hay algunas reglas que las subconsultas deben seguir:

• Las subconsultas deben ir entre paréntesis.

• Una subconsulta solo puede tener una columna en la cláusula SELECT, a menos que haya varias columnas en la consulta principal para que la subconsulta compare sus columnas seleccionadas.

• Un ORDER BY no se puede usar en una subconsulta, aunque la consulta principal puede usar un ORDER BY. GROUP BY se puede usar para realizar la misma función que ORDER BY en una subconsulta.

• Las subconsultas que devuelven más de una fila solo se pueden usar con varios operadores de valor, como el operador IN.

• El operador BETWEEN no se puede utilizar con una subconsulta; sin embargo, BETWEEN se puede utilizar dentro de la subconsulta.

Subconsultas con instrucción SELECT

Las subconsultas se utilizan con mayor frecuencia con la instrucción SELECT. La sintaxis básica es la siguiente:

SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
   (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

Ejemplo

Considere la tabla EMPRESA con los siguientes registros.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Ahora, verifiquemos la siguiente subconsulta con la instrucción SELECT.

sqlite> SELECT * 
   FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY 
      WHERE SALARY > 45000) ;

Esto producirá el siguiente resultado.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

Subconsultas con instrucción INSERT

Las subconsultas también se pueden usar con instrucciones INSERT. La instrucción INSERT utiliza los datos devueltos por la subconsulta para insertarlos en otra tabla. Los datos seleccionados en la subconsulta se pueden modificar con cualquiera de las funciones de carácter, fecha o número.

A continuación, la sintaxis básica es la siguiente:

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Ejemplo

Considere una tabla COMPANY_BKP con una estructura similar a la tabla COMPANY y se puede crear usando la misma CREATE TABLE usando COMPANY_BKP como el nombre de la tabla. Para copiar la tabla COMPAÑÍA completa en COMPANY_BKP, la siguiente es la sintaxis:

sqlite> INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY) ;

Subconsultas con instrucción UPDATE

La subconsulta se puede utilizar junto con la instrucción UPDATE. Se pueden actualizar una o varias columnas en una tabla cuando se usa una subconsulta con la instrucción UPDATE.

A continuación, la sintaxis básica es la siguiente:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Ejemplo

Suponiendo que tenemos la tabla COMPANY_BKP disponible, que es una copia de seguridad de la tabla COMPANY.

El siguiente ejemplo actualiza SALARIO 0,50 veces en la tabla EMPRESA para todos los clientes cuya EDAD sea mayor o igual a 27.

sqlite> UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Esto afectaría a dos filas y finalmente la tabla EMPRESA tendría los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  10000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Subconsultas con instrucción DELETE

La subconsulta se puede usar junto con la instrucción DELETE como con cualquier otra instrucción mencionada anteriormente.

A continuación, la sintaxis básica es la siguiente:

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Ejemplo

Suponiendo que tenemos la tabla COMPANY_BKP disponible, que es una copia de seguridad de la tabla COMPANY.

El siguiente ejemplo elimina registros de la tabla EMPRESA para todos los clientes cuya EDAD sea mayor o igual a 27.

sqlite> DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
   WHERE AGE > 27 );

Esto afectará a dos filas y finalmente la tabla EMPRESA tendrá los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite AUTOINCREMENTes una palabra clave utilizada para incrementar automáticamente un valor de un campo en la tabla. Podemos incrementar automáticamente el valor de un campo usandoAUTOINCREMENT palabra clave al crear una tabla con un nombre de columna específico para incrementar automáticamente.

La palabra clave AUTOINCREMENT solo se puede utilizar con el campo INTEGER.

Sintaxis

El uso básico de AUTOINCREMENT La palabra clave es la siguiente:

CREATE TABLE table_name(
   column1 INTEGER AUTOINCREMENT,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Ejemplo

Considere la tabla EMPRESA que se creará de la siguiente manera:

sqlite> CREATE TABLE COMPANY(
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Ahora, inserte los siguientes registros en la tabla EMPRESA:

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );

Esto insertará 7 tuplas en la tabla EMPRESA y EMPRESA tendrá los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Si toma la entrada del usuario a través de una página web y la inserta en una base de datos SQLite, existe la posibilidad de que se haya quedado abierto a un problema de seguridad conocido como inyección SQL. En este capítulo, aprenderá cómo ayudar a evitar que esto suceda y cómo proteger sus scripts y declaraciones SQLite.

La inyección generalmente ocurre cuando le pides a un usuario una entrada, como su nombre, y en lugar de un nombre, te dan una declaración SQLite que, sin saberlo, ejecutarás en tu base de datos.

Nunca confíe en los datos proporcionados por el usuario, procese estos datos solo después de la validación; como regla, esto se hace mediante la coincidencia de patrones. En el siguiente ejemplo, el nombre de usuario está restringido a caracteres alfanuméricos más guión bajo y a una longitud de entre 8 y 20 caracteres; modifique estas reglas según sea necesario.

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)){ $db = new SQLiteDatabase('filename');
   $result = @$db->query("SELECT * FROM users WHERE username = $matches[0]");
} else {
   echo "username not accepted";
}

Para demostrar el problema, considere este extracto:

$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");

Se supone que la llamada a la función recupera un registro de la tabla de usuarios donde la columna de nombre coincide con el nombre especificado por el usuario. Bajo circunstancias normales,$namesolo contendría caracteres alfanuméricos y quizás espacios, como la cadena ilia. Sin embargo, en este caso, al agregar una consulta completamente nueva a $ name, la llamada a la base de datos se convierte en un desastre: la consulta DELETE inyectada elimina todos los registros de los usuarios.

Hay interfaces de bases de datos que no permiten apilar consultas o ejecutar múltiples consultas en una sola llamada de función. Si intenta apilar consultas, la llamada falla, pero SQLite y PostgreSQL realizan felizmente consultas apiladas, ejecutan todas las consultas proporcionadas en una cadena y crean un problema de seguridad grave.

Prevención de la inyección de SQL

Puede manejar todos los caracteres de escape de forma inteligente en lenguajes de script como PERL y PHP. El lenguaje de programación PHP proporciona la funciónstring sqlite_escape_string() para escapar de los caracteres de entrada que son especiales para SQLite.

if (get_magic_quotes_gpc()) {
   $name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");

Aunque la codificación hace que sea seguro insertar los datos, proporcionará comparaciones de texto simples y LIKE cláusulas en sus consultas inutilizables para las columnas que contienen los datos binarios.

Note - addslashes()NO debe usarse para citar sus cadenas para consultas SQLite; dará lugar a resultados extraños al recuperar sus datos.

La declaración SQLite puede ir precedida por la palabra clave "EXPLICAR" o por la frase "EXPLICAR EL PLAN DE CONSULTA" que se utiliza para describir los detalles de una tabla.

Cualquiera de las modificaciones hace que la declaración SQLite se comporte como una consulta y devuelva información sobre cómo habría operado la declaración SQLite si se hubiera omitido la palabra clave o frase EXPLAIN.

• La salida de EXPLAIN y EXPLAIN QUERY PLAN está destinada únicamente al análisis interactivo y la resolución de problemas.

• Los detalles del formato de salida están sujetos a cambios de una versión de SQLite a la siguiente.

• Las aplicaciones no deben utilizar EXPLAIN o EXPLAIN QUERY PLAN ya que su comportamiento exacto es variable y solo está parcialmente documentado.

Sintaxis

sintaxis para EXPLAIN es como sigue -

EXPLAIN [SQLite Query]

sintaxis para EXPLAIN QUERY PLAN es como sigue -

EXPLAIN  QUERY PLAN [SQLite Query]

Ejemplo

Considere la tabla EMPRESA con los siguientes registros:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Ahora, verifiquemos la siguiente subconsulta con la instrucción SELECT:

sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;

Esto producirá el siguiente resultado.

addr        opcode      p1          p2          p3
----------  ----------  ----------  ----------  ----------
0           Goto        0           19
1           Integer     0           0
2           OpenRead    0           8
3           SetNumColu  0           5
4           Rewind      0           17
5           Column      0           4
6           RealAffini  0           0
7           Integer     20000       0
8           Lt          357         16          collseq(BI
9           Rowid       0           0
10          Column      0           1
11          Column      0           2
12          Column      0           3
13          Column      0           4
14          RealAffini  0           0
15          Callback    5           0
16          Next        0           5
17          Close       0           0
18          Halt        0           0
19          Transactio  0           0
20          VerifyCook  0           38
21          Goto        0           1
22          Noop        0           0

Ahora, revisemos lo siguiente Explain Query Plan con instrucción SELECT -

SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;

order       from        detail
----------  ----------  -------------
0           0           TABLE COMPANY

El comando VACUUM limpia la base de datos principal copiando su contenido en un archivo de base de datos temporal y volviendo a cargar el archivo de base de datos original desde la copia. Esto elimina las páginas libres, alinea los datos de la tabla para que sean contiguos y limpia la estructura de archivos de la base de datos.

El comando VACUUM puede cambiar el ROWID de las entradas en tablas que no tienen una CLAVE PRIMARIA INTEGER explícita. El comando VACUUM solo funciona en la base de datos principal. No es posible aspirar un archivo de base de datos adjunto.

El comando VACUUM fallará si hay una transacción activa. El comando VACUUM no es una operación para las bases de datos en memoria. A medida que el comando VACUUM reconstruye el archivo de la base de datos desde cero, VACUUM también se puede utilizar para modificar muchos parámetros de configuración específicos de la base de datos.

VACÍO manual

A continuación se muestra una sintaxis simple para emitir un comando VACUUM para toda la base de datos desde el símbolo del sistema:

$sqlite3 database_name "VACUUM;"

Puede ejecutar VACUUM desde el indicador de SQLite, así como lo siguiente:

sqlite> VACUUM;

También puede ejecutar VACUUM en una mesa en particular de la siguiente manera:

sqlite> VACUUM table_name;

Auto-VACÍO

SQLite Auto-VACUUM no hace lo mismo que VACUUM, sino que solo mueve las páginas libres al final de la base de datos, lo que reduce el tamaño de la base de datos. Al hacerlo, puede fragmentar significativamente la base de datos, mientras que VACUUM garantiza la desfragmentación. Por lo tanto, Auto-VACUUM solo mantiene la base de datos pequeña.

Puede habilitar / deshabilitar la aspiración automática de SQLite mediante los siguientes pragmas que se ejecutan en el indicador de SQLite:

sqlite> PRAGMA auto_vacuum = NONE; -- 0 means disable auto vacuum
sqlite> PRAGMA auto_vacuum = FULL; -- 1 means enable full auto vacuum
sqlite> PRAGMA auto_vacuum = INCREMENTAL; -- 2 means enable incremental vacuum

Puede ejecutar el siguiente comando desde el símbolo del sistema para verificar la configuración de vacío automático:

$sqlite3 database_name "PRAGMA auto_vacuum;"

SQLite admite cinco funciones de fecha y hora de la siguiente manera:

No Señor.	Función	Ejemplo
1	fecha (cadena de tiempo, modificadores ...)	Esto devuelve la fecha en este formato: AAAA-MM-DD
2	tiempo (cadena de tiempo, modificadores ...)	Esto devuelve la hora como HH: MM: SS
3	fecha y hora (cadena de tiempo, modificadores ...)	Esto devuelve AAAA-MM-DD HH: MM: SS
4	julianday (cadena de tiempo, modificadores ...)	Esto devuelve el número de días desde el mediodía en Greenwich el 24 de noviembre de 4714 a. C.
5	strftime (cadena de tiempo, modificadores ...)	Esto devuelve la fecha formateada de acuerdo con la cadena de formato especificada como el primer argumento formateado según los formateadores que se explican a continuación.

Las cinco funciones de fecha y hora anteriores toman una cadena de tiempo como argumento. La cadena de tiempo va seguida de cero o más modificadores. La función strftime () también toma una cadena de formato como primer argumento. La siguiente sección le brindará detalles sobre los diferentes tipos de cadenas de tiempo y modificadores.

Cadenas de tiempo

Una cadena de tiempo puede tener cualquiera de los siguientes formatos:

No Señor.	Cadena de tiempo	Ejemplo
1	AAAA-MM-DD	2010-12-30
2	AAAA-MM-DD HH: MM	2010-12-30 12:10
3	AAAA-MM-DD HH: MM: SS.SSS	2010-12-30 12: 10: 04.100
4	DD-MM-AAAA HH: MM	30-12-2010 12:10
5	HH: MM	12:10
6	AAAA-MM-DDTHH: MM	2010-12-30 12:10
7	HH: MM: SS	12:10:01
8	AAAAMMDD HHMMSS	20101230 121001
9	ahora	2013-05-07

Puede utilizar la "T" como un carácter literal que separa la fecha y la hora.

Modificadores

La cadena de tiempo puede ir seguida de cero o más modificadores que alterarán la fecha y / o la hora devuelta por cualquiera de las cinco funciones anteriores. Los modificadores se aplican de izquierda a derecha.

Los siguientes modificadores están disponibles en SQLite:

• NNN días
• NNN horas
• NNN minutos
• NNN.NNNN segundos
• NNN meses
• NNN años
• comienzo de mes
• inicio de año
• comienzo del día
• día de la semana N
• unixepoch
• localtime
• utc

Formateadores

SQLite proporciona una función muy útil strftime()para formatear cualquier fecha y hora. Puede utilizar las siguientes sustituciones para formatear su fecha y hora.

Sustitución	Descripción
%re	Día del mes, 01-31
%F	Segundos fraccionarios, SS.SSS
% H	Hora, 00-23
% j	Día del año, 001-366
% J	Número de día juliano, DDDD.DDDD
%metro	Mes, 00-12
%METRO	Minuto, 00-59
% s	Segundos desde 1970-01-01
% S	Segundos, 00-59
% w	Día de la semana, 0-6 (0 es domingo)
% W	Semana del año, 01-53
% Y	Año, AAAA
%%	símbolo%

Ejemplos

Probemos ahora con varios ejemplos usando el indicador SQLite. El siguiente comando calcula la fecha actual.

sqlite> SELECT date('now');
2013-05-07

El siguiente comando calcula el último día del mes actual.

sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31

El siguiente comando calcula la fecha y la hora para una marca de tiempo UNIX determinada 1092941466.

sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06

El siguiente comando calcula la fecha y la hora para una marca de tiempo UNIX determinada 1092941466 y compensa su zona horaria local.

sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06

El siguiente comando calcula la marca de tiempo actual de UNIX.

sqlite> SELECT strftime('%s','now');
1393348134

El siguiente comando calcula el número de días desde la firma de la Declaración de Independencia de EE. UU.

sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023

El siguiente comando calcula el número de segundos desde un momento particular en 2004.

sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572

El siguiente comando calcula la fecha del primer martes de octubre del año actual.

sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01

El siguiente comando calcula el tiempo desde la época de UNIX en segundos (como strftime ('% s', 'ahora') excepto que incluye parte fraccionaria).

sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598

Para convertir entre los valores de hora local y UTC al formatear una fecha, use los modificadores utc o localtime de la siguiente manera:

sqlite> SELECT time('12:00', 'localtime');
05:00:00

sqlite> SELECT time('12:00', 'utc');
19:00:00

SQLite tiene muchas funciones integradas para realizar el procesamiento de cadenas o datos numéricos. A continuación se muestra la lista de algunas funciones integradas útiles de SQLite y todas distinguen entre mayúsculas y minúsculas, lo que significa que puede usar estas funciones en minúsculas, mayúsculas o en forma mixta. Para obtener más detalles, puede consultar la documentación oficial de SQLite.

No Señor.	Función descriptiva
1	SQLite COUNT Function La función agregada SQLite COUNT se usa para contar el número de filas en una tabla de base de datos.
2	SQLite MAX Function SQLite MAX aggregate function allows us to select the highest (maximum) value for a certain column.
3	SQLite MIN Function SQLite MIN aggregate function allows us to select the lowest (minimum) value for a certain column.
4	SQLite AVG Function SQLite AVG aggregate function selects the average value for certain table column.
5	SQLite SUM Function SQLite SUM aggregate function allows selecting the total for a numeric column.
6	SQLite RANDOM Function SQLite RANDOM function returns a pseudo-random integer between -9223372036854775808 and +9223372036854775807.
7	SQLite ABS Function SQLite ABS function returns the absolute value of the numeric argument.
8	SQLite UPPER Function SQLite UPPER function converts a string into upper-case letters.
9	SQLite LOWER Function SQLite LOWER function converts a string into lower-case letters.
10	SQLite LENGTH Function SQLite LENGTH function returns the length of a string.
11	SQLite sqlite_version Function SQLite sqlite_version function returns the version of the SQLite library.

Before we start giving examples on the above-mentioned functions, consider COMPANY table with the following records.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite COUNT Function

SQLite COUNT aggregate function is used to count the number of rows in a database table. Following is an example −

sqlite> SELECT count(*) FROM COMPANY;

The above SQLite SQL statement will produce the following.

count(*)
----------
7

SQLite MAX Function

SQLite MAX aggregate function allows us to select the highest (maximum) value for a certain column. Following is an example −

sqlite> SELECT max(salary) FROM COMPANY;

The above SQLite SQL statement will produce the following.

max(salary)
-----------
85000.0

SQLite MIN Function

SQLite MIN aggregate function allows us to select the lowest (minimum) value for a certain column. Following is an example −

sqlite> SELECT min(salary) FROM COMPANY;

The above SQLite SQL statement will produce the following.

min(salary)
-----------
10000.0

SQLite AVG Function

SQLite AVG aggregate function selects the average value for a certain table column. Following is an the example −

sqlite> SELECT avg(salary) FROM COMPANY;

The above SQLite SQL statement will produce the following.

avg(salary)
----------------
37142.8571428572

SQLite SUM Function

SQLite SUM aggregate function allows selecting the total for a numeric column. Following is an example −

sqlite> SELECT sum(salary) FROM COMPANY;

The above SQLite SQL statement will produce the following.

sum(salary)
-----------
260000.0

SQLite RANDOM Function

SQLite RANDOM function returns a pseudo-random integer between -9223372036854775808 and +9223372036854775807. Following is an example −

sqlite> SELECT random() AS Random;

The above SQLite SQL statement will produce the following.

Random
-------------------
5876796417670984050

SQLite ABS Function

SQLite ABS function returns the absolute value of the numeric argument. Following is an example −

sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");

The above SQLite SQL statement will produce the following.

abs(5)      abs(-15)    abs(NULL)   abs(0)      abs("ABC")
----------  ----------  ----------  ----------  ----------
5           15                      0           0.0

SQLite UPPER Function

SQLite UPPER function converts a string into upper-case letters. Following is an example −

sqlite> SELECT upper(name) FROM COMPANY;

The above SQLite SQL statement will produce the following.

upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMES

SQLite LOWER Function

SQLite LOWER function converts a string into lower-case letters. Following is an example −

sqlite> SELECT lower(name) FROM COMPANY;

The above SQLite SQL statement will produce the following.

lower(name)
-----------
paul
allen
teddy
mark
david
kim
james

SQLite LENGTH Function

SQLite LENGTH function returns the length of a string. Following is an example −

sqlite> SELECT name, length(name) FROM COMPANY;

The above SQLite SQL statement will produce the following.

NAME        length(name)
----------  ------------
Paul        4
Allen       5
Teddy       5
Mark        4
David       5
Kim         3
James       5

SQLite sqlite_version Function

SQLite sqlite_version function returns the version of the SQLite library. Following is an example −

sqlite> SELECT sqlite_version() AS 'SQLite Version';

The above SQLite SQL statement will produce the following.

SQLite Version
--------------
3.6.20

In this chapter, you will learn how to use SQLite in C/C++ programs.

Installation

Before you start using SQLite in our C/C++ programs, you need to make sure that you have SQLite library set up on the machine. You can check SQLite Installation chapter to understand the installation process.

C/C++ Interface APIs

Following are important C/C++ SQLite interface routines, which can suffice your requirement to work with SQLite database from your C/C++ program. If you are looking for a more sophisticated application, then you can look into SQLite official documentation.

Sr.No.	API & Description
1	sqlite3_open(const char *filename, sqlite3 **ppDb) This routine opens a connection to an SQLite database file and returns a database connection object to be used by other SQLite routines. If the filename argument is NULL or ':memory:', sqlite3_open() will create an in-memory database in RAM that lasts only for the duration of the session. If the filename is not NULL, sqlite3_open() attempts to open the database file by using its value. If no file by that name exists, sqlite3_open() will open a new database file by that name.
2	sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg) This routine provides a quick, easy way to execute SQL commands provided by sql argument which can consist of more than one SQL command. Here, the first argument sqlite3 is an open database object, sqlite_callback is a call back for which data is the 1st argument and errmsg will be returned to capture any error raised by the routine. SQLite3_exec() routine parses and executes every command given in the sql argument until it reaches the end of the string or encounters an error.
3	sqlite3_close(sqlite3*) This routine closes a database connection previously opened by a call to sqlite3_open(). All prepared statements associated with the connection should be finalized prior to closing the connection. If any queries remain that have not been finalized, sqlite3_close() will return SQLITE_BUSY with the error message Unable to close due to unfinalized statements.

Connect To Database

Following C code segment shows how to connect to an existing database. If the database does not exist, then it will be created and finally a database object will be returned.

#include <stdio.h>
#include <sqlite3.h> 

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;

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

   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

Now, let's compile and run the above program to create our database test.db in the current directory. You can change your path as per your requirement.

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

If you are going to use C++ source code, then you can compile your code as follows −

$g++ test.c -l sqlite3

Here, we are linking our program with sqlite3 library to provide required functions to C program. This will create a database file test.db in your directory and you will have the following result.

-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root  323 May 8 02:05 test.c
-rw-r--r--. 1 root root    0 May 8 02:06 test.db

Create a Table

Following C code segment will be used to create a table in the previously created database −

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stdout, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Table created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

When the above program is compiled and executed, it will create COMPANY table in your test.db and the final listing of the file will be as follows −

-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.db

INSERT Operation

Following C code segment shows how you can create records in COMPANY table created in the above example −

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Records created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

When the above program is compiled and executed, it will create the given records in COMPANY table and will display the following two lines −

Opened database successfully
Records created successfully

SELECT Operation

Before proceeding with actual example to fetch records, let us look at some detail about the callback function, which we are using in our examples. This callback provides a way to obtain results from SELECT statements. It has the following declaration −

typedef int (*sqlite3_callback)(
   void*,    /* Data provided in the 4th argument of sqlite3_exec() */
   int,      /* The number of columns in row */
   char**,   /* An array of strings representing fields in the row */
   char**    /* An array of strings representing column names */
);

If the above callback is provided in sqlite_exec() routine as the third argument, SQLite will call this callback function for each record processed in each SELECT statement executed within the SQL argument.

El siguiente segmento de código C muestra cómo puede obtener y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior:

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación ACTUALIZAR

El siguiente segmento de código C muestra cómo podemos usar la instrucción UPDATE para actualizar cualquier registro y luego buscar y mostrar registros actualizados de la tabla EMPRESA.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación DELETE

El siguiente segmento de código C muestra cómo puede usar la instrucción DELETE para eliminar cualquier registro y luego buscar y mostrar los registros restantes de la tabla EMPRESA.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName) {
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "DELETE from COMPANY where ID=2; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

En este capítulo, aprenderá a usar SQLite en programas Java.

Instalación

Antes de comenzar a usar SQLite en nuestros programas Java, debe asegurarse de tener el controlador SQLite JDBC y Java configurado en la máquina. Puede consultar el tutorial de Java para la instalación de Java en su máquina. Ahora, veamos cómo configurar el controlador SQLite JDBC.

• Descargue la última versión de sqlite-jdbc- (VERSION) .jar desde el repositorio sqlite-jdbc .

• Agregue el archivo jar descargado sqlite-jdbc- (VERSION) .jar en su ruta de clases, o puede usarlo junto con la opción -classpath como se explica en los siguientes ejemplos.

La siguiente sección asume que tiene pocos conocimientos sobre los conceptos de Java JDBC. Si no lo hace, le recomendamos que dedique media hora al tutorial de JDBC para familiarizarse con los conceptos que se explican a continuación.

Conectarse a la base de datos

Los siguientes programas de Java muestran cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos.

import java.sql.*;

public class SQLiteJDBC {
  public static void main( String args[] ) {
      Connection c = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

Ahora, compilemos y ejecutemos el programa anterior para crear nuestra base de datos test.dben el directorio actual. Puede cambiar su ruta según sus necesidades. Suponemos que la versión actual del controlador JDBC sqlite-jdbc-3.7.2.jar está disponible en la ruta actual.

$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfully

Si va a utilizar una máquina con Windows, puede compilar y ejecutar su código de la siguiente manera:

$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfully

Crear una tabla

El siguiente programa de Java se utilizará para crear una tabla en la base de datos creada anteriormente.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "CREATE TABLE COMPANY " +
                        "(ID INT PRIMARY KEY     NOT NULL," +
                        " NAME           TEXT    NOT NULL, " + 
                        " AGE            INT     NOT NULL, " + 
                        " ADDRESS        CHAR(50), " + 
                        " SALARY         REAL)"; 
         stmt.executeUpdate(sql);
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Table created successfully");
   }
}

Cuando se compila y ejecuta el programa anterior, creará la tabla EMPRESA en su test.db y la lista final del archivo será la siguiente:

-rw-r--r--. 1 root root 3201128 Jan 22 19:04 sqlite-jdbc-3.7.2.jar
-rw-r--r--. 1 root root    1506 May  8 05:43 SQLiteJDBC.class
-rw-r--r--. 1 root root     832 May  8 05:42 SQLiteJDBC.java
-rw-r--r--. 1 root root    3072 May  8 05:43 test.db

INSERTAR Operación

El siguiente programa Java muestra cómo crear registros en la tabla EMPRESA creada en el ejemplo anterior.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                        "VALUES (1, 'Paul', 32, 'California', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (2, 'Allen', 25, 'Texas', 15000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );"; 
         stmt.executeUpdate(sql);

         stmt.close();
         c.commit();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Records created successfully");
   }
}

Cuando el programa anterior se compila y ejecuta, creará los registros dados en la tabla EMPRESA y se mostrará en las siguientes dos líneas:

Opened database successfully
Records created successfully

SELECCIONAR Operación

El siguiente programa Java muestra cómo buscar y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {

   Connection c = null;
   Statement stmt = null;
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
   System.out.println("Operation done successfully");
  }
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación ACTUALIZAR

El siguiente código Java muestra cómo usar la instrucción UPDATE para actualizar cualquier registro y luego buscar y mostrar los registros actualizados de la tabla EMPRESA.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {
  
   Connection c = null;
   Statement stmt = null;
   
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
      stmt.executeUpdate(sql);
      c.commit();

      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
    System.out.println("Operation done successfully");
   }
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación DELETE

El siguiente código de Java muestra cómo usar la instrucción DELETE para eliminar cualquier registro y luego buscar y mostrar los registros restantes de nuestra tabla EMPRESA.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "DELETE from COMPANY where ID=2;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         
         while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

En este capítulo, aprenderá a usar SQLite en programas PHP.

Instalación

La extensión SQLite3 está habilitada de forma predeterminada a partir de PHP 5.3.0. Es posible deshabilitarlo usando--without-sqlite3 en tiempo de compilación.

Los usuarios de Windows deben habilitar php_sqlite3.dll para poder usar esta extensión. Esta DLL se incluye con las distribuciones de PHP de Windows a partir de PHP 5.3.0.

Para obtener instrucciones de instalación detalladas, consulte nuestro tutorial de PHP y su sitio web oficial.

API de interfaz PHP

A continuación se presentan importantes rutinas de PHP que pueden ser suficientes para trabajar con la base de datos SQLite desde su programa PHP. Si está buscando una aplicación más sofisticada, puede consultar la documentación oficial de PHP.

No Señor.	API y descripción
1	public void SQLite3::open ( filename, flags, encryption_key ) Abre la base de datos SQLite 3. Si la compilación incluye cifrado, intentará utilizar la clave. Si el nombre del archivo se da como':memory:', SQLite3 :: open () creará una base de datos en memoria en la RAM que durará solo mientras dure la sesión. Si el nombre del archivo es el nombre del archivo del dispositivo real, SQLite3 :: open () intenta abrir el archivo de la base de datos utilizando su valor. Si no existe ningún archivo con ese nombre, se crea un nuevo archivo de base de datos con ese nombre. Indicadores opcionales que se utilizan para determinar cómo abrir la base de datos SQLite. Por defecto, open usa SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE.
2	public bool SQLite3::exec ( string $query ) Esta rutina proporciona una forma rápida y fácil de ejecutar comandos SQL proporcionados por el argumento sql, que puede constar de más de un comando SQL. Esta rutina se utiliza para ejecutar una consulta sin resultados en una base de datos determinada.
3	public SQLite3Result SQLite3::query ( string $query ) Esta rutina ejecuta una consulta SQL, devolviendo un SQLite3Result objeto si la consulta devuelve resultados.
4	public int SQLite3::lastErrorCode ( void ) Esta rutina devuelve el código de resultado numérico de la solicitud SQLite fallida más reciente.
5	public string SQLite3::lastErrorMsg ( void ) Esta rutina devuelve texto en inglés que describe la solicitud SQLite fallida más reciente.
6	public int SQLite3::changes ( void ) Esta rutina devuelve el número de filas de la base de datos que se actualizaron, insertaron o eliminaron mediante la declaración SQL más reciente.
7	public bool SQLite3::close ( void ) Esta rutina cierra una conexión de base de datos previamente abierta por una llamada a SQLite3 :: open ().
8	public string SQLite3::escapeString ( string $value ) Esta rutina devuelve una cadena que se ha escapado correctamente para su inclusión segura en una declaración SQL.

Conectarse a la base de datos

El siguiente código PHP muestra cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
?>

Ahora, ejecutemos el programa anterior para crear nuestra base de datos. test.dben el directorio actual. Puede cambiar su ruta según sus necesidades. Si la base de datos se creó correctamente, mostrará el siguiente mensaje:

Open database successfully

Crear una tabla

El siguiente programa PHP se utilizará para crear una tabla en la base de datos creada anteriormente.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL);
EOF;

   $ret = $db->exec($sql); if(!$ret){
      echo $db->lastErrorMsg(); } else { echo "Table created successfully\n"; } $db->close();
?>

Cuando se ejecuta el programa anterior, creará la tabla EMPRESA en su test.db y mostrará los siguientes mensajes:

Opened database successfully
Table created successfully

INSERTAR Operación

El siguiente programa PHP muestra cómo crear registros en la tabla EMPRESA creada en el ejemplo anterior.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db){ echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ); EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo "Records created successfully\n";
   }
   $db->close();
?>

Cuando se ejecuta el programa anterior, creará los registros dados en la tabla EMPRESA y mostrará las siguientes dos líneas.

Opened database successfully
Records created successfully

SELECCIONAR Operación

El siguiente programa PHP muestra cómo buscar y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior:

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

Operación ACTUALIZAR

El siguiente código PHP muestra cómo usar la instrucción UPDATE para actualizar cualquier registro y luego buscar y mostrar los registros actualizados de la tabla EMPRESA.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF UPDATE COMPANY set SALARY = 25000.00 where ID=1; EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
1 Record updated successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

Operación DELETE

El siguiente código PHP muestra cómo usar la instrucción DELETE para eliminar cualquier registro y luego buscar y mostrar los registros restantes de la tabla EMPRESA.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID = 2; EOF; $ret = $db->exec($sql);
   if(!$ret){ echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record deleted successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
1 Record deleted successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

En este capítulo, aprenderá a usar SQLite en programas Perl.

Instalación

SQLite3 se puede integrar con Perl usando el módulo Perl DBI, que es un módulo de acceso a la base de datos para el lenguaje de programación Perl. Define un conjunto de métodos, variables y convenciones que proporcionan una interfaz de base de datos estándar.

Los siguientes son pasos simples para instalar el módulo DBI en su máquina Linux / UNIX:

$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz $ tar xvfz DBI-1.625.tar.gz
$ cd DBI-1.625 $ perl Makefile.PL
$ make $ make install

Si necesita instalar el controlador SQLite para DBI, puede instalarlo de la siguiente manera:

$ wget http://search.cpan.org/CPAN/authors/id/M/MS/MSERGEANT/DBD-SQLite-1.11.tar.gz $ tar xvfz DBD-SQLite-1.11.tar.gz
$ cd DBD-SQLite-1.11 $ perl Makefile.PL
$ make $ make install

API de interfaz DBI

A continuación se muestran importantes rutinas DBI, que pueden ser suficientes para su requisito de trabajar con la base de datos SQLite desde su programa Perl. Si está buscando una aplicación más sofisticada, puede consultar la documentación oficial de Perl DBI.

No Señor.	API y descripción
1	DBI->connect($data_source, "", "", \%attr) Establece una conexión de base de datos, o sesión, al $ data_source solicitado. Devuelve un objeto de identificador de base de datos si la conexión se realiza correctamente. La fuente de datos tiene la forma como: DBI:SQLite:dbname = 'test.db'donde SQLite es el nombre del controlador SQLite y test.db es el nombre del archivo de base de datos SQLite. Si el nombre del archivo se da como':memory:', creará una base de datos en memoria en RAM que durará solo el tiempo que dure la sesión. Si el nombre de archivo es el nombre de archivo del dispositivo real, intenta abrir el archivo de base de datos utilizando su valor. Si no existe ningún archivo con ese nombre, se crea un nuevo archivo de base de datos con ese nombre. Mantiene el segundo y tercer parámetro como cadenas en blanco y el último parámetro es pasar varios atributos como se muestra en el siguiente ejemplo.
2	$dbh->do($sql) Esta rutina prepara y ejecuta una sola instrucción SQL. Devuelve el número de filas afectadas o indefinidas en caso de error. Un valor de retorno de -1 significa que el número de filas no se conoce, no es aplicable o no está disponible. Aquí, $ dbh es un identificador devuelto por DBI-> connect () call.
3	$dbh->prepare($sql) Esta rutina prepara una declaración para su posterior ejecución por parte del motor de base de datos y devuelve una referencia a un objeto identificador de declaración.
4	$sth->execute() Esta rutina realiza cualquier procesamiento necesario para ejecutar la instrucción preparada. Se devuelve un indef si se produce un error. Una ejecución exitosa siempre devuelve verdadero independientemente del número de filas afectadas. Aquí,$sth is a statement handle returned by $dbh-> prepare ($ sql) llamada.
5	$sth->fetchrow_array() Esta rutina obtiene la siguiente fila de datos y la devuelve como una lista que contiene los valores del campo. Los campos nulos se devuelven como valores indefinidos en la lista.
6	$DBI::err Esto es equivalente a $ h-> err, donde $h is any of the handle types like $dbh, $sth, or $drh. Esto devuelve el código de error del motor de base de datos nativo del último método de controlador llamado.
7	$DBI::errstr Esto es equivalente a $ h-> errstr, donde $h is any of the handle types like $dbh, $sth, or $drh. Esto devuelve el mensaje de error del motor de base de datos nativo del último método DBI llamado.
8	$dbh->disconnect() Esta rutina cierra una conexión de base de datos previamente abierta por una llamada a DBI-> connect ().

Conectarse a la base de datos

El siguiente código Perl muestra cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite"; 
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

Ahora, ejecutemos el programa anterior para crear nuestra base de datos test.db en el directorio actual. Puede cambiar su ruta según sus necesidades. Mantenga el código anterior en el archivo sqlite.pl y ejecútelo como se muestra a continuación. Si la base de datos se creó correctamente, mostrará el siguiente mensaje:

$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfully

Crear una tabla

El siguiente programa Perl se utiliza para crear una tabla en la base de datos creada anteriormente.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
   (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL););

my $rv = $dbh->do($stmt); if($rv < 0) {
   print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();

Cuando se ejecuta el programa anterior, creará la tabla EMPRESA en su test.db y mostrará los siguientes mensajes:

Opened database successfully
Table created successfully

NOTE - En caso de que vea el siguiente error en alguna de las operaciones -

DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398

En tal caso, abra dbdimp.c file disponible en la instalación DBD-SQLite y descubra sqlite3_prepare() función y cambie su tercer argumento a -1 en lugar de 0. Finalmente, instale DBD :: SQLite usando make y hacer make install para resolver el problema.

INSERTAR Operación

El siguiente programa de Perl muestra cómo crear registros en la tabla EMPRESA creada en el ejemplo anterior.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););

$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

Cuando se ejecuta el programa anterior, creará los registros dados en la tabla EMPRESA y mostrará las siguientes dos líneas:

Opened database successfully
Records created successfully

SELECCIONAR Operación

El siguiente programa Perl muestra cómo buscar y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

Operación ACTUALIZAR

El siguiente código de Perl muestra cómo ACTUALIZAR la instrucción para actualizar cualquier registro y luego buscar y mostrar los registros actualizados de la tabla EMPRESA.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
   print $DBI::errstr; } else { print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
   print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
      print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

Operación DELETE

El siguiente código de Perl muestra cómo usar la instrucción DELETE para eliminar cualquier registro y luego buscar y mostrar los registros restantes de la tabla EMPRESA:

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID = 2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;

if( $rv < 0 ) { print $DBI::errstr;
} else {
   print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

En este capítulo, aprenderá a usar SQLite en programas Python.

Instalación

SQLite3 se puede integrar con Python usando el módulo sqlite3, que fue escrito por Gerhard Haring. Proporciona una interfaz SQL compatible con la especificación DB-API 2.0 descrita por PEP 249. No es necesario instalar este módulo por separado porque se envía de forma predeterminada junto con la versión 2.5.x de Python en adelante.

Para usar el módulo sqlite3, primero debe crear un objeto de conexión que represente la base de datos y luego, opcionalmente, puede crear un objeto de cursor, que lo ayudará a ejecutar todas las declaraciones SQL.

API del módulo Python sqlite3

Las siguientes son rutinas importantes del módulo sqlite3, que pueden ser suficientes para su requisito de trabajar con la base de datos SQLite desde su programa Python. Si está buscando una aplicación más sofisticada, puede consultar la documentación oficial del módulo Python sqlite3.

No Señor.	API y descripción
1	sqlite3.connect(database [,timeout ,other optional arguments]) Esta API abre una conexión al archivo de base de datos SQLite. Puede utilizar ": memory:" para abrir una conexión de base de datos a una base de datos que reside en la RAM en lugar de en el disco. Si la base de datos se abre correctamente, devuelve un objeto de conexión. Cuando se accede a una base de datos mediante múltiples conexiones, y uno de los procesos modifica la base de datos, la base de datos SQLite se bloquea hasta que se confirma la transacción. El parámetro de tiempo de espera especifica cuánto tiempo debe esperar la conexión para que desaparezca el bloqueo hasta generar una excepción. El valor predeterminado para el parámetro de tiempo de espera es 5,0 (cinco segundos). Si el nombre de la base de datos proporcionado no existe, esta llamada creará la base de datos. También puede especificar el nombre de archivo con la ruta requerida si desea crear una base de datos en cualquier otro lugar excepto en el directorio actual.
2	connection.cursor([cursorClass]) Esta rutina crea una cursorque se utilizará en toda la programación de su base de datos con Python. Este método acepta un único parámetro opcional cursorClass. Si se proporciona, debe ser una clase de cursor personalizada que amplíe sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Esta rutina ejecuta una instrucción SQL. La instrucción SQL puede parametrizarse (es decir, marcadores de posición en lugar de literales SQL). El módulo sqlite3 admite dos tipos de marcadores de posición: signos de interrogación y marcadores de posición con nombre (estilo con nombre). For example - cursor.execute ("insertar en las personas valores (?,?)", (Quién, edad))
4	connection.execute(sql [, optional parameters]) Esta rutina es un atajo del método de ejecución anterior proporcionado por el objeto cursor y crea un objeto cursor intermedio llamando al método del cursor, luego llama al método de ejecución del cursor con los parámetros dados.
5	cursor.executemany(sql, seq_of_parameters) Esta rutina ejecuta un comando SQL contra todas las secuencias de parámetros o asignaciones que se encuentran en la secuencia sql.
6	connection.executemany(sql[, parameters]) Esta rutina es un atajo que crea un objeto de cursor intermedio llamando al método cursor, luego llama al método cursor.s executemany con los parámetros dados.
7	cursor.executescript(sql_script) Esta rutina ejecuta varias sentencias SQL a la vez proporcionadas en forma de script. Primero emite una declaración COMMIT, luego ejecuta el script SQL que obtiene como parámetro. Todas las sentencias SQL deben estar separadas por punto y coma (;).
8	connection.executescript(sql_script) Esta rutina es un atajo que crea un objeto de cursor intermedio llamando al método del cursor, luego llama al método de ejecución del cursor con los parámetros dados.
9	connection.total_changes() Esta rutina devuelve el número total de filas de la base de datos que se han modificado, insertado o eliminado desde que se abrió la conexión a la base de datos.
10	connection.commit() Este método confirma la transacción actual. Si no llama a este método, cualquier cosa que haya hecho desde la última llamada a commit () no es visible desde otras conexiones de base de datos.
11	connection.rollback() Este método revierte cualquier cambio en la base de datos desde la última llamada a commit ().
12	connection.close() Este método cierra la conexión a la base de datos. Tenga en cuenta que esto no llama automáticamente a commit (). Si cierra la conexión de su base de datos sin llamar a commit () primero, ¡sus cambios se perderán!
13	cursor.fetchone() Este método obtiene la siguiente fila de un conjunto de resultados de consulta y devuelve una sola secuencia, o None cuando no hay más datos disponibles.
14	cursor.fetchmany([size = cursor.arraysize]) Esta rutina recupera el siguiente conjunto de filas del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay más filas disponibles. El método intenta obtener tantas filas como indique el parámetro de tamaño.
15	cursor.fetchall() Esta rutina recupera todas las filas (restantes) del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay filas disponibles.

Conectarse a la base de datos

El siguiente código de Python muestra cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')

print "Opened database successfully";

Aquí, también puede proporcionar el nombre de la base de datos como nombre especial :memory:para crear una base de datos en RAM. Ahora, ejecutemos el programa anterior para crear nuestra base de datos.test.dben el directorio actual. Puede cambiar su ruta según sus necesidades. Mantenga el código anterior en el archivo sqlite.py y ejecútelo como se muestra a continuación. Si la base de datos se creó correctamente, mostrará el siguiente mensaje.

$chmod +x sqlite.py $./sqlite.py
Open database successfully

Crear una tabla

El siguiente programa de Python se utilizará para crear una tabla en la base de datos creada anteriormente.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute('''CREATE TABLE COMPANY
         (ID INT PRIMARY KEY     NOT NULL,
         NAME           TEXT    NOT NULL,
         AGE            INT     NOT NULL,
         ADDRESS        CHAR(50),
         SALARY         REAL);''')
print "Table created successfully";

conn.close()

Cuando se ejecuta el programa anterior, creará la tabla EMPRESA en su test.db y mostrará los siguientes mensajes:

Opened database successfully
Table created successfully

INSERTAR Operación

El siguiente programa de Python muestra cómo crear registros en la tabla EMPRESA creada en el ejemplo anterior.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");

conn.commit()
print "Records created successfully";
conn.close()

Cuando se ejecuta el programa anterior, creará los registros dados en la tabla EMPRESA y mostrará las siguientes dos líneas:

Opened database successfully
Records created successfully

SELECCIONAR Operación

El siguiente programa de Python muestra cómo buscar y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación ACTUALIZAR

El siguiente código de Python muestra cómo usar la instrucción UPDATE para actualizar cualquier registro y luego buscar y mostrar los registros actualizados de la tabla EMPRESA.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

Operación DELETE

El siguiente código de Python muestra cómo usar la instrucción DELETE para eliminar cualquier registro y luego buscar y mostrar los registros restantes de la tabla EMPRESA.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("DELETE from COMPANY where ID = 2;")
conn.commit()
print "Total number of rows deleted :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Cuando se ejecuta el programa anterior, producirá el siguiente resultado.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully