Fundamentos de Bases de Datos Relacionales

Introducción a las Bases de Datos Relacionales

Antes de escribir una sola línea de código, hay que entender el terreno que pisamos. Una base de datos relacional no es más que un conjunto de tablas que se relacionan entre sí — como un gran archivador con fichas que se cruzan por códigos comunes.

🧱 ¿Qué es una tabla?

La unidad fundamental. Piensa en una hoja de cálculo: cada fila es un registro (una persona, un producto, un pedido) y cada columna es un atributo (nombre, precio, fecha).

🔑 Claves primarias y foráneas

Aquí está la magia del modelo relacional:

🌐 El modelo relacional de un vistazo

Una base de datos no es una tabla sola, sino un conjunto de tablas conectadas por claves foráneas. Este esqueleto se llama esquema relacional.

⬆️ Un departamento tiene muchos empleados (1:N). La FK depto_id en EMPLEADOS apunta a id en DEPARTAMENTOS.

Relaciones y Cardinalidad

La cardinalidad define cuántos elementos de una entidad se asocian con cuántos de otra. Es el lenguaje que usamos para dibujar bases de datos antes de escribirlas.

📐 Notación de pata de gallo (Crow's Foot)

Es el estándar visual en el modelado de datos. Cada extremo de la línea puede tener:

Relación 1:1 (Uno a Uno)

Un registro de la tabla A se relaciona con exactamente uno de la tabla B, y viceversa. Como una persona y su pasaporte.

Relación 1:N (Uno a Muchos)

La más común. Un registro de A se relaciona con varios de B, pero cada B pertenece a un solo A. Ejemplo: un cliente tiene muchos pedidos.

Relación N:M (Muchos a Muchos)

Un registro de A puede relacionarse con muchos de B, y viceversa. Ejemplo: estudiantes y cursos — un estudiante se matricula en muchos cursos, y cada curso tiene muchos estudiantes.

Normalización (1FN, 2FN, 3FN, BCNF)

La normalización es el proceso de organizar los datos para eliminar redundancias y evitar anomalías. Piénsalo como "ordenar el armario": cada cosa en su sitio, una sola vez.

📖 Explicación detallada

PyQt5 y Bases de Datos

PyQt5 viene con un módulo llamado QtSql que abstrae las diferencias entre motores de base de datos. Puedes escribir el mismo código para SQLite, MariaDB, PostgreSQL, etc., y solo cambiar la cadena de conexión.

🧩 Componentes principales de QtSql

🔌 Estructura básica de conexión

Este es el esqueleto que usaremos tanto para SQLite como para MariaDB:

from PyQt5.QtSql import QSqlDatabase, QSqlQuery
from PyQt5.QtWidgets import QApplication, QMessageBox

def conectar_bd(tipo="QSQLITE"):
    db = QSqlDatabase.addDatabase(tipo)
    if tipo == "QSQLITE":
        db.setDatabaseName("contactos.db")
    elif tipo == "QMARIADB":
        db.setHostName("localhost")
        db.setDatabaseName("contactos_db")
        db.setUserName("root")
        db.setPassword("tu_password")
        db.setPort(3306)
    if not db.open():
        QMessageBox.critical(None, "Error",
            db.lastError().text())
    return db

CRUD con SQLite

SQLite es el motor de base de datos más usado del mundo. Está en tu teléfono, en tu navegador y en miles de millones de dispositivos. Es un archivo local — no necesita servidor.

📁 Conectar y crear tabla

import sys
from PyQt5.QtSql import QSqlDatabase, QSqlQuery
from PyQt5.QtWidgets import QApplication, QMainWindow, QTableView, QVBoxLayout, QWidget
from PyQt5.QtCore import Qt

app = QApplication(sys.argv)

db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("contactos.db")
db.open()

# Crear tabla si no existe
q = QSqlQuery()
q.exec("""CREATE TABLE IF NOT EXISTS contactos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nombre TEXT NOT NULL,
    email TEXT,
    telefono TEXT,
    creado DATE DEFAULT CURRENT_DATE
)""")

Con solo estas líneas ya tienes una base de datos funcional. El archivo contactos.db se crea automáticamente en el mismo directorio.

➕ Operaciones CRUD

# Leer todos los contactos
q = QSqlQuery("SELECT * FROM contactos")
while q.next():
    print(f"{q.value(0)}: {q.value(1)} — {q.value(2)}")

# Insertar un contacto
q = QSqlQuery()
q.prepare("INSERT INTO contactos (nombre, email, telefono) VALUES (?, ?, ?)")
q.addBindValue("Ana García")
q.addBindValue("ana@mail.com")
q.addBindValue("612345678")
q.exec()

# Actualizar un contacto
q = QSqlQuery()
q.prepare("UPDATE contactos SET email = ? WHERE id = ?")
q.addBindValue("ana.garcia@mail.com")
q.addBindValue(1)
q.exec()

# Eliminar un contacto
q = QSqlQuery()
q.prepare("DELETE FROM contactos WHERE id = ?")
q.addBindValue(2)
q.exec()

📋 QSqlTableModel — La forma más fácil

# Modelo conectado a la tabla entera
modelo = QSqlTableModel()
modelo.setTable("contactos")
modelo.setEditStrategy(QSqlTableModel.OnManualSubmit)
modelo.select()  # carga los datos

# Mostrar en una tabla
vista = QTableView()
vista.setModel(modelo)
vista.show()

# Los cambios se guardan con:
modelo.submitAll()

Con QSqlTableModel, el usuario puede editar las celdas directamente en la tabla. ¡No necesitas escribir consultas SQL para el CRUD básico!

CRUD con MariaDB

MariaDB es un motor cliente-servidor. Necesitas tener el servidor instalado y ejecutándose. El cambio desde SQLite es mínimo en código, pero enorme en capacidades.

⚙️ Requisitos previos

🔌 Conexión a MariaDB

db = QSqlDatabase.addDatabase("QMARIADB")
db.setHostName("localhost")   # o la IP del servidor
db.setPort(3306)                # puerto por defecto de MariaDB
db.setDatabaseName("contactos_db")
db.setUserName("root")
db.setPassword("password_seguro")

if not db.open():
    print("Error:", db.lastError().text())
else:
    print("✅ Conectado a MariaDB")

🔄 Las mismas operaciones CRUD

Una vez conectado, las operaciones SQL son idénticas a SQLite. La magia de QtSql es que abstrae las diferencias:

q = QSqlQuery()
q.prepare("""INSERT INTO contactos (nombre, email, telefono)
VALUES (?, ?, ?)""")
q.addBindValue("María López")
q.addBindValue("maria@mail.com")
q.addBindValue("698765432")
q.exec()
print("Insertado con ID:", q.lastInsertId())

q = QSqlQuery("SELECT id, nombre, email FROM contactos")
while q.next():
    print(f"{q.value('id')}: {q.value('nombre')} <{q.value('email')}>")

# ¡Exactamente el mismo código que con SQLite!
modelo = QSqlTableModel()
modelo.setTable("contactos")
modelo.setEditStrategy(QSqlTableModel.OnFieldChange)
modelo.select()
modelo.setHeaderData(1, Qt.Horizontal, "Nombre")
modelo.setHeaderData(2, Qt.Horizontal, "Email")

vista = QTableView()
vista.setModel(modelo)
vista.show()

Miniproyecto: Libreta de Contactos

Vamos a construir una aplicación completa de libreta de contactos con PyQt5 que funcione tanto con SQLite como con MariaDB. El usuario podrá elegir el motor al iniciar.

📦 Código completo del proyecto

# libreta_contactos.py — App CRUD con PyQt5
# Funciona con SQLITE (local) o MARIADB (servidor)

import sys
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout,
    QHBoxLayout, QPushButton, QTableView, QLineEdit,
    QLabel, QMessageBox, QComboBox
)
from PyQt5.QtSql import QSqlDatabase, QSqlTableModel, QSqlQuery
from PyQt5.QtCore import Qt

