Update app.py

app.py

@@ -181,6 +181,14 @@ class PostgresManager:
                     )
                 )
 
+                # 🔁 Reescribir referencias a esquemas globales (public, pagila, etc.)
+                # para que todo termine dentro de nuestro schema aislado de sesión.
+                pattern_public = re.compile(r'\bpublic\.', flags=re.IGNORECASE)
+                pattern_pagila = re.compile(r'\bpagila\.', flags=re.IGNORECASE)
+        
+                sql_text = pattern_public.sub(f'{schema_name}.', sql_text)
+                sql_text = pattern_pagila.sub(f'{schema_name}.', sql_text)
+
                 in_copy = False
                 copy_sql = ""
                 copy_rows: list[str] = []
@@ -391,7 +399,7 @@ class PostgresManager:
 
     def get_schema(self, connection_id: str) -> Dict[str, Any]:
         info = self._get_info(connection_id)
-        schema = info["schema"]
+        schema = info["schema"]  # schema "ideal" que registramos
 
         conn = self._get_conn()
         try:
@@ -399,7 +407,7 @@ class PostgresManager:
             foreign_keys: List[Dict[str, Any]] = []
 
             with conn.cursor() as cur:
-                # Tablas básicas
+                # 1) Intentamos solo con el schema registrado
                 cur.execute(
                     """
                     SELECT table_name
@@ -412,7 +420,56 @@ class PostgresManager:
                 )
                 tables = [r[0] for r in cur.fetchall()]
 
-                # Columnas por tabla
+                # 2) 🔁 Fallback: si no hay tablas en ese schema,
+                #    buscamos en TODOS los schemas de usuario
+                if not tables:
+                    cur.execute(
+                        """
+                        SELECT table_schema, table_name
+                        FROM information_schema.tables
+                        WHERE table_type = 'BASE TABLE'
+                          AND table_schema NOT IN ('pg_catalog','information_schema')
+                        ORDER BY table_schema, table_name;
+                        """
+                    )
+                    rows = cur.fetchall()
+
+                    if not rows:
+                        # No hay tablas en ningún schema de usuario
+                        return {
+                            "tables": {},
+                            "foreign_keys": [],
+                        }
+
+                    # Schemas candidatos que sí tienen tablas
+                    schemas = sorted({s for (s, _) in rows})
+
+                    # Preferimos:
+                    # 1) el schema ya registrado (si por alguna razón tiene tablas)
+                    # 2) 'pagila'
+                    # 3) 'public'
+                    # 4) el primero que aparezca
+                    target_schema = None
+                    if schema in schemas:
+                        target_schema = schema
+                    elif "pagila" in schemas:
+                        target_schema = "pagila"
+                    elif "public" in schemas:
+                        target_schema = "public"
+                    else:
+                        target_schema = schemas[0]
+
+                    print(
+                        f"[WARN] Schema '{schema}' sin tablas; usando schema real '{target_schema}'"
+                    )
+
+                    # Actualizamos el schema asociado a esta conexión
+                    schema = target_schema
+                    info["schema"] = schema
+
+                    tables = [t for (s, t) in rows if s == schema]
+
+                # 3) Columnas por tabla del schema final seleccionado
                 for t in tables:
                     cur.execute(
                         """
@@ -427,7 +484,7 @@ class PostgresManager:
                     cols = [r[0] for r in cur.fetchall()]
                     tables_info[t] = {"columns": cols}
 
-                # Foreign keys
+                # 4) Foreign keys del schema final
                 cur.execute(
                     """
                     SELECT