feat: exposed _index for better generator reliability; added on conflict support

Author: radim

regresql/fixture.go

@@ -16,9 +16,10 @@ type (
 	}
 
 	GenerateSpec struct {
-		Table   string                   `yaml:"table" json:"table"`
-		Count   int                      `yaml:"count" json:"count"`
-		Columns map[string]GeneratorSpec `yaml:"columns" json:"columns"`
+		Table      string                   `yaml:"table" json:"table"`
+		Count      int                      `yaml:"count" json:"count"`
+		Columns    map[string]GeneratorSpec `yaml:"columns" json:"columns"`
+		OnConflict string                   `yaml:"on_conflict,omitempty" json:"on_conflict,omitempty"`
 	}
 
 	GeneratorSpec struct {

regresql/fixture_manager.go

@@ -402,26 +402,22 @@ func (fm *FixtureManager) generateTableData(genSpec GenerateSpec) error {
 			count = genSpec.Count - i
 		}
 
-		if err := fm.generateAndInsertBatch(genSpec, tableInfo, count); err != nil {
+		if err := fm.generateAndInsertBatch(genSpec, tableInfo, count, i); err != nil {
 			return fmt.Errorf("failed to generate batch at row %d: %w", i, err)
 		}
 	}
 
 	return nil
 }
 
