You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by ke...@apache.org on 2025/10/01 12:53:21 UTC
(skywalking-banyandb) 02/04: stream query ok
This is an automated email from the ASF dual-hosted git repository.
kezhenxu94 pushed a commit to branch ql
in repository https://gitbox.apache.org/repos/asf/skywalking-banyandb.git
commit b91e936795438f0f7592ed591c1154a5e900b825
Author: kezhenxu94 <ke...@apache.org>
AuthorDate: Fri Sep 19 16:44:32 2025 +0800
stream query ok
---
bydbctl/internal/cmd/bydbql.go | 40 ++--
bydbctl/internal/cmd/bydbql_test.go | 438 ++++++++++++++++--------------------
bydbctl/internal/cmd/rest.go | 4 +-
bydbctl/internal/cmd/stream_test.go | 1 +
pkg/bydbql/bydbql_test.go | 67 ++++--
pkg/bydbql/translator.go | 83 ++++---
6 files changed, 315 insertions(+), 318 deletions(-)
diff --git a/bydbctl/internal/cmd/bydbql.go b/bydbctl/internal/cmd/bydbql.go
index 67545eae..387898d7 100644
--- a/bydbctl/internal/cmd/bydbql.go
+++ b/bydbctl/internal/cmd/bydbql.go
@@ -28,6 +28,7 @@ import (
"github.com/go-resty/resty/v2"
"github.com/spf13/cobra"
"github.com/spf13/viper"
+
"sigs.k8s.io/yaml"
"github.com/apache/skywalking-banyandb/pkg/bydbql"
@@ -36,10 +37,10 @@ import (
// BydbQL endpoint paths
const (
- streamQueryPath = "/api/v1/stream/query"
- measureQueryPath = "/api/v1/measure/query"
- traceQueryPath = "/api/v1/trace/query"
- propertyQueryPath = "/api/v1/property/query"
+ streamQueryPath = "/api/v1/stream/data"
+ measureQueryPath = "/api/v1/measure/data"
+ traceQueryPath = "/api/v1/trace/data"
+ propertyQueryPath = "/api/v1/property/data/query"
topnQueryPath = "/api/v1/measure/topn"
)
@@ -228,22 +229,21 @@ func executeBydbQLQuery(query string) error {
if err != nil {
return fmt.Errorf("translation error: %w", err)
}
- fmt.Printf("Translated YAML:\n%s\n", yamlData)
// Convert to JSON for REST API
- jsonData, err := json.Marshal(yamlData)
- if err != nil {
- return fmt.Errorf("JSON conversion error: %w", err)
- }
-
- // Determine endpoint based on query type
+ // jsonData, err := json.Marshal(yamlData)
+ // if err != nil {
+ // return fmt.Errorf("JSON conversion error: %w", err)
+ // }
+ //
+ // // Determine endpoint based on query type
endpoint, err := determineEndpoint(parsed)
if err != nil {
return err
}
// Execute the query via REST API
- return executeRESTQuery(endpoint, jsonData)
+ return executeRESTQuery(endpoint, yamlData)
}
// determineEndpoint determines the REST endpoint based on query type
@@ -279,18 +279,21 @@ func determineEndpoint(parsed *bydbql.ParsedQuery) (string, error) {
}
// executeRESTQuery executes the query via REST API
-func executeRESTQuery(endpoint string, jsonData []byte) error {
- // Create REST request using existing infrastructure
- reqBodyData := reqBody{
- data: jsonData,
- }
-
+func executeRESTQuery(endpoint string, jsonData map[string]any) error {
// Use existing rest function with appropriate parameters
return rest(
func() ([]reqBody, error) {
+ data, err := json.Marshal(jsonData)
+ if err != nil {
+ return nil, fmt.Errorf("JSON conversion error: %w", err)
+ }
+
+ reqBodyData := reqBody{data: data}
+
return []reqBody{reqBodyData}, nil
},
func(req request) (*resty.Response, error) {
+ fmt.Printf("Executing query at endpoint %s\n", string(req.data))
url := viper.GetString("addr") + endpoint
resp, err := req.req.
SetHeader("Content-Type", "application/json").
@@ -375,4 +378,3 @@ func printQueryResult(data []byte) error {
fmt.Print(string(yamlData))
return nil
}
-
diff --git a/bydbctl/internal/cmd/bydbql_test.go b/bydbctl/internal/cmd/bydbql_test.go
index 1b13e792..361d286d 100644
--- a/bydbctl/internal/cmd/bydbql_test.go
+++ b/bydbctl/internal/cmd/bydbql_test.go
@@ -15,27 +15,208 @@
// specific language governing permissions and limitations
// under the License.
-package cmd
+package cmd_test
import (
- "bytes"
+ "fmt"
"strings"
+ "time"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
"github.com/spf13/cobra"
- "github.com/spf13/viper"
"github.com/zenizh/go-capturer"
- "sigs.k8s.io/yaml"
+ grpclib "google.golang.org/grpc"
+ "google.golang.org/grpc/credentials/insecure"
- "github.com/apache/skywalking-banyandb/pkg/bydbql"
+ streamv1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/stream/v1"
+ "github.com/apache/skywalking-banyandb/bydbctl/internal/cmd"
"github.com/apache/skywalking-banyandb/pkg/test/flags"
+ "github.com/apache/skywalking-banyandb/pkg/test/helpers"
"github.com/apache/skywalking-banyandb/pkg/test/setup"
+ cases_stream_data "github.com/apache/skywalking-banyandb/test/cases/stream/data"
)
-const httpSchema = "http://"
+var _ = Describe("BydbQL Stream Query", func() {
+ var addr, grpcAddr string
+ var deferFunc func()
+ var rootCmd *cobra.Command
+ var now time.Time
+ var nowStr, endStr string
+ var interval time.Duration
+
+ BeforeEach(func() {
+ var err error
+ now, err = time.ParseInLocation("2006-01-02T15:04:05", "2021-09-01T23:30:00", time.Local)
+ Expect(err).NotTo(HaveOccurred())
+ nowStr = now.Format(time.RFC3339)
+ interval = 500 * time.Millisecond
+ endStr = now.Add(1 * time.Hour).Format(time.RFC3339)
+ grpcAddr, addr, deferFunc = setup.Standalone()
+ addr = httpSchema + addr
+ rootCmd = &cobra.Command{Use: "root"}
+ cmd.RootCmdFlags(rootCmd)
+ })
+
+ It("executes stream query with BydbQL", func() {
+ conn, err := grpclib.NewClient(
+ grpcAddr,
+ grpclib.WithTransportCredentials(insecure.NewCredentials()),
+ )
+ Expect(err).NotTo(HaveOccurred())
+
+ // Write test data
+ cases_stream_data.Write(conn, "sw", now, interval)
+
+ // Test BydbQL query execution
+ rootCmd.SetArgs([]string{"bydbql", "query", "-a", addr, "-f", "-"})
+ issue := func() string {
+ rootCmd.SetIn(strings.NewReader(fmt.Sprintf(`
+SELECT trace_id FROM STREAM sw in (default) TIME BETWEEN '%s' AND '%s'`, nowStr, endStr)))
+ return capturer.CaptureStdout(func() {
+ err := rootCmd.Execute()
+ if err != nil {
+ GinkgoWriter.Printf("execution fails:%v", err)
+ }
+ })
+ }
+ Eventually(issue, flags.EventuallyTimeout).ShouldNot(ContainSubstring("code:"))
+ Eventually(func() int {
+ out := issue()
+ resp := new(streamv1.QueryResponse)
+ helpers.UnmarshalYAML([]byte(out), resp)
+ GinkgoWriter.Println(resp)
+ return len(resp.Elements)
+ }, flags.EventuallyTimeout).Should(Equal(5))
+ })
+
+ It("executes stream query with WHERE condition", func() {
+ conn, err := grpclib.NewClient(
+ grpcAddr,
+ grpclib.WithTransportCredentials(insecure.NewCredentials()),
+ )
+ Expect(err).NotTo(HaveOccurred())
+
+ // Write test data
+ cases_stream_data.Write(conn, "sw", now, interval)
+
+ // Test BydbQL query with WHERE condition
+ rootCmd.SetArgs([]string{"bydbql", "query", "-a", addr, "-f", "-"})
+ issue := func() string {
+ rootCmd.SetIn(strings.NewReader(fmt.Sprintf(`
+SELECT trace_id FROM STREAM sw in (default) WHERE trace_id = 'trace-1' TIME BETWEEN '%s' AND '%s' LIMIT 10`, nowStr, endStr)))
+ return capturer.CaptureStdout(func() {
+ err := rootCmd.Execute()
+ if err != nil {
+ GinkgoWriter.Printf("execution fails:%v", err)
+ }
+ })
+ }
+ Eventually(issue, flags.EventuallyTimeout).ShouldNot(ContainSubstring("code:"))
+ Eventually(func() int {
+ out := issue()
+ resp := new(streamv1.QueryResponse)
+ helpers.UnmarshalYAML([]byte(out), resp)
+ GinkgoWriter.Println(resp)
+ return len(resp.Elements)
+ }, time.Microsecond).Should(Equal(1))
+ })
+
+ It("executes stream query with relative time range", func() {
+ conn, err := grpclib.NewClient(
+ grpcAddr,
+ grpclib.WithTransportCredentials(insecure.NewCredentials()),
+ )
+ Expect(err).NotTo(HaveOccurred())
+
+ // Write test data
+ cases_stream_data.Write(conn, "sw", now, interval)
+
+ // Test BydbQL query with relative time range
+ rootCmd.SetArgs([]string{"bydbql", "query", "-a", addr, "-f", "-"})
+ issue := func() string {
+ rootCmd.SetIn(strings.NewReader(`
+SELECT trace_id FROM STREAM sw TIME > '-30m' LIMIT 10`))
+ return capturer.CaptureStdout(func() {
+ err := rootCmd.Execute()
+ if err != nil {
+ GinkgoWriter.Printf("execution fails:%v", err)
+ }
+ })
+ }
+ Eventually(issue, flags.EventuallyTimeout).ShouldNot(ContainSubstring("code:"))
+ Eventually(func() int {
+ out := issue()
+ resp := new(streamv1.QueryResponse)
+ helpers.UnmarshalYAML([]byte(out), resp)
+ GinkgoWriter.Println(resp)
+ return len(resp.Elements)
+ }, flags.EventuallyTimeout).Should(Equal(5))
+ })
+
+ It("executes stream query with multiple projections", func() {
+ conn, err := grpclib.NewClient(
+ grpcAddr,
+ grpclib.WithTransportCredentials(insecure.NewCredentials()),
+ )
+ Expect(err).NotTo(HaveOccurred())
+
+ // Write test data
+ cases_stream_data.Write(conn, "sw", now, interval)
+
+ // Test BydbQL query with multiple projections
+ rootCmd.SetArgs([]string{"bydbql", "query", "-a", addr, "-f", "-"})
+ issue := func() string {
+ rootCmd.SetIn(strings.NewReader(fmt.Sprintf(`
+SELECT trace_id, service_id FROM STREAM sw TIME BETWEEN '%s' AND '%s' LIMIT 10`, nowStr, endStr)))
+ return capturer.CaptureStdout(func() {
+ err := rootCmd.Execute()
+ if err != nil {
+ GinkgoWriter.Printf("execution fails:%v", err)
+ }
+ })
+ }
+ Eventually(issue, flags.EventuallyTimeout).ShouldNot(ContainSubstring("code:"))
+ Eventually(func() int {
+ out := issue()
+ resp := new(streamv1.QueryResponse)
+ helpers.UnmarshalYAML([]byte(out), resp)
+ GinkgoWriter.Println(resp)
+ return len(resp.Elements)
+ }, flags.EventuallyTimeout).Should(Equal(5))
+ })
+
+ It("handles invalid BydbQL syntax", func() {
+ conn, err := grpclib.NewClient(
+ grpcAddr,
+ grpclib.WithTransportCredentials(insecure.NewCredentials()),
+ )
+ Expect(err).NotTo(HaveOccurred())
+
+ // Write test data
+ cases_stream_data.Write(conn, "sw", now, interval)
+
+ // Test invalid BydbQL query
+ rootCmd.SetArgs([]string{"bydbql", "query", "-a", addr, "-f", "-"})
+ issue := func() string {
+ rootCmd.SetIn(strings.NewReader(`
+SELECT FROM STREAM sw`))
+ return capturer.CaptureStderr(func() {
+ err := rootCmd.Execute()
+ if err != nil {
+ GinkgoWriter.Printf("execution fails:%v", err)
+ }
+ })
+ }
+ Eventually(issue, flags.EventuallyTimeout).Should(ContainSubstring("parsing errors"))
+ })
+
+ AfterEach(func() {
+ deferFunc()
+ })
+})
-var _ = Describe("BydbQL Command", func() {
+var _ = Describe("BydbQL Command Structure", func() {
var addr string
var deferFunc func()
var rootCmd *cobra.Command
@@ -44,14 +225,9 @@ var _ = Describe("BydbQL Command", func() {
_, addr, deferFunc = setup.EmptyStandalone()
addr = httpSchema + addr
- // Reset viper for clean test state
- viper.Reset()
- viper.Set("addr", addr)
- viper.Set("group", "default")
-
// Create root command with all subcommands
rootCmd = &cobra.Command{Use: "root"}
- RootCmdFlags(rootCmd)
+ cmd.RootCmdFlags(rootCmd)
})
AfterEach(func() {
@@ -82,85 +258,10 @@ var _ = Describe("BydbQL Command", func() {
}
Expect(subCommandNames).To(ContainElements("interactive", "query"))
})
-})
-
-var _ = Describe("Endpoint Determination", func() {
- DescribeTable("determines correct endpoint for different query types",
- func(query, expectedEndpoint string) {
- parsed, errors := bydbql.ParseQuery(query)
- Expect(errors).To(BeEmpty())
-
- endpoint, err := determineEndpoint(parsed)
- Expect(err).NotTo(HaveOccurred())
- Expect(endpoint).To(Equal(expectedEndpoint))
- },
- Entry("stream query", "SELECT * FROM STREAM sw", streamQueryPath),
- Entry("measure query", "SELECT * FROM MEASURE metrics", measureQueryPath),
- Entry("trace query", "SELECT * FROM TRACE traces", traceQueryPath),
- Entry("property query", "SELECT * FROM PROPERTY props", propertyQueryPath),
- Entry("top-n query", "SHOW TOP 10 FROM MEASURE metrics", topnQueryPath),
- )
-})
-
-var _ = Describe("Query Execution Parse Errors", func() {
- DescribeTable("handles parsing errors correctly",
- func(query string) {
- err := executeBydbQLQuery(query)
- Expect(err).To(HaveOccurred())
- Expect(err.Error()).To(ContainSubstring("parsing errors"))
- },
- Entry("incomplete SELECT", "SELECT"),
- Entry("missing resource", "SELECT * FROM"),
- Entry("missing N in TOP", "SHOW TOP FROM MEASURE metrics"),
- )
-})
-
-var _ = Describe("Valid Query Parsing", func() {
- DescribeTable("parses valid queries correctly",
- func(query string) {
- // Parse and validate query structure
- parsed, errors := bydbql.ParseQuery(query)
- Expect(errors).To(BeEmpty())
- Expect(parsed).NotTo(BeNil())
-
- // Validate endpoint determination
- _, err := determineEndpoint(parsed)
- Expect(err).NotTo(HaveOccurred())
- },
- Entry("stream query", "SELECT * FROM STREAM sw"),
- Entry("measure query with aggregation", "SELECT region, SUM(latency) FROM MEASURE metrics GROUP BY region"),
- Entry("top-n query", "SHOW TOP 10 FROM MEASURE service_latency ORDER BY value DESC"),
- Entry("trace query with condition", "SELECT * FROM TRACE traces WHERE status = 'error'"),
- Entry("property query with condition", "SELECT ip, owner FROM PROPERTY metadata WHERE datacenter = 'dc-1'"),
- )
-})
-
-var _ = Describe("Help Command", func() {
- var addr string
- var deferFunc func()
- var rootCmd *cobra.Command
-
- BeforeEach(func() {
- _, addr, deferFunc = setup.EmptyStandalone()
- addr = httpSchema + addr
-
- // Reset viper for clean test state
- viper.Reset()
- viper.Set("addr", addr)
- viper.Set("group", "default")
-
- // Create root command with all subcommands
- rootCmd = &cobra.Command{Use: "root"}
- RootCmdFlags(rootCmd)
- })
-
- AfterEach(func() {
- deferFunc()
- })
It("displays help information correctly", func() {
// Capture help output
- var output bytes.Buffer
+ var output strings.Builder
rootCmd.SetOut(&output)
// Execute help for bydbql command
@@ -184,162 +285,3 @@ var _ = Describe("Help Command", func() {
}
})
})
-
-var _ = Describe("BydbQL Integration", func() {
- DescribeTable("full pipeline processing",
- func(query string, resourceType bydbql.ResourceType) {
- // Step 1: Parse query
- parsed, errors := bydbql.ParseQuery(query)
- Expect(errors).To(BeEmpty())
- Expect(parsed).NotTo(BeNil())
-
- // Step 2: Validate resource type detection
- if parsed.ResourceType != resourceType {
- // For auto-detected resource types, this might be expected
- GinkgoWriter.Printf("Resource type: expected %s, got %s (may be auto-detected)",
- resourceType.String(), parsed.ResourceType.String())
- }
-
- // Step 3: Translate to YAML
- context := &bydbql.QueryContext{
- DefaultGroup: "default",
- }
- translator := bydbql.NewTranslator(context)
- yamlData, err := translator.TranslateToYAML(parsed)
- Expect(err).NotTo(HaveOccurred())
- Expect(yamlData).NotTo(BeEmpty())
-
- // Step 4: Determine correct endpoint
- endpoint, err := determineEndpoint(parsed)
- Expect(err).NotTo(HaveOccurred())
-
- // Step 5: Validate endpoint matches expected resource type
- expectedEndpoints := map[bydbql.ResourceType]string{
- bydbql.ResourceTypeStream: streamQueryPath,
- bydbql.ResourceTypeMeasure: measureQueryPath,
- bydbql.ResourceTypeTrace: traceQueryPath,
- bydbql.ResourceTypeProperty: propertyQueryPath,
- }
-
- // For Top-N queries, always use measure endpoint
- if _, isTopN := parsed.Statement.(*bydbql.TopNStatement); isTopN {
- Expect(endpoint).To(Equal(topnQueryPath))
- } else if expectedEndpoint, ok := expectedEndpoints[resourceType]; ok {
- Expect(endpoint).To(Equal(expectedEndpoint))
- }
-
- // Step 6: Validate YAML structure
- var yamlMap map[string]interface{}
- err = yaml.Unmarshal(yamlData, &yamlMap)
- Expect(err).NotTo(HaveOccurred())
-
- // Basic validation: should have name or resource identifier
- Expect(yamlMap["Name"] != nil || yamlMap["topN"] != nil).To(BeTrue())
-
- GinkgoWriter.Printf("Successfully processed query: %s", query)
- GinkgoWriter.Printf("Generated YAML length: %d bytes", len(yamlData))
- GinkgoWriter.Printf("Target endpoint: %s", endpoint)
- },
- Entry("stream query full pipeline",
- "SELECT trace_id, service_id FROM STREAM sw WHERE service_id = 'webapp' TIME > '-30m' LIMIT 100",
- bydbql.ResourceTypeStream),
- Entry("measure query full pipeline",
- "SELECT region, AVG(latency) FROM MEASURE service_metrics WHERE service = 'auth' GROUP BY region",
- bydbql.ResourceTypeMeasure),
- Entry("topn query full pipeline",
- "SHOW TOP 5 FROM MEASURE error_count WHERE status_code = '500'",
- bydbql.ResourceTypeMeasure),
- Entry("trace query full pipeline",
- "SELECT * FROM TRACE app_traces WHERE operation_name = 'GET /api/users' TIME BETWEEN '-1h' AND 'now'",
- bydbql.ResourceTypeTrace),
- Entry("property query full pipeline",
- "SELECT ip, region FROM PROPERTY server_info WHERE ID = 'server-1'",
- bydbql.ResourceTypeProperty),
- )
-})
-
-var _ = Describe("Command Line Flags", func() {
- var addr string
- var deferFunc func()
- var rootCmd *cobra.Command
-
- BeforeEach(func() {
- _, addr, deferFunc = setup.EmptyStandalone()
- addr = httpSchema + addr
-
- // Reset viper for clean test state
- viper.Reset()
- viper.Set("addr", addr)
- viper.Set("group", "default")
-
- // Create root command with all subcommands
- rootCmd = &cobra.Command{Use: "root"}
- RootCmdFlags(rootCmd)
- })
-
- AfterEach(func() {
- deferFunc()
- })
-
- DescribeTable("handles command line flags correctly",
- func(args []string, expectError bool) {
- // Prepend "bydbql" to the args since we're testing the bydbql subcommand
- fullArgs := append([]string{"bydbql"}, args...)
- rootCmd.SetArgs(fullArgs)
-
- // We're testing command structure, not execution
- // So we expect parsing to succeed even if execution might fail
- err := rootCmd.ParseFlags(fullArgs)
-
- if expectError {
- Expect(err).To(HaveOccurred())
- } else {
- Expect(err).NotTo(HaveOccurred())
- }
- },
- Entry("valid query command with file", []string{"query", "-f", "test.sql"}, false),
- Entry("valid interactive command", []string{"interactive"}, false),
- Entry("alias i for interactive", []string{"i"}, false),
- )
-})
-
-var _ = Describe("BydbQL Query Execution", func() {
- var addr string
- var deferFunc func()
- var rootCmd *cobra.Command
-
- BeforeEach(func() {
- _, addr, deferFunc = setup.EmptyStandalone()
- addr = httpSchema + addr
-
- // Reset viper for clean test state
- viper.Reset()
- viper.Set("addr", addr)
- viper.Set("group", "default")
-
- // Create root command with all subcommands
- rootCmd = &cobra.Command{Use: "root"}
- RootCmdFlags(rootCmd)
- })
-
- AfterEach(func() {
- deferFunc()
- })
-
- It("executes simple query successfully", func() {
- // Test a simple query execution
- rootCmd.SetArgs([]string{"bydbql", "query", "-f", "-"})
- rootCmd.SetIn(strings.NewReader("SELECT * FROM STREAM sw LIMIT 1"))
-
- executeQuery := func() string {
- return capturer.CaptureStdout(func() {
- err := rootCmd.Execute()
- if err != nil {
- GinkgoWriter.Printf("execution fails: %v", err)
- }
- })
- }
-
- Eventually(executeQuery, flags.EventuallyTimeout).ShouldNot(ContainSubstring("error"))
- })
-})
diff --git a/bydbctl/internal/cmd/rest.go b/bydbctl/internal/cmd/rest.go
index 3608128f..10af7be7 100644
--- a/bydbctl/internal/cmd/rest.go
+++ b/bydbctl/internal/cmd/rest.go
@@ -203,8 +203,8 @@ func parseTimeRangeFromFlagAndYAML(reader io.Reader) (requests []reqBody, err er
}
startTS = endTS.Add(-timeRange)
}
- s := startTS.Format(time.RFC3339)
- e := endTS.Format(time.RFC3339)
+ s := startTS.Format("2006-01-02T15:04:05-07:00")
+ e := endTS.Format("2006-01-02T15:04:05-07:00")
var rawRequests []reqBody
if rawRequests, err = parseNameAndGroupFromYAML(reader); err != nil {
return nil, err
diff --git a/bydbctl/internal/cmd/stream_test.go b/bydbctl/internal/cmd/stream_test.go
index 4423e134..687e396b 100644
--- a/bydbctl/internal/cmd/stream_test.go
+++ b/bydbctl/internal/cmd/stream_test.go
@@ -237,6 +237,7 @@ projection:
Eventually(issue, flags.EventuallyTimeout).ShouldNot(ContainSubstring("code:"))
Eventually(func() int {
out := issue()
+ GinkgoWriter.Println(out)
resp := new(streamv1.QueryResponse)
helpers.UnmarshalYAML([]byte(out), resp)
GinkgoWriter.Println(resp)
diff --git a/pkg/bydbql/bydbql_test.go b/pkg/bydbql/bydbql_test.go
index 57e8d8f8..d993b085 100644
--- a/pkg/bydbql/bydbql_test.go
+++ b/pkg/bydbql/bydbql_test.go
@@ -202,31 +202,31 @@ var _ = Describe("Translator", func() {
Entry("simple stream query",
"SELECT * FROM STREAM sw",
func(data map[string]any) bool {
- return data["Name"] == "sw"
+ return data["name"] == "sw"
}),
Entry("measure query with aggregation",
"SELECT region, SUM(latency) FROM MEASURE metrics GROUP BY region",
func(data map[string]any) bool {
- agg, ok := data["Agg"].(map[string]any)
- return ok && agg["Function"] == "SUM" && agg["FieldName"] == "latency"
+ agg, ok := data["agg"].(map[string]any)
+ return ok && agg["function"] == "SUM" && agg["field_name"] == "latency"
}),
Entry("time range query",
"SELECT * FROM STREAM sw TIME BETWEEN '2023-01-01T00:00:00Z' AND '2023-01-02T00:00:00Z'",
func(data map[string]any) bool {
- timeRange, ok := data["TimeRange"].(map[string]any)
- return ok && timeRange["Begin"] == "2023-01-01T00:00:00Z" &&
- timeRange["End"] == "2023-01-02T00:00:00Z"
+ timeRange, ok := data["timeRange"].(map[string]any)
+ return ok && timeRange["begin"] == "2023-01-01T00:00:00Z" &&
+ timeRange["end"] == "2023-01-02T00:00:00Z"
}),
Entry("relative time query",
"SELECT * FROM STREAM sw TIME > '-30m'",
func(data map[string]any) bool {
- timeRange, ok := data["TimeRange"].(map[string]any)
- return ok && timeRange["Begin"] != nil && timeRange["End"] != nil
+ timeRange, ok := data["timeRange"].(map[string]any)
+ return ok && timeRange["begin"] != nil && timeRange["end"] != nil
}),
Entry("WHERE clause with criteria",
"SELECT * FROM STREAM sw WHERE service_id = 'webapp'",
func(data map[string]any) bool {
- criteria, ok := data["Criteria"].([]any)
+ criteria, ok := data["criteria"].([]any)
if !ok || len(criteria) == 0 {
return false
}
@@ -236,20 +236,49 @@ var _ = Describe("Translator", func() {
Entry("TOP N query",
"SHOW TOP 10 FROM MEASURE service_latency ORDER BY value DESC",
func(data map[string]any) bool {
- topN := data["TopN"]
- fieldValueSort := data["FieldValueSort"]
- return topN == float64(10) && fieldValueSort == "DESC"
+ topN := data["top_n"]
+ fieldValueSort := data["field_value_sort"]
+ return topN == 10 && fieldValueSort == "DESC"
}),
Entry("property query with IDs",
"SELECT * FROM PROPERTY metadata WHERE ID = 'id1' OR ID = 'id2'",
func(data map[string]any) bool {
- criteria, ok := data["Criteria"].([]any)
+ criteria, ok := data["criteria"].([]any)
return ok && len(criteria) == 2
}),
Entry("query trace enabled",
"SELECT * FROM STREAM sw WITH QUERY_TRACE",
func(data map[string]any) bool {
- return data["Trace"] == true
+ return data["trace"] == true
+ }),
+ Entry("stream query with projection tagFamilies format",
+ "SELECT trace_id FROM STREAM sw",
+ func(data map[string]any) bool {
+ // Verify that projection is translated to tagFamilies format with snake_case
+ projection, ok := data["projection"].(map[string]any)
+ if !ok {
+ return false
+ }
+ tagFamiliesRaw := projection["tagFamilies"]
+ tagFamilies, ok := tagFamiliesRaw.([]interface{})
+ if !ok || len(tagFamilies) == 0 {
+ return false
+ }
+ tagFamily, ok := tagFamilies[0].(map[string]interface{})
+ if !ok {
+ return false
+ }
+ name, ok := tagFamily["name"].(string)
+ if !ok || name != "searchable" {
+ return false
+ }
+ tagsRaw := tagFamily["tags"]
+ tags, ok := tagsRaw.([]interface{})
+ if !ok || len(tags) == 0 {
+ return false
+ }
+ tag, ok := tags[0].(string)
+ return ok && tag == "trace_id"
}),
)
})
@@ -370,15 +399,15 @@ var _ = Describe("Time Format Parsing", func() {
Entry("absolute time range",
"BETWEEN '2023-01-01T10:00:00Z' AND '2023-01-01T11:00:00Z'",
func(data map[string]any) bool {
- timeRange, ok := data["TimeRange"].(map[string]any)
- return ok && timeRange["Begin"] == "2023-01-01T10:00:00Z" &&
- timeRange["End"] == "2023-01-01T11:00:00Z"
+ timeRange, ok := data["timeRange"].(map[string]any)
+ return ok && timeRange["begin"] == "2023-01-01T10:00:00Z" &&
+ timeRange["end"] == "2023-01-01T11:00:00Z"
}),
Entry("relative time condition",
"> '-30m'",
func(data map[string]any) bool {
- timeRange, ok := data["TimeRange"].(map[string]any)
- return ok && timeRange["Begin"] != nil && timeRange["End"] != nil
+ timeRange, ok := data["timeRange"].(map[string]any)
+ return ok && timeRange["begin"] != nil && timeRange["end"] != nil
}),
)
})
diff --git a/pkg/bydbql/translator.go b/pkg/bydbql/translator.go
index ca41b8fd..df25f9eb 100644
--- a/pkg/bydbql/translator.go
+++ b/pkg/bydbql/translator.go
@@ -24,38 +24,38 @@ import (
"time"
str2duration "github.com/xhit/go-str2duration/v2"
- "sigs.k8s.io/yaml"
+ "gopkg.in/yaml.v3"
)
// QueryYAML represents the YAML structure for BanyanDB queries
type QueryYAML struct {
// Common fields
- Name string `yaml:"name,omitempty"`
- Groups []string `yaml:"groups,omitempty"`
- TimeRange *TimeRangeYAML `yaml:"timeRange,omitempty"`
- Criteria []map[string]interface{} `yaml:"criteria,omitempty"`
- Limit *int `yaml:"limit,omitempty"`
- Offset *int `yaml:"offset,omitempty"`
- Trace bool `yaml:"trace,omitempty"`
+ Name string `yaml:"name,omitempty" json:"name,omitempty"`
+ Groups []string `yaml:"groups,omitempty" json:"groups,omitempty"`
+ TimeRange *TimeRangeYAML `yaml:"timeRange,omitempty" json:"timeRange,omitempty"`
+ Criteria []map[string]interface{} `yaml:"criteria,omitempty" json:"criteria,omitempty"`
+ Limit *int `yaml:"limit,omitempty" json:"limit,omitempty"`
+ Offset *int `yaml:"offset,omitempty" json:"offset,omitempty"`
+ Trace bool `yaml:"trace,omitempty" json:"trace,omitempty"`
// Stream/Trace specific
- Projection []string `yaml:"projection,omitempty"`
- OrderBy *OrderByYAML `yaml:"orderBy,omitempty"`
+ Projection interface{} `yaml:"projection,omitempty" json:"projection,omitempty"`
+ OrderBy *OrderByYAML `yaml:"order_by,omitempty" json:"order_by,omitempty"`
// Measure specific
- TagProjection []string `yaml:"tagProjection,omitempty"`
- FieldProjection []string `yaml:"fieldProjection,omitempty"`
- GroupBy *GroupByYAML `yaml:"groupBy,omitempty"`
- Agg *AggregationYAML `yaml:"agg,omitempty"`
- Top *TopYAML `yaml:"top,omitempty"`
+ TagProjection []string `yaml:"tag_projection,omitempty" json:"tag_projection,omitempty"`
+ FieldProjection []string `yaml:"field_projection,omitempty" json:"field_projection,omitempty"`
+ GroupBy *GroupByYAML `yaml:"group_by,omitempty" json:"group_by,omitempty"`
+ Agg *AggregationYAML `yaml:"agg,omitempty" json:"agg,omitempty"`
+ Top *TopYAML `yaml:"top,omitempty" json:"top,omitempty"`
// Property specific
- IDs []string `yaml:"ids,omitempty"`
+ IDs []string `yaml:"ids,omitempty" json:"ids,omitempty"`
// Top-N specific (for separate endpoint)
- TopN int `yaml:"topN,omitempty"`
- FieldValueSort string `yaml:"fieldValueSort,omitempty"`
- Conditions []map[string]interface{} `yaml:"conditions,omitempty"`
+ TopN int `yaml:"top_n,omitempty" json:"top_n,omitempty"`
+ FieldValueSort string `yaml:"field_value_sort,omitempty" json:"field_value_sort,omitempty"`
+ Conditions []map[string]interface{} `yaml:"conditions,omitempty" json:"conditions,omitempty"`
}
// TimeRangeYAML represents time range in YAML
@@ -66,26 +66,37 @@ type TimeRangeYAML struct {
// OrderByYAML represents ORDER BY clause in YAML
type OrderByYAML struct {
- IndexRuleName string `yaml:"indexRuleName"`
+ IndexRuleName string `yaml:"index_rule_name"`
Sort string `yaml:"sort"` // ASC or DESC
}
// GroupByYAML represents GROUP BY clause in YAML
type GroupByYAML struct {
- TagProjection []string `yaml:"tagProjection"`
+ TagProjection []string `yaml:"tag_projection"`
+}
+
+// TagFamilyYAML represents a tag family in projection
+type TagFamilyYAML struct {
+ Name string `yaml:"name"`
+ Tags []string `yaml:"tags"`
+}
+
+// ProjectionYAML represents the projection structure for stream/trace queries
+type ProjectionYAML struct {
+ TagFamilies []TagFamilyYAML `yaml:"tagFamilies"`
}
// AggregationYAML represents aggregation function in YAML
type AggregationYAML struct {
- Function string `yaml:"function"`
- FieldName string `yaml:"fieldName"`
+ Function string `yaml:"function"`
+ FieldName string `yaml:"field_name"`
}
// TopYAML represents TOP N clause in YAML
type TopYAML struct {
- Number int `yaml:"number"`
- FieldName string `yaml:"fieldName"`
- FieldValueSort string `yaml:"fieldValueSort"`
+ Number int `yaml:"number"`
+ FieldName string `yaml:"field_name"`
+ FieldValueSort string `yaml:"field_value_sort"`
}
// Translator converts parsed BydbQL to YAML format
@@ -209,10 +220,20 @@ func (t *Translator) translateStreamOrTraceQuery(stmt *SelectStatement, yamlQuer
// SELECT * - no specific projection needed
} else if stmt.Projection.Empty {
// SELECT () - empty projection for traces
- yamlQuery.Projection = []string{}
+ yamlQuery.Projection = &ProjectionYAML{
+ TagFamilies: []TagFamilyYAML{},
+ }
} else if len(stmt.Projection.Columns) > 0 {
+ // Group columns by tag family (default to "searchable" for now)
+ tagFamily := TagFamilyYAML{
+ Name: "searchable",
+ Tags: make([]string, 0, len(stmt.Projection.Columns)),
+ }
for _, col := range stmt.Projection.Columns {
- yamlQuery.Projection = append(yamlQuery.Projection, col.Name)
+ tagFamily.Tags = append(tagFamily.Tags, col.Name)
+ }
+ yamlQuery.Projection = &ProjectionYAML{
+ TagFamilies: []TagFamilyYAML{tagFamily},
}
}
}
@@ -301,9 +322,11 @@ func (t *Translator) translateMeasureQuery(stmt *SelectStatement, yamlQuery *Que
func (t *Translator) translatePropertyQuery(stmt *SelectStatement, yamlQuery *QueryYAML) (*QueryYAML, error) {
// Translate projection
if stmt.Projection != nil && !stmt.Projection.All && len(stmt.Projection.Columns) > 0 {
+ projection := make([]string, 0, len(stmt.Projection.Columns))
for _, col := range stmt.Projection.Columns {
- yamlQuery.Projection = append(yamlQuery.Projection, col.Name)
+ projection = append(projection, col.Name)
}
+ yamlQuery.Projection = projection
}
// Extract IDs from WHERE clause if present
@@ -588,4 +611,4 @@ func TranslateQuery(query string, context *QueryContext) ([]byte, []string, erro
}
return yamlBytes, nil, nil
-}
\ No newline at end of file
+}