Almacenamiento

de la
Información

Base de datos SQLite

Ing. M. Carlos Cruz Vedia

 Contenido
1. INTRODUCCIÓN AL LENGUAJE SQL ...................................................................................................... 1
2. SQLITE........................................................................................................................................................... 2
3. ¿POR QUÉ SQLITE? ..................................................................................................................................... 2
4. LIMITACIONES DE SQLITE ....................................................................................................................... 2
5. TIPOS DE DATOS ......................................................................................................................................... 3
6. COMANDOS DE SQLITE: ........................................................................................................................... 5
7. LENGUAJE DE DEFINICIÓN DE DATOS (DDL) ...................................................................................... 5
7.1. Crear tablas (CREATE TABLE) ........................................................................................................... 5
7.2. Modificar Tabla (ALTER TABLE) ....................................................................................................... 6
8. RESTRICCIONES DE SQLITE ..................................................................................................................... 7
8.1. Restricción NOT NULL ........................................................................................................................ 8
8.2. Restricción DEFAULT .......................................................................................................................... 8
8.3. Restricción UNIQUE ............................................................................................................................ 9
8.4. Restricción de CLAVE PRINCIPAL .................................................................................................... 9
8.5. Restricción CHECK ............................................................................................................................ 10
8.6. Restricción DROPPING ...................................................................................................................... 10
8.7. Autoincremento (AUTOINCREMENT) ............................................................................................. 10
9. LENGUAJE DE MANIPULACIÓN DE DATOS (DML) ........................................................................... 11
9.1. Consulta INSERT ................................................................................................................................ 11
9.2. Consulta SELECT ............................................................................................................................... 13
9.3. Consulta de actualización (UPDATE) ................................................................................................. 14
9.4. Consulta de eliminación (DELETE).................................................................................................... 15
10. SINTAXIS DE SQLITE .......................................................................................................................... 16
11. OPERADORES ....................................................................................................................................... 19
11.1. Operadores aritméticos de SQLite:...................................................................................................... 19
11.2. Operadores de Comparación ............................................................................................................... 19
11.3. Operadores Lógicos ............................................................................................................................. 21
12. EXPRESIONES SQLITE ........................................................................................................................ 25
12.1. Expresiones booleanas: ....................................................................................................................... 25
12.2. Expresión Numérica ............................................................................................................................ 26
12.3. Expresiones de fecha: .......................................................................................................................... 26
13. CLÁUSULA WHERE ............................................................................................................................. 27
14. OPERADOR AND Y OR ........................................................................................................................ 30
14.1. El operador AND: ............................................................................................................................... 30
14.2. El operador OR: .................................................................................................................................. 31
15. CLÁUSULA LIKE .................................................................................................................................. 32
16. CLÁUSULA GLOB................................................................................................................................. 33
17. CLÁUSULA LIMIT ................................................................................................................................ 35
18. CLÁUSULA ORDER BY ....................................................................................................................... 37
19. CLÁUSULA GROUP BY ....................................................................................................................... 38
20. CLÁUSULA HAVING ............................................................................................................................ 41
21. CLÁUSULA DISTINCT ......................................................................................................................... 43
22. CLÁUSULA JOINS................................................................................................................................. 44
22.1. La unión cruzada (CROSS JOIN) ....................................................................................................... 45
22.2. La unión interna (INNER JOIN) ......................................................................................................... 46
22.3. La unión externa (OUTER JOIN) ....................................................................................................... 46
23. CLÁUSULA UNIONS ............................................................................................................................ 47
23.1. La Cláusula UNION ALL: .................................................................................................................. 48
24. VALORES NULOS ................................................................................................................................. 49
25. SINTAXIS ALIAS ................................................................................................................................... 51
 Ing. En Diseño y Animación Digital

1. INTRODUCCIÓN AL LENGUAJE SQL

Tras la exposición del modelo relacional por parte de E. F. Codd en 1970, dos compañeros del IBM
Research Center, Donald D. Chamberlin y Raymond F. Boyce, definieron cuatro años más tarde un
lenguaje de programación gracias al que interactuar con la información contenida en una base de
datos. Dada la similitud de dicho lenguaje con la lengua cotidiana, lo llamaron SEQUEL (structured
English query language, lenguaje de consulta estructurado en inglés). Debido a problemas de
copyright, el nombre se cambió a SQL.
Basado en la teoría del álgebra y el cálculo relacional, SQL es un lenguaje de alto nivel con el que
comunicarse con un SGBD(O)R. No solamente sirve para realizar consultas, altas, modificaciones y
borrado de datos, sino también para definir la estructura de la base de datos, declarar sus objetos y
elementos (usuarios, perfiles, backups, temporizaciones) y establecer elementos de seguridad.
Es importante ubicar SQL como lenguaje de programación:
• Es un lenguaje no procedimental, ya que se le especifica qué es lo que se quiere obtener sin
entrar en el cómo (no se escriben instrucciones secuenciales y precisas, tan solo se indica
qué acción se quiere realizar, y es tarea del propio lenguaje encontrar el camino adecuado
para ejecutarla).
• Solo sirve para ejecutar consultas sobre bases de datos. Carece de estructuras de control
(if, while, for), por lo que no es un lenguaje Turing completo.
La organización de estandarización ANSI formalizó SQL en 1986 (SQL-86). Desde entonces
se han publicado otras siete versiones del estándar (SQL-89, SQL-92, SQL:1999, SQL:2003,
SQL:2006, SQL:2008 y SQL:2011).
Las compañías que desarrollan SGBDR han ido ampliado notablemente el ámbito de SQL,
acercándose y alejándose del estándar según la evolución de este y del mercado. En este sentido,
han introducido una sintaxis propietaria que, si bien simplifica ciertas instrucciones u ofrece nuevas
funcionalidades, dificulta la migración de bases de datos entre distintos sistemas gestores y crea
dependencia por parte de sus clientes.
Las funcionalidades de SQL se suelen dividir en tres sublenguajes:
• DDL (data definition language, lenguaje de definición de datos). Permite crear la
estructura de los elementos de la base de datos (tablas, índices, la propia base de datos).
• DML (data manipulation language, lenguaje de manipulación de datos). Opera sobre la
información contenida en la base de datos (valores de los campos y registros). Al DML
corresponde la inserción, modificación, borrado y consulta de los datos.

1
 Ing. En Diseño y Animación Digital
Debido a la falta de universalidad de las implementaciones comerciales de SQL, así como a la rápida
evolución del mercado, en este libro se seguirá la sintaxis SQL estándar. Conocido el estándar, la
adaptación del lector a la sintaxis de cualquier otra versión de SQL será una tarea rápida y sencilla.
Salvo que se indique lo contrario, se utilizará como referencia el estándar SQL:1999, ya que las
versiones posteriores se centran en características que quedan fuera del ámbito de este texto. Se
muestra una sintaxis simplificada en aras de garantizar un enfoque práctico.

2. SQLITE
SQLite es una biblioteca en proceso que implementa un motor de base de datos SQL transaccional
autónomo, sin servidor y sin configuración. Es la única base de datos sin configuración, lo que
significa que, al igual que otras bases de datos, no necesita configurarse en el sistema.
El motor SQLite no es un proceso independiente como otras bases de datos; puede vincularlo
estática o dinámicamente con su aplicación según sus
necesidades. SQLite accede directamente a sus archivos de almacenamiento.
• 2000 - D. Richard Hipp diseñó SQLite con el propósito de que no se necesitara administración
para operar un programa.
• 2000 - en agosto, se lanzó SQLite 1.0 con GNU Database Manager.

3. ¿POR QUÉ SQLITE?

• SQLite no requiere un proceso o sistema de servidor separado para funcionar (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 único archivo de disco
multiplataforma.
• SQLite es muy pequeño y liviano, menos de 400 KiB completamente configurado o menos de
250 KiB con opciones características omitidas.
• SQLite es autónomo, lo que significa que no tiene 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 características 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).

4. LIMITACIONES DE SQLITE
Hay algunas características no compatibles de SQL92 en SQLite que se muestran a continuación.

Característica Descripción
RIGHT OUTER JOIN Sólo se implementa LEFT OUTER JOIN.
FULL OUTER JOIN Sólo se implementa LEFT OUTER JOIN.

2
 Ing. En Diseño y Animación Digital
Se admiten las variantes RENAME TABLE y ADD COLUMNA del comando ALTER TABLE. No se admiten las
ALTER TABLE
variantes DROP COLUMNA, ALTER COLUMNA ni ADD CONSTRAINT.
Soporte Trigger Se admiten los triggers FOR EACH ROW pero no los triggers FOR EACH STATEMENT
Las vistas en SQLite son de solo lectura. No se pueden ejecutar sentencias DELETE, INSERT ni UPDATE en
VISTAS
una vista.
Los únicos permisos de acceso que se pueden aplicar son los permisos de acceso a archivos normales
GRANT and REVOKE
del sistema operativo subyacente.

5. TIPOS DE DATOS
El tipo de dato de SQLite es un atributo que especifica el tipo de dato de cualquier objeto. Cada
columna, variable y La 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 tipos dinámicos más
general. En SQLite, el tipo de dato de un valor se asocia al valor mismo, no a su contenedor.
• Clases de almacenamiento:
Cada valor almacenado en una base de datos SQLite tiene una de las siguientes clases de
almacenamiento
Clase de
Descripción
almacenamiento
NULL El valor es un valor NULL.
INTEGER El valor es un entero con signo, almacenado en 1, 2, 3, 4, 6 u 8 bytes según la magnitud del valor.
REAL El valor es un valor de punto flotante, almacenado como un número de punto flotante IEEE de 8 bytes.
El valor es una cadena de texto, almacenada utilizando la codificación de la base de datos (UTF-8, UTF-16BE
TEXT
o UTF-16LE)
BLOB El valor es un conjunto de datos, almacenados exactamente como se ingresó.

