Python postgres connector

[bocodigital]

The Postgres connector's lambda-to-SQL flow builds predicate strings but then inserts them into queries in a way that treats them as SQL literals (quoted strings) rather than expressions. This results in queries like WHERE '"content_type" = 'course'' which Postgres rejects as an invalid boolean. The fix is to pass parsed clauses into psycopg.sql as sql.SQL(...)/sql.Composed objects (or better: return parameterized clauses + params). I'm attaching a small patch that converts where_clauses to sql.SQL before formatting; I'd be happy to open a PR that returns parameterized clauses and params for safer construction.

[bocodigital]

This might be useful. Chat Gpt wrote me a monkey patch to get around the issue. `# patch_sk_postgres_filter.py — import this from AppConfig.ready()
from psycopg import sql
import semantic_kernel.connectors.postgres as sk_postgres
import inspect
import logging

logger = logging.getLogger("sk_postgres_patch")

Only patch once

if not getattr(sk_postgres.PostgresCollection, "_patched_lambda_filter_sql", False):
original_build_filter = getattr(sk_postgres.PostgresCollection, "_build_filter", None)

def _wrap_clause_as_sql(clause):
    # If the clause is already sql.Composed/SQL, leave it alone
    if isinstance(clause, sql.Composed) or isinstance(clause, sql.SQL):
        return clause
    # If it's a string, wrap in sql.SQL to insert as SQL fragment
    if isinstance(clause, str):
        return sql.SQL(clause)
    # If it's a list of strings, map recursively
    if isinstance(clause, list) or isinstance(clause, tuple):
        return [ _wrap_clause_as_sql(c) for c in clause ]
    return clause

def patched_build_filter(self, filter_obj):
    # Call original implementation first (may return str, list[str], or sql objects)
    res = original_build_filter(self, filter_obj) if original_build_filter else None
    if res is None:
        return res
    # Convert string clauses to sql.SQL objects so they are embedded as SQL fragments,
    # not SQL string literals when using sql.SQL().format(...)
    try:
        return _wrap_clause_as_sql(res)
    except Exception:
        logger.exception("Failed to wrap where clause into sql.SQL; returning original")
        return res

# Apply monkeypatch
setattr(sk_postgres.PostgresCollection, "_build_filter", patched_build_filter)
# marker so we don't patch twice
setattr(sk_postgres.PostgresCollection, "_patched_lambda_filter_sql", True)
logger.info("Patched semantic_kernel PostgresCollection._build_filter to return sql.SQL fragments")`

[tejasai97]

Hi, apologies for the premature PR #13602. I closed it as it wasn't ready. I'd like to work on this issue if it's still available. I have a fix ready that changes _lambda_parser to return sql.Composable objects instead of plain strings, so psycopg's sql.SQL.format() embeds them as SQL fragments rather than wrapping them as sql.Literal. The fix includes unit tests as well. Please let me know if I can go ahead and open a proper PR.