Update app.py

app.py

@@ -153,53 +153,118 @@ class PostgresManager:
 
     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 (incluyendo COPY ... FROM stdin).
+        Crea un schema aislado en Neon y restaura dentro de él
+        un dump de Postgres tipo psql (con COPY FROM stdin, DROP DATABASE, etc.).
         """
         connection_id = self._new_connection_id()
         schema_name = f"sess_{uuid.uuid4().hex[:8]}"
 
-        # Para el dump queremos manejar la transacción a mano
-        conn = self._get_conn(autocommit=False)
+        conn = self._get_conn()
         try:
             with conn.cursor() as cur:
-                # Crear schema aislado
+                # 1) Crear schema aislado
                 cur.execute(
                     pgsql.SQL("CREATE SCHEMA {}").format(
                         pgsql.Identifier(schema_name)
                     )
                 )
-                # Usar ese schema por defecto
+                # 2) Usar ese schema como search_path
                 cur.execute(
                     pgsql.SQL("SET search_path TO {}").format(
                         pgsql.Identifier(schema_name)
                     )
                 )
-                # Ejecutar dump completo (DDL + COPY)
-                self._execute_pg_dump(cur, sql_text)
 
-            conn.commit()
-        except Exception as e:
-            conn.rollback()
+                # 3) Parsear el dump línea por línea
+                in_copy = False
+                copy_sql = ""
+                copy_rows: list[str] = []
+                stmt_lines: list[str] = []
+
+                def flush_statement():
+                    """Ejecuta el statement acumulado si es útil."""
+                    stmt = "\n".join(stmt_lines).strip()
+                    stmt_lines.clear()
+                    if not stmt or stmt == ";":
+                        return
+
+                    # saltar cosas peligrosas o innecesarias
+                    upper = stmt.upper()
+                    skip_prefixes = (
+                        "SET ",
+                        "SELECT PG_CATALOG.SET_CONFIG",
+                        "COMMENT ON EXTENSION",
+                        "DROP DATABASE",
+                        "CREATE DATABASE",
+                        "ALTER DATABASE",
+                        "REVOKE ",
+                        "GRANT ",
+                        "BEGIN",
+                        "COMMIT",
+                        "ROLLBACK",
+                    )
+                    if upper.startswith(skip_prefixes):
+                        return
+
+                    # quitar ';' final si viene solo
+                    if stmt.endswith(";"):
+                        stmt = stmt[:-1]
+
+                    cur.execute(stmt)
+
+                for raw_line in sql_text.splitlines():
+                    line = raw_line.rstrip("\n")
+
+                    # Comentarios y líneas vacías
+                    if not in_copy and (not line.strip() or line.strip().startswith("--")):
+                        continue
+
+                    if in_copy:
+                        # Estamos dentro de un bloque COPY ... FROM stdin
+                        if line.strip() == r"\.":
+                            # Fin del COPY → mandar todo a copy_expert
+                            data_str = "\n".join(copy_rows) + "\n"
+                            copy_rows.clear()
+                            in_copy = False
+                            cur.copy_expert(copy_sql, io.StringIO(data_str))
+                        else:
+                            copy_rows.append(line)
+                        continue
+
+                    # Detectar COPY ... FROM stdin;
+                    stripped = line.strip()
+                    if stripped.upper().startswith("COPY ") and "FROM stdin" in stripped:
+                        # Antes de entrar al COPY, ejecutar lo que hubiera acumulado
+                        flush_statement()
+                        in_copy = True
+                        copy_sql = stripped  # tal cual viene en el dump
+                        copy_rows = []
+                        continue
+
+                    # Acumular statement “normal”
+                    stmt_lines.append(line)
+                    if stripped.endswith(";"):
+                        flush_statement()
+
+                # Por si quedó algo sin ';' al final
+                if stmt_lines:
+                    flush_statement()
 
-            # Intentar limpiar el schema si llegó a crearse
+        except Exception as e:
+            # Si falla, eliminar el schema recién creado
             try:
-                cleanup_conn = self._get_conn(autocommit=True)
-                with cleanup_conn.cursor() as cur:
+                with 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:
-            if not conn.closed:
-                conn.close()
+            conn.close()
 
         self.connections[connection_id] = {
             "label": label,