Nombre de Tu Empresa OTEC
Manual de Contenido
Manejo Básico de Sentencias SQL para Desarrolladores PHP
¡Muy buenos días a todos y todas! Es un placer compartir este espacio con ustedes hoy.
En el dinámico mundo de la tecnología de la información, la gestión de datos es una habilidad fundamental. Las bases de datos relacionales son el pilar de casi cualquier sistema de software moderno, desde aplicaciones móviles hasta complejos sistemas empresariales. Comprender su estructura y funcionamiento es esencial para cualquier profesional de TI.
Hoy, nos sumergiremos en los cimientos de este paradigma: el Modelo Relacional. A través de esta charla, buscaremos:
Mi objetivo es que al finalizar esta sesión, ustedes no solo conozcan estos conceptos, sino que puedan aplicarlos y visualizarlos en escenarios reales, especialmente en nuestro contexto chileno.
A pesar de la emergencia de nuevas tecnologías de bases de datos (NoSQL, NewSQL, etc.), el modelo relacional sigue siendo la columna vertebral de la mayoría de las aplicaciones y sistemas de información críticos a nivel global. En Chile, desde la administración pública (como el Servicio de Impuestos Internos o el Registro Civil) hasta grandes empresas de retail, banca o telecomunicaciones, todos dependen fuertemente de bases de datos relacionales para almacenar y gestionar sus operaciones diarias.
Su importancia radica en su robustez, la garantía de integridad de datos, la facilidad para realizar consultas complejas y su madurez, respaldada por décadas de desarrollo y optimización. Es el lenguaje común para interactuar con la información estructurada.
El modelo relacional no siempre existió. Antes de su aparición, las bases de datos solían ser jerárquicas o de red, con estructuras más rígidas y difíciles de manejar. Fue en 1970 cuando un brillante científico de computación de IBM, Edgar F. Codd, publicó su seminal artículo "A Relational Model of Data for Large Shared Data Banks".
Codd propuso una forma matemática y lógica de organizar los datos en tablas, basándose en la teoría de conjuntos y la lógica de predicados. Su visión fue revolucionaria porque separó la forma lógica en que los usuarios ven los datos de la forma física en que se almacenan, abriendo la puerta a una mayor flexibilidad y simplicidad en la gestión de la información. Aunque inicialmente recibió escepticismo, su modelo demostró ser superior y sentó las bases para el desarrollo de SQL y los SGBDR modernos.
Un SGBDR es el software que permite a los usuarios y aplicaciones interactuar con una base de datos relacional. Son los "motores" que gestionan el almacenamiento, la recuperación y la manipulación de los datos. En Chile, encontramos una amplia variedad de SGBDR en uso:
La elección de un SGBDR depende de factores como el tamaño del proyecto, el presupuesto, los requisitos de rendimiento y la infraestructura tecnológica existente.
Imaginemos una tabla como una hoja de cálculo o una matriz bidimensional. Es la estructura fundamental donde almacenamos nuestros datos de forma organizada. Cada tabla representa una "entidad" del mundo real o un concepto significativo para nuestro sistema. Por ejemplo, en un sistema de ventas, podríamos tener tablas para "Clientes", "Productos", "Ventas", "Empleados", etc.
Una tabla se compone de dos elementos principales:
Analogía: Piensen en una tabla como una ficha de un carnet de identidad chileno. Cada carnet es una fila (un registro único de una persona), y cada campo en el carnet (Nombre, RUT, Fecha de Nacimiento, Domicilio) es una columna (un atributo).
Una fila es una colección de valores relacionados que representan una única instancia de la entidad que la tabla describe. Por ejemplo, en una tabla Clientes, una fila podría contener todos los datos de un cliente específico: su ID, nombre, RUT, dirección, etc. Cada fila es una "tupla" en la terminología relacional.
Una columna define un tipo específico de dato que se almacena para cada fila de la tabla. Cada columna tiene un nombre único y un tipo de dato asociado (que veremos en detalle más adelante). Por ejemplo, en la tabla Clientes, podríamos tener columnas como ID_Cliente, Nombre, Apellido, RUT, Direccion, Telefono, Email.
Para que una tabla sea considerada relacional, debe adherirse a ciertas propiedades clave:
Dentro de una base de datos, no pueden existir dos tablas con el mismo nombre. Esto asegura una referencia clara y sin ambigüedades. Por ejemplo, no podemos tener dos tablas llamadas Clientes en el mismo esquema de base de datos.
El modelo relacional garantiza que el orden en que se almacenan las filas o las columnas no afecta la lógica ni la recuperación de los datos. Podemos consultar los datos sin preocuparnos por su posición física. La información se identifica por el nombre de la columna y por el valor de la clave primaria de la fila.
No puede haber dos filas idénticas en una tabla. Esto se asegura mediante la definición de una clave primaria, que identifica de forma única cada registro. Si tuviéramos dos filas exactamente iguales, no podríamos distinguir entre ellas, lo que comprometería la integridad de los datos.
Dentro de una misma tabla, cada columna debe tener un nombre distinto para evitar confusiones al referenciar los datos. Además, cada columna está asociada a un tipo de dato específico (número, texto, fecha, etc.), lo que restringe los valores que puede contener y asegura la consistencia de los datos almacenados en esa columna.
Veamos cómo se verían algunas tablas comunes en un sistema de una empresa chilena, como un supermercado o una tienda de retail:
ClientesAlmacena la información de los clientes que realizan compras.
| ID_Cliente | RUT | Nombre | Apellido | Direccion | Comuna | Telefono | |
|---|---|---|---|---|---|---|---|
| 1 | 12345678-9 | María | González | Av. Providencia 1234 | Providencia | +56912345678 | maria.g@email.com |
| 2 | 19876543-2 | Pedro | Ramírez | Calle Los Carrera 567 | Concepción | +56987654321 | pedro.r@email.com |
ProductosContiene el catálogo de productos disponibles para la venta.
| ID_Producto | Nombre_Producto | Descripcion | Precio_Unitario | Stock | Categoria |
|---|---|---|---|---|---|
| 101 | Leche Entera 1L | Leche pasteurizada, marca Colun | 1050.00 | 500 | Lácteos |
| 102 | Pan de Molde Integral | Pan de molde 500g, marca Ideal | 1590.00 | 250 | Panadería |
VentasRegistra cada transacción de venta realizada.
| ID_Venta | ID_Cliente | Fecha_Venta | Total_Venta | Metodo_Pago |
|---|---|---|---|---|
| 1001 | 1 | 2023-10-26 | 3500.00 | Tarjeta Crédito |
| 1002 | 2 | 2023-10-26 | 2640.00 | Débito |
Una columna, también conocida como atributo o campo, es el componente más pequeño de una tabla que almacena un tipo específico de dato. Cada columna tiene un nombre que la identifica de manera única dentro de su tabla y un dominio que define los valores permitidos.
El nombre de la columna debe ser descriptivo y único dentro de la tabla. Por ejemplo, Nombre_Cliente, Fecha_Nacimiento, Monto_Total. Un buen nombre facilita la comprensión del esquema de la base de datos.
El dominio de una columna es el conjunto de todos los valores posibles y válidos que esa columna puede contener. Este dominio se define principalmente por el tipo de dato asignado a la columna, pero también puede ser restringido por otras reglas (por ejemplo, un campo Edad solo puede aceptar valores entre 0 y 120).
La selección correcta del tipo de dato es crucial para la eficiencia del almacenamiento, el rendimiento de las consultas y, lo más importante, la integridad de los datos. SQL define varios tipos de datos, y aunque pueden variar ligeramente entre SGBDR, los fundamentales son:
DECIMAL(10, 2) para un precio con dos decimales.ID_Producto: INT (para un identificador único de producto).Stock: SMALLINT (para la cantidad de productos en inventario, si no esperamos más de 32,767 unidades).Precio_Unitario: DECIMAL(10, 2) (para el precio de un producto, asegurando dos decimales para los centavos).Cantidad_Vendida: INT.Nombre_Cliente: VARCHAR(100) (para el nombre completo del cliente).Direccion: VARCHAR(255) (para la dirección, que puede variar mucho en longitud).RUT: VARCHAR(12) (para el Rol Único Tributario chileno, incluyendo el guion y el dígito verificador, ej. "12.345.678-9"). Aunque es numérico, se almacena como texto para preservar el formato y el dígito verificador, que puede ser 'K'.Descripcion_Producto: TEXT (para una descripción detallada de un producto).Fecha_Nacimiento: DATE (solo necesitamos la fecha).Fecha_Venta: DATETIME (para registrar la fecha y hora exacta de una transacción).Fecha_Creacion_Registro: TIMESTAMP (útil para auditoría, a menudo se configura para registrar la fecha y hora de creación automáticamente).Activo: BOOLEAN (indica si un cliente o producto está activo).Elegir el tipo de dato adecuado para cada columna es una decisión de diseño fundamental que impacta directamente en:
INT. Un DECIMAL(10,2) garantiza que un precio siempre tendrá dos decimales, evitando errores de cálculo.SMALLINT en lugar de BIGINT si los valores no superarán 32,767) consume menos espacio en disco. Esto es crítico en bases de datos muy grandes.Una mala elección puede llevar a errores de datos, desperdicio de espacio, lentitud en las operaciones y dificultades en el desarrollo.
Retomando nuestros ejemplos chilenos, veamos la aplicación de tipos de datos:
Clientes| Columna | Tipo de Dato | Justificación |
|---|---|---|
ID_Cliente |
INT |
Identificador numérico único, entero. |
RUT |
VARCHAR(12) |
El RUT chileno puede incluir 'K' como dígito verificador y guiones, por lo que se trata como texto para preservar el formato. Ej: "12.345.678-K". |
Nombre |
VARCHAR(50) |
Nombres de personas, longitud variable. |
Apellido |
VARCHAR(50) |
Apellidos de personas, longitud variable. |
Direccion |
VARCHAR(255) |
Direcciones pueden ser largas y variadas. |
Comuna |
VARCHAR(100) |
Nombres de comunas chilenas. |
Telefono |
VARCHAR(15) |
Números de teléfono, incluyendo prefijo internacional y espacios/guiones. Ej: "+56 9 1234 5678". |
Email |
VARCHAR(100) |
Direcciones de correo electrónico. |
Fecha_Nacimiento |
DATE |
Solo se necesita la fecha de nacimiento. |
Productos| Columna | Tipo de Dato | Justificación |
|---|---|---|
ID_Producto |
INT |
Identificador numérico único. |
Nombre_Producto |
VARCHAR(150) |
Nombre del producto, longitud variable. |
Descripcion |
TEXT |
Descripción detallada del producto, puede ser muy larga. |
Precio_Unitario |
DECIMAL(10, 2) |
Precios en pesos chilenos, con dos decimales para centavos (aunque en Chile no se usan centavos en transacciones, es buena práctica para cálculos internos o divisas). |
Stock |
SMALLINT |
Cantidad de productos en inventario, rara vez supera 32,767. |
Activo |
BOOLEAN |
Indica si el producto está disponible para la venta. |
Las claves son uno de los conceptos más importantes en el modelo relacional. Son atributos (o conjuntos de atributos) especiales dentro de una tabla que cumplen dos propósitos fundamentales:
Sin claves, las bases de datos relacionales perderían su capacidad de organizar y relacionar datos de forma fiable, llevando a la redundancia y a la inconsistencia.
Una Clave Primaria (PK) es una columna o un conjunto de columnas en una tabla que identifica de forma única cada fila de esa tabla. Es el "identificador" principal de la entidad.
Sus características esenciales son:
La clave primaria es crucial para la integridad de la entidad. Garantiza que cada entidad (cada fila) sea única e identificable de manera inequívoca. Sin una PK, no podríamos distinguir entre dos registros que, por casualidad, tuvieran el mismo nombre o dirección, lo que llevaría a ambigüedad y errores en la gestión de datos.
Clientes, ID_Cliente (un entero autoincremental) es una excelente clave primaria. También podríamos considerar el RUT si lo definimos como único y no nulo, ya que en Chile es un identificador único para personas y empresas.Productos, ID_Producto.Ventas, ID_Venta.RUT de un empleado podría ser la clave primaria de la tabla Empleados.Una clave primaria compuesta es aquella que está formada por dos o más columnas. La combinación de los valores de estas columnas es lo que garantiza la unicidad de la fila, no cada columna por separado. Se utilizan cuando una sola columna no es suficiente para identificar un registro de forma única.
Ejemplo: En una tabla que registra las notas de alumnos en diferentes asignaturas, la clave primaria podría ser la combinación de ID_Alumno y ID_Asignatura. Un alumno puede tener muchas notas, pero solo una nota para una asignatura específica.
| ID_Alumno (PK Parte 1) | ID_Asignatura (PK Parte 2) | Nota | Fecha_Evaluacion |
|---|---|---|---|
| 101 | 201 | 6.5 | 2023-09-15 |
| 101 | 202 | 5.8 | 2023-10-20 |
| 102 | 201 | 7.0 | 2023-09-15 |
Aquí, (101, 201) es una combinación única, pero 101 por sí solo no lo es, ni 201 por sí solo.
ID_Cliente, RUT.Una Clave Foránea (FK) es una columna o un conjunto de columnas en una tabla (la tabla "hija" o "referenciadora") que hace referencia a la clave primaria (o a una clave candidata única) de otra tabla (la tabla "padre" o "referenciada").
Su propósito principal es establecer y mantener un enlace lógico entre dos tablas. Es el mecanismo que permite que el modelo relacional "relacione" los datos.
La clave foránea siempre apunta a un valor existente en la clave primaria de la tabla padre. Esto significa que si tenemos un ID_Cliente en la tabla Ventas como FK, ese ID_Cliente debe existir previamente en la tabla Clientes como PK.
La FK es la base de la integridad referencial. Esta integridad garantiza que las relaciones entre tablas sean válidas y que no haya "referencias rotas". Es decir:
Esto asegura la consistencia y validez de los datos a través de todo el esquema.
Ventas, la columna ID_Cliente es una clave foránea que referencia a ID_Cliente (PK) en la tabla Clientes. Esto vincula cada venta a un cliente específico.Detalle_Venta (que almacena los productos de cada venta), la columna ID_Venta sería una FK a ID_Venta (PK) en la tabla Ventas, y ID_Producto sería una FK a ID_Producto (PK) en la tabla Productos.Ejemplo de tabla Ventas con FK:
| ID_Venta (PK) | ID_Cliente (FK → Clientes.ID_Cliente) | Fecha_Venta | Total_Venta |
|---|---|---|---|
| 1001 | 1 | 2023-10-26 | 3500.00 |
| 1002 | 2 | 2023-10-26 | 2640.00 |
| 1003 | 1 | 2023-10-27 | 1200.00 |
Aquí, ID_Cliente en la tabla Ventas asegura que cada venta esté asociada a un cliente válido que existe en la tabla Clientes.
ID_Cliente en Ventas, ID_Producto en Detalle_Venta.Aunque las PK y FK son las más usadas, existen otros tipos de claves en la teoría relacional:
ID_Cliente es PK, y RUT también es único y no nulo, entonces RUT es una clave alternativa.En la práctica, nos enfocamos principalmente en PK y FK para el diseño y la implementación.
Las claves son los guardianes de la integridad de los datos en el modelo relacional. Permiten aplicar los tres principios fundamentales de integridad:
Principio: La clave primaria de una tabla no puede contener valores nulos y sus valores deben ser únicos.
Asegurado por: La definición de la Clave Primaria (PK). Esto garantiza que cada registro en la tabla represente una entidad única y bien identificada.
CREATE TABLE Clientes (
ID_Cliente INT PRIMARY KEY,
RUT VARCHAR(12) UNIQUE NOT NULL,
...
);
Aquí, ID_Cliente no puede ser nulo y cada valor debe ser único. El RUT también se define como único y no nulo, actuando como una clave alternativa.
Principio: Si una clave foránea existe en una tabla, sus valores deben coincidir con un valor de clave primaria en la tabla padre, o bien ser nulos (si así se permite).
Asegurado por: La definición de la Clave Foránea (FK). Esto evita "punteros colgantes" o referencias a datos inexistentes, manteniendo la coherencia entre tablas relacionadas.
CREATE TABLE Ventas (
ID_Venta INT PRIMARY KEY,
ID_Cliente INT,
Fecha_Venta DATE,
FOREIGN KEY (ID_Cliente) REFERENCES Clientes(ID_Cliente)
ON DELETE RESTRICT ON UPDATE CASCADE
);
Esta cláusula FOREIGN KEY asegura que cada ID_Cliente en Ventas existe en la tabla Clientes. ON DELETE RESTRICT impide eliminar un cliente con ventas asociadas, y ON UPDATE CASCADE actualiza el ID_Cliente en Ventas si cambia en Clientes.
Principio: Todos los valores de una columna deben ser del tipo de dato correcto y estar dentro del rango o conjunto de valores permitidos para ese dominio.
Asegurado por: La asignación de Tipos de Datos SQL y restricciones CHECK. Esto garantiza que los valores sean lógicamente válidos para el atributo que representan.
CREATE TABLE Productos (
ID_Producto INT PRIMARY KEY,
Precio_Unitario DECIMAL(10, 2) CHECK (Precio_Unitario >= 0),
Stock SMALLINT CHECK (Stock >= 0),
...
);
Aquí, DECIMAL(10, 2) asegura el formato del precio, y las cláusulas CHECK garantizan que tanto el precio como el stock no sean negativos.
Estos principios, implementados a través de las claves y los tipos de datos, son la base para construir bases de datos fiables y consistentes.
CHECK validan los valores de las columnas.En un mundo ideal, toda la información podría estar en una sola tabla. Sin embargo, esto llevaría a problemas serios:
Las relaciones entre tablas resuelven estos problemas. Permiten almacenar cada tipo de información una sola vez (evitando redundancia) y luego vincularla lógicamente cuando sea necesario, asegurando la consistencia y facilitando la gestión y consulta de los datos.
La cardinalidad describe cuántas instancias de una entidad están relacionadas con cuántas instancias de otra entidad. Es decir, cuántas filas de una tabla se conectan con cuántas filas de otra tabla. Existen tres tipos principales de cardinalidad:
Una relación uno a uno significa que una fila en la Tabla A está relacionada con exactamente una fila en la Tabla B, y viceversa. Son las menos comunes, ya que a menudo la información podría estar en una sola tabla.
Ejemplo contextualizado en Chile:
Ejemplo de tablas:
Tabla: Personas |
Tabla: Info_Censurada_CI |
|---|---|
ID_Persona (PK) |
ID_Info_CI (PK) |
Nombre |
ID_Persona (FK) |
Apellido |
Numero_Serie_CI |
RUT |
Fecha_Emision_CI |
Se utiliza una relación 1:1 en los siguientes casos:
Personas e Info_Censurada_CI).TEXT muy extenso) y no se usan con frecuencia, se pueden mover a una tabla 1:1 para optimizar el rendimiento de las consultas en la tabla principal.La implementación se realiza generalmente haciendo que la clave primaria de una tabla sea también la clave foránea que referencia la clave primaria de la otra tabla.
Una relación uno a muchos significa que una fila en la Tabla A puede estar relacionada con cero, una o muchas filas en la Tabla B, pero una fila en la Tabla B solo puede estar relacionada con una fila en la Tabla A. Es el tipo de relación más común en las bases de datos relacionales.
Ejemplos contextualizados en Chile:
Esta relación se implementa colocando la clave primaria de la tabla "uno" (la tabla padre) como una clave foránea en la tabla "muchos" (la tabla hija). La clave foránea en la tabla hija es lo que establece el vínculo con la fila correspondiente en la tabla padre.
Ejemplo: Cliente - Pedidos
Tabla: Clientes (lado "uno") |
Tabla: Pedidos (lado "muchos") |
|---|---|
ID_Cliente (PK) |
ID_Pedido (PK) |
Nombre |
ID_Cliente (FK → Clientes.ID_Cliente) |
RUT |
Fecha_Pedido |
| ... | Monto_Total |
Aquí, ID_Cliente en la tabla Pedidos es la clave foránea que apunta a la clave primaria ID_Cliente en la tabla Clientes. Esto permite saber qué cliente hizo cada pedido.
Una relación muchos a muchos significa que una fila en la Tabla A puede estar relacionada con cero, una o muchas filas en la Tabla B, y viceversa, una fila en la Tabla B puede estar relacionada con cero, una o muchas filas en la Tabla A.
Ejemplos contextualizados en Chile:
Las bases de datos relacionales no pueden implementar directamente una relación N:M. Para resolver esto, se introduce una tabla intermedia (o tabla de unión/asociación). Esta tabla tiene claves foráneas que referencian las claves primarias de las dos tablas originales, transformando la relación N:M en dos relaciones 1:N.
Ejemplo: Alumno - Cursos
Tabla: Alumnos |
Tabla Intermedia: Inscripciones |
Tabla: Cursos |
|---|---|---|
ID_Alumno (PK) |
ID_Inscripcion (PK) |
ID_Curso (PK) |
Nombre_Alumno |
ID_Alumno (FK → Alumnos.ID_Alumno) |
Nombre_Curso |
RUT_Alumno |
ID_Curso (FK → Cursos.ID_Curso) |
Creditos |
| ... | Fecha_Inscripcion |
... |
Nota_Final |
Aquí, la tabla Inscripciones es la tabla intermedia. Contiene ID_Alumno como FK y ID_Curso como FK. La combinación de ID_Alumno y ID_Curso podría ser una clave compuesta para la tabla Inscripciones, asegurando que un alumno no se inscriba dos veces en el mismo curso. Además, esta tabla puede almacenar atributos propios de la relación, como la Fecha_Inscripcion o la Nota_Final.
Para consolidar lo aprendido, veamos un esquema relacional simplificado para un sistema de ventas típico en Chile. Este sistema nos permitirá gestionar clientes, productos, y las transacciones de venta.
Aunque no podemos dibujar un DER interactivo aquí, lo describiremos y representaremos con una estructura de tablas y sus relaciones:
Entidades (Tablas) y sus Atributos (Columnas):
Clientes
ID_Cliente (PK, INT)RUT (VARCHAR(12), UNIQUE, NOT NULL)Nombre (VARCHAR(50))Apellido (VARCHAR(50))Direccion (VARCHAR(255))Comuna (VARCHAR(100))Email (VARCHAR(100))Productos
ID_Producto (PK, INT)Nombre_Producto (VARCHAR(150))Descripcion (TEXT)Precio_Unitario (DECIMAL(10, 2))Stock (SMALLINT)Pedidos
ID_Pedido (PK, INT)ID_Cliente (FK → Clientes.ID_Cliente, INT)Fecha_Pedido (DATETIME)Estado_Pedido (VARCHAR(50))Total_Pedido (DECIMAL(10, 2))Detalle_Pedidos (Tabla intermedia para la relación N:M entre Pedidos y Productos)
ID_Detalle_Pedido (PK, INT) - O (ID_Pedido, ID_Producto) como PK compuesta.ID_Pedido (FK → Pedidos.ID_Pedido, INT)ID_Producto (FK → Productos.ID_Producto, INT)Cantidad (SMALLINT)Precio_Unitario_Compra (DECIMAL(10, 2)) - Precio del producto al momento de la compra.Descripción de las Relaciones:
Clientes y Pedidos: Relación Uno a Muchos (1:N).
Pedidos.ID_Cliente es FK que referencia Clientes.ID_Cliente.Pedidos y Productos: Relación Muchos a Muchos (N:M).
Detalle_Pedidos.Pedidos y Detalle_Pedidos: Relación Uno a Muchos (1:N).
Detalle_Pedidos.ID_Pedido es FK que referencia Pedidos.ID_Pedido.Productos y Detalle_Pedidos: Relación Uno a Muchos (1:N).
Detalle_Pedidos.ID_Producto es FK que referencia Productos.ID_Producto.Visualización de las Relaciones (Texto Simplificado):
+-----------------+ +-----------------+ +-----------------------+ +-----------------+
| Clientes | <-----| Pedidos | <-----| Detalle_Pedidos |-----> | Productos |
+-----------------+ +-----------------+ +-----------------------+ +-----------------+
| PK ID_Cliente | | PK ID_Pedido | | PK ID_Detalle_Pedido | | PK ID_Producto |
| RUT | | FK ID_Cliente | | FK ID_Pedido | | Nombre_Producto |
| Nombre | | Fecha_Pedido | | FK ID_Producto | | Precio_Unitario |
| Apellido | | Estado_Pedido | | Cantidad | | Stock |
| ... | | Total_Pedido | | Precio_Unitario_Compra| | ... |
+-----------------+ +-----------------+ +-----------------------+ +-----------------+
Relaciones:
- Clientes (1) ---- (N) Pedidos (ID_Cliente en Pedidos referencia ID_Cliente en Clientes)
- Pedidos (1) ---- (N) Detalle_Pedidos (ID_Pedido en Detalle_Pedidos referencia ID_Pedido en Pedidos)
- Productos (1) ---- (N) Detalle_Pedidos (ID_Producto en Detalle_Pedidos referencia ID_Producto en Productos)
- Pedidos (N) ---- (M) Productos (a través de Detalle_Pedidos)
Este esquema permite una gestión eficiente de los datos de ventas, evitando redundancia y manteniendo la consistencia de la información, tal como se esperaría en cualquier sistema de retail moderno en Chile.
Hemos recorrido un camino fundamental en la comprensión de las bases de datos relacionales. Recapitulamos los pilares que hemos explorado:
Comprender estos conceptos es el primer paso para diseñar, implementar y gestionar bases de datos eficientes y fiables en cualquier entorno de TI.
El modelo relacional no es solo una teoría académica; es la base práctica sobre la que se construyen innumerables sistemas en la industria del software. Desde una aplicación móvil que gestiona tus contactos hasta el sistema ERP de una gran empresa minera en Chile, la mayoría de ellos utilizan bases de datos relacionales.
Para un desarrollador de software, un analista de datos o un arquitecto de soluciones, tener un dominio sólido del modelo relacional significa:
Es una habilidad transversal y fundamental que sigue siendo altamente demandada en el mercado laboral chileno y global de TI.
En este momento, abrimos el espacio para sus preguntas. No hay preguntas tontas, solo oportunidades para aprender y clarificar conceptos.
(Aquí se abriría el espacio para interacción con la audiencia)
El aprendizaje de bases de datos es un viaje continuo. Para aquellos que deseen profundizar, les recomiendo los siguientes recursos:
¡Muchas gracias por su atención y espero que esta charla les haya sido de gran utilidad!
¡Hola a todos! Es un placer compartir con ustedes esta sesión introductoria a uno de los pilares fundamentales en el mundo de la tecnología de la información: SQL. Como Diseñador Instruccional Experto en Tecnología y Bases de Datos, mi objetivo es que salgan de aquí con una comprensión clara de qué es SQL, por qué es crucial y cómo empezar a interactuar con él de manera práctica.
Bienvenidos a esta inmersión inicial en el fascinante universo de las bases de datos y el lenguaje estándar SQL. Durante esta charla, exploraremos desde los conceptos más básicos hasta una primera aproximación práctica que les permitirá ejecutar sus primeros comandos SQL.
Nuestra agenda para hoy es la siguiente:
¡Prepárense para una sesión didáctica, práctica y progresiva!
Al finalizar esta sesión, ustedes serán capaces de:
En la era de la información, los datos son el activo más valioso para cualquier organización. Desde pequeñas startups hasta gigantes tecnológicos, todos dependen de la capacidad de almacenar, gestionar y analizar grandes volúmenes de información. Aquí es donde SQL (Structured Query Language) se convierte en una habilidad indispensable.
Dominar SQL no es solo aprender un lenguaje; es adquirir la llave para desbloquear el potencial de los datos.
Una base de datos es una colección organizada de información estructurada, o datos, típicamente almacenados electrónicamente en un sistema informático. Su propósito principal es permitir el almacenamiento, la recuperación, la modificación y la gestión eficiente de grandes volúmenes de datos.
Para entender una base de datos relacional, necesitamos conocer algunos conceptos clave:
SQL, acrónimo de Structured Query Language (Lenguaje de Consulta Estructurado), es un lenguaje de programación declarativo diseñado específicamente para gestionar y manipular bases de datos relacionales. A diferencia de lenguajes de programación imperativos como Python o Java, SQL no se enfoca en "cómo" hacer algo, sino en "qué" se quiere lograr con los datos.
Su propósito principal es:
En esencia, SQL es la interfaz principal a través de la cual los usuarios y las aplicaciones interactúan con un SGBD para realizar operaciones con los datos.
Una de las mayores fortalezas de SQL es su estatus como lenguaje estándar. Esto significa que, aunque existen diferentes implementaciones de SGBD (MySQL, PostgreSQL, SQL Server, Oracle, etc.), todos ellos entienden y utilizan una versión del mismo lenguaje base: SQL.
Este estandarización, impulsada por organismos como ANSI e ISO (que veremos a continuación), ofrece ventajas significativas:
Aunque cada SGBD puede tener extensiones o variaciones propias (conocidas como "dialectos"), el núcleo de SQL permanece constante, lo que lo convierte en una herramienta increíblemente poderosa y versátil para la gestión de datos.
La historia de SQL está intrínsecamente ligada al desarrollo de las bases de datos relacionales. Todo comenzó en 1970, cuando el Dr. Edgar F. Codd, un científico informático de IBM, publicó su influyente artículo "A Relational Model of Data for Large Shared Data Banks". Este documento sentó las bases teóricas para lo que hoy conocemos como bases de datos relacionales.
La creciente popularidad de SQL llevó a la necesidad de una estandarización para asegurar la compatibilidad y la interoperabilidad entre los diferentes productos de SGBD. Dos organismos clave fueron fundamentales en este proceso:
La colaboración entre ANSI e ISO ha sido crucial para mantener SQL como un lenguaje verdaderamente global y estándar.
Desde su estandarización inicial, SQL ha continuado evolucionando para adaptarse a las nuevas necesidades y tecnologías. Cada nueva versión del estándar introduce mejoras, nuevas características y clarificaciones. Algunas de las versiones más significativas incluyen:
Es importante destacar que, si bien el estándar SQL es exhaustivo, los diferentes SGBD implementan subconjuntos del estándar y a menudo añaden sus propias extensiones propietarias. Sin embargo, el conocimiento del núcleo del estándar SQL sigue siendo la base para trabajar con cualquier sistema de gestión de datos.
Para simplificar el aprendizaje y la comprensión de SQL, sus comandos se agrupan en varias categorías funcionales. Las dos categorías principales y más fundamentales son DDL y DML, que cubriremos en detalle. Existen otras como DCL (Data Control Language) para permisos y TCL (Transaction Control Language) para transacciones, pero hoy nos centraremos en la definición y manipulación de datos.
Pensemos en una base de datos como un edificio:
Esta distinción es crucial para entender el propósito de cada tipo de comando y cómo interactúan con la base de datos.
El Data Definition Language (DDL) es el conjunto de comandos SQL que se utilizan para definir, modificar y eliminar la estructura de los objetos de una base de datos. Estos comandos operan sobre el esquema de la base de datos, no sobre los datos en sí mismos. Cuando se ejecuta un comando DDL, se realiza una operación de confirmación automática (auto-commit), lo que significa que los cambios son permanentes e irreversibles.
Las funcionalidades principales del DDL incluyen:
En resumen, DDL es el lenguaje que usamos para "diseñar" y "construir" nuestra base de datos.
CREATE DATABASEEl comando CREATE DATABASE se utiliza para crear una nueva base de datos en el servidor de SGBD.
CREATE DATABASE nombre_de_la_base_de_datos;Opcionalmente, se pueden especificar parámetros como el juego de caracteres (charset) y la intercalación (collation) para definir cómo se almacenarán y ordenarán los datos.
CREATE DATABASE nombre_de_la_base_de_datos
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;Imaginemos que estamos creando un sistema para una pequeña tienda de electrónica. Necesitaremos una base de datos para almacenar toda la información.
CREATE DATABASE TiendaElectronica;Este comando creará una base de datos vacía llamada TiendaElectronica en nuestro servidor.
CREATE DATABASE se usa para crear una nueva base de datos.CREATE TABLEEl comando CREATE TABLE es uno de los más fundamentales de DDL, ya que permite definir la estructura de las tablas donde se almacenarán nuestros datos.
CREATE TABLE nombre_de_la_tabla (
nombre_columna1 TIPO_DATO [RESTRICCIONES],
nombre_columna2 TIPO_DATO [RESTRICCIONES],
...
);Algunos tipos de datos comunes incluyen:
Las restricciones son reglas que se aplican a las columnas de una tabla para limitar el tipo de datos que se pueden almacenar en ella, asegurando la integridad de los datos.
PRIMARY KEY: Identifica de forma única cada fila en la tabla. No puede contener valores nulos y cada valor debe ser único. Una tabla solo puede tener una clave primaria. A menudo se combina con AUTO_INCREMENT para IDs numéricos.NOT NULL: Asegura que una columna no pueda contener valores nulos (vacíos).UNIQUE: Asegura que todos los valores en una columna sean diferentes.DEFAULT valor: Asigna un valor predeterminado a una columna si no se especifica uno al insertar una fila.Continuando con nuestra TiendaElectronica, crearemos una tabla para almacenar los productos.
USE TiendaElectronica; -- Seleccionamos la base de datos donde queremos crear la tabla
CREATE TABLE Productos (
id_producto INT AUTO_INCREMENT PRIMARY KEY,
nombre VARCHAR(100) NOT NULL,
descripcion TEXT,
precio DECIMAL(10, 2) NOT NULL,
stock INT NOT NULL DEFAULT 0,
fecha_creacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);En este ejemplo:
id_producto es un entero que se auto-incrementa y es la clave primaria.nombre es una cadena de hasta 100 caracteres y no puede ser nula.descripcion es un texto largo (puede ser nulo).precio es un número decimal con 10 dígitos en total y 2 decimales, no puede ser nulo.stock es un entero, no puede ser nulo y su valor predeterminado es 0.fecha_creacion es una marca de tiempo que por defecto registra la fecha y hora actual.CREATE TABLE define la estructura de una tabla.PRIMARY KEY identifica filas únicas; NOT NULL evita valores vacíos.ALTER TABLE (Introducción a la Modificación de Estructura)El comando ALTER TABLE se utiliza para modificar la estructura de una tabla existente. Es muy útil cuando necesitamos ajustar el esquema de nuestra base de datos sin tener que recrear la tabla desde cero.
ADD COLUMN, DROP COLUMN)ALTER TABLE nombre_de_la_tabla
ADD COLUMN nombre_nueva_columna TIPO_DATO [RESTRICCIONES];ALTER TABLE nombre_de_la_tabla
DROP COLUMN nombre_columna_a_eliminar;MODIFY COLUMN o CHANGE COLUMN; para PostgreSQL es ALTER COLUMN.)
-- Ejemplo MySQL para modificar tipo de dato
ALTER TABLE nombre_de_la_tabla
MODIFY COLUMN nombre_columna NUEVO_TIPO_DATO;
-- Ejemplo PostgreSQL para modificar tipo de dato
ALTER TABLE nombre_de_la_tabla
ALTER COLUMN nombre_columna TYPE NUEVO_TIPO_DATO;Supongamos que en nuestra tabla Productos, decidimos que necesitamos almacenar la marca de cada producto.
USE TiendaElectronica;
-- Añadir una columna 'marca'
ALTER TABLE Productos
ADD COLUMN marca VARCHAR(50) NULL AFTER nombre; -- 'AFTER nombre' es opcional y específica la posición
-- Más tarde, si la marca se vuelve un campo obligatorio
ALTER TABLE Productos
MODIFY COLUMN marca VARCHAR(50) NOT NULL DEFAULT 'Desconocida';
-- Si decidimos que la descripción no es necesaria
ALTER TABLE Productos
DROP COLUMN descripcion;ALTER TABLE modifica la estructura de una tabla existente.ADD COLUMN para añadir, DROP COLUMN para eliminar.DROP TABLE y DROP DATABASEEstos comandos se utilizan para eliminar completamente tablas o bases de datos. Son comandos muy potentes y deben usarse con extrema precaución.
DROP TABLE nombre_de_la_tabla;DROP DATABASE nombre_de_la_base_de_datos;Los comandos DROP TABLE y DROP DATABASE son irreversibles. Una vez ejecutados, la tabla o base de datos y todos sus datos asociados se eliminan permanentemente. No hay una "papelera de reciclaje" en la mayoría de los SGBD para estas operaciones.
Matriz de Responsabilidades (Ejemplo Simplificado):
| Rol | Acción DDL | Responsabilidad |
|---|---|---|
| Administrador de BD (DBA) | DROP DATABASE, DROP TABLE |
Autorizado para ejecutar, responsable de copias de seguridad y recuperación. |
| Desarrollador Senior | DROP TABLE (en entornos de desarrollo/pruebas) |
Autorizado para ejecutar en entornos controlados, bajo supervisión o aprobación. |
| Desarrollador Junior | Ninguno (o solo con supervisión directa) | No autorizado para ejecutar en entornos de producción. |
Checklist Operativo antes de ejecutar DROP:
Siempre piensen dos veces antes de ejecutar un DROP.
DROP TABLE y DROP DATABASE eliminan objetos y sus datos permanentemente.El Data Manipulation Language (DML) es el conjunto de comandos SQL que se utilizan para gestionar y manipular los datos dentro de las tablas de una base de datos. A diferencia del DDL que trabaja con la estructura, el DML interactúa directamente con las filas y columnas llenas de información.
Las funcionalidades principales del DML incluyen:
Los comandos DML son la forma en que las aplicaciones y los usuarios interactúan con la información almacenada en la base de datos para realizar operaciones diarias.
INSERT INTOEl comando INSERT INTO se utiliza para añadir nuevas filas (registros) de datos a una tabla existente.
INSERT INTO nombre_de_la_tabla (columna1, columna2, ...)
VALUES (valor1, valor2, ...);INSERT INTO nombre_de_la_tabla
VALUES (valor1, valor2, ...);INSERT INTO nombre_de_la_tabla (columna1, columna2, ...)
VALUES
(valor1a, valor2a, ...),
(valor1b, valor2b, ...),
...;Usando nuestra tabla Productos de la TiendaElectronica:
USE TiendaElectronica;
-- Insertar un solo producto
INSERT INTO Productos (nombre, marca, descripcion, precio, stock)
VALUES ('Laptop Gamer X', 'TechBrand', 'Potente laptop para juegos con RTX 3080', 1899.99, 15);
-- Insertar otro producto, omitiendo la descripción (que es NULLable)
INSERT INTO Productos (nombre, marca, precio, stock)
VALUES ('Teclado Mecánico RGB', 'GamerGear', 85.50, 50);
-- Insertar múltiples productos
INSERT INTO Productos (nombre, marca, descripcion, precio, stock)
VALUES
('Monitor Curvo 27"', 'ViewLux', 'Monitor de alta resolución para productividad', 349.00, 20),
('Mouse Inalámbrico Ergonómico', 'ErgoTech', NULL, 45.99, 100),
('Auriculares Bluetooth', 'SoundWave', 'Auriculares con cancelación de ruido', 120.00, 75);INSERT INTO añade nuevas filas de datos a una tabla.SELECT (Recuperación de Datos Básica)El comando SELECT es el más utilizado en SQL. Permite recuperar datos de una o varias tablas de la base de datos. Es la base de cualquier consulta de información.
SELECT *, SELECT columna1, columna2)SELECT * FROM nombre_de_la_tabla;El asterisco (*) es un comodín que indica "todas las columnas".
SELECT columna1, columna2, ...
FROM nombre_de_la_tabla;Esto recupera solo las columnas que nos interesan, lo cual es más eficiente y recomendado en producción.
FROMLa cláusula FROM especifica de qué tabla (o tablas) se van a recuperar los datos. Es obligatoria para cualquier consulta SELECT que acceda a datos de una tabla.
SELECT columna1, columna2
FROM nombre_de_la_tabla;WHERE (Filtros Simples: `=`, `>`, `<`, `LIKE`)La cláusula WHERE se utiliza para filtrar los registros que se recuperan, especificando una o más condiciones. Solo las filas que cumplen la condición serán incluidas en el resultado.
= (Igual a)<> o != (Diferente de)> (Mayor que)< (Menor que)>= (Mayor o igual que)<= (Menor o igual que)LIKE: Se usa para buscar patrones en cadenas de texto.
%: Representa cero o más caracteres._: Representa un solo carácter.SELECT columna
FROM tabla
WHERE columna LIKE 'patron%'; -- Empieza con 'patron'
WHERE columna LIKE '%patron'; -- Termina con 'patron'
WHERE columna LIKE '%patron%'; -- Contiene 'patron'
WHERE columna LIKE 'p_tron'; -- 'patron', 'pstron', etc.AND, OR, NOT para combinar condiciones.Recuperando datos de nuestra tabla Productos:
USE TiendaElectronica;
-- 1. Consultar todos los productos
SELECT *
FROM Productos;
-- 2. Consultar solo el nombre y el precio de los productos
SELECT nombre, precio
FROM Productos;
-- 3. Consultar productos con un precio mayor a 100
SELECT nombre, precio
FROM Productos
WHERE precio > 100.00;
-- 4. Consultar productos de la marca 'TechBrand'
SELECT *
FROM Productos
WHERE marca = 'TechBrand';
-- 5. Consultar productos cuyo nombre contenga la palabra 'Monitor'
SELECT nombre, marca
FROM Productos
WHERE nombre LIKE '%Monitor%';
-- 6. Consultar productos con stock entre 20 y 50 (inclusive)
SELECT nombre, stock
FROM Productos
WHERE stock >= 20 AND stock <= 50;
-- 7. Consultar productos que no sean de la marca 'GamerGear'
SELECT nombre, marca
FROM Productos
WHERE NOT marca = 'GamerGear'; -- o WHERE marca <> 'GamerGear';SELECT recupera datos de tablas.* selecciona todas las columnas; se pueden especificar columnas individuales.FROM indica la tabla de origen.WHERE filtra filas usando operadores de comparación, LIKE y lógicos.UPDATEEl comando UPDATE se utiliza para modificar datos existentes en una o varias filas de una tabla.
UPDATE nombre_de_la_tabla
SET columna1 = nuevo_valor1, columna2 = nuevo_valor2, ...
WHERE condicion;WHERELa cláusula WHERE en un comando UPDATE es absolutamente crítica. Si se omite la cláusula WHERE, el comando UPDATE afectará a *todas las filas* de la tabla, actualizando los valores especificados en todas ellas. Esto puede llevar a una pérdida masiva de datos y es uno de los errores más comunes y costosos en la gestión de bases de datos.
¡Siempre, siempre, siempre utiliza WHERE con UPDATE a menos que intencionalmente quieras actualizar toda la tabla!
Actualicemos algunos datos en nuestra tabla Productos:
USE TiendaElectronica;
-- 1. Aumentar el precio de un producto específico (ej. id_producto = 1)
UPDATE Productos
SET precio = 1999.99
WHERE id_producto = 1;
-- 2. Reducir el stock de todos los productos de una marca específica
UPDATE Productos
SET stock = stock - 5
WHERE marca = 'GamerGear';
-- 3. Actualizar la descripción de un producto que no la tenía
UPDATE Productos
SET descripcion = 'Ratón inalámbrico con diseño ergonómico para largas jornadas'
WHERE nombre = 'Mouse Inalámbrico Ergonómico';
-- 4. ¡CUIDADO! Este comando actualizaría el precio de *todos* los productos
-- UPDATE Productos
-- SET precio = precio * 1.10; -- Aumenta el precio un 10% a todos los productos
-- NO EJECUTAR SIN UN WHERE ESPECÍFICO A MENOS QUE SEA INTENCIONAL.UPDATE modifica datos existentes en una tabla.SET especifica las columnas y sus nuevos valores.WHERE es CRÍTICA para especificar qué filas actualizar.WHERE en UPDATE afectará a todas las filas, lo cual es peligroso.DELETE FROMEl comando DELETE FROM se utiliza para eliminar una o varias filas de datos de una tabla.
DELETE FROM nombre_de_la_tabla
WHERE condicion;WHEREAl igual que con UPDATE, la cláusula WHERE en un comando DELETE FROM es extremadamente importante. Si se omite la cláusula WHERE, el comando DELETE FROM eliminará *todas las filas* de la tabla, dejando la tabla vacía pero conservando su estructura. Esto es igualmente peligroso y puede resultar en una pérdida irrecuperable de datos.
¡Siempre, siempre, siempre utiliza WHERE con DELETE FROM a menos que intencionalmente quieras vaciar toda la tabla!
Cláusula Modelo de Seguridad:
-- Siempre verificar la condición antes de ejecutar un DELETE FROM
-- Primero, ejecuta un SELECT con la misma condición para ver qué filas se afectarán:
SELECT * FROM nombre_de_la_tabla WHERE condicion_de_eliminacion;
-- Si el resultado es el esperado, entonces procede con el DELETE:
DELETE FROM nombre_de_la_tabla WHERE condicion_de_eliminacion;
Eliminemos algunos datos de nuestra tabla Productos:
USE TiendaElectronica;
-- 1. Eliminar un producto específico por su ID
DELETE FROM Productos
WHERE id_producto = 4; -- Eliminar el 'Mouse Inalámbrico Ergonómico'
-- 2. Eliminar todos los productos con stock cero
DELETE FROM Productos
WHERE stock = 0;
-- 3. ¡CUIDADO! Este comando eliminaría *todos* los productos de la tabla
-- DELETE FROM Productos; -- Vacía la tabla "Productos" completamente
-- NO EJECUTAR SIN UN WHERE ESPECÍFICO A MENOS QUE SEA INTENCIONAL.DELETE FROM elimina filas de datos de una tabla.WHERE es CRÍTICA para especificar qué filas eliminar.WHERE en DELETE FROM eliminará todas las filas, lo cual es muy peligroso.SELECT antes de ejecutar un DELETE.Un Sistema Gestor de Bases de Datos (SGBD), o DBMS (Database Management System), es un software que permite a los usuarios y aplicaciones interactuar con una base de datos. Es el intermediario entre la base de datos física (los archivos donde se almacenan los datos) y los usuarios o programas que necesitan acceder a esos datos.
Las funciones clave de un SGBD incluyen:
Algunos de los SGBD relacionales más populares que implementan SQL son:
Para interactuar con un SGBD y ejecutar comandos SQL, necesitamos herramientas cliente. Estas herramientas nos proporcionan una interfaz gráfica de usuario (GUI) o una línea de comandos para enviar nuestras consultas y ver los resultados.
La elección de la herramienta dependerá del SGBD que utilicen y de sus preferencias personales.
Para la parte práctica de esta charla, asumiremos que tienen un entorno de desarrollo local configurado. La forma más sencilla de lograr esto es usando un "stack" de servidor local.
Estos paquetes de software instalan un servidor web (Apache), un intérprete de PHP y, crucialmente, un servidor de base de datos MySQL/MariaDB en su máquina local.
Si no tienen uno instalado, les recomiendo XAMPP por su facilidad de uso y compatibilidad multiplataforma. Una vez instalado, deben iniciar los servicios de Apache y MySQL/MariaDB desde el panel de control del paquete.
http://localhost/phpmyadmin.localhost, Puerto: 3306, Usuario: root, Contraseña: (vacía) para instalaciones por defecto de XAMPP/WAMP/MAMP).Para esta práctica, cualquier entorno que les permita ejecutar SQL contra un servidor MySQL/MariaDB local será suficiente.
http://localhost/phpmyadmin.¡Es hora de poner en práctica lo aprendido! Utilizaremos un entorno como phpMyAdmin o DBeaver para ejecutar nuestros primeros comandos SQL. Asegúrense de que su servidor MySQL/MariaDB esté en ejecución.
Si están usando phpMyAdmin, ya deberían estar conectados al navegar a http://localhost/phpmyadmin. Si usan DBeaver, asegúrense de que su conexión a MySQL/MariaDB esté activa.
Busquen la interfaz para ejecutar consultas SQL. En phpMyAdmin, es la pestaña "SQL". En DBeaver, pueden hacer clic derecho en su conexión o base de datos y seleccionar "New SQL Editor".
Vamos a crear una base de datos para un catálogo de productos simple.
CREATE DATABASE MiCatalogo
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;Después de ejecutar este comando, refresquen la lista de bases de datos en su herramienta. Deberían ver MiCatalogo. Selecciónenla para que los siguientes comandos se ejecuten dentro de ella.
MiCatalogo.Ahora, dentro de MiCatalogo, crearemos una tabla llamada Articulos.
USE MiCatalogo; -- Asegurarse de que estamos en la BD correcta
CREATE TABLE Articulos (
id INT AUTO_INCREMENT PRIMARY KEY,
nombre VARCHAR(100) NOT NULL,
descripcion TEXT,
precio DECIMAL(10, 2) NOT NULL,
stock INT NOT NULL DEFAULT 0
);Verifiquen que la tabla Articulos se ha creado correctamente y que tiene las columnas y restricciones definidas.
Articulos dentro de MiCatalogo.PRIMARY KEY, NOT NULL, DEFAULT).Vamos a poblar nuestra tabla con algunos datos de ejemplo.
USE MiCatalogo;
INSERT INTO Articulos (nombre, descripcion, precio, stock)
VALUES
('Teclado Mecánico', 'Teclado retroiluminado RGB con switches azules', 75.00, 50),
('Ratón Gaming', 'Ratón óptico de alta precisión con 6 botones programables', 45.50, 80),
('Monitor Ultrawide 34"', 'Monitor curvo para inmersión total en juegos y trabajo', 599.99, 15),
('Webcam Full HD', 'Cámara web con micrófono integrado para videollamadas', 30.00, 120),
('Disco Duro SSD 1TB', 'Unidad de estado sólido de alta velocidad para almacenamiento', 99.99, 40);INSERT INTO para añadir múltiples filas de datos.Verifiquemos que los datos se han insertado correctamente.
USE MiCatalogo;
SELECT *
FROM Articulos;Deberían ver todas las filas que acabamos de insertar.
SELECT * para recuperar todas las columnas de todos los registros.Ahora, apliquemos algunos filtros para recuperar datos específicos.
USE MiCatalogo;
-- Consultar artículos con precio superior a 100
SELECT nombre, precio, stock
FROM Articulos
WHERE precio > 100.00;
-- Consultar artículos cuyo nombre contenga 'Teclado'
SELECT id, nombre, descripcion
FROM Articulos
WHERE nombre LIKE '%Teclado%';WHERE para filtrar resultados.>) y patrones (LIKE).Modifiquemos algunos datos existentes.
USE MiCatalogo;
-- Actualizar el stock del "Ratón Gaming" (asumiendo id=2)
UPDATE Articulos
SET stock = 70
WHERE id = 2; -- ¡La cláusula WHERE es crucial aquí!
-- Aumentar el precio de los artículos con 'Monitor' en su nombre en un 5%
UPDATE Articulos
SET precio = precio * 1.05
WHERE nombre LIKE '%Monitor%';Después de ejecutar, pueden volver a consultar la tabla completa o el artículo específico para ver los cambios.
SELECT * FROM Articulos WHERE id = 2;
SELECT * FROM Articulos WHERE nombre LIKE '%Monitor%';UPDATE para modificar datos existentes.WHERE para evitar actualizaciones masivas no deseadas.Finalmente, eliminemos un registro de nuestra tabla.
USE MiCatalogo;
-- Eliminar el artículo "Webcam Full HD" (asumiendo id=4)
DELETE FROM Articulos
WHERE id = 4; -- ¡La cláusula WHERE es crucial aquí!
-- Verificar que el artículo ha sido eliminado
SELECT *
FROM Articulos;Deberían ver que el artículo con id=4 ya no aparece en la lista.
DELETE FROM para eliminar filas de datos.WHERE para evitar la eliminación de todas las filas.Hemos cubierto un terreno significativo en esta introducción a SQL. Recapitulando, hemos aprendido que:
CREATE DATABASE, CREATE TABLE, ALTER TABLE, DROP TABLE).INSERT INTO, SELECT, UPDATE, DELETE FROM).MiCatalogo.Este es solo el comienzo de su viaje con SQL, pero ya tienen las bases sólidas para seguir construyendo.
Ahora abrimos el espacio para sus preguntas. No hay preguntas tontas, solo oportunidades para aprender más.
[Espacio para preguntas y respuestas del público]
Para continuar su aprendizaje y dominar SQL, les recomiendo los siguientes recursos:
Muchas gracias por su atención y participación activa en esta charla. Espero que esta introducción a SQL les haya sido útil y les inspire a seguir explorando el apasionante mundo de las bases de datos y la gestión de datos. ¡El poder de los datos está ahora a su alcance!
¡Hasta la próxima!