Sqlite
Sqlite
Sqlite
www.linkedin.com/in/antonio-padial-solier
Descargado en: www.detodoprogramacion.org
Todos los derechos reservados
Una de las primeras decisiones que hay que tomar antes de elaborar un
curso como éste es precisamente dar respuesta a esta pregunta ¿a quién va
dirigido? ¿a quién va a ser más útil?
En el caso de la serie “Aprende en un fin de semana” la respuesta es clara: a
cualquier persona que sepa utilizar mínimamente un ordenador.
Este manual no te convertirá en un experto en la materia. No pretendo
engañar a nadie, uno no se convierte en un maestro de la noche a la mañana,
pero sí que te garantizo que al finalizar este libro te desenvolverás con
soltura a la hora de utilizar SQL en las situaciones más habituales.
¿Estás desarrollando una web y quieres utilizar MySQL para almacenar
información? ¿estás estudiando y se te atraganta la asignatura de base de
datos? ¿quieres aprender SQL para mejorar tu currículum o dar un giro a tu
vida laboral? o ¿símplemente tienes curiosidad por conocer este lenguaje y
sus posibilidades? A todos vosotros bienvenidos, habéis dado con el libro
adecuado.
¿Cuál es el objetivo?
¿Cómo utilizarlo?
En este capítulo:
1. Aprenderás qué es una base de datos y cuál es el papel de SQL
a la hora de utilizarla.
Una base de datos no es más que un software, esto es, un programa como
puede ser un sistema operativo o un antivirus, cuyo principal objetivo es
almacenar información.
Piensa en ella como si fuera un armario con multitud de baldas donde
guardar la ropa o en un archivador donde almacenar nuestras notas.
Por ejemplo, cuando entramos en nuestro muro de Facebook, escribimos
algo y lo enviamos, tanto el texto como las fotos y vídeos que hayamos
adjuntado tienen que guardarse en algún sitio para que puedan verse cada
vez que nosotros o nuestros contactos accedan a nuestro perfil.
Pues bien, ese sitio es la base de datos y dado que no es una persona capaz
de comprender un lenguaje natural sino un software, necesitamos un
mecanismo para indicarle qué información guardar o qué queremos
recuperar. Ese mecanismo es precisamente el lenguaje SQL.
En este capítulo:
1. Aprenderás los elementos fundamentales del modelo relacional:
tablas, columnas, registros, relaciones y restricciones.
Un poco de teoría
Tablas
Campos o columnas
No todos los armarios (tablas) tienen por qué ser iguales: unos tendrán más
baldas, otros menos pero más grandes, etc. en función de los artículos que
se vayan a guardar.
En una base de datos estas baldas son las columnas de las tablas. Cuando se
crea una, aparte de darle nombre, es imprescindible indicar qué columnas la
forman.
Registros
Relaciones
Las relaciones son el concepto más complejo de entender y dado que son
difíciles de extrapolar al mundo real, lo más sencillo es que lo veamos con
un ejemplo del modelo relacional.
Pensemos en una base de datos donde queremos almacenar la lista de
vehículos de los que dispone una empresa de renting. Supongamos que por
cada uno de ellos queremos conocer la matrícula, marca, el modelo, la
cilindrada, el consumo mixto y los kilómetros recorridos.
Obviamente lo más sencillo es guardarlo todo en una tabla con el siguiente
aspecto:
Tabla VEHÍCULOS
MATRÍCULA MARCA MODELO CILINDRADA CONSUMO KM
Restricciones
Resumiendo
Has aprendido que a grandes rasgos una base de datos relacional no es más
que un conjunto de tablas que se relacionan entre sí.
Cada una de las tablas están formadas por una o varias columnas y son el
lugar donde se almacenan los datos, esto es, números, fechas, textos,
imágenes, etc.
Finalmente has aprendido que podemos establecer restricciones
(CONSTRAINTS) para controlar la información que guardamos.
Descargado en: www.detodoprogramacion.org
En este capítulo:
1. Configurarás todo lo necesario para utilizar SQLite en el resto
del curso.
Ahora que ya sabes qué es una base de datos y para qué se utiliza SQL,
estás listo para configurar tu entorno de pruebas.
A lo largo de todo el curso utilizaremos SQLite por los siguientes motivos:
1. No necesita instalación. Como hemos dicho al principio el
tiempo es oro, por lo que no queremos que lo pierdas intentando
resolver problemas de configuración.
2. Es inmensamente popular. Según db-engines (http://db-
engines.com/en/ranking) en Octubre de 2015 SQLite era la
novena base de datos más popular del mundo.
3. Es multiplataforma por lo que podrás utilizarla tanto si tu
sistema operativo es Windows como OSX o Linux.
4. Y finalmente, es completamente gratuito.
Descargar el software
En este capítulo:
1. Aprenderás los principales tipos de datos que pueden utilizarse
en SQL.
2. Comprenderás por qué es importante elegir el más adecuado
para cada situación.
Los más importantes con los que trabajaremos a lo largo del curso son:
● Texto: el más común. Se utiliza para almacenar cualquier texto
como un nombre, un DNI o un comentario en un blog.
● Números: con o sin decimales. La diferencia es importante ya
que para un ordenador es mucho más costoso trabajar con los
segundos.
● Fechas: es un tipo de dato especial que aparte de almacenar la
fecha en sí, nos permite manipularla sumando o restando minutos,
horas, días...
Si quieres profundizar más en el tema, en este enlace de la Wikipedia
encontrarás la lista de tipos de SQL
(https://en.wikipedia.org/wiki/SQL#Data_types), en éste de w3schools
están los de las bases de datos más populares
(http://www.w3schools.com/sql/sql_datatypes.asp) y en este otro los que
admite SQLite (https://www.sqlite.org/datatype3.html)
A los informáticos no nos gustan las cosas sencillas por lo que sí, una base
de datos puede admitir tipos de datos propios.
SQL es un lenguaje estándar y por lo tanto define la teoría, luego son los
productos como SQLite, MySQL u Oracle los que deciden cómo
implementarlo.
A grandes rasgos todas las bases de datos comparten el 80% del lenguaje
SQL, pero siempre existen características particulares y una de éstas pueden
ser tipos de datos propios o lo que es más común, nombres diferentes para
algunos de ellos.
Por ejemplo, todas admiten números enteros aunque algunas los llaman
INTEGER otras símplemente INT y existan variantes como BIGINT o
SMALLINT. También es normal encontrar el tipo texto (TEXT) pero
existen multitud de variantes como CLOB, uno especial que admite hasta 4
GB de información en una única columna.
Esto implica que cuando empieces a trabajar con algún producto que no sea
SQLite, una de las primeras cosas que tendrás que revisar son los datos que
admite.
SQLite
Los cuatro tipos con los que trabajaremos a lo largo del curso son:
1. INTEGER: Permite almacenar un número entero positivo o
negativo.
2. TEXT: Para almacenar texto.
3. REAL: Números positivos o negativos con decimales.
4. DATETIME: Fechas.
Otra de las características particulares de SQLite es que no permite limitar
el tamaño de un campo. En otras bases de datos como Oracle o MySQL al
definir un campo numérico o de texto especificamos también su tamaño
máximo. Es decir, cuando decimos que una columna guardará códigos
postales españoles, podemos limitarla a 5 caracteres que es lo máximo que
pueden tener.
Es un mecanismo importante para controlar que la información guardada es
correcta y para facilitar el trabajo de la base de datos a la hora de almacenar
y recuperar la información, pero no es imprescindible para cumplir nuestro
objetivo que no es otro que aprender a utilizar SQL.
En todo caso y aunque no haga caso a la restricción, SQLite nos permite
indicar el tamaño máximo al crear nuestras columnas por lo que así lo
haremos a lo largo del curso.
CAPÍTULO 1.5 - TU PRIMERA BASE DE
DATOS
Descargado en: www.detodoprogramacion.org
En este capítulo:
1. Aprenderás los fundamentos del programa DB Browser for
SQLite.
2. Crearás tu primera base de datos.
Muy bien, ya sabes qué es una base de datos y qué podemos almacenar en
ella además de qué es y para qué sirve SQL, así que sólo queda abrir DB
Browser for SQLite y crear una.
Ejecuta el programa y selecciona el menú File -> New Database. Aparecerá
un navegador para que le des un nombre y selecciones donde quieres
guardarla (en SQLite la base de datos se guarda en un único archivo). Por
mi parte he elegido “MITIENDA”. Asigna la extensión .sqlite3 ya que te
simplificará el trabajo a la hora de abrirla de nuevo.
A continuación aparecerá un asistente con el título “Edit table definition”
que nos permite crear tablas con el editor visual. Haz click en “Cancel” ya
que la idea es que hagamos todo con SQL directamente.
Y finalmente aparecerá la interfaz completa del programa con la base de
datos MITIENDA abierta. Si ¡ya has creado tu primera base de datos!
Ventana principal del programa
En SQLite si, una base de datos no es más que un simple archivo donde se
almacenan todas las tablas, columnas, registros, etc.
Pero esto no quiere decir que sea así en todos los productos, de hecho lo
normal es que una base de datos se gestione mediante multitud de archivos
y directorios. Esto depende del producto en concreto y del tamaño que
tenga la base de datos ya que no es lo mismo gestionar las entradas de un
blog, que las transacciones de una entidad bancaria.
CAPÍTULO 1.6 - CREACIÓN DE TABLAS
En este capítulo:
1. Crearás tablas con distintas columnas y tipos.
2. Escribirás tus primeras sentencias SQL.
3. Utilizarás las facilidades que nos proporciona DB Browser for
SQLite para explorar las tablas de una base de datos.
4. Aprenderás el significado de los conceptos “esquema” e
“instancia”.
Un pequeño acto de fe
Finalmente sólo queda guardar los cambios. Para ello pulsa la opción
“Write Changes” de la barra de menús. Esta es una particularidad de SQLite
y debes tenerla en cuenta a lo largo del curso: siempre que realices una
operación y quieras guardarla debes pulsar esta opción.
Ya profundizaremos en ello más adelante pero conviene destacar que en
otras bases de datos la operación de crear o eliminar una tabla es
irreversible, es decir, no hay un “Write Changes” o un “Revert Changes”.
Esquema e Instancia
Hasta ahora lo único que hemos creado es una base de datos con una tabla
vacía, es decir, un “contenedor” de información. Pues bien, a este
contenedor, es decir, al conjunto de elementos que componen una base de
datos a excepción de los propios datos, normalmente se le denomina
“esquema de base de datos”.
Por su parte una “instancia de base de datos” es una base de datos con
contenido.
Haciendo un símil con el mundo real piensa en un fabricante de armarios
que diseña un nuevo modelo, o lo que es lo mismo, crea un nuevo
“esquema de base de datos”. A continuación fabrica 1.000 unidades y las
vende a diferentes clientes. Pues bien, cada uno de estos mil armarios sería
una “instancia de base de datos”.
Lo normal es que una base de datos se cree a partir de un esquema para dar
servicio a algún tipo de software como por ejemplo Wordpress.
Éste es una de las plataformas más utilizadas para crear blogs y basa su
funcionamiento en una base de datos MySQL que es donde se almacenan
todos los artículos, comentarios, etc.
Pues bien, cuando instalamos Wordpress una de las primeras cosas que se
hacen es crear una nueva instancia de base de datos MySQL a partir de un
esquema predefinido.
Esa instancia es la que utiliza el blog para guardar información, es decir,
todos los blogs hechos con Wordpress comparten “esquema de base de
datos” (tienen una base de datos con el mismo número de tablas, columnas,
índices y relaciones).
En este capítulo:
1. Aprenderás cómo grabar filas en una tabla utilizando
sentencias SQL.
2. Utilizarás DB Browser for SQLite para ver el contenido de las
tablas.
3. Crearás tus primeras sentencias SQL para consultar datos.
Buscar información
SELECT nos permite buscar datos en una tabla. Ésta es una de las
funciones principales de SQL por lo que es una de las palabras clave que
más utilizarás a lo largo del curso.
Escribe y ejecuta la siguiente query (que es como comúnmente se
denominan las sentencias SQL):
SELECT * FROM USUARIOS
WHERE ALIAS = 'admin'
Si todo ha ido bien verás una rejilla con un único registro y un mensaje de
confirmación más abajo:
SQL es un lenguaje diseñado para que parezca natural así que al igual que
para crear tablas (CREATE TABLE) y para insertar registros (INSERT
INTO), la sintaxis para consultar información es bastante comprensible.
1. Empezamos por la palabra clave SELECT que le ordena a la
base de datos que busque información. A continuación
enumeramos las columnas a mostrar. Si necesitamos todas
podemos utilizar el símbolo asterisco (*).
2. A continuación debemos indicar en qué tablas buscar, para ello
utilizamos la palabra FROM junto con el nombre de la misma.
3. Finalmente le decimos a la base de datos qué registros
queremos que nos devuelva: todos o los que cumplan alguna
condición. Para ello utilizamos WHERE y en este caso una
condición que especifica que estamos buscando aquellos cuyo
ALIAS sea “admin”.
En resumen, lo que le hemos preguntado a la base de datos es: “Dime el
alias, el e-mail y el password de los usuarios cuyo alias sea ‘admin’”
Finalmente destacar que normalmente hablamos de buscar o consultar
información, es decir, tras insertar registros en la base de datos nos
dedicamos a hacerle preguntas.
Esto implica que al contrario del símil del armario donde guardamos y
sacamos objetos, la lectura de información en una base de datos no es
destructiva, es decir, la información sigue ahí hasta que la borremos de
forma explícita.
Resumimos
¡Enhorabuena! has finalizado el primer día del curso y por lo tanto ya tienes
los conocimientos básicos para continuar con tu aprendizaje del lenguaje
SQL.
A lo largo de esta jornada has aprendido que una base de datos no es más
que un software diseñado para almacenar información, esto es, textos,
fechas, imágenes, números, etc. y que SQL es el lenguaje estándar que se
utiliza para manipularla y realizarle preguntas.
También has aprendido qué significa exactamente el término “relacional” y
por lo tanto qué elementos componen una base de datos: tablas, columnas,
registros, relaciones y restricciones principalmente.
Al igual que pasa con cualquier tipo de software, existen multitud de
productos en el mercado cada uno de ellos con sus características propias y
por lo tanto más o menos adecuados en función de para qué se vayan a
utilizar. No es lo mismo almacenar el contenido de un blog que el registro
telefónico de una operadora móvil.
En el curso hemos elegido SQLite ya que es gratis, potente y fácil de
instalar. Has configurado la herramienta DB Browser for SQLite que al
igual que la base de datos es gratuita, multiplataforma, tiene todas las
funcionalidades básicas y es fácil de manejar.
Y finalmente has realizado tus primeras operaciones sobre una base de
datos: crearla, construir una tabla, insertar registros y buscar información.
DÍA 2
En contrapartida al primer día donde los capítulos fueron teóricos, los que
te esperan a continuación son en su mayoría prácticos. Escribirás numerosas
sentencias SQL así que pruébalas todas y tal y como comentamos
anteriormente, experimenta y pon en práctica lo que vayas aprendiendo.
CAPÍTULO 2.1 - EL LENGUAJE SQL
En este capítulo:
1. Aprenderás las características generales del lenguaje SQL.
2. Se enumeran las restricciones que existen a la hora de dar
nombres a las tablas, columnas, etc. de una base de datos.
3. Repasaremos los distintos tipos de datos que existen.
Introducción
Palabras clave
Nombres
Operadores
Tipos de datos
Los últimos elementos que componen el lenguaje son los tipos de datos,
esto es, los distintos tipos de valores que podremos guardar en las columnas
de una tabla. Como adelantamos en los primeros capítulos del libro, los que
utilizaremos a lo largo del curso son:
1. INTEGER: Números enteros positivos o negativos.
2. TEXT: Textos.
3. REAL: Números positivos o negativos con decimales.
4. DATETIME: Fechas.
SELECT
*
FROM USUARIOS
Saltos de línea y tabulaciones:
SELECT *
FROM USUARIOS
En este capítulo:
1. Aprenderás a crear y modificar tablas.
2. Utilizarás la sentencia DROP TABLE para eliminarlas.
3. Aprenderás a definir columnas con una longitud
predeterminada.
CREATE TABLE
Lo primero que debemos hacer para utilizar una base de datos es crear las
tablas que la forman mediante la instrucción CREATE TABLE cuya
sintaxis es:
# IMPORTANTE
CREATE TABLE nombre_tabla (
nombre_columna_1 tipo_columna_1 (tamaño_columna_1),
nombre_columna_2 tipo_columna_2 (tamaño_columna_2),
nombre_columna_n tipo_columna_n (tamaño_columna_n)
)
Para practicar intenta deducir si los siguientes valores son correctos en base
a la columna en la que se intentan guardar:
1. Columna IMPORTE de tipo REAL (6,2)
a. -1814
b. 2015,23
c. -1456,567
d. 23
e. 12,887
a) si b) si c) no d) si e) no
2. Columna OBJETO de tipo TEXT (10)
a. Bombilla
b. Bombilla de bajo consumo
c. Vaso
d. Vaso alto
a) si b) no c) si d) si
# EJERCICIO
A tener en cuenta:
● El DNI puede estar formado por 8 números y un dígito de
control por lo que el tipo mínimo es un TEXT (9).
● El número de socio debe ser un INTEGER (4) y la edad un
INTEGER (3) ya que los clientes siempre tendrán menos de 999
años.
● Los puntos necesitan 5 dígitos enteros y 2 decimales de ahí que
la solución sea un REAL (7,2).
ALTER TABLE
# IMPORTANTE
ALTER TABLE nombre_tabla
RENAME TO nuevo_nombre
Por ejemplo:
# IMPORTANTE
ALTER TABLE nombre_tabla
ADD COLUMN nombre_columna tipo_columna (tamaño_columna)
# IMPORTANTE
ALTER TABLE nombre_tabla
DROP COLUMN nombre_columna
# IMPORTANTE
ALTER TABLE nombre_tabla
RENAME COLUMN nombre_columna TO nuevo_nombre
# EJERCICIO
Escribe las sentencias SQL necesarias para realizar los siguientes cambios
en la tabla CLIENTES:
1. Añadir una columna para registrar direcciones de e-mail de
como mucho 50 caracteres de largo.
2. Añadir otra para los teléfonos fijos.
3. Eliminar la columna de puntos dado que ya ha terminado la
promoción.
4. Cambiar DNI por NIF permitiendo por lo tanto registrar
autónomos como clientes de la tienda.
La solución sería (ten en cuenta que las dos últimas no funcionan en SQLite
debido a las limitaciones comentadas anteriormente):
DROP TABLE
# IMPORTANTE
DROP TABLE nombre_tabla
En este capítulo:
1. Aprenderás a guardar registros en una tabla.
INSERT INTO
Muy bien, ya has aprendido a crear, modificar y eliminar tablas así que te
estarás preguntando ¿cómo puedo llenarlas de contenido? es decir ¿cómo
puedo almacenar información en ellas? Pues muy sencillo, mediante la
instrucción INSERT INTO:
# IMPORTANTE
INSERT INTO nombre_tabla
VALUES (valor_1, valor_n)
A tener en cuenta:
● Los valores que vamos a guardar en las columnas de tipo TEXT
se delimitan entre comillas simples (‘). La necesidad de utilizar
separadores en los textos es algo común a todos los lenguajes de
programación.
● Por su parte, los números no necesitan ningún tipo de
delimitador.
● Para especificar decimales utilizamos un punto (.).
● Las fechas debemos escribirlas siguiendo el siguiente formato:
año (4 dígitos) - mes (2 dígitos) - día (2 dígitos), como por
ejemplo '1978-08-21'.
● NULL es la palabra reservada de SQL para representar el valor
nulo, es decir, indica que en esa columna no se guardará ningún
valor.
Ahora, si vamos a la pestaña “Browse Data” veremos el contenido de la
tabla con el registro que acabamos de insertar:
Primer registro de la tabla
En este caso hemos especificado un valor para cada una de las columnas,
pero no es imprescindible, es decir, SQL nos permite omitir columnas
cuando creamos un nuevo registro. Para ello se utiliza una variante de la
sentencia INSERT INTO:
# IMPORTANTE
INSERT INTO nombre_tabla (columna_1, columna_n)
VALUES (valor_1, valor_n)
✔ INSERT INTO
✔ nombre_tabla
✔ (columna_1, columna_n): nombres de las columnas separadas
por comas.
✔ VALUES
Por defecto, la base de datos asignará el valor NULL a los campos en los
que no hayamos guardado un valor.
En el segundo registro hay columnas sin valor
table CLIENTES has 11 columns but 1 values were supplied: INSERT INTO
CLIENTES VALUES ('ROBERTO')
# EJERCICIO
En este capítulo:
1. Estudiaremos qué son las restricciones de una base de datos
relacional.
2. Aprenderás a establecer la denominada “restricción de clave
primaria” o PRIMARY KEY CONSTRAINT, fundamental para
casi todas las tablas.
Una restricción no es más que una prohibición, una norma a cumplir por
todos y cada uno de los registros de una tabla. Las hay de varios tipos
siendo la fundamental y con la que trabajaremos a lo largo del curso la
PRIMARY KEY o símplemente PK.
Ésta establece que no pueden existir dos registros con los mismos valores
en una serie de columnas. Por ejemplo, si estamos guardando clientes en
una tabla, podemos definir la PK en la columna DNI evitando así que
existan dos personas con el mismo documento.
Salvo excepciones, todas las tablas de una base de datos relacional tienen
PK.
Volviendo al ejemplo que vimos el primer día sobre una tabla con modelos
de vehículos:
MODELO MARCA CILINDRADA CONSUMO
Si queremos que una única columna forme la PK de una tabla, basta con
añadir la palabra reservada PRIMARY KEY a continuación de su tipo en
el SQL de creación.
# IMPORTANTE
CREATE TABLE nombre_tabla (
nombre_columna_1 tipo_columna_1 (tamaño_columna_1)
PRIMARY KEY,
nombre_columna_n tipo_columna_n (tamaño_columna_n)
)
Por ejemplo:
Otra posibilidad es que la PK esté formada por dos o más columnas. En este
caso también utilizaremos la palabra PRIMARY KEY pero esta vez
precediendo al conjunto de columnas que la forman.
# IMPORTANTE
CREATE TABLE nombre_tabla (
nombre_columna_1 tipo_columna_1 (tamaño_columna_1),
nombre_columna_2 tipo_columna_2 (tamaño_columna_2),
nombre_columna_n tipo_columna_n (tamaño_columna_n),
PRIMARY KEY (columna_1, columna_n)
)
# IMPORTANTE
ALTER TABLE nombre_tabla
ADD PRIMARY KEY (columna_1, columna_n)
SQLite sólo nos permite añadir restricciones al crear las tablas por lo que
esta opción no es compatible. En todo caso un ejemplo de uso sería:
# IMPORTANTE
ALTER TABLE nombre_tabla DROP PRIMARY KEY
Al igual que el caso anterior, SQLite no es compatible con esta opción. Un
ejemplo de uso sería.
www.detodoprogramacion.org
www.detodopython.com
www.gratiscodigo.com
CAPÍTULO 2.5 - SELECT BÁSICO
En este capítulo:
1. Utilizarás la sentencia SELECT para leer los registros de una
tabla.
2. Combinarás su uso con DISTINCT para buscar valores
diferentes y con COUNT para contar filas.
3. Ordenarás los resultados mediante ORDER BY.
4. Limitarás las filas a obtener con LIMIT.
Como ya hemos comentado varias veces a lo largo del curso, las principales
funciones de una base de datos son guardar y recuperar información. En los
capítulos anteriores has aprendido a crear tablas y a insertar registros en
ellas. Pues bien, en éste aprenderás a consultar esta información mediante el
uso de la sentencia SELECT.
Ésta es sin duda la palabra clave más potente de SQL ya que admite
multitud de variantes, por lo que en el libro le dedicaremos varios capítulos.
Éste se centra en su forma más básica: la que permite acceder a los datos de
una única tabla.
Su sintaxis es la siguiente:
# IMPORTANTE
SELECT columna_1, columna_n
FROM nombre_tabla
Resultado de la consulta
DISTINCT
Tal y como su nombre indica, esta sentencia nos permite calcular los
diferentes valores de un conjunto de columnas. Su sintaxis es:
# IMPORTANTE
SELECT DISTINCT columna_1, columna_n
FROM nombre_tabla
✔ FROM
✔ nombre_tabla
Por ejemplo, para obtener una lista con los nombres de nuestros clientes:
NUM_TELEFONO DIRECCION
NULL NULL
NULL Calle Manuela Malasaña 23. Madrid
2 NULL NULL
3 NULL NULL
4 NULL NULL
6 NULL NULL
7 NULL NULL
ORDER BY
NOMBRE APELLIDOS
Verás que no hay diferencia entre utilizar ASC o no. Prueba en cambio:
NOMBRE APELLIDOS
LIMIT
Con esta palabra clave podrás indicarle a la base de datos que sólo quieres
recuperar los primeros registros de una consulta.
# IMPORTANTE
SELECT [...]
LIMIT número_registros
Por ejemplo, para mostrar los 3 clientes más mayores podrías ejecutar:
SELECT *
FROM CLIENTES
ORDER BY EDAD DESC LIMIT 3
COUNT
Hasta ahora todas las consultas que hemos hecho han ido enfocadas a
recuperar el contenido de una tabla, es decir, a ver qué datos tiene cada fila.
Si por el contrario lo que queremos saber es símplemente cuántos clientes
se han registrado o cuántos nos han dado su número de teléfono, podemos
utilizar COUNT:
# IMPORTANTE
SELECT COUNT (* / columna / DISTINCT columna)
FROM nombre_tabla
✔ SELECT
✔ FROM
✔ nombre_tabla
Dado que sólo hay dos clientes que hayan informado el NIF, el resultado de
la query es 2.
# EJERCICIO
En este capítulo:
1. Aprenderás a utilizar WHERE para limitar el conjunto de filas
devueltas por una query de tipo SELECT.
2. Utilizarás operadores simples como >, <, = junto con otros
más complejos como BETWEEN, IN o IS NULL.
3. Combinarás varios de ellos gracias a los operadores lógicos
AND, NOT y OR.
Buscar filas
Salvo en los ejemplos de LIMIT, todas las consultas que hemos visto en el
capítulo anterior accedían al contenido completo de una tabla. Es decir,
cuando consultábamos un subconjunto de columnas de la tabla CLIENTES,
la base de datos nos devolvía la información de todas las filas.
Ésto no es problema cuando trabajamos con tablas con unos pocos
registros, pero evidentemente es algo inviable si tenemos que manipular
cientos, miles o millones de filas.
Además, no siempre querremos acceder a todos los datos. Piensa por
ejemplo en la portada de un blog, lo normal no es que aparezcan todas las
entradas del sitio web, sino las diez o veinte primeras. O si estamos viendo
un post en concreto, lo normal es que se muestren sólo los comentarios de
ese artículo.
Pues bien, para limitar el conjunto de filas a leer en una sentencia SELECT
utilizaremos la cláusula WHERE después de la lista de tablas. Por ejemplo:
Comparaciones simples
Lo más habitual es buscar filas en las que una o varias columnas cumplan
una condición determinada de filtrado. Por ejemplo:
● Clientes con el NIF 23232323A.
● Productos con importe menor a 100 €.
● Películas de la categoría “Acción”.
Para construirlas SQL dispone de los siguientes operadores simples:
OPERADOR SIGNIFICADO EJEMPLO SIGNIFICADO
# EJERCICIO
1. SELECT NOMBRE
FROM CLIENTES
WHERE DNI = '78665424D';
2. SELECT DNI
FROM CLIENTES
WHERE DNI != '78665424D';
3. SELECT *
FROM CLIENTES
WHERE NOMBRE = 'SILVIA';
4. SELECT COUNT (*)
FROM CLIENTES
WHERE EDAD > 35;
5. SELECT *
FROM CLIENTES
WHERE PUNTOS > 10
ORDER BY PUNTOS DESC;
BETWEEN
Palabra clave que nos permite buscar filas en base a un rango de valores. Es
equivalente al uso de los operadores <= y >= en la misma condición.
# IMPORTANTE
columna BETWEEN valor_1 AND valor_2
✔ BETWEEN
✔ valor_1: límite inferior del rango. Valor mínimo que puede tener
la columna para cumplir la condición.
✔ AND
✔ valor_2: límite superior del rango.
NOMBRE EDAD
ROBERTO 32
LAURA 45
SELECT *
FROM CLIENTES
WHERE EDAD BETWEEN 45 AND 32
IN
# IMPORTANTE
columna IN (valor_1, valor_n)
✔ IN
NOMBRE APELLIDOS
ANTONIO SÁNCHEZ CABALLERO
Operadores lógicos
Descargado en: www.detodoprogramacion.org
Aunque es bastante común buscar filas en base a una única columna,
muchas veces nos veremos obligados a realizar consultas que involucren
varios atributos.
Piensa por ejemplo en cuando estás navegando por una tienda on-line. Lo
normal es que quieras ver productos de una determinada categoría
(Televisiones por ejemplo) con un precio máximo (900 €) y quizás
restringir la búsqueda a tus marcas favoritas.
Para poder construir estas sentencias contamos con dos operadores lógicos:
AND y OR. Ambos “unen” dos condiciones de la siguiente manera:
# IMPORTANTE
condición_1 AND / OR condición_2
✔ condición_1
✔ AND / OR
✔ condición_2
ANTONIO NULL
ANTONIO NULL
ANTONIO 1968-06-05
NOMBRE APELLIDOS
ANTONIO 1968-06-05
SQLite nos devuelve un registro ya que es el único que cumple las dos.
IS NULL
# IMPORTANTE
columna IS NULL
NOMBRE DNI
ANTONIO NULL
ANTONIO NULL
HÉCTOR NULL
LAURA NULL
ANTONIO NULL
NOT
SELECT *
FROM CLIENTES
WHERE EDAD != 32;
SELECT *
FROM CLIENTES
WHERE NOT EDAD != 32;
SELECT *
FROM CLIENTES
WHERE EDAD BETWEEN 18 AND 25;
SELECT *
FROM CLIENTES
WHERE EDAD NOT BETWEEN 18 AND 25;
SELECT *
FROM CLIENTES
WHERE DNI IS NULL;
SELECT *
FROM CLIENTES
WHERE DNI IS NOT NULL;
SELECT *
FROM CLIENTES
WHERE NOMBRE IN ('ROBERTO', 'ANTONIO');
SELECT *
FROM CLIENTES
WHERE NOMBRE NOT IN ('ROBERTO', 'ANTONIO');
Uso de paréntesis
LAURA NULL 45
NOMBRE FECHA_NAC
ROBERTO 1
HÉCTOR 123
SILVIA NULL
LAURA NULL
SELECT *
FROM CLIENTES
WHERE NOMBRE != 'ROBERTO' AND NUM_SOCIO = 1
# EJERCICIO
2. SELECT *
FROM CLIENTES
WHERE
(NOMBRE IN ('HECTOR', 'LAURA')) OR
(NOMBRE NOT IN ('HECTOR', 'LAURA')
AND NUM_TELEFONO = 679867456);
3. SELECT *
FROM CLIENTES
WHERE DNI = '78665424D'
AND NUM_SOCIO > 0 AND EDAD > 18;
5. SELECT *
FROM CLIENTES
WHERE EDAD BETWEEN 10
AND 35 AND EMAIL IS NOT NULL;
Descargado en: www.detodoprogramacion.org
En este capítulo:
1. Unirás los datos de varias tablas utilizando la sentencia JOIN.
2. Combinarás su uso con WHERE para crear consultas
complejas.
Relacionando información
Hasta ahora todas las sentencias que hemos visto han afectado a una única
tabla. Si bien esto es perfectamente normal a la hora de crearlas o
modificarlas, no lo es tanto cuando hablamos de consultar información.
Las bases de datos nacieron para estructurar y organizar datos, por lo que si
aparte de los relativos a nuestros clientes queremos mantener, por ejemplo,
el historial de compras de cada uno de ellos, lo normal es que existan al
menos dos tablas: una con los clientes y otra con las ventas.
Piensa ahora que necesitas obtener una relación de todas las ventas hechas
en el mes junto con los números de DNI de los compradores. Con las
palabras clave que has aprendido hasta ahora no tendrías más remedio que
hacer dos consultas:
1. Una a la tabla de clientes para obtener el DNI de todos ellos.
2. Otra al historial de compras.
Puede parecerte una buena opción ya que al fin y al cabo son sólo dos
consultas pero ¿y si necesitases acceder a 5 tablas? ¿no sería mejor
consultarlas todas a la vez? Pues bien, para unir varias tablas en una misma
consulta SQL el lenguaje pone a nuestra disposición la palabra clave JOIN.
Como su nombre indica, esta sentencia permite unir dos tablas utilizando
las columnas que necesitemos como “pegamento”. Visualmente puede
representarse de la siguiente forma.
Representación gráfica de un JOIN
Tabla VENTAS
NUM FECHA PRODUCTO CANTIDAD
1 02/02/2015 SILLA 4
1 02/09/2015 LÁMPARA 1
2 02/10/2016 ALFOMBRA 3
Como lo que queremos obtener es una lista de ventas junto con los DNI de
los compradores, lo que realmente necesitamos es “pegar” en la tabla de
VENTAS el DNI de CLIENTES.
Para ello tenemos que relacionar ambas tablas por al menos una columna
que servirá de nexo de unión entre ellas. En el caso que nos ocupa sería
NUM_SOCIO, presente tanto en la tabla de CLIENTES (para identificar a
cada uno de ellos) como en la de VENTAS (para indicar qué cliente compró
cada producto).
Por lo tanto, el JOIN consistiría en añadir a cada fila de la tabla de
VENTAS el DNI del registro de CLIENTE que tenga el mismo valor en la
columna NUM_SOCIO:
NUM FECHA PRODUCTO CANTIDAD DNI
# IMPORTANTE
tabla_1 JOIN tabla_2 ON condicion
✔ JOIN
SELECT VENTAS.NUM_SOCIO,
VENTAS.FECHA,
VENTAS.PRODUCTO,
VENTAS.CANTIDAD,
CLIENTES.DNI
FROM VENTAS
JOIN CLIENTES ON
VENTAS.NUM_SOCIO = CLIENTES.NUM_SOCIO
Como acabamos de ver, para indicarle a SQLite la tabla de la cual debe leer
un dato podemos utilizar el nombre de ésta como prefijo.
Esto es práctico cuando los nombres son cortos y significativos o utilizamos
pocas tablas y/o columnas, pero si su número aumenta o los nombres son
muy extensos la cosa se complica.
Para reducir el tamaño de las consultas, SQL nos permite utilizar un alias,
esto es, un nombre temporal que podemos asignar tanto a tablas como a
columnas.
Su sintaxis es:
# IMPORTANTE
tabla / columna AS alias:
NOMBRE APELLIDO_COMPLETO
Ahora vamos a ampliar nuestro modelo para poder hacer pruebas de uso de
la sentencia.
En primer lugar daremos de alta nuevos clientes.
Recuerda, “*” tras SELECT le indica a la BBDD que queremos leer todas
las columnas. En el ejemplo utilizamos el prefijo V para obtener todas las
de la tabla VENTAS.
NUM_SOCIO FECHA PRODUCTO CANTIDAD DNI
SELECT C.NOMBRE
FROM VENTAS V
JOIN CLIENTES C ON V.NUM_SOCIO = C.NUM_SOCIO
WHERE V.PRODUCTO = 'TAZA'
NOMBRE
MARÍA
Fíjate que no hemos tenido que hacer nada para seleccionar “que hayan
comprado alguna vez”. Esto es porque JOIN sólo muestra datos cuando se
cumple la condición de unión y tal y como comentamos en el capítulo
dedicado a WHERE, los valores vacíos nunca se tienen en cuenta en los
operadores aritméticos =, >, <...
Esto hace que, por ejemplo, en la consulta sólo se seleccionen socios con
ventas y ventas que tengan algún valor en NUM_SOCIO. Si alguna
estuviese asociado a un cliente ajeno a la tabla de clientes, no se hubiera
mostrado en la consulta anterior.
Y para finalizar, supongamos que lo que necesitamos es saber cuántos
clientes mayores de 20 años han comprado marcos de fotos. Para ello
añadiremos a la sentencia las palabras clave COUNT y DISTINCT.
# EJERCICIO
En este capítulo:
1. Unirás los resultados de varias consultas mediante la cláusula
UNION.
2. Aprenderás la diferencia que existe entre UNION y UNION
ALL.
3. Utilizarás EXCEPT para restar resultados.
Supongamos que hemos construido una base de datos para un negocio que
tiene tanto tienda física como tienda online y que los hemos separado en
dos tablas independientes.
Si queremos obtener un listado de las personas que se han dado de alta en
ambos negocios, podemos utilizar la sentencia JOIN que visualmente
puede representarse como la intersección de dos conjuntos:
El resultado serán por lo tanto aquellos clientes que estén en las dos tablas.
Imaginemos ahora que lo que queremos obtener es una lista con todos los
clientes, independientemente de dónde se hayan dado de alta. Para ello
tenemos que “sumar” el contenido de dos consultas: la de los clientes de la
tienda física y las del portal web, lo que visualmente puede representarse
como:
Para realizar esta operación, SQL dispone de la palabra clave UNION cuya
sintaxis es:
# IMPORTANTE
consulta_1 UNION / UNION ALL
consulta_2 UNION / UNION ALL
consulta_n
Vamos a crear una nueva tabla de clientes web en nuestra base de datos y la
poblaremos con registros de ejemplo:
Para obtener una lista con todos los clientes podemos ejecutar:
# IMPORTANTE
consulta_1 EXCEPT
consulta_2 EXCEPT
consulta_n
1 78665424D ROBERTO
En este capítulo:
1. Aprenderás a modificar los valores de las filas que ya existen
en la base de datos mediante la sentencia UPDATE.
2. Borrarás registros concretos de una tabla utilizando la palabra
clave DELETE.
3. Aceptarás o descartarás los cambios con COMMIT y
ROLLBACK.
4. Gestionarás transacciones con la palabra clave BEGIN
TRANSACTION.
DELETE
# IMPORTANTE
DELETE FROM tabla <WHERE>
Tal y como hemos visto al principio, para descartar todos estos cambios
podemos utilizar la sentencia ROLLBACK. Símplemente escríbela en el
editor de SQL y ejecútala.
Si ahora vuelves a consultar la tabla CLIENTES verás que vuelve a tener 10
filas.
UPDATE
# IMPORTANTE
UPDATE tabla SET asignaciones <WHERE>
✔ SET
✔ asignaciones: parejas columna = valor separadas por coma
mediante las que indicamos los nuevos valores de los atributos de la
tabla. Los valores pueden ser fijos (un número, texto, etc.),
operaciones (como por ejemplo sumar 10 a una cantidad) o incluso
pueden referirse a otras columnas de la misma fila.
✔ WHERE: al igual que en DELETE es opcional pero si no
añadimos ninguna condición se modificarán todos los registros de la
tabla.
NOMBRE NUM_SOCIO
ROBERTO 1
ANTONIO 0
ANTONIO 0
HÉCTOR 123
ROLLBACK
Transacciones
# IMPORTANTE
BEGIN TRANSACTION
sentencias SQL
COMMIT / ROLLBACK
# EJERCICIO
BEGIN TRANSACTION;
UPDATE CLIENTES SET EDAD = EDAD + 5;
# EJERCICIO
BEGIN TRANSACTION;
DELETE FROM CLIENTES WHERE NUM_SOCIO IS NULL;
SELECT * FROM CLIENTES;
ROLLBACK;
BEGIN TRANSACTION;
UPDATE CLIENTES SET PUNTOS = NUM_SOCIO;
SELECT * FROM CLIENTES;
ROLLBACK;
BEGIN TRANSACTION;
UPDATE CLIENTES SET NUM_TELEFONO = NUM_TELEFONO_FIJO
WHERE NUM_TELEFONO IS NULL ;
SELECT * FROM CLIENTES;
ROLLBACK;
BEGIN TRANSACTION;
UPDATE CLIENTES SET NUM_SOCIO = 23 WHERE DNI = '78665432Q';
SELECT * FROM CLIENTES;
ROLLBACK;
CAPÍTULO 2.10 - RESUMEN DEL SEGUNDO
DÍA
Resumimos
En este capítulo:
1. Aprenderás qué es una función de SQL.
2. Sumarás valores y obtendrás mínimos y máximos mediante
SUM, MIN y MAX.
3. Utilizarás CAST para cambiar el formato de las columnas.
4. Modificarás textos mediante funciones de SQLite.
SUM
✔ SUM
184 5 36
CAST
# IMPORTANTE
CAST (valor AS tipo)
✔ CAST
✔ valor: valor cuyo tipo vamos a modificar. Puede ser una columna
o un cálculo entre varias.
✔ AS
✔ tipo: tipo al que se va a convertir: INTEGER, REAL… No se
especifica longitud.
SELECT
(SUM (CAST (EDAD AS REAL))
/
COUNT (EDAD)) AS EDAD_MEDIA
FROM CLIENTES
EDAD_MEDIA
36.8
MIN y MAX
# IMPORTANTE
MIN (columna) / MAX (columna)
✔ MIN
✔ columna: Columna de la que se obtendrán los valores sobre los
que se aplicará la función.
Vamos a buscar la edad del cliente más joven y la del más mayor, todo en la
misma sentencia:
Manipulación de textos
Las tres funciones que hemos visto hasta ahora se engloban bajo la
tipología “funciones de agregación” es decir, su objetivo es obtener un
resultado a partir de un conjunto de datos.
Tanto en SQLite como en el resto de bases de datos existen muchas más que
permiten realizar otras tareas siendo las que manipulan textos las siguientes
en importancia.
En nuestra tabla CLIENTES todos los nombres están en mayúsculas así que
¿qué podríamos hacer si necesitásemos mostrarlos en minúsculas? o por
ejemplo ¿cómo podríamos extraer la letra de los NIF para comprobar que es
correcta?
UPPER y LOWER
# IMPORTANTE
UPPER (columna) / LOWER (columna)
✔ UPPER / LOWER
Para SQLite una letra mayúscula es diferente a una minúscula por lo que es
imprescindible utilizar estas funciones para buscar textos. Prueba a ejecutar
lo siguiente:
SUBSTR
Permite “extraer” un trozo de una cadena de texto y por lo tanto es la que
tendrías que utilizar para, por ejemplo, identificar la letra de un NIF. Su
sintaxis es:
# IMPORTANTE
SUBSTR (texto, inicio, tamaño)
✔ SUBSTR
Vamos a probar todas las opciones con una serie de ejemplos partiendo del
DNI del cliente 1 (78665424D).
Partimos de la tercera posición y recogemos un carácter.
78665424D 6
El resultado es vacío.
Dos letras anteriores a la que está situada en tercera posición.
Unir textos
DNI
En este capítulo:
1. Crearás agregados parciales mediante la palabra clave
GROUP BY.
2. Filtrarás los resultados utilizando la cláusula HAVING.
Cálculo de subtotales
# IMPORTANTE
SELECT col_agrupacion_1, col_agrupacion_n, funcion_1, funcion_n
[...]
GROUP BY col_agrupacion_1, col_agrupacion_n
✔ SELECT
✔ col_agrupacion_x: columnas para cuyos valores se generarán
subtotales. Por ejemplo, si la columna es sólo el NUM_SOCIO de la
tabla VENTAS, se generarán resultados para cada socio. Si por el
contrario las columnas son NUM_SOCIO y PRODUCTO, se
calcularán valores para cada pareja de socio y producto.
✔ GROUP BY
NUM_SOCIO NUMERO
1000 3
1001 2
1002 1
Ahora vamos a construir una consulta para calcular cuántas veces han
adquirido cada producto y en qué cantidad total.
SELECT NUM_SOCIO,
PRODUCTO,
COUNT (*) AS NUM_VECES,
SUM (CANTIDAD) AS NUM_UNIDADES
FROM VENTAS
GROUP BY NUM_SOCIO, PRODUCTO
1001 TAZA 1 1
Podemos ver por ejemplo que el socio 1000 ha realizado dos compras de
velas adquiriendo 10 unidades en total.
Seleccionar grupos
Mientras que con WHERE podemos filtrar las filas que se tienen en cuenta
en la sentencia, con HAVING seleccionaremos los subtotales a mostrar.
Siempre se coloca después de GROUP BY y su sintaxis es:
# IMPORTANTE
HAVING condicion
✔ HAVING
Por ejemplo, para mostrar aquellos socios que han hecho dos o más
compras podemos ejecutar lo siguiente:
SELECT NUM_SOCIO,
COUNT (*) AS NUM_COMPRAS
FROM VENTAS
GROUP BY NUM_SOCIO
HAVING COUNT (*) >= 2
NUM_SOCIO NUM_COMPRAS
1000 3
1001 2
SELECT PRODUCTO
FROM VENTAS
GROUP BY PRODUCTO
HAVING COUNT (*) > 1 AND MIN (CANTIDAD) >= 3
PRODUCTO
VELA
Descargado en: www.detodoprogramacion.org
En este capítulo:
1. Crearás consultas a partir de los resultados de otras
sentencias.
2. Las utilizarás para insertar, modificar o borrar filas.
Una subconsulta es una query anidada dentro de otra sentencia SQL. Puede
utilizarse para realizar búsquedas complejas o para otras operaciones como,
por ejemplo, insertar en una tabla el resultado de una sentencia SELECT.
Probablemente ahora te resulte difícil pensar en una situación donde lo
necesites, pero la verdad es que su uso es muy habitual ya que nos da
mucha flexibilidad a la hora de realizar preguntas a la base de datos.
Por ejemplo, ¿cómo podríamos buscar todos los clientes que han hecho más
compras que el NUM_SOCIO = 1001?
Con lo que has aprendido hasta ahora la única solución es ejecutar dos
querys: en la primera calcularías las veces que ha comprado el cliente 1001
y en la segunda buscarías todos los que lo hayan hecho en más ocasiones.
El resultado es “2”.
NUM_SOCIO NUM_COMPRAS
1000 3
Para escribir una subquery lo único que tenemos que hacer es rodearla entre
paréntesis “()”
SELECT NUM_SOCIO
FROM VENTAS
GROUP BY NUM_SOCIO
HAVING COUNT (*) >
(SELECT COUNT (*) FROM VENTAS
WHERE NUM_SOCIO = 1001)
✔ INSERT INTO
El resultado es 3.
En este capítulo:
1. Generarás vistas a partir de sentencias SQL.
2. Las combinarás con otras tablas para realizar consultas
complejas.
Una vista no es más que una query “memorizada” por la base de datos a la
que asignamos un nombre para poder utilizarla como si fuera una tabla
cualquiera.
Son muy útiles para reaprovechar sentencias sin tener que reescribirlas por
completo cada vez que queramos ejecutarlas.
La sintaxis es:
# IMPORTANTE
CREATE VIEW nombre_vista (columnas) AS consulta
✔ CREATE VIEW
✔ nombre_vista: nombre que daremos a la vista.
✔ AS
✔ consulta: sentencia SQL que la base de datos ejecutará siempre
que utilicemos la vista.
Vamos a crear una que devuelva la lista de clientes de la tienda que no están
dados de alta en el comercio on-line:
Probamos a consultarla:
COMMIT;
SELECT * FROM CLIENTES_NO_WEB;
Eliminación de vistas
# IMPORTANTE
DROP VIEW nombre_vista
✔ DROP VIEW
Por ejemplo:
En este capítulo:
1. Realizarás uniones de datos similares a los de JOIN pero
obteniendo no sólo los registros comunes, sino todos los que estén
en la tabla maestra.
JUAN VELA 10
MARÍA TAZA 1
# IMPORTANTE
tabla_maestra LEFT OUTER JOIN tabla_detalle ON condición
✔ ON
ANTONIO
HÉCTOR
JUAN VELA 10
LAURA
MARÍA TAZA 1
SILVIA
ANTONIO
HÉCTOR
JUAN VELA 10
LAURA
ROBERTO
SILVIA
CAPÍTULO 3.6 - OPERACIONES CON
DATETIME
En este capítulo:
1. Aprenderás a visualizar fechas en distintos formatos.
2. Obtendrás el mes, año y día de la semana.
3. Sumarás y restarás periodos a una fecha.
Manipulando fechas
SQLite cuenta con tres funciones que generan los formatos más habituales:
fecha (año-mes-día), tiempo (hora:minuto:segundo) y la unión de las dos.
# IMPORTANTE
DATE (fecha) / TIME (fecha) / DATETIME (fecha)
Vamos a utilizar los tres formatos con las fechas de nacimiento que tenemos
almacenadas en la tabla de clientes:
COMMIT;
SELECT DATE (FECHA), TIME (FECHA)
FROM VENTAS
WHERE NUM_SOCIO = 1000;
DATE(FECHA) TIME(FECHA)
2015-01-12 00:00:00
2015-02-14 00:00:00
2015-06-20 00:00:00
2016-02-23 12:34:56
A tener en cuenta:
● Para indicarle a SQLite que un dato es una fecha basta con
utilizar el formato “año-mes-día horas:minutos:segundos”.
● Podemos utilizar sólo la parte de la fecha o sólo la parte del
tiempo.
# IMPORTANTE
STRFTIME (formato, fecha)
✔ STRFTIME
✔ formato: Cadena de texto con el formato a aplicar. Para
especificar fracciones de una fecha debemos utilizar una serie de
variables. En la documentación oficial de SQLite
(https://www.sqlite.org/lang_datefunc.html) puedes ver la lista
completa.
%M Minutos
%S Segundos
%Y Año
%m Mes (1-12)
AÑO_MES
2016-02
# EJERCICIO
Modificadores
# IMPORTANTE
STRFTIME (formato, fecha, modificador_1, modificador_n)
SELECT NUM_SOCIO,
MIN (FECHA) AS PRIMERA_COMPRA,
STRFTIME ('%Y-%m-%d', MIN (FECHA), '+1 months', '+12 days')
AS FECHA_ENCUESTA
FROM VENTAS
GROUP BY NUM_SOCIO
Fecha actual
FECHA_ACTUAL
2016-03-30 12:46:10
“Un momento ¿no hay FROM?“ Pues no y no es necesario ya que al igual
que muchos otros productos, SQLite nos permite ejecutar querys sin tablas
siempre y cuando sólo utilicemos valores fijos como ‘now’ o una cadena de
texto determinada y funciones sobre ellos.
Es una utilidad muy extendida que nos permite, por ejemplo, realizar
operaciones como ésta donde símplemente queremos obtener la fecha
actual.
CAPÍTULO 3.7 - PROYECTO FINAL
En primer lugar ¡enhorabuena!, has llegado al final del curso y por lo tanto
estás preparado para utilizar SQL en las situaciones más habituales. Y en
segundo lugar ¡prepárate! este pequeño proyecto te pondrá a prueba
obligándote a utilizar todo lo que has aprendido hasta ahora.
Para ello vamos a construir las sentencias necesarias para gestionar un
pequeño blog.
El motivo de elegir este tipo de software es que aunque no lo parezca,
puede ser un producto sumamente complejo compuesto por multitud de
piezas siendo la base de datos una de las más importantes.
Piensa en la página de inicio de un blog cualquiera:
1. En la sección principal con toda seguridad aparecerán los posts,
compuestos de texto, fotos e imágenes que como puedes imaginar,
se han recuperado de una base de datos.
2. También es muy habitual que exista una barra de navegación
lateral con las entradas más visitadas, comentarios de los usuarios,
etc. ¿Dónde está almacenado todo esto? ¡bingo! En la base de
datos.
3. Y para terminar seguramente también existe una segunda barra
lateral con las secciones del blog y que evidentemente, también se
almacenan en la misma base de datos.
Entre todas las tareas a realizar se encuentran la de diseñar el esquema de
base de datos que lo sustentará y la de preparar todas las sentencias
necesarias para crear y consultar los posts, comentarios, etc.
En realidad existen multitud de alternativas para no tener que hacer esto “a
mano” pero aun así el ejemplo es perfectamente válido para los objetivos
que perseguimos: poner en práctica lo aprendido y vislumbrar las infinitas
posibilidades del lenguaje.
Descargado en: www.detodoprogramacion.org
Tabla TAGS
COLUMNA TIPO USO
Tabla COMENTARIOS
COLUMNA TIPO USO
Gracias a ésta un mismo post podrá tener varios tags (de ahí que la clave
sean las dos columnas) y un tag podrá añadirse a todas las entradas que
queramos.
Y con esto damos por finalizado nuestro modelo.
Escribe una sentencia SQL que añada una nueva fila a la tabla
COMENTARIOS. Ten en cuenta que al igual que en POST, la PK de la
tabla es un número entero “autoincrementado”.
Vamos a asumir que todos los autores tienen permiso para editar cualquier
post. Para modificar uno tendrás que actualizar los siguientes campos para
la entrada en cuestión:
● NICK_MOD: Nick del usuario que lo está editando.
● FECHA_MOD: Momento en el que se modifica. Puedes
utilizar la fecha actual.
● TXT_POST: Nuevo texto del post.
Para ayudar a los usuarios a navegar por el contenido del blog, vamos a
crear una sección en uno de los laterales que contenga todos los tags
ordenados alfabéticamente junto con el número de entradas que hay en cada
uno de ellos.
Diseña una consulta que genere ese resultado.
www.detodoprogramacion.org
www.detodopython.com
www.gratiscodigo.com