fix: batch YAML fixture application and improve generator robustness

Author: radim

regresql/generator.go

@@ -116,13 +116,56 @@ func (bg *BaseGenerator) Name() string {
 	return bg.name
 }
 
-// getParam retrieves a parameter value with type assertion
+// getParam retrieves a parameter value with type assertion and numeric conversion
 func getParam[T any](params map[string]any, key string, defaultValue T) T {
-	if val, exists := params[key]; exists {
-		if typed, ok := val.(T); ok {
+	val, exists := params[key]
+	if !exists {
+		return defaultValue
+	}
+
+	// Direct type assertion
+	if typed, ok := val.(T); ok {
+		return typed
+	}
+
+	// Handle numeric type conversions (YAML parses numbers as int, but we often want int64)
+	var result any
+	switch any(defaultValue).(type) {
+	case int64:
+		switch v := val.(type) {
+		case int:
+			result = int64(v)
+		case int64:
+			result = v
+		case float64:
+			result = int64(v)
+		}
+	case int:
+		switch v := val.(type) {
+		case int:
+			result = v
+		case int64:
+			result = int(v)
+		case float64:
+			result = int(v)
+		}
+	case float64:
+		switch v := val.(type) {
+		case int:
+			result = float64(v)
+		case int64:
+			result = float64(v)
+		case float64:
+			result = v
+		}
+	}
+
+	if result != nil {
+		if typed, ok := result.(T); ok {
 			return typed
 		}
 	}
+
 	return defaultValue
 }
 

regresql/generators_basic.go

@@ -45,7 +45,6 @@ type (
 	// SequenceGenerator generates sequential integers
 	SequenceGenerator struct {
 		BaseGenerator
-		counter int64
 	}
 
 	// IntGenerator generates random integers
@@ -102,21 +101,15 @@ type (
 func NewSequenceGenerator() *SequenceGenerator {
 	return &SequenceGenerator{
 		BaseGenerator: BaseGenerator{name: "sequence"},
-		counter:       0,
 	}
 }
 
 func (g *SequenceGenerator) Generate(params map[string]any, column *ColumnInfo) (any, error) {
 	start := getParam(params, "start", int64(1))
+	index := getParam(params, "_index", int64(0))
 
-	if g.counter == 0 {
-		g.counter = start
-	}
-
-	value := g.counter
-	g.counter++
-
-	return value, nil
+	// Stateless: value is simply start + index
+	return start + index, nil
 }
 
 func (g *SequenceGenerator) Validate(params map[string]any, column *ColumnInfo) error {

regresql/snapshot_build.go

@@ -185,7 +185,9 @@ func applyFixtures(db *sql.DB, root string, fixtures []string, verbose bool) ([]
 	}
 
 	var applied []string
+	var yamlFixtures []string
 
+	// First pass: execute SQL fixtures immediately, collect YAML fixtures
 	for _, f := range fixtures {
 		if isSQLFixture(f) {
 			if verbose {
@@ -197,27 +199,35 @@ func applyFixtures(db *sql.DB, root string, fixtures []string, verbose bool) ([]
 			applied = append(applied, f)
 		} else {
 			name := trimYAMLExt(f)
-			if verbose {
+			yamlFixtures = append(yamlFixtures, name)
+		}
+	}
+
+	// Second pass: apply all YAML fixtures in a single transaction
+	// This ensures dependencies are resolved correctly and not re-applied
+	if len(yamlFixtures) > 0 {
+		if verbose {
+			for _, name := range yamlFixtures {
 				fmt.Printf("  Applying fixture: %s\n", name)
 			}
-			if err := applyYAMLFixture(fm, name); err != nil {
-				return nil, fmt.Errorf("fixture %q: %w", name, err)
-			}
-			applied = append(applied, name)
 		}
+		if err := applyYAMLFixtures(fm, yamlFixtures); err != nil {
+			return nil, err
+		}
+		applied = append(applied, yamlFixtures...)
 	}
 
 	return applied, nil
 }
 
-func applyYAMLFixture(fm *FixtureManager, name string) error {
+func applyYAMLFixtures(fm *FixtureManager, names []string) error {
 	if err := fm.BeginTransaction(); err != nil {
 		return err
 	}
 
 	_ = fm.IntrospectSchema()
 
-	if err := fm.ApplyFixtures([]string{name}); err != nil {
+	if err := fm.ApplyFixtures(names); err != nil {
 		fm.Rollback()
 		return err
 	}