feat: selecting update for better DX

Author: radim

cmd/update.go

@@ -14,17 +14,43 @@ var (
 	updateCommit       bool
 	updateNoRestore    bool
 	updateForceRestore bool
+	updatePending      bool
+	updateInteractive  bool
+	updateDryRun       bool
 
 	// updateCmd represents the update command
 	updateCmd = &cobra.Command{
-		Use:   "update [flags]",
+		Use:   "update [path...]",
 		Short: "Creates or updates the expected output files",
+		Long: `Creates or updates the expected output files for queries.
+
+Without arguments, updates all queries. With path arguments, only updates
+queries matching those paths.
+
+Examples:
+  regresql update                         # Update all queries
+  regresql update orders/                 # Update queries in orders/
+  regresql update orders/get_order.sql    # Update specific query
+  regresql update --pending               # Only create missing baselines
+  regresql update --dry-run               # Preview what would be updated
+  regresql update --interactive           # Review each change`,
+		Args: cobra.ArbitraryArgs,
 		Run: func(cmd *cobra.Command, args []string) {
 			if err := checkDirectory(updateCwd); err != nil {
 				fmt.Print(err.Error())
 				os.Exit(1)
 			}
-			regresql.Update(updateCwd, updateRunFilter, updateCommit, updateNoRestore, updateForceRestore)
+			regresql.Update(regresql.UpdateOptions{
+				Root:         updateCwd,
+				RunFilter:    updateRunFilter,
+				Paths:        args,
+				Commit:       updateCommit,
+				NoRestore:    updateNoRestore,
+				ForceRestore: updateForceRestore,
+				Pending:      updatePending,
+				Interactive:  updateInteractive,
+				DryRun:       updateDryRun,
+			})
 		},
 	}
 )
@@ -37,4 +63,7 @@ func init() {
 	updateCmd.Flags().BoolVar(&updateCommit, "commit", false, "Commit transactions instead of rollback (use with caution)")
 	updateCmd.Flags().BoolVar(&updateNoRestore, "no-restore", false, "Skip snapshot restore before update")
 	updateCmd.Flags().BoolVar(&updateForceRestore, "force-restore", false, "Force snapshot restore even if unchanged")
+	updateCmd.Flags().BoolVar(&updatePending, "pending", false, "Only create baselines for queries without expected files")
+	updateCmd.Flags().BoolVar(&updateInteractive, "interactive", false, "Review and confirm each update")
+	updateCmd.Flags().BoolVar(&updateDryRun, "dry-run", false, "Show what would be updated without writing files")
 }

regresql/interactive.go

@@ -0,0 +1,44 @@
+package regresql
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+)
+
+// ErrUserQuit is returned when the user chooses to quit during interactive mode
+var ErrUserQuit = errors.New("user quit")
+
+// InteractivePrompter handles interactive user prompts for update operations
+type InteractivePrompter struct {
+	reader *bufio.Reader
+}
+
+// NewInteractivePrompter creates a new interactive prompter
+func NewInteractivePrompter() *InteractivePrompter {
+	return &InteractivePrompter{reader: bufio.NewReader(os.Stdin)}
+}
+
+// PromptAccept shows query name and asks user to accept/skip/quit
+// Returns: "accept", "skip", "quit"
+func (p *InteractivePrompter) PromptAccept(queryName string, diff string) string {
+	fmt.Printf("\nQuery: %s\n", queryName)
+	if diff != "" {
+		fmt.Printf("%s\n", diff)
+	}
+	fmt.Print("[a]ccept / [s]kip / [q]uit: ")
+
+	input, _ := p.reader.ReadString('\n')
+	input = strings.TrimSpace(strings.ToLower(input))
+
+	switch input {
+	case "a", "accept", "":
+		return "accept"
+	case "q", "quit":
+		return "quit"
+	default:
+		return "skip"
+	}
+}

regresql/plans.go

@@ -260,3 +260,45 @@ func getResultSetPath(p *Plan, targetdir string, index int) string {
 	}
 	return filepath.Join(targetdir, rsFileName)
 }
+
+// ComputeDiffForInteractive computes a diff between current results and existing expected files
+// Returns a human-readable diff string for interactive review
+func (p *Plan) ComputeDiffForInteractive(expectedDir string) string {
+	var diffs []string
+
+	for i, rs := range p.ResultSets {
+		expectedPath := getResultSetPath(p, expectedDir, i)
+
+		// Check if expected file exists
+		if _, err := os.Stat(expectedPath); os.IsNotExist(err) {
+			diffs = append(diffs, fmt.Sprintf("  [NEW] %s (%d rows)", filepath.Base(expectedPath), len(rs.Rows)))
+			continue
+		}
+
+		// Load existing expected result
+		expected, err := LoadResultSet(expectedPath)
+		if err != nil {
+			diffs = append(diffs, fmt.Sprintf("  [ERROR] %s: %v", filepath.Base(expectedPath), err))
+			continue
+		}
+
+		// Compare row counts
+		if len(expected.Rows) != len(rs.Rows) {
+			diffs = append(diffs, fmt.Sprintf("  [CHANGED] %s: %d rows → %d rows",
+				filepath.Base(expectedPath), len(expected.Rows), len(rs.Rows)))
+			continue
+		}
+
+		// Quick check if content differs (compare JSON representations)
+		expectedJSON := expected.ToJSON()
+		actualJSON := rs.ToJSON()
+		if expectedJSON != actualJSON {
+			diffs = append(diffs, fmt.Sprintf("  [CHANGED] %s: content differs", filepath.Base(expectedPath)))
+		}
+	}
+
+	if len(diffs) == 0 {
+		return "  (no changes)"
+	}
+	return strings.Join(diffs, "\n")
+}

