Creación de Tablas en SQLite

Introducción

En este laboratorio, aprenderá las habilidades fundamentales para crear y administrar tablas en SQLite, un motor de base de datos ligero y sin servidor perfecto para aplicaciones a pequeña escala. Explorará los tipos de datos de SQLite, creará tablas con claves primarias (primary keys), aplicará restricciones (constraints) como NOT NULL y UNIQUE, inspeccionará las estructuras de las tablas utilizando el comando .schema y eliminará tablas de forma segura. A través de ejercicios paso a paso en el entorno de la VM de LabEx, obtendrá experiencia práctica utilizando la herramienta de línea de comandos sqlite3 para construir y administrar tablas de bases de datos. Este laboratorio está diseñado para principiantes, proporcionando un camino claro para comprender la gestión de tablas de SQLite.

Conectarse a SQLite y Crear una Tabla contacts

En este primer paso, se conectará a una base de datos SQLite y creará su primera tabla llamada contacts. SQLite es un motor de base de datos ligero que almacena datos en un solo archivo. Utilizará la herramienta de línea de comandos sqlite3 para interactuar con la base de datos.

Abra una terminal en el entorno de la VM de LabEx. Asegúrese de estar en el directorio de trabajo predeterminado /home/labex/project.
Conéctese a una base de datos SQLite llamada test.db utilizando la herramienta sqlite3. Este comando creará el archivo de base de datos si aún no existe.
```
sqlite3 test.db
```
Este comando abre el shell de SQLite, y verá un prompt como sqlite>, indicando que está dentro del entorno de SQLite.
Cree una tabla llamada contacts con columnas para id, name y phone. Introduzca el siguiente comando SQL en el prompt sqlite>:
```
CREATE TABLE contacts (
    id INTEGER PRIMARY KEY,
    name TEXT,
    phone TEXT
);
```
Este comando crea una tabla llamada contacts. La columna id es un entero y está designada como la PRIMARY KEY (clave primaria), lo que significa que identificará de forma única cada fila de la tabla. Las columnas name y phone son ambas de tipo TEXT, que puede almacenar cualquier dato de tipo cadena (string).

Desglosemos el comando:
- CREATE TABLE contacts: Esto le dice a SQLite que cree una nueva tabla llamada contacts.
- id INTEGER PRIMARY KEY: Esto define una columna llamada id con el tipo de datos INTEGER. La restricción PRIMARY KEY (clave primaria) asegura que cada valor en esta columna sea único y sirva como el identificador primario para cada fila.
- name TEXT: Esto define una columna llamada name con el tipo de datos TEXT, que puede almacenar cualquier dato de tipo cadena (string).
- phone TEXT: Esto define una columna llamada phone con el tipo de datos TEXT, que puede almacenar cualquier dato de tipo cadena (string).

Insertar Datos en la Tabla contacts

Ahora que ha creado la tabla contacts, vamos a insertar algunos datos en ella. Utilizará la sentencia INSERT INTO para añadir nuevas filas a la tabla.

Inserte un nuevo contacto en la tabla contacts. Ejecute este comando en el prompt sqlite>:
```
INSERT INTO contacts (name, phone) VALUES ('John Doe', '123-456-7890');
```
Este comando inserta una nueva fila en la tabla contacts con el nombre 'John Doe' y el número de teléfono '123-456-7890'. A la columna id se le asignará automáticamente un valor único porque es la clave primaria (primary key).

Desglosemos el comando:
- INSERT INTO contacts: Esto le dice a SQLite que inserte datos en la tabla contacts.
- (name, phone): Esto especifica las columnas en las que desea insertar datos.
- VALUES ('John Doe', '123-456-7890'): Esto especifica los valores que se insertarán en las columnas correspondientes.
Inserte otro contacto en la tabla contacts:
```
INSERT INTO contacts (name, phone) VALUES ('Jane Smith', '987-654-3210');
```
Este comando inserta otra fila en la tabla contacts con el nombre 'Jane Smith' y el número de teléfono '987-654-3210'.

Recuperar Datos de la Tabla contacts

Ahora que ha insertado datos en la tabla contacts, vamos a recuperarlos. Utilizará la sentencia SELECT para consultar la tabla y mostrar los datos.

Recupere todos los datos de la tabla contacts. Ejecute este comando en el prompt sqlite>:
```
SELECT * FROM contacts;
```
Este comando selecciona todas las columnas (*) de la tabla contacts y muestra los resultados.

Resultado Esperado:
```
1|John Doe|123-456-7890
2|Jane Smith|987-654-3210
```
La salida muestra los dos contactos que insertó, junto con sus valores id asignados automáticamente.

Desglosemos el comando:
- SELECT *: Esto le dice a SQLite que seleccione todas las columnas de la tabla.
- FROM contacts: Esto especifica la tabla de la que desea recuperar datos.
Recupere solo las columnas name y phone de la tabla contacts:
```
SELECT name, phone FROM contacts;
```
Este comando selecciona solo las columnas name y phone de la tabla contacts y muestra los resultados.

