Fix for WHERE clause with JSON path

Author: matt-aitken

internal-packages/tsql/src/query/printer.test.ts

@@ -597,6 +597,61 @@ describe("ClickHousePrinter", () => {
       expect(sql).toContain("GROUP BY status");
       expect(sql).not.toContain(".:String");
     });
+
+    it("should NOT add .:String type hint for JSON subfield in WHERE comparison", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT id FROM runs WHERE error.data.name = 'test'",
+        ctx
+      );
+
+      // WHERE clause should NOT have .:String type hint (it breaks the query)
+      expect(sql).toContain("equals(error.data.name,");
+      expect(sql).not.toContain("error.data.name.:String");
+    });
+
+    it("should NOT add .:String for JSON subfield in WHERE with LIKE", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT id FROM runs WHERE error.message LIKE '%error%'",
+        ctx
+      );
+
+      // WHERE clause should NOT have .:String type hint
+      expect(sql).toContain("like(error.message,");
+      expect(sql).not.toContain("error.message.:String");
+    });
+
+    it("should add .:String in SELECT but not in WHERE for same field", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT error.data.name FROM runs WHERE error.data.name = 'test'",
+        ctx
+      );
+
+      // SELECT should have .:String with alias
+      expect(sql).toContain("error.data.name.:String AS error_data_name");
+      // WHERE should NOT have .:String
+      expect(sql).toContain("equals(error.data.name,");
+      // Make sure WHERE doesn't accidentally get the type hint
+      expect(sql).not.toMatch(/equals\(error\.data\.name\.:String/);
+    });
+
+    it("should add .:String in GROUP BY but not in WHERE for same query", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT error.data.name, count() AS cnt FROM runs WHERE error.data.name = 'test' GROUP BY error.data.name",
+        ctx
+      );
+
+      // SELECT should have .:String
+      expect(sql).toContain("error.data.name.:String AS error_data_name");
+      // GROUP BY should have .:String
+      expect(sql).toContain("GROUP BY error.data.name.:String");
+      // WHERE should NOT have .:String
+      expect(sql).toContain("equals(error.data.name,");
+      expect(sql).not.toMatch(/equals\(error\.data\.name\.:String/);
+    });
   });
 
   describe("textColumn optimization for JSON columns", () => {
@@ -716,16 +771,18 @@ describe("ClickHousePrinter", () => {
         expect(sql).toContain("notLike(output_text,");
       });
 
-      it("should use JSON column for subfield comparison", () => {
+      it("should use JSON column for subfield comparison without .:String", () => {
         const ctx = createTextColumnContext();
         const { sql } = printQuery(
           "SELECT id FROM runs WHERE output.data.name = 'test'",
           ctx
         );
 
         // Should use the original JSON column, not the text column
-        expect(sql).toContain("equals(output.data.name.:String,");
+        // And should NOT have .:String in WHERE (breaks the query)
+        expect(sql).toContain("equals(output.data.name,");
         expect(sql).not.toContain("output_text");
+        expect(sql).not.toContain("output.data.name.:String");
       });
 
       it("should still use nullValue transformation for IS NULL", () => {

internal-packages/tsql/src/query/printer.ts

@@ -2126,10 +2126,12 @@ export class ClickHousePrinter {
     // For JSON column subfield access (e.g., error.data.name), add .:String type hint
     // This is required because ClickHouse's Dynamic/Variant types are not allowed in
     // GROUP BY without type casting, and SELECT/GROUP BY expressions must match
+    // However, we skip this in WHERE comparisons where it breaks the query
     if (resolvedChain.length > 1) {
       // Check if the root column (first part) is a JSON column
       const rootColumnSchema = this.resolveFieldToColumnSchema([node.chain[0]]);
-      if (rootColumnSchema?.type === "JSON") {
+      // Add .:String for SELECT/GROUP BY, but NOT in WHERE comparisons
+      if (rootColumnSchema?.type === "JSON" && !this.isInWhereComparisonContext()) {
         // Add .:String type hint for JSON subfield access
         result = `${result}.:String`;
       }
@@ -2157,6 +2159,20 @@ export class ClickHousePrinter {
     return false;
   }
 
+  /**
+   * Check if we're inside a WHERE/HAVING comparison operation.
+   * Unlike isInComparisonContext(), this does NOT include GROUP BY context.
+   * Used to skip .:String type hints in WHERE clauses where they break queries.
+   */
+  private isInWhereComparisonContext(): boolean {
+    for (const node of this.stack) {
+      if ((node as CompareOperation).expression_type === "compare_operation") {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Resolve field chain with table alias prefix to avoid alias conflicts.
    * This is used in WHERE clauses when a column has whereTransform to ensure