regresql/regresql.go

@@ -6,20 +6,34 @@ import (
 	"time"
 )
 
-type TestOptions struct {
-	Root          string
-	RunFilter     string
-	FormatName    string
-	OutputPath    string
-	Commit        bool
-	NoRestore     bool
-	ForceRestore  bool
-	FailOnSkipped bool
-	Color         bool
-	NoColor       bool
-	FullDiff      bool
-	NoDiff        bool
-}
+type (
+	TestOptions struct {
+		Root          string
+		RunFilter     string
+		FormatName    string
+		OutputPath    string
+		Commit        bool
+		NoRestore     bool
+		ForceRestore  bool
+		FailOnSkipped bool
+		Color         bool
+		NoColor       bool
+		FullDiff      bool
+		NoDiff        bool
+	}
+
+	UpdateOptions struct {
+		Root         string
+		RunFilter    string
+		Paths        []string
+		Commit       bool
+		NoRestore    bool
+		ForceRestore bool
+		Pending      bool
+		Interactive  bool
+		DryRun       bool
+	}
+)
 
 /*
 Init initializes a code repository for RegreSQL processing.
@@ -108,37 +122,38 @@ case and add a value for each parameter. `)
 Update updates the expected files from the queries and their parameters.
 Each query runs in its own transaction that rolls back (unless commit is true).
 */
-func Update(root string, runFilter string, commit, noRestore, forceRestore bool) {
-	config, err := ReadConfig(root)
+func Update(opts UpdateOptions) {
+	config, err := ReadConfig(opts.Root)
 	ignorePatterns := []string{}
 	if err == nil {
 		ignorePatterns = config.Ignore
 	}
 
-	suite := Walk(root, ignorePatterns)
-	suite.SetRunFilter(runFilter)
+	suite := Walk(opts.Root, ignorePatterns)
+	suite.SetRunFilter(opts.RunFilter)
+	suite.SetPathFilters(opts.Paths)
 	config, err = suite.readConfig()
 	if err != nil {
 		fmt.Print(err.Error())
 		os.Exit(3)
 	}
 
-	autoRestore(config, root, noRestore, forceRestore)
+	autoRestore(config, opts.Root, opts.NoRestore, opts.ForceRestore)
 
 	// Validate schema hasn't changed since last snapshot build
-	if err := ValidateSchemaHash(root); err != nil {
+	if err := ValidateSchemaHash(opts.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 {
+	if err := ValidateMigrationsHash(opts.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 {
+	if err := ValidateMigrationCommandHash(opts.Root); err != nil {
 		fmt.Printf("Error: %s\n", err)
 		os.Exit(1)
 	}
@@ -149,16 +164,26 @@ func Update(root string, runFilter string, commit, noRestore, forceRestore bool)
 	}
 
 	// Validate server settings match snapshot (warn, strict, or ignore)
-	if err := validateServerSettings(config, root); err != nil {
+	if err := validateServerSettings(config, opts.Root); err != nil {
 		fmt.Printf("Error: %s\n", err)
 		os.Exit(1)
 	}
 
-	if err := suite.createExpectedResults(config.PgUri, commit); err != nil {
+	updateOpts := createExpectedOptions{
+		Commit:      opts.Commit,
+		Pending:     opts.Pending,
+		Interactive: opts.Interactive,
+		DryRun:      opts.DryRun,
+	}
+	if err := suite.createExpectedResults(config.PgUri, updateOpts); err != nil {
 		fmt.Print(err.Error())
 		os.Exit(12)
 	}
 
+	if opts.DryRun {
+		return // Don't print success message for dry-run
+	}
+
 	fmt.Println("")
 	fmt.Println(`Expected files have now been created.
 You can run regression tests for your SQL queries with the command

regresql/resultset.go

@@ -168,6 +168,31 @@ func (r *ResultSet) Write(filename string, overwrite bool) error {
 	return nil
 }
 
+// LoadResultSet loads a ResultSet from a JSON file
+func LoadResultSet(filename string) (*ResultSet, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file '%s': %w", filename, err)
+	}
+
+	var rs ResultSet
+	if err := json.Unmarshal(data, &rs); err != nil {
+		return nil, fmt.Errorf("failed to parse JSON from '%s': %w", filename, err)
+	}
+
+	rs.Filename = filename
+	return &rs, nil
+}
+
+// ToJSON returns the JSON representation of the ResultSet as a string
+func (r *ResultSet) ToJSON() string {
+	jsonBytes, err := json.Marshal(r)
+	if err != nil {
+		return ""
+	}
+	return string(jsonBytes)
+}
+
 // valueToString is an helper function for the Pretty Printer
 func valueToString(value any) string {
 	switch v := value.(type) {