Fundamentos de Bases de Datos con Oracle

Introducción: El Universo de las Bases de Datos

Imagina una gigantesca biblioteca digital, perfectamente organizada, donde cada pieza de información tiene su lugar y puede ser encontrada en segundos. ¡Eso es, en esencia, una base de datos! Son sistemas cruciales diseñados para almacenar, organizar, proteger y permitir el acceso eficiente a la información. Hoy en día, casi todas las aplicaciones que usas, desde tu red social favorita hasta el sistema de tu banco, dependen vitalmente de ellas.

Oracle Database es uno de los "bibliotecarios" más robustos y utilizados a nivel mundial, especialmente en entornos empresariales que demandan alta performance, seguridad y escalabilidad.

Un Vistazo a los Tipos de Bases de Datos:

No todas las "bibliotecas" son iguales. Existen diferentes enfoques para organizar la información:

En este curso, nos enfocaremos en el mundo de las bases de datos relacionales (SQL), utilizando el poder de Oracle para modelar, construir y gestionar la información.

Módulo 1: Modelado Conceptual de Bases de Datos

Antes de construir cualquier cosa, ¡necesitamos un plano! El modelado de bases de datos es como diseñar el plano arquitectónico de nuestra "biblioteca de datos". Un buen modelo asegura que la información esté organizada lógicamente, sea fácil de acceder y se eviten problemas futuros como datos duplicados o inconsistentes.

🔹 ¿Por qué modelar? La Importancia de un Buen Diseño

Imagina intentar construir una casa sin planos: ¡sería un caos! Un modelo de datos bien pensado:

• Asegura la integridad y consistencia de los datos.
• Facilita la comprensión de la estructura de la información.
• Reduce la redundancia de datos (ahorrando espacio y evitando errores).
• Optimiza el rendimiento de las consultas.
• Sirve como documentación para desarrolladores y usuarios.

Pasos para Modelar tu Universo de Datos:

Modelar una base de datos es un proceso que parte de entender una necesidad del mundo real. Tomemos como ejemplo un sistema para una pequeña tienda online.

Paso 4: Crear el Esquema Lógico (Diagrama Entidad-Relación - DER) 📐

El DER es la representación gráfica de nuestro modelo. Muestra entidades, atributos y relaciones. Herramientas como Oracle SQL Developer Data Modeler nos ayudan a crearlos.

Diagrama Entidad-Relación Interactivo

Ver Diagrama

🔹 Concepto Clave: Normalización 📊 - ¡Organizando para la Eficiencia!

La normalización es un proceso para refinar la estructura de nuestras tablas, eliminando la redundancia de datos y mejorando su integridad. Imagina que tienes la dirección de un cliente repetida en cada una de sus 100 ventas; si el cliente se muda, ¡tendrías que actualizarla en 100 sitios! La normalización evita esto.

La normalización puede parecer compleja, pero resulta en bases de datos más limpias, eficientes y fáciles de mantener.

Módulo 2: Creando el Modelo Físico en Oracle (SQL)

Una vez que tenemos nuestro "plano" conceptual (modelo lógico y DER), es hora de traducirlo a la realidad de cómo se almacenarán los datos en Oracle. Esto es el Modelo Físico. Aquí entran en juego los tipos de datos específicos de Oracle, las restricciones y las optimizaciones.

CREATE TABLE Cliente (
  ID_Cliente NUMBER(10) PRIMARY KEY,
  Nombre VARCHAR2(50) NOT NULL
);

Del Lógico al Físico: Materializando el Diseño

El modelo físico detalla:

• Nombres exactos de tablas y columnas.
• Tipos de datos Oracle para cada columna (NUMBER, VARCHAR2, DATE, etc.).
• Restricciones (Constraints) para asegurar la integridad de los datos (PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK).
• Índices para acelerar las búsquedas.
• Otras estructuras específicas del DBMS como tablespaces o particiones (conceptos más avanzados que mencionaremos).

Tipos de Datos Comunes en Oracle SQL:

