tai-sql 0.1.1__py3-none-any.whl

tai_sql/__init__.py

@@ -0,0 +1,26 @@
+"""
+Declarative models for SQLAlchemy.
+This module provides the base classes and utilities to define
+models using SQLAlchemy's declarative system.
+"""
+from __future__ import annotations
+
+# Importar la instancia global
+from .manager import db
+from .core import datasource, generate, env, connection_string, params
+from .orm import Table, column, relation
+from sqlalchemy.types import BigInteger as bigint
+
+# Exportar los elementos principales
+__all__ = [
+    'db',
+    'datasource', 
+    'generate',
+    'env',
+    'connection_string',
+    'params',
+    'Table',
+    'column',
+    'relation',
+    'bigint'
+]

tai_sql/cli/commands/createdb.py

@@ -0,0 +1,123 @@
+import os
+import click
+from sqlalchemy import text, create_engine, URL
+from sqlalchemy.exc import OperationalError, ProgrammingError
+
+from tai_sql import db
+from .utils.schema import Schema
+
+class DBCommand(Schema):
+    """
+    Command to create a new database.
+    """
+
+    def exists(self) -> bool:
+        """
+        Verifica si existe la base de datos especificada en la configuración.
+        
+        Returns:
+            bool: True si la base de datos existe, False en caso contrario
+        """
+        try:
+            # Obtener la URL de conexión del engine
+            
+            click.echo(f"🔍 Verificando existencia de la base de datos: {db.provider.database}")
+            
+            with db.engine.connect() as conn:
+                if db.provider.drivername == "postgresql":
+                    # PostgreSQL
+                    result = conn.execute(text(
+                        "SELECT 1 FROM pg_database WHERE datname = :db_name"
+                    ), {"db_name": db.provider.database})
+                    
+                elif db.provider.drivername == "mysql":
+                    # MySQL/MariaDB
+                    result = conn.execute(text(
+                        "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = :db_name"
+                    ), {"db_name": db.provider.database})
+                    
+                elif db.provider.drivername == "sqlite":
+                    # SQLite - verificar si el archivo existe
+                    db_file = db.provider.database
+                    exists = os.path.exists(db_file)
+                    return exists
+                    
+                else:
+                    click.echo(f"❌ Tipo de base de datos no implementado: {db.provider.drivername}", err=True)
+                    return False
+                
+                exists = result.fetchone() is not None
+                return exists
+                
+        except (OperationalError, ProgrammingError) as e:
+            click.echo(f"❌ La base de datos no existe", err=True)
+            return False
+        except Exception as e:
+            click.echo(f"❌ Error inesperado: {e}", err=True)
+            return False
+    
+    def create(self) -> bool:
+        """
+        Crea la base de datos especificada en la configuración.
+        
+        Returns:
+            bool: True si la base de datos se creó exitosamente o ya existía, False en caso contrario
+        """
+        try:
+            # Verificar si ya existe
+            if self.exists():
+                click.echo("ℹ️  La base de datos ya existe")
+                return True
+            
+            click.echo(f"🚀 Creando base de datos: {db.provider.database}")
+            
+            if db.provider.drivername == "sqlite":
+                # SQLite - crear archivo de base de datos vacío
+                db_file = db.provider.database
+        
+                # Crear directorios padre si no existen
+                os.makedirs(os.path.dirname(db_file) if os.path.dirname(db_file) else '.', exist_ok=True)
+
+                with db.engine.connect() as conn:
+                    pass  # La conexión crea el archivo
+                
+                click.echo(f"✅ Base de datos SQLite creada: {db_file}")
+                return True
+            
+            engine = create_engine(
+                URL.create(
+                    drivername=db.provider.drivername,
+                    username=db.provider.username,
+                    password=db.provider.password,
+                    host=db.provider.host,
+                    port=db.provider.port
+                )
+            )
+            
+            with engine.connect() as conn:
+                if db.provider.drivername == 'postgresql':
+                    # PostgreSQL requires autocommit mode for CREATE DATABASE
+                    conn = conn.execution_options(autocommit=True)
+                    conn.execute(text("COMMIT"))
+                    conn.execute(text(f'CREATE DATABASE "{db.provider.database}"'))
+                elif db.provider.drivername == 'mysql':
+                    # MySQL can use regular transaction mode
+                    conn = conn.execution_options(autocommit=True)
+                    conn.execute(text(f'CREATE DATABASE "{db.provider.database}"'))
+                    
+                else:
+                    click.echo(f"❌ Tipo de base de datos no soportado: {db.provider.drivername}", err=True)
+                    return False
+            
+            click.echo(f"✅ Base de datos {db.provider.database} creada exitosamente")
+            
+            # Verificar que se creó correctamente
+            return self.exists()
+            
+        except (OperationalError, ProgrammingError) as e:
+            click.echo(f"❌ Error al crear la base de datos: {e}", err=True)
+            return False
+        except Exception as e:
+            click.echo(f"❌ Error inesperado: {e}", err=True)
+            return False
+        

