Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: migrate MSSQL metadata parser to omni (#20215)
rebelice2d956b7c7b62
diff --git a/backend/plugin/advisor/tidb/utils.go b/backend/plugin/advisor/tidb/utils.goindex d5409f4491..34122186d5 100644--- a/backend/plugin/advisor/tidb/utils.go+++ b/backend/plugin/advisor/tidb/utils.go@@ -1,4 +1,6 @@// package tidb implements the SQL advisor rules for MySQL.+//+//nolint:unused // Kept for PingCap-based TiDB advisors during the omni migration.package tidbimport (diff --git a/backend/plugin/schema/mssql/get_database_metadata.go b/backend/plugin/schema/mssql/get_database_metadata.goindex 6c275bdf9c..5469fa4dfd 100644--- a/backend/plugin/schema/mssql/get_database_metadata.go+++ b/backend/plugin/schema/mssql/get_database_metadata.go@@ -20,8 +20,9 @@ func init() {schema.RegisterGetDatabaseMetadata(storepb.Engine_MSSQL, GetDatabaseMetadata)}-// GetDatabaseMetadata parses the SQL schema text and returns the database metadata.-func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {+// getDatabaseMetadataANTLR parses the SQL schema text and returns the database metadata.+// It is kept as a compatibility oracle while MSSQL metadata extraction migrates to omni.+func getDatabaseMetadataANTLR(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {parseResults, err := tsql.ParseTSQL(schemaText)if err != nil {return nil, errors.Wrapf(err, "failed to parse SQL schema")diff --git a/backend/plugin/schema/mssql/get_database_metadata_omni.go b/backend/plugin/schema/mssql/get_database_metadata_omni.gonew file mode 100644index 0000000000..20e5118ac2--- /dev/null+++ b/backend/plugin/schema/mssql/get_database_metadata_omni.go@@ -0,0 +1,710 @@+package mssql++import (+ "fmt"+ "slices"+ "strconv"+ "strings"++ "github.com/bytebase/omni/mssql/ast"+ "github.com/pkg/errors"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/tsql"+)++const noAction = "NO ACTION"++// GetDatabaseMetadata parses the SQL schema text and returns the database metadata.+func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {+ return getDatabaseMetadataOmni(schemaText)+}++func getDatabaseMetadataOmni(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {+ stmts, err := tsql.ParseTSQLOmni(schemaText)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to parse SQL schema")+ }++ if len(stmts) == 0 {+ return &storepb.DatabaseSchemaMetadata{+ Name: "",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "dbo",+ Tables: []*storepb.TableMetadata{},+ },+ },+ }, nil+ }++ extractor := &omniMetadataExtractor{+ currentSchema: "dbo",+ schemas: make(map[string]*storepb.SchemaMetadata),+ tables: make(map[tableKey]*storepb.TableMetadata),+ schemaText: schemaText,+ }++ for _, stmt := range stmts {+ if stmt.Empty() {+ continue+ }+ extractor.extractStatement(stmt.AST)+ }+ if extractor.err != nil {+ return nil, extractor.err+ }++ schemaMetadata := &storepb.DatabaseSchemaMetadata{+ Name: extractor.currentDatabase,+ }++ var schemaNames []string+ for name := range extractor.schemas {+ schemaNames = append(schemaNames, name)+ }+ slices.Sort(schemaNames)++ for _, schemaName := range schemaNames {+ schemaMetadata.Schemas = append(schemaMetadata.Schemas, extractor.schemas[schemaName])+ }++ return schemaMetadata, nil+}++type omniMetadataExtractor struct {+ currentDatabase string+ currentSchema string+ schemas map[string]*storepb.SchemaMetadata+ tables map[tableKey]*storepb.TableMetadata+ indexCounter int+ schemaText string+ err error+}++func (e *omniMetadataExtractor) getOrCreateSchema(schemaName string) *storepb.SchemaMetadata {+ if schemaName == "" {+ schemaName = "dbo"+ }+ if schema, exists := e.schemas[schemaName]; exists {+ return schema+ }+ schema := &storepb.SchemaMetadata{+ Name: schemaName,+ Tables: []*storepb.TableMetadata{},+ Views: nil,+ Procedures: nil,+ Functions: nil,+ Sequences: nil,+ }+ e.schemas[schemaName] = schema+ return schema+}++func (e *omniMetadataExtractor) getOrCreateTable(schemaName, tableName string) *storepb.TableMetadata {+ key := tableKey{schema: schemaName, table: tableName}+ if table, exists := e.tables[key]; exists {+ return table+ }+ table := &storepb.TableMetadata{+ Name: tableName,+ Columns: []*storepb.ColumnMetadata{},+ Indexes: []*storepb.IndexMetadata{},+ ForeignKeys: nil,+ CheckConstraints: nil,+ }+ schema := e.getOrCreateSchema(schemaName)+ schema.Tables = append(schema.Tables, table)+ e.tables[key] = table+ return table+}++func (e *omniMetadataExtractor) extractStatement(node ast.Node) {+ if node == nil || e.err != nil {+ return+ }++ switch n := node.(type) {+ case *ast.CreateSchemaStmt:+ e.getOrCreateSchema(n.Name)+ if n.Elements != nil {+ for _, item := range n.Elements.Items {+ e.extractStatement(item)+ }+ }+ case *ast.CreateTableStmt:+ e.extractCreateTable(n)+ case *ast.CreateIndexStmt:+ e.extractCreateIndex(n)+ case *ast.CreateSpatialIndexStmt:+ e.extractCreateSpatialIndex(n)+ case *ast.CreateViewStmt:+ schemaName, viewName := tableRefSchemaObject(n.Name, e.currentSchema)+ schemaMetadata := e.getOrCreateSchema(schemaName)+ if schemaMetadata.Views == nil {+ schemaMetadata.Views = []*storepb.ViewMetadata{}+ }+ schemaMetadata.Views = append(schemaMetadata.Views, &storepb.ViewMetadata{+ Name: viewName,+ Definition: e.definitionText(n),+ })+ case *ast.CreateProcedureStmt:+ schemaName, procedureName := tableRefSchemaObject(n.Name, e.currentSchema)+ schemaMetadata := e.getOrCreateSchema(schemaName)+ if schemaMetadata.Procedures == nil {+ schemaMetadata.Procedures = []*storepb.ProcedureMetadata{}+ }+ schemaMetadata.Procedures = append(schemaMetadata.Procedures, &storepb.ProcedureMetadata{+ Name: procedureName,+ Definition: e.definitionText(n),+ })+ case *ast.CreateFunctionStmt:+ schemaName, functionName := tableRefSchemaObject(n.Name, e.currentSchema)+ schemaMetadata := e.getOrCreateSchema(schemaName)+ if schemaMetadata.Functions == nil {+ schemaMetadata.Functions = []*storepb.FunctionMetadata{}+ }+ schemaMetadata.Functions = append(schemaMetadata.Functions, &storepb.FunctionMetadata{+ Name: functionName,+ Definition: e.definitionText(n),+ })+ case *ast.CreateSequenceStmt:+ e.extractCreateSequence(n)+ case *ast.ExecStmt:+ e.extractExtendedProperty(n)+ default:+ }+}++func (e *omniMetadataExtractor) extractCreateTable(n *ast.CreateTableStmt) {+ schemaName, tableName := tableRefSchemaObject(n.Name, e.currentSchema)+ table := e.getOrCreateTable(schemaName, tableName)++ if n.Columns != nil {+ for _, item := range n.Columns.Items {+ column, ok := item.(*ast.ColumnDef)+ if !ok {+ continue+ }+ e.extractColumn(column, table, schemaName)+ }+ }+ if n.Constraints != nil {+ for _, item := range n.Constraints.Items {+ constraint, ok := item.(*ast.ConstraintDef)+ if !ok {+ continue+ }+ e.extractTableConstraint(constraint, table, schemaName)+ }+ }+ if n.Indexes != nil {+ for _, item := range n.Indexes.Items {+ index, ok := item.(*ast.InlineIndexDef)+ if !ok {+ continue+ }+ table.Indexes = append(table.Indexes, e.inlineIndexMetadata(index))+ }+ }+}++func (e *omniMetadataExtractor) extractColumn(n *ast.ColumnDef, table *storepb.TableMetadata, schemaName string) {+ column := &storepb.ColumnMetadata{+ Name: n.Name,+ Position: int32(len(table.Columns) + 1),+ Nullable: true,+ }+ if n.DataType != nil {+ column.Type = e.nodeText(n.DataType)+ }+ if n.Identity != nil {+ column.IsIdentity = true+ column.IdentitySeed = n.Identity.Seed+ column.IdentityIncrement = n.Identity.Increment+ }+ if n.Nullable != nil {+ column.Nullable = !n.Nullable.NotNull+ }+ if n.DefaultExpr != nil {+ column.Default = e.nodeText(n.DefaultExpr)+ }+ if n.Collation != "" {+ column.Collation = n.Collation+ }++ if n.Constraints != nil {+ for _, item := range n.Constraints.Items {+ constraint, ok := item.(*ast.ConstraintDef)+ if !ok {+ continue+ }+ switch constraint.Type {+ case ast.ConstraintPrimaryKey:+ column.Nullable = false+ table.Indexes = append(table.Indexes, e.constraintIndexMetadata(+ constraint,+ fmt.Sprintf("PK_%s", table.Name),+ []string{column.Name},+ true,+ ))+ case ast.ConstraintUnique:+ table.Indexes = append(table.Indexes, e.constraintIndexMetadata(+ constraint,+ fmt.Sprintf("UQ_%s", table.Name),+ []string{column.Name},+ false,+ ))+ case ast.ConstraintDefault:+ if constraint.Expr != nil {+ column.Default = e.nodeText(constraint.Expr)+ }+ case ast.ConstraintCheck:+ e.appendCheckConstraint(table, constraint)+ case ast.ConstraintForeignKey:+ appendForeignKey(table, constraint, []string{column.Name}, schemaName)+ default:+ }+ }+ }++ table.Columns = append(table.Columns, column)+}++func (e *omniMetadataExtractor) extractTableConstraint(n *ast.ConstraintDef, table *storepb.TableMetadata, schemaName string) {+ switch n.Type {+ case ast.ConstraintPrimaryKey:+ table.Indexes = append(table.Indexes, e.constraintIndexMetadata(n, "", indexColumnNames(n.Columns), true))+ case ast.ConstraintUnique:+ table.Indexes = append(table.Indexes, e.constraintIndexMetadata(n, "", indexColumnNames(n.Columns), false))+ case ast.ConstraintCheck:+ e.appendCheckConstraint(table, n)+ case ast.ConstraintForeignKey:+ appendForeignKey(table, n, stringNodeList(n.Columns), schemaName)+ default:+ }+}++func (e *omniMetadataExtractor) extractCreateIndex(n *ast.CreateIndexStmt) {+ schemaName, tableName := tableRefSchemaObject(n.Table, e.currentSchema)+ table := e.getOrCreateTable(schemaName, tableName)++ index := &storepb.IndexMetadata{+ Name: n.Name,+ Unique: n.Unique,+ Type: indexType(n.Columnstore, n.Clustered),+ Expressions: []string{},+ Descending: []bool{},+ IsConstraint: false,+ }+ appendIndexColumns(index, n.Columns)+ table.Indexes = append(table.Indexes, index)+}++func (e *omniMetadataExtractor) extractCreateSpatialIndex(n *ast.CreateSpatialIndexStmt) {+ schemaName, tableName := tableRefSchemaObject(n.Table, e.currentSchema)+ table := e.getOrCreateTable(schemaName, tableName)++ index := &storepb.IndexMetadata{+ Name: n.Name,+ Type: "SPATIAL",+ Expressions: []string{},+ Descending: []bool{},+ IsConstraint: false,+ SpatialConfig: &storepb.SpatialIndexConfig{+ Method: "SPATIAL",+ Tessellation: &storepb.TessellationConfig{+ Scheme: strings.ToUpper(n.Using),+ },+ Dimensional: &storepb.DimensionalConfig{+ Dimensions: 2,+ },+ },+ }+ if n.SpatialColumn != "" {+ index.Expressions = append(index.Expressions, n.SpatialColumn)+ index.Descending = append(index.Descending, false)+ }+ if strings.Contains(index.SpatialConfig.Tessellation.Scheme, "GEOGRAPHY") {+ index.SpatialConfig.Dimensional.DataType = "GEOGRAPHY"+ } else {+ index.SpatialConfig.Dimensional.DataType = "GEOMETRY"+ }+ parseSpatialOptions(n.Options, index)+ table.Indexes = append(table.Indexes, index)+}++func (e *omniMetadataExtractor) extractCreateSequence(n *ast.CreateSequenceStmt) {+ schemaName, sequenceName := tableRefSchemaObject(n.Name, e.currentSchema)+ schemaMetadata := e.getOrCreateSchema(schemaName)+ sequence := &storepb.SequenceMetadata{Name: sequenceName}+ if n.DataType != nil {+ sequence.DataType = e.nodeText(n.DataType)+ }+ if schemaMetadata.Sequences == nil {+ schemaMetadata.Sequences = []*storepb.SequenceMetadata{}+ }+ schemaMetadata.Sequences = append(schemaMetadata.Sequences, sequence)+}++func (e *omniMetadataExtractor) constraintIndexMetadata(n *ast.ConstraintDef, prefix string, columns []string, primary bool) *storepb.IndexMetadata {+ name := n.Name+ if name == "" && prefix != "" {+ e.indexCounter+++ name = fmt.Sprintf("%s_%d", prefix, e.indexCounter)+ }+ index := &storepb.IndexMetadata{+ Name: name,+ Primary: primary,+ Unique: true,+ IsConstraint: true,+ Expressions: []string{},+ Descending: []bool{},+ Type: indexType(false, n.Clustered),+ }+ for _, column := range columns {+ index.Expressions = append(index.Expressions, column)+ index.Descending = append(index.Descending, false)+ }+ if len(columns) == 0 && n.Columns != nil {+ appendIndexColumns(index, n.Columns)+ }+ return index+}++func (*omniMetadataExtractor) inlineIndexMetadata(n *ast.InlineIndexDef) *storepb.IndexMetadata {+ index := &storepb.IndexMetadata{+ Name: n.Name,+ Unique: n.Unique,+ Type: indexType(n.Columnstore, n.Clustered),+ Expressions: []string{},+ Descending: []bool{},+ IsConstraint: false,+ }+ appendIndexColumns(index, n.Columns)+ return index+}++func (e *omniMetadataExtractor) appendCheckConstraint(table *storepb.TableMetadata, n *ast.ConstraintDef) {+ check := &storepb.CheckConstraintMetadata{+ Name: n.Name,+ Expression: e.nodeText(n.Expr),+ }+ if table.CheckConstraints == nil {+ table.CheckConstraints = []*storepb.CheckConstraintMetadata{}+ }+ table.CheckConstraints = append(table.CheckConstraints, check)+}++func appendForeignKey(table *storepb.TableMetadata, n *ast.ConstraintDef, columns []string, fallbackSchema string) {+ fk := &storepb.ForeignKeyMetadata{+ Name: n.Name,+ Columns: columns,+ ReferencedColumns: stringNodeList(n.RefColumns),+ OnDelete: referentialAction(n.OnDelete),+ OnUpdate: referentialAction(n.OnUpdate),+ }+ if fk.OnDelete == "" {+ fk.OnDelete = noAction+ }+ if fk.OnUpdate == "" {+ fk.OnUpdate = noAction+ }+ if n.RefTable != nil {+ refSchema, refTable := tableRefSchemaObject(n.RefTable, fallbackSchema)+ fk.ReferencedSchema = refSchema+ fk.ReferencedTable = refTable+ }+ if table.ForeignKeys == nil {+ table.ForeignKeys = []*storepb.ForeignKeyMetadata{}+ }+ table.ForeignKeys = append(table.ForeignKeys, fk)+}++func (e *omniMetadataExtractor) extractExtendedProperty(n *ast.ExecStmt) {+ if n.Name == nil || !strings.EqualFold(n.Name.Object, "sp_addextendedproperty") {+ return+ }+ if n.Args == nil || len(n.Args.Items) < 6 {+ return+ }++ var args []string+ for _, item := range n.Args.Items {+ arg, ok := item.(*ast.ExecArg)+ if !ok || arg.Value == nil {+ continue+ }+ switch v := arg.Value.(type) {+ case *ast.Literal:+ args = append(args, v.Str)+ default:+ args = append(args, e.nodeText(v))+ }+ }+ if len(args) < 6 || !strings.EqualFold(args[0], "MS_Description") {+ return+ }++ comment := args[1]+ var schemaName, tableName, columnName string+ for i := 2; i < len(args)-1; i += 2 {+ switch strings.ToUpper(args[i]) {+ case "SCHEMA":+ schemaName = args[i+1]+ case "TABLE":+ tableName = args[i+1]+ case "COLUMN":+ columnName = args[i+1]+ default:+ }+ }+ if schemaName != "" && tableName != "" {+ e.applyComment(schemaName, tableName, columnName, comment)+ }+}++func (e *omniMetadataExtractor) applyComment(schemaName, tableName, columnName, comment string) {+ key := tableKey{schema: schemaName, table: tableName}+ table := e.tables[key]+ if table == nil {+ table = e.getOrCreateTable(schemaName, tableName)+ }+ if columnName != "" {+ for _, column := range table.Columns {+ if column.Name == columnName {+ column.Comment = comment+ return+ }+ }+ return+ }+ table.Comment = comment+}++func parseSpatialOptions(options *ast.List, index *storepb.IndexMetadata) {+ if options == nil {+ return+ }+ index.SpatialConfig.Storage = &storepb.StorageConfig{+ AllowRowLocks: true,+ AllowPageLocks: true,+ }+ for _, item := range options.Items {+ option, ok := item.(*ast.String)+ if !ok {+ continue+ }+ name, value, ok := strings.Cut(option.Str, "=")+ if !ok {+ continue+ }+ name = strings.ToUpper(strings.TrimSpace(name))+ value = strings.TrimSpace(value)+ switch name {+ case "BOUNDING_BOX":+ parseBoundingBox(value, index)+ case "GRIDS":+ parseGridLevels(value, index)+ case "CELLS_PER_OBJECT":+ if cellsPerObject, err := strconv.ParseInt(value, 10, 32); err == nil {+ index.SpatialConfig.Tessellation.CellsPerObject = int32(cellsPerObject)+ }+ case "PAD_INDEX", "FILLFACTOR", "SORT_IN_TEMPDB", "ONLINE", "ALLOW_ROW_LOCKS", "ALLOW_PAGE_LOCKS", "MAXDOP", "DATA_COMPRESSION":+ parseSpatialStorageOption(name, value, index)+ default:+ }+ }+}++func parseBoundingBox(value string, index *storepb.IndexMetadata) {+ value = strings.TrimSpace(strings.Trim(value, "()"))+ parts := strings.Split(value, ",")+ if len(parts) != 4 {+ return+ }+ var nums [4]float64+ for i, part := range parts {+ num, err := strconv.ParseFloat(strings.TrimSpace(part), 64)+ if err != nil {+ return+ }+ nums[i] = num+ }+ index.SpatialConfig.Tessellation.BoundingBox = &storepb.BoundingBox{+ Xmin: nums[0],+ Ymin: nums[1],+ Xmax: nums[2],+ Ymax: nums[3],+ }+}++func parseGridLevels(value string, index *storepb.IndexMetadata) {+ value = strings.TrimSpace(strings.Trim(value, "()"))+ var gridLevels []*storepb.GridLevel+ for _, part := range strings.Split(value, ",") {+ levelPart, densityPart, ok := strings.Cut(part, "=")+ if !ok {+ continue+ }+ levelPart = strings.TrimSpace(levelPart)+ densityPart = strings.TrimSpace(densityPart)+ var levelNum int32+ if strings.HasPrefix(strings.ToUpper(levelPart), "LEVEL_") {+ if num, err := strconv.ParseInt(levelPart[6:], 10, 32); err == nil {+ levelNum = int32(num)+ }+ }+ gridLevels = append(gridLevels, &storepb.GridLevel{+ Level: levelNum,+ Density: strings.ToUpper(densityPart),+ })+ }+ index.SpatialConfig.Tessellation.GridLevels = gridLevels+}++func parseSpatialStorageOption(name, value string, index *storepb.IndexMetadata) {+ if index.SpatialConfig.Storage == nil {+ index.SpatialConfig.Storage = &storepb.StorageConfig{}+ }+ storage := index.SpatialConfig.Storage+ switch name {+ case "PAD_INDEX":+ storage.PadIndex = strings.EqualFold(value, "ON")+ case "FILLFACTOR":+ if fillFactor, err := strconv.ParseInt(value, 10, 32); err == nil {+ storage.Fillfactor = int32(fillFactor)+ }+ case "SORT_IN_TEMPDB":+ storage.SortInTempdb = strings.ToUpper(value)+ case "ONLINE":+ storage.Online = strings.EqualFold(value, "ON")+ case "ALLOW_ROW_LOCKS":+ storage.AllowRowLocks = strings.EqualFold(value, "ON")+ case "ALLOW_PAGE_LOCKS":+ storage.AllowPageLocks = strings.EqualFold(value, "ON")+ case "MAXDOP":+ if maxdop, err := strconv.ParseInt(value, 10, 32); err == nil {+ storage.Maxdop = int32(maxdop)+ }+ case "DATA_COMPRESSION":+ storage.DataCompression = strings.ToUpper(value)+ default:+ }+}++func tableRefSchemaObject(ref *ast.TableRef, fallbackSchema string) (string, string) {+ if ref == nil {+ return fallbackSchema, ""+ }+ schemaName := ref.Schema+ if schemaName == "" {+ schemaName = fallbackSchema+ }+ return schemaName, ref.Object+}++func (e *omniMetadataExtractor) nodeText(node ast.Node) string {+ loc := ast.NodeLoc(node)+ if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {+ return ""+ }+ return e.schemaText[loc.Start:loc.End]+}++func (e *omniMetadataExtractor) definitionText(node ast.Node) string {+ loc := ast.NodeLoc(node)+ if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {+ return ""+ }+ end := loc.End+ for end < len(e.schemaText) {+ switch e.schemaText[end] {+ case ' ', '\t', '\r', '\n':+ end+++ default:+ if e.schemaText[end] == ';' {+ end+++ }+ return strings.TrimSpace(e.schemaText[loc.Start:end])+ }+ }+ return strings.TrimSpace(e.schemaText[loc.Start:end])+}++func indexType(columnstore bool, clustered *bool) string {+ if columnstore {+ if clustered != nil && *clustered {+ return "CLUSTERED COLUMNSTORE"+ }+ return "NONCLUSTERED COLUMNSTORE"+ }+ if clustered == nil {+ return ""+ }+ if *clustered {+ return "CLUSTERED"+ }+ return "NONCLUSTERED"+}++func appendIndexColumns(index *storepb.IndexMetadata, columns *ast.List) {+ if columns == nil {+ return+ }+ for _, item := range columns.Items {+ column, ok := item.(*ast.IndexColumn)+ if !ok {+ continue+ }+ index.Expressions = append(index.Expressions, column.Name)+ index.Descending = append(index.Descending, column.SortDir == ast.SortDesc)+ }+}++func indexColumnNames(columns *ast.List) []string {+ var names []string+ if columns == nil {+ return names+ }+ for _, item := range columns.Items {+ column, ok := item.(*ast.IndexColumn)+ if !ok {+ continue+ }+ names = append(names, column.Name)+ }+ return names+}++func stringNodeList(list *ast.List) []string {+ var result []string+ if list == nil {+ return result+ }+ for _, item := range list.Items {+ switch n := item.(type) {+ case *ast.String:+ result = append(result, n.Str)+ case *ast.IndexColumn:+ result = append(result, n.Name)+ default:+ }+ }+ return result+}++func referentialAction(action ast.ReferentialAction) string {+ switch action {+ case ast.RefActCascade:+ return "CASCADE"+ case ast.RefActSetNull:+ return "SET NULL"+ case ast.RefActSetDefault:+ return "SET DEFAULT"+ case ast.RefActNoAction:+ return noAction+ default:+ return ""+ }+}diff --git a/backend/plugin/schema/mssql/get_database_metadata_omni_test.go b/backend/plugin/schema/mssql/get_database_metadata_omni_test.gonew file mode 100644index 0000000000..6ea9f7a18f--- /dev/null+++ b/backend/plugin/schema/mssql/get_database_metadata_omni_test.go@@ -0,0 +1,86 @@+package mssql++import (+ "encoding/json"+ "io"+ "os"+ "testing"++ "github.com/stretchr/testify/require"+ "gopkg.in/yaml.v3"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++func TestGetDatabaseMetadataOmniParityWithANTLR(t *testing.T) {+ tests := []getDatabaseMetadataCase{}+ yamlFile, err := os.Open("test-data/test_get_database_metadata.yaml")+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ require.NoError(t, yaml.Unmarshal(byteValue, &tests))++ for _, tc := range tests {+ antlrMeta, err := getDatabaseMetadataANTLR(tc.Input)+ require.NoError(t, err, tc.Input)+ omniMeta, err := getDatabaseMetadataOmni(tc.Input)+ require.NoError(t, err, tc.Input)++ antlrJSON, err := json.MarshalIndent(antlrMeta, "", " ")+ require.NoError(t, err)+ omniJSON, err := json.MarshalIndent(omniMeta, "", " ")+ require.NoError(t, err)+ require.Equal(t, string(antlrJSON), string(omniJSON), tc.Input)+ }+}++func TestGetDatabaseMetadataOmniSequenceUsesExplicitSchema(t *testing.T) {+ metadata, err := getDatabaseMetadataOmni(`+CREATE SCHEMA audit;+CREATE SEQUENCE audit.EventSeq AS BIGINT;+`)+ require.NoError(t, err)++ require.Equal(t, []*storepb.SchemaMetadata{+ {+ Name: "audit",+ Tables: []*storepb.TableMetadata{},+ Sequences: []*storepb.SequenceMetadata{+ {+ Name: "EventSeq",+ DataType: "BIGINT",+ },+ },+ },+ }, metadata.Schemas)+}++func TestGetDatabaseMetadataOmniColumnForeignKeyUsesTableSchemaFallback(t *testing.T) {+ metadata, err := getDatabaseMetadataOmni(`+CREATE SCHEMA sales;+CREATE TABLE sales.customers (+ id INT PRIMARY KEY+);+CREATE TABLE sales.orders (+ id INT PRIMARY KEY,+ customer_id INT REFERENCES customers(id)+);+`)+ require.NoError(t, err)++ var orders *storepb.TableMetadata+ for _, table := range metadata.Schemas[0].Tables {+ if table.Name == "orders" {+ orders = table+ break+ }+ }+ require.NotNil(t, orders)+ require.Len(t, orders.ForeignKeys, 1)+ require.Equal(t, "sales", orders.ForeignKeys[0].ReferencedSchema)+ require.Equal(t, "customers", orders.ForeignKeys[0].ReferencedTable)+ require.Equal(t, []string{"customer_id"}, orders.ForeignKeys[0].Columns)+ require.Equal(t, []string{"id"}, orders.ForeignKeys[0].ReferencedColumns)+}diff --git a/go.mod b/go.modindex 81f364e8d3..9251d90ef7 100644--- a/go.mod+++ b/go.mod@@ -34,7 +34,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20260507034522-964293f6eb9c+ github.com/bytebase/omni v0.0.0-20260508022716-902da6c9bd2agithub.com/caarlos0/env/v11 v11.4.0github.com/cenkalti/backoff/v5 v5.0.3github.com/cockroachdb/cockroachdb-parser v0.25.2diff --git a/go.sum b/go.sumindex d3e81a0fa2..49d46530eb 100644--- a/go.sum+++ b/go.sum@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888 h1:E8tz8maxpih/vtgithub.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888/go.mod h1:IgLUOjyiHehdE0G3C92IjGYu9lJQgkPwf2mdNSvPWq8=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=-github.com/bytebase/omni v0.0.0-20260507034522-964293f6eb9c h1:UOKS5HxqTgiIkJHQO8+sp6zGpAoUCSyVtO4o7IgarBw=-github.com/bytebase/omni v0.0.0-20260507034522-964293f6eb9c/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=+github.com/bytebase/omni v0.0.0-20260508022716-902da6c9bd2a h1:YeNioujsdgU53DZONC8Zoi7Hx2CVht0F0hbn8PeAAu4=+github.com/bytebase/omni v0.0.0-20260508022716-902da6c9bd2a/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640 h1:g4Jed1/Jv/DHBiQmEgN5ILOQDDBjFlG4N4Lp+3B4aYE=github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=