Definiendo Tablas con CREATE TABLE y Restricciones:

El comando SQL principal para crear la estructura es CREATE TABLE. Aquí un ejemplo completo para nuestra tienda:

CREATE TABLE Cliente (
    ID_Cliente      NUMBER(10)      CONSTRAINT pk_cliente PRIMARY KEY,
    Nombre          VARCHAR2(50)    CONSTRAINT nn_cliente_nombre NOT NULL,
    Apellido        VARCHAR2(50)    CONSTRAINT nn_cliente_apellido NOT NULL,
    Email           VARCHAR2(100)   CONSTRAINT uq_cliente_email UNIQUE,
    Telefono        VARCHAR2(20),
    FechaRegistro   DATE            DEFAULT SYSDATE, -- Valor por defecto: fecha actual
    PuntosFidelidad NUMBER(5)       CONSTRAINT ck_cliente_puntos CHECK (PuntosFidelidad >= 0)
);

CREATE TABLE Producto (
    ID_Producto     NUMBER(10)      CONSTRAINT pk_producto PRIMARY KEY,
    NombreProd      VARCHAR2(100)   CONSTRAINT nn_prod_nombre NOT NULL,
    Descripcion     CLOB,
    PrecioUnit      NUMBER(10,2)    CONSTRAINT nn_prod_precio NOT NULL 
                                    CONSTRAINT ck_prod_precio CHECK (PrecioUnit > 0),
    StockDisp       NUMBER(6)       DEFAULT 0 
                                    CONSTRAINT ck_prod_stock CHECK (StockDisp >= 0)
);

CREATE TABLE Venta (
    ID_Venta        NUMBER(12)      CONSTRAINT pk_venta PRIMARY KEY,
    ID_Cliente_FK   NUMBER(10)      CONSTRAINT nn_venta_cliente NOT NULL,
    FechaVenta      TIMESTAMP       DEFAULT CURRENT_TIMESTAMP,
    MontoTotal      NUMBER(12,2)    CONSTRAINT ck_venta_monto CHECK (MontoTotal >= 0),
    -- Definiendo la Clave Foránea (FK)
    CONSTRAINT fk_venta_cliente FOREIGN KEY (ID_Cliente_FK)
        REFERENCES Cliente(ID_Cliente)
        -- ON DELETE SET NULL -- Opcional: qué hacer si se borra el cliente
        -- ON DELETE CASCADE -- Opcional: borrar ventas si se borra el cliente
);
-- Nota: La tabla Detalle_Venta para la relación M:N se crearía de forma similar.
                    

Explicación de las Restricciones (Constraints):

• CONSTRAINT nombre_constraint TIPO_CONSTRAINT (columnas): Forma explícita de nombrar una restricción. Facilita su gestión.
• PRIMARY KEY: Identificador único de la fila. Implícitamente NOT NULL y UNIQUE.
• NOT NULL: La columna no puede tener valores nulos.
• UNIQUE: Todos los valores en la columna (o combinación de columnas) deben ser únicos. Permite un valor nulo.
• CHECK: Asegura que los valores cumplan una condición lógica.
• FOREIGN KEY ... REFERENCES ...: Establece una relación con otra tabla, asegurando la integridad referencial.
• DEFAULT: Asigna un valor por defecto si no se especifica uno al insertar.

Acelerando Consultas con Índices:

Un índice es como el índice de un libro: permite a Oracle encontrar datos más rápidamente sin tener que leer toda la tabla (Full Table Scan).

-- Crear un índice en la columna Email de la tabla Cliente para búsquedas rápidas por email
CREATE INDEX idx_cliente_email ON Cliente(Email);

-- Crear un índice compuesto si a menudo buscas por Apellido y Nombre juntos
CREATE INDEX idx_cliente_apellinom ON Cliente(Apellido, Nombre);
                    

Módulo 3: Modelado Visual con Oracle SQL Developer Data Modeler

