chore: do not strip type cast

Author: tianzhou

internal/diff/table.go

@@ -2,7 +2,6 @@ package diff
 
 import (
 	"fmt"
-	"regexp"
 	"sort"
 	"strings"
 
@@ -1104,9 +1103,7 @@ func buildColumnClauses(column *ir.Column, isPartOfAnyPK bool, tableSchema strin
 			defaultValue = strings.ReplaceAll(defaultValue, schemaPrefix, "")
 		}
 
-		// Strip type qualifiers from default values
-		defaultValue = stripTypeQualifiers(defaultValue)
-
+		// Type casts are now preserved (from pg_query.Deparse) for canonical representation
 		parts = append(parts, fmt.Sprintf("DEFAULT %s", defaultValue))
 	}
 
@@ -1213,18 +1210,6 @@ func formatColumnDataTypeForCreate(column *ir.Column) string {
 	return dataType
 }
 
-// stripTypeQualifiers removes PostgreSQL type qualifiers from default values
-func stripTypeQualifiers(defaultValue string) string {
-	// Use regex to match any type qualifier pattern (::typename)
-	// This handles both built-in types and user-defined types like enums
-	re := regexp.MustCompile(`(.*)::[a-zA-Z_][a-zA-Z0-9_\s]*(\[\])?$`)
-	matches := re.FindStringSubmatch(defaultValue)
-	if len(matches) > 1 {
-		return matches[1]
-	}
-	return defaultValue
-}
-
 // indexesStructurallyEqual compares two indexes for structural equality
 // excluding comments and other metadata that don't require index recreation
 func indexesStructurallyEqual(oldIndex, newIndex *ir.Index) bool {

ir/formatter.go

@@ -219,6 +219,23 @@ func (f *postgreSQLFormatter) formatRangeSubselect(subselect *pg_query.RangeSubs
 	}
 }
 
+// formatExpressionWithTextCast formats an expression and adds ::text cast to string literals
+// This is used in CASE THEN/ELSE clauses to match PostgreSQL's canonical representation
+func (f *postgreSQLFormatter) formatExpressionWithTextCast(expr *pg_query.Node) {
+	// Check if this is a string constant that needs a ::text cast
+	if aConst := expr.GetAConst(); aConst != nil {
+		if aConst.GetSval() != nil {
+			// Format the string literal with ::text cast
+			f.formatAConst(aConst)
+			f.buffer.WriteString("::text")
+			return
+		}
+	}
+
+	// For other expressions, format normally
+	f.formatExpression(expr)
+}
+
 // formatExpression formats a general expression
 //
 // NOTE: Two important expression types for array operations:
@@ -558,14 +575,15 @@ func (f *postgreSQLFormatter) formatCaseExpr(caseExpr *pg_query.CaseExpr) {
 			f.buffer.WriteString(" WHEN ")
 			f.formatExpression(when.Expr)
 			f.buffer.WriteString(" THEN ")
-			f.formatExpressionStripCast(when.Result)
+			// Add ::text cast to string literals in THEN clause
+			f.formatExpressionWithTextCast(when.Result)
 		}
 	}
 
-	// Format ELSE clause, stripping unnecessary type casts from constants/NULL
+	// Format ELSE clause - add ::text cast to string literals
 	if caseExpr.Defresult != nil {
 		f.buffer.WriteString(" ELSE ")
-		f.formatExpressionStripCast(caseExpr.Defresult)
+		f.formatExpressionWithTextCast(caseExpr.Defresult)
 	}
 
 	f.buffer.WriteString(" END")
@@ -647,26 +665,6 @@ func (f *postgreSQLFormatter) formatNullTest(nullTest *pg_query.NullTest) {
 	}
 }
 
