Update app.py

app.py

@@ -83,22 +83,84 @@ class PostgresManager:
             raise KeyError(f"connection_id '{connection_id}' no registrado")
         return self.connections[connection_id]
 
-    def _get_conn(self):
+    def _get_conn(self, autocommit: bool = True):
         conn = psycopg2.connect(self.dsn)
-        conn.autocommit = True
+        conn.autocommit = autocommit
         return conn
 
+    def _execute_pg_dump(self, cur, sql_text: str) -> None:
+        """
+        Ejecuta un script tipo pg_dump:
+
+          - Ejecuta DDL/INSERTs normales con execute
+          - Maneja bloques:
+
+                COPY tabla (...) FROM stdin;
+                datos...
+                \.
+
+            usando copy_expert.
+        """
+        lines = sql_text.splitlines()
+        n = len(lines)
+        i = 0
+        buffer: List[str] = []
+
+        def flush_buffer():
+            stmt = "\n".join(buffer).strip()
+            if not stmt:
+                return
+            # Partimos por ';' para ejecutar cada sentencia
+            for piece in stmt.split(";"):
+                piece = piece.strip()
+                if piece:
+                    cur.execute(piece)
+
+        while i < n:
+            line = lines[i]
+
+            # ¿Inicio de bloque COPY ... FROM stdin; ?
+            if re.match(r"^\s*copy\s+.+from\s+stdin;?\s*$", line, re.IGNORECASE):
+                # Ejecutar lo acumulado antes del COPY
+                flush_buffer()
+                buffer = []
+
+                copy_sql = line.strip()
+                i += 1
+                data_lines: List[str] = []
+
+                # Acumular las filas hasta encontrar '\.'
+                while i < n and lines[i].strip() != r"\.":
+                    data_lines.append(lines[i])
+                    i += 1
+
+                # Saltar la línea '\.' si existe
+                if i < n and lines[i].strip() == r"\.":
+                    i += 1
+
+                data_str = "\n".join(data_lines) + "\n"
+
+                # Ejecutar el COPY con los datos
+                cur.copy_expert(copy_sql, io.StringIO(data_str))
+            else:
+                buffer.append(line)
+                i += 1
+
+        # Ejecutar lo que quede al final
+        flush_buffer()
+
     # ---------- creación de BD desde dump ----------
 
     def create_database_from_dump(self, label: str, sql_text: str) -> str:
         """
         Crea un schema en Neon, fija search_path a ese schema
-        y ejecuta el dump SQL dentro de él.
+        y ejecuta el dump SQL dentro de él (incluyendo COPY ... FROM stdin).
         """
         connection_id = self._new_connection_id()
         schema_name = f"sess_{uuid.uuid4().hex[:8]}"
 
-        conn = self._get_conn()
+        # Para el dump queremos manejar la transacción a mano
+        conn = self._get_conn(autocommit=False)
         try:
             with conn.cursor() as cur:
                 # Crear schema aislado
@@ -113,23 +175,31 @@ class PostgresManager:
                         pgsql.Identifier(schema_name)
                     )
                 )
-                # Ejecutar dump completo (puede tener múltiples sentencias)
-                cur.execute(sql_text)
+                # Ejecutar dump completo (DDL + COPY)
+                self._execute_pg_dump(cur, sql_text)
+
+            conn.commit()
         except Exception as e:
-            # Si falla, intentar limpiar el schema
+            conn.rollback()
+
+            # Intentar limpiar el schema si llegó a crearse
             try:
-                with conn.cursor() as cur:
+                cleanup_conn = self._get_conn(autocommit=True)
+                with cleanup_conn.cursor() as cur:
                     cur.execute(
                         pgsql.SQL("DROP SCHEMA IF EXISTS {} CASCADE").format(
                             pgsql.Identifier(schema_name)
                         )
                     )
+                cleanup_conn.close()
             except Exception:
                 pass
+
             conn.close()
             raise RuntimeError(f"Error ejecutando dump SQL en Postgres: {e}")
         finally:
-            conn.close()
+            if not conn.closed:
+                conn.close()
 
         self.connections[connection_id] = {
             "label": label,