Method generateAlterDomainDDLs

schema/generator.go:2594–2642

(current, desired *Domain)

}

func (g *Generator) generateAlterDomainDDLs(current, desired *Domain) ([]string, error) {
	var ddls []string
	domainName := g.escapeDomainName(current)

	if !g.areSameDefaultValue(current.defaultValue, desired.defaultValue, current.dataType) {
		if desired.defaultValue == nil {
			ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s DROP DEFAULT", domainName))
		} else {
			normalizedExpr := normalizeExpr(desired.defaultValue.expression, g.mode)
			exprStr := parser.String(normalizedExpr)
			ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s SET DEFAULT %s", domainName, exprStr))
		}
	}

	if current.notNull != desired.notNull {
		if desired.notNull {
			ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s SET NOT NULL", domainName))
		} else {
			ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s DROP NOT NULL", domainName))
		}
	}

	for _, currentConstraint := range current.constraints {
		if !g.findDomainConstraintByExpression(desired.constraints, currentConstraint.expression) {
			if currentConstraint.name != "" {
				ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s DROP CONSTRAINT %s",
					domainName, currentConstraint.name))
			}
		}
	}

	for _, desiredConstraint := range desired.constraints {
		if !g.findDomainConstraintByExpression(current.constraints, desiredConstraint.expression) {
			exprStr := parser.String(desiredConstraint.expression)
			if desiredConstraint.name != "" {
				ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s ADD CONSTRAINT %s CHECK (%s)",
					domainName, desiredConstraint.name, exprStr))
			} else {
				ddls = append(ddls, fmt.Sprintf("ALTER DOMAIN %s ADD CHECK (%s)",
					domainName, exprStr))
			}
		}
	}

	// Note: We don't handle collation changes as PostgreSQL doesn't support changing collation via ALTER DOMAIN
	// The user would need to drop and recreate the domain to change collation

	return ddls, nil
}

func (g *Generator) findDomainConstraintByExpression(constraints []DomainConstraint, expression parser.Expr) bool {
	normalizedExpr := normalizeCheckExpr(expression, g.mode)