Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(elasticsearch): handle JSON array responses from _cat APIs (#19050)

Danny Xuc35d3dab7f6c
diff --git a/backend/plugin/db/elasticsearch/elasticsearch.go b/backend/plugin/db/elasticsearch/elasticsearch.go
index 53e298c9c8..478529bf2b 100644
--- a/backend/plugin/db/elasticsearch/elasticsearch.go
+++ b/backend/plugin/db/elasticsearch/elasticsearch.go
@@ -467,17 +467,41 @@ func (d *Driver) QueryConn(_ context.Context, _ *sql.Conn, statement string, _ d
switch {
case strings.Contains(contentType, "application/json"):
- pairs := map[string]any{}
- if err := json.Unmarshal(respBytes, &pairs); err != nil {
+ // ElasticSearch/OpenSearch REST APIs return two types of JSON responses:
+ // 1. Objects (most APIs): {"took":5,"hits":{...}}
+ // 2. Arrays (_cat APIs with format=json): [{"index":"test",...}]
+ // They never return primitive types (strings, numbers, booleans, null).
+
+ // First unmarshal into any to determine the JSON type
+ var data any
+ if err := json.Unmarshal(respBytes, &data); err != nil {
return errors.Wrapf(err, "failed to parse json body")
}
- for key, val := range pairs {
- result.ColumnNames = append(result.ColumnNames, key)
- bytes, err := json.Marshal(val)
+
+ // Handle based on the actual type
+ switch v := data.(type) {
+ case map[string]any:
+ // Object response: create one column per key
+ for key, val := range v {
+ result.ColumnNames = append(result.ColumnNames, key)
+ bytes, err := json.Marshal(val)
+ if err != nil {
+ return err
+ }
+ row.Values = append(row.Values, &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: string(bytes)}})
+ }
+ case []any:
+ // Array response (e.g., _cat APIs with format=json): create a single column with array data
+ result.ColumnNames = append(result.ColumnNames, "result")
+ bytes, err := json.Marshal(v)
if err != nil {
return err
}
row.Values = append(row.Values, &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: string(bytes)}})
+ default:
+ // ElasticSearch/OpenSearch APIs only return objects or arrays, never primitives.
+ // If we get here, something unexpected happened.
+ return errors.Errorf("unexpected JSON type: %T (expected object or array)", v)
}
case strings.Contains(contentType, "text/plain"):
result.ColumnNames = append(result.ColumnNames, "text/plain")
diff --git a/backend/plugin/db/elasticsearch/elasticsearch_test.go b/backend/plugin/db/elasticsearch/elasticsearch_test.go
index b4d3a9c94b..7cc6c581dd 100644
--- a/backend/plugin/db/elasticsearch/elasticsearch_test.go
+++ b/backend/plugin/db/elasticsearch/elasticsearch_test.go
@@ -2,6 +2,7 @@ package elasticsearch
import (
"context"
+ "encoding/json"
"net/url"
"strings"
"testing"
@@ -123,3 +124,81 @@ func TestURLConstructionWithQueryParams(t *testing.T) {
})
}
}
+
+func TestJSONParsing(t *testing.T) {
+ testCases := []struct {
+ name string
+ jsonData string
+ wantColumns []string
+ wantErr bool
+ }{
+ {
+ name: "JSON object response",
+ jsonData: `{"took":5,"hits":{"total":100}}`,
+ wantColumns: []string{"took", "hits"},
+ wantErr: false,
+ },
+ {
+ name: "JSON array response (from _cat API)",
+ jsonData: `[{"health":"yellow","status":"open"},{"health":"green","status":"open"}]`,
+ wantColumns: []string{"result"},
+ wantErr: false,
+ },
+ {
+ name: "invalid JSON",
+ jsonData: `{invalid`,
+ wantErr: true,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ respBytes := []byte(tc.jsonData)
+
+ // Simulate the parsing logic from QueryConn
+ var columnNames []string
+
+ // Unmarshal into any to determine type
+ var data any
+ err := json.Unmarshal(respBytes, &data)
+ if err != nil {
+ if !tc.wantErr {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ return
+ }
+
+ if tc.wantErr {
+ t.Fatal("expected error but got none")
+ }
+
+ // Handle based on type (same logic as QueryConn)
+ switch v := data.(type) {
+ case map[string]any:
+ // Object case
+ for key := range v {
+ columnNames = append(columnNames, key)
+ }
+ case []any:
+ // Array case
+ columnNames = append(columnNames, "result")
+ }
+
+ // Verify column count matches
+ assert.Equal(t, len(tc.wantColumns), len(columnNames),
+ "number of columns should match")
+
+ // For object responses, verify all expected columns exist
+ // (order may vary due to map iteration)
+ if len(tc.wantColumns) > 1 {
+ for _, expected := range tc.wantColumns {
+ assert.Contains(t, columnNames, expected,
+ "should contain expected column")
+ }
+ } else {
+ // For single column (array case), verify exact match
+ assert.Equal(t, tc.wantColumns, columnNames)
+ }
+ })
+ }
+}