warkanum
a32647ee16
- merge: cloneTable keeps relationships; skip-tables applies to new schemas - diff: detect schema description/owner changes - prisma: reader no longer turns relation fields into columns, enum detection via declared names; writer type mapping is ordered - typeorm writer: keep explicit SQL types that cannot be inferred - drizzle: enum columns call the enum constant; reader resolves them - mysql/mssql/sqlite writers: honour OutputPath, deterministic column and constraint order; mssql live execute covers full schema - template: ToYAML recovers from panics; Merge nil-pointer loop - regenerate drizzle fixtures
588 lines
17 KiB
Go
588 lines
17 KiB
Go
package mssql
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
|
|
_ "github.com/microsoft/go-mssqldb" // MSSQL driver
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
"git.warky.dev/wdevs/relspecgo/pkg/mssql"
|
|
"git.warky.dev/wdevs/relspecgo/pkg/writers"
|
|
)
|
|
|
|
// Writer implements the Writer interface for MSSQL SQL output
|
|
type Writer struct {
|
|
options *writers.WriterOptions
|
|
writer io.Writer
|
|
}
|
|
|
|
// NewWriter creates a new MSSQL SQL writer
|
|
func NewWriter(options *writers.WriterOptions) *Writer {
|
|
return &Writer{
|
|
options: options,
|
|
}
|
|
}
|
|
|
|
// qualTable returns a schema-qualified name using bracket notation
|
|
func (w *Writer) qualTable(schema, name string) string {
|
|
if w.options.FlattenSchema {
|
|
return fmt.Sprintf("[%s]", name)
|
|
}
|
|
return fmt.Sprintf("[%s].[%s]", schema, name)
|
|
}
|
|
|
|
// WriteDatabase writes the entire database schema as SQL
|
|
func (w *Writer) WriteDatabase(db *models.Database) error {
|
|
// Check if we should execute SQL directly on a database
|
|
if connString, ok := w.options.Metadata["connection_string"].(string); ok && connString != "" {
|
|
return w.executeDatabaseSQL(db, connString)
|
|
}
|
|
|
|
release, err := w.openOutput()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer release()
|
|
|
|
// Write header comment
|
|
fmt.Fprintf(w.writer, "-- MSSQL Database Schema\n")
|
|
fmt.Fprintf(w.writer, "-- Database: %s\n", db.Name)
|
|
fmt.Fprintf(w.writer, "-- Generated by RelSpec\n\n")
|
|
|
|
// Process each schema in the database
|
|
for _, schema := range db.Schemas {
|
|
if err := w.WriteSchema(schema); err != nil {
|
|
return fmt.Errorf("failed to write schema %s: %w", schema.Name, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// openOutput points w.writer at the configured destination (output file or
|
|
// stdout) when none is set, and returns a func that releases it again.
|
|
func (w *Writer) openOutput() (func(), error) {
|
|
if w.writer != nil {
|
|
return func() {}, nil
|
|
}
|
|
if w.options.OutputPath != "" {
|
|
file, err := os.Create(w.options.OutputPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create output file: %w", err)
|
|
}
|
|
w.writer = file
|
|
return func() {
|
|
file.Close()
|
|
w.writer = nil
|
|
}, nil
|
|
}
|
|
w.writer = os.Stdout
|
|
return func() { w.writer = nil }, nil
|
|
}
|
|
|
|
// WriteSchema writes a single schema and all its tables
|
|
func (w *Writer) WriteSchema(schema *models.Schema) error {
|
|
release, err := w.openOutput()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer release()
|
|
|
|
// Phase 1: Create schema (skip dbo schema and when flattening)
|
|
if schema.Name != "dbo" && !w.options.FlattenSchema {
|
|
fmt.Fprintf(w.writer, "-- Schema: %s\n", schema.Name)
|
|
fmt.Fprintf(w.writer, "CREATE SCHEMA [%s];\n\n", schema.Name)
|
|
}
|
|
|
|
// Phase 2: Create tables with columns
|
|
fmt.Fprintf(w.writer, "-- Tables for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeCreateTable(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 3: Primary keys
|
|
fmt.Fprintf(w.writer, "-- Primary keys for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writePrimaryKey(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 4: Indexes
|
|
fmt.Fprintf(w.writer, "-- Indexes for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeIndexes(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 5: Unique constraints
|
|
fmt.Fprintf(w.writer, "-- Unique constraints for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeUniqueConstraints(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 6: Check constraints
|
|
fmt.Fprintf(w.writer, "-- Check constraints for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeCheckConstraints(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 7: Foreign keys
|
|
fmt.Fprintf(w.writer, "-- Foreign keys for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeForeignKeys(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Phase 8: Comments
|
|
fmt.Fprintf(w.writer, "-- Comments for schema: %s\n", schema.Name)
|
|
for _, table := range schema.Tables {
|
|
if err := w.writeComments(schema, table); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// WriteTable writes a single table with all its elements
|
|
func (w *Writer) WriteTable(table *models.Table) error {
|
|
release, err := w.openOutput()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer release()
|
|
|
|
// Create a temporary schema with just this table
|
|
schema := models.InitSchema(table.Schema)
|
|
schema.Tables = append(schema.Tables, table)
|
|
|
|
return w.WriteSchema(schema)
|
|
}
|
|
|
|
// writeCreateTable generates CREATE TABLE statement
|
|
func (w *Writer) writeCreateTable(schema *models.Schema, table *models.Table) error {
|
|
fmt.Fprintf(w.writer, "CREATE TABLE %s (\n", w.qualTable(schema.Name, table.Name))
|
|
|
|
// Sort columns by sequence
|
|
columns := getSortedColumns(table.Columns)
|
|
columnDefs := make([]string, 0, len(columns))
|
|
|
|
for _, col := range columns {
|
|
def := w.generateColumnDefinition(col)
|
|
columnDefs = append(columnDefs, " "+def)
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "%s\n", strings.Join(columnDefs, ",\n"))
|
|
fmt.Fprintf(w.writer, ");\n\n")
|
|
|
|
return nil
|
|
}
|
|
|
|
// generateColumnDefinition generates MSSQL column definition
|
|
func (w *Writer) generateColumnDefinition(col *models.Column) string {
|
|
parts := []string{fmt.Sprintf("[%s]", col.Name)}
|
|
|
|
// Computed column: "name AS (expr) PERSISTED" has no data type and cannot carry
|
|
// IDENTITY or a DEFAULT. PERSISTED mirrors the stored semantics of Column.Generated.
|
|
if col.Generated && col.GenerationExpression != "" {
|
|
parts = append(parts, fmt.Sprintf("AS (%s) PERSISTED", col.GenerationExpression))
|
|
if col.NotNull {
|
|
parts = append(parts, "NOT NULL")
|
|
}
|
|
return strings.Join(parts, " ")
|
|
}
|
|
|
|
// Type with length/precision
|
|
baseType := mssql.ConvertCanonicalToMSSQL(col.Type)
|
|
typeStr := baseType
|
|
|
|
// Handle specific type parameters for MSSQL
|
|
if col.Length > 0 && col.Precision == 0 {
|
|
// String types with length - override the default length from baseType
|
|
if strings.HasPrefix(baseType, "NVARCHAR") || strings.HasPrefix(baseType, "VARCHAR") ||
|
|
strings.HasPrefix(baseType, "CHAR") || strings.HasPrefix(baseType, "NCHAR") {
|
|
if col.Length > 0 && col.Length < 8000 {
|
|
// Extract base type without length specification
|
|
baseName := strings.Split(baseType, "(")[0]
|
|
typeStr = fmt.Sprintf("%s(%d)", baseName, col.Length)
|
|
}
|
|
}
|
|
} else if col.Precision > 0 {
|
|
// Numeric types with precision/scale
|
|
baseName := strings.Split(baseType, "(")[0]
|
|
if col.Scale > 0 {
|
|
typeStr = fmt.Sprintf("%s(%d,%d)", baseName, col.Precision, col.Scale)
|
|
} else {
|
|
typeStr = fmt.Sprintf("%s(%d)", baseName, col.Precision)
|
|
}
|
|
}
|
|
|
|
parts = append(parts, typeStr)
|
|
|
|
// IDENTITY for auto-increment
|
|
if col.AutoIncrement || col.Identity {
|
|
parts = append(parts, "IDENTITY(1,1)")
|
|
}
|
|
|
|
// NOT NULL
|
|
if col.NotNull {
|
|
parts = append(parts, "NOT NULL")
|
|
}
|
|
|
|
// DEFAULT
|
|
if col.Default != nil {
|
|
switch v := col.Default.(type) {
|
|
case string:
|
|
cleanDefault := stripBackticks(v)
|
|
if strings.HasPrefix(strings.ToUpper(cleanDefault), "GETDATE") ||
|
|
strings.HasPrefix(strings.ToUpper(cleanDefault), "CURRENT_") {
|
|
parts = append(parts, fmt.Sprintf("DEFAULT %s", cleanDefault))
|
|
} else if cleanDefault == "true" || cleanDefault == "false" {
|
|
if cleanDefault == "true" {
|
|
parts = append(parts, "DEFAULT 1")
|
|
} else {
|
|
parts = append(parts, "DEFAULT 0")
|
|
}
|
|
} else {
|
|
parts = append(parts, fmt.Sprintf("DEFAULT '%s'", escapeQuote(cleanDefault)))
|
|
}
|
|
case bool:
|
|
if v {
|
|
parts = append(parts, "DEFAULT 1")
|
|
} else {
|
|
parts = append(parts, "DEFAULT 0")
|
|
}
|
|
case int, int64:
|
|
parts = append(parts, fmt.Sprintf("DEFAULT %v", v))
|
|
}
|
|
}
|
|
|
|
return strings.Join(parts, " ")
|
|
}
|
|
|
|
// writePrimaryKey generates ALTER TABLE statement for primary key
|
|
func (w *Writer) writePrimaryKey(schema *models.Schema, table *models.Table) error {
|
|
// Find primary key constraint
|
|
var pkConstraint *models.Constraint
|
|
for _, constraint := range table.Constraints {
|
|
if constraint.Type == models.PrimaryKeyConstraint {
|
|
pkConstraint = constraint
|
|
break
|
|
}
|
|
}
|
|
|
|
var columnNames []string
|
|
pkName := fmt.Sprintf("PK_%s_%s", schema.Name, table.Name)
|
|
|
|
if pkConstraint != nil {
|
|
pkName = pkConstraint.Name
|
|
columnNames = make([]string, 0, len(pkConstraint.Columns))
|
|
for _, colName := range pkConstraint.Columns {
|
|
columnNames = append(columnNames, fmt.Sprintf("[%s]", colName))
|
|
}
|
|
} else {
|
|
// Check for columns with IsPrimaryKey = true
|
|
for _, col := range table.Columns {
|
|
if col.IsPrimaryKey {
|
|
columnNames = append(columnNames, fmt.Sprintf("[%s]", col.Name))
|
|
}
|
|
}
|
|
sort.Strings(columnNames)
|
|
}
|
|
|
|
if len(columnNames) == 0 {
|
|
return nil
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "ALTER TABLE %s ADD CONSTRAINT [%s] PRIMARY KEY (%s);\n\n",
|
|
w.qualTable(schema.Name, table.Name), pkName, strings.Join(columnNames, ", "))
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeIndexes generates CREATE INDEX statements
|
|
func (w *Writer) writeIndexes(schema *models.Schema, table *models.Table) error {
|
|
// Sort indexes by name
|
|
indexNames := make([]string, 0, len(table.Indexes))
|
|
for name := range table.Indexes {
|
|
indexNames = append(indexNames, name)
|
|
}
|
|
sort.Strings(indexNames)
|
|
|
|
for _, name := range indexNames {
|
|
index := table.Indexes[name]
|
|
|
|
// Skip if it's a primary key index
|
|
if strings.HasPrefix(strings.ToLower(index.Name), "pk_") {
|
|
continue
|
|
}
|
|
|
|
// Build column list
|
|
columnExprs := make([]string, 0, len(index.Columns))
|
|
for _, colName := range index.Columns {
|
|
columnExprs = append(columnExprs, fmt.Sprintf("[%s]", colName))
|
|
}
|
|
|
|
if len(columnExprs) == 0 {
|
|
continue
|
|
}
|
|
|
|
unique := ""
|
|
if index.Unique {
|
|
unique = "UNIQUE "
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "CREATE %sINDEX [%s] ON %s (%s);\n\n",
|
|
unique, index.Name, w.qualTable(schema.Name, table.Name), strings.Join(columnExprs, ", "))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeUniqueConstraints generates ALTER TABLE statements for unique constraints
|
|
func (w *Writer) writeUniqueConstraints(schema *models.Schema, table *models.Table) error {
|
|
// Sort constraints by name
|
|
constraintNames := make([]string, 0)
|
|
for name, constraint := range table.Constraints {
|
|
if constraint.Type == models.UniqueConstraint {
|
|
constraintNames = append(constraintNames, name)
|
|
}
|
|
}
|
|
sort.Strings(constraintNames)
|
|
|
|
for _, name := range constraintNames {
|
|
constraint := table.Constraints[name]
|
|
|
|
// Build column list
|
|
columnExprs := make([]string, 0, len(constraint.Columns))
|
|
for _, colName := range constraint.Columns {
|
|
columnExprs = append(columnExprs, fmt.Sprintf("[%s]", colName))
|
|
}
|
|
|
|
if len(columnExprs) == 0 {
|
|
continue
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "ALTER TABLE %s ADD CONSTRAINT [%s] UNIQUE (%s);\n\n",
|
|
w.qualTable(schema.Name, table.Name), constraint.Name, strings.Join(columnExprs, ", "))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeCheckConstraints generates ALTER TABLE statements for check constraints
|
|
func (w *Writer) writeCheckConstraints(schema *models.Schema, table *models.Table) error {
|
|
// Sort constraints by name
|
|
constraintNames := make([]string, 0)
|
|
for name, constraint := range table.Constraints {
|
|
if constraint.Type == models.CheckConstraint {
|
|
constraintNames = append(constraintNames, name)
|
|
}
|
|
}
|
|
sort.Strings(constraintNames)
|
|
|
|
for _, name := range constraintNames {
|
|
constraint := table.Constraints[name]
|
|
|
|
if constraint.Expression == "" {
|
|
continue
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "ALTER TABLE %s ADD CONSTRAINT [%s] CHECK (%s);\n\n",
|
|
w.qualTable(schema.Name, table.Name), constraint.Name, constraint.Expression)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeForeignKeys generates ALTER TABLE statements for foreign keys
|
|
func (w *Writer) writeForeignKeys(schema *models.Schema, table *models.Table) error {
|
|
// Process foreign key constraints
|
|
constraintNames := make([]string, 0)
|
|
for name, constraint := range table.Constraints {
|
|
if constraint.Type == models.ForeignKeyConstraint {
|
|
constraintNames = append(constraintNames, name)
|
|
}
|
|
}
|
|
sort.Strings(constraintNames)
|
|
|
|
for _, name := range constraintNames {
|
|
constraint := table.Constraints[name]
|
|
|
|
// Build column lists
|
|
sourceColumns := make([]string, 0, len(constraint.Columns))
|
|
for _, colName := range constraint.Columns {
|
|
sourceColumns = append(sourceColumns, fmt.Sprintf("[%s]", colName))
|
|
}
|
|
|
|
targetColumns := make([]string, 0, len(constraint.ReferencedColumns))
|
|
for _, colName := range constraint.ReferencedColumns {
|
|
targetColumns = append(targetColumns, fmt.Sprintf("[%s]", colName))
|
|
}
|
|
|
|
if len(sourceColumns) == 0 || len(targetColumns) == 0 {
|
|
continue
|
|
}
|
|
|
|
refSchema := constraint.ReferencedSchema
|
|
if refSchema == "" {
|
|
refSchema = schema.Name
|
|
}
|
|
|
|
onDelete := "NO ACTION"
|
|
if constraint.OnDelete != "" {
|
|
onDelete = strings.ToUpper(constraint.OnDelete)
|
|
}
|
|
|
|
onUpdate := "NO ACTION"
|
|
if constraint.OnUpdate != "" {
|
|
onUpdate = strings.ToUpper(constraint.OnUpdate)
|
|
}
|
|
|
|
fmt.Fprintf(w.writer, "ALTER TABLE %s ADD CONSTRAINT [%s] FOREIGN KEY (%s)\n",
|
|
w.qualTable(schema.Name, table.Name), constraint.Name, strings.Join(sourceColumns, ", "))
|
|
fmt.Fprintf(w.writer, " REFERENCES %s (%s)\n",
|
|
w.qualTable(refSchema, constraint.ReferencedTable), strings.Join(targetColumns, ", "))
|
|
fmt.Fprintf(w.writer, " ON DELETE %s ON UPDATE %s;\n\n",
|
|
onDelete, onUpdate)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeComments generates EXEC sp_addextendedproperty statements for table and column descriptions
|
|
func (w *Writer) writeComments(schema *models.Schema, table *models.Table) error {
|
|
// Table comment
|
|
if table.Description != "" {
|
|
fmt.Fprintf(w.writer, "EXEC sp_addextendedproperty\n")
|
|
fmt.Fprintf(w.writer, " @name = 'MS_Description',\n")
|
|
fmt.Fprintf(w.writer, " @value = '%s',\n", escapeQuote(table.Description))
|
|
fmt.Fprintf(w.writer, " @level0type = 'SCHEMA', @level0name = '%s',\n", schema.Name)
|
|
fmt.Fprintf(w.writer, " @level1type = 'TABLE', @level1name = '%s';\n\n", table.Name)
|
|
}
|
|
|
|
// Column comments
|
|
for _, col := range getSortedColumns(table.Columns) {
|
|
if col.Description != "" {
|
|
fmt.Fprintf(w.writer, "EXEC sp_addextendedproperty\n")
|
|
fmt.Fprintf(w.writer, " @name = 'MS_Description',\n")
|
|
fmt.Fprintf(w.writer, " @value = '%s',\n", escapeQuote(col.Description))
|
|
fmt.Fprintf(w.writer, " @level0type = 'SCHEMA', @level0name = '%s',\n", schema.Name)
|
|
fmt.Fprintf(w.writer, " @level1type = 'TABLE', @level1name = '%s',\n", table.Name)
|
|
fmt.Fprintf(w.writer, " @level2type = 'COLUMN', @level2name = '%s';\n\n", col.Name)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// executeDatabaseSQL executes the full generated schema (tables, keys,
|
|
// indexes, constraints and comments) directly on an MSSQL database.
|
|
func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) error {
|
|
statements, err := w.generateStatements(db)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Connect to database
|
|
dbConn, err := sql.Open("mssql", connString)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to connect to database: %w", err)
|
|
}
|
|
defer dbConn.Close()
|
|
|
|
ctx := context.Background()
|
|
if err = dbConn.PingContext(ctx); err != nil {
|
|
return fmt.Errorf("failed to ping database: %w", err)
|
|
}
|
|
|
|
// Execute statements
|
|
executedCount := 0
|
|
for i, stmt := range statements {
|
|
fmt.Fprintf(os.Stderr, "Executing statement %d/%d...\n", i+1, len(statements))
|
|
|
|
if _, execErr := dbConn.ExecContext(ctx, stmt); execErr != nil {
|
|
fmt.Fprintf(os.Stderr, "⚠ Warning: Statement failed: %v\n", execErr)
|
|
continue
|
|
}
|
|
|
|
executedCount++
|
|
}
|
|
|
|
fmt.Fprintf(os.Stderr, "✓ Successfully executed %d statements\n", executedCount)
|
|
return nil
|
|
}
|
|
|
|
// generateStatements renders the same script WriteDatabase would produce and
|
|
// splits it into individually executable statements (comments removed).
|
|
func (w *Writer) generateStatements(db *models.Database) ([]string, error) {
|
|
var buf strings.Builder
|
|
saved := w.writer
|
|
w.writer = &buf
|
|
defer func() { w.writer = saved }()
|
|
|
|
for _, schema := range db.Schemas {
|
|
if err := w.WriteSchema(schema); err != nil {
|
|
return nil, fmt.Errorf("failed to generate statements for schema %s: %w", schema.Name, err)
|
|
}
|
|
}
|
|
|
|
// Every statement the writer emits ends with ";\n\n".
|
|
var statements []string
|
|
for _, chunk := range strings.Split(buf.String(), ";\n\n") {
|
|
lines := make([]string, 0)
|
|
for _, line := range strings.Split(chunk, "\n") {
|
|
if !strings.HasPrefix(strings.TrimSpace(line), "--") {
|
|
lines = append(lines, line)
|
|
}
|
|
}
|
|
if stmt := strings.TrimSpace(strings.Join(lines, "\n")); stmt != "" {
|
|
statements = append(statements, stmt)
|
|
}
|
|
}
|
|
return statements, nil
|
|
}
|
|
|
|
// Helper functions
|
|
|
|
// getSortedColumns returns columns sorted by sequence, then by name so that
|
|
// columns without a sequence still come out in a stable order.
|
|
func getSortedColumns(columns map[string]*models.Column) []*models.Column {
|
|
sorted := make([]*models.Column, 0, len(columns))
|
|
for _, col := range columns {
|
|
sorted = append(sorted, col)
|
|
}
|
|
sort.Slice(sorted, func(i, j int) bool {
|
|
if sorted[i].Sequence != sorted[j].Sequence {
|
|
return sorted[i].Sequence < sorted[j].Sequence
|
|
}
|
|
return sorted[i].Name < sorted[j].Name
|
|
})
|
|
return sorted
|
|
}
|
|
|
|
// escapeQuote escapes single quotes in strings for SQL
|
|
func escapeQuote(s string) string {
|
|
return strings.ReplaceAll(s, "'", "''")
|
|
}
|
|
|
|
// stripBackticks removes backticks from SQL expressions
|
|
func stripBackticks(s string) string {
|
|
return strings.ReplaceAll(s, "`", "")
|
|
}
|