validation

func ClassifyStatements ¶

func ClassifyStatements(sql string) ([]ClassifiedStatement, error)

ClassifyStatements parses a SQL script with the real PostgreSQL parser (pg_query) and classifies every top-level statement. Statement splitting is therefore correct in the presence of dollar-quoted bodies, string literals, and comments. A parse failure returns an error; callers implementing safety gates must fail closed on error.

func CompareCatalogSnapshots ¶

func CompareCatalogSnapshots(original, candidate *CatalogSnapshot) (*SchemaDiff, error)

CompareCatalogSnapshots compares portable catalog snapshots without a live database.

func ValidateSchemaDiff ¶

func ValidateSchemaDiff(schema1, schema2 string) (*SchemaDiff, error)

ValidateSchemaDiff performs a direct schema difference comparison between two schema strings. It normalizes both schemas using the default normalizer and returns the differences.

This is useful for pre-flight checks where you have the raw SQL of two schemas (e.g. pg_dump output) and want to see if they are equivalent.

func NewValidator ¶

func NewValidator(config *ValidationConfig) *SchemaValidator

NewValidator creates a new schema validator with the given configuration

Example:

config := validation.DefaultConfig()
config.DockerApproach = validation.ApproachTwoDatabases
validator := validation.NewValidator(config)

func NewPostFlightValidator ¶

func NewPostFlightValidator() *StaticValidator

NewPostFlightValidator returns a validator optimized for final verification (strict)

func NewPreFlightValidator ¶

func NewPreFlightValidator() *StaticValidator

NewPreFlightValidator returns a validator optimized for initial checks (fast, hygiene focused)

func NewStaticValidator ¶

func NewStaticValidator(config *StaticValidatorConfig) *StaticValidator

NewStaticValidator creates a new static validator with configured rules

func BuildStaticValidatorConfig ¶

func BuildStaticValidatorConfig(base *StaticValidatorConfig, enableRules, disableRules []string, strict bool) (*StaticValidatorConfig, error)

BuildStaticValidatorConfig applies runtime overrides (enable/disable/strict) to a base static-validator config and returns the resolved validator config.

func CloneStaticValidatorConfig ¶

func CloneStaticValidatorConfig(conf *StaticValidatorConfig) *StaticValidatorConfig

CloneStaticValidatorConfig returns a deep copy of the provided static-validator config. If conf is nil, it returns a copy of the engine defaults.

func DefaultStaticValidatorConfig ¶

func DefaultStaticValidatorConfig() *StaticValidatorConfig

DefaultStaticValidatorConfig returns a copy of the engine default static-validator config.

func MergeStaticValidatorConfig ¶

func MergeStaticValidatorConfig(base, overlay *StaticValidatorConfig) *StaticValidatorConfig

MergeStaticValidatorConfig overlays `overlay` onto `base` using engine semantics: - EnabledRules: if overlay has values, they replace base enabled rules. - RuleOptions: deep-merged (base first, then overlay keys overwrite). - TreatWarningsAsErrors: overlay value replaces base value.

If base is nil, engine defaults are used.

func DefaultConfig ¶

func DefaultConfig() *ValidationConfig

DefaultConfig returns a recommended configuration for validation

func QuickValidate ¶

func QuickValidate(ctx context.Context, originalDir, squashedDir string) (*ValidationResult, error)

QuickValidate is a convenience function for fast validation with minimal setup. Uses the fastest validation approach (SchemaDiff) for quick feedback.

This is ideal for CI/CD pipelines or rapid development iteration where speed is more important than exhaustive validation.

Example:

result, err := validation.QuickValidate(context.Background(), "./original", "./squashed")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Validation: %v (took %s)\n", result.Success, result.Duration)

func ThoroughValidate ¶

func ThoroughValidate(ctx context.Context, originalDir, squashedDir string) (*ValidationResult, error)

ThoroughValidate performs comprehensive validation with all checks enabled. Uses the most accurate validation approach (TwoContainers) for maximum confidence.

This is recommended for production releases, final validation before deployment, or when schema accuracy is critical.

Example:

result, err := validation.ThoroughValidate(context.Background(), "./original", "./squashed")
if err != nil {
    log.Fatal(err)
}
if !result.Success {
    log.Printf("Found %d errors and %d warnings\n", len(result.Errors), len(result.Warnings))
}

func ValidateSchemaEquivalence ¶

func ValidateSchemaEquivalence(
	ctx context.Context,
	originalDir string,
	squashedDir string,
	config *ValidationConfig,
) (*ValidationResult, error)

ValidateSchemaEquivalence is a convenience function that validates whether squashed migrations produce the same schema as the original migrations.

This is a high-level helper that sets up validation with recommended defaults and returns a simple pass/fail result with detailed comparison information.

Parameters:

• ctx: Context for cancellation and timeouts
• originalDir: Directory containing original migration files
• squashedDir: Directory containing squashed migration files
• config: Optional validation configuration (uses defaults if nil)

Returns:

• ValidationResult with Success, Errors, Warnings, and SchemaComparison
• Error if validation infrastructure fails (Docker, parsing, etc.)

Example:

ctx := context.Background()
result, err := validation.ValidateSchemaEquivalence(ctx, "./original", "./squashed", nil)
if err != nil {
    log.Fatalf("Validation infrastructure error: %v", err)
}

if result.Success {
    fmt.Println("✓ Schemas are equivalent!")
} else {
    fmt.Println("✗ Schema differences found:")
    for _, diff := range result.SchemaComparison.Differences {
        fmt.Printf("  - %s: %s\n", diff.Type, diff.Description)
    }
}