mtpk-postgres 0.1.0__py3-none-any.whl

mtpk_postgres/core_sync.py

@@ -0,0 +1,1688 @@
+#!/usr/bin/env python3
+#-*- coding: UTF-8 -*-
+# ----------------------------------------
+# jjandres 2025
+# Adaptación a Postgres (psycopg) de mtpk_mariadb.core_sync
+# ----------------------------------------
+
+
+# Esta librería es un wrapper (envolvente) del conector psycopg para manejo de Postgres
+
+import psycopg
+from psycopg.rows import dict_row
+import logging
+import re
+import traceback
+from dataclasses import dataclass, field
+from typing import Optional, Union, Literal, List, Dict
+
+from contextlib import contextmanager
+
+
+@dataclass
+class SQLLiteral:
+    valor: str
+    def __str__(self):
+        return self.valor
+
+
+@dataclass
+class Columna:
+    """
+    Representa una columna SQL para crear tablas en Postgres.
+
+    Esta clase define los atributos necesarios para generar la declaración SQL de una columna,
+    incluyendo tipos de datos, claves primarias, restricciones, valores por defecto y soporte
+    para columnas calculadas (GENERATED).
+
+    Atributos:
+        - `nombre` (str): Nombre de la columna.
+        - `tipo` (Literal): Tipo de dato del modelo (se traduce al tipo equivalente en Postgres).
+        - `longitud` (int, opcional): Longitud para tipos como VARCHAR(n), CHAR(n).
+        - `precision` (int, opcional): Precisión para tipos numéricos como DECIMAL(p,s).
+        - `escala` (int, opcional): Escala para tipos numéricos como DECIMAL(p,s).
+        - `not_null` (bool): Indica si la columna es NOT NULL.
+        - `primary_key` (bool): Indica si la columna es clave primaria.
+        - `unique` (bool): Indica si la columna tiene restricción UNIQUE.
+        - `auto_increment` (bool): Si es True, la columna se crea como GENERATED ALWAYS AS IDENTITY.
+        - `default` (str|int|float, opcional): Valor por defecto de la columna.
+        - `comentario` (str, opcional): Comentario asociado a la columna (se emite como COMMENT ON COLUMN aparte).
+        - `enum_opciones` (list[str], opcional): Valores válidos si el tipo es ENUM o SET (se traduce a TEXT + CHECK).
+        - `protegido_insertar` (bool): Si está protegida contra inserciones vía CRUD.
+        - `protegido_actualizar` (bool): Si está protegida contra actualizaciones vía CRUD.
+        - `generado` (str, opcional): Expresión SQL para columnas calculadas (GENERATED ALWAYS AS (...) STORED).
+        - `generado_tipo` (str, opcional): Se conserva por compatibilidad, pero Postgres solo admite columnas
+            calculadas STORED, así que siempre se emite como STORED independientemente de este valor.
+        - `tabla` (Tabla, opcional): Referencia a la tabla que contiene esta columna.
+    """
+
+    nombre: str
+    """Nombre de la columna"""
+
+    tipo: Literal[
+        "TINYINT", "SMALLINT", "MEDIUMINT", "INT", "INTEGER", "BIGINT", "DECIMAL", "NUMERIC", "FLOAT", "DOUBLE",
+        "CHAR", "VARCHAR", "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT", "BINARY", "VARBINARY", "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",
+        "DATE", "TIME", "YEAR", "DATETIME", "TIMESTAMP", "ENUM", "SET", "BOOLEAN", "GEOMETRY", "POINT", "LINESTRING", "POLYGON"
+    ]
+    """Tipo de dato del modelo (mismo vocabulario que mtpk-mariadb, traducido a Postgres en to_sql())"""
+
+    longitud: Optional[int] = None
+    """Longitud para tipos como VARCHAR(n), CHAR(n)."""
+
+    precision: Optional[int] = None
+    """Precisión para DECIMAL(p, s), etc."""
+
+    escala: Optional[int] = None
+    """Escala para DECIMAL(p, s), opcional"""
+
+    not_null: bool = False
+    """Si la columna debe ser NOT NULL"""
+
+    primary_key: bool = False
+    """Si esta columna es clave primaria"""
+
+    unique: bool = False
+    """Si esta columna tiene restricción UNIQUE"""
+
+    auto_increment: bool = False
+    """Si es autoincremental (GENERATED ALWAYS AS IDENTITY en Postgres)"""
+
+    default: Optional[Union[str, int, float, Literal["CURRENT_TIMESTAMP"]]] = None
+    """Valor por defecto. Usar CURRENT_TIMESTAMP como literal string si aplica."""
+
+    comentario: Optional[str] = None
+    """Comentario asociado a la columna"""
+
+    enum_opciones: Optional[list[str]] = None
+    """Lista de valores posibles si tipo es ENUM o SET"""
+
+    protegido_insertar: bool = False
+    """Si esta columna está protegida contra inserciones (Solo cuando se indique al método CRUD)"""
+
+    protegido_actualizar: bool = False
+    """Si esta columna está protegida contra actualizaciones (Solo cuando se indique al método CRUD)"""
+
+    generado: Optional[str] = None
+    """Expresión SQL para campos calculados (GENERATED ALWAYS AS (...) STORED)"""
+
+    generado_tipo: Optional[Literal["STORED", "VIRTUAL"]] = None
+    """Se conserva por compatibilidad; Postgres siempre emite STORED."""
+
+    tabla: Optional["Tabla"] = field(default=None, repr=False)
+
+    _MAPA_TIPOS = {
+        "TINYINT": "SMALLINT", "SMALLINT": "SMALLINT", "MEDIUMINT": "SMALLINT",
+        "INT": "INTEGER", "INTEGER": "INTEGER", "BIGINT": "BIGINT",
+        "DECIMAL": "DECIMAL", "NUMERIC": "NUMERIC",
+        "FLOAT": "REAL", "DOUBLE": "DOUBLE PRECISION",
+        "CHAR": "CHAR", "VARCHAR": "VARCHAR",
+        "TEXT": "TEXT", "TINYTEXT": "TEXT", "MEDIUMTEXT": "TEXT", "LONGTEXT": "TEXT",
+        "BINARY": "BYTEA", "VARBINARY": "BYTEA", "BLOB": "BYTEA",
+        "TINYBLOB": "BYTEA", "MEDIUMBLOB": "BYTEA", "LONGBLOB": "BYTEA",
+        "DATE": "DATE", "TIME": "TIME", "DATETIME": "TIMESTAMP", "TIMESTAMP": "TIMESTAMP",
+        "YEAR": "SMALLINT",
+        "BOOLEAN": "BOOLEAN",
+        "ENUM": "TEXT", "SET": "TEXT",
+    }
+    _SIN_SOPORTE = {"GEOMETRY", "POINT", "LINESTRING", "POLYGON"}
+
+    def _tipo_sql(self) -> str:
+        """Traduce self.tipo (+ longitud/precision/escala) al tipo SQL de Postgres."""
+        tipo_upper = self.tipo.upper()
+        if tipo_upper in self._SIN_SOPORTE:
+            raise NotImplementedError(
+                f"El tipo '{tipo_upper}' requiere la extensión PostGIS y no está soportado."
+            )
+        base = self._MAPA_TIPOS.get(tipo_upper, tipo_upper)
+
+        if base in {"VARCHAR", "CHAR"}:
+            return f"{base}({self.longitud})"
+        if base in {"DECIMAL", "NUMERIC"}:
+            if self.precision is not None and self.escala is not None:
+                return f"{base}({self.precision},{self.escala})"
+            elif self.precision is not None:
+                return f"{base}({self.precision})"
+            return base
+        return base
+
+    def to_sql(self) -> str:
+        """
+        Genera la definición SQL de esta columna para Postgres.
+        Los comentarios (COMMENT ON COLUMN) no van aquí: se generan aparte en Tabla.to_sql_comentarios().
+        """
+        partes = [f'"{self.nombre}"']
+        tipo_upper = self.tipo.upper()
+        tipo_sql = self._tipo_sql()
+
+        if self.generado:
+            partes.append(f"{tipo_sql} GENERATED ALWAYS AS ({self.generado}) STORED")
+        else:
+            partes.append(tipo_sql)
+
+            if self.auto_increment:
+                partes.append("GENERATED ALWAYS AS IDENTITY")
+
+            partes.append("NOT NULL" if self.not_null or self.primary_key else "NULL")
+
+            if self.default is not None:
+                if isinstance(self.default, SQLLiteral):
+                    partes.append(f"DEFAULT {self.default}")
+                elif isinstance(self.default, str) and not self.default.upper().startswith("CURRENT_TIMESTAMP"):
+                    partes.append(f"DEFAULT '{self.default}'")
+                else:
+                    partes.append(f"DEFAULT {self.default}")
+
+            if self.unique:
+                partes.append("UNIQUE")
+
+            if self.primary_key:
+                partes.append("PRIMARY KEY")
+
+            if tipo_upper in {"ENUM", "SET"} and self.enum_opciones:
+                opciones = ", ".join(f"'{o}'" for o in self.enum_opciones)
+                partes.append(f'CHECK ("{self.nombre}" IN ({opciones}))')
+
+        return " ".join(partes)
+
+
+@dataclass
+class ForeignKey:
+    """
+    Representa una clave foránea (FOREIGN KEY) en una tabla SQL.
+
+    - Atributos:
+        - `columna`               (str): Nombre de la columna local en esta tabla que actúa como clave foránea.
+        - `referencia_tabla`      (str): Nombre de la tabla referenciada.
+        - `referencia_columna`    (str): Columna de la tabla referenciada a la que apunta esta clave foránea.
+        - `nombre`                (str, opcional): Nombre explícito del constraint. Si no se proporciona, Postgres generará uno automáticamente.
+        - `on_delete`             (str, opcional): Acción a realizar al eliminar la fila referenciada ('CASCADE', 'RESTRICT', 'SET NULL', etc.).
+        - `on_update`             (str, opcional): Acción a realizar al actualizar la fila referenciada.
+        - `tabla`                 (Tabla, opcional): Referencia a la tabla actual que contiene esta clave. Se asigna automáticamente.
+    """
+    columna: str
+    referencia_tabla: str
+    referencia_columna: str
+    nombre: Optional[str] = None
+    on_delete: Optional[str] = None
+    on_update: Optional[str] = None
+    tabla: Optional["Tabla"] = field(default=None, repr=False)
+
+    def to_sql(self) -> str:
+        sql = ""
+        if self.nombre:
+            sql += f'CONSTRAINT "{self.nombre}" '
+        sql += f'FOREIGN KEY ("{self.columna}") REFERENCES "{self.referencia_tabla}"("{self.referencia_columna}")'
+        if self.on_delete:
+            sql += f" ON DELETE {self.on_delete}"
+        if self.on_update:
+            sql += f" ON UPDATE {self.on_update}"
+        return sql
+
+
+@dataclass
+class Index:
+    """
+    Representa un índice (normal o único) sobre una o más columnas de una tabla SQL.
+
+    Postgres no admite índices dentro de CREATE TABLE: to_sql() genera aquí la sentencia
+    CREATE INDEX / CREATE UNIQUE INDEX completa (necesita conocer la tabla a la que pertenece).
+
+    - Atributos:
+        - `columnas`    (List[str]): Lista de nombres de columnas incluidas en el índice. Pueden ser una o varias (índice compuesto).
+        - `nombre`      (str, opcional): Nombre personalizado del índice. Si no se indica, se generará automáticamente combinando los nombres de las columnas.
+        - `unico`       (bool): Indica si el índice es único (`UNIQUE`). Por defecto es `False`.
+        - `tabla`       (Tabla, opcional): Referencia a la tabla que contiene este índice. Se asigna automáticamente al añadir el índice a la tabla.
+    """
+    columnas: List[str]
+    nombre: Optional[str] = None
+    unico: bool = False
+    tabla: Optional["Tabla"] = field(default=None, repr=False)
+
+    def to_sql(self) -> str:
+        if not self.tabla:
+            raise ValueError(
+                f"El índice sobre {self.columnas} no está asociado a ninguna tabla; no se puede generar el CREATE INDEX."
+            )
+        cols = ", ".join(f'"{c}"' for c in self.columnas)
+        nombre = self.nombre or f"{'_'.join(self.columnas)}_{'uk' if self.unico else 'idx'}"
+        tipo_sql = "UNIQUE INDEX" if self.unico else "INDEX"
+        return f'CREATE {tipo_sql} IF NOT EXISTS "{nombre}" ON "{self.tabla.nombre}" ({cols})'
+
+
+@dataclass
+class Tabla:
+    """
+    Representa la definición estructural de una tabla SQL para Postgres.
+
+    - Atributos:
+        - `nombre`              (str): Nombre de la tabla en la base de datos.
+        - `columnas`            (List[Columna]): Lista de objetos `Columna` que definen los campos de la tabla.
+        - `indices`             (List[Index]): Lista de índices adicionales (simples o compuestos), excluyendo claves primarias y claves foráneas.
+        - `foreign_keys`        (List[ForeignKey]): Lista de claves foráneas que definen relaciones con otras tablas.
+        - `claves_primarias`    (List[str]): Lista de nombres de columnas que componen la clave primaria (si es compuesta).
+        - `comentario`          (str, opcional): Comentario descriptivo opcional para la tabla.
+        - `registros_iniciales` (Optional[List[Dict[str, Union[str, int, float]]]]):
+                                Lista de diccionarios con registros que deben insertarse automáticamente tras crear la tabla.
+                                Cada diccionario representa un registro, con las claves como nombres de columnas.
+        - `vistas`              (Optional[List[str]]): Lista de vistas asociadas a esta tabla, que serán insertadas en la base de datos.
+        - `triggers`            (list[str], opcional): Sentencias SQL de triggers asociados.
+        - `db_name`             (str, opcional): Nombre de la base de datos asociada a esta tabla. Solo se usa para clasificar la tabla y saber a que base de datos pertenece.
+        - `database`            (Database, opcional): Referencia a la instancia de `Database` a la que pertenece esta tabla. Se asigna automáticamente al añadir la tabla a una base de datos.
+
+    """
+    nombre: str
+    columnas: List[Columna]
+    indices: List[Index] = field(default_factory=list)
+    foreign_keys: List[ForeignKey] = field(default_factory=list)
+    claves_primarias: List[str] = field(default_factory=list)
+    comentario: Optional[str] = None
+    registros_iniciales: Optional[List[Dict[str, Union[str, int, float]]]] = field(default_factory=list)
+    vistas: Optional[List[str]] = field(default_factory=list)
+    triggers: Optional[list[str]] = None
+    procedimientos: Optional[list[str]] = None
+    database: Optional["Database"] = None
+    db_name: Optional[str] = None  # ← nuevo campo, sin conflicto con Database
+
+    def add_columna(self, columna: Columna):
+        """
+        Añade una columna a la tabla si no existe ya.
+
+        - Args:
+            - `columna` (Columna): Objeto columna a añadir.
+
+        Raises:
+            ValueError: Si ya existe una columna con el mismo nombre.
+        """
+
+        if any(col.nombre == columna.nombre for col in self.columnas):
+            raise ValueError(f"La columna '{columna.nombre}' ya está definida en la tabla '{self.nombre}'.")
+        columna.tabla = self
+        self.columnas.append(columna)
+
+    def set_columnas(self, columnas: List[Columna]):
+        """
+        Reemplaza la lista completa de columnas con una nueva, validando que no haya duplicados.
+
+        - Args:
+            - `columnas` (List[Columna]): Lista de objetos Columna.
+
+        Raises:
+            ValueError: Si hay columnas con nombres duplicados.
+        """
+        nombres = [col.nombre for col in columnas]
+        duplicados = {nombre for nombre in nombres if nombres.count(nombre) > 1}
+        if duplicados:
+            raise ValueError(f"Columnas duplicadas encontradas: {', '.join(duplicados)}")
+        for col in columnas:
+            col.tabla = self
+        self.columnas = columnas
+
+    def get_nombres_columnas(self):
+        """Devuelve una lista con los nombre de las columnas de la tabla"""
+        return [c.nombre for c in self.columnas]
+
+    def add_index(self, index: Index):
+        if any(set(index.columnas) == set(idx.columnas) for idx in self.indices):
+            raise ValueError(f"Ya existe un índice para las columnas {index.columnas} en la tabla '{self.nombre}'.")
+        index.tabla = self
+        self.indices.append(index)
+
+    def set_indices(self, indices: List[Index]):
+        seen = set()
+        for idx in indices:
+            key = tuple(sorted(idx.columnas))
+            if key in seen:
+                raise ValueError(f"Índice duplicado con columnas: {key}")
+            seen.add(key)
+            idx.tabla = self
+        self.indices = indices
+
+    def add_foreign_key(self, fk: ForeignKey):
+        if any((fk.columna == f.columna and fk.referencia_tabla == f.referencia_tabla and fk.referencia_columna == f.referencia_columna) for f in self.foreign_keys):
+            raise ValueError(f"Ya existe una clave foránea similar en la tabla '{self.nombre}'.")
+        fk.tabla = self
+        self.foreign_keys.append(fk)
+
+    def set_foreign_keys(self, foreign_keys: List[ForeignKey]):
+        """
+        Asigna la lista completa de claves foráneas, validando duplicados y asignando la tabla padre.
+
+        Args:
+            foreign_keys (List[ForeignKey]): Lista de claves foráneas.
+
+        Raises:
+            ValueError: Si hay duplicados por columna/referencia.
+        """
+        claves_unicas = set()
+        for fk in foreign_keys:
+            clave = (fk.columna, fk.referencia_tabla, fk.referencia_columna)
+            if clave in claves_unicas:
+                raise ValueError(f"Clave foránea duplicada: {clave}")
+            claves_unicas.add(clave)
+            fk.tabla = self
+        self.foreign_keys = foreign_keys
+
+    def set_database(self, db):
+        """
+        Establece la base de datos a la que pertenece esta tabla.
+        """
+        self.database = db
+
+    def to_sql(self) -> str:
+        """
+        Genera la sentencia SQL CREATE TABLE IF NOT EXISTS con columnas, clave primaria compuesta y claves foráneas.
+        Los índices y los comentarios van aparte: ver `to_sql_indices()` y `to_sql_comentarios()`.
+        """
+        elementos_sql = []
+
+        for col in self.columnas:
+            elementos_sql.append(col.to_sql())
+
+        if self.claves_primarias:
+            pk = ", ".join(f'"{c}"' for c in self.claves_primarias)
+            elementos_sql.append(f"PRIMARY KEY ({pk})")
+
+        for fk in self.foreign_keys:
+            elementos_sql.append(fk.to_sql())
+
+        cuerpo = ",\n  ".join(elementos_sql)
+
+        return (
+            f'CREATE TABLE IF NOT EXISTS "{self.nombre}" (\n'
+            f"  {cuerpo}\n"
+            f");"
+        )
+
+    def to_sql_indices(self) -> List[str]:
+        """Sentencias CREATE INDEX / CREATE UNIQUE INDEX de esta tabla (van fuera del CREATE TABLE en Postgres)."""
+        return [f"{idx.to_sql()};" for idx in self.indices]
+
+    def to_sql_comentarios(self) -> List[str]:
+        """Sentencias COMMENT ON TABLE / COMMENT ON COLUMN de esta tabla (Postgres no admite COMMENT inline)."""
+        sentencias = []
+        if self.comentario:
+            texto = self.comentario.replace("'", "''")
+            sentencias.append(f"COMMENT ON TABLE \"{self.nombre}\" IS '{texto}';")
+        for col in self.columnas:
+            if col.comentario:
+                texto = col.comentario.replace("'", "''")
+                sentencias.append(f"COMMENT ON COLUMN \"{self.nombre}\".\"{col.nombre}\" IS '{texto}';")
+        return sentencias
+
+    _PG_A_MODELO = {
+        "smallint": "SMALLINT",
+        "integer": "INTEGER",
+        "bigint": "BIGINT",
+        "numeric": "DECIMAL",
+        "real": "FLOAT",
+        "double precision": "DOUBLE",
+        "character varying": "VARCHAR",
+        "character": "CHAR",
+        "text": "TEXT",
+        "bytea": "BLOB",
+        "date": "DATE",
+        "time without time zone": "TIME",
+        "timestamp without time zone": "TIMESTAMP",
+        "boolean": "BOOLEAN",
+    }
+
+    def obtener_columnas_postgres(self, conexion, dbname=None) -> List[Columna]:
+        """
+        Obtiene la definición de columnas de esta tabla desde Postgres.
+        Consulta information_schema.columns (más las claves primarias/únicas de
+        information_schema.table_constraints) para reconstruir cada Columna.
+
+        Args:
+            - `conexion`: Conexión psycopg abierta.
+            - `dbname`: (Opcional) Nombre de la base de datos; si se omite se toma de
+                        self.database.db. Postgres solo ve el catálogo de la base conectada,
+                        así que este valor no se usa para filtrar, se mantiene por compatibilidad
+                        de firma con la versión mariadb.
+
+        Returns:
+            - `columnas`: Lista de objetos Columna con la definición de cada columna.
+        """
+        if not dbname:
+            if not self.database or not hasattr(self.database, 'db'):
+                raise ValueError("No se ha especificado el nombre de la base de datos y la tabla no está asociada a una instancia Database.")
+            dbname = self.database.db
+
+        columnas = []
+        with conexion.cursor(row_factory=dict_row) as cursor:
+            cursor.execute(
+                """
+                SELECT
+                    c.column_name, c.data_type, c.character_maximum_length,
+                    c.numeric_precision, c.numeric_scale, c.is_nullable,
+                    c.column_default, c.is_identity,
+                    COALESCE(pk.es_pk, false) AS es_pk,
+                    COALESCE(uq.es_unique, false) AS es_unique
+                FROM information_schema.columns c
+                LEFT JOIN (
+                    SELECT kcu.column_name, true AS es_pk
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu
+                        ON tc.constraint_name = kcu.constraint_name
+                        AND tc.table_schema = kcu.table_schema
+                    WHERE tc.table_schema = 'public' AND tc.table_name = %s
+                        AND tc.constraint_type = 'PRIMARY KEY'
+                ) pk ON pk.column_name = c.column_name
+                LEFT JOIN (
+                    SELECT kcu.column_name, true AS es_unique
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu
+                        ON tc.constraint_name = kcu.constraint_name
+                        AND tc.table_schema = kcu.table_schema
+                    WHERE tc.table_schema = 'public' AND tc.table_name = %s
+                        AND tc.constraint_type = 'UNIQUE'
+                ) uq ON uq.column_name = c.column_name
+                WHERE c.table_schema = 'public' AND c.table_name = %s
+                ORDER BY c.ordinal_position
+                """,
+                (self.nombre, self.nombre, self.nombre)
+            )
+            filas = cursor.fetchall()
+
+        checks_por_columna = self._obtener_opciones_check(conexion)
+
+        for fila in filas:
+            tipo_base = self._PG_A_MODELO.get(fila["data_type"], fila["data_type"].upper())
+            enum_opciones = None
+
+            if tipo_base == "TEXT" and fila["column_name"] in checks_por_columna:
+                # Postgres no distingue ENUM de SET tras reconstruir desde el CHECK: ambos
+                # se guardan como TEXT + CHECK (ver Columna.to_sql), así que se asume ENUM.
+                tipo_base = "ENUM"
+                enum_opciones = checks_por_columna[fila["column_name"]]
+
+            col = Columna(
+                nombre=fila["column_name"],
+                tipo=tipo_base,
+                longitud=fila["character_maximum_length"],
+                precision=fila["numeric_precision"],
+                escala=fila["numeric_scale"],
+                not_null=(fila["is_nullable"] == "NO"),
+                default=fila["column_default"],
+                auto_increment=(fila["is_identity"] == "YES"),
+                primary_key=fila["es_pk"],
+                unique=fila["es_unique"],
+                enum_opciones=enum_opciones,
+            )
+            columnas.append(col)
+
+        return columnas
+
+    def _obtener_opciones_check(self, conexion) -> Dict[str, List[str]]:
+        """
+        Reconstruye, de forma best-effort, las opciones de las columnas ENUM/SET (TEXT + CHECK)
+        a partir de las restricciones CHECK existentes en la tabla.
+        """
+        resultado: Dict[str, List[str]] = {}
+        with conexion.cursor(row_factory=dict_row) as cursor:
+            cursor.execute(
+                """
+                SELECT pg_get_constraintdef(con.oid) AS definicion
+                FROM pg_constraint con
+                JOIN pg_class rel ON rel.oid = con.conrelid
+                JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+                WHERE con.contype = 'c' AND nsp.nspname = 'public' AND rel.relname = %s
+                """,
+                (self.nombre,)
+            )
+            for fila in cursor.fetchall():
+                definicion = fila["definicion"] or ""
+                m = re.match(r'CHECK\s*\(\("?(\w+)"?\s*=\s*ANY\s*\(ARRAY\[(.*?)\]', definicion, re.IGNORECASE)
+                if not m:
+                    m = re.match(r'CHECK\s*\(\("?(\w+)"?\s+IN\s*\((.*?)\)\)', definicion, re.IGNORECASE)
+                if m:
+                    columna = m.group(1)
+                    valores = re.findall(r"'([^']*)'", m.group(2))
+                    if valores:
+                        resultado[columna] = valores
+        return resultado
+
+    def obtener_indices_postgres(self, conexion, dbname: str = None) -> List["Index"]:
+        """
+        Obtiene los índices no primarios definidos en esta tabla en Postgres,
+        a partir de los catálogos pg_index/pg_class/pg_attribute.
+        """
+        with conexion.cursor(row_factory=dict_row) as cursor:
+            cursor.execute(
+                """
+                SELECT ix.relname AS nombre_indice, a.attname AS columna,
+                       i.indisunique AS es_unico, i.indisprimary AS es_primaria,
+                       array_position(i.indkey::int2[], a.attnum::int2) AS posicion
+                FROM pg_index i
+                JOIN pg_class t ON t.oid = i.indrelid
+                JOIN pg_class ix ON ix.oid = i.indexrelid
+                JOIN pg_namespace n ON n.oid = t.relnamespace
+                JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(i.indkey)
+                WHERE t.relname = %s AND n.nspname = 'public'
+                ORDER BY ix.relname, posicion
+                """,
+                (self.nombre,)
+            )
+            filas = cursor.fetchall()
+
+        agrupados: Dict[str, dict] = {}
+        for fila in filas:
+            if fila["es_primaria"]:
+                continue
+            info = agrupados.setdefault(fila["nombre_indice"], {"columnas": [], "unico": fila["es_unico"]})
+            info["columnas"].append(fila["columna"])
+
+        return [Index(nombre=nombre, columnas=info["columnas"], unico=info["unico"]) for nombre, info in agrupados.items()]
+
+    def obtener_fks_postgres(self, conexion, dbname: str = None) -> List["ForeignKey"]:
+        """
+        Recupera las claves foráneas existentes en esta tabla desde Postgres.
+        """
+        with conexion.cursor(row_factory=dict_row) as cursor:
+            cursor.execute(
+                """
+                SELECT
+                    kcu.constraint_name, kcu.column_name,
+                    ccu.table_name AS referenced_table_name,
+                    ccu.column_name AS referenced_column_name,
+                    rc.update_rule, rc.delete_rule
+                FROM information_schema.key_column_usage kcu
+                JOIN information_schema.referential_constraints rc
+                    ON kcu.constraint_name = rc.constraint_name
+                    AND kcu.constraint_schema = rc.constraint_schema
+                JOIN information_schema.constraint_column_usage ccu
+                    ON ccu.constraint_name = rc.unique_constraint_name
+                    AND ccu.constraint_schema = rc.unique_constraint_schema
+                WHERE kcu.table_schema = 'public' AND kcu.table_name = %s
+                """,
+                (self.nombre,)
+            )
+            filas = cursor.fetchall()
+
+        resultado = []
+        for fila in filas:
+            fk = ForeignKey(
+                columna=fila["column_name"],
+                referencia_tabla=fila["referenced_table_name"],
+                referencia_columna=fila["referenced_column_name"],
+                nombre=fila["constraint_name"],
+                on_update=fila["update_rule"],
+                on_delete=fila["delete_rule"]
+            )
+            resultado.append(fk)
+
+        return resultado
+
+    def comparar_generar_alter(self, conexion, dbname=None, permitir_drop=False) -> List[str]:
+        """
+        Compara la definición de esta tabla en los modelos contra su estado real en Postgres
+        y genera las sentencias necesarias para sincronizarla: ALTER TABLE (columnas nuevas o
+        modificadas mediante ALTER COLUMN, ya que Postgres no tiene MODIFY COLUMN), sentencias
+        CREATE/DROP INDEX sueltas (no van dentro de ALTER TABLE) y ADD/DROP CONSTRAINT para FKs.
+
+        Args:
+            - `conexion`: Conexión psycopg abierta.
+            - `dbname`: (Opcional) Nombre de la base de datos, si se deja vacío se toma de
+                        self.database.db emparentado a la tabla.
+            - `permitir_drop`: Si se permiten DROP INDEX y DROP CONSTRAINT (FK).
+
+        Returns:
+            List[str]: Sentencias SQL a ejecutar, en un orden seguro.
+        """
+
+        if not dbname:
+            if not self.database or not hasattr(self.database, 'db'):
+                raise ValueError("No se ha especificado el nombre de la base de datos y la tabla no está asociada a Database.")
+            dbname = self.database.db
+
+        col_alteraciones = []
+        idx_adds = []
+        idx_drops = []
+        fk_adds = []
+        fk_drops = []
+
+        reales = {col.nombre: col for col in self.obtener_columnas_postgres(conexion, dbname)}
+        definidas = {col.nombre: col for col in self.columnas}
+
+        def norm(val):
+            if val is None:
+                return None
+            texto = str(val).strip().lower()
+            texto = re.sub(r"::\w+(\[\])?$", "", texto)
+            return texto.replace("'", "").replace("()", "").strip()
+
+        def default_eq(real, definido):
+            if isinstance(definido, SQLLiteral):
+                definido = definido.valor
+            val_real = norm(real)
+            val_def = norm(definido)
+            null_equivalentes = {None, "null"}
+            if val_real in null_equivalentes and val_def in null_equivalentes:
+                return True
+            equivalentes = {("now", "current_timestamp")}
+            return (val_real, val_def) in equivalentes or (val_def, val_real) in equivalentes or val_real == val_def
+
+        def tipos_iguales(col_real, col_def):
+            return (
+                norm(col_real.tipo) == norm(col_def.tipo) and
+                col_real.longitud == col_def.longitud and
+                col_real.precision == col_def.precision and
+                (col_real.escala or None) == (col_def.escala or None)
+            )
+
+        def iguales(col_real, col_def):
+            return (
+                tipos_iguales(col_real, col_def) and
+                (col_real.not_null == col_def.not_null or col_def.primary_key) and
+                default_eq(col_real.default, col_def.default) and
+                bool(col_real.auto_increment) == bool(col_def.auto_increment) and
+                bool(col_real.primary_key) == bool(col_def.primary_key) and
+                bool(col_real.unique) == bool(col_def.unique) and
+                set(col_real.enum_opciones or []) == set(col_def.enum_opciones or [])
+            )
+
+        # --- COLUMNAS ---
+        for nombre, col_def in definidas.items():
+            col_real = reales.get(nombre)
+            if not col_real:
+                col_alteraciones.append(f"ADD COLUMN {col_def.to_sql()}")
+            elif not iguales(col_real, col_def):
+                if not tipos_iguales(col_real, col_def):
+                    tipo_sql = col_def._tipo_sql()
+                    col_alteraciones.append(f'ALTER COLUMN "{nombre}" TYPE {tipo_sql} USING "{nombre}"::{tipo_sql}')
+                if bool(col_real.not_null) != bool(col_def.not_null) and not col_def.primary_key:
+                    col_alteraciones.append(f'ALTER COLUMN "{nombre}" {"SET" if col_def.not_null else "DROP"} NOT NULL')
+                if not default_eq(col_real.default, col_def.default):
+                    if col_def.default is None:
+                        col_alteraciones.append(f'ALTER COLUMN "{nombre}" DROP DEFAULT')
+                    elif isinstance(col_def.default, SQLLiteral):
+                        col_alteraciones.append(f'ALTER COLUMN "{nombre}" SET DEFAULT {col_def.default}')
+                    elif isinstance(col_def.default, str) and not col_def.default.upper().startswith("CURRENT_TIMESTAMP"):
+                        col_alteraciones.append(f"ALTER COLUMN \"{nombre}\" SET DEFAULT '{col_def.default}'")
+                    else:
+                        col_alteraciones.append(f'ALTER COLUMN "{nombre}" SET DEFAULT {col_def.default}')
+
+        # --- ÍNDICES ---
+        reales_idx = {tuple(i.columnas): i for i in self.obtener_indices_postgres(conexion, dbname)}
+        definidos_idx = {tuple(i.columnas): i for i in self.indices}
+
+        for clave, idx_def in definidos_idx.items():
+            if clave not in reales_idx:
+                idx_adds.append(f"{idx_def.to_sql()};")
+
+        if permitir_drop:
+            for clave, idx_real in reales_idx.items():
+                if clave not in definidos_idx:
+                    # Evitar eliminar índices implícitos de FKs
+                    if any(
+                        fk.columna in idx_real.columnas and fk.nombre == idx_real.nombre
+                        for fk in self.foreign_keys
+                    ):
+                        continue
+                    idx_drops.append(f'DROP INDEX IF EXISTS "{idx_real.nombre}";')
+
+        # --- CLAVES FORÁNEAS ---
+        reales_fk_set = {
+            (fk.columna, fk.referencia_tabla, fk.referencia_columna): fk
+            for fk in self.obtener_fks_postgres(conexion, dbname)
+        }
+        definidos_fk_set = {
+            (fk.columna, fk.referencia_tabla, fk.referencia_columna): fk
+            for fk in self.foreign_keys
+        }
+
+        for clave, fk_def in definidos_fk_set.items():
+            if clave not in reales_fk_set:
+                fk_adds.append(f"ADD {fk_def.to_sql()}")
+
+        if permitir_drop:
+            for clave, fk_real in reales_fk_set.items():
+                if clave not in definidos_fk_set:
+                    fk_drops.append(f'DROP CONSTRAINT "{fk_real.nombre}"')
+
+        # Orden seguro: columnas -> drop FK -> drop índices -> add índices -> add FK
+        # (los índices son sentencias independientes en Postgres, no cláusulas de ALTER TABLE)
+        resultado = []
+        if col_alteraciones:
+            resultado.append(f'ALTER TABLE "{self.nombre}"\n  ' + ",\n  ".join(col_alteraciones) + ";")
+        if fk_drops:
+            resultado.append(f'ALTER TABLE "{self.nombre}"\n  ' + ",\n  ".join(fk_drops) + ";")
+        resultado.extend(idx_drops)
+        resultado.extend(idx_adds)
+        if fk_adds:
+            resultado.append(f'ALTER TABLE "{self.nombre}"\n  ' + ",\n  ".join(fk_adds) + ";")
+        return resultado
+
+    def extraer_estructura(self, db_name: str) -> list[tuple[str, str, str, str | None, str]]:
+        """
+        Devuelve la estructura de la tabla, según definiciones, como una lista de tuplas:
+        (db_name, tabla, tipo, nombre, definicion)
+        """
+        est = [(db_name, self.nombre, 'tabla', None, self.to_sql())]
+
+        for col in self.columnas:
+            est.append((db_name, self.nombre, 'columna', col.nombre, col.to_sql()))
+
+        for idx in self.indices:
+            est.append((db_name, self.nombre, 'indice', idx.nombre, idx.to_sql()))
+
+        for fk in self.foreign_keys:
+            est.append((db_name, self.nombre, 'fk', fk.nombre, fk.to_sql()))
+
+        return est
+
+
+class Database:
+    def __init__(self, host: str, user: str, password: str, db: str, port: int = 5432, logger: Optional[logging.Logger] = None):
+        """clase Database que:
+        Almacena los parámetros de conexión.
+        Mantiene una lista (o diccionario) de objetos Tabla.
+        Genere una única conexión compartida (con psycopg.connect()).
+        Permita añadir tablas y reutilizar esa conexión para leer o sincronizar.
+        Args:
+            - `host`:       Host de la base de datos.
+            - `user`:       Usuario de la base de datos.
+            - `password`:   Contraseña del usuario.
+            - `db`:         Nombre de la base de datos.
+            - `port`      (int): Puerto de conexión (default 5432).
+            - `logger`:     (opcional) Instancia de logger para registrar eventos .
+        """
+        self.host = host
+        self.user = user
+        self.password = password
+        self.db = db
+        self.port = port
+        self.tablas: Dict[str, Tabla] = {}
+        self._conexion = None  # connection
+        self.logger = logger  # logger
+        self.ultimo_insert_id: Optional[int] = None
+
+    @contextmanager
+    def transaccion(self):
+        """
+        Context manager para ejecutar múltiples operaciones dentro de una transacción (modo síncrono).
+        """
+        conn = self._conexion
+        try:
+            yield conn
+            conn.commit()
+        except Exception as e:
+            conn.rollback()
+            raise e
+
+    def conectar(self, autocommit=False):
+        """
+        Abre una única conexión reutilizable.
+        Args:
+            - `autocommit`: Si se debe activar el autocommit (por defecto False, las transacciones se controlan manualmente).
+        returns:
+            - `conexion`: Conexión psycopg abierta.
+        """
+        if self._conexion is None or self._conexion.closed:
+            self._conexion = psycopg.connect(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                dbname=self.db,
+                port=self.port,
+                autocommit=autocommit,
+            )
+        return self._conexion
+
+    def cerrar(self):
+        """cierra la conexión si está abierta. No interviene en la transacción activa."""
+        if self._conexion and not self._conexion.closed:
+            self._conexion.close()
+
+    def commit(self):
+        """
+        Confirma la transacción activa si existe y cierra la conexión.
+        Si no hay conexión abierta o está en autocommit, no hace nada salvo cerrar.
+        """
+        if self._conexion and not self._conexion.closed:
+            if not self._conexion.autocommit:
+                try:
+                    self._conexion.commit()
+                except Exception as e:
+                    raise RuntimeError(f"Error al hacer commit: {e}") from e
+            self.cerrar()
+
+    def rollback(self):
+        """
+        Revierte la transacción activa si existe y cierra la conexión.
+        Si no hay conexión abierta o está en autocommit, no hace nada salvo cerrar.
+        """
+        if self._conexion and not self._conexion.closed:
+            if not self._conexion.autocommit:
+                try:
+                    self._conexion.rollback()
+                except Exception as e:
+                    raise RuntimeError(f"Error al hacer rollback: {e}") from e
+            self.cerrar()
+
+    def add_tabla(self, tabla: Tabla):
+        """
+        Añade un objeto Tabla al conjunto de esta base de datos.
+        Args:
+            - `tabla`: Objeto Tabla a añadir.
+        """
+        self.tablas[tabla.nombre] = tabla
+        tabla.set_database(self)  # Establece la referencia a la base de datos
+
+    def get_tabla(self, nombre: str) -> Tabla:
+        """
+        Devuelve la tabla del nombre indicado. Si nombre no existe lanza un KeyError.
+        Args:
+            - `nombre`: Nombre de la tabla a devolver.
+        """
+
+        if nombre not in self.tablas:
+            raise KeyError(f"La tabla '{nombre}' no está registrada en esta base de datos.")
+        return self.tablas[nombre]
+
+    def _query_select(self, sql: str, params=None, conexion=None, uno: bool = False) -> List[Dict]:
+        """
+        Ejecuta una consulta SELECT y devuelve los registros como lista de diccionarios.
+
+        Args:
+            - `sql`         (str): Consulta SQL.
+            - `params`      (tuple or dict, optional): Parámetros para el SQL.
+            - `conexion`    (psycopg.Connection, optional): Conexión externa abierta. Si no se indica, se abre una.
+
+        Returns:
+            List[Dict]: Lista de registros obtenidos.
+        """
+        propia = False
+        if conexion is None:
+            conexion = self.conectar()
+            propia = True
+
+        try:
+            with conexion.cursor(row_factory=dict_row) as cursor:
+                cursor.execute(sql, params)
+                if uno:
+                    return cursor.fetchone()
+                return cursor.fetchall()
+        finally:
+            if propia:
+                self.cerrar()
+
+    def _query_accion(self, sql: str, params=None, conexion=None) -> int:
+        """
+        Ejecuta una acción tipo INSERT, UPDATE, DELETE.
+
+        Postgres no tiene `lastrowid`: si la sentencia incluye una cláusula RETURNING,
+        el primer valor de la primera fila devuelta se guarda en `self.ultimo_insert_id`.
+
+        - Args:
+            - `sql`         - (str): Sentencia SQL.
+            - `params`      - (tuple or dict, optional): Parámetros para la consulta.
+            - `conexion`    - (psycopg.Connection, optional): Conexión externa abierta. Si no se indica, se abre una.
+
+        Returns:
+            int: Número de filas afectadas.
+        """
+        propia = False
+        if conexion is None:
+            conexion = self.conectar()
+            propia = True
+        try:
+            with conexion.cursor() as cursor:
+                cursor.execute(sql, params)
+                filas = cursor.rowcount
+                if cursor.description:
+                    fila = cursor.fetchone()
+                    if fila:
+                        self.ultimo_insert_id = fila[0]
+                if propia:
+                    conexion.commit()
+                return filas
+        except Exception as e:
+            if propia:
+                conexion.rollback()
+            if self.logger:
+                self.logger.error(f"Error al ejecutar acción: {e}")
+            raise
+        finally:
+            if propia:
+                self.cerrar()
+
+    def query(self, sql: str, params=None, conexion=None, uno: bool = False):
+        """
+        Ejecuta automáticamente una consulta SQL detectando si es de lectura (SELECT)
+        o de acción (INSERT, UPDATE, DELETE).
+
+        - Args:
+            - `sql`         - (str): Sentencia SQL.
+            - `params`      - (tuple or dict, optional): Parámetros para la consulta.
+            - `conexion`    - (psycopg.Connection, optional): Conexión externa abierta. Si no se indica, se abre una.
+            - `uno`         - (bool):  Si True, se espera un único resultado (SELECT).
+
+        Returns:
+            Resultado de la operación:
+                - List[Dict] si es SELECT, SHOW, EXPLAIN, etc.
+                - int (nº de filas afectadas) si es INSERT/UPDATE/DELETE
+        """
+        sql_limpia = sql.strip().lstrip("/*- ").upper()
+        comando = sql_limpia.split()[0]
+
+        if comando in {"SELECT", "SHOW", "EXPLAIN"}:
+            return self._query_select(sql, params=params, conexion=conexion, uno=uno)
+        else:
+            return self._query_accion(sql, params=params, conexion=conexion)
+
+    def call_proc(self, nombre: str, parametros: tuple, conexion=None, uno: bool = True) -> Optional[Union[dict, list[dict]]]:
+        """
+        Llama a un procedimiento almacenado y devuelve los resultados si existen.
+
+        - Args:
+            - `nombre` (str): Nombre del procedimiento.
+            - `parametros` (tuple): Parámetros a pasar.
+            - `conexion` (psycopg.Connection, opcional): Conexión externa si se gestiona desde fuera.
+            - `uno` (bool): Si True, devuelve una fila (dict); si False, todas las filas (list[dict]).
+
+        - Returns:
+            dict | list[dict] | None: Resultado del procedimiento si devuelve SELECT. None si no hay resultado.
+        """
+        propia = False
+        if conexion is None:
+            conexion = self.conectar()
+            propia = True
+
+        try:
+            placeholders = ', '.join(['%s'] * len(parametros))
+            sql = f"CALL {nombre}({placeholders})"
+            with conexion.cursor(row_factory=dict_row) as cursor:
+                cursor.execute(sql, parametros)
+                try:
+                    return cursor.fetchone() if uno else cursor.fetchall()
+                except Exception:
+                    return None
+        except Exception as e:
+            if propia:
+                conexion.rollback()
+            if self.logger:
+                self.logger.error(f"Error en call_proc('{nombre}'): {e}")
+            raise
+        finally:
+            if propia:
+                self.cerrar()
+
+
+class ManagerDB(Database):
+    """
+    Extensión de la clase Database que implementa lógica avanzada de verificación,
+    simulación y aplicación de cambios estructurales, comparando contra la tabla 'estructura_actual'.
+    """
+
+    def crear_tablas_si_no_existen(self) -> dict:
+        """
+        Crea las tablas registradas en la base de datos usando CREATE TABLE IF NOT EXISTS,
+        seguido de sus índices y comentarios. No aplica ALTERs.
+
+        Returns:
+            dict: Diccionario con:
+                - clave: nombre de la tabla
+                - valor: lista de sentencias SQL ejecutadas
+        """
+        resultados = {}
+        try:
+            conexion = self.conectar()
+            with conexion.cursor() as cursor:
+                for nombre_tabla, tabla in self.tablas.items():
+                    sentencias = [tabla.to_sql()] + tabla.to_sql_indices() + tabla.to_sql_comentarios()
+                    for sentencia in sentencias:
+                        cursor.execute(sentencia)
+                    resultados[nombre_tabla] = sentencias
+                    if self.logger:
+                        self.logger.info(f"Intento crear \"{nombre_tabla}\".")
+            # Postgres no autocommitea DDL como MariaDB: hay que confirmar explícitamente.
+            conexion.commit()
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error al crear tablas: {e}")
+            raise RuntimeError(f"Error al crear tablas: {e}") from e
+        finally:
+            self.cerrar()
+
+        return resultados
+
+    def simular_cambios(self, permitir_drop=False) -> dict:
+        """
+        Simula los cambios que aplicarían ALTER TABLE o CREATE TABLE (no ejecuta nada).
+        Devuelve un diccionario con las sentencias que se generarían por tabla.
+        """
+        self.tablas = {t.nombre: t for t in self._ordenar_tablas_por_dependencias()}
+        resultados = {}
+        try:
+            conexion = self.conectar()
+            cursor = conexion.cursor()
+
+            for nombre_tabla, tabla in self.tablas.items():
+                cursor.execute(
+                    "SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = %s",
+                    (nombre_tabla,)
+                )
+                existe = cursor.fetchone() is not None
+
+                if not existe:
+                    resultados[nombre_tabla] = [tabla.to_sql()] + tabla.to_sql_indices() + tabla.to_sql_comentarios()
+                else:
+                    alter = tabla.comparar_generar_alter(conexion, permitir_drop=permitir_drop)
+                    resultados[nombre_tabla] = alter if alter else []
+
+        except Exception:
+            resultados["error"] = traceback.format_exc()
+            if self.logger:
+                self.logger.error("Error al simular cambios:\n" + resultados["error"])
+        finally:
+            self.cerrar()
+
+        return resultados
+
+    def aplicar_cambios(self, permitir_drop: bool = True) -> dict:
+        """
+        Aplica todos los cambios estructurales en la base de datos:
+        - Crea tablas que no existen (con CREATE TABLE IF NOT EXISTS + índices + comentarios)
+        - Aplica ALTERs para sincronizar columnas, índices y claves foráneas
+        - Registra cada cambio aplicado en la tabla _migraciones
+
+        Todo dentro de una única transacción. Si ocurre un error, se revierte todo.
+
+        Args:
+            - `permitir_drop` (bool): Si se permiten DROP INDEX y DROP CONSTRAINT (FK).
+
+        Returns:
+            dict: Resultados por tabla (sentencias ejecutadas o errores).
+        """
+        self.tablas = {t.nombre: t for t in self._ordenar_tablas_por_dependencias()}
+        resultados = {}
+        try:
+            conexion = self.conectar(autocommit=False)
+            with conexion.cursor() as cursor:
+                # Asegurar existencia de la tabla _migraciones
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS _migraciones (
+                        id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+                        tabla VARCHAR(100),
+                        sentencia TEXT,
+                        fecha TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+                # --- Crear tablas nuevas (+ índices + comentarios) ---
+                for nombre_tabla, tabla in self.tablas.items():
+                    sentencias_creacion = [tabla.to_sql()] + tabla.to_sql_indices() + tabla.to_sql_comentarios()
+                    resultados[nombre_tabla] = []
+                    for sql_creacion in sentencias_creacion:
+                        cursor.execute(sql_creacion)
+                        self._registrar_migracion(conexion, nombre_tabla, sql_creacion)
+                        resultados[nombre_tabla].append(sql_creacion)
+                    if self.logger:
+                        self.logger.info(f"Tabla \"{nombre_tabla}\": ejecutado CREATE IF NOT EXISTS.")
+
+                # --- Aplicar ALTERs ---
+                for nombre_tabla, tabla in self.tablas.items():
+                    alter_sqls = tabla.comparar_generar_alter(conexion, permitir_drop=permitir_drop)
+                    for alter_sql in alter_sqls:
+                        cursor.execute(alter_sql)
+                        self._registrar_migracion(conexion, nombre_tabla, alter_sql)
+                        resultados[nombre_tabla].append(alter_sql)
+                        if self.logger:
+                            self.logger.info(f"Tabla \"{nombre_tabla}\": ejecutado -> {alter_sql}")
+
+            conexion.commit()
+            if self.logger:
+                self.logger.info("Todos los cambios aplicados y confirmados.")
+
+        except Exception:
+            self.rollback()
+            resultados["error"] = traceback.format_exc()
+            if self.logger:
+                self.logger.error("Error durante aplicar_cambios():\n" + resultados["error"])
+        finally:
+            self.cerrar()
+
+        return resultados
+
+    def _registrar_migracion(self, conexion, tabla: str, sentencia: str):
+        """
+        Registra una sentencia estructural (CREATE, ALTER, CREATE INDEX, COMMENT...) aplicada
+        a una tabla en el historial de migraciones.
+
+        Crea automáticamente la tabla `_migraciones` si no existe. Antes de registrar, verifica que la sentencia
+        no haya sido previamente aplicada para evitar duplicados. Se utiliza una combinación de `tabla + sentencia`
+        como criterio de unicidad.
+
+        Este método está pensado para ser llamado automáticamente desde `aplicar_cambios()` tras ejecutar cada cambio.
+
+        Args:
+            - `conexion`    (psycopg.Connection): Conexión activa a la base de datos.
+            - `tabla`       (str): Nombre de la tabla afectada por la sentencia.
+            - `sentencia`   (str): Sentencia SQL completa que ha sido ejecutada.
+        """
+        with conexion.cursor() as cursor:
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS _migraciones (
+                    id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+                    tabla VARCHAR(100),
+                    sentencia TEXT,
+                    fecha TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            cursor.execute("""
+                SELECT 1 FROM _migraciones
+                WHERE tabla = %s AND sentencia = %s
+            """, (tabla, sentencia))
+            if not cursor.fetchone():
+                cursor.execute("""
+                    INSERT INTO _migraciones (tabla, sentencia)
+                    VALUES (%s, %s)
+                """, (tabla, sentencia))
+
+    def verificar_contra_estructura_actual(self) -> dict[str, list[str]]:
+        """
+        Compara la estructura definida en los modelos locales con la registrada previamente
+        en la tabla 'estructura_actual'.
+
+        Returns:
+            dict[str, list[str]]: Diccionario con diferencias detectadas, agrupadas por tabla.
+        """
+        divergencias: dict[str, list[str]] = {}
+        conn = self.conectar()
+
+        try:
+            with conn.cursor(row_factory=dict_row) as cur:
+                for tabla in self.tablas.values():
+                    cur.execute("""
+                        SELECT tipo, nombre, definicion FROM estructura_actual
+                        WHERE db_name = %s AND tabla = %s
+                    """, (self.db, tabla.nombre))
+                    registros_previos = cur.fetchall()
+
+                    prev_dict = {
+                        (r['tipo'], r['nombre']): r['definicion'].strip() if r['definicion'] else ""
+                        for r in registros_previos
+                    }
+
+                    actual_dict = {('tabla', None): tabla.to_sql().strip()}
+
+                    for col in tabla.columnas:
+                        actual_dict[('columna', col.nombre)] = col.to_sql().strip()
+
+                    for idx in tabla.indices:
+                        nombre_idx = idx.nombre or "_".join(idx.columnas)
+                        actual_dict[('indice', nombre_idx)] = idx.to_sql().strip()
+
+                    for fk in tabla.foreign_keys:
+                        nombre_fk = fk.nombre or f"fk_{tabla.nombre}_{fk.columna}"
+                        actual_dict[('fk', nombre_fk)] = fk.to_sql().strip()
+
+                    for clave, nueva_def in actual_dict.items():
+                        antigua_def = prev_dict.get(clave)
+                        if antigua_def is not None and nueva_def != antigua_def:
+                            tipo, nombre = clave
+                            nombre_txt = f"'{nombre}'" if nombre else "(sin nombre)"
+                            divergencias.setdefault(tabla.nombre, []).append(
+                                f"Cambio en {tipo} {nombre_txt}:\n  - Antes: {antigua_def}\n  - Ahora:  {nueva_def}"
+                            )
+
+                    for clave in prev_dict:
+                        if clave not in actual_dict:
+                            tipo, nombre = clave
+                            if tipo == "columna":
+                                continue
+                            if tipo == "tabla" and nombre is None:
+                                continue
+                            nombre_txt = f"'{nombre}'" if nombre else "(sin nombre)"
+                            divergencias.setdefault(tabla.nombre, []).append(
+                                f"{tipo.capitalize()} {nombre_txt} eliminado respecto a estructura registrada."
+                            )
+
+                    for clave in actual_dict:
+                        if clave not in prev_dict:
+                            tipo, nombre = clave
+                            nombre_txt = f"'{nombre}'" if nombre else "(sin nombre)"
+                            divergencias.setdefault(tabla.nombre, []).append(
+                                f"{tipo.capitalize()} {nombre_txt} añadido."
+                            )
+        finally:
+            self.cerrar()
+
+        return divergencias
+
+    def _ordenar_tablas_por_dependencias(self) -> List[Tabla]:
+        """
+        Ordena las tablas internas considerando las claves foráneas (dependencias).
+
+        Returns:
+            List[Tabla]: Lista ordenada por orden de creación seguro.
+        """
+        tablas = {t.nombre: t for t in self.tablas.values()}
+        dependencias = {
+            t.nombre: [
+                fk.referencia_tabla
+                for fk in t.foreign_keys
+                if fk.referencia_tabla != t.nombre
+            ]
+            for t in self.tablas.values()
+        }
+        ordenadas = []
+        visitadas = set()
+        en_curso = set()
+
+        def visitar(nombre):
+            if nombre in visitadas:
+                return
+            if nombre in en_curso:
+                raise RuntimeError(f"Ciclo de dependencias detectado al visitar la tabla '{nombre}'.")
+
+            en_curso.add(nombre)
+            for dep in dependencias.get(nombre, []):
+                visitar(dep)
+            en_curso.remove(nombre)
+
+            visitadas.add(nombre)
+            ordenadas.append(tablas[nombre])
+
+        for nombre in tablas:
+            visitar(nombre)
+
+        return ordenadas
+
+    def simular_cambios_avanzado(self) -> dict[str, dict[str, list[str]]]:
+        """
+        Simula diferencias entre los modelos y:
+        - La estructura real actual de la base de datos.
+        - La estructura registrada en estructura_actual, si existe.
+
+        Si la tabla estructura_actual no existe o está vacía, se asume primera ejecución
+        y solo se compara contra la base de datos real.
+
+        Returns:
+            dict: Contiene claves:
+                - 'comparacion_bd': Diferencias con la base de datos real.
+                - 'comparacion_estructura_actual': Diferencias con la estructura registrada (si aplica).
+        """
+        print("Comparando estructura de modelos con base de datos real...")
+        diferencias_bd = self.simular_cambios(permitir_drop=True)
+
+        conn = self.conectar()
+        usar_estructura_actual = False
+
+        try:
+            with conn.cursor(row_factory=dict_row) as cur:
+                cur.execute("""
+                    SELECT COUNT(*) AS total FROM information_schema.tables
+                    WHERE table_schema = 'public' AND table_name = 'estructura_actual'
+                """)
+                existe = cur.fetchone()
+                if existe and existe.get("total", 0) > 0:
+                    cur.execute("SELECT COUNT(*) AS filas FROM estructura_actual WHERE db_name = %s", (self.db,))
+                    filas = cur.fetchone()
+                    if filas and filas.get("filas", 0) > 0:
+                        usar_estructura_actual = True
+        finally:
+            self.cerrar()
+
+        if usar_estructura_actual:
+            print("Comparando estructura de modelos con estructura_actual registrada...")
+            diferencias_guardadas = self.verificar_contra_estructura_actual()
+        else:
+            print("Tabla 'estructura_actual' no existe o está vacía. Se asume primera ejecución.")
+            diferencias_guardadas = {}
+
+        return {
+            "comparacion_bd": diferencias_bd,
+            "comparacion_estructura_actual": diferencias_guardadas
+        }
+
+    def _aplicar_cambios_respecto_a_estructura_actual(self, permitir_drop: bool = False) -> dict[str, list[str]]:
+        """
+        Implementación interna que compara los modelos contra la estructura registrada en estructura_actual.
+        Aplica CREATE TABLE (+ índices + comentarios) o ALTER según sea necesario. Nunca elimina columnas.
+
+        Args:
+            permitir_drop (bool): Permite eliminar índices y claves foráneas. No afecta a columnas.
+
+        Returns:
+            dict[str, list[str]]: Acciones aplicadas agrupadas por tabla.
+        """
+        resultado: dict[str, list[str]] = {}
+        conn = self.conectar(autocommit=False)
+
+        try:
+            with conn.cursor(row_factory=dict_row) as cur:
+                for tabla in self.tablas.values():
+                    cur.execute("""
+                        SELECT tipo, nombre, definicion FROM estructura_actual
+                        WHERE db_name = %s AND tabla = %s
+                    """, (self.db, tabla.nombre))
+                    registros_previos = cur.fetchall()
+                    prev_dict = {(r["tipo"], r["nombre"]): (r["definicion"].strip() if r["definicion"] else "") for r in registros_previos}
+
+                    actual_dict = {('tabla', None): tabla.to_sql().strip()}
+
+                    for col in tabla.columnas:
+                        actual_dict[('columna', col.nombre)] = col.to_sql().strip()
+
+                    for idx in tabla.indices:
+                        nombre_idx = idx.nombre or "_".join(idx.columnas)
+                        actual_dict[('indice', nombre_idx)] = idx.to_sql().strip()
+
+                    for fk in tabla.foreign_keys:
+                        nombre_fk = fk.nombre or f"fk_{tabla.nombre}_{fk.columna}"
+                        actual_dict[('fk', nombre_fk)] = fk.to_sql().strip()
+
+                    cur.execute("""
+                        SELECT COUNT(*) AS total FROM information_schema.tables
+                        WHERE table_schema = 'public' AND table_name = %s
+                    """, (tabla.nombre,))
+                    existe_bd = cur.fetchone()
+
+                    if not existe_bd or existe_bd.get("total", 0) == 0:
+                        sentencias = [tabla.to_sql()] + tabla.to_sql_indices() + tabla.to_sql_comentarios()
+                        for sentencia in sentencias:
+                            cur.execute(sentencia)
+                        resultado[tabla.nombre] = sentencias
+                    else:
+                        alter_sqls = tabla.comparar_generar_alter(conn, permitir_drop=permitir_drop)
+                        for alter_sql in alter_sqls:
+                            cur.execute(alter_sql)
+                            resultado.setdefault(tabla.nombre, []).append(alter_sql)
+
+            conn.commit()
+            self.guardar_estructura_actual(conn)
+
+        except Exception as e:
+            conn.rollback()
+            raise RuntimeError(f"Error aplicando cambios en '{self.db}': {e}") from e
+
+        finally:
+            self.cerrar()
+
+        return resultado
+
+    def aplicar_cambios_respecto_a_estructura_actual(self, permitir_drop: bool = False) -> dict[str, list[str]]:
+        """
+        Aplica cambios estructurales comparando los modelos con la estructura registrada en 'estructura_actual'.
+        Si la tabla no existe o está vacía, se considera primera ejecución y se aplican los cambios comparando contra
+        la base de datos real, generando después la tabla estructura_actual.
+
+        Args:
+            permitir_drop (bool): Permite eliminar índices o claves foráneas si ya no existen en los modelos.
+                                Nunca se eliminan columnas.
+
+        Returns:
+            dict[str, list[str]]: Acciones realizadas, agrupadas por tabla.
+        """
+        self.tablas = {t.nombre: t for t in self._ordenar_tablas_por_dependencias()}
+        conn = self.conectar()
+        usar_estructura_actual = False
+
+        try:
+            with conn.cursor(row_factory=dict_row) as cur:
+                cur.execute("""
+                    SELECT COUNT(*) AS total FROM information_schema.tables
+                    WHERE table_schema = 'public' AND table_name = 'estructura_actual'
+                """)
+                existe = cur.fetchone()
+                if existe and existe.get("total", 0) > 0:
+                    cur.execute("SELECT COUNT(*) AS filas FROM estructura_actual WHERE db_name = %s", (self.db,))
+                    filas = cur.fetchone()
+                    if filas and filas.get("filas", 0) > 0:
+                        usar_estructura_actual = True
+        finally:
+            self.cerrar()
+
+        if not usar_estructura_actual:
+            print("No hay estructura registrada. Se considera primera ejecución.")
+            resultado = self.aplicar_cambios(permitir_drop=permitir_drop)
+            conn = self.conectar()
+            self.guardar_estructura_actual(conn)
+            self.cerrar()
+            return resultado
+
+        print("Aplicando cambios comparando contra estructura_actual registrada...")
+        return self._aplicar_cambios_respecto_a_estructura_actual(permitir_drop)
+
+    def crear_tabla_estructura_si_no_existe(self, conn):
+        """
+        Crea la tabla estructura_actual si no existe.
+        """
+        sql = """
+        CREATE TABLE IF NOT EXISTS estructura_actual (
+            id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            db_name VARCHAR(100) NOT NULL,
+            tabla VARCHAR(100) NOT NULL,
+            tipo VARCHAR(20) NOT NULL CHECK (tipo IN ('tabla', 'columna', 'indice', 'fk')),
+            nombre VARCHAR(100),
+            definicion TEXT NOT NULL,
+            fecha_actualizacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (db_name, tabla, tipo, nombre)
+        )
+        """
+        with conn.cursor() as cur:
+            cur.execute(sql)
+        conn.commit()
+
+    def guardar_estructura_actual(self, conn):
+        """
+        Guarda en la tabla 'estructura_actual' la estructura actual de los modelos
+        tras aplicar cambios correctamente. Borra primero los datos anteriores por tabla.
+
+        - Args:
+            - conn (psycopg.Connection): Conexión activa a la base de datos.
+        """
+        try:
+            self.crear_tabla_estructura_si_no_existe(conn)
+
+            with conn.cursor() as cur:
+                for tabla in self.tablas.values():
+                    cur.execute(
+                        "DELETE FROM estructura_actual WHERE db_name=%s AND tabla=%s",
+                        (self.db, tabla.nombre)
+                    )
+                    for fila in tabla.extraer_estructura(self.db):
+                        # Solo se permiten tipos válidos, evitamos errores como ('nombre', None) o cabeceras mal insertadas
+                        if fila[2] not in {'tabla', 'columna', 'indice', 'fk'}:
+                            if self.logger:
+                                self.logger.warning(f"[IGNORADO] Tipo inválido '{fila[2]}' detectado en tabla '{tabla.nombre}': {fila}")
+                            continue
+
+                        cur.execute("""
+                            INSERT INTO estructura_actual (db_name, tabla, tipo, nombre, definicion)
+                            VALUES (%s, %s, %s, %s, %s)
+                        """, fila)
+
+            conn.commit()
+
+        except Exception as e:
+            conn.rollback()
+            raise RuntimeError(f"Error guardando estructura actual para {self.db}: {e}") from e
+
+    def insertar_registros_iniciales(self):
+        """
+        Inserta automáticamente los registros definidos en `tabla.registros_iniciales`
+        para cada tabla sincronizada, si aún no existen.
+
+        Los registros iniciales siempre deben incluir el campo `id` y se asume que es la clave primaria.
+        Cada registro se inserta en su propia sub-transacción (savepoint): si uno falla, no arrastra
+        al resto (en Postgres, a diferencia de MariaDB, un error dentro de una transacción la deja
+        abortada hasta el siguiente rollback).
+        """
+        conn = self.conectar()
+
+        for tabla in self.tablas.values():
+            if not tabla.registros_iniciales:
+                continue
+
+            for registro in tabla.registros_iniciales:
+                if "id" not in registro:
+                    print(f"Registro sin campo 'id' en tabla '{tabla.nombre}', se omite.")
+                    continue
+
+                try:
+                    with conn.transaction():
+                        with conn.cursor() as cursor:
+                            sql_check = f'SELECT 1 FROM "{tabla.nombre}" WHERE "id" = %s LIMIT 1'
+                            cursor.execute(sql_check, (registro["id"],))
+
+                            if not cursor.fetchone():
+                                columnas = ", ".join(f'"{k}"' for k in registro)
+                                placeholders = ", ".join(["%s"] * len(registro))
+                                valores_insert = tuple(registro.values())
+                                sql_insert = f'INSERT INTO "{tabla.nombre}" ({columnas}) VALUES ({placeholders})'
+                                cursor.execute(sql_insert, valores_insert)
+                except Exception as e:
+                    print(f"Error insertando en '{tabla.nombre}': {e}")
+
+        self.cerrar()
+
+    def crear_vistas(self):
+        """
+        Crea o reemplaza las vistas definidas en cada tabla usando `CREATE OR REPLACE VIEW`.
+        Las vistas se recrean siempre, sin comparar con el estado previo.
+
+        Se asume que las vistas están correctamente definidas en el atributo `tabla.vistas`.
+        El orden se resuelve automáticamente si una vista depende de otra.
+        """
+
+        conn = self.conectar()
+        cursor = conn.cursor()
+
+        # Reunir todas las vistas como {nombre: SQL}
+        vistas_dict: Dict[str, str] = {}
+        for tabla in self.tablas.values():
+            if tabla.vistas:
+                for vista_sql in tabla.vistas:
+                    if not vista_sql.strip().lower().startswith("create"):
+                        print(f"Vista en tabla '{tabla.nombre}' no comienza por 'CREATE':\n{vista_sql.strip().splitlines()[0]}")
+                        continue
+                    nombre_vista = self._extraer_nombre_vista(vista_sql)
+                    if nombre_vista:
+                        vistas_dict[nombre_vista] = vista_sql
+
+        if not vistas_dict:
+            print("No se encontraron vistas para crear.")
+            return
+
+        # Ordenar por dependencias entre vistas
+        dependencias = {}
+        for nombre, sql in vistas_dict.items():
+            sql_lower = sql.lower()
+            deps = []
+            for otro in vistas_dict:
+                if otro == nombre:
+                    continue
+                # Patrón flexible: busca vista entre espacios, comillas dobles/simples o delimitadores SQL
+                patron = rf"""[\s"'(,]({re.escape(otro.lower())})[\s"'.,)]"""
+                if re.search(patron, sql_lower):
+                    deps.append(otro)
+            dependencias[nombre] = set(deps)
+
+        ordenadas = []
+        visitadas = set()
+
+        def visitar(v):
+            if v in visitadas:
+                return
+            for dep in dependencias.get(v, []):
+                visitar(dep)
+            visitadas.add(v)
+            ordenadas.append(v)
+
+        for vista in vistas_dict:
+            visitar(vista)
+
+        print(f"Se van a crear {len(ordenadas)} vistas: {', '.join(ordenadas)}")
+
+        for nombre in ordenadas:
+            sql = vistas_dict[nombre]
+            try:
+                cursor.execute(sql)
+                print(f"Vista creada: {nombre}")
+                if self.logger:
+                    self.logger.info(f"[Vista] Ejecutada: {nombre}")
+            except Exception as e:
+                print(f"Error al crear vista '{nombre}': {e}")
+                print("\nSQL con error:\n" + sql + "\n")
+                if self.logger:
+                    self.logger.error(f"Error al crear vista '{nombre}': {e}")
+                raise RuntimeError(f"Error al crear vista '{nombre}': {e}") from e
+
+        conn.commit()
+        self.cerrar()
+
+    def crear_triggers(self) -> list[str]:
+        """
+        Crea o reemplaza los triggers definidos en las tablas asociadas.
+        Cada sentencia se ejecuta en su propia sub-transacción (savepoint) para que un
+        trigger con error no invalide la conexión para el resto.
+        """
+        resultado = []
+        conexion = self.conectar()
+        for tabla in self.tablas.values():
+            if tabla.triggers:
+                for trigger_sql in tabla.triggers:
+                    try:
+                        with conexion.transaction():
+                            with conexion.cursor() as cur:
+                                cur.execute(trigger_sql)
+                        resultado.append(f"Trigger creado o reemplazado en {tabla.nombre}")
+                    except Exception as e:
+                        resultado.append(f"Error creando trigger en {tabla.nombre}: {e}")
+        self.cerrar()
+        return resultado
+
+    def crear_procedimientos(self) -> list[str]:
+        """
+        Crea o reemplaza los procedimientos almacenados definidos en las tablas asociadas.
+        Cada sentencia se ejecuta en su propia sub-transacción (savepoint) para que un
+        procedimiento con error no invalide la conexión para el resto.
+        """
+        resultado = []
+        conexion = self.conectar()
+        for tabla in self.tablas.values():
+            if tabla.procedimientos:
+                for proc_sql in tabla.procedimientos:
+                    try:
+                        with conexion.transaction():
+                            with conexion.cursor() as cur:
+                                cur.execute(proc_sql)
+                        resultado.append(f"Procedimiento creado o reemplazado en {tabla.nombre}")
+                    except Exception as e:
+                        resultado.append(f"Error creando procedimiento en {tabla.nombre}: {e}")
+        self.cerrar()
+        return resultado
+
+    def _extraer_nombre_vista(self, sql: str) -> Optional[str]:
+        """
+        Extrae el nombre de la vista desde una sentencia CREATE VIEW.
+        Admite CREATE OR REPLACE VIEW "nombre" AS ... (o sin comillas).
+        """
+        match = re.search(r'CREATE\s+(OR\s+REPLACE\s+)?VIEW\s+"?(\w+)"?', sql, re.IGNORECASE)
+        return match.group(2) if match else None
+
+    def crear_todo(self, permitir_drop: bool = True):
+        """
+        Ejecuta todo el ciclo de sincronización completo:
+        - Aplica cambios estructurales respecto a estructura_actual (creación/modificación de tablas)
+        - Inserta registros iniciales
+        - Crea o reemplaza las vistas
+
+        Args:
+            permitir_drop (bool): Permite eliminar claves foráneas e índices si ya no existen en los modelos.
+        """
+        print(f"Aplicando cambios estructurales en '{self.db}'...")
+        resultado = self.aplicar_cambios_respecto_a_estructura_actual(permitir_drop=permitir_drop)
+        print(f"Insertando registros iniciales en '{self.db}'...")
+        self.insertar_registros_iniciales()
+        print(f"Creando vistas en '{self.db}'...")
+        self.crear_vistas()
+        resultado_tg = self.crear_triggers()
+        for linea in resultado_tg:
+            print(linea)
+        resultado_pr = self.crear_procedimientos()
+        for linea in resultado_pr:
+            print(linea)
+        return resultado