postgres ROUND fixing

ai/signatures.py

@@ -160,6 +160,44 @@ class AnalyzeAndPlan(dspy.Signature):
     There is no product_master, products, or product_catalog table.
     Use product_id as the only product identifier. Never invent table names.
 
+    ══════════════════════════════════════════════════════════════
+    RULE 1D0 — PERCENTAGE / RATIO WITH CASE WHEN — NEVER PRE-FILTER STATUS
+    ══════════════════════════════════════════════════════════════
+    When computing a percentage breakdown across different statuses
+    (e.g. "% closed vs % cancelled"), the denominator must be ALL orders.
+    Adding WHERE status IN ('closed', 'cancelled') before grouping removes
+    other statuses from the denominator → inflated percentages.
+
+    WRONG (WHERE filter shrinks denominator):
+      SELECT customer_id,
+          SUM(CASE WHEN status = 'closed' THEN total_amount ELSE 0 END) * 100.0
+          / SUM(total_amount) AS pct_closed
+      FROM sales_table_v2_sales_order
+      WHERE status IN ('closed', 'cancelled')   ← removes open/processing rows
+      GROUP BY customer_id
+
+    CORRECT (no WHERE on status — CASE WHEN handles the split):
+      SELECT cm.customer_id, cm.customer_name,
+          ROUND((SUM(CASE WHEN so.status = 'closed' THEN so.total_amount ELSE 0 END)
+                 * 100.0 / SUM(so.total_amount))::numeric, 2) AS pct_closed,
+          ROUND((SUM(CASE WHEN so.status = 'cancelled' THEN so.total_amount ELSE 0 END)
+                 * 100.0 / SUM(so.total_amount))::numeric, 2) AS pct_cancelled
+      FROM sales_table_v2_sales_order so
+      JOIN sales_table_v2_customer_master cm ON so.customer_id = cm.customer_id
+      GROUP BY cm.customer_id, cm.customer_name
+
+    ══════════════════════════════════════════════════════════════
+    RULE 1D1 — PostgreSQL ROUND() REQUIRES ::numeric CAST
+    ══════════════════════════════════════════════════════════════
+    PostgreSQL's ROUND(value, N) only accepts numeric as the first argument.
+    Division or SUM() results are often double precision — passing them to
+    ROUND() directly raises: "function round(double precision, integer) does not exist".
+
+    WRONG:   ROUND(SUM(x) * 100.0 / SUM(y), 2)
+    CORRECT: ROUND((SUM(x) * 100.0 / SUM(y))::numeric, 2)
+
+    Always cast the expression to ::numeric inside every ROUND(..., N) call.
+
     ══════════════════════════════════════════════════════════════
     RULE 1D2 — "PER X" DENOMINATOR — READ THE QUESTION CAREFULLY
     ══════════════════════════════════════════════════════════════
@@ -505,6 +543,16 @@ class SQLGeneration(dspy.Signature):
 
     4d. NO product_master table — never reference it; use product_id only.
 
+    4d0. PERCENTAGE WITH CASE WHEN — never add WHERE status filter on the same column:
+         When splitting by status with CASE WHEN, the denominator must include ALL rows.
+         WRONG:   WHERE status IN ('closed','cancelled') ... SUM(total_amount) as denominator
+         CORRECT: No WHERE on status. CASE WHEN handles split; SUM(total_amount) = all orders.
+
+    4d1. ROUND() IN PostgreSQL — always cast to ::numeric first:
+         WRONG:   ROUND(SUM(x) / SUM(y), 2)
+         CORRECT: ROUND((SUM(x) / SUM(y))::numeric, 2)
+         Applies to every ROUND(..., N) call — division results are double precision by default.
+
     4d2. "PER X" DENOMINATOR — use the correct divisor for what "per" refers to:
          "per order"    → COUNT(DISTINCT so.so_id)      NOT SUM(quantity)
          "per unit"     → SUM(quantity)                 NOT COUNT(DISTINCT so_id)

ai/sql_pattern_checker.py

@@ -232,6 +232,43 @@ def check_sql_patterns(sql: str) -> list[dict[str, Any]]:
                 ),
             })
 