La clase de almacenamiento SQLite es ligeramente más general que un tipo de dato. La clase de
almacenamiento INTEGER, por ejemplo, incluye seis tipos de datos enteros diferentes de distintas
longitudes.
• Tipo de afinidad
SQLite admite el concepto de afinidad de tipos en columnas. Cualquier columna puede almacenar
cualquier tipo de datos, pero la clase de almacenamiento preferida para una columna se denomina
afinidad. A cada columna de tabla en una base de datos SQLite3 se le asigna una de las siguientes
afinidades de tipos:
Afinidad Descripción
TEXT Esta columna almacena todos los datos utilizando las clases de almacenamiento NULL, TEXT o BLOB
NUMERIC Esta columna puede contener valores que utilicen las cinco clases de almacenamiento
INTEGER Se comporta igual que una columna con afinidad NUMERIC con una excepción en un CAST
Se comporta como una columna con afinidad NUMERIC excepto que fuerza los valores enteros a una representación
REAL
de punto flotante
Una columna con afinidad NINGUNA no prefiere una clase de almacenamiento sobre otra y no se intenta
NONE
forzar datos de una clase de almacenamiento a otra.

3
 Ing. En Diseño y Animación Digital
• Afinidad y nombres de tipos
La siguiente tabla enumera varios nombres de tipos de datos que se pueden usar al crear tablas
SQLite3 y también se muestra la afinidad aplicada correspondiente:
Tipo de dato Afinidad
INT
INTEGER
TINYINT
SMALLINT
MEDIUMINT INTEGER
BIGINT
UNSIGNED BIG INT
INT2
INT8
CHARACTER (20)
VARCHAR (255)
VARYING CHARACTER (255
NCHAR (55)
TEXT
NATIVE CHARACTER (70)
NVARCHAR (100)
TEXT
CLOB
BLOB
NONE
no datatype specified
REAL
DOUBLE
REAL
DOUBLE PRECISION
FLOAT
NUMERIC
DECIMAL (10,5)
BOOLEAN NUMERIC
DATE
DATETIME

• Tipo de dato booleano:

SQLite no tiene una clase de almacenamiento booleano independiente. En su lugar, los valores
booleanos se almacenan como 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 de TEXTO, REALES o ENTEROS
Clase de almacenamiento Formato de fecha
TEXT Una fecha en un formato como "AAAA-MM-DD HH:MM:[Link]"
REAL El número de días transcurridos desde el mediodía en Greenwich el 24 de nov. de 4714 a. C.
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 de fecha y hora integradas.

4
 Ing. En Diseño y Animación Digital
6. COMANDOS DE SQLITE:
Los comandos estándar de SQLite para interactuar con bases de datos relacionales son similares a
los de SQL. Son CREATE, SELECT, INSERT, UPDATE, DELETE y DROP. Estos comandos se pueden
clasificar en grupos según su naturaleza operativa:

7. LENGUAJE DE DEFINICIÓN DE DATOS (DDL)

Comando Descripción
CREATE Crea una nueva tabla, una vista de una tabla u otro objeto en la base de datos
ALTER Modifica un objeto de base de datos existente, como una tabla.
DROP Elimina una tabla completa, una vista de una tabla u otro objeto de la base de datos.

7.1. Crear tablas (CREATE TABLE)

La declaración CREATE TABLE de SQLite se utiliza para crear una nueva tabla en cualquiera de las
bases de datos dadas.
La creación de una tabla básica implica nombrar la tabla y definir sus columnas y el tipo de datos de
cada columna.
Sintaxis:
La sintaxis básica de la declaración CREATE TABLE es la siguiente

CREATE TABLE nombre_basededatos.nombre_tabla (

columna1 tipo_dato PRIMARY KEY (uno o más columnas),
columna2 tipo_dato,
.....
columnaN tipo_dato,
);

CREATE TABLE es la palabra clave que indica al sistema de base de datos que cree una nueva tabla.
El nombre único o identificador de la tabla sigue a la instrucción CREATE TABLE. Opcionalmente,
puede especificar nombre_basededatos junto con nombre_tabla.
Ejemplo:
A continuación, se muestra un ejemplo, que crea una tabla EMPLEADO 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:

CREATE TABLE Empleado (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL,
NroHijos INT,
Direccion CHAR (50),
Salario REAL
);

5
 Ing. En Diseño y Animación Digital
Creemos una tabla más, que utilizaremos en nuestros ejercicios en los capítulos siguientes:

CREATE TABLE Departamento (

ID INT PRIMARY KEY NOT NULL,
Departamento CHAR (50) NOT NULL,
IDEmp INT NOT NULL
);

7.2. Modificar Tabla (ALTER TABLE)

El comando ALTER TABLE de SQLite modifica una tabla existente sin realizar un volcado completo ni
recargar los datos. Puede renombrar una tabla mediante la instrucción ALTER TABLE y agregar
columnas adicionales a una tabla existente mediante la instrucción ALTER TABLE.
El comando ALTER TABLE en SQLite no admite ninguna otra operación, excepto renombrar una tabla
y añadir una columna a una tabla existente.
Sintaxis:
La sintaxis básica de ALTER TABLE para cambiar el nombre de una tabla existente es la siguiente:

ALTER TABLE nombre_basededatos.nombre_tabla RENAME TO nombre_nueva_tabla;

La sintaxis básica de ALTER TABLE para agregar una nueva columna en una tabla existente es la
siguiente:

ALTER TABLE nombre_basededatos.nombre_tabla ADD COLUMN nueva_columna, …

;
Ejemplo:
Supongamos que nuestra tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

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

ALTER TABLE EMPLEADO RENAME TO EMPLEADOS;

6
 Ing. En Diseño y Animación Digital
La instrucción SQLite anterior cambiará el nombre de la tabla EMPLEADO a EMPLEADOS.
Ahora, intentemos agregar una nueva columna en la tabla EMPLEADOS de la siguiente manera:

ALTER TABLE EMPELADOS ADD COLUMN GENERO char(1);

Ahora, se modifica la tabla EMPLEADOS y la declaración SELECT arrojará el siguiente resultado:

Id Nombrecompleto Nrohijos Direccion Salario Genero

---- ----------------------- -------- ------------------- ------------ -------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000 NULL
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000 NULL
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000 NULL
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500 NULL
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500 NULL
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900 NULL
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000 NULL

Se debe tener en cuenta que la columna recién agregada se completa con valores NULL.
7.3. Eliminar Tabla (DROP TABLE)
La declaración DROP TABLE de SQLite se utiliza para eliminar una definición de tabla y todos los
datos, índices, triggers, restricciones y especificaciones de permisos para esa tabla.
Debe tener cuidado al utilizar 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:
La sintaxis básica de la instrucción DROP TABLE es la siguiente. Opcionalmente, puede especificar
el nombre de la base de datos junto con el nombre de la tabla, como se indica a continuación:

DROP TABLE nombre_basededatos.nombre_tabla;

Ejemplo
Primero verificaremos la tabla EMPLEADO y luego la eliminaremos de la base de
datos de la siguiente manera:

DROP TABLE Empelado

8. RESTRICCIONES DE SQLITE
Las restricciones son reglas que se aplican a las columnas de datos de una tabla. Se utilizan para
limitar el tipo de datos que se pueden incluir en una tabla. Esto garantiza la precisión y fiabilidad de
los datos en la base de datos.

7
 Ing. En Diseño y Animación Digital
Las restricciones pueden ser a 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 más utilizadas disponibles en SQLite.
• Restricción NOT NULL: garantiza que una columna no pueda tener un valor NULL.
• Restricción DEFAULT: proporciona un valor predeterminado para una columna cuando no
se especifica ninguno.
• Restricción UNIQUE: garantiza que todos los valores de una columna sean diferentes.
• Clave PRIMARIA: Identifica de forma única cada fila/registro en una tabla de base de datos.
• Restricción CHECK: la restricción CHECK asegura que todos los valores de una columna
satisfagan ciertas condiciones.

8.1. Restricción NOT NULL

De forma predeterminada, una columna puede contener valores NULL. Si no desea que una columna
tenga un valor NULL, debe definir una restricción para ella, especificando que no se permiten valores
NULL.
Un valor NULL no es lo mismo que ningún dato, sino que representa datos desconocidos.
EJEMPLO:
Por ejemplo, la siguiente declaración SQLite crea una nueva tabla llamada EMPLEADO y agrega 5
columnas, tres de las cuales, ID, NombreCompleto y Salario, especifican no aceptar valores NULL

CREATE TABLE EMPLEADO(

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL,
NROHIJOS INT(30),
Direccion CHAR(30),
Salario REAL NOT NULL
);

8.2. Restricción DEFAULT

La restricción DEFAULT proporciona un valor predeterminado a una columna cuando la declaración
INSERT INTO no proporciona un valor específico.
EJEMPLO:
Por ejemplo, la siguiente sentencia SQLite crea una nueva tabla llamada EMPLEADO y añade 5
columnas. Aquí, la columna SALARIO se establece en 3000 de manera predeterminada, por lo que
en caso de que la declaración INSERT INTO no proporcione un valor para esta columna, entonces,
de manera predeterminada, esta columna se establecerá en 3000.

8
 Ing. En Diseño y Animación Digital

CREATE TABLE EMPLEADO (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL,
NROHIJOS INT(30),
Direccion CHAR(30),
Salario REAL DEFAULT 3000
);

8.3. Restricción UNIQUE

La restricción UNIQUE impide que dos registros tengan valores idénticos en una columna. Por
ejemplo, en la tabla EMPLEADO, podría querer evitar que dos o más personas tengan la misma Fecha
de Nacimiento.
EJEMPLO:
Por ejemplo, la siguiente sentencia SQLite crea una nueva tabla llamada EMPLEADO y añade cinco
columnas. Aquí, La columna NOMBRECOMPLETO está configurada como ÚNICA, por lo que no
puede tener dos registros con el mismo nombre completo:

CREATE TABLE EMPLEADO (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL UNIQUE,
NROHIJOS INT(30),
Direccion CHAR(30),
Salario REAL DEFAULT 3000
);

8.4. Restricción de CLAVE PRINCIPAL

La restricción PRIMARY KEY identifica de forma única cada registro de una tabla de base de datos.
Puede haber varias columnas UNIQUE, pero solo una clave principal en una tabla. Las claves
principales son importantes al diseñar las tablas de la base de datos. Las claves primarias son
identificadores únicos.
Las usamos para referirnos a las filas de una tabla. Las claves primarias se convierten en claves
foráneas en otras tablas al crear relaciones entre ellas. Debido a un error de codificación de larga
data, las claves primarias pueden ser nulas en SQLite. Esto no ocurre con otras bases de datos.
Una clave principal es un campo de una tabla que identifica de forma única cada fila o registro de
una tabla de base de datos. Las claves principales deben contener valores únicos. Una columna de
clave principal no puede tener valores nulos.
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 denominan claves compuestas.

9
 Ing. En Diseño y Animación Digital
Si una tabla tiene una clave principal definida en cualquiera de los campos, entonces no puede
haber dos registros que tengan el mismo valor de ese campo.
EJEMPLO:
Ya has visto varios ejemplos arriba donde hemos creado la tabla EMPLEADO con ID como clave
principal

CREATE TABLE EMPLEADO (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL UNIQUE,
NROHIJOS INT(30),
Direccion CHAR(30),
Salario REAL DEFAULT 3000
);

8.5. Restricción CHECK

La restricción CHECK permite que una condición verifique el valor introducido en un registro. Si la
condición se evalúa como falsa, el registro infringe la restricción y no se introduce en la tabla.
EJEMPLO:
Por ejemplo, la siguiente SQLite crea una nueva tabla llamada EMPLEADO y añade siete columnas.
Aquí, añadimos una columna CHECK con SALARIO, para que no haya ningún SALARIO cero:

CREATE TABLE EMPLEADO (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL UNIQUE,
NROHIJOS INT(30),
Direccion CHAR(30),
Salario REAL CHECK(Salario>0)
);

8.6. Restricción DROPPING

SQLite admite un subconjunto limitado de ALTER TABLE. El comando ALTER TABLE de SQLite permite
renombrar una tabla o añadir una nueva columna a una tabla existente. No es posible renombrar ni
eliminar columnas, ni añadir o eliminar restricciones de una tabla.
8.7. Autoincremento (AUTOINCREMENT)
SQLite AUTOINCREMENT es una palabra clave que se utiliza para incrementar automáticamente el
valor de un campo de la tabla. Podemos incrementar automáticamente el valor de un campo usando
la palabra clave AUTOINCREMENT al crear una tabla con un nombre de columna específico.
La palabra clave AUTOINCREMENT solo se puede usar con campos INTEGER.

10
 Ing. En Diseño y Animación Digital
Sintaxis:
El uso básico de la palabra clave AUTOINCREMENT es el siguiente:

CREATE TABLE nombre_tabla (

column1 INTEGER AUTOINCREMENT,
column2 datatype,
.....
columnN datatype,
);

Ejemplo:
Considere la tabla EMPLEADO que se creará de la siguiente manera:

CREATE TABLE Empleado (

ID INT PRIMARY KEY AUTOINCREMENT,
NombreCompleto TEXT NOT NULL,
NroHijos INT,
Direccion CHAR (50),
Salario REAL
);

9. LENGUAJE DE MANIPULACIÓN DE DATOS (DML)

Comando Descripción
INSERT Crea registro
SELECT Recupera registros de una o más tablas
DELETE Eliminar registro
UPDATE Modificar registro

9.1. Consulta INSERT

La declaración INSERT INTO de SQLite se utiliza para agregar nuevas filas de datos a una tabla en la
base de datos.
Sintaxis:
Hay dos sintaxis básicas de la instrucción INSERT INTO como se indica a continuación:

INSERT INTO NOMBRE_TABLA (columna1, columna2, columna3, ...columnaN)]

