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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(cassandra): return materialized view definitions
t8y2f1b981bf0d97
diff --git a/agents/drivers/cassandra-go/integration_test.go b/agents/drivers/cassandra-go/integration_test.goindex 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 valuediff --git a/agents/drivers/cassandra-go/main.go b/agents/drivers/cassandra-go/main.goindex 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) (anyresult, err := s.listTriggers(stringParam(params, "schema"), stringParam(params, "table"))return result, false, errcase "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, errcase "get_table_ddl":result, err := s.getTableDDL(stringParam(params, "schema"), stringParam(params, "table"))return result, false, errdiff --git a/agents/drivers/cassandra-go/materialized_view.go b/agents/drivers/cassandra-go/materialized_view.gonew file mode 100644index 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.goindex 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.goindex a699d3f081..465e090882 100644--- a/agents/drivers/cassandra-go/metadata_test.go+++ b/agents/drivers/cassandra-go/metadata_test.go@@ -3,11 +3,21 @@ package mainimport ("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"}) {