+    # ── Pattern 3a ───────────────────────────────────────────────────────────
+    # WHERE status filter alongside CASE WHEN status — wrong denominator.
+    # When computing "percentage of X vs Y", the WHERE clause must NOT pre-filter
+    # by status because that shrinks the denominator (misses open/processing orders).
+    # CASE WHEN inside SUM() handles the split; no WHERE on status needed.
+    if (
+        re.search(r"\bcase\s+when\b.*?\bstatus\b", sql_lower, re.DOTALL)
+        and re.search(r"\bwhere\b.*?\bstatus\s+in\s*\(", sql_lower, re.DOTALL)
+        and re.search(r"\bsum\s*\(", sql_lower)
+    ):
+        issues.append({
+            "pattern_name": "case_when_status_with_where_filter",
+            "description": (
+                "WRONG DENOMINATOR — a WHERE status IN (...) filter is combined with "
+                "CASE WHEN so.status = ... inside SUM(). "
+                "The WHERE clause removes rows before aggregation, making the denominator "
+                "(SUM of all orders) too small and inflating every percentage. "
+                "For percentage breakdowns across statuses, the CASE WHEN handles the split "
+                "and the WHERE clause on status must be removed."
+            ),
+            "correction": (
+                "Remove the WHERE status filter. Let CASE WHEN handle the split:\n"
+                "\n"
+                "CORRECT pattern:\n"
+                "SELECT cm.customer_id, cm.customer_name,\n"
+                "    ROUND((SUM(CASE WHEN so.status = 'closed' THEN so.total_amount ELSE 0 END)\n"
+                "           * 100.0 / SUM(so.total_amount))::numeric, 2) AS pct_closed,\n"
+                "    ROUND((SUM(CASE WHEN so.status = 'cancelled' THEN so.total_amount ELSE 0 END)\n"
+                "           * 100.0 / SUM(so.total_amount))::numeric, 2) AS pct_cancelled\n"
+                "FROM sales_table_v2_sales_order so\n"
+                "JOIN sales_table_v2_customer_master cm ON so.customer_id = cm.customer_id\n"
+                "GROUP BY cm.customer_id, cm.customer_name\n"
+                "\n"
+                "No WHERE on status — SUM(so.total_amount) must include ALL orders as denominator."
+            ),
+        })
+
     # ── Pattern 3b ───────────────────────────────────────────────────────────
     # "per order" metric computed with SUM(quantity) as denominator instead of
     # COUNT(DISTINCT so_id).  SUM(quantity) = revenue per unit; "per order"
@@ -257,6 +294,34 @@ def check_sql_patterns(sql: str) -> list[dict[str, Any]]:
             ),
         })
 
+    # ── Pattern 3c ───────────────────────────────────────────────────────────
+    # PostgreSQL ROUND() requires numeric, not double precision.
+    # ROUND(expr, N) fails with "function round(double precision, integer) does not exist"
+    # if expr evaluates to double precision. Fix: cast to ::numeric before ROUND().
+    if re.search(r"\bround\s*\(", sql_lower):
+        # Check if any ROUND( call lacks a ::numeric cast inside it
+        round_calls = re.findall(r"round\s*\(([^;]+?),\s*\d+\s*\)", sql, re.IGNORECASE)
+        for call in round_calls:
+            if "::numeric" not in call.lower() and "::decimal" not in call.lower():
+                issues.append({
+                    "pattern_name": "round_missing_numeric_cast",
+                    "description": (
+                        "PostgreSQL TYPE ERROR — ROUND(value, N) only accepts numeric as first "
+                        "argument. If value is double precision (e.g. result of division or "
+                        "SUM()), PostgreSQL raises: "
+                        "'function round(double precision, integer) does not exist'. "
+                        "You must cast to ::numeric before calling ROUND."
+                    ),
+                    "correction": (
+                        "Always cast the expression to ::numeric inside ROUND:\n"
+                        "  WRONG:   ROUND(SUM(x) * 100.0 / SUM(y), 2)\n"
+                        "  CORRECT: ROUND((SUM(x) * 100.0 / SUM(y))::numeric, 2)\n"
+                        "\n"
+                        "Apply this to every ROUND(..., N) call in the query."
+                    ),
+                })
+                break  # one report per query is enough
+
     # ── Pattern 4 ────────────────────────────────────────────────────────────
     # Schema-aware: detect alias.column where column doesn't exist in that table.
     # Generic — works for gold_kt on pricing table, or any future similar mistake.