VALUES (valor1, valor2, valor3, ...valorN);

Aquí, columna1, columna2, ...columnaN son los nombres de las columnas de la tabla en la que
desea insertar datos.

11
 Ing. En Diseño y Animación Digital
Es posible que no necesite especificar el nombre de las columnas en la consulta SQLite si agrega
valores para todas las columnas de la tabla. Sin embargo, asegúrese de que el orden de los valores
coincida con el de las columnas de la tabla. La sintaxis INSERT INTO de SQLite sería la siguiente:

INSERT INTO NOMBRE_TABLA VALUES (valor1, valor2, valor3, ...valorN);

Ejemplo:
Considere que ya ha creado la tabla Empresa en su [Link] de la siguiente manera:

CREATE TABLE Empleado (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL,
NroHijos INT,
Direccion CHAR (50),
Salario REAL
);

Ahora, las siguientes declaraciones crearían seis registros en la tabla EMPLEADO:

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (1, 'PEDRO PEREZ MALDONADO',2, 'JUNIN # 700',5000);

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (2, 'JUAN PEREZ ACEITUNO', 3,'BELEN # 1000',22000);

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (3, 'MARIA GALARDO ROJAS', 4,'JAIME MENDOZA # 1500',15000);

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (4, 'XIMENA ANZE MENDEZ', 2,'TARAPACA # 100',4500);

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (5, 'ROGER MACHACA',1, 'EMILIO PEREZ # 45',6500);

INSERT INTO EMPLEADO (ID, NOMBRECOMPLETO, NROHIJOS, DIRECCION, SALARIO)

VALUES (6, 'RAUL RIOS PEREZ',4, 'JAPON # 3000',8900);

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

INSERT INTO EMPLEADO VALUES (7, 'NEYSA MENDEZ ROJAS', 2,'RELOJ #5',10000);

Todas las instrucciones anteriores crearían los siguientes registros en la tabla EMPLEADO.

12
 Ing. En Diseño y Animación Digital

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

9.2. Consulta SELECT

La instrucción SELECT de SQLite se utiliza para obtener 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
denominan conjuntos de resultados.
Sintaxis:
La sintaxis básica de la declaración SELECT de SQLite es la siguiente:

SELECT columna1, columna2, columnaN FROM nambre_tabla;

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

SELECT * FROM nambre_tabla;

Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

SELECT *
FROM Empleado;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

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

SELECT NOMBRECOMPLETO, SALARIO FROM Empleado;

13
 Ing. En Diseño y Animación Digital

NOMBRECOMPLETO SALARIO
------------------------------------ ------------
PEDRO PEREZ MALDONADO 5000
JUAN PEREZ ACEITUNO 22000
MARIA GALARDO ROJAS 15000
XIMENA ANZE MENDEZ 4500
ROGER MACHACA 6500
RAUL RIOS PEREZ 8900
NEYSA MENDEZ ROJAS 10000

9.3. Consulta de actualización (UPDATE)

La consulta UPDATE de SQLite se utiliza para modificar los registros existentes en una tabla. Puede
usar la Cláusula WHERE con consulta UPDATE para actualizar filas seleccionadas, de lo contrario
se actualizarían todas las filas.
Sintaxis:
La sintaxis básica de la consulta UPDATE con Cláusula WHERE es la siguiente:

UPDATE nombre_tabla
SET columna1 = valor1, columna2 = valor2, ..., columnaN = valorN
WHERE [condición];

Puede combinar N cantidades de condiciones utilizando los operadores AND u OR.

Ejemplo:
Considere la tabla EMPLEADO, a continuación, se muestra un ejemplo que actualizaría la
DIRECCIÓN de un cliente cuyo ID es 6:

UPDATE EMPLEADO SET DIRECCION = 'AVENIDA JAPON # 3000' WHERE ID = 6;

Ahora, la tabla EMPELADO tendría los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
6 RAUL RIOS PEREZ 4 AVENIDA JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

14
 Ing. En Diseño y Animación Digital
Si desea modificar todos los valores de las columnas DIRECCIÓN y SALARIO en la tabla EMPRESA,
no necesita utilizar la Cláusula WHERE y la consulta UPDATE serían las siguientes:

UPDATE EMPLEADO SET DIRECCION = 'AVENIDA JAPON # 3000', SALARIO=20000

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 AVENIDA JAPON # 3000 20000
2 JUAN PEREZ ACEITUNO 3 AVENIDA JAPON # 3000 20000
3 MARIA GALARDO ROJAS 4 AVENIDA JAPON # 3000 20000
4 XIMENA ANZE MENDEZ 2 AVENIDA JAPON # 3000 20000
5 ROGER MACHACA 1 AVENIDA JAPON # 3000 20000
6 RAUL RIOS PEREZ 4 AVENIDA JAPON # 3000 20000
7 NEYSA MENDEZ ROJAS 2 AVENIDA JAPON # 3000 20000

