feat: CREATE domain

Author: tianzhou

internal/diff/type.go

@@ -49,13 +49,24 @@ func generateCreateTypesSQL(w *SQLWriter, types []*ir.Type, targetSchema string)
 // generateModifyTypesSQL generates ALTER TYPE statements
 func generateModifyTypesSQL(w *SQLWriter, diffs []*TypeDiff, targetSchema string) {
 	for _, diff := range diffs {
-		// Only ENUM types can be modified by adding values
-		if diff.Old.Kind == ir.TypeKindEnum && diff.New.Kind == ir.TypeKindEnum {
-			// Generate ALTER TYPE ... ADD VALUE statements for new enum values
-			alterStatements := generateAlterTypeEnumStatements(diff.Old, diff.New, targetSchema)
-			for _, stmt := range alterStatements {
-				w.WriteDDLSeparator()
-				w.WriteString(stmt) // No comments for diff scenarios
+		switch diff.Old.Kind {
+		case ir.TypeKindEnum:
+			// ENUM types can be modified by adding values
+			if diff.New.Kind == ir.TypeKindEnum {
+				alterStatements := generateAlterTypeEnumStatements(diff.Old, diff.New, targetSchema)
+				for _, stmt := range alterStatements {
+					w.WriteDDLSeparator()
+					w.WriteString(stmt) // No comments for diff scenarios
+				}
+			}
+		case ir.TypeKindDomain:
+			// Domain types can be modified with ALTER DOMAIN
+			if diff.New.Kind == ir.TypeKindDomain {
+				alterStatements := generateAlterDomainStatements(diff.Old, diff.New, targetSchema)
+				for _, stmt := range alterStatements {
+					w.WriteDDLSeparator()
+					w.WriteString(stmt + "\n")
+				}
 			}
 		}
 	}
@@ -73,8 +84,18 @@ func generateDropTypesSQL(w *SQLWriter, types []*ir.Type, targetSchema string) {
 	for _, typeObj := range sortedTypes {
 		w.WriteDDLSeparator()
 		typeName := qualifyEntityName(typeObj.Schema, typeObj.Name, targetSchema)
-		sql := fmt.Sprintf("DROP TYPE IF EXISTS %s CASCADE;", typeName)
-		w.WriteStatementWithComment("TYPE", typeObj.Name, typeObj.Schema, "", sql, targetSchema)
+
+		var sql string
+		var objectType string
+		if typeObj.Kind == ir.TypeKindDomain {
+			sql = fmt.Sprintf("DROP DOMAIN IF EXISTS %s RESTRICT;", typeName)
+			objectType = "DOMAIN"
+		} else {
+			sql = fmt.Sprintf("DROP TYPE IF EXISTS %s RESTRICT;", typeName)
+			objectType = "TYPE"
+		}
+
+		w.WriteStatementWithComment(objectType, typeObj.Name, typeObj.Schema, "", sql, targetSchema)
 	}
 }
 
@@ -112,6 +133,80 @@ func generateAlterTypeEnumStatements(oldType, newType *ir.Type, targetSchema str
 	return statements
 }
 
+// generateAlterDomainStatements generates ALTER DOMAIN statements for domain changes
+func generateAlterDomainStatements(oldDomain, newDomain *ir.Type, targetSchema string) []string {
+	var statements []string
+	domainName := qualifyEntityName(newDomain.Schema, newDomain.Name, targetSchema)
+
+	// Check if default value changed
+	if oldDomain.Default != newDomain.Default {
+		if newDomain.Default == "" {
+			statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s DROP DEFAULT;", domainName))
+		} else {
+			statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s SET DEFAULT %s;", domainName, newDomain.Default))
+		}
+	}
+
+	// Check if NOT NULL changed
+	if oldDomain.NotNull != newDomain.NotNull {
+		if newDomain.NotNull {
+			statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s SET NOT NULL;", domainName))
+		} else {
+			statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s DROP NOT NULL;", domainName))
+		}
+	}
+
+	// Check constraints changes
+	// Create maps for easier comparison
+	oldConstraints := make(map[string]*ir.DomainConstraint)
+	for _, c := range oldDomain.Constraints {
+		key := c.Name
+		if key == "" {
+			key = c.Definition
+		}
+		oldConstraints[key] = c
+	}
+
+	newConstraints := make(map[string]*ir.DomainConstraint)
+	for _, c := range newDomain.Constraints {
+		key := c.Name
+		if key == "" {
+			key = c.Definition
+		}
+		newConstraints[key] = c
+	}
+
+	// Drop removed constraints
+	for key, oldConstraint := range oldConstraints {
+		if newConstraint, exists := newConstraints[key]; !exists {
+			// Constraint was removed
+			if oldConstraint.Name != "" {
+				statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s DROP CONSTRAINT %s;", domainName, oldConstraint.Name))
+			}
+			// Note: unnamed constraints cannot be dropped individually
+		} else if oldConstraint.Name != "" && oldConstraint.Definition != newConstraint.Definition {
+			// Constraint exists but definition changed - need to drop and recreate
+			statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s DROP CONSTRAINT %s;", domainName, oldConstraint.Name))
+		}
+	}
+
+	// Add new constraints
+	for key, newConstraint := range newConstraints {
+		oldConstraint, exists := oldConstraints[key]
+		if !exists || (exists && oldConstraint.Definition != newConstraint.Definition) {
+			// Either new constraint or definition changed
+			constraintDef := newConstraint.Definition
+			if newConstraint.Name != "" {
+				statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s ADD CONSTRAINT %s %s;", domainName, newConstraint.Name, constraintDef))
+			} else {
+				statements = append(statements, fmt.Sprintf("ALTER DOMAIN %s ADD %s;", domainName, constraintDef))
+			}
+		}
+	}
+
+	return statements
+}
+
 // generateTypeSQL generates CREATE TYPE statement
 func generateTypeSQL(typeObj *ir.Type, targetSchema string) string {
 	// Only include type name without schema if it's in the target schema
@@ -144,22 +239,35 @@ func generateTypeSQL(typeObj *ir.Type, targetSchema string) string {
 		}
 		return fmt.Sprintf("CREATE TYPE %s AS (%s);", typeName, strings.Join(attributes, ", "))
 	case ir.TypeKindDomain:
-		stmt := fmt.Sprintf("CREATE DOMAIN %s AS %s", typeName, typeObj.BaseType)
+		// Use multi-line format for better readability if there are constraints
+		hasConstraints := len(typeObj.Constraints) > 0 || typeObj.NotNull || typeObj.Default != ""
+
+		if !hasConstraints {
+			return fmt.Sprintf("CREATE DOMAIN %s AS %s;", typeName, typeObj.BaseType)
+		}
+
+		// Multi-line format
+		lines := []string{fmt.Sprintf("CREATE DOMAIN %s AS %s", typeName, typeObj.BaseType)}
+
 		if typeObj.Default != "" {
-			stmt += fmt.Sprintf(" DEFAULT %s", typeObj.Default)
+			lines = append(lines, fmt.Sprintf("  DEFAULT %s", typeObj.Default))
 		}
 		if typeObj.NotNull {
-			stmt += " NOT NULL"
+			lines = append(lines, "  NOT NULL")
 		}
+
 		// Add domain constraints (CHECK constraints)
+		// Normalize VALUE to uppercase for consistency
 		for _, constraint := range typeObj.Constraints {
+			constraintDef := constraint.Definition
 			if constraint.Name != "" {
-				stmt += fmt.Sprintf(" CONSTRAINT %s %s", constraint.Name, constraint.Definition)
+				lines = append(lines, fmt.Sprintf("  CONSTRAINT %s %s", constraint.Name, constraintDef))
 			} else {
-				stmt += fmt.Sprintf(" %s", constraint.Definition)
+				lines = append(lines, fmt.Sprintf("  %s", constraintDef))
 			}
 		}
-		return stmt + ";"
+
+		return strings.Join(lines, "\n") + ";"
 	default:
 		return fmt.Sprintf("CREATE TYPE %s;", typeName)
 	}

internal/ir/inspector.go

@@ -1507,6 +1507,11 @@ func (i *Inspector) buildTypes(ctx context.Context, schema *IR, targetSchema str
 		constraintName := i.safeInterfaceToString(constraint.ConstraintName)
 		constraintDef := i.safeInterfaceToString(constraint.ConstraintDefinition)
 
+		// Skip NOT NULL constraints as they are already captured in the NotNull boolean field
+		if constraintDef == "NOT NULL" {
+			continue
+		}
+
 		domainConstraint := &DomainConstraint{
 			Name:       constraintName,
 			Definition: constraintDef,

internal/ir/normalize.go

@@ -43,6 +43,11 @@ func normalizeSchema(schema *Schema) {
 	for _, procedure := range schema.Procedures {
 		normalizeProcedure(procedure)
 	}
+
+	// Normalize types (including domains)
+	for _, typeObj := range schema.Types {
+		normalizeType(typeObj)
+	}
 }
 
 // normalizeTable normalizes table-related objects
@@ -610,6 +615,78 @@ func isComplexExpression(expr string) bool {
 	return false
 }
 
+// normalizeType normalizes type-related objects, including domain constraints
+func normalizeType(typeObj *Type) {
+	if typeObj == nil || typeObj.Kind != TypeKindDomain {
+		return
+	}
+
+	// Normalize domain default value
+	if typeObj.Default != "" {
+		typeObj.Default = normalizeDomainDefault(typeObj.Default)
+	}
+
+	// Normalize domain constraints
+	for _, constraint := range typeObj.Constraints {
+		normalizeDomainConstraint(constraint)
+	}
+}
+
+// normalizeDomainDefault normalizes domain default values
+func normalizeDomainDefault(defaultValue string) string {
+	if defaultValue == "" {
+		return defaultValue
+	}
+
+	// Remove redundant type casts from string literals
+	// e.g., 'example@acme.com'::text -> 'example@acme.com'
+	defaultValue = regexp.MustCompile(`'([^']+)'::text\b`).ReplaceAllString(defaultValue, "'$1'")
+
+	return defaultValue
+}
+
+// normalizeDomainConstraint normalizes domain constraint definitions
+func normalizeDomainConstraint(constraint *DomainConstraint) {
+	if constraint == nil || constraint.Definition == "" {
+		return
+	}
+
+	def := constraint.Definition
+
+	// Normalize VALUE keyword to uppercase in domain constraints
+	// Use word boundaries to ensure we only match the identifier, not parts of other words
+	def = regexp.MustCompile(`\bvalue\b`).ReplaceAllStringFunc(def, func(match string) string {
+		return strings.ToUpper(match)
+	})
+
+	// Handle CHECK constraints
+	if strings.HasPrefix(def, "CHECK ") {
+		// Extract the expression inside CHECK (...)
+		checkMatch := regexp.MustCompile(`^CHECK\s*\((.*)\)$`).FindStringSubmatch(def)
+		if len(checkMatch) > 1 {
+			expr := checkMatch[1]
+			
+			// Remove outer parentheses if they wrap the entire expression
+			expr = strings.TrimSpace(expr)
+			if strings.HasPrefix(expr, "(") && strings.HasSuffix(expr, ")") {
+				inner := expr[1 : len(expr)-1]
+				if isBalancedParentheses(inner) {
+					expr = inner
+				}
+			}
+			
+			// Remove redundant type casts
+			// e.g., '...'::text -> '...'
+			expr = regexp.MustCompile(`'([^']+)'::text\b`).ReplaceAllString(expr, "'$1'")
+			
+			// Reconstruct the CHECK constraint
+			def = fmt.Sprintf("CHECK (%s)", expr)
+		}
+	}
+
+	constraint.Definition = def
+}
+
 // normalizePostgreSQLType normalizes PostgreSQL internal type names to standard SQL types.
 // This function handles both expressions (with type casts) and direct type names.
 func normalizePostgreSQLType(input string) string {

internal/ir/parser.go

@@ -2268,6 +2268,46 @@ func (p *Parser) parseCreateDomain(domainStmt *pg_query.CreateDomainStmt) error
 		BaseType: baseType,
 	}
 
+	// Parse domain constraints from the AST
+	if domainStmt.Constraints != nil {
+		for _, constraintNode := range domainStmt.Constraints {
+			if constraint := constraintNode.GetConstraint(); constraint != nil {
+				// Handle different constraint types
+				switch constraint.Contype {
+				case pg_query.ConstrType_CONSTR_NOTNULL:
+					// Set NOT NULL flag for domain
+					domainType.NotNull = true
+				case pg_query.ConstrType_CONSTR_DEFAULT:
+					// Extract default value from the constraint
+					if constraint.RawExpr != nil {
+						domainType.Default = p.extractExpressionText(constraint.RawExpr)
+					}
+				case pg_query.ConstrType_CONSTR_CHECK:
+					// Extract CHECK constraint
+					constraintDef := ""
+					if constraint.RawExpr != nil {
+						exprText := p.extractExpressionText(constraint.RawExpr)
+						constraintDef = fmt.Sprintf("CHECK %s", exprText)
+					}
+
+					if constraintDef != "" {
+						constraintName := constraint.Conname
+						// Auto-generate constraint name if not provided (matching PostgreSQL behavior)
+						if constraintName == "" {
+							constraintName = fmt.Sprintf("%s_check", domainName)
+						}
+
+						domainConstraint := &DomainConstraint{
+							Name:       constraintName,
+							Definition: constraintDef,
+						}
+						domainType.Constraints = append(domainType.Constraints, domainConstraint)
+					}
+				}
+			}
+		}
+	}
+
 	// Add type to schema
 	dbSchema.Types[domainName] = domainType
 

testdata/diff/create_domain/add_domain/migration.sql

@@ -0,0 +1,4 @@
+CREATE DOMAIN email_address AS text
+  DEFAULT 'example@acme.com'
+  NOT NULL
+  CONSTRAINT email_address_check CHECK (VALUE ~ '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$');

testdata/diff/create_domain/add_domain/new.sql

@@ -0,0 +1,4 @@
+CREATE DOMAIN email_address AS text 
+  DEFAULT 'example@acme.com'
+  NOT NULL
+  CHECK (VALUE ~ '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$');

testdata/diff/create_domain/add_domain/old.sql

@@ -0,0 +1 @@
+-- Empty schema (no domains)

testdata/diff/create_domain/change_domain/migration.sql

@@ -0,0 +1,5 @@
+ALTER DOMAIN user_rating SET DEFAULT 3;
+
+ALTER DOMAIN user_rating DROP CONSTRAINT user_rating_check;
+
+ALTER DOMAIN user_rating ADD CONSTRAINT user_rating_check CHECK ((VALUE >= 1) AND (VALUE <= 10));

testdata/diff/create_domain/change_domain/new.sql

@@ -0,0 +1,3 @@
+CREATE DOMAIN user_rating AS integer
+  DEFAULT 3
+  CHECK (VALUE >= 1 AND VALUE <= 10);

testdata/diff/create_domain/change_domain/old.sql

@@ -0,0 +1,2 @@
+CREATE DOMAIN user_rating AS integer
+  CHECK (VALUE >= 1 AND VALUE <= 5);