chore: create folders only when used

Author: radim

regresql/baseline.go

@@ -219,7 +219,7 @@ func BaselineQueries(root string, runFilter string, analyzeOverride bool) {
 	baselineDir := filepath.Join(suite.RegressDir, "baselines")
 
 	fmt.Printf("Creating baselines directory: %s\n", baselineDir)
-	if err := maybeMkdirAll(baselineDir); err != nil {
+	if err := ensureDir(baselineDir); err != nil {
 		fmt.Printf("Failed to create baselines directory: %s\n", err.Error())
 		os.Exit(11)
 	}
@@ -231,16 +231,12 @@ func BaselineQueries(root string, runFilter string, analyzeOverride bool) {
 	fmt.Printf("\nCreating baselines for queries (%s):\n", mode)
 
 	for _, folder := range suite.Dirs {
-		folderBaselineDir := filepath.Join(baselineDir, folder.Dir)
 		folderPlanDir := filepath.Join(suite.PlanDir, folder.Dir)
-
-		if err := maybeMkdirAll(folderBaselineDir); err != nil {
-			fmt.Printf("Failed to create folder baseline directory: %s\n", err.Error())
-			os.Exit(11)
+		dir := &lazyDir{
+			path:   filepath.Join(baselineDir, folder.Dir),
+			header: fmt.Sprintf("\n  %s/", folder.Dir),
 		}
 
-		fmt.Printf("\n  %s/\n", folder.Dir)
-
 		for _, name := range folder.Files {
 			qfile := filepath.Join(suite.Root, folder.Dir, name)
 
@@ -266,7 +262,12 @@ func BaselineQueries(root string, runFilter string, analyzeOverride bool) {
 					continue
 				}
 
-				if err := q.CreateBaseline(folderBaselineDir, folderPlanDir, db, useAnalyze); err != nil {
+				if err := dir.Ensure(); err != nil {
+					fmt.Printf("Failed to create folder baseline directory: %s\n", err.Error())
+					os.Exit(11)
+				}
+
+				if err := q.CreateBaseline(dir.path, folderPlanDir, db, useAnalyze); err != nil {
 					fmt.Printf("  Error creating baseline for %s: %s\n", q.Name, err.Error())
 				}
 			}

regresql/suite.go

@@ -47,22 +47,24 @@ type (
 		ignoreMatcher *IgnoreMatcher
 	}
 
-	// createExpectedOptions controls behavior of createExpectedResults
+	Folder struct {
+		Dir   string
+		Files []string
+	}
+
+	// lazyDir defers directory creation until Ensure() is called
+	lazyDir struct {
+		path    string
+		header  string
+		created bool
+	}
+
 	createExpectedOptions struct {
 		Commit      bool
 		Pending     bool
 		Interactive bool
 		DryRun      bool
-		Snapshot    *SnapshotInfo // Current snapshot for baseline metadata tracking
-	}
-
-	/*
-		Folder implements a directory from the source repository wherein we found
-		some SQL files. Folder are only implemented as part of a Suite instance.
-	*/
-	Folder struct {
-		Dir   string
-		Files []string
+		Snapshot    *SnapshotInfo
 	}
 )
 
@@ -225,13 +227,30 @@ func (s *Suite) matchesRunFilter(fileName, queryName string) bool {
 	return re.MatchString(fileName) || re.MatchString(queryName)
 }
 
-// Println(Suite) pretty prints the Suite instance to standard out.
+// Println pretty prints the Suite, respecting the run filter if set.
 func (s *Suite) Println() {
 	fmt.Printf("%s\n", s.Root)
 	for _, folder := range s.Dirs {
-		fmt.Printf("  %s/\n", folder.Dir)
+		var matching []string
 		for _, name := range folder.Files {
-			fmt.Printf("    %s\n", name)
+			if s.runFilter == "" {
+				matching = append(matching, name)
+				continue
+			}
+			qfile := filepath.Join(s.Root, folder.Dir, name)
+			queries, _ := parseQueryFile(qfile)
+			for _, q := range queries {
+				if s.matchesRunFilter(name, q.Name) {
+					matching = append(matching, name)
+					break
+				}
+			}
+		}
+		if len(matching) > 0 {
+			fmt.Printf("  %s/\n", folder.Dir)
+			for _, name := range matching {
+				fmt.Printf("    %s\n", name)
+			}
 		}
 	}
 }
@@ -241,11 +260,7 @@ func (s *Suite) Println() {
 // structure in its own space.
 func (s *Suite) initRegressHierarchy() error {
 	for _, folder := range s.Dirs {
-		rdir := filepath.Join(s.PlanDir, folder.Dir)
-
-		if err := maybeMkdirAll(rdir); err != nil {
-			return fmt.Errorf("Failed to create test plans directory: %s", err)
-		}
+		rdir := &lazyDir{path: filepath.Join(s.PlanDir, folder.Dir)}
 
 		for _, name := range folder.Files {
 			qfile := filepath.Join(s.Root, folder.Dir, name)
@@ -268,7 +283,11 @@ func (s *Suite) initRegressHierarchy() error {
 					continue
 				}
 
-				if _, err := q.CreateEmptyPlan(rdir); err != nil {
+				if err := rdir.Ensure(); err != nil {
+					return fmt.Errorf("Failed to create test plans directory: %s", err)
+				}
+
+				if _, err := q.CreateEmptyPlan(rdir.path); err != nil {
 					fmt.Println("Skipping:", err)
 				}
 			}
@@ -299,26 +318,19 @@ func (s *Suite) createExpectedResults(pguri string, opts createExpectedOptions)
 
 	for _, folder := range s.Dirs {
 		rdir := filepath.Join(s.PlanDir, folder.Dir)
-		edir := filepath.Join(s.ExpectedDir, folder.Dir)
+		edir := &lazyDir{
+			path:   filepath.Join(s.ExpectedDir, folder.Dir),
+			header: fmt.Sprintf("  %s", filepath.Join(s.ExpectedDir, folder.Dir)),
+		}
 
-		// Build relative path for filtering
 		relPath := folder.Dir
-
-		// Check path filter at folder level
 		if !s.matchesPathFilter(relPath) && !s.matchesPathFilter(relPath+"/") {
 			continue
 		}
 
-		if !opts.DryRun {
-			maybeMkdirAll(edir)
-			fmt.Printf("  %s\n", edir)
-		}
-
 		for _, name := range folder.Files {
 			qfile := filepath.Join(s.Root, folder.Dir, name)
 			queryPath := filepath.Join(relPath, name)
-
-			// Check path filter at file level
 			if !s.matchesPathFilter(queryPath) {
 				continue
 			}
@@ -336,11 +348,9 @@ func (s *Suite) createExpectedResults(pguri string, opts createExpectedOptions)
 					continue
 				}
 
-				// Check for pending-only mode
 				if opts.Pending {
-					expectedPath := filepath.Join(edir, q.Name+".json")
-					if fileExists(expectedPath) {
-						continue // Skip - already has baseline
+					if fileExists(filepath.Join(edir.path, q.Name+".json")) {
+						continue
 					}
 				}
 
@@ -349,6 +359,12 @@ func (s *Suite) createExpectedResults(pguri string, opts createExpectedOptions)
 					return err
 				}
 
+				if !opts.DryRun {
+					if err := edir.Ensure(); err != nil {
+						return err
+					}
+				}
+
 				// Execute query and handle results
 				var writtenFiles []string
 				if err := s.runInTransaction(db, opts.Commit, func(tx *sql.Tx) error {
@@ -366,7 +382,7 @@ func (s *Suite) createExpectedResults(pguri string, opts createExpectedOptions)
 
 					// Interactive mode: compute diff and prompt for each change
 					if opts.Interactive {
-						diff := p.ComputeDiffForInteractive(edir)
+						diff := p.ComputeDiffForInteractive(edir.path)
 						action := prompter.PromptAccept(q.Name, diff)
 						switch action {
 						case "skip":
@@ -376,13 +392,13 @@ func (s *Suite) createExpectedResults(pguri string, opts createExpectedOptions)
 						}
 					}
 
-					if err := p.WriteResultSets(edir); err != nil {
+					if err := p.WriteResultSets(edir.path); err != nil {
 						return err
 					}
 
 					// Track written files for metadata recording
 					for _, rs := range p.ResultSets {
-						writtenFiles = append(writtenFiles, filepath.Join(edir, filepath.Base(rs.Filename)))
+						writtenFiles = append(writtenFiles, filepath.Join(edir.path, filepath.Base(rs.Filename)))
 					}
 					return nil
 				}); err != nil {
@@ -459,9 +475,8 @@ func (s *Suite) testQueries(pguri string, formatter OutputFormatter, outputPath
 	for _, folder := range s.Dirs {
 		rdir := filepath.Join(s.PlanDir, folder.Dir)
 		edir := filepath.Join(s.ExpectedDir, folder.Dir)
-		odir := filepath.Join(s.OutDir, folder.Dir)
+		odir := &lazyDir{path: filepath.Join(s.OutDir, folder.Dir)}
 		bdir := filepath.Join(s.BaselineDir, folder.Dir)
-		maybeMkdirAll(odir)
 
 		for _, name := range folder.Files {
 			qfile := filepath.Join(s.Root, folder.Dir, name)
@@ -486,11 +501,15 @@ func (s *Suite) testQueries(pguri string, formatter OutputFormatter, outputPath
 					return nil, err
 				}
 
+				if err := odir.Ensure(); err != nil {
+					return nil, err
+				}
+
 				if err := s.runInTransaction(db, commit, func(tx *sql.Tx) error {
 					if err := p.Execute(tx); err != nil {
 						return err
 					}
-					if err := p.WriteResultSets(odir); err != nil {
+					if err := p.WriteResultSets(odir.path); err != nil {
 						return err
 					}
 
@@ -556,7 +575,7 @@ func (s *Suite) executeAllQueries(pguri, outputDir string, verbose bool) (int, e
 
 	for _, folder := range s.Dirs {
 		rdir := filepath.Join(s.PlanDir, folder.Dir)
-		odir := filepath.Join(outputDir, folder.Dir)
+		odir := &lazyDir{path: filepath.Join(outputDir, folder.Dir)}
 
 		for _, name := range folder.Files {
 			qfile := filepath.Join(s.Root, folder.Dir, name)
@@ -582,14 +601,15 @@ func (s *Suite) executeAllQueries(pguri, outputDir string, verbose bool) (int, e
 					continue
 				}
 
-				// Only create output directory if we have queries to run
-				maybeMkdirAll(odir)
+				if err := odir.Ensure(); err != nil {
+					return count, err
+				}
 
 				if err := s.runInTransaction(db, false, func(tx *sql.Tx) error {
 					if err := p.Execute(tx); err != nil {
 						return err
 					}
-					if err := p.WriteResultSets(odir); err != nil {
+					if err := p.WriteResultSets(odir.path); err != nil {
 						return err
 					}
 					return nil
@@ -612,8 +632,8 @@ func (s *Suite) executeAllQueries(pguri, outputDir string, verbose bool) (int, e
 	return count, nil
 }
 
-// Only create dir(s) when it doesn't exists already
-func maybeMkdirAll(dir string) error {
+// ensureDir creates directory if it doesn't exist
+func ensureDir(dir string) error {
 	stat, err := os.Stat(dir)
 	if err != nil || !stat.IsDir() {
 		fmt.Printf("Creating directory '%s'\n", dir)
@@ -627,6 +647,20 @@ func maybeMkdirAll(dir string) error {
 	return nil
 }
 
+func (d *lazyDir) Ensure() error {
+	if d.created {
+		return nil
+	}
+	if err := ensureDir(d.path); err != nil {
+		return err
+	}
+	if d.header != "" {
+		fmt.Println(d.header)
+	}
+	d.created = true
+	return nil
+}
+
 // hasBaselines checks if any baseline files exist for the given query
 func hasBaselines(q *Query, baselineDir string, names []string) bool {
 	// If query has no parameters, check for single baseline file