Function computeDiff

core/schema_diff.go:209–419

computeDiff computes the difference between current and expected schemas

(current, expected *sdata.DBInfo, opts DiffOptions)

// computeDiff computes the difference between current and expected schemas
func computeDiff(current, expected *sdata.DBInfo, opts DiffOptions) []SchemaOperation {
	dialect := getDDLDialect(expected.Type)
	if dialect == nil {
		dialect = getDDLDialect(current.Type)
	}
	if dialect == nil {
		return nil
	}

	var ops []SchemaOperation

	// Build maps for efficient lookup
	currentTables := make(map[string]*sdata.DBTable)
	for i := range current.Tables {
		t := &current.Tables[i]
		currentTables[t.Name] = t
	}

	expectedTables := make(map[string]*sdata.DBTable)
	for i := range expected.Tables {
		t := &expected.Tables[i]
		expectedTables[t.Name] = t
	}

	// Find tables to create
	// Sort tables to create parent tables before children (FK dependency order)
	sortedTables := sortTablesByDependency(expected.Tables)
	for _, expTable := range sortedTables {
		if _, exists := currentTables[expTable.Name]; !exists {
			sql := dialect.CreateTable(expTable)
			ops = append(ops, SchemaOperation{
				Type:  "create_table",
				Table: expTable.Name,
				SQL:   sql,
			})

			// Add indexes for searchable, unique, and indexed columns
			for _, col := range expTable.Columns {
				if col.FullText {
					sql := dialect.CreateSearchIndex(expTable.Name, col)
					if sql != "" {
						ops = append(ops, SchemaOperation{
							Type:   "add_index",
							Table:  expTable.Name,
							Column: col.Name,
							SQL:    sql,
						})
					}
				}
				if col.UniqueKey && !col.PrimaryKey {
					sql := dialect.CreateUniqueIndex(expTable.Name, col)
					if sql != "" {
						ops = append(ops, SchemaOperation{
							Type:   "add_index",
							Table:  expTable.Name,
							Column: col.Name,
							SQL:    sql,
						})