Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(cassandra): return materialized view definitions

t8y2f1b981bf0d97
diff --git a/agents/drivers/cassandra-go/integration_test.go b/agents/drivers/cassandra-go/integration_test.go
index 017c13097e..0172808822 100644
--- a/agents/drivers/cassandra-go/integration_test.go
+++ b/agents/drivers/cassandra-go/integration_test.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"os"
+ "sort"
"strconv"
"strings"
"testing"
@@ -42,7 +43,7 @@ func TestCassandraIntegration(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- defer runtime.close()
+ t.Cleanup(runtime.close)
server := newServer(runtime, connection)
if err := server.validateConnection(); err != nil {
t.Fatal(err)
@@ -54,7 +55,9 @@ func TestCassandraIntegration(t *testing.T) {
pagedTable := "paged_rows"
mustCQL(t, server, "CREATE KEYSPACE "+quoteCQLIdentifier(keyspace)+" WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}", "")
t.Cleanup(func() {
- _, _ = server.executeQuery(queryOptions{SQL: "DROP KEYSPACE IF EXISTS " + quoteCQLIdentifier(keyspace)})
+ if _, err := server.executeQuery(queryOptions{SQL: "DROP KEYSPACE IF EXISTS " + quoteCQLIdentifier(keyspace)}); err != nil {
+ t.Errorf("drop integration keyspace %s: %v", keyspace, err)
+ }
})
mustCQL(t, server, "CREATE TABLE "+qualifiedCQLName(keyspace, table)+" ("+
"id int PRIMARY KEY, txt text, flag boolean, amount decimal, payload blob, created timestamp, address inet, "+
@@ -139,6 +142,187 @@ func TestCassandraIntegration(t *testing.T) {
}
}
+func TestCassandraMaterializedViewDDLIntegration(t *testing.T) {
+ host := strings.TrimSpace(os.Getenv("CASSANDRA_TEST_HOST"))
+ if host == "" {
+ t.Skip("Cassandra integration environment is not configured")
+ }
+ port := 9042
+ if rawPort := strings.TrimSpace(os.Getenv("CASSANDRA_TEST_PORT")); rawPort != "" {
+ parsedPort, err := strconv.Atoi(rawPort)
+ if err != nil {
+ t.Fatal(err)
+ }
+ port = parsedPort
+ }
+ ssl, err := strconv.ParseBool(envDefault("CASSANDRA_TEST_SSL", "false"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ connection := connectParams{
+ Host: host,
+ Port: port,
+ Username: os.Getenv("CASSANDRA_TEST_USERNAME"),
+ Password: os.Getenv("CASSANDRA_TEST_PASSWORD"),
+ URLParams: os.Getenv("CASSANDRA_TEST_URL_PARAMS"),
+ SSL: ssl,
+ CACertPath: os.Getenv("CASSANDRA_TEST_CA_CERT_PATH"),
+ ClientCertPath: os.Getenv("CASSANDRA_TEST_CLIENT_CERT_PATH"),
+ ClientKeyPath: os.Getenv("CASSANDRA_TEST_CLIENT_KEY_PATH"),
+ }
+ runtime, err := newConnectionRuntime(connection)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(runtime.close)
+ server := newServer(runtime, connection)
+ if err := server.validateConnection(); err != nil {
+ t.Fatal(err)
+ }
+ connectionInfo, err := server.connectionInfo()
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("Cassandra runtime version: %v", connectionInfo["version"])
+
+ suffix := strconv.FormatInt(time.Now().UnixNano(), 36)
+ keyspace := "dbx_issue_7475_regression_" + suffix
+ baseTable := "BaseEvents"
+ view := "EventsByCategory"
+ allColumnsView := "AllEventsByCategory"
+ mustCQL(t, server, "CREATE KEYSPACE "+quoteCQLIdentifier(keyspace)+" WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}", "")
+ t.Cleanup(func() {
+ if _, err := server.executeQuery(queryOptions{SQL: "DROP KEYSPACE IF EXISTS " + quoteCQLIdentifier(keyspace)}); err != nil {
+ t.Errorf("drop integration keyspace %s: %v", keyspace, err)
+ }
+ })
+ mustCQL(t, server, "CREATE TABLE "+qualifiedCQLName(keyspace, baseTable)+" ("+
+ `"Tenant Id" text, "Bucket" int, "Event Time" timestamp, "Category" text, "Payload" text, `+
+ `PRIMARY KEY ("Tenant Id", "Event Time", "Bucket")) `+
+ `WITH CLUSTERING ORDER BY ("Event Time" DESC, "Bucket" ASC)`, keyspace)
+ mustCQL(t, server, "CREATE MATERIALIZED VIEW "+qualifiedCQLName(keyspace, view)+" AS "+
+ `SELECT "Tenant Id", "Bucket", "Event Time", "Category" FROM `+qualifiedCQLName(keyspace, baseTable)+" "+
+ `WHERE "Tenant Id" IS NOT NULL AND "Event Time" IS NOT NULL AND "Bucket" IS NOT NULL AND "Category" IS NOT NULL `+
+ `PRIMARY KEY (("Tenant Id", "Category"), "Event Time", "Bucket") `+
+ `WITH CLUSTERING ORDER BY ("Event Time" DESC, "Bucket" ASC) AND comment = 'issue 7475 round trip' AND gc_grace_seconds = 86401`, keyspace)
+ mustCQL(t, server, "CREATE MATERIALIZED VIEW "+qualifiedCQLName(keyspace, allColumnsView)+" AS "+
+ `SELECT * FROM `+qualifiedCQLName(keyspace, baseTable)+" "+
+ `WHERE "Tenant Id" IS NOT NULL AND "Event Time" IS NOT NULL AND "Bucket" IS NOT NULL AND "Category" IS NOT NULL `+
+ `PRIMARY KEY (("Tenant Id", "Category"), "Event Time", "Bucket") `+
+ `WITH CLUSTERING ORDER BY ("Event Time" DESC, "Bucket" ASC)`, keyspace)
+
+ ddl, err := server.getTableDDL(keyspace, view)
+ if err != nil {
+ t.Fatalf("materialized view DDL failed: %v", err)
+ }
+ for _, fragment := range []string{
+ "CREATE MATERIALIZED VIEW",
+ "FROM " + keyspace + "." + quoteCQLIdentifier(baseTable),
+ `PRIMARY KEY (("Tenant Id", "Category"), "Event Time", "Bucket")`,
+ `CLUSTERING ORDER BY ("Event Time" DESC, "Bucket" ASC)`,
+ "comment = 'issue 7475 round trip'",
+ "gc_grace_seconds = 86401",
+ } {
+ if !strings.Contains(ddl, fragment) {
+ t.Fatalf("materialized view DDL omitted %q:\n%s", fragment, ddl)
+ }
+ }
+ projection := materializedViewProjection(t, ddl)
+ wantProjection := []string{`"Bucket"`, `"Category"`, `"Event Time"`, `"Tenant Id"`}
+ sort.Strings(projection)
+ sort.Strings(wantProjection)
+ if strings.Join(projection, ",") != strings.Join(wantProjection, ",") || strings.Contains(ddl, `"Payload"`) || strings.Contains(ddl, "SELECT *") {
+ t.Fatalf("materialized view DDL lost its selected-column subset:\n%s", ddl)
+ }
+ metadataSession, err := runtime.sessionFor("")
+ if err != nil {
+ t.Fatal(err)
+ }
+ legacyCatalog, err := legacyMaterializedViewCatalog(metadataSession, keyspace, view)
+ if err != nil {
+ t.Fatalf("legacy materialized view catalog failed: %v", err)
+ }
+ legacyDDL, err := materializedViewDDLFromCatalog(keyspace, view, legacyCatalog)
+ if err != nil {
+ t.Fatalf("legacy materialized view DDL failed: %v", err)
+ }
+ legacyProjection := materializedViewProjection(t, legacyDDL)
+ sort.Strings(legacyProjection)
+ if strings.Join(legacyProjection, ",") != strings.Join(wantProjection, ",") || strings.Contains(legacyDDL, `"Payload"`) || strings.Contains(legacyDDL, "SELECT *") {
+ t.Fatalf("legacy materialized view DDL lost its selected-column subset:\n%s", legacyDDL)
+ }
+ allColumnsDDL, err := server.getTableDDL(keyspace, allColumnsView)
+ if err != nil || !strings.Contains(allColumnsDDL, "SELECT *") {
+ t.Fatalf("materialized view SELECT * was not preserved: ddl=%q err=%v", allColumnsDDL, err)
+ }
+
+ result, _, err := server.dispatch("get_object_source", map[string]json.RawMessage{
+ "schema": json.RawMessage(strconv.Quote(keyspace)),
+ "name": json.RawMessage(strconv.Quote(view)),
+ "object_type": json.RawMessage(`"MATERIALIZED_VIEW"`),
+ })
+ if err != nil {
+ t.Fatalf("materialized view object-source RPC failed: %v", err)
+ }
+ source, ok := result.(objectSource)
+ if !ok || source.Source != ddl || source.Name != view || source.ObjectType != "MATERIALIZED_VIEW" {
+ t.Fatalf("unexpected materialized view object-source response: %#v", result)
+ }
+
+ tableDDL, err := server.getTableDDL(keyspace, baseTable)
+ if err != nil || !strings.HasPrefix(tableDDL, "CREATE TABLE ") || strings.Contains(tableDDL, "CREATE MATERIALIZED VIEW") {
+ t.Fatalf("ordinary table DDL changed: ddl=%q err=%v", tableDDL, err)
+ }
+ if _, err := server.getTableDDL(keyspace, "MissingObject"); err == nil {
+ t.Fatal("missing schema object unexpectedly returned DDL")
+ }
+ if _, err := server.getMaterializedViewDDL(keyspace, "MissingObject"); err == nil {
+ t.Fatal("missing materialized view unexpectedly returned DDL")
+ }
+
+ mustCQL(t, server, "DROP MATERIALIZED VIEW "+qualifiedCQLName(keyspace, view), keyspace)
+ mustCQL(t, server, ddl, keyspace)
+ recreatedDDL, err := server.getTableDDL(keyspace, view)
+ if err != nil {
+ t.Fatalf("materialized view DDL after recreation failed: %v", err)
+ }
+ if recreatedDDL != ddl {
+ t.Fatalf("materialized view changed after DDL round trip:\nbefore:\n%s\nafter:\n%s", ddl, recreatedDDL)
+ }
+ mustCQL(t, server, "DROP MATERIALIZED VIEW "+qualifiedCQLName(keyspace, view), keyspace)
+ mustCQL(t, server, legacyDDL, keyspace)
+ legacyRecreatedDDL, err := server.getTableDDL(keyspace, view)
+ if err != nil {
+ t.Fatalf("materialized view DDL after legacy recreation failed: %v", err)
+ }
+ if legacyRecreatedDDL != ddl {
+ t.Fatalf("legacy materialized view DDL changed the definition:\nbefore:\n%s\nafter:\n%s", ddl, legacyRecreatedDDL)
+ }
+}
+
+func materializedViewProjection(t *testing.T, ddl string) []string {
+ t.Helper()
+ upper := strings.ToUpper(ddl)
+ selectIndex := strings.Index(upper, "SELECT ")
+ if selectIndex < 0 {
+ t.Fatalf("DDL has no SELECT clause:\n%s", ddl)
+ }
+ projectionStart := selectIndex + len("SELECT ")
+ fromOffset := strings.Index(upper[projectionStart:], "FROM ")
+ if fromOffset < 0 {
+ t.Fatalf("DDL has no FROM clause:\n%s", ddl)
+ }
+ projection := strings.TrimSpace(ddl[projectionStart : projectionStart+fromOffset])
+ if projection == "" {
+ t.Fatalf("DDL has an empty projection:\n%s", ddl)
+ }
+ columns := strings.Split(projection, ",")
+ for index := range columns {
+ columns[index] = strings.TrimSpace(columns[index])
+ }
+ return columns
+}
+
func envDefault(name, fallback string) string {
if value := strings.TrimSpace(os.Getenv(name)); value != "" {
return value
diff --git a/agents/drivers/cassandra-go/main.go b/agents/drivers/cassandra-go/main.go
index fc264cb690..4d596f3360 100644
--- a/agents/drivers/cassandra-go/main.go
+++ b/agents/drivers/cassandra-go/main.go
@@ -365,7 +365,12 @@ func (s *server) dispatch(method string, params map[string]json.RawMessage) (any
result, err := s.listTriggers(stringParam(params, "schema"), stringParam(params, "table"))
return result, false, err
case "get_object_source":
- return nil, false, errors.New("object source is not supported by Cassandra")
+ result, err := s.getObjectSource(
+ firstNonEmpty(stringParam(params, "schema"), stringParam(params, "database"), s.defaultKeyspace()),
+ firstNonEmpty(stringParam(params, "name"), stringParam(params, "table")),
+ stringParam(params, "object_type"),
+ )
+ return result, false, err
case "get_table_ddl":
result, err := s.getTableDDL(stringParam(params, "schema"), stringParam(params, "table"))
return result, false, err
diff --git a/agents/drivers/cassandra-go/materialized_view.go b/agents/drivers/cassandra-go/materialized_view.go
new file mode 100644
index 0000000000..9f7e77e8c2
--- /dev/null
+++ b/agents/drivers/cassandra-go/materialized_view.go
@@ -0,0 +1,394 @@
+package main
+
+import (
+ "errors"
+ "fmt"
+ "sort"
+ "strings"
+
+ gocql "github.com/apache/cassandra-gocql-driver/v2"
+)
+
+const maxLegacyMaterializedViewColumns = 4096
+
+const cassandraMaterializedViewObjectType = "MATERIALIZED_VIEW"
+
+var legacyMaterializedViewOptionNames = []string{
+ "additional_write_policy",
+ "bloom_filter_fp_chance",
+ "caching",
+ "cdc",
+ "comment",
+ "compaction",
+ "compression",
+ "crc_check_chance",
+ "dclocal_read_repair_chance",
+ "gc_grace_seconds",
+ "max_index_interval",
+ "memtable",
+ "memtable_flush_period_in_ms",
+ "min_index_interval",
+ "read_repair",
+ "read_repair_chance",
+ "speculative_retry",
+}
+
+type objectSource struct {
+ Name string `json:"name"`
+ ObjectType string `json:"object_type"`
+ Schema *string `json:"schema"`
+ Source string `json:"source"`
+}
+
+type materializedViewColumn struct {
+ Name string
+ Kind string
+ Position int
+ ClusteringOrder string
+}
+
+type materializedViewCatalog struct {
+ BaseTable string
+ IncludeAllColumns bool
+ WhereClause string
+ Columns []materializedViewColumn
+ Options map[string]any
+}
+
+func (s *server) getObjectSource(schema, name, objectType string) (objectSource, error) {
+ return materializedViewObjectSource(schema, name, objectType, func() (string, error) {
+ return s.getMaterializedViewDDL(schema, name)
+ })
+}
+
+func materializedViewObjectSource(schema, name, objectType string, loadDDL func() (string, error)) (objectSource, error) {
+ if normalizeCassandraObjectType(objectType) != cassandraMaterializedViewObjectType {
+ return objectSource{}, errors.New("object source is not supported by Cassandra")
+ }
+ source, err := loadDDL()
+ if err != nil {
+ return objectSource{}, err
+ }
+ return objectSource{
+ Name: name,
+ ObjectType: cassandraMaterializedViewObjectType,
+ Schema: optionalString(schema),
+ Source: source,
+ }, nil
+}
+
+func normalizeCassandraObjectType(value string) string {
+ value = strings.ToUpper(strings.TrimSpace(value))
+ value = strings.ReplaceAll(value, "-", "_")
+ return strings.ReplaceAll(value, " ", "_")
+}
+
+func (s *server) getMaterializedViewDDL(schema, view string) (string, error) {
+ session, err := s.runtime.sessionFor("")
+ if err != nil {
+ return "", err
+ }
+ return materializedViewDDLWithFallback(
+ func() (string, error) {
+ return describeMaterializedViewDDL(session, schema, view)
+ },
+ func() (string, error) {
+ catalog, err := legacyMaterializedViewCatalog(session, schema, view)
+ if err != nil {
+ return "", err
+ }
+ return materializedViewDDLFromCatalog(schema, view, catalog)
+ },
+ )
+}
+
+func materializedViewDDLWithFallback(describe, legacy func() (string, error)) (string, error) {
+ ddl, err := describe()
+ if err == nil {
+ if strings.TrimSpace(ddl) == "" {
+ return "", errors.New("Cassandra returned an empty materialized view definition")
+ }
+ return ddl, nil
+ }
+ if !isUnsupportedDescribeSyntax(err) {
+ return "", err
+ }
+ return legacy()
+}
+
+func isUnsupportedDescribeSyntax(err error) bool {
+ var requestError gocql.RequestError
+ return errors.As(err, &requestError) && requestError.Code() == gocql.ErrCodeSyntax
+}
+
+func describeMaterializedViewDDL(session *gocql.Session, schema, view string) (string, error) {
+ statement := "DESCRIBE MATERIALIZED VIEW " + qualifiedCQLIdentifier(schema, view)
+ var describedSchema, objectType, describedName, ddl string
+ if err := session.Query(statement).Scan(&describedSchema, &objectType, &describedName, &ddl); err != nil {
+ return "", fmt.Errorf("describe Cassandra materialized view %s: %w", qualifiedCQLIdentifier(schema, view), err)
+ }
+ if normalizeCassandraObjectType(objectType) != cassandraMaterializedViewObjectType {
+ return "", fmt.Errorf("Cassandra DESCRIBE returned object type %q for materialized view %s", objectType, qualifiedCQLIdentifier(schema, view))
+ }
+ if strings.TrimSpace(ddl) == "" {
+ return "", fmt.Errorf("Cassandra returned an empty materialized view definition for %s", qualifiedCQLIdentifier(schema, view))
+ }
+ return ddl, nil
+}
+
+func legacyMaterializedViewCatalog(session *gocql.Session, schema, view string) (materializedViewCatalog, error) {
+ row := map[string]any{}
+ err := session.Query(
+ "SELECT * FROM system_schema.views WHERE keyspace_name = ? AND view_name = ?",
+ schema,
+ view,
+ ).MapScan(row)
+ if errors.Is(err, gocql.ErrNotFound) {
+ return materializedViewCatalog{}, fmt.Errorf("Cassandra materialized view not found: %s.%s", schema, view)
+ }
+ if err != nil {
+ return materializedViewCatalog{}, fmt.Errorf("read Cassandra materialized view catalog for %s: %w", qualifiedCQLIdentifier(schema, view), err)
+ }
+
+ baseTable, ok := row["base_table_name"].(string)
+ if !ok || strings.TrimSpace(baseTable) == "" {
+ return materializedViewCatalog{}, fmt.Errorf("Cassandra materialized view catalog has no base table for %s", qualifiedCQLIdentifier(schema, view))
+ }
+ includeAllColumns, ok := row["include_all_columns"].(bool)
+ if !ok {
+ return materializedViewCatalog{}, fmt.Errorf("Cassandra materialized view catalog has no projection mode for %s", qualifiedCQLIdentifier(schema, view))
+ }
+ whereClause, ok := row["where_clause"].(string)
+ if !ok || strings.TrimSpace(whereClause) == "" {
+ return materializedViewCatalog{}, fmt.Errorf("Cassandra materialized view catalog has no WHERE clause for %s", qualifiedCQLIdentifier(schema, view))
+ }
+
+ options, err := legacyMaterializedViewOptions(row)
+ if err != nil {
+ return materializedViewCatalog{}, fmt.Errorf("read Cassandra materialized view options for %s: %w", qualifiedCQLIdentifier(schema, view), err)
+ }
+ columns, err := legacyMaterializedViewColumns(session, schema, view)
+ if err != nil {
+ return materializedViewCatalog{}, err
+ }
+ return materializedViewCatalog{
+ BaseTable: baseTable,
+ IncludeAllColumns: includeAllColumns,
+ WhereClause: whereClause,
+ Columns: columns,
+ Options: options,
+ }, nil
+}
+
+func legacyMaterializedViewOptions(row map[string]any) (map[string]any, error) {
+ metadataColumns := map[string]bool{
+ "base_table_id": true,
+ "base_table_name": true,
+ "id": true,
+ "include_all_columns": true,
+ "keyspace_name": true,
+ "view_name": true,
+ "where_clause": true,
+ }
+ knownOptions := make(map[string]bool, len(legacyMaterializedViewOptionNames)+1)
+ for _, name := range legacyMaterializedViewOptionNames {
+ knownOptions[name] = true
+ }
+ knownOptions["default_time_to_live"] = true
+ knownOptions["extensions"] = true
+
+ for name, value := range row {
+ if value != nil && !metadataColumns[name] && !knownOptions[name] {
+ return nil, fmt.Errorf("unsupported system_schema.views column %q", name)
+ }
+ }
+ if value, exists := row["default_time_to_live"]; exists && value != nil && fmt.Sprint(value) != "0" {
+ return nil, fmt.Errorf("unsupported non-zero default_time_to_live %v", value)
+ }
+ if value, exists := row["extensions"]; exists && value != nil && !isEmptyCQLCollection(value) {
+ return nil, errors.New("non-empty materialized view extensions cannot be reproduced safely")
+ }
+
+ options := make(map[string]any, len(legacyMaterializedViewOptionNames))
+ _, hasModernReadRepair := row["read_repair"]
+ for _, name := range legacyMaterializedViewOptionNames {
+ if value, exists := row[name]; exists && value != nil {
+ if hasModernReadRepair && (name == "dclocal_read_repair_chance" || name == "read_repair_chance") {
+ continue
+ }
+ if name == "memtable" && strings.TrimSpace(fmt.Sprint(value)) == "" {
+ continue
+ }
+ options[name] = value
+ }
+ }
+ return options, nil
+}
+
+func legacyMaterializedViewColumns(session *gocql.Session, schema, view string) ([]materializedViewColumn, error) {
+ iter := session.Query(
+ "SELECT column_name, kind, position, clustering_order FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ?",
+ schema,
+ view,
+ ).PageSize(512).Iter()
+ columns := make([]materializedViewColumn, 0)
+ var column materializedViewColumn
+ for iter.Scan(&column.Name, &column.Kind, &column.Position, &column.ClusteringOrder) {
+ if len(columns) >= maxLegacyMaterializedViewColumns {
+ _ = iter.Close()
+ return nil, fmt.Errorf("Cassandra materialized view %s has more than %d columns", qualifiedCQLIdentifier(schema, view), maxLegacyMaterializedViewColumns)
+ }
+ columns = append(columns, column)
+ column = materializedViewColumn{}
+ }
+ if err := iter.Close(); err != nil {
+ return nil, fmt.Errorf("read Cassandra materialized view columns for %s: %w", qualifiedCQLIdentifier(schema, view), err)
+ }
+ if len(columns) == 0 {
+ return nil, fmt.Errorf("Cassandra materialized view catalog has no columns for %s", qualifiedCQLIdentifier(schema, view))
+ }
+ return columns, nil
+}
+
+func materializedViewDDLFromCatalog(schema, view string, catalog materializedViewCatalog) (string, error) {
+ if strings.TrimSpace(catalog.BaseTable) == "" {
+ return "", fmt.Errorf("Cassandra materialized view catalog has no base table for %s", qualifiedCQLIdentifier(schema, view))
+ }
+ if strings.TrimSpace(catalog.WhereClause) == "" {
+ return "", fmt.Errorf("Cassandra materialized view catalog has no WHERE clause for %s", qualifiedCQLIdentifier(schema, view))
+ }
+
+ partitionKeys, clusteringColumns, selectedColumns, err := classifyMaterializedViewColumns(catalog.Columns)
+ if err != nil {
+ return "", fmt.Errorf("invalid Cassandra materialized view columns for %s: %w", qualifiedCQLIdentifier(schema, view), err)
+ }
+ if len(partitionKeys) == 0 {
+ return "", fmt.Errorf("Cassandra materialized view has no partition key: %s", qualifiedCQLIdentifier(schema, view))
+ }
+
+ projection := "*"
+ if !catalog.IncludeAllColumns {
+ quoted := make([]string, len(selectedColumns))
+ for index, column := range selectedColumns {
+ quoted[index] = quoteCQLIdentifier(column.Name)
+ }
+ projection = strings.Join(quoted, ", ")
+ }
+
+ primaryParts := make([]string, 0, len(clusteringColumns)+1)
+ if len(partitionKeys) == 1 {
+ primaryParts = append(primaryParts, quoteCQLIdentifier(partitionKeys[0].Name))
+ } else {
+ quoted := make([]string, len(partitionKeys))
+ for index, column := range partitionKeys {
+ quoted[index] = quoteCQLIdentifier(column.Name)
+ }
+ primaryParts = append(primaryParts, "("+strings.Join(quoted, ", ")+")")
+ }
+ for _, column := range clusteringColumns {
+ primaryParts = append(primaryParts, quoteCQLIdentifier(column.Name))
+ }
+
+ properties := make([]string, 0, len(catalog.Options)+1)
+ if len(clusteringColumns) > 0 {
+ orders := make([]string, len(clusteringColumns))
+ for index, column := range clusteringColumns {
+ order := strings.ToUpper(strings.TrimSpace(column.ClusteringOrder))
+ if order != "ASC" && order != "DESC" {
+ return "", fmt.Errorf("invalid clustering order %q for column %q", column.ClusteringOrder, column.Name)
+ }
+ orders[index] = quoteCQLIdentifier(column.Name) + " " + order
+ }
+ properties = append(properties, "CLUSTERING ORDER BY ("+strings.Join(orders, ", ")+")")
+ }
+ for _, name := range legacyMaterializedViewOptionNames {
+ value, exists := catalog.Options[name]
+ if !exists || value == nil {
+ continue
+ }
+ properties = append(properties, name+" = "+cqlLiteral(value))
+ }
+ if len(properties) == 0 {
+ return "", fmt.Errorf("Cassandra materialized view has no reproducible table options: %s", qualifiedCQLIdentifier(schema, view))
+ }
+
+ return "CREATE MATERIALIZED VIEW " + qualifiedCQLIdentifier(schema, view) + " AS\n" +
+ " SELECT " + projection + "\n" +
+ " FROM " + qualifiedCQLIdentifier(schema, catalog.BaseTable) + "\n" +
+ " WHERE " + strings.TrimSpace(catalog.WhereClause) + "\n" +
+ " PRIMARY KEY (" + strings.Join(primaryParts, ", ") + ")\n" +
+ " WITH " + strings.Join(properties, "\n AND ") + ";", nil
+}
+
+func qualifiedCQLIdentifier(schema, name string) string {
+ return quoteCQLIdentifier(schema) + "." + quoteCQLIdentifier(name)
+}
+
+func classifyMaterializedViewColumns(columns []materializedViewColumn) ([]materializedViewColumn, []materializedViewColumn, []materializedViewColumn, error) {
+ partitionKeys := make([]materializedViewColumn, 0)
+ clusteringColumns := make([]materializedViewColumn, 0)
+ regularColumns := make([]materializedViewColumn, 0)
+ seenNames := make(map[string]bool, len(columns))
+ for _, column := range columns {
+ if strings.TrimSpace(column.Name) == "" {
+ return nil, nil, nil, errors.New("column name is empty")
+ }
+ if seenNames[column.Name] {
+ return nil, nil, nil, fmt.Errorf("duplicate column %q", column.Name)
+ }
+ seenNames[column.Name] = true
+ switch strings.ToLower(strings.TrimSpace(column.Kind)) {
+ case "partition_key":
+ partitionKeys = append(partitionKeys, column)
+ case "clustering", "clustering_key":
+ clusteringColumns = append(clusteringColumns, column)
+ case "regular", "static":
+ regularColumns = append(regularColumns, column)
+ default:
+ return nil, nil, nil, fmt.Errorf("unsupported kind %q for column %q", column.Kind, column.Name)
+ }
+ }
+ if err := sortMaterializedViewKeyColumns(partitionKeys, "partition"); err != nil {
+ return nil, nil, nil, err
+ }
+ if err := sortMaterializedViewKeyColumns(clusteringColumns, "clustering"); err != nil {
+ return nil, nil, nil, err
+ }
+ sort.Slice(regularColumns, func(left, right int) bool { return regularColumns[left].Name < regularColumns[right].Name })
+ selectedColumns := make([]materializedViewColumn, 0, len(columns))
+ selectedColumns = append(selectedColumns, partitionKeys...)
+ selectedColumns = append(selectedColumns, clusteringColumns...)
+ selectedColumns = append(selectedColumns, regularColumns...)
+ return partitionKeys, clusteringColumns, selectedColumns, nil
+}
+
+func sortMaterializedViewKeyColumns(columns []materializedViewColumn, kind string) error {
+ sort.Slice(columns, func(left, right int) bool {
+ if columns[left].Position == columns[right].Position {
+ return columns[left].Name < columns[right].Name
+ }
+ return columns[left].Position < columns[right].Position
+ })
+ for index, column := range columns {
+ if column.Position < 0 {
+ return fmt.Errorf("invalid %s-key position %d for column %q", kind, column.Position, column.Name)
+ }
+ if index > 0 && columns[index-1].Position == column.Position {
+ return fmt.Errorf("duplicate %s-key position %d", kind, column.Position)
+ }
+ }
+ return nil
+}
+
+func isEmptyCQLCollection(value any) bool {
+ switch typed := value.(type) {
+ case map[string]string:
+ return len(typed) == 0
+ case map[string][]byte:
+ return len(typed) == 0
+ case map[string]any:
+ return len(typed) == 0
+ default:
+ return false
+ }
+}
diff --git a/agents/drivers/cassandra-go/metadata.go b/agents/drivers/cassandra-go/metadata.go
index d8ec9eb82b..23deacc922 100644
--- a/agents/drivers/cassandra-go/metadata.go
+++ b/agents/drivers/cassandra-go/metadata.go
@@ -470,11 +470,23 @@ func indexesFromMetadata(metadata *gocql.TableMetadata) []indexInfo {
}
func (s *server) getTableDDL(schema, table string) (string, error) {
- metadata, err := s.tableMetadata(schema, table)
+ keyspace, err := s.keyspaceMetadata(schema)
if err != nil {
return "", err
}
- return tableDDLFromMetadata(schema, table, metadata)
+ return schemaObjectDDLFromMetadata(schema, table, keyspace, func() (string, error) {
+ return s.getMaterializedViewDDL(schema, table)
+ })
+}
+
+func schemaObjectDDLFromMetadata(schema, table string, keyspace *gocql.KeyspaceMetadata, materializedViewDDL func() (string, error)) (string, error) {
+ if keyspace.MaterializedViews[table] != nil {
+ return materializedViewDDL()
+ }
+ if metadata := keyspace.Tables[table]; metadata != nil {
+ return tableDDLFromMetadata(schema, table, metadata)
+ }
+ return "", fmt.Errorf("Cassandra table not found: %s.%s", schema, table)
}
func tableDDLFromMetadata(schema, table string, metadata *gocql.TableMetadata) (string, error) {
diff --git a/agents/drivers/cassandra-go/metadata_test.go b/agents/drivers/cassandra-go/metadata_test.go
index a699d3f081..465e090882 100644
--- a/agents/drivers/cassandra-go/metadata_test.go
+++ b/agents/drivers/cassandra-go/metadata_test.go
@@ -3,11 +3,21 @@ package main
import (
"errors"
"reflect"
+ "strings"
"testing"
gocql "github.com/apache/cassandra-gocql-driver/v2"
)
+type testCassandraRequestError struct {
+ code int
+ message string
+}
+
+func (e *testCassandraRequestError) Error() string { return e.message }
+func (e *testCassandraRequestError) Code() int { return e.code }
+func (e *testCassandraRequestError) Message() string { return e.message }
+
type triggerMetadataIterator struct {
rows []struct {
name string
@@ -80,6 +90,250 @@ func TestColumnsIndexesAndDDLFromMetadata(t *testing.T) {
}
}
+func TestSchemaObjectDDLChoosesMaterializedViewBeforeMirroredTableMetadata(t *testing.T) {
+ id := &gocql.ColumnMetadata{Name: "id", Kind: gocql.ColumnPartitionKey, Type: gocql.NewNativeType(4, gocql.TypeInt, "")}
+ tableMetadata := &gocql.TableMetadata{
+ OrderedColumns: []string{"id"},
+ PartitionKey: []*gocql.ColumnMetadata{id},
+ Columns: map[string]*gocql.ColumnMetadata{"id": id},
+ }
+ keyspace := &gocql.KeyspaceMetadata{
+ Tables: map[string]*gocql.TableMetadata{
+ "users": tableMetadata,
+ "users_by_email": tableMetadata,
+ },
+ MaterializedViews: map[string]*gocql.MaterializedViewMetadata{
+ "users_by_email": {Name: "users_by_email", BaseTable: tableMetadata},
+ },
+ }
+
+ viewCalls := 0
+ ddl, err := schemaObjectDDLFromMetadata("app", "users_by_email", keyspace, func() (string, error) {
+ viewCalls++
+ return "CREATE MATERIALIZED VIEW app.users_by_email", nil
+ })
+ if err != nil || ddl != "CREATE MATERIALIZED VIEW app.users_by_email" || viewCalls != 1 {
+ t.Fatalf("materialized view dispatch = %q, calls = %d, err = %v", ddl, viewCalls, err)
+ }
+
+ tableDDL, err := schemaObjectDDLFromMetadata("app", "users", keyspace, func() (string, error) {
+ t.Fatal("ordinary table DDL must not use the materialized-view loader")
+ return "", nil
+ })
+ if err != nil || !strings.HasPrefix(tableDDL, `CREATE TABLE "app"."users"`) {
+ t.Fatalf("ordinary table DDL = %q, err = %v", tableDDL, err)
+ }
+ if _, err := schemaObjectDDLFromMetadata("app", "missing", keyspace, func() (string, error) {
+ return "", errors.New("unexpected")
+ }); err == nil || !strings.Contains(err.Error(), "table not found") {
+ t.Fatalf("missing object error = %v", err)
+ }
+}
+
+func TestMaterializedViewObjectSourcePreservesProtocolShape(t *testing.T) {
+ result, err := materializedViewObjectSource("app", "users_by_email", "MATERIALIZED_VIEW", func() (string, error) {
+ return "CREATE MATERIALIZED VIEW app.users_by_email", nil
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result.Name != "users_by_email" || result.ObjectType != "MATERIALIZED_VIEW" || result.Schema == nil || *result.Schema != "app" || result.Source != "CREATE MATERIALIZED VIEW app.users_by_email" {
+ t.Fatalf("unexpected object source: %#v", result)
+ }
+
+ loaderCalled := false
+ _, err = materializedViewObjectSource("app", "users", "TABLE", func() (string, error) {
+ loaderCalled = true
+ return "unexpected", nil
+ })
+ if err == nil || loaderCalled || err.Error() != "object source is not supported by Cassandra" {
+ t.Fatalf("unsupported source err = %v, loader called = %v", err, loaderCalled)
+ }
+
+ wantErr := errors.New("definition unavailable")
+ _, err = materializedViewObjectSource("app", "users_by_email", "materialized view", func() (string, error) {
+ return "", wantErr
+ })
+ if !errors.Is(err, wantErr) {
+ t.Fatalf("object-source loader error = %v", err)
+ }
+}
+
+func TestMaterializedViewDDLFromLegacyCatalogPreservesDefinition(t *testing.T) {
+ catalog := materializedViewCatalog{
+ BaseTable: `Base"Events`,
+ IncludeAllColumns: false,
+ WhereClause: `"Tenant Id" IS NOT NULL AND "Category" IS NOT NULL`,
+ Columns: []materializedViewColumn{
+ {Name: "Bucket", Kind: "clustering", Position: 1, ClusteringOrder: "asc"},
+ {Name: "Payload", Kind: "regular", Position: -1},
+ {Name: "Category", Kind: "partition_key", Position: 1},
+ {Name: "Event Time", Kind: "clustering", Position: 0, ClusteringOrder: "desc"},
+ {Name: "Tenant Id", Kind: "partition_key", Position: 0},
+ },
+ Options: map[string]any{
+ "caching": map[string]string{"rows_per_partition": "NONE", "keys": "ALL"},
+ "comment": "owner's view",
+ "default_time_to_live": 0,
+ "extensions": map[string][]byte{},
+ "gc_grace_seconds": 86401,
+ "speculative_retry": "99PERCENTILE",
+ "read_repair_chance": 0.0,
+ "dclocal_read_repair_chance": 0.1,
+ },
+ }
+
+ ddl, err := materializedViewDDLFromCatalog(`App"Ks`, `Events"ByCategory`, catalog)
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, fragment := range []string{
+ `CREATE MATERIALIZED VIEW "App""Ks"."Events""ByCategory" AS`,
+ `SELECT "Tenant Id", "Category", "Event Time", "Bucket", "Payload"`,
+ `FROM "App""Ks"."Base""Events"`,
+ `WHERE "Tenant Id" IS NOT NULL AND "Category" IS NOT NULL`,
+ `PRIMARY KEY (("Tenant Id", "Category"), "Event Time", "Bucket")`,
+ `CLUSTERING ORDER BY ("Event Time" DESC, "Bucket" ASC)`,
+ `caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'}`,
+ `comment = 'owner''s view'`,
+ `dclocal_read_repair_chance = 0.1`,
+ `gc_grace_seconds = 86401`,
+ `read_repair_chance = 0`,
+ `speculative_retry = '99PERCENTILE'`,
+ } {
+ if !strings.Contains(ddl, fragment) {
+ t.Fatalf("materialized view DDL omitted %q:\n%s", fragment, ddl)
+ }
+ }
+ if strings.Contains(ddl, "default_time_to_live") || strings.Contains(ddl, "extensions") {
+ t.Fatalf("materialized view DDL emitted non-applicable empty options:\n%s", ddl)
+ }
+}
+
+func TestLegacyMaterializedViewOptionsUseVersionAppropriateReadRepair(t *testing.T) {
+ modern, err := legacyMaterializedViewOptions(map[string]any{
+ "read_repair": "BLOCKING",
+ "read_repair_chance": 0.0,
+ "dclocal_read_repair_chance": 0.0,
+ "memtable": "",
+ "default_time_to_live": 0,
+ "extensions": map[string][]byte{},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if modern["read_repair"] != "BLOCKING" || modern["read_repair_chance"] != nil || modern["dclocal_read_repair_chance"] != nil || modern["memtable"] != nil {
+ t.Fatalf("unexpected modern options: %#v", modern)
+ }
+
+ legacy, err := legacyMaterializedViewOptions(map[string]any{
+ "read_repair_chance": 0.0,
+ "dclocal_read_repair_chance": 0.1,
+ "default_time_to_live": 0,
+ "extensions": map[string][]byte{},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if legacy["read_repair_chance"] != 0.0 || legacy["dclocal_read_repair_chance"] != 0.1 {
+ t.Fatalf("unexpected Cassandra 3 options: %#v", legacy)
+ }
+}
+
+func TestMaterializedViewDDLFromLegacyCatalogPreservesSelectStar(t *testing.T) {
+ ddl, err := materializedViewDDLFromCatalog("app", "users_by_email", materializedViewCatalog{
+ BaseTable: "users",
+ IncludeAllColumns: true,
+ WhereClause: "email IS NOT NULL AND id IS NOT NULL",
+ Columns: []materializedViewColumn{
+ {Name: "email", Kind: "partition_key", Position: 0},
+ {Name: "id", Kind: "clustering", Position: 0, ClusteringOrder: "asc"},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !strings.Contains(ddl, "SELECT *") {
+ t.Fatalf("materialized view DDL did not preserve SELECT *:\n%s", ddl)
+ }
+}
+
+func TestMaterializedViewDDLOnlyFallsBackForUnsupportedDescribeSyntax(t *testing.T) {
+ legacyCalls := 0
+ ddl, err := materializedViewDDLWithFallback(
+ func() (string, error) { return "CREATE MATERIALIZED VIEW native", nil },
+ func() (string, error) {
+ legacyCalls++
+ return "unexpected", nil
+ },
+ )
+ if err != nil || ddl != "CREATE MATERIALIZED VIEW native" || legacyCalls != 0 {
+ t.Fatalf("native DDL = %q, legacy calls = %d, err = %v", ddl, legacyCalls, err)
+ }
+
+ legacyCalls = 0
+ ddl, err = materializedViewDDLWithFallback(
+ func() (string, error) {
+ return "", &testCassandraRequestError{code: gocql.ErrCodeSyntax, message: "no viable alternative at input 'DESCRIBE'"}
+ },
+ func() (string, error) {
+ legacyCalls++
+ return "CREATE MATERIALIZED VIEW legacy", nil
+ },
+ )
+ if err != nil || ddl != "CREATE MATERIALIZED VIEW legacy" || legacyCalls != 1 {
+ t.Fatalf("syntax fallback = %q, calls = %d, err = %v", ddl, legacyCalls, err)
+ }
+
+ permissionErr := &testCassandraRequestError{code: gocql.ErrCodeUnauthorized, message: "not authorized"}
+ legacyCalls = 0
+ _, err = materializedViewDDLWithFallback(
+ func() (string, error) { return "", permissionErr },
+ func() (string, error) {
+ legacyCalls++
+ return "unexpected", nil
+ },
+ )
+ if !errors.Is(err, permissionErr) || legacyCalls != 0 {
+ t.Fatalf("permission error = %v, legacy calls = %d", err, legacyCalls)
+ }
+
+ networkErr := errors.New("connection reset")
+ _, err = materializedViewDDLWithFallback(
+ func() (string, error) { return "", networkErr },
+ func() (string, error) {
+ legacyCalls++
+ return "unexpected", nil
+ },
+ )
+ if !errors.Is(err, networkErr) || legacyCalls != 0 {
+ t.Fatalf("network error = %v, legacy calls = %d", err, legacyCalls)
+ }
+}
+
+func TestLegacyMaterializedViewOptionsRejectLossyDefinitions(t *testing.T) {
+ for name, row := range map[string]map[string]any{
+ "unknown option": {
+ "base_table_name": "users",
+ "future_option": "cannot safely reproduce",
+ },
+ "non-zero default TTL": {
+ "base_table_name": "users",
+ "default_time_to_live": 60,
+ },
+ "non-empty extensions": {
+ "base_table_name": "users",
+ "extensions": map[string][]byte{"custom": {0x01}},
+ },
+ } {
+ t.Run(name, func(t *testing.T) {
+ if _, err := legacyMaterializedViewOptions(row); err == nil {
+ t.Fatal("expected an explicit error instead of a lossy legacy DDL")
+ }
+ })
+ }
+}
+
func TestMetadataWindowAndFilter(t *testing.T) {
values := []string{"a", "b", "c", "d"}
if got := applyMetadataWindow(values, 1, 2); !reflect.DeepEqual(got, []string{"b", "c"}) {