-// generateAndInsertBatch generates and inserts a batch of rows
-func (fm *FixtureManager) generateAndInsertBatch(genSpec GenerateSpec, tableInfo *TableInfo, count int) error {
-	// Collect column names
+func (fm *FixtureManager) generateAndInsertBatch(genSpec GenerateSpec, tableInfo *TableInfo, count, startIndex int) error {
 	columns := make([]string, 0, len(genSpec.Columns))
 	for colName := range genSpec.Columns {
 		columns = append(columns, colName)
 	}
 
-	// Build INSERT statement
 	query := fmt.Sprintf("INSERT INTO %s (%s) VALUES ", genSpec.Table, joinColumns(columns))
 
-	// Generate rows
 	var values []any
 	valuePlaceholders := make([]string, 0, count)
 
@@ -438,11 +434,11 @@ func (fm *FixtureManager) generateAndInsertBatch(genSpec GenerateSpec, tableInfo
 			}
 
 			params := copyParams(genSpecCol.Params)
-			params["_index"] = i
+			params["_index"] = startIndex + i
 
 			value, err := gen.Generate(params, colInfo)
 			if err != nil {
-				return fmt.Errorf("failed to generate value for column '%s' (row %d): %w", colName, i, err)
+				return fmt.Errorf("failed to generate value for column '%s' (row %d): %w", colName, startIndex+i, err)
 			}
 
 			values = append(values, value)
@@ -452,8 +448,11 @@ func (fm *FixtureManager) generateAndInsertBatch(genSpec GenerateSpec, tableInfo
 		valuePlaceholders = append(valuePlaceholders, fmt.Sprintf("(%s)", joinStrings(rowValues, ", ")))
 	}
 
-	// Execute insert
 	finalQuery := query + joinStrings(valuePlaceholders, ", ")
+	if genSpec.OnConflict == "skip" {
+		finalQuery += " ON CONFLICT DO NOTHING"
+	}
+
 	if _, err := fm.tx.Exec(finalQuery, values...); err != nil {
 		return err
 	}

regresql/generators_basic.go

@@ -161,21 +161,37 @@ func NewStringGenerator() *StringGenerator {
 func (g *StringGenerator) Generate(params map[string]any, column *ColumnInfo) (any, error) {
 	length := getParam(params, "length", 10)
 	charset := getParam(params, "charset", defaultCharset)
+	unique := getParam(params, "unique", false)
+	index := getParam(params, "_index", -1)
 
 	if length <= 0 {
 		return nil, fmt.Errorf("length must be positive")
 	}
 
-	// Apply column max length constraint if available
 	if column.MaxLength != nil && length > *column.MaxLength {
 		length = *column.MaxLength
 	}
 
+	// Deterministic unique string based on index
+	if unique && index >= 0 {
+		base := fmt.Sprintf("%d", index)
+		if len(base) > length {
+			return nil, fmt.Errorf("unique string generator: index %d requires %d chars but length is %d", index, len(base), length)
+		}
+		if len(base) == length {
+			return base, nil
+		}
+		padding := make([]byte, length-len(base))
+		for i := range padding {
+			padding[i] = charset[(index+i)%len(charset)]
+		}
+		return string(padding) + base, nil
+	}
+
 	result := make([]byte, length)
 	for i := range result {
 		result[i] = charset[rand.Intn(len(charset))]
 	}
-
 	return string(result), nil
 }
 
@@ -227,16 +243,20 @@ func NewEmailGenerator() *EmailGenerator {
 
 func (g *EmailGenerator) Generate(params map[string]any, column *ColumnInfo) (any, error) {
 	domain := getParam(params, "domain", "")
-
-	prefix := emailPrefixes[rand.Intn(len(emailPrefixes))]
-	suffix := rand.Intn(10000)
+	index := getParam(params, "_index", -1)
 
 	if domain == "" {
 		domain = emailDomains[rand.Intn(len(emailDomains))]
 	}
 
-	email := fmt.Sprintf("%s%d@%s", prefix, suffix, domain)
-	return email, nil
+	// Use index for guaranteed uniqueness when available
+	if index >= 0 {
+		return fmt.Sprintf("user%d@%s", index, domain), nil
+	}
+
+	prefix := emailPrefixes[rand.Intn(len(emailPrefixes))]
+	suffix := rand.Intn(10000)
+	return fmt.Sprintf("%s%d@%s", prefix, suffix, domain), nil
 }
 
 func (g *EmailGenerator) Validate(params map[string]any, column *ColumnInfo) error {
@@ -251,20 +271,42 @@ func NewNameGenerator() *NameGenerator {
 
 func (g *NameGenerator) Generate(params map[string]any, column *ColumnInfo) (any, error) {
 	nameType := getParam(params, "type", "full")
-
-	firstName := firstNames[rand.Intn(len(firstNames))]
-	lastName := lastNames[rand.Intn(len(lastNames))]
-
+	unique := getParam(params, "unique", false)
+	index := getParam(params, "_index", -1)
+
+	var firstName, lastName string
+	if unique && index >= 0 {
+		firstName = firstNames[index%len(firstNames)]
+		lastName = lastNames[index%len(lastNames)]
+		// Add suffix when names would cycle
+		cycle := index / (len(firstNames) * len(lastNames))
+		if cycle > 0 {
+			lastName = fmt.Sprintf("%s%d", lastName, cycle)
+		}
+	} else {
+		firstName = firstNames[rand.Intn(len(firstNames))]
+		lastName = lastNames[rand.Intn(len(lastNames))]
+	}
+
+	var result string
 	switch nameType {
 	case "first":
-		return firstName, nil
+		result = firstName
 	case "last":
-		return lastName, nil
+		result = lastName
 	case "full":
-		return fmt.Sprintf("%s %s", firstName, lastName), nil
+		result = fmt.Sprintf("%s %s", firstName, lastName)
 	default:
 		return nil, fmt.Errorf("unsupported name type: %s", nameType)
 	}
+
+	if column.MaxLength != nil && len(result) > *column.MaxLength {
+		if unique {
+			return nil, fmt.Errorf("unique name generator: result %q (%d chars) exceeds column max length %d", result, len(result), *column.MaxLength)
+		}
+		result = result[:*column.MaxLength]
+	}
+	return result, nil
 }
 
 func (g *NameGenerator) Validate(params map[string]any, column *ColumnInfo) error {

regresql/schema.go

@@ -26,6 +26,7 @@ type (
 		IsNullable   bool
 		IsPrimaryKey bool
 		IsForeignKey bool
+		IsUnique     bool
 		ForeignKey   *ForeignKeyInfo
 		Default      *string
 		MaxLength    *int
@@ -95,6 +96,17 @@ func IntrospectSchema(db *sql.DB) (*DatabaseSchema, error) {
 			}
 		}
 
+		// Get unique constraints
+		uniqueCols, err := getUniqueColumns(db, tableName)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get unique constraints for table '%s': %w", tableName, err)
+		}
+		for colName := range uniqueCols {
+			if col, exists := tableInfo.Columns[colName]; exists {
+				col.IsUnique = true
+			}
+		}
+
 		schema.tables[tableName] = tableInfo
 	}
 
@@ -252,6 +264,34 @@ func getForeignKeys(db *sql.DB, tableName string) ([]*ForeignKeyInfo, error) {
 	return foreignKeys, rows.Err()
 }
 
+func getUniqueColumns(db *sql.DB, tableName string) (map[string]bool, error) {
+	query := `
+		SELECT a.attname
+		FROM pg_index i
+		JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+		WHERE i.indrelid = $1::regclass
+		  AND i.indisunique
+		  AND NOT i.indisprimary
+		  AND array_length(i.indkey, 1) = 1
+	`
+
+	rows, err := db.Query(query, tableName)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	uniqueCols := make(map[string]bool)
+	for rows.Next() {
+		var colName string
+		if err := rows.Scan(&colName); err != nil {
+			return nil, err
+		}
+		uniqueCols[colName] = true
+	}
+	return uniqueCols, rows.Err()
+}
+
 // GetTable retrieves table metadata
 func (ds *DatabaseSchema) GetTable(name string) (*TableInfo, error) {
 	table, exists := ds.tables[name]