class LibretaContactos(QMainWindow):
    def __init__(self, motor="sqlite"):
        super().__init__()
        self.setWindowTitle("📒 Libreta de Contactos")
        self.resize(700, 500)
        self.conectar_bd(motor)
        self.init_ui()

    def conectar_bd(self, motor):
        db = QSqlDatabase.addDatabase(
            "QSQLITE" if motor == "sqlite" else "QMARIADB"
        )
        if motor == "sqlite":
            db.setDatabaseName("contactos.db")
        else:
            db.setHostName("localhost")
            db.setDatabaseName("contactos_db")
            db.setUserName("root")
            db.setPassword("password")
            db.setPort(3306)

        if not db.open():
            QMessageBox.critical(self, "Error BD",
                db.lastError().text())
            sys.exit(1)

        # Crear tabla si es necesario
        q = QSqlQuery()
        q.exec("""CREATE TABLE IF NOT EXISTS contactos (
            id INTEGER PRIMARY KEY AUTO_INCREMENT,
            nombre TEXT NOT NULL,
            email TEXT,
            telefono TEXT,
            creado DATE DEFAULT CURRENT_DATE
        )""")

    def init_ui(self):
        central = QWidget()
        self.setCentralWidget(central)
        layout = QVBoxLayout(central)

        # Barra de búsqueda
        top = QHBoxLayout()
        self.busqueda = QLineEdit()
        self.busqueda.setPlaceholderText("🔍 Buscar contacto...")
        self.busqueda.textChanged.connect(self.filtrar)
        top.addWidget(QLabel("Buscar:"))
        top.addWidget(self.busqueda)
        layout.addLayout(top)

        # Tabla de datos
        self.modelo = QSqlTableModel()
        self.modelo.setTable("contactos")
        self.modelo.setEditStrategy(QSqlTableModel.OnManualSubmit)
        self.modelo.select()
        self.modelo.setHeaderData(1, Qt.Horizontal, "Nombre")
        self.modelo.setHeaderData(2, Qt.Horizontal, "Email")
        self.modelo.setHeaderData(3, Qt.Horizontal, "Teléfono")

        self.tabla = QTableView()
        self.tabla.setModel(self.modelo)
        self.tabla.setSelectionBehavior(QTableView.SelectRows)
        self.tabla.setAlternatingRowColors(True)
        layout.addWidget(self.tabla)

        # Botones
        btn_layout = QHBoxLayout()
        btn_add = QPushButton("➕ Añadir")
        btn_add.clicked.connect(self.anadir)
        btn_save = QPushButton("💾 Guardar cambios")
        btn_save.clicked.connect(self.guardar)
        btn_del = QPushButton("🗑️ Eliminar")
        btn_del.clicked.connect(self.eliminar)
        btn_layout.addWidget(btn_add)
        btn_layout.addWidget(btn_save)
        btn_layout.addWidget(btn_del)
        layout.addLayout(btn_layout)

    def anadir(self):
        # Añade fila vacía para editar
        row = self.modelo.rowCount()
        self.modelo.insertRow(row)

    def guardar(self):
        if self.modelo.submitAll():
            QMessageBox.information(self, "OK", "Cambios guardados ✅")
        else:
            QMessageBox.warning(self, "Error",
                self.modelo.lastError().text())

    def eliminar(self):
        sel = self.tabla.selectionModel().selectedRows()
        for i in reversed(sel):
            self.modelo.removeRow(i.row())
        self.guardar()

    def filtrar(self, texto):
        if texto:
            self.modelo.setFilter(
                f"nombre LIKE '%{texto}%' OR email LIKE '%{texto}%'")
        else:
            self.modelo.setFilter("")
        self.modelo.select()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    # Cambia a "mariadb" para usar servidor
    ventana = LibretaContactos(motor="sqlite")
    ventana.show()
    sys.exit(app.exec())

SQLite vs MariaDB

No hay un "mejor" motor — hay el motor adecuado para cada situación. Aquí tienes una comparativa directa para que puedas elegir con criterio.

📊 Tabla comparativa rápida

Buenas Prácticas

Pequeños hábitos que marcan la diferencia entre un diseño que funciona y uno que duele mantener.