9.4. Consulta de eliminación (DELETE)

La consulta DELETE de SQLite se utiliza para eliminar los registros existentes de una tabla. Puede
usar Cláusula WHERE con consulta DELETE para eliminar filas seleccionadas, de lo contrario se
eliminarán todos los registros.
Sintaxis:
La sintaxis básica de la consulta DELETE con Cláusula WHERE es la siguiente:

DELETE FROM nombre_tabla

WHERE [condición];

Puede combinar N cantidades de condiciones utilizando los operadores AND u OR.

Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

A continuación, se muestra un ejemplo que eliminaría un cliente cuyo ID es 7:

DELETE FROM EMPLEADO WHERE ID = 7;

15
 Ing. En Diseño y Animación Digital
Ahora, la tabla EMPLEADO tendrá los siguientes registros

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA JAPON # 3000 8900

Si desea ELIMINAR todos los registros de la tabla EMPLEADO, no necesita usar la Cláusula WHERE
con consulta DELETE, que quedaría así:

DELETE FROM EMPLEADO;

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

10. SINTAXIS DE SQLITE

SQLite se rige por un conjunto único de reglas y directrices llamadas sintaxis. Este tutorial te ofrece
una introducción rápida con SQLite enumerando toda la sintaxis básica de SQLite.
• Sensibilidad a mayúsculas y minúsculas
Un punto importante para tener en cuenta es que SQLite no distingue entre mayúsculas y
minúsculas, pero hay algunos comandos que sí lo hacen, como GLOB y glob, que tienen un
significado diferente en las declaraciones de SQLite.
• Comentarios
Los comentarios de SQLite son notas adicionales que puede agregar a su código SQLite para
aumentar su legibilidad y pueden aparecer en cualquier lugar; pueden aparecer espacios en blanco,
incluso dentro de expresiones y en medio de otras declaraciones 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 inclusive (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.

16
 Ing. En Diseño y Animación Digital
• Sentencias 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 (;).
• Cláusula AND/OR:

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE CONDICION1 {AND|OR} CONDICION2;

• Cláusula BETWEEN:

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE nombre_columna BETWEEN val-1 AND val-2;

• Cláusula COUNT:

SELECT COUNT (nombre_columna)

FROM nombre_tabla
WHERE CONDICION;};

• Cláusula DISTINCT

SELECT DISTINCT columna1, columna2....columnaN

FROM nombre_tabla;

• Cláusula EXISTS

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE nombre_columna EXISTS (SELECT * FROM nombre_tabla);

• Cláusula GROUP BY

SELECT SUM (nombre_columna)

FROM nombre_tabla
WHERE CONDICION
GROUP BY nombre_columna;

17
 Ing. En Diseño y Animación Digital
• Cláusula HAVING

SELECT SUM (nombre_columna)

FROM nombre_tabla
WHERE CONDICION
GROUP BY nombre_columna
HAVING (función aritmética condición);

• Cláusula IN

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE nombre_columna IN (val-1, val-2, ...val-N);

• Cláusula NOT IN

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE nombre_columna NOT IN (val-1, val-2, ...val-N);

• Cláusula LIKE

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE nombre_columna LIKE {PATTERN};

• Cláusula ORDER BY

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE CONDITION
ORDER BY nombre_columna {ASC|DESC};

• Cláusula WHERE

SELECT columna1, columna2....columnaN

FROM nombre_tabla
WHERE CONDICION;

18
 Ing. En Diseño y Animación Digital
11. OPERADORES
¿Qué es un operador en SQLite?
Un operador es una palabra reservada o un carácter utilizado 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 lógicos
• Operadores bit a bit

11.1. Operadores aritméticos de SQLite:

Supongamos que la variable a contiene 10 y la variable b contiene 20, entonces:
Operador Descripción Ejemplo
+ Suma: agrega valores en 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 valores en 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
% b % a dará 0
resto

11.2. Operadores de Comparación

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

19
 Ing. En Diseño y Animación Digital
Ejemplo
Considere que la tabla Empleado tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

El siguiente ejemplo mostrará el uso de varios operadores de comparación de SQLite.

Aquí, hemos utilizado la Cláusula WHERE, que se explicará en un capítulo aparte, pero por ahora
puedes entender que la Cláusula WHERE se utiliza para colocar una declaración condicional junto
con la declaración SELECT.
La siguiente declaración SELECT enumera todos los registros cuyo SALARIO es mayor a 10000:

SELECT * FROM Empleado WHERE Salario > 10000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros cuyo SALARIO es igual a 22000:

SELECT * FROM Empleado WHERE SALARIO = 22000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000

La siguiente declaración SELECT enumera todos los registros cuyo SALARIO no es igual a 22000:

SELECT * FROM Empleado WHERE SALARIO != 22000;

20
 Ing. En Diseño y Animación Digital

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

La siguiente declaración SELECT enumera todos los registros cuyo SALARIO no es igual a 22000:

SELECT * FROM Empleado WHERE SALARIO <> 22000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

La siguiente declaración SELECT enumera todos los registros cuyo SALARIO sea mayor o igual a
10000:

SELECT * FROM Empleado WHERE SALARIO >= 10000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

11.3. Operadores Lógicos

Aquí hay una lista de todos los operadores lógicos disponibles en SQLite
Operador Descripción
AND El operador AND permite la existencia de múltiples condiciones en la Cláusula WHERE de una declaración SQL.
El operador BETWEEN se utiliza para buscar valores que estén dentro de un conjunto de valores, dado el valor mínimo
BETWEEN
y el valor máximo.
EXISTS El operador EXISTS se utiliza para buscar la presencia de una fila en una tabla específica que cumpla ciertos criterios.
IN El operador IN se utiliza para comparar un valor con una lista de valores literales que se han especificado.
La negación del operador IN que se utiliza para comparar un valor con una lista de valores literales que se han
NOT IN
especificado.
LIKE El operador LIKE se utiliza para comparar un valor con valores similares utilizando operadores comodín.
El operador GLOB se utiliza para comparar un valor con valores similares mediante operadores comodín. Además,
GLOB
GLOB distingue entre mayúsculas y minúsculas, a diferencia de LIKE.

21
 Ing. En Diseño y Animación Digital
El operador NOT invierte el significado del operador lógico con el que se utiliza. Por ejemplo, NOT EXISTS, NOT
NOT
BETWEEN, NOT IN, etc. Este es un operador de negación.
OR El operador OR se utiliza para combinar múltiples condiciones en la Cláusula WHERE de una declaración SQL.
IS NULL El operador NULL se utiliza para comparar un valor con un valor NULL.
IS El operador IS funciona como =
IS NOT El operador IS NOT funciona como !=
|| Agrega dos cadenas diferentes y crea una nueva.
UNIQUE El operador UNIQUE busca unicidad (sin duplicados) en cada fila de una tabla específica.

Ejemplo
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

A continuación, se muestran ejemplos sencillos que muestran el uso de los operadores lógicos de
SQLite. La siguiente instrucción SELECT lista todos los registros donde NROHIJOS es mayor o igual
a 2 y SALARIO es mayor o igual a 10000:

SELECT * FROM Empleado WHERE NROHIJOS >= 2 AND SALARIO >= 10000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

La siguiente declaración SELECT enumera todos los registros donde NROHIJOS es mayor o igual a
2 o SALARIO es mayor o igual a 8000

SELECT * FROM Empleado WHERE NROHIJOS >= 2 OR SALARIO >= 8000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- --------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEEZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

22
 Ing. En Diseño y Animación Digital

La siguiente declaración SELECT enumera todos los registros donde NROHIJOS no es NULL, lo que
significa todos los registros porque ninguno de los registros tiene NROHIJOS igual a NULL:

SELECT * FROM Empleado WHERE NROHIJOS IS NOT NULL;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
2 RELOJ #5 10000

La siguiente declaración SELECT enumera todos los registros donde NOMBRECOMPLETO comienza
con 'MA', sin importar lo que venga después de 'MA'.

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO LIKE 'MA%';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------ ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros donde NOMBRECOMPLETO comienza
con 'MA', sin importar lo que venga después de 'MA':

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO GLOB 'MA*';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros donde el valor AGE es 25 o 27:

SELECT * FROM EMPLEADO WHERE NROHIJOS IN (2, 3);

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

23
 Ing. En Diseño y Animación Digital
La siguiente declaración SELECT enumera todos los registros donde el valor NROHIJOS no es ni 2 ni 3:

SELECT * FROM EMPLEADO WHERE NROHIJOS NOT IN (2, 3);

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900

La siguiente declaración SELECT enumera todos los registros donde el valor de NROHIJOS está ENTRE
(BETWEEN) 2 y 3:

SELECT * FROM EMPLEADO WHERE NROHIJOS BETWEEN 2 AND 3;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

La siguiente declaración SELECT hace uso de una subconsulta SQL donde la subconsulta encuentra
todos los registros con el campo NROHIJOS que tiene SALARIO > 10000 y luego se usa la Cláusula
WHERE junto con el operador EXISTS para enumerar todos los registros donde NROHIJOS de la
consulta externa existe en el resultado devuelto por la subconsulta:

SELECT NROHIJOS FROM EMPLEADO

WHERE EXISTS (SELECT NROHIJOS FROM EMPLEADO WHERE SALARIO > 10000);