Diseñar bases de datos complejas directamente con código SQL puede ser propenso a errores y difícil de visualizar. Aquí es donde brillan herramientas como Oracle SQL Developer Data Modeler (SDDM). Es una herramienta gráfica, gratuita, que te permite diseñar, documentar y generar los esquemas de tu base de datos de forma visual e intuitiva.

Diseño Visual

Ingeniería Automática

Generación de Scripts

¿Qué puedes hacer con SQL Developer Data Modeler?

• Diseñar Modelos Lógicos: Representar entidades, atributos y relaciones sin preocuparte aún por los detalles específicos de Oracle.
• Ingeniería a Modelo Relacional/Físico: Convertir tu modelo lógico en un modelo físico específico para Oracle (u otros DBMS), asignando tipos de datos, definiendo tablas, etc.
• Generar DDL: Crear automáticamente los scripts SQL (CREATE TABLE, ALTER TABLE, etc.) para implementar tu diseño en la base de datos.
• Ingeniería Inversa: Crear un modelo visual a partir de una base de datos existente o un script DDL. ¡Muy útil para documentar sistemas legados!
• Comparar y Sincronizar Modelos: Comparar diferentes versiones de tu modelo o tu modelo con una base de datos real.
• Documentar: Generar informes y documentación sobre tu modelo.

Flujo de Trabajo Básico en Data Modeler:

Modelado Paso a Paso (Simulado)

Crear Diseño Lógico Definir Entidades Establecer Relaciones Convertir a Modelo Físico Generar Script SQL

Paso 1: Crear Nuevo Diseño Lógico

En SQL Developer Data Modeler, crea un nuevo proyecto usando Archivo > Nuevo > Diseño Lógico

Aquí definirás las entidades y relaciones sin preocuparte aún por detalles específicos de Oracle.

Paso 2: Definir Entidades y Atributos

Arrastra y suelta entidades desde la paleta de herramientas. Define nombres (Cliente, Producto) y atributos (ID_Cliente, Nombre, etc.)

Para cada atributo, especifica su tipo de dato lógico y si es clave primaria.

Paso 3: Establecer Relaciones

Usa la herramienta de relación para conectar entidades. Define la cardinalidad (1:N, M:N).

Para relaciones M:N, SDDM puede ayudarte a generar automáticamente la tabla de intersección.

Paso 4: Convertir a Modelo Físico

Utiliza Ingeniería > Ingeniería a Modelo Relacional y selecciona Oracle como plataforma.

SDDM convertirá tus entidades lógicas a tablas físicas con tipos de datos Oracle específicos.

Paso 5: Generar Script SQL (DDL)

Usa Archivo > Exportar > Archivo DDL para generar automáticamente los scripts SQL.

El script generado incluirá todos los CREATE TABLE, restricciones, y otros objetos de base de datos.

Ejemplo de Representación Gráfica en Data Modeler:

SDDM te permite ver claramente cómo se conectan tus datos, identificar posibles problemas de diseño y generar la base de tu base de datos de manera eficiente.

Módulo 4: Creando tu Base de Datos con Scripts SQL

Un script SQL es simplemente un archivo de texto que contiene una secuencia de comandos SQL. Son increíblemente útiles para:

• Automatizar la creación de la estructura de la base de datos (tablas, índices, restricciones, vistas, etc.).
• Poblar la base de datos con datos iniciales o de prueba.
• Realizar modificaciones consistentes en la estructura (ej: añadir una columna).
• Recrear la base de datos fácilmente en diferentes entornos (desarrollo, pruebas, producción).
• Control de versiones de tu esquema de base de datos.

🔹 Estructura de un Script de Creación Típico:

Un buen script suele seguir un orden lógico:

1. (Opcional) Comandos para limpiar/eliminar objetos existentes: Para que el script sea re-ejecutable (ej: DROP TABLE nombre_tabla;). En Oracle, esto puede ser más complejo si hay dependencias de FK, a veces se requiere un orden específico o deshabilitar constraints temporalmente.

   -- Cuidado con DROP en producción! Usar con precaución.
   BEGIN
      EXECUTE IMMEDIATE 'DROP TABLE Detalle_Venta';
   EXCEPTION
      WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF; -- Ignora error "table does not exist"
   END;
   / 
   -- (Repetir para Venta, Producto, Cliente en orden inverso de dependencias)
                               

   (El bloque PL/SQL anterior es una forma de manejar errores si la tabla no existe. En desarrollo, un simple DROP TABLE ... CASCADE CONSTRAINTS; puede ser más directo si se conocen las implicaciones.)

2. Creación de Tablas (CREATE TABLE): Define la estructura y restricciones primarias.
3. Creación de Secuencias (CREATE SEQUENCE): (Común en Oracle para generar IDs únicos si no se usan IDENTITY columns de Oracle 12c+).
4. (Opcional) Modificación de Tablas (ALTER TABLE): Para añadir restricciones de Clave Foránea después de que todas las tablas referenciadas existan.
5. Creación de Índices (CREATE INDEX).
6. Inserción de Datos (INSERT INTO).
7. Comandos COMMIT; Para guardar permanentemente los cambios de DML (Data Manipulation Language como INSERT, UPDATE, DELETE).
8. (Opcional) Creación de Vistas, Procedimientos, Funciones, Triggers.
9. Consultas de Verificación (SELECT).

Ejemplo de Script SQL para la Tienda Online (Oracle):

-- Borrado de tablas (simplificado para demo, en orden inverso de creación y dependencias)
-- DROP TABLE Detalle_Venta;
-- DROP TABLE Venta;
-- DROP TABLE Producto;
-- DROP TABLE Cliente;
-- DROP SEQUENCE seq_cliente_id;
-- DROP SEQUENCE seq_producto_id;
-- DROP SEQUENCE seq_venta_id;
-- DROP SEQUENCE seq_detalle_id;

-- Creación de Secuencias para IDs
CREATE SEQUENCE seq_cliente_id START WITH 1 INCREMENT BY 1;
CREATE SEQUENCE seq_producto_id START WITH 100 INCREMENT BY 1;
CREATE SEQUENCE seq_venta_id START WITH 1000 INCREMENT BY 1;
CREATE SEQUENCE seq_detalle_id START WITH 5000 INCREMENT BY 1;

-- Tabla Cliente
CREATE TABLE Cliente (
    ID_Cliente      NUMBER(10) DEFAULT seq_cliente_id.NEXTVAL PRIMARY KEY,
    Nombre          VARCHAR2(50) NOT NULL,
    Apellido        VARCHAR2(50) NOT NULL,
    Email           VARCHAR2(100) UNIQUE,
    FechaRegistro   DATE DEFAULT SYSDATE
);

-- Tabla Producto
CREATE TABLE Producto (
    ID_Producto     NUMBER(10) DEFAULT seq_producto_id.NEXTVAL PRIMARY KEY,
    NombreProd      VARCHAR2(100) NOT NULL,
    PrecioUnit      NUMBER(10,2) NOT NULL CHECK (PrecioUnit > 0),
    StockDisp       NUMBER(6) DEFAULT 0 CHECK (StockDisp >= 0)
);

-- Tabla Venta
CREATE TABLE Venta (
    ID_Venta        NUMBER(12) DEFAULT seq_venta_id.NEXTVAL PRIMARY KEY,
    ID_Cliente_FK   NUMBER(10) NOT NULL,
    FechaVenta      TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    MontoTotal      NUMBER(12,2),
    CONSTRAINT fk_v_cliente FOREIGN KEY (ID_Cliente_FK) REFERENCES Cliente(ID_Cliente)
);