tai_sql/cli/commands/generate.py

@@ -0,0 +1,26 @@
+import click
+
+from tai_sql import db
+
+from .utils.schema import Schema
+
+class GenerateCommand(Schema):
+
+    def run_generators(self):
+        """Run the configured generators."""
+        # Ejecutar cada generador
+        for generator in db.generators:
+            try:
+                generator_name = generator.__class__.__name__
+                click.echo(f"Ejecutando generador: {generator_name}")
+                
+                # El generador se encargará de descubrir los modelos internamente
+                result = generator.generate()
+                
+                click.echo(f"✅ Generador {generator_name} completado con éxito.")
+                if result:
+                    click.echo(f"   Resultado: {result}")
+            except Exception as e:
+                import logging
+                logging.exception(e)
+                click.echo(f"❌ Error al ejecutar el generador {generator_name}: {str(e)}", err=True)

tai_sql/cli/commands/init.py

@@ -0,0 +1,185 @@
+import subprocess
+import sys
+import os
+from pathlib import Path
+import click
+
+# ...existing code...
+
+class NewSchemaCommand:
+
+    def __init__(self, namespace: str, schema_name: str):
+        self.namespace = namespace
+        self.schema_name = schema_name
+
+    @property
+    def subnamespace(self) -> str:
+        """Retorna el subnamespace basado en el namespace"""
+        return self.namespace.replace('-', '_')
+    
+    def exists(self) -> bool:
+        """Verifica si el esquema ya existe"""
+        schemas_dir = Path(self.namespace) / 'schemas'
+        return (schemas_dir / f'{self.schema_name}.py').exists()
+    
+    def create(self):
+        """Crea el esquema con la estructura básica"""
+        click.echo(f"🚀 Creando esquema '{self.schema_name}' en '{self.namespace}/schemas'...")
+
+        if self.exists():
+            click.echo(f"❌ Error: El esquema '{self.schema_name}' ya existe en '{self.namespace}/schemas'.", err=True)
+            sys.exit(1)
+        
+        # Crear directorio para el esquema
+        schemas_dir = Path(self.namespace) / 'schemas'
+        schemas_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Crear main.py con el contenido exacto del ejemplo
+        content = self.get_content()
+        (schemas_dir / f'{self.schema_name}.py').write_text(content, encoding='utf-8')
+        
+        click.echo(f"   ✅ '{self.schema_name}.py' creado en '{self.namespace}/schemas/'")
+    
+    def get_content(self) -> str:
+        """Retorna el contenido exacto del archivo main.py de ejemplo"""
+        return f'''# -*- coding: utf-8 -*-
+"""
+Fuente principal para la definición de esquemas y generación de modelos CRUD.
+Usa el contenido de tai_sql para definir tablas, relaciones y generar automáticamente modelos y CRUDs.
+Usa tai_sql.generators para generar modelos y CRUDs basados en las tablas definidas.
+Ejecuta por consola tai_sql generate para generar los recursos definidos en este esquema.
+"""
+from __future__ import annotations
+from typing import List, Optional
+# from datetime import datetime
+from tai_sql import *
+from tai_sql.generators import ModelsGenerator, CRUDGenerator
+
+
+# Configurar el datasource
+datasource(
+    provider=env('{self.schema_name.upper()}_DATABASE_URL') # Además de env, también puedes usar (para testing) connection_string y params
+    # Revisa la documentación de la función datasource para más opciones
+)
+
+# Configurar los generadores
+generate(
+    ModelsGenerator(
+        output_dir='{self.namespace}/{self.subnamespace}/{self.schema_name}/models' # Directorio donde se generarán los modelos
+    ),
+    CRUDGenerator(
+        output_dir='{self.namespace}/{self.subnamespace}/{self.schema_name}/crud', # Directorio donde se generarán los CRUDs
+        models_import_path='{self.subnamespace}.{self.schema_name}.models', # Ruta de importación de los modelos generados
+        mode='sync' # Modo de generación: 'sync' para síncrono, 'async' para asíncrono, 'both' para ambos
+    )
+)
+
+# Definición de tablas y relaciones
+
+# Ejemplo de definición de tablas y relaciones. Eliminar estos modelos y definir los tuyos propios.
+class User(Table):
+    __tablename__ = "user"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    name: str
+    email: Optional[str] # Nullable
+    
+    posts: List[Post] # Relación one-to-many (implícita) con la tabla Post	
+
+class Post(Table):
+    __tablename__ = "post"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    title: str = 'Post Title' # Valor por defecto
+    content: str
+    author_id: int
+    
+    author: User = relation(fields=['author_id'], references=['id'], backref='posts') # Relación many-to-one con la tabla User
+    '''
+
+
+class InitCommand:
+
+    def __init__(self, namespace: str, schema_name: str):
+        self.namespace = namespace
+        self.schema_name = schema_name
+    
+    @property
+    def subnamespace(self) -> str:
+        """Retorna el subnamespace basado en el namespace"""
+        return self.namespace.replace('-', '_')
+    
+    def check_poetry(self):
+        """Verifica que Poetry esté instalado y disponible"""
+        try:
+            subprocess.run(['poetry', '--version'], check=True, capture_output=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            click.echo("❌ Error: Poetry no está instalado o no está en el PATH", err=True)
+            click.echo("Instala Poetry desde: https://python-poetry.org/docs/#installation")
+            sys.exit(1)
+    
+    def check_directory_is_avaliable(self):
+        """Verifica que el directorio del proyecto no exista"""
+        if os.path.exists(self.namespace):
+            click.echo(f"❌ Error: el directorio '{self.namespace}' ya existe", err=True)
+            sys.exit(1)
+    
+    def check_virtualenv(self):
+        """Verifica que el entorno virtual de Poetry esté activo"""
+        if 'VIRTUAL_ENV' not in os.environ:
+            click.echo("❌ Error: No hay entorno virutal activo", err=True)
+            click.echo("   Puedes crear uno con 'pyenv virtualenv <env_name>' y asignarlo con 'pyenv local <env_name>'", err=True)
+            sys.exit(1)
+    
+    def create_project(self):
+        """Crea el proyecto base con Poetry"""
+        click.echo(f"🚀 Creando '{self.namespace}'...")
+        
+        try:
+            subprocess.run(['poetry', 'new', self.namespace], 
+                        check=True, 
+                        capture_output=True)
+            subprocess.run(['poetry', 'install'],
+                        cwd=self.namespace,
+                        check=True, 
+                        capture_output=True)
+            click.echo(f"✅ poetry new '{self.namespace}': OK")
+        except subprocess.CalledProcessError as e:
+            click.echo(f"❌ Error: {e}", err=True)
+            sys.exit(1)
+
+    def add_dependencies(self):
+        """Añade las dependencias necesarias al proyecto"""
+        click.echo("📦 Añadiendo dependencias...")
+        
+        dependencies = ['sqlalchemy', 'psycopg2-binary']
+        
+        for dep in dependencies:
+            try:
+                subprocess.run(['poetry', 'add', dep], 
+                            cwd=self.namespace,
+                            check=True, 
+                            capture_output=True)
+                click.echo(f"   ✅ {dep} añadido")
+            except subprocess.CalledProcessError as e:
+                click.echo(f"   ❌ Error al añadir dependencia {dep}: {e}", err=True)
+                sys.exit(1)
+    
+    def add_schemas_folder(self):
+        """Crea la estructura adicional del proyecto"""
+        new_schema = NewSchemaCommand(self.namespace, self.schema_name)
+        new_schema.create()
+
+    def msg(self):
+        """Muestra el mensaje de éxito y next steps"""
+        click.echo()
+        click.echo(f'🎉 ¡Proyecto "{self.namespace}" creado exitosamente!')
+        click.echo()
+        click.echo("📋 Próximos pasos:")
+        click.echo("   1. Configurar DATABASE_URL en tu entorno:")
+        click.echo("      export DATABASE_URL='postgresql://user:pass@localhost:5432/dbname'")
+        click.echo("   2. Definir tus modelos en schemas/main.py")
+        click.echo("   3. Crear recursos:")
+        click.echo("      tai-sql generate")
+        click.echo()
+        click.echo("🔗 Documentación: https://github.com/tu-repo/tai-sql")

tai_sql/cli/commands/push.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+import sys
+import click
+from dataclasses import dataclass, field
+from typing import List
+from sqlalchemy import MetaData, Column, text, Engine
+from sqlalchemy.schema import Table, UniqueConstraint
+
+from tai_sql import db
+from tai_sql.orm import Table
+from .utils.schema import Schema
+from .utils.ddl import DDLManager, CreateStatement, AlterColumnStatement, ForeignKeyStatement
+
+
+@dataclass
+class DriftManager:
+    """
+    Clase para almacenar los cambios detectados en el esquema
+    """
+    engine: Engine = field(default_factory=lambda: db.engine)
+    metadata: MetaData = field(default_factory=lambda: MetaData(db.schema if db.provider.drivername == 'postgresql' else None))
+    existing_metadata: MetaData = field(default_factory=lambda: MetaData(db.schema if db.provider.drivername == 'postgresql' else None))
+    new_tables: dict[str, list[Table]] = field(default_factory=dict)
+    existing_tables: dict[str, list[Table]] = field(default_factory=dict)
+    columns_to_add: dict[str, list[Column]] = field(default_factory=dict)
+    columns_to_drop: dict[str, list[Column]] = field(default_factory=dict)
+    columns_to_modify: dict[str, list[Column]] = field(default_factory=dict)
+
+    def detect(self) -> None:
+        """
+        Detecta cambios entre el esquema definido y el esquema actual
+        
+        Returns:
+            dict: Diccionario con los cambios detectados
+        """
+        click.echo("🔎 Detectando cambios en el esquema...")
+
+        self.existing_metadata.reflect(bind=self.engine)
+        
+        db_tables = set(self.existing_metadata.tables.keys())
+        schema_tables = set(self.metadata.tables.keys())
+        
+        # Tablas nuevas
+        new_tables = list(schema_tables - db_tables)
+
+        for table_name in new_tables:
+            new_table = self.metadata.tables[table_name]
+            self.new_tables[table_name] = new_table
+        
+        # Tablas existentes
+        existing_tables = list(schema_tables & db_tables)
+
+        # Analizar cambios en columnas para tablas existentes
+        for table_name in existing_tables:
+            current_table = self.existing_metadata.tables[table_name]
+            self.existing_tables[table_name] = current_table
+            new_table = self.metadata.tables[table_name]
+
+            constraint_columns = []
+            # Check constrains
+            for constraint in current_table.constraints:
+                if isinstance(constraint, UniqueConstraint):
+                    constraint_columns = [col.name for col in constraint.columns]
+            
+            current_columns = {col.name: col for col in current_table.columns}
+            new_columns = {col.name: col for col in new_table.columns}
+            
+            # Columnas a añadir
+            columns_to_add = set(new_columns.keys()) - set(current_columns.keys())
+            if columns_to_add:
+                self.columns_to_add[table_name] = [
+                    new_columns[col_name] for col_name in columns_to_add
+                ]
+            
+            # Columnas a eliminar (comentado por seguridad)
+            columns_to_drop = set(current_columns.keys()) - set(new_columns.keys())
+            if columns_to_drop:
+                self.columns_to_drop[table_name] = [
+                    current_columns[col_name] for col_name in columns_to_drop
+                ]
+            
+            # Columnas a modificar
+            for col_name in set(current_columns.keys()) & set(new_columns.keys()):
+                current_col = current_columns[col_name]
+                new_col = new_columns[col_name]
+
+                if str(current_col.type) == 'TIMESTAMP' and str(new_col.type) == 'DATETIME':
+                    # Manejar caso especial de TIMESTAMP vs TIMESTAMP WITH TIME ZONE
+                    type_changed = False
+                else:
+                    # Comparar tipo de dato
+                    type_changed = str(current_col.type) != str(new_col.type)
+
+                # Comparar nullable
+                nullable_changed = current_col.nullable != new_col.nullable
+                
+                # Comparar valor por defecto
+                # default_changed = str(current_col.server_default) != str(new_col.server_default)
+                
+                # Comparar primary key
+                pk_changed = current_col.primary_key != new_col.primary_key
+                
+                # Comparar autoincrement
+                autoincrement_changed = current_col.autoincrement != new_col.autoincrement
+
+                if col_name in constraint_columns:
+                    current_col.unique = True
+
+                # Comparar uniqueness
+                unique_changed = current_col.unique != new_col.unique
+                
+                if type_changed or nullable_changed or pk_changed or autoincrement_changed or unique_changed:
+                    if table_name not in self.columns_to_modify:
+                        self.columns_to_modify[table_name] = []
+                    self.columns_to_modify[table_name].append(new_col)
+
+    def show(self):
+        """Muestra un resumen de los cambios detectados"""
+        click.echo("📋 Resumen de cambios:")
+        
+        if self.new_tables:
+            click.echo(f"   🆕 {len(self.new_tables)} tabla(s) nueva(s): {', '.join(self.new_tables)}")
+        
+        if self.columns_to_add:
+            total_columns = sum(len(cols) for cols in self.columns_to_add.values())
+            click.echo(f"   ➕ {total_columns} columna(s) a añadir en {len(self.columns_to_add)} tabla(s)")
+        
+        if self.columns_to_drop:
+            total_columns = sum(len(cols) for cols in self.columns_to_drop.values())
+            click.echo(f"   ⚠️  {total_columns} columna(s) serían eliminadas")
+        
+        if self.columns_to_modify:
+            total_columns = sum(len(cols) for cols in self.columns_to_modify.values())
+            click.echo(f"   ✏️  {total_columns} columna(s) a modificar en {len(self.columns_to_modify)} tabla(s)")
+        
+        if not self.new_tables and not self.columns_to_add and not self.columns_to_drop and not self.columns_to_modify:
+            click.echo("   ✅ No se detectaron cambios")
+        
+        click.echo()
+
+class PushCommand(Schema):
+    """
+    Comando para generar y ejecutar sentencias DDL CREATE TABLE basadas en un schema.
+    
+    Este comando procesa un archivo de schema, genera las sentencias DDL necesarias
+    para crear las tablas definidas y las ejecuta en la base de datos configurada.
+    """
+
+    def __init__(self, schema_file: str):
+        super().__init__(schema_file)
+        self.schema_file = schema_file
+        self.ddl_manager = DDLManager()
+        self.drift_manager = DriftManager()
+
+    def load_schema(self) -> MetaData:
+        """
+        Carga y ejecuta el archivo de schema para obtener las definiciones de tablas
+        
+        Returns:
+            MetaData: Metadata de SQLAlchemy con las tablas definidas
+        """
+        click.echo("📖 Cargando definiciones de schema...")
+        
+        try:
+            # Limpiar estado previo
+            db.tables = []
+
+            Table.analyze()
+            Table.validate()
+
+            db.tables = Table.registry
+
+            for table in db.tables:
+                # Convertir la definición de tai_sql a tabla SQLAlchemy
+                sqlalchemy_table = table.to_sqlalchemy_table(self.drift_manager.metadata)
+                click.echo(f"   📋 Tabla: {sqlalchemy_table.name}")
+
+            return self.drift_manager.metadata
+            
+        except Exception as e:
+            raise Exception(f"Error al cargar schema: {e}")
+    
+    def validate_schema_names(self):
+        """
+        Valida que los nombres de tablas y columnas no sean palabras reservadas
+        """
+        click.echo("🔍 Validando nombres de tablas y columnas...")
+        
+        warnings = []
+        
+        for table in self.drift_manager.metadata.tables.values():
+            # Validar nombre de tabla
+            if table.name.lower() in self.ddl_manager.ddl.reserved_words:
+                warnings.append(f"⚠️  Tabla '{table.name}' es una palabra reservada")
+            
+            # Validar nombres de columnas
+            for column in table.columns:
+                if column.name.lower() in self.ddl_manager.ddl.reserved_words:
+                    warnings.append(f"⚠️  Columna '{column.name}' en tabla '{table.name}' es una palabra reservada")
+        
+        if warnings:
+            click.echo("❌ Se encontraron problemas con nombres:")
+            for warning in warnings:
+                click.echo(f"   {warning}")
+            click.echo()
+            click.echo("💡 Sugerencias:")
+            click.echo("   - Cambia 'user' por 'users' o 'app_user'")
+            click.echo("   - Cambia 'order' por 'orders' o 'user_order'")
+            click.echo("   - Usa nombres descriptivos que no sean palabras reservadas")
+            click.echo()
+            
+            if not click.confirm("¿Continuar de todas formas? (se manejará automáticamente)"):
+                click.echo("❌ Operación cancelada por el usuario")
+                sys.exit(1)
+        
+        click.echo("✅ Validación de nombres completada")
+    
+    def generate(self) -> None:
+        """
+        Genera las sentencias DDL considerando cambios incrementales
+        
+        Returns:
+            Lista de sentencias DDL como strings
+        """
+
+        # Limpiar sentencias previas
+        self.ddl_manager.clear()
+        # Detectar cambios
+        self.drift_manager.detect()
+        
+        # Mostrar resumen de cambios
+        self.drift_manager.show()
+
+        new_tables = self.drift_manager.new_tables
+        new_cols = self.drift_manager.columns_to_add
+        delete_cols = self.drift_manager.columns_to_drop
+        modify_cols = self.drift_manager.columns_to_modify
+
+        if new_tables:
+            self.ddl_manager.generate_creations(new_tables.values())
+        
+        # Generar migraciones para tablas existentes
+        if new_cols or delete_cols or modify_cols:
+            self.ddl_manager.generate_migrations(new_cols, delete_cols, modify_cols)
+
+        return self.ddl_manager.statements
+    
+    def execute(self):
+        """Ejecuta las sentencias DDL en la base de datos"""
+        if not self.ddl_manager.statements:
+            click.echo("ℹ️  No hay cambios para aplicar")
+            return
+            
+        click.echo("⚙️  Ejecutando sentencias DDL...")
+        
+        try:
+            executed_count = 0
+            
+            with self.drift_manager.engine.connect() as conn:
+                # Usar transacción para todas las operaciones
+                trans = conn.begin()
+                
+                try:
+                    for stmt in self.ddl_manager.statements:
+
+                        if isinstance(stmt, CreateStatement):
+                            # Ejecutar CREATE TABLE
+                            conn.execute(text(stmt.text))
+                            executed_count += 1
+                            click.echo(f"   ✅ Tabla {stmt.table_name} creada")
+                            
+                        elif isinstance(stmt, AlterColumnStatement):
+                            # Ejecutar ALTER TABLE
+
+                            if stmt.column.unique:
+                                result = stmt.check_unique_constraints()
+
+                                if result:
+                                    click.echo("   ❌  UniqueConstraint error:")
+                                    click.echo(f'   ⚠️  Columna "{stmt.column_name}" tiene valores duplicados en {stmt.table_name}, se omitirá la modificación')
+                                    continue
+
+                            if isinstance(stmt.text, List):
+                                for sub_stmt in stmt.text:
+                                    conn.execute(text(sub_stmt))
+                            else:
+
+                                conn.execute(text(stmt.text))
+
+                            executed_count += 1
+
+                            if stmt.column_name:
+                                click.echo(f"   ✅ Columna {stmt.column_name} añadida/modificada en {stmt.table_name}")
+
+                        elif isinstance(stmt, ForeignKeyStatement):
+                            # Ejecutar ALTER TABLE
+                            conn.execute(text(stmt.text))
+                            executed_count += 1
+                            click.echo(f"   ✅ Foreign Key: {stmt.table_name}.{stmt.fk.parent.name} → {stmt.fk.column.table.name}.{stmt.fk.column.name} añadida a {stmt.table_name}")
+                    
+                    trans.commit()
+                    click.echo(f"   🎉 {executed_count} operación(es) ejecutada(s) exitosamente")
+                    
+                except Exception as e:
+                    trans.rollback()
+                    raise e
+                    
+        except Exception as e:
+            raise Exception(f"Error al ejecutar DDL: {e}")
+    
+
+