feat: capture PostgreSQL server setting & basic settings affecting planner costs

I.e. buffers don't lie, and costs is considered stable (well below the
treshold of 10% used at the moment), if we can trust the setting is same.

Author: radim

cmd/snapshot.go

@@ -24,6 +24,7 @@ var (
 	snapshotBuildSchema     string
 	snapshotBuildMigrations string
 	snapshotBuildVerbose    bool
+	snapshotInfoCompare     bool
 
 	snapshotCmd = &cobra.Command{
 		Use:   "snapshot",
@@ -109,10 +110,13 @@ Examples:
 		Short: "Display snapshot metadata",
 		Long: `Display metadata about the current snapshot.
 
-Shows the snapshot path, hash, size, creation time, and fixtures used.
+Shows the snapshot path, hash, size, creation time, server version, planner settings, and fixtures used.
+
+Use --compare to compare stored settings with current database settings.
 
 Examples:
-  regresql snapshot info`,
+  regresql snapshot info
+  regresql snapshot info --compare`,
 		Run: func(cmd *cobra.Command, args []string) {
 			if err := checkDirectory(snapshotCwd); err != nil {
 				fmt.Print(err.Error())
@@ -152,6 +156,8 @@ func init() {
 	snapshotBuildCmd.Flags().StringVar(&snapshotBuildMigrations, "migrations", "", "Directory of SQL migrations to apply")
 	snapshotBuildCmd.Flags().StringSliceVar(&snapshotBuildFixtures, "fixtures", nil, "Fixture names to apply")
 	snapshotBuildCmd.Flags().BoolVarP(&snapshotBuildVerbose, "verbose", "v", false, "Print detailed progress")
+
+	snapshotInfoCmd.Flags().BoolVar(&snapshotInfoCompare, "compare", false, "Compare stored settings with current database")
 }
 
 func validateSnapshotPrereqs(pguri string) error {
@@ -497,6 +503,9 @@ func runSnapshotBuild() error {
 	if len(result.FixturesUsed) > 0 {
 		fmt.Printf("  Fixtures: %d applied\n", len(result.FixturesUsed))
 	}
+	if result.Info.Server != nil {
+		fmt.Printf("  Server:   PostgreSQL %d\n", result.Info.Server.MajorVersion())
+	}
 
 	return nil
 }
@@ -556,5 +565,72 @@ func runSnapshotInfo() error {
 		}
 	}
 
+	if info.Server != nil {
+		fmt.Println()
+		fmt.Printf("Server: PostgreSQL %s\n", info.Server.Version)
+		if len(info.Server.PlannerSettings) > 0 {
+			fmt.Println()
+			fmt.Println("Planner Settings:")
+			for _, name := range regresql.PlannerSettings {
+				if val, ok := info.Server.PlannerSettings[name]; ok {
+					fmt.Printf("  %s: %s\n", name, val)
+				}
+			}
+		}
+	}
+
+	if snapshotInfoCompare {
+		if err := runSnapshotInfoCompare(info); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func runSnapshotInfoCompare(info *regresql.SnapshotInfo) error {
+	if info.Server == nil {
+		fmt.Println()
+		fmt.Println("No server context stored - nothing to compare")
+		return nil
+	}
+
+	cfg, err := regresql.ReadConfig(snapshotCwd)
+	if err != nil {
+		return fmt.Errorf("failed to read config: %w", err)
+	}
+
+	db, err := regresql.OpenDB(cfg.PgUri)
+	if err != nil {
+		return fmt.Errorf("failed to connect: %w", err)
+	}
+	defer db.Close()
+
+	validation, err := regresql.ValidateServerContext(db, info.Server)
+	if err != nil {
+		return fmt.Errorf("failed to compare: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Println("Comparison with current database:")
+	if !validation.HasDifferences() {
+		fmt.Println("  [ok] All settings match")
+		return nil
+	}
+
+	if validation.VersionDiff != nil {
+		marker := "[!]"
+		if validation.MajorMismatch {
+			marker = "[X]"
+		}
+		fmt.Printf("  %s version: %s -> %s\n", marker, info.Server.Version, validation.VersionDiff.Actual)
+	} else {
+		fmt.Printf("  [ok] version: %s\n", info.Server.Version)
+	}
+
+	for _, d := range validation.SettingsDiffs {
+		fmt.Printf("  [!] %s: %s -> %s\n", d.Name, d.Expected, d.Actual)
+	}
+
 	return nil
 }

regresql/config.go

@@ -36,6 +36,7 @@ type (
 		Fixtures         []string `yaml:"fixtures,omitempty"`          // SQL/YAML fixture files for snapshot build
 		AutoRestore      *bool    `yaml:"auto_restore,omitempty"`      // restore snapshot before test (default: true if path is set)
 		RestoreDatabase  string   `yaml:"restore_database,omitempty"`  // override target database for restore
+		ValidateSettings string   `yaml:"validate_settings,omitempty"` // server settings validation: warn (default), strict, ignore
 	}
 )
 

regresql/regresql.go

@@ -110,11 +110,35 @@ func Update(root string, runFilter string, commit, noRestore, forceRestore bool)
 
 	autoRestore(config, root, noRestore, forceRestore)
 
+	// Validate schema hasn't changed since last snapshot build
+	if err := ValidateSchemaHash(root); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
+	// Validate migrations haven't changed since last snapshot build
+	if err := ValidateMigrationsHash(root); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
+	// Validate migration command hasn't changed since last snapshot build
+	if err := ValidateMigrationCommandHash(root); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
 	if err := TestConnectionString(config.PgUri); err != nil {
 		fmt.Print(err.Error())
 		os.Exit(2)
 	}
 
+	// Validate server settings match snapshot (warn, strict, or ignore)
+	if err := validateServerSettings(config, root); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
 	if err := suite.createExpectedResults(config.PgUri, commit); err != nil {
 		fmt.Print(err.Error())
 		os.Exit(12)
@@ -189,6 +213,47 @@ func autoRestore(cfg config, root string, noRestore, forceRestore bool) {
 	fmt.Printf("Restored in %.1fs\n\n", duration.Seconds())
 }
 
+func validateServerSettings(cfg config, root string) error {
+	mode := GetValidateSettings(cfg.Snapshot)
+	if mode == ValidateSettingsIgnore {
+		return nil
+	}
+
+	snapshotsDir := GetSnapshotsDir(root)
+	metadata, err := ReadSnapshotMetadata(snapshotsDir)
+	if err != nil {
+		return nil // no metadata - nothing to validate
+	}
+
+	if metadata.Current == nil || metadata.Current.Server == nil {
+		return nil // no server context stored
+	}
+
+	db, err := OpenDB(cfg.PgUri)
+	if err != nil {
+		return fmt.Errorf("failed to connect for server validation: %w", err)
+	}
+	defer db.Close()
+
+	validation, err := ValidateServerContext(db, metadata.Current.Server)
+	if err != nil {
+		return fmt.Errorf("failed to validate server context: %w", err)
+	}
+
+	if !validation.HasDifferences() {
+		return nil
+	}
+
+	warning := validation.FormatWarning()
+
+	if mode == ValidateSettingsStrict {
+		return fmt.Errorf("%s\n\nUse validate_settings: warn to continue with warnings", warning)
+	}
+
+	fmt.Printf("%s\n\n", warning)
+	return nil
+}
+
 // Test runs regression tests for all queries.
 // Each query runs in its own transaction that rolls back (unless commit is true).
 func Test(root, runFilter, formatName, outputPath string, commit, noRestore, forceRestore bool) {
@@ -234,6 +299,12 @@ func Test(root, runFilter, formatName, outputPath string, commit, noRestore, for
 		os.Exit(2)
 	}
 
+	// Validate server settings match snapshot (warn, strict, or ignore)
+	if err := validateServerSettings(config, root); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
 	if formatName == "" {
 		formatName = "console"
 	}