NROHIJO
----
2
3
4
2
1
4
2

La siguiente declaración SELECT hace uso de una subconsulta SQL donde la subconsulta encuentra
todos los registros con el campo NROHIJOS que tiene SALARIO > 10000 y la Cláusula WHERE
posterior se usa junto con el operador > para enumerar todos los registros donde la NROHIJOS de la
consulta externa es mayor que el número de hijos en el resultado devuelto por la subconsulta:

24
 Ing. En Diseño y Animación Digital

SELECT * FROM EMPLEADO

WHERE NROHIJOS > (SELECT NROHIJOS FROM EMPLEADO WHERE SALARIO > 10000);

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900

12. EXPRESIONES SQLITE

Una expresión es una combinación de uno o más valores, operadores y funciones SQL que evalúan
a un valor.
Las expresiones SQL son como fórmulas y están escritas en lenguaje de consulta. También se
pueden usar para consultar un conjunto específico de datos en la base de datos.
Sintaxis:
Considere la sintaxis básica de la declaración SELECT de la siguiente manera:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
WHERE [CONDICIÓN | EXPRESIÓN];

Existen diferentes tipos de expresiones SQLite, que se mencionan a continuación:

12.1. Expresiones booleanas:
Las expresiones booleanas de SQLite obtienen los datos basándose en un valor único coincidente.
A continuación, se muestra la sintaxis

SELECT columna1, columna2, columnaN

FROM nombre_tabla
WHERE VALOR ÚNICO QUE COINCIDE CON LA EXPRESIÓN;

A continuación, se muestran ejemplos sencillos que muestran el uso de expresiones booleanas en

la tabla Empleado:

SELECT * FROM EMPLEADO WHERE SALARIO = 15000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

25
 Ing. En Diseño y Animación Digital
12.2. 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 Expresion_numerica as NOMBRE_DE_OPERACIÓN

[FROM nombre_tabla WHERE CONDICIÓN];

Aquí, expresión_numérica se utiliza para expresiones matemáticas o cualquier fórmula. A

continuación, se muestra un ejemplo sencillo mostrando el uso de expresiones numéricas de
SQLite:
SELECT (15 + 6) AS ADICION

ADICION
--------
21

Hay varias funciones integradas como AVG(), SUM(), COUNT(), etc., para realizar lo que se conoce
como cálculos de datos agregados contra una tabla o una columna de tabla específica.

SELECT COUNT(*) AS "REGISTROS" FROM EMPLEADO;

REGISTROS
--------
7

12.3. Expresiones de fecha:

Las expresiones de fecha devuelven valores de fecha y hora del sistema actual y estas expresiones
se utilizarán en diversas manipulaciones de datos.

SELECT CURRENT_TIMESTAMP;

CURRENT_TIMESTAMP
--------------
2025-10-20 18:43:48

26
 Ing. En Diseño y Animación Digital
13. CLÁUSULA WHERE
La Cláusula WHERE de SQLite se utiliza para especificar una condición al obtener datos de una o
varias tablas.
Si se cumple la condición dada (es decir, verdadero), se devuelve un valor específico de la tabla. Se
usaría la Cláusula WHERE para filtrar los registros y obtener solo los necesarios.
La Cláusula WHERE no solo se utiliza en la declaración SELECT, sino que también se utiliza en las
declaraciones UPDATE, DELETE, etc.
Sintaxis:
La sintaxis básica de la declaración SELECT de SQLite con Cláusula WHERE es la siguiente:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
WHERE [condición]

Ejemplo
Puede especificar una condición utilizando operadores de comparación o lógicos como >, <, =, LIKE,
NOT, etc. Considere la tabla EMPLEADO:
A continuación, se muestran ejemplos sencillos que muestran el uso de los operadores lógicos de
SQLite. La siguiente instrucción SELECT lista todos los registros donde NROHIJOS es mayor o igual a
25 y salario es mayor o igual a 15000:

SELECT * FROM EMPLEADO WHERE NROHIJOS >= 2 AND SALARIO >= 15000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros donde NROHIJOS es mayor o igual a 2 O
SALARIO es mayor o igual a 15000:

SELECT * FROM EMPLEADO WHERE NROHIJOS >= 3 OR SALARIO >= 15000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900

27
 Ing. En Diseño y Animación Digital
La siguiente declaración SELECT enumera todos los registros donde NROHIJOS no es NULL, lo que
significa todos los registros porque ninguno de los registros tiene NROHIJOS igual a NULL:

SELECT * FROM EMPLEADO WHERE NROHIJOS IS NOT NULL;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

La siguiente declaración SELECT enumera todos los registros donde NOMBRECOMPLETO comienza
con 'MA', sin importar lo que venga después de 'MA'.

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO LIKE 'MA%';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros donde NOMBRECOMPLETO comienza
con 'MA', sin importar lo que venga después de 'MA':

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO LIKE 'MA*';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ----------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

La siguiente declaración SELECT enumera todos los registros donde el valor NROHIJOS es 2 o 3:

SELECT * FROM EMPLEADO WHERE NROHIJOS IN (2,3);

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------ ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

28
 Ing. En Diseño y Animación Digital
La siguiente declaración SELECT enumera todos los registros donde el valor NROHIJOS no es ni 2 ni
3:

SELECT * FROM EMPLEADO WHERE NROHIJOS NOT IN ( 2, 3 );

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900

La siguiente declaración SELECT enumera todos los registros donde el valor de NROHIJOS está
ENTRE 2 Y 3:

SELECT * FROM EMPLEADO WHERE NROHIJOS BETWEEN 2 AND 3;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------ ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

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

SELECT NROHIJOS
FROM EMPLEADO
WHERE EXISTS (SELECT NROHIJOS FROM EMPLEADO WHERE SALARIO > 15000);

NROHIJOS
-----------
2
3
4
2
1
4
2

29
 Ing. En Diseño y Animación Digital
La siguiente declaración SELECT hace uso de una subconsulta SQL donde la subconsulta encuentra
todos los registros con el campo NROHIJOS que tiene SALARIO> 15000 y la Cláusula WHERE
posterior se usa junto con el operador > para enumerar todos los registros donde la NROHIJOS de la
consulta externa es mayor que la edad en el resultado devuelto por la subconsulta:

SELECT * FROM EMPLEADO

WHERE NROHIJOS > (SELECT NROHIJOS FROM EMPLEADO WHERE SALARIO > 15000);

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------ ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900

14. OPERADOR AND Y OR

El operador AND permite la existencia de múltiples condiciones en la Cláusula WHERE de una
sentencia SQLite. Al usar el operador AND, se asumirá que la condición completa es verdadera
cuando todas las condiciones lo sean.
Por ejemplo:
[condición1] Y [condición2] serán verdaderos solo cuando tanto la condición1 como la condición2
sean verdaderas.
14.1. El operador AND:
Sintaxis:
La sintaxis básica del operador AND con Cláusula WHERE es la siguiente:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
WHERE [condición1] AND [condición2], ...AND [condiciónN];

Se pueden combinar N condiciones mediante el operador AND. Para que la sentencia SQLite realice
una acción, ya sea una transacción o una consulta, todas las condiciones separadas por AND deben
ser verdaderas.
Ejemplo:
Considere la tabla Empleado para el ejemplo:
La siguiente declaración SELECT enumera todos los registros donde NROHIJOS es mayor o igual a 2
AND SALARIO es mayor o igual a 15000.

SELECT * FROM EMPLEADO WHERE NROHIJOS >= 2 AND SALARIO >= 15000;

30
 Ing. En Diseño y Animación Digital

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------ ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000

14.2. El operador OR:

El operador OR también se utiliza para combinar varias condiciones en la Cláusula WHERE de una
sentencia SQLite. Al usar el operador OR, se asumirá que la condición completa es verdadera
cuando al menos una de las condiciones lo es. Por ejemplo, [condición1] OR [condición2] será
verdadera si la condición1 o la condición2 lo son.
Sintaxis:
La sintaxis básica del operador OR con Cláusula WHERE es la siguiente:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
WHERE [condición1] OR [condición2], ...OR [condiciónN]

Se pueden combinar N condiciones mediante el operador OR. Para que la sentencia SQLite realice
una acción, ya sea una transacción o una consulta, solo UNA de las condiciones separadas por el
operador OR debe ser VERDADERA.
Ejemplo:
Considere la tabla EMPLEADO para el ejemplo:
La siguiente declaración SELECT enumera todos los registros donde NROHIJOS es mayor o igual a 2
O SALARIO es mayor o igual a 15000

SELECT * FROM EMPLEADO WHERE NROHIJOS >= 25 OR SALARIO >= 15000;

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- ------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
6 RAUL RIOS PEREZ 4 JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

31
 Ing. En Diseño y Animación Digital
15. CLÁUSULA LIKE
El operador LIKE de SQLite se utiliza para comparar valores de texto con un patrón mediante
comodines. Si la expresión de búsqueda coincide 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 guión bajo (_)
El signo de porcentaje representa cero, uno o varios números o caracteres. El guion bajo representa
un solo número o carácter. Estos símbolos pueden combinarse.
Sintaxis:
La sintaxis básica de % y _ es como sigue:

SELECT * FROM nombre_tabla WHERE columna LIKE 'XXXX%'

o
SELECT * FROM nombre_tabla WHERE columna LIKE '%XXXX%'
o
SELECT * FROM nombre_tabla WHERE columna LIKE 'XXXX_'
o
SELECT * FROM nombre_tabla WHERE columna LIKE '_XXXX'
o
SELECT * FROM nombre_tabla WHERE columna LIKE '_XXXX_'