-// formatExpressionStripCast formats an expression, stripping unnecessary type casts from constants and NULL
-func (f *postgreSQLFormatter) formatExpressionStripCast(expr *pg_query.Node) {
-	// If this is a TypeCast of a constant or NULL, format just the value without the cast
-	if typeCast := expr.GetTypeCast(); typeCast != nil {
-		if typeCast.Arg != nil {
-			if aConst := typeCast.Arg.GetAConst(); aConst != nil {
-				// This is a typed constant, format just the constant value
-				f.formatAConst(aConst)
-				return
-			}
-			// For non-constant args, recursively strip casts
-			f.formatExpressionStripCast(typeCast.Arg)
-			return
-		}
-	}
-
-	// Otherwise, format normally
-	f.formatExpression(expr)
-}
-
 // formatAArrayExpr formats array expressions (ARRAY[...])
 func (f *postgreSQLFormatter) formatAArrayExpr(arrayExpr *pg_query.A_ArrayExpr) {
 	f.buffer.WriteString("ARRAY[")
@@ -682,17 +680,17 @@ func (f *postgreSQLFormatter) formatAArrayExpr(arrayExpr *pg_query.A_ArrayExpr)
 // formatArrayAsIN is a helper to format "column IN (values)" syntax
 // Used by both formatAExpr and formatScalarArrayOpExpr to convert "= ANY(ARRAY[...])" to "IN (...)"
 func (f *postgreSQLFormatter) formatArrayAsIN(leftExpr *pg_query.Node, arrayElements []*pg_query.Node) {
-	// Format left side (the column/expression)
-	f.formatExpressionStripCast(leftExpr)
+	// Format left side (the column/expression) - preserves type casts for canonical representation
+	f.formatExpression(leftExpr)
 
 	f.buffer.WriteString(" IN (")
 
-	// Format array elements as comma-separated list, stripping unnecessary type casts
+	// Format array elements as comma-separated list - preserves type casts for canonical representation
 	for i, elem := range arrayElements {
 		if i > 0 {
 			f.buffer.WriteString(", ")
 		}
-		f.formatExpressionStripCast(elem)
+		f.formatExpression(elem)
 	}
 
 	f.buffer.WriteString(")")

ir/normalize.go

@@ -112,28 +112,16 @@ func normalizeDefaultValue(value string) string {
 	}
 
 	// Handle type casting - remove explicit type casts that are semantically equivalent
-	// Pattern: ''::text -> ''
-	// Pattern: '{}'::jsonb -> '{}'
+	// Use regex to properly handle type casts within complex expressions
+	// Pattern: 'literal'::type -> 'literal' (removes redundant casts from string literals)
 	if strings.Contains(value, "::") {
-		// Find the cast and remove it for simple literal values
-		if strings.HasPrefix(value, "'") {
-			if idx := strings.Index(value, "'::"); idx != -1 {
-				// Find the closing quote
-				if closeIdx := strings.Index(value[1:], "'"); closeIdx != -1 {
-					literal := value[:closeIdx+2] // Include the closing quote
-					if literal == "''" || literal == "'{}'" {
-						value = literal
-					}
-				}
-			}
-		}
-		// Pattern: 'G'::schema.type_name -> 'G'
-		// Pattern: 'G'::type_name -> 'G'
-		if strings.Contains(value, "'::") {
-			if idx := strings.Index(value, "'::"); idx != -1 {
-				value = value[:idx+1]
-			}
-		}
+		// Use regex to match and remove type casts from string literals
+		// This handles: 'text'::text, 'utc'::text, '{}'::jsonb, '{}'::text[], etc.
+		// Pattern explanation:
+		// '([^']*)' - matches a quoted string literal (capturing the content)
+		// ::[\w.]+(\[\])? - matches ::typename or ::typename[] (including schema.typename and array types)
+		re := regexp.MustCompile(`'([^']*)'::[\w.]+(\[\])?`)
+		value = re.ReplaceAllString(value, "'$1'")
 	}
 
 	return value
@@ -891,7 +879,7 @@ func normalizeCheckClause(checkClause string) string {
 func normalizeExpressionWithPgQuery(expr string) string {
 	// Create a dummy SELECT statement with the expression to parse it
 	dummySQL := fmt.Sprintf("SELECT %s", expr)
-	
+
 	parseResult, err := pg_query.Parse(dummySQL)
 	if err != nil {
 		// If parsing fails, return empty string to trigger fallback
@@ -935,7 +923,7 @@ func removeRedundantNumericCasts(expr string) string {
 		re := regexp.MustCompile(pattern)
 		result = re.ReplaceAllString(result, "$1")
 	}
-	
+
 	return result
 }