Fix for SELECT using JSON paths

Author: matt-aitken

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

@@ -622,19 +622,18 @@ describe("ClickHousePrinter", () => {
       expect(sql).not.toContain("error.message.:String");
     });
 
-    it("should add .:String in SELECT but not in WHERE for same field", () => {
+    it("should NOT add .:String in SELECT or WHERE when no GROUP BY", () => {
       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");
+      // SELECT should NOT have .:String (no GROUP BY, so no need for type hint)
+      expect(sql).toContain("error.data.name AS error_data_name");
+      expect(sql).not.toContain(".:String");
       // 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", () => {
@@ -712,13 +711,14 @@ describe("ClickHousePrinter", () => {
         expect(sql).toContain("error_text AS error");
       });
 
-      it("should use JSON column for subfield access", () => {
+      it("should use JSON column for subfield access without .:String when no GROUP BY", () => {
         const ctx = createTextColumnContext();
         const { sql } = printQuery("SELECT output.data.name FROM runs", ctx);
 
-        // Should use the original JSON column with .:String type hint
-        expect(sql).toContain("output.data.name.:String");
+        // Should use the original JSON column without .:String (no GROUP BY)
+        expect(sql).toContain("output.data.name AS output_data_name");
         expect(sql).not.toContain("output_text");
+        expect(sql).not.toContain(".:String");
       });
     });
 

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

@@ -114,6 +114,8 @@ export class ClickHousePrinter {
   private outputColumns: OutputColumnMetadata[] = [];
   /** Whether we're currently processing GROUP BY expressions */
   private inGroupByContext = false;
+  /** Whether the current query has a GROUP BY clause (used for JSON subfield type hints) */
+  private queryHasGroupBy = false;
   /** Columns hidden when SELECT * is expanded to core columns only */
   private hiddenColumns: string[] = [];
   /**
@@ -392,6 +394,11 @@ export class ClickHousePrinter {
       }
     }
 
+    // Track if query has GROUP BY for JSON subfield type hint decisions
+    // (ClickHouse requires .:String for Dynamic types in GROUP BY, and SELECT must match)
+    const savedQueryHasGroupBy = this.queryHasGroupBy;
+    this.queryHasGroupBy = !!node.group_by;
+
     // Process SELECT columns and collect metadata
     // Using flatMap because asterisk expansion can return multiple columns
     // Set inProjectionContext to block internal-only columns in user projections
@@ -543,6 +550,7 @@ export class ClickHousePrinter {
 
     // Restore saved contexts (for nested queries)
     this.selectAliases = savedAliases;
+    this.queryHasGroupBy = savedQueryHasGroupBy;
     this.tableContexts = savedTableContexts;
     this.allowedInternalColumns = savedInternalColumns;
     this.internalOnlyColumns = savedInternalOnlyColumns;
@@ -2124,14 +2132,21 @@ export class ClickHousePrinter {
     let result = resolvedChain.map((part) => this.printIdentifierOrIndex(part)).join(".");
 
     // 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
+    // This is ONLY required when the query has GROUP BY, because:
+    // 1. ClickHouse's Dynamic/Variant types are not allowed in GROUP BY without type casting
+    // 2. SELECT/GROUP BY expressions must match
+    // For queries without GROUP BY, the .:String type hint actually breaks the query
+    // (returns NULL instead of the actual value)
+    // We also 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]]);
-      // Add .:String for SELECT/GROUP BY, but NOT in WHERE comparisons
-      if (rootColumnSchema?.type === "JSON" && !this.isInWhereComparisonContext()) {
+      // Add .:String ONLY for GROUP BY queries, and NOT in WHERE comparisons
+      if (
+        rootColumnSchema?.type === "JSON" &&
+        this.queryHasGroupBy &&
+        !this.isInWhereComparisonContext()
+      ) {
         // Add .:String type hint for JSON subfield access
         result = `${result}.:String`;
       }