-- Tabla Detalle_Venta (para relación M:N entre Venta y Producto)
CREATE TABLE Detalle_Venta (
    ID_DetalleVenta NUMBER(12) DEFAULT seq_detalle_id.NEXTVAL PRIMARY KEY,
    ID_Venta_FK     NUMBER(12) NOT NULL,
    ID_Producto_FK  NUMBER(10) NOT NULL,
    Cantidad        NUMBER(5) NOT NULL CHECK (Cantidad > 0),
    PrecioVenta     NUMBER(10,2) NOT NULL, -- Precio al momento de la venta
    CONSTRAINT fk_dv_venta FOREIGN KEY (ID_Venta_FK) REFERENCES Venta(ID_Venta),
    CONSTRAINT fk_dv_producto FOREIGN KEY (ID_Producto_FK) REFERENCES Producto(ID_Producto),
    CONSTRAINT uq_dv_venta_prod UNIQUE (ID_Venta_FK, ID_Producto_FK) -- Un producto solo una vez por venta
);

-- Insertar datos en Cliente
INSERT INTO Cliente (Nombre, Apellido, Email) VALUES ('Carlos', 'Santana', 'carlos.s@example.com');
INSERT INTO Cliente (Nombre, Apellido, Email) VALUES ('Laura', 'Pausini', 'laura.p@example.com');
COMMIT;

-- Insertar datos en Producto
INSERT INTO Producto (NombreProd, PrecioUnit, StockDisp) VALUES ('Guitarra Eléctrica Pro', 799.99, 10);
INSERT INTO Producto (NombreProd, PrecioUnit, StockDisp) VALUES ('Micrófono Condensador', 149.50, 25);
INSERT INTO Producto (NombreProd, PrecioUnit, StockDisp) VALUES ('Teclado MIDI 61 teclas', 220.00, 15);
COMMIT;

-- Simular una Venta (requeriría lógica para MontoTotal y Detalle_Venta)
-- Ejemplo: Carlos (ID_Cliente_FK será 1 si es el primero) compra una guitarra
INSERT INTO Venta (ID_Cliente_FK, FechaVenta, MontoTotal) VALUES (
    (SELECT ID_Cliente FROM Cliente WHERE Email = 'carlos.s@example.com'), 
    TO_TIMESTAMP('2025-05-15 10:30:00', 'YYYY-MM-DD HH24:MI:SS'), 
    799.99
);
COMMIT;

-- Insertar detalle de esa venta
INSERT INTO Detalle_Venta (ID_Venta_FK, ID_Producto_FK, Cantidad, PrecioVenta) VALUES (
    (SELECT ID_Venta FROM Venta WHERE ID_Cliente_FK = (SELECT ID_Cliente FROM Cliente WHERE Email = 'carlos.s@example.com')), -- Asumiendo es la última venta de Carlos
    (SELECT ID_Producto FROM Producto WHERE NombreProd = 'Guitarra Eléctrica Pro'),
    1,
    799.99
);
COMMIT;

-- Consultar los datos
SELECT 'Clientes:' AS Tabla, COUNT(*) AS Registros FROM Cliente
UNION ALL
SELECT 'Productos:', COUNT(*) FROM Producto
UNION ALL
SELECT 'Ventas:', COUNT(*) FROM Venta
UNION ALL
SELECT 'Detalle Ventas:', COUNT(*) FROM Detalle_Venta;

SELECT c.Nombre, c.Apellido, p.NombreProd, dv.Cantidad, dv.PrecioVenta, v.FechaVenta
FROM Cliente c
JOIN Venta v ON c.ID_Cliente = v.ID_Cliente_FK
JOIN Detalle_Venta dv ON v.ID_Venta = dv.ID_Venta_FK
JOIN Producto p ON dv.ID_Producto_FK = p.ID_Producto;
                            

Ejecución del Script:

• En Oracle SQL Developer: Abre una nueva "Hoja de Trabajo SQL" (Worksheet), pega el contenido del script y presiona F5 (Ejecutar Script) o el botón correspondiente.
• En SQL*Plus (línea de comandos): Guarda el script en un archivo (ej: crear_tienda.sql), conéctate a tu base de datos y ejecuta @ruta/a/tu/crear_tienda.sql.

Los scripts son tus aliados para construir y mantener tus bases de datos de forma ordenada y reproducible. A medida que avances en tu carrera con Oracle, verás que los scripts SQL son una herramienta fundamental en tu arsenal de desarrollo.