feat: introduce --sections flag to control pre-data/data/post-data

correctly

Author: radim

cmd/snapshot.go

@@ -13,9 +13,11 @@ import (
 var (
 	snapshotCwd           string
 	snapshotOutput        string
+	snapshotOutputDir     string
 	snapshotFormat        string
 	snapshotSchemaOnly    bool
 	snapshotSection       string
+	snapshotSections      bool
 	snapshotInput         string
 	snapshotClean         bool
 	snapshotBuildFixtures []string
@@ -36,13 +38,21 @@ Examples:
   regresql snapshot capture
   regresql snapshot capture --output snapshots/mydata.dump
   regresql snapshot capture --schema-only
-  regresql snapshot capture --format plain --output snapshots/schema.sql`,
+  regresql snapshot capture --format plain --output snapshots/schema.sql
+  regresql snapshot capture --section pre-data --output snapshots/pre-data.sql
+  regresql snapshot capture --sections --output-dir snapshots/`,
 		Run: func(cmd *cobra.Command, args []string) {
 			if err := checkDirectory(snapshotCwd); err != nil {
 				fmt.Print(err.Error())
 				os.Exit(1)
 			}
-			if err := runSnapshotCapture(); err != nil {
+			var err error
+			if snapshotSections {
+				err = runSnapshotCaptureSections()
+			} else {
+				err = runSnapshotCapture()
+			}
+			if err != nil {
 				fmt.Printf("Error: %s\n", err.Error())
 				os.Exit(1)
 			}
@@ -123,9 +133,11 @@ func init() {
 	snapshotCmd.PersistentFlags().StringVarP(&snapshotCwd, "cwd", "C", ".", "Change to directory")
 
 	snapshotCaptureCmd.Flags().StringVarP(&snapshotOutput, "output", "o", "", "Output file path")
+	snapshotCaptureCmd.Flags().StringVar(&snapshotOutputDir, "output-dir", "", "Output directory for sectioned capture")
 	snapshotCaptureCmd.Flags().StringVarP(&snapshotFormat, "format", "f", "", "Dump format: custom, plain, or directory")
 	snapshotCaptureCmd.Flags().BoolVar(&snapshotSchemaOnly, "schema-only", false, "Dump only schema, no data")
 	snapshotCaptureCmd.Flags().StringVar(&snapshotSection, "section", "", "Dump specific section: pre-data, data, or post-data")
+	snapshotCaptureCmd.Flags().BoolVar(&snapshotSections, "sections", false, "Capture all sections to separate SQL files")
 
 	snapshotRestoreCmd.Flags().StringVar(&snapshotInput, "from", "", "Input file path")
 	snapshotRestoreCmd.Flags().StringVarP(&snapshotFormat, "format", "f", "", "Snapshot format: custom, plain, or directory")
@@ -137,18 +149,26 @@ func init() {
 	snapshotBuildCmd.Flags().BoolVarP(&snapshotBuildVerbose, "verbose", "v", false, "Print detailed progress")
 }
 
+func validateSnapshotPrereqs(pguri string) error {
+	if pguri == "" {
+		return fmt.Errorf("pguri not configured in regress.yaml")
+	}
+	if err := regresql.TestConnectionString(pguri); err != nil {
+		return fmt.Errorf("database connection failed: %w", err)
+	}
+	if err := regresql.CheckPgTool("pg_dump", snapshotCwd); err != nil {
+		return err
+	}
+	return nil
+}
+
 func runSnapshotCapture() error {
 	cfg, err := regresql.ReadConfig(snapshotCwd)
 	if err != nil {
 		return fmt.Errorf("failed to read config: %w (have you run 'regresql init'?)", err)
 	}
-
-	if cfg.PgUri == "" {
-		return fmt.Errorf("pguri not configured in regress.yaml")
-	}
-
-	if err := regresql.TestConnectionString(cfg.PgUri); err != nil {
-		return fmt.Errorf("database connection failed: %w", err)
+	if err := validateSnapshotPrereqs(cfg.PgUri); err != nil {
+		return err
 	}
 
 	outputPath := snapshotOutput
@@ -165,10 +185,6 @@ func runSnapshotCapture() error {
 		format = regresql.GetSnapshotFormat(cfg.Snapshot)
 	}
 
-	if err := regresql.CheckPgTool("pg_dump", snapshotCwd); err != nil {
-		return err
-	}
-
 	opts := regresql.SnapshotOptions{
 		OutputPath: outputPath,
 		Format:     format,
@@ -206,6 +222,52 @@ func runSnapshotCapture() error {
 	return nil
 }
 
+func runSnapshotCaptureSections() error {
+	cfg, err := regresql.ReadConfig(snapshotCwd)
+	if err != nil {
+		return fmt.Errorf("failed to read config: %w (have you run 'regresql init'?)", err)
+	}
+	if err := validateSnapshotPrereqs(cfg.PgUri); err != nil {
+		return err
+	}
+
+	outputDir := snapshotOutputDir
+	if outputDir == "" {
+		outputDir = regresql.GetSnapshotsDir(snapshotCwd)
+	} else if !filepath.IsAbs(outputDir) {
+		outputDir = filepath.Join(snapshotCwd, outputDir)
+	}
+
+	fmt.Printf("Capturing database sections...\n")
+	fmt.Printf("  Database:   %s\n", maskConnectionString(cfg.PgUri))
+	fmt.Printf("  Output dir: %s\n", outputDir)
+	fmt.Printf("  Sections:   pre-data, data, post-data\n")
+	fmt.Println()
+
+	result, err := regresql.CaptureSections(cfg.PgUri, regresql.SectionsOptions{
+		OutputDir: outputDir,
+	})
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Sections captured successfully.\n")
+	fmt.Printf("  Time: %s\n", result.Created.Format("2006-01-02 15:04:05 UTC"))
+	fmt.Println()
+
+	var totalSize int64
+	for _, s := range result.Sections {
+		fmt.Printf("  %s.sql\n", s.Section)
+		fmt.Printf("    Size: %s\n", regresql.FormatBytes(s.SizeBytes))
+		fmt.Printf("    Hash: %s\n", s.Hash)
+		totalSize += s.SizeBytes
+	}
+	fmt.Println()
+	fmt.Printf("  Total: %s\n", regresql.FormatBytes(totalSize))
+
+	return nil
+}
+
 func maskConnectionString(pguri string) string {
 	masked := pguri
 	if idx := findPasswordEnd(pguri); idx > 0 {

regresql/snapshot.go

@@ -37,6 +37,22 @@ type (
 		Section    string
 	}
 
+	SectionsOptions struct {
+		OutputDir string
+	}
+
+	SectionInfo struct {
+		Section   string
+		Path      string
+		Hash      string
+		SizeBytes int64
+	}
+
+	SectionsResult struct {
+		Sections []SectionInfo
+		Created  time.Time
+	}
+
 	RestoreOptions struct {
 		InputPath string
 		Format    SnapshotFormat
@@ -171,6 +187,68 @@ func CaptureSnapshot(pguri string, opts SnapshotOptions) (*SnapshotInfo, error)
 	return info, nil
 }
 
+// CaptureSections captures all three database sections (pre-data, data, post-data)
+// to separate plain SQL files for git-friendly version control.
+func CaptureSections(pguri string, opts SectionsOptions) (*SectionsResult, error) {
+	if err := os.MkdirAll(opts.OutputDir, 0o755); err != nil {
+		return nil, fmt.Errorf("failed to create output directory: %w", err)
+	}
+
+	sections := []string{"pre-data", "data", "post-data"}
+	result := &SectionsResult{
+		Created: time.Now().UTC(),
+	}
+
+	for _, section := range sections {
+		outputPath := filepath.Join(opts.OutputDir, section+".sql")
+
+		info, err := captureSection(pguri, section, outputPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to capture %s section: %w", section, err)
+		}
+
+		result.Sections = append(result.Sections, *info)
+	}
+
+	return result, nil
+}
+
+func captureSection(pguri, section, outputPath string) (*SectionInfo, error) {
+	args := []string{"--dbname", pguri, "--format=plain", "--section", section}
+
+	cmd := exec.Command("pg_dump", args...)
+	cmd.Stderr = os.Stderr
+
+	outFile, err := os.Create(outputPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer outFile.Close()
+
+	cmd.Stdout = outFile
+
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("pg_dump failed: %w", err)
+	}
+
+	stat, err := os.Stat(outputPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to stat output file: %w", err)
+	}
+
+	hash, err := computeSingleFileHash(outputPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to compute hash: %w", err)
+	}
+
+	return &SectionInfo{
+		Section:   section,
+		Path:      outputPath,
+		Hash:      hash,
+		SizeBytes: stat.Size(),
+	}, nil
+}
+
 func buildPgDumpArgs(pguri string, opts SnapshotOptions) []string {
 	args := []string{"--dbname", pguri}
 

regresql/snapshot_test.go

@@ -455,3 +455,15 @@ func TestParseToolVersionsFileNotFound(t *testing.T) {
 		t.Errorf("parseToolVersions() = %d, want 0 for missing file", got)
 	}
 }
+
+func TestCaptureSectionsCreatesDirectory(t *testing.T) {
+	tmpDir := t.TempDir()
+	outputDir := filepath.Join(tmpDir, "new", "nested", "dir")
+
+	// pg_dump will fail but directory creation happens first
+	_, _ = CaptureSections("postgres://invalid", SectionsOptions{OutputDir: outputDir})
+
+	if _, err := os.Stat(outputDir); os.IsNotExist(err) {
+		t.Error("CaptureSections should create output directory before calling pg_dump")
+	}
+}