Function normalizeCheckExpr

schema/normalize.go:269–580

normalizeCheckExpr normalizes a CHECK constraint expression AST for comparison mode parameter controls PostgreSQL-specific normalization (IN to ANY conversion)

(expr parser.Expr, mode GeneratorMode)

// normalizeCheckExpr normalizes a CHECK constraint expression AST for comparison
// mode parameter controls PostgreSQL-specific normalization (IN to ANY conversion)
func normalizeCheckExpr(expr parser.Expr, mode GeneratorMode) parser.Expr {
	if expr == nil {
		return nil
	}

	switch e := expr.(type) {
	case *parser.IntervalExpr:
		if mode == GeneratorModePostgres {
			return normalizeExpr(e, mode)
		}
		return expr
	case *parser.CastExpr:
		// Numeric/money/interval casts fold to a value-independent form, so reuse the
		// value-context path; otherwise CHECK keeps its own cast simplification below.
		if mode == GeneratorModePostgres && e.Type != nil && isFoldableValueCastTypeName(strings.ToLower(e.Type.Type)) {
			return normalizeExpr(e, mode)
		}
		// Remove certain casts that PostgreSQL simplifies
		// - text, character varying: Always removed
		// - date, timestamp without time zone: Removed when cast from string literals
		// - time, time without time zone: Kept but normalized (PostgreSQL preserves these for precision)
		if e.Type != nil {
			typeStr := strings.ToLower(e.Type.Type)

			// Always remove text casts
			if typeStr == "text" || typeStr == "character varying" {
				return normalizeCheckExpr(e.Expr, mode)
			}

			normalizedTypeStr := normalizeTypeName(typeStr, mode)

			// Remove date/timestamp casts from string literals
			// PostgreSQL simplifies '2020-01-01'::date to '2020-01-01' in CHECK constraints
			if normalizedTypeStr == "date" || normalizedTypeStr == "timestamp" {
				return normalizeCheckExpr(e.Expr, mode)
			}

			// Remove redundant array typecasts on ARRAY constructors
			// PostgreSQL normalizes ARRAY['a'::varchar]::text[] to ARRAY['a'::varchar::text]
			// by pushing down the array typecast to each element. Since we strip ::text casts
			// on elements, we also need to strip ::text[] on the ARRAY constructor itself.
			// e.g., ARRAY['a'::varchar]::text[] -> ARRAY['a'::varchar] (after stripping ::text[])
			//       ARRAY['a'::varchar::text]   -> ARRAY['a'::varchar] (after stripping ::text on element)
			// Empty arrays (ARRAY[]) need the typecast or PostgreSQL can't determine the type.
			normalizedExpr := normalizeCheckExpr(e.Expr, mode)
			if arrayConstructor, isArrayConstructor := normalizedExpr.(*parser.ArrayConstructor); isArrayConstructor {
				if strings.HasSuffix(typeStr, "[]") && len(arrayConstructor.Elements) > 0 {
					// Non-empty array with array typecast: strip the redundant typecast
					return normalizedExpr
				}
			}

			// For time types, keep the cast but use normalized type name
			return &parser.CastExpr{
				Expr: normalizedExpr,
				Type: &parser.ConvertType{Type: normalizedTypeStr},
			}
		}