Puede combinar N condiciones mediante los operadores AND u OR. Aquí, XXXX puede ser cualquier
valor numérico o de cadena.
Ejemplo:
A continuación, se muestran varios ejemplos que muestran la parte WHERE con diferentes
Cláusulas LIKE con operadores '%' y '_':
Declaración Descripción
WHERE SALARY LIKE '200%' Encuentra cualquier valor que comience con 200.
WHERE SALARY LIKE '%200%' Encuentra cualquier valor que tenga 200 en cualquier posición.
WHERE SALARY LIKE '_00%' Encuentra cualquier valor que tenga 00 en la segunda y tercera posición.
WHERE SALARY LIKE '2_%_%' Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de longitud.
WHERE SALARY LIKE '%2' Encuentra cualquier valor que termine en 2.
WHERE SALARY LIKE '_2%3' Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con un 3.
WHERE SALARY LIKE '2___3' Encuentra cualquier valor en un número de cinco dígitos que comience con 2 y termine con 3

32
 Ing. En Diseño y Animación Digital
Tomemos un ejemplo real, consideremos que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

A continuación, se muestra un ejemplo que mostrará todos los registros de la tabla EMPLEADO
donde NOMBRECOMPLETO comienza con ‘R%’:

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO LIKE 'r%';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900

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

SELECT * FROM EMPLEADO WHERE DIRECCION LIKE '%-%';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900

16. CLÁUSULA GLOB

El operador GLOB de SQLite se utiliza para hacer coincidir únicamente valores de texto con un patrón
mediante comodines. Si la expresión de búsqueda se puede hacer coincidir con la expresión de
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 asterisco representa cero o varios números o caracteres. El signo ? representa un solo número o
carácter.

33
 Ing. En Diseño y Animación Digital
Sintaxis:
La sintaxis básica de * y ? es la siguiente:

SELECT * FROM nombre_tabla WHERE column GLOB 'XXXX*'

o
SELECT * FROM nombre_tabla WHERE column GLOB '*XXXX*'
o
SELECT * FROM nombre_tabla WHERE column GLOB 'XXXX?'
o
SELECT * FROM nombre_tabla WHERE column GLOB '?XXXX'
o
SELECT * FROM nombre_tabla WHERE column GLOB '?XXXX?'
or
SELECT * FROM nombre_tabla WHERE column GLOB '????'

Puedes combinar N condiciones mediante los operadores AND u OR. Aquí, XXXX puede ser cualquier
valor numérico o de cadena.
Ejemplo:
A continuación, se muestran varios ejemplos que muestran la parte WHERE que tiene una Cláusula
LIKE diferente con '*' y operadores '?':
Declaración Descripción
WHERE SALARY GLOB '200*' Encuentra cualquier valor que comience con 200.
WHERE SALARY GLOB '*200*' Encuentra cualquier valor que tenga 200 en cualquier posición.
WHERE SALARY GLOB '?00*' Encuentra cualquier valor que tenga 00 en la segunda y tercera posición.
WHERE SALARY GLOB '2??' Encuentra cualquier valor que comience con 2 y tenga al menos 3 caracteres de longitud.
WHERE SALARY GLOB '*2' Encuentra cualquier valor que termine en 2.
WHERE SALARY GLOB '?2*3' Encuentra cualquier valor que tenga un 2 en la segunda posición y termine con un 3.
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, consideremos que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

34
 Ing. En Diseño y Animación Digital
A continuación, se muestra un ejemplo que mostrará todos los registros de la tabla EMPLEADO
donde NOMBRECOMPLETO comienza con R:

SELECT * FROM EMPLEADO WHERE NOMBRECOMPLETO GLOB 'R*';

Esto produciría el siguiente resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900

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

SELECT * FROM EMPLEADO WHERE DIRECCION GLOB '*-*';

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900

17. CLÁUSULA LIMIT

La Cláusula LIMIT de SQLite se utiliza para limitar la cantidad de datos devueltos por la declaración
SELECT.
Sintaxis:
La sintaxis básica de la declaración SELECT con Cláusula LIMIT es la siguiente:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
LIMIT [número de filas]

A continuación, se muestra la sintaxis de la Cláusula LIMIT cuando se utiliza junto con la Cláusula
OFFSET:

SELECT columna1, columna2, columnaN

FROM nombre_tabla
LIMIT [número de filas] OFFSET [número de filas]

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

35
 Ing. En Diseño y Animación Digital
Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

A continuación, se muestra un ejemplo que limita la fila de la tabla según la cantidad de filas que
desea obtener de la tabla:

SELECT * FROM EMPLEADO LIMIT 5;

Esto produciría el siguiente resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500

Pero en ciertas situaciones, puede que necesites seleccionar un conjunto de registros de un

desplazamiento específico. Aquí tienes un ejemplo:
que recoge 3 registros empezando desde la 3ra posición:

SELECT * FROM EMPLEADO LIMIT 3 OFFSET 2;

Esto produciría el siguiente resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500

36
 Ing. En Diseño y Animación Digital
18. CLÁUSULA ORDER BY
La Cláusula ORDER BY de SQLite se utiliza para ordenar los datos en orden ascendente o
descendente, según uno o más columnas.
Sintaxis:
La sintaxis básica de la Cláusula ORDER BY es la siguiente:

SELECT lista_columnas
FROM nombre_tabla
[WHERE condición]
[ORDER BY columna1, columna2, … columnaN] [ASC | DESC];

Puede usar más de una columna en la Cláusula ORDER BY. Asegúrese de que la columna que use
para ordenar esté disponible en la lista de columnas.
Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

A continuación, se muestra un ejemplo que ordenaría el resultado en orden ascendente por

SALARIO:

SELECT * FROM EMPLEADO ORDER BY SALARIO ASC;

Como resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000

37
 Ing. En Diseño y Animación Digital
A continuación, se muestra un ejemplo que ordenaría el resultado en orden descendente por
NOMBRECOMPLETO y SALARIO:

SELECT * FROM EMPLEADO ORDER BY NOMBRECOMPLETO, SALARIO ASC;

Como resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500

A continuación, se muestra un ejemplo que ordenaría el resultado en orden descendente por

NOMBRECOMPLETO:

SELECT * FROM EMPLEADO ORDER BY NOMBRECOMPLETO DESC;

Como resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000

19. CLÁUSULA GROUP BY

La Cláusula GROUP BY de SQLite se utiliza en colaboración con la declaración SELECT para
organizar datos idénticos en grupos.
La Cláusula GROUP BY sigue a la Cláusula WHERE en una declaración SELECT y precede a la
Cláusula ORDER BY.
Sintaxis:
La sintaxis básica de la Cláusula GROUP BY se detalla a continuación. La Cláusula GROUP BY debe
seguir las condiciones de la Cláusula WHERE y preceder a la Cláusula ORDER BY, si se utiliza.

38
 Ing. En Diseño y Animación Digital

SELECT lista_columnas
FROM nombre_tabla
WHERE [condición]
GROUP BY columna1, columna2....columnaN
ORDER BY columna1, columna2....columnaN

Puede usar más de una columna en la Cláusula GROUP BY. Asegúrese de que la columna que use
para agrupar esté disponible en la lista de columnas.
Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

Si desea saber el monto total del salario de cada cliente, entonces la consulta GROUP BY sería la
siguiente:

SELECT NOMBRECOMPLETO, SUM(SALARIO)

FROM EMPLEADO
GROUP BY NOMBRECOMPLETO;

Como resultado:

NOMBRECOMPLETO SUM(SALARIO)
----------------------- --------
JUAN PEREZ ACEITUNO 22000
MARIA GALARDO ROJAS 15000
NEYSA MENDEZ ROJAS 10000
PEDRO PEREZ MALDONADO 5000
RAUL RIOS PEREZ 8900
ROGER MACHACA 6500
XIMENA ANZE MENDEZ 4500

Ahora, creemos DOS registros más en la tabla EMPELADO usando las siguientes instrucciones
INSERT:

INSERT INTO EMPLEADO VALUES (8, ' RAUL RIOS PEREZ ', 1, ' LOA # 200', 25000.);
INSERT INTO EMPLEADO VALUES (9, 'JUAN PEREZ ACEITUNO', 1, 'CALVO # 300', 19000);

39
 Ing. En Diseño y Animación Digital
Ahora, nuestra tabla tiene los siguientes registros con nombres duplicados:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
8 RAUL RIOS PEREZ 1 LOA # 200 25000
9 JUAN PEREZ ACEITUNO 1 CALVO # 300 19000

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

SELECT NOMBRECOMPLETO, SUM(SALARIO)

FROM EMPLEADO
GROUP BY NOMBRECOMPLETO
ORDER BY NOMBRECOMPLETO;

Como resultado:

NOMBRECOMPLETO SUM(SALARIO)
----------------------- --------
JUAN PEREZ ACEITUNO 41000
MARIA GALARDO ROJAS 15000
NEYSA MENDEZ ROJAS 10000
PEDRO PEREZ MALDONADO 5000
RAUL RIOS PEREZ 33900
ROGER MACHACA 6500
XIMENA ANZE MENDEZ 4500

Utilicemos la Cláusula ORDER BY junto con la Cláusula GROUP BY de la siguiente manera:

SELECT NOMBRECOMPLETO, SUM(SALARIO)