Resultado Esperado:
```
John Doe|123-456-7890
Jane Smith|987-654-3210
```

Crear una Tabla users con Restricciones

Las restricciones (constraints) son reglas que imponen la integridad de los datos en una tabla. Añadamos restricciones NOT NULL y UNIQUE a una nueva tabla llamada users.

Cree una tabla llamada users con restricciones. Ejecute este comando en el prompt sqlite>:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
Este comando crea una tabla llamada users con las siguientes restricciones:
- username no puede ser NULL y debe ser UNIQUE.
- email no puede ser NULL.
Desglosemos el comando:
- CREATE TABLE users: Esto le dice a SQLite que cree una nueva tabla llamada users.
- id INTEGER PRIMARY KEY: Esto define una columna llamada id con el tipo de dato INTEGER. La restricción PRIMARY KEY asegura que cada valor en esta columna sea único y sirva como identificador primario para cada fila.
- username TEXT NOT NULL UNIQUE: Esto define una columna llamada username con el tipo de dato TEXT. La restricción NOT NULL asegura que esta columna no pueda estar vacía, y la restricción UNIQUE asegura que todos los valores en esta columna sean distintos.
- email TEXT NOT NULL: Esto define una columna llamada email con el tipo de dato TEXT. La restricción NOT NULL asegura que esta columna no pueda estar vacía.
- age INTEGER: Esto define una columna llamada age con el tipo de dato INTEGER.
Ahora, intentemos insertar algunos datos que violen estas restricciones para ver cómo funcionan. Primero, intente insertar un usuario sin un nombre de usuario (username):
```
INSERT INTO users (email, age) VALUES ('test@example.com', 25);
```
Verá un error porque la columna username está definida como NOT NULL.

Resultado Esperado:
```
Error: NOT NULL constraint failed: users.username
```
Este error muestra que SQLite aplica la restricción NOT NULL en username, impidiendo la inserción.
A continuación, intente insertar un usuario con un nombre de usuario (username) duplicado. Primero, inserte un usuario válido:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'john.doe@example.com', 30);
```
Luego, intente insertar otro usuario con el mismo nombre de usuario:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'jane.doe@example.com', 25);
```
Verá un error porque la columna username está definida como UNIQUE.

Resultado Esperado:
```
Error: UNIQUE constraint failed: users.username
```
Este error demuestra que SQLite aplica la restricción UNIQUE en username, impidiendo valores duplicados.

Inspeccionar la Estructura de la Tabla con .schema

Puede inspeccionar la estructura de una tabla utilizando el comando .schema. Este comando muestra la sentencia SQL utilizada para crear la tabla, incluyendo los nombres de las columnas, los tipos de datos y las restricciones (constraints).

Inspeccione la estructura de la tabla users. Ejecute este comando en el prompt sqlite>:
```
.schema users
```
Resultado Esperado:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
La salida muestra la sentencia CREATE TABLE para la tabla users, incluyendo las restricciones NOT NULL y UNIQUE en la columna username.

El comando .schema es una herramienta útil para comprender la estructura de sus tablas y verificar que las restricciones (constraints) estén definidas correctamente.
Salga del shell de SQLite:
```
.quit
```
Este comando saldrá del shell de SQLite y le devolverá a la terminal de Linux.

IMPORTANTE: Asegúrese de usar .exit antes de hacer clic en el botón "Continue". De lo contrario, el paso no se podrá verificar porque el historial de sqlite no se registrará.

Eliminar la Tabla contacts

Puede eliminar (drop) una tabla de la base de datos utilizando el comando DROP TABLE. Este comando elimina permanentemente la tabla y todos sus datos, así que utilícelo con precaución.

Conéctese a la base de datos test.db:
```
sqlite3 test.db
```
Elimine la tabla contacts. Ejecute este comando en el prompt sqlite>:
```
DROP TABLE contacts;
```
Este comando elimina la tabla contacts y todos sus datos de la base de datos.

Advertencia: Esta acción es irreversible. Una vez que elimina (drop) una tabla, no puede recuperarla ni sus datos.
Verifique que la tabla contacts ha sido eliminada intentando seleccionar datos de ella:
```
SELECT * FROM contacts;
```
Verá un error porque la tabla contacts ya no existe.
Salga del shell de SQLite:
```
.quit
```

Resumen

En este laboratorio, ha aprendido las habilidades fundamentales para construir y administrar tablas en SQLite. Exploró los tipos de datos de SQLite, creó tablas con claves primarias (primary keys), aplicó restricciones (constraints) como NOT NULL y UNIQUE, inspeccionó las estructuras de las tablas utilizando el comando .schema y eliminó tablas de forma segura (dropped tables). Estas habilidades son esenciales para trabajar con bases de datos SQLite y construir aplicaciones basadas en datos (data-driven applications).