fix: Embed JSON-aliased VARCHAR columns as nested JSON (#38) (#39)

DuckDB's JSON type is a logical-type alias over VARCHAR; the dispatch in QueryResult::convertVectorEntryToJson switched on the physical type id and routed JSON cells to the VARCHAR handler, so API consumers got an escaped string and had to JSON.parse a second time.

Inspect the logical-type alias before dispatching. When it equals the literal "JSON" that DuckDB sets on LogicalType::JSON(), route to a new convertVectorJsonToJson helper that parses with crow::json::load and embeds the result via wvalue(const rvalue&). Nested objects and arrays now travel through the response unchanged. Malformed JSON degrades to the raw string rather than nulling the row.

Also destroy the logical type on every exit path of convertVectorEntryToJson; the dead destroy below the switch was unreachable, leaking one logical-type allocation per emitted cell.

Tests added TDD-style (red → green):
- unit: nested object, JSON array, NULL JSON, plain-VARCHAR regression guard.
- integration: GET /json-demo/ returns the exact "Expected" shape from the issue.

Closes #38

Author: jrosskopf

src/include/query_executor.hpp

@@ -48,6 +48,7 @@ class QueryResult {
 
     static crow::json::wvalue convertVectorEntryToJson(const duckdb_vector &vector, const idx_t row_idx);
     static crow::json::wvalue convertVectorVarcharToJson(const duckdb_vector &vector, const idx_t row_idx);
+    static crow::json::wvalue convertVectorJsonToJson(const duckdb_vector &vector, const idx_t row_idx);
     static crow::json::wvalue convertVectorDecimalToJson(const duckdb_vector &vector, const idx_t row_idx);
     static crow::json::wvalue convertVectorTimestampToJson(const duckdb_vector &vector, const idx_t row_idx);
     static crow::json::wvalue convertVectorDateToJson(const duckdb_vector &vector, const idx_t row_idx);

src/query_executor.cpp

@@ -203,6 +203,23 @@ std::vector<crow::json::wvalue> QueryResult::convertChunkToJson(const std::vecto
 crow::json::wvalue QueryResult::convertVectorEntryToJson(const duckdb_vector &vector, const idx_t row_idx) {
     auto type = duckdb_vector_get_column_type(vector);
     auto type_id = duckdb_get_type_id(type);
+
+    // DuckDB's JSON type is a logical-type alias over VARCHAR (see
+    // DuckDB's LogicalType::JSON()), so `duckdb_get_type_id` returns
+    // VARCHAR for it. Detect the alias before dispatching to the VARCHAR
+    // handler so JSON columns are embedded as nested JSON rather than
+    // emitted as escaped strings.
+    bool is_json_alias = false;
+    if (type_id == DUCKDB_TYPE_VARCHAR) {
+        DuckDBString alias(duckdb_logical_type_get_alias(type));
+        is_json_alias = !alias.is_null() && std::string(alias.get()) == "JSON";
+    }
+    duckdb_destroy_logical_type(&type);
+
+    if (is_json_alias) {
+        return convertVectorJsonToJson(vector, row_idx);
+    }
+
     switch (type_id) {
         case DUCKDB_TYPE_SQLNULL:
             return crow::json::wvalue(nullptr);
@@ -278,17 +295,14 @@ crow::json::wvalue QueryResult::convertVectorEntryToJson(const duckdb_vector &ve
             CROW_LOG_WARNING << "Unknown type: " << type_id;
             return crow::json::wvalue(nullptr);
     }
-
-    duckdb_destroy_logical_type(&type);
-    return crow::json::wvalue();
 }
 
 crow::json::wvalue QueryResult::convertVectorVarcharToJson(const duckdb_vector &vector, const idx_t row_idx) {
     auto validity = duckdb_vector_get_validity(vector);
     if (!duckdb_validity_row_is_valid(validity, row_idx)) {
         return crow::json::wvalue(nullptr);
     }
-    
+
     auto data = (duckdb_string_t *)duckdb_vector_get_data(vector);
     auto str = duckdb_string_is_inlined(data[row_idx])
              ? std::string(data[row_idx].value.inlined.inlined, data[row_idx].value.inlined.length)
@@ -297,6 +311,30 @@ crow::json::wvalue QueryResult::convertVectorVarcharToJson(const duckdb_vector &
     return crow::json::wvalue(str);
 }
 
+crow::json::wvalue QueryResult::convertVectorJsonToJson(const duckdb_vector &vector, const idx_t row_idx) {
+    auto validity = duckdb_vector_get_validity(vector);
+    if (!duckdb_validity_row_is_valid(validity, row_idx)) {
+        return crow::json::wvalue(nullptr);
+    }
+
+    auto data = (duckdb_string_t *)duckdb_vector_get_data(vector);
+    const char* str_ptr = duckdb_string_is_inlined(data[row_idx])
+                        ? data[row_idx].value.inlined.inlined
+                        : (const char*)data[row_idx].value.pointer.ptr;
+    const idx_t str_len = duckdb_string_is_inlined(data[row_idx])
+                        ? data[row_idx].value.inlined.length
+                        : data[row_idx].value.pointer.length;
+
+    auto parsed = crow::json::load(str_ptr, str_len);
+    if (!parsed) {
+        // Source row contains malformed JSON; degrade to the raw string
+        // rather than dropping the row or returning null. The cell stays
+        // queryable, just as a string.
+        return crow::json::wvalue(std::string(str_ptr, str_len));
+    }
+    return crow::json::wvalue(parsed);
+}
+
 crow::json::wvalue QueryResult::convertVectorDecimalToJson(const duckdb_vector &vector, const idx_t row_idx) {
     auto validity = duckdb_vector_get_validity(vector);
 

test/cpp/query_executor_test.cpp

@@ -79,6 +79,76 @@ TEST_CASE("QueryExecutor error handling", "[query_executor]") {
     duckdb_close(&database);
 }
 
+TEST_CASE("QueryExecutor JSON column", "[query_executor][json]") {
+    duckdb_database database;
+    REQUIRE(duckdb_open(NULL, &database) == DuckDBSuccess);
+
+    QueryExecutor executor(database);
+    executor.execute("INSTALL json; LOAD json;");
+
+    SECTION("nested JSON value is embedded, not escaped") {
+        // Reproduction from issue #38: a column with the DuckDB `JSON`
+        // logical-type alias must serialise as nested JSON, not as a
+        // JSON-escaped string the caller has to parse a second time.
+        executor.execute(R"SQL(
+            SELECT
+                1 AS id,
+                '{"a": 1, "b": [10, 20], "c": {"nested": true}}'::JSON AS payload
+        )SQL");
+
+        auto doc = crow::json::load(executor.toJson().dump());
+        REQUIRE(doc.size() == 1);
+        REQUIRE(doc[0]["id"].i() == 1);
+
+        // The crux: payload must be an Object, not a String.
+        REQUIRE(doc[0]["payload"].t() == crow::json::type::Object);
+        REQUIRE(doc[0]["payload"]["a"].i() == 1);
+        REQUIRE(doc[0]["payload"]["b"].t() == crow::json::type::List);
+        REQUIRE(doc[0]["payload"]["b"].size() == 2);
+        REQUIRE(doc[0]["payload"]["b"][0].i() == 10);
+        REQUIRE(doc[0]["payload"]["b"][1].i() == 20);
+        REQUIRE(doc[0]["payload"]["c"]["nested"].b() == true);
+    }
+
+    SECTION("JSON array column is embedded as array") {
+        executor.execute(R"SQL(
+            SELECT '[1, 2, 3]'::JSON AS arr
+        )SQL");
+
+        auto doc = crow::json::load(executor.toJson().dump());
+        REQUIRE(doc.size() == 1);
+        REQUIRE(doc[0]["arr"].t() == crow::json::type::List);
+        REQUIRE(doc[0]["arr"].size() == 3);
+        REQUIRE(doc[0]["arr"][0].i() == 1);
+        REQUIRE(doc[0]["arr"][2].i() == 3);
+    }
+
+    SECTION("NULL JSON column stays null") {
+        executor.execute(R"SQL(
+            SELECT CAST(NULL AS JSON) AS payload
+        )SQL");
+
+        auto doc = crow::json::load(executor.toJson().dump());
+        REQUIRE(doc.size() == 1);
+        REQUIRE(doc[0]["payload"].t() == crow::json::type::Null);
+    }
+
+    SECTION("plain VARCHAR is still emitted as a string") {
+        // Regression guard: only the JSON-aliased VARCHAR path changes;
+        // bare VARCHAR must continue to render as a JSON string.
+        executor.execute(R"SQL(
+            SELECT '{"looks":"like json"}'::VARCHAR AS not_json
+        )SQL");
+
+        auto doc = crow::json::load(executor.toJson().dump());
+        REQUIRE(doc.size() == 1);
+        REQUIRE(doc[0]["not_json"].t() == crow::json::type::String);
+        REQUIRE(doc[0]["not_json"].s() == "{\"looks\":\"like json\"}");
+    }
+
+    duckdb_close(&database);
+}
+
 TEST_CASE("QueryExecutor type coverage", "[query_executor]") {
     duckdb_database database;
     REQUIRE(duckdb_open(NULL, &database) == DuckDBSuccess);

test/integration/api_configuration/sqls/json_demo.sql

@@ -0,0 +1,5 @@
+-- Reproduction of issue #38. `::JSON` triggers DuckDB's autoload of the
+-- json extension, so no explicit LOAD is needed here.
+SELECT
+    1 AS id,
+    '{"a": 1, "b": [10, 20], "c": {"nested": true}}'::JSON AS payload

test/integration/api_configuration/sqls/json_demo.yaml

@@ -0,0 +1,16 @@
+# Reproduces issue #38: a DuckDB JSON-aliased VARCHAR column must serialise
+# as nested JSON, not as a JSON-escaped string the caller has to parse a
+# second time. The endpoint returns the literal payload from the issue's
+# reproduction so a test can assert on the structure directly.
+url-path: /json-demo/
+method: GET
+
+template-source: json_demo.sql
+
+# A connection is required by the endpoint loader; the SQL itself does not
+# touch the connection, so the existing parquet connection works.
+connection:
+  - data-types-parquet
+
+auth:
+  enabled: false

test/integration/test_json_column.tavern.yaml

@@ -0,0 +1,26 @@
+# Regression test for issue #38:
+# A column declared as DuckDB's JSON logical type must appear in the HTTP
+# response body as a nested JSON object, not as a JSON-escaped string.
+test_name: JSON-aliased VARCHAR columns are returned as nested JSON
+
+stages:
+  - name: GET /json-demo embeds payload as a nested object
+    request:
+      url: "{base_url}/json-demo/"
+      method: GET
+    response:
+      status_code: 200
+      headers:
+        content-type: application/json
+      json:
+        data:
+          - id: 1
+            payload:
+              a: 1
+              b:
+                - 10
+                - 20
+              c:
+                nested: true
+        next: !anything
+        total_count: !anything