FROM EMPLEADO
GROUP BY NOMBRECOMPLETO
ORDER BY NOMBRECOMPLETO DESC;

40
 Ing. En Diseño y Animación Digital
Como resultado:

NOMBRECOMPLETO SUM(SALARIO)
----------------------- --------
XIMENA ANZE MENDEZ 4500
ROGER MACHACA 6500
RAUL RIOS PEREZ 33900
PEDRO PEREZ MALDONADO 5000
NEYSA MENDEZ ROJAS 10000
MARIA GALARDO ROJAS 15000
JUAN PEREZ ACEITUNO 41000

20. CLÁUSULA HAVING

La Cláusula HAVING 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:
La siguiente es 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 utiliza. A continuación, se muestra la sintaxis de la instrucción SELECT,
incluyendo la Cláusula HAVING:

SELECT columna1, columna2

FROM tabla1, tabla2
WHERE [condición]
GROUP BY column1, column2
HAVING [condición]
ORDER BY columna1, columna2

41
 Ing. En Diseño y Animación Digital
Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
8 RAUL RIOS PEREZ 1 LOA # 200 25000
9 JUAN PEREZ ACEITUNO 1 CALVO # 300 19000

A continuación, se muestra un ejemplo que mostrará un registro cuyo número de nombres es menor
a 2:

SELECT *
FROM EMPLEADO
GROUP BY nombrecompleto
HAVING count(nombrecompleto) < 2;

Como resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500

A continuación, se muestra un ejemplo que mostrará un registro cuyo número de nombres es mayor
que 2:

SELECT *
FROM EMPLEADO
GROUP BY nombrecompleto
HAVING count(nombrecompleto) > 1;

Como resultado:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900

42
 Ing. En Diseño y Animación Digital
21. CLÁUSULA DISTINCT
La palabra clave DISTINCT de SQLite se utiliza junto con la declaración SELECT para eliminar todos
los registros duplicados y obtener solo registros únicos.
Puede darse el caso de que haya varios registros duplicados en una tabla. Al obtener estos registros,
es más conveniente obtener solo los únicos en lugar de los duplicados.
Sintaxis:
La sintaxis básica de la palabra clave DISTINCT para eliminar registros duplicados es la siguiente:

SELECT DISTINCT columna1, columna2, … columnaN

FROM nombre_tabla
WHERE [condición]ORDER BY

Ejemplo:
Considere que la tabla EMPLEADO tiene los siguientes registros:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000
8 RAUL RIOS PEREZ 1 LOA # 200 25000
9 JUAN PEREZ ACEITUNO 1 CALVO # 300 19000

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

SELECT NOMBRECOMPLETO FROM EMPELADO;

Esto produciría el siguiente resultado:

NOMBRECOMPLETO
------------------------------
PEDRO PEREZ MALDONADO
JUAN PEREZ ACEITUNO
MARIA GALARDO ROJAS
XIMENA ANZE MENDEZ
ROGER MACHACA
RAUL RIOS PEREZ
NEYSA MENDEZ ROJAS
RAUL RIOS PEREZ
JUAN PEREZ ACEITUNO

43
 Ing. En Diseño y Animación Digital
Ahora, usemos la palabra clave DISTINCT con la consulta SELECT anterior y veamos el resultado:

SELECT DISTINCT NOMBRECOMPLETO FROM EMPLEADO;

Esto produciría el siguiente resultado:

NOMBRECOMPLETO
------------------------------
PEDRO PEREZ MALDONADO
JUAN PEREZ ACEITUNO
MARIA GALARDO ROJAS
XIMENA ANZE MENDEZ
ROGER MACHACA
RAUL RIOS PEREZ
NEYSA MENDEZ ROJAS

22. CLÁUSULA JOINS

La Cláusula "Join" de SQLite se utiliza para combinar registros de dos o más tablas en una base de
datos. Una "JOIN" permite combinar campos de dos tablas utilizando valores comunes a ambas.
SQL define tres tipos principales de uniones:
• CROSS JOIN
• INNER JOIN
• OUTER JOIN
Antes de continuar, consideremos dos tablas: EMPLEADO y DEPARTAMENTO. Ya hemos visto
instrucciones INSERT para rellenar la tabla EMPLEADO.
Supongamos que la lista de registros disponibles en la tabla EMPLEADO es la siguiente:

ID NOMBRECOMPLETO NROHIJOS DIRECCION SALARIO

---- ----------------------- -------- ----------------------------- ------------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

Otra tabla es DEPARTAMENTO tiene la siguiente definición:

CREATE TABLE DEPARTAMENTO(

ID INT PRIMARY KEY NOT NULL,
NOMBRE VARCHAR(50) NOT NULL,
IDEMP INT NOT NULL,
FOREIGN KEY (IDEMP) REFERENCES EMPLEADO(ID)
);

44
 Ing. En Diseño y Animación Digital
Aquí está la lista de declaraciones INSERT para completar la tabla DEPARTAMENTO:

INSERT INTO DEPARTAMENTO (ID, nombre, IDEMP) VALUES (1, 'DTIC', 1 );

INSERT INTO DEPARTAMENTO (ID, nombre, IDEMP) VALUES (2, 'INGENIERIA', 2 );
INSERT INTO DEPARTAMENTO (ID, nombre, IDEMP) VALUES (3, 'FINANZAS', 7 );

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

ID NOMBRE IDEMP
---- ----------------------- --------
1 DTIC 1
2 INGENIERIA 2
3 FINANZAS 7

22.1. La unión cruzada (CROSS JOIN)

Una combinación cruzada (CROSS JOIN) empareja cada fila de la primera tabla con cada fila de la
segunda. Si las tablas de entrada tienen columnas x e y, respectivamente, la tabla resultante tendrá
columnas x+y. Dado que las combinaciones cruzadas pueden generar tablas extremadamente
grandes, se debe tener cuidado de usarlas solo cuando sea apropiado.
La siguiente es la sintaxis de CROSS JOIN:

SELECT ... FROM tabla1 CROSS JOIN tabla2 ...

Basándonos en las tablas anteriores, podemos escribir una unión cruzada de la siguiente manera:

SELECT IDEMP, NOMBRECOMPLETO, NOMBRE

FROM EMPLEADO CROSS JOIN DEPARTAMENTO;

IDEMP NombreCompleto NOMBRE

---- ----------------------------------- --------
1 PEDRO PEREZ MALDONADO DTIC
2 PEDRO PEREZ MALDONADO INGENIERIA
7 PEDRO PEREZ MALDONADO FINANZAS
1 JUAN PEREZ ACEITUNO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 JUAN PEREZ ACEITUNO FINANZAS
1 MARIA GALARDO ROJAS DTIC
2 MARIA GALARDO ROJAS INGENIERIA
7 MARIA GALARDO ROJAS FINANZAS
1 XIMENA ANZE MENDEZ DTIC
2 XIMENA ANZE MENDEZ INGENIERIA
7 XIMENA ANZE MENDEZ FINANZAS
1 ROGER MACHACA DTIC
2 ROGER MACHACA INGENIERIA
7 ROGER MACHACA FINANZAS
1 RAUL RIOS PEREZ DTIC
2 RAUL RIOS PEREZ INGENIERIA
7 RAUL RIOS PEREZ FINANZAS
1 NEYSA MENDEZ ROJAS DTIC
2 NEYSA MENDEZ ROJAS INGENIERIA
7 NEYSA MENDEZ ROJAS FINANZAS
1 RAUL RIOS PEREZ DTIC
2 RAUL RIOS PEREZ INGENIERIA
7 RAUL RIOS PEREZ FINANZAS
1 JUAN PEREZ ACEITUNO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 JUAN PEREZ ACEITUNO FINANZAS

45
 Ing. En Diseño y Animación Digital
22.2. La unión interna (INNER JOIN)
Una unión interna crea una nueva tabla de resultados combinando los valores de las columnas de
dos tablas (tabla1 y tabla2) según el predicado de unión. La consulta compara cada fila de la tabla1
con cada fila de la tabla2 para encontrar todos los pares de filas que cumplen el predicado de unión.
Cuando se cumple el predicado de unión, los valores de las columnas de cada par coincidente de
filas A y B se combinan en una fila de resultados.
Una unión interna (INNER JOIN) es el tipo de unión más común y el predeterminado. Puede usar la
palabra clave INNER opcionalmente.
A continuación, se muestra la sintaxis de INNER JOIN:

SELECT ... FROM tabla1 [INNER] JOIN tabla2 ON expresión_condicional ...

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

SELECT ... FROM tabla1 JOIN tabla2 USING (columna1, ...) ...

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

SELECT ... FROM tabla1 NATURAL JOIN tabla2...

Basándonos en las tablas anteriores, podemos escribir un INNER JOIN de la siguiente manera:

SELECT [Link], NOMBRECOMPLETO, NOMBRE

FROM EMPLEADO INNER JOIN DEPARTAMENTO
ON [Link] = [Link];

La consulta producirá el siguiente resultado:

CI NombreCompleto NOMBRE
---- ---------------------------------- --------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
3 MARIA GALARDO ROJAS FINANZAS

22.3. La unión externa (OUTER JOIN)

La unión externa (OUTER JOIN) es una extensión de la unión interna (INNER JOIN). Aunque el
estándar SQL define tres tipos de uniones externas: izquierda, derecha y completa, SQLite solo
admite la unión externa izquierda.
Las uniones externas tienen una condición idéntica a las uniones internas, expresada mediante las
palabras clave ON, USING o NATURAL. La tabla de resultados inicial se calcula de la misma manera.

46
 Ing. En Diseño y Animación Digital
Una vez calculada la unión principal, una unión externa toma las filas no unidas de una o ambas
tablas, las rellena con valores NULL y las añade a la tabla resultante.
A continuación, se muestra la sintaxis de LEFT OUTER JOIN:

SELECT ... FROM tabla1 LEFT OUTER JOIN tabla2 ON expresión_condicional ...

Para evitar redundancias y abreviar la redacción, las condiciones de OUTER JOIN pueden declararse
con una expresión USING. Esta expresión especifica una lista de una o más columnas:

SELECT ... FROM tabla1 LEFT OUTER JOIN tabla2 USING (columna1, ...) ...

Basándonos en las tablas anteriores, podemos escribir una unión interna de la siguiente manera:

SELECT IDEMP, NOMBRECOMPLETO, NOMBRE

FROM EMPLEADO LEFT OUTER JOIN DEPARTAMENTO
ON [Link] = [Link];

La consulta producirá el siguiente resultado:

CI NombreCompleto NOMBRE
---- ----------------------------------- --------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 MARIA GALARDO ROJAS FINANZAS
XIMENA ANZE MENDEZ
ROGER MACHACA
RAUL RIOS PEREZ
NEYSA MENDEZ ROJAS

23. CLÁUSULA UNIONS

La Cláusula/operador UNION de SQLite se utiliza para combinar los resultados de dos o más
sentencias SELECT sin devolver filas duplicadas.
Para utilizar UNION, cada SELECT debe tener la misma cantidad de columnas seleccionadas, la
misma cantidad de expresiones de columna, el mismo tipo de datos y estar en el mismo orden, pero
no es necesario que tengan la misma longitud.
Sintaxis:
La sintaxis básica de UNION es la siguiente:

SELECT columna1 [, columna2]

FROM tabla1 [, tabla2]
[WHERE condición]
UNION
SELECT columna1 [, columna2]
FROM tabla1 [, tabla2]
[WHERE condición]

47
 Ing. En Diseño y Animación Digital
Aquí la condición dada podría ser cualquier expresión dada según su requisito.
Ejemplo:
A continuación, se utilizará las tablas EMPLEADO y DEPARTAMENTO:
Ahora, unamos estas dos tablas usando la declaración SELECT junto con la Cláusula UNION de la
siguiente manera:

SELECT IDEMP, NombreCompleto, nombre

FROM empleado INNER JOIN DEPARTAMENTO
ON [Link] = [Link]
UNION
SELECT IDEMP, NombreCompleto, nombre
FROM empleado INNER JOIN DEPARTAMENTO
ON [Link] = [Link];

La consulta producirá el siguiente resultado:

CI NombreCompleto NOMBRE
---- ------------------------------ --------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 MARIA GALARDO ROJAS FINANZAS

23.1. La Cláusula UNION ALL:

El operador UNION ALL se utiliza para combinar los resultados de dos declaraciones SELECT
incluidas filas duplicadas.
Las mismas reglas que se aplican a UNION se aplican también al operador UNION ALL.
Sintaxis:
La sintaxis básica de UNION ALL es la siguiente:

SELECT columna1 [, columna2]

FROM tabla1 [, tabla2]
[WHERE condición]
UNION ALL
SELECT columna1 [, columna2]
FROM tabla1 [, tabla2]
[WHERE condición]

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

48
 Ing. En Diseño y Animación Digital
Ejemplo:
Ahora, unamos las dos tablas mencionadas anteriormente en nuestra declaración SELECT de la
siguiente manera:

SELECT IDEMP, NOMBRECOMPLETO, NOMBRE

FROM empleado INNER JOIN DEPARTAMENTO
ON [Link] = [Link]
UNION ALL
SELECT IDEMP, NOMBRECOMPLETO, NOMBRE
FROM empleado INNER JOIN DEPARTAMENTO
ON [Link] = [Link];

La consulta producirá el siguiente resultado:

CI NombreCompleto NOMBRE
---- ------------------------------------ --------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 MARIA GALARDO ROJAS FINANZAS
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
7 MARIA GALARDO ROJAS FINANZAS

24. VALORES NULOS

El término "NULL" de SQLite se utiliza para representar un valor faltante. Un valor "NULL" en una
tabla es un valor en un campo que parece estar en blanco.
Un campo con un valor nulo es un campo sin valor. Es muy importante comprender que un valor nulo
es diferente de un valor cero o de un campo con espacios.
Sintaxis:
La sintaxis básica del uso de NULL al crear una tabla:

CREATE TABLE Empleado (

ID INT PRIMARY KEY NOT NULL,
NombreCompleto TEXT NOT NULL,
NroHijos INT,
Direccion CHAR (50),
Salario REAL NOT NULL
);

Aquí, NOT NULL significa que la columna siempre debe aceptar un valor explícito del tipo de dato
indicado. Hay dos columnas donde no se usó NOT NULL, lo que significa que podrían ser NULL.
Un campo con un valor NULL es aquel que se dejó en blanco durante la creación del registro.

49
 Ing. En Diseño y Animación Digital
Ejemplo:
Sin embargo, el valor NULL puede causar problemas al seleccionar datos, ya que, al comparar un
valor desconocido con cualquier otro, el resultado siempre es desconocido y no se incluye en los
resultados finales. Considere la siguiente tabla, EMPLEADO, con los siguientes registros:

ID NombresCompleto NROHIJOS Direccion Salario

---- ---------------------------------- ------------------- ------------ ---------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 JAIME-MENDOZA # 1500 15000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 EMILIO PEREZ # 45 6500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

Utilicemos la declaración UPDATE para establecer algunos valores que aceptan valores NULL como
NULL de la siguiente manera:

UPDATE EMPLEADO SET DIRECCION = NULL, SALARIO = NULL

WHERE ID IN (3,5)

Ahora, la tabla EMPLEADO debe tener los siguientes registros:

ID NombresCompleto NROHIJOS Direccion Salario

---- ---------------------------------- ------------------- ------------ ---------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
3 MARIA GALARDO ROJAS 4 NULL NULL
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
5 ROGER MACHACA 1 NULL NULL
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

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

SELECT ID, NombreCompleto, NROHIJOS, Direccion, Salario

FROM EMPLEADO
WHERE SALARIO IS NOT NULL;

La consulta producirá el siguiente resultado:

ID NombresCompleto NROHIJOS Direccion Salario

---- ---------------------------------- ------------------- ------------ ---------
1 PEDRO PEREZ MALDONADO 2 JUNIN # 700 5000
2 JUAN PEREZ ACEITUNO 3 BELEN # 1000 22000
4 XIMENA ANZE MENDEZ 2 TARAPACA # 100 4500
6 RAUL RIOS PEREZ 4 AVENIDA-JAPON # 3000 8900
7 NEYSA MENDEZ ROJAS 2 RELOJ #5 10000

50
 Ing. En Diseño y Animación Digital
A continuación, se muestra el uso del operador IS NULL, que enumerará todos los registros donde
SALARIO es NULL:

SELECT ID, NombreCompleto, NROHIJOS, Direccion, Salario

FROM EMPLEADO
WHERE SALARIO IS NULL;

La consulta producirá el siguiente resultado:

ID NombresCompleto NROHIJOS Direccion Salario

---- ---------------------------------- ------------------- ------------ ---------
3 MARIA GALARDO ROJAS 4 NULL NULL
5 ROGER MACHACA 1 NULL NULL

25. SINTAXIS ALIAS

Puede renombrar temporalmente una tabla o columna asignándole un nombre diferente, conocido
como ALIAS. El uso de alias de tabla implica renombrar una tabla en una sentencia SQLite
específica. El cambio de nombre es temporal y el nombre real de la tabla no cambia en la base de
datos. Los alias de columna se utilizan para renombrar las columnas de una tabla para una consulta
SQLite específica.
Sintaxis:
La sintaxis básica del alias de tabla es la siguiente:

SELECT columna1, columna2....

FROM nombre_tabla AS nombre_alias
WHERE [condicion];

La sintaxis básica del alias de columna es la siguiente:

SELECT nombre_columna AS nombre_alias

FROM nombre_tabla
WHERE [condición];

Ejemplo:
Considere las tablas EMPLEADO y DEPARTAMENTO
A continuación, se muestra el uso de TABLE ALIAS donde usamos E y D como alias para EMPLEADO
y DEPARTAMENTO respectivamente:

51
 Ing. En Diseño y Animación Digital

SELECT [Link], NOMBRECOMPLETO, [Link]

FROM EMPLEADOS E, DEPARTAMENTO D
WHERE [Link] = [Link];

La consulta producirá el siguiente resultado:

ID NombresCompleto NOMBRE
---- ------------------------------ -----------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
3 MARIA GALARDO ROJAS FINANZAS

Veamos un ejemplo del uso de COLUMN ALIAS donde IDENTIFICADOR es un alias de la columna ID
y NombreDepartamento es un alias de la columna de nombre:

SELECT [Link] as IDENTIFICADOR, NombreCompleto,

[Link] as NombreDepartamento
FROM EMPLEADO E, DEPARTAMENTO D
WHERE [Link] = [Link];

La consulta producirá el siguiente resultado:

IDENTIFICADOR NombreCompleto NombreDepartamento

---- ------------------------------ ---------------------
1 PEDRO PEREZ MALDONADO DTIC
2 JUAN PEREZ ACEITUNO INGENIERIA
3 MARIA GALARDO ROJAS FINANZAS

52