feat(writer): 🎉 Add support for unique constraints in schema generation

* Implement unique constraint handling in GenerateSchemaStatements
* Add writeUniqueConstraints method for generating SQL statements
* Create unit test for unique constraints in writer_test.go

cmd/relspec/scripts.go

@@ -18,6 +18,7 @@ var (
 	scriptsConn         string
 	scriptsSchemaName   string
 	scriptsDBName       string
+	scriptsIgnoreErrors bool
 )
 
 var scriptsCmd = &cobra.Command{
@@ -62,7 +63,7 @@ var scriptsExecuteCmd = &cobra.Command{
 	Long: `Execute SQL scripts from a directory against a PostgreSQL database.
 
 Scripts are executed in order: Priority (ascending), Sequence (ascending), Name (alphabetical).
-Execution stops immediately on the first error.
+By default, execution stops immediately on the first error. Use --ignore-errors to continue execution.
 
 The directory is scanned recursively for all subdirectories and files matching the patterns:
   {priority}_{sequence}_{name}.sql or .pgsql (underscore format)
@@ -86,7 +87,12 @@ Examples:
 
   # Execute with SSL disabled
   relspec scripts execute --dir ./sql \
-                          --conn "postgres://user:pass@localhost/db?sslmode=disable"`,
+                          --conn "postgres://user:pass@localhost/db?sslmode=disable"
+
+  # Continue executing even if errors occur
+  relspec scripts execute --dir ./migrations \
+                          --conn "postgres://localhost/mydb" \
+                          --ignore-errors`,
 	RunE: runScriptsExecute,
 }
 
@@ -105,6 +111,7 @@ func init() {
 	scriptsExecuteCmd.Flags().StringVar(&scriptsConn, "conn", "", "PostgreSQL connection string (required)")
 	scriptsExecuteCmd.Flags().StringVar(&scriptsSchemaName, "schema", "public", "Schema name (optional, default: public)")
 	scriptsExecuteCmd.Flags().StringVar(&scriptsDBName, "database", "database", "Database name (optional, default: database)")
+	scriptsExecuteCmd.Flags().BoolVar(&scriptsIgnoreErrors, "ignore-errors", false, "Continue executing scripts even if errors occur")
 
 	err = scriptsExecuteCmd.MarkFlagRequired("dir")
 	if err != nil {
@@ -250,17 +257,39 @@ func runScriptsExecute(cmd *cobra.Command, args []string) error {
 	writer := sqlexec.NewWriter(&writers.WriterOptions{
 		Metadata: map[string]any{
 			"connection_string": scriptsConn,
+			"ignore_errors":     scriptsIgnoreErrors,
 		},
 	})
 
 	if err := writer.WriteSchema(schema); err != nil {
 		fmt.Fprintf(os.Stderr, "\n")
-		return fmt.Errorf("execution failed: %w", err)
+		return fmt.Errorf("script execution failed: %w", err)
+	}
+
+	// Get execution results from writer metadata
+	totalCount := len(schema.Scripts)
+	successCount := totalCount
+	failedCount := 0
+
+	opts := writer.Options()
+	if total, exists := opts.Metadata["execution_total"].(int); exists {
+		totalCount = total
+	}
+	if success, exists := opts.Metadata["execution_success"].(int); exists {
+		successCount = success
+	}
+	if failed, exists := opts.Metadata["execution_failed"].(int); exists {
+		failedCount = failed
 	}
 
 	fmt.Fprintf(os.Stderr, "\n=== Execution Complete ===\n")
 	fmt.Fprintf(os.Stderr, "Completed at: %s\n", getCurrentTimestamp())
-	fmt.Fprintf(os.Stderr, "Successfully executed %d script(s)\n\n", len(schema.Scripts))
+	fmt.Fprintf(os.Stderr, "Total scripts: %d\n", totalCount)
+	fmt.Fprintf(os.Stderr, "Successful:    %d\n", successCount)
+	if failedCount > 0 {
+		fmt.Fprintf(os.Stderr, "Failed:        %d\n", failedCount)
+	}
+	fmt.Fprintf(os.Stderr, "\n")
 
 	return nil
 }

pkg/writers/pgsql/writer.go

@@ -295,6 +295,31 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 		}
 	}
 
+	// Phase 5.5: Unique constraints
+	for _, table := range schema.Tables {
+		for _, constraint := range table.Constraints {
+			if constraint.Type != models.UniqueConstraint {
+				continue
+			}
+
+			// Wrap in DO block to check for existing constraint
+			stmt := fmt.Sprintf("DO $$\nBEGIN\n"+
+				"  IF NOT EXISTS (\n"+
+				"    SELECT 1 FROM information_schema.table_constraints\n"+
+				"    WHERE table_schema = '%s'\n"+
+				"      AND table_name = '%s'\n"+
+				"      AND constraint_name = '%s'\n"+
+				"  ) THEN\n"+
+				"    ALTER TABLE %s.%s ADD CONSTRAINT %s UNIQUE (%s);\n"+
+				"  END IF;\n"+
+				"END;\n$$",
+				schema.Name, table.Name, constraint.Name,
+				schema.SQLName(), table.SQLName(), constraint.Name,
+				strings.Join(constraint.Columns, ", "))
+			statements = append(statements, stmt)
+		}
+	}
+
 	// Phase 6: Foreign keys
 	for _, table := range schema.Tables {
 		for _, constraint := range table.Constraints {
@@ -542,6 +567,11 @@ func (w *Writer) WriteSchema(schema *models.Schema) error {
 		return err
 	}
 
+	// Phase 5.5: Create unique constraints (priority 185)
+	if err := w.writeUniqueConstraints(schema); err != nil {
+		return err
+	}
+
 	// Phase 6: Create foreign key constraints (priority 195)
 	if err := w.writeForeignKeys(schema); err != nil {
 		return err
@@ -865,6 +895,55 @@ func (w *Writer) writeIndexes(schema *models.Schema) error {
 	return nil
 }
 
+// writeUniqueConstraints generates ALTER TABLE statements for unique constraints
+func (w *Writer) writeUniqueConstraints(schema *models.Schema) error {
+	fmt.Fprintf(w.writer, "-- Unique constraints for schema: %s\n", schema.Name)
+
+	for _, table := range schema.Tables {
+		// Sort constraints by name for consistent output
+		constraintNames := make([]string, 0, len(table.Constraints))
+		for name, constraint := range table.Constraints {
+			if constraint.Type == models.UniqueConstraint {
+				constraintNames = append(constraintNames, name)
+			}
+		}
+		sort.Strings(constraintNames)
+
+		for _, name := range constraintNames {
+			constraint := table.Constraints[name]
+
+			// Build column list
+			columnExprs := make([]string, 0, len(constraint.Columns))
+			for _, colName := range constraint.Columns {
+				if col, ok := table.Columns[colName]; ok {
+					columnExprs = append(columnExprs, col.SQLName())
+				}
+			}
+
+			if len(columnExprs) == 0 {
+				continue
+			}
+
+			// Wrap in DO block to check for existing constraint
+			fmt.Fprintf(w.writer, "DO $$\n")
+			fmt.Fprintf(w.writer, "BEGIN\n")
+			fmt.Fprintf(w.writer, "  IF NOT EXISTS (\n")
+			fmt.Fprintf(w.writer, "    SELECT 1 FROM information_schema.table_constraints\n")
+			fmt.Fprintf(w.writer, "    WHERE table_schema = '%s'\n", schema.Name)
+			fmt.Fprintf(w.writer, "      AND table_name = '%s'\n", table.Name)
+			fmt.Fprintf(w.writer, "      AND constraint_name = '%s'\n", constraint.Name)
+			fmt.Fprintf(w.writer, "  ) THEN\n")
+			fmt.Fprintf(w.writer, "    ALTER TABLE %s.%s ADD CONSTRAINT %s UNIQUE (%s);\n",
+				schema.SQLName(), table.SQLName(), constraint.Name, strings.Join(columnExprs, ", "))
+			fmt.Fprintf(w.writer, "  END IF;\n")
+			fmt.Fprintf(w.writer, "END;\n")
+			fmt.Fprintf(w.writer, "$$;\n\n")
+		}
+	}
+
+	return nil
+}
+
 // writeForeignKeys generates ALTER TABLE statements for foreign keys
 func (w *Writer) writeForeignKeys(schema *models.Schema) error {
 	fmt.Fprintf(w.writer, "-- Foreign keys for schema: %s\n", schema.Name)

pkg/writers/pgsql/writer_test.go

@@ -164,6 +164,76 @@ func TestWriteForeignKeys(t *testing.T) {
 	}
 }
 
+func TestWriteUniqueConstraints(t *testing.T) {
+	// Create a test database with unique constraints
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	// Create table with unique constraints
+	table := models.InitTable("users", "public")
+
+	// Add columns
+	emailCol := models.InitColumn("email", "users", "public")
+	emailCol.Type = "varchar(255)"
+	emailCol.NotNull = true
+	table.Columns["email"] = emailCol
+
+	guidCol := models.InitColumn("guid", "users", "public")
+	guidCol.Type = "uuid"
+	guidCol.NotNull = true
+	table.Columns["guid"] = guidCol
+
+	// Add unique constraints
+	emailConstraint := &models.Constraint{
+		Name:    "uq_email",
+		Type:    models.UniqueConstraint,
+		Schema:  "public",
+		Table:   "users",
+		Columns: []string{"email"},
+	}
+	table.Constraints["uq_email"] = emailConstraint
+
+	guidConstraint := &models.Constraint{
+		Name:    "uq_guid",
+		Type:    models.UniqueConstraint,
+		Schema:  "public",
+		Table:   "users",
+		Columns: []string{"guid"},
+	}
+	table.Constraints["uq_guid"] = guidConstraint
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer with output to buffer
+	var buf bytes.Buffer
+	options := &writers.WriterOptions{}
+	writer := NewWriter(options)
+	writer.writer = &buf
+
+	// Write the database
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+
+	// Print output for debugging
+	t.Logf("Generated SQL:\n%s", output)
+
+	// Verify unique constraints are present
+	if !strings.Contains(output, "-- Unique constraints for schema: public") {
+		t.Errorf("Output missing unique constraints header")
+	}
+	if !strings.Contains(output, "ADD CONSTRAINT uq_email UNIQUE (email)") {
+		t.Errorf("Output missing uq_email unique constraint\nFull output:\n%s", output)
+	}
+	if !strings.Contains(output, "ADD CONSTRAINT uq_guid UNIQUE (guid)") {
+		t.Errorf("Output missing uq_guid unique constraint\nFull output:\n%s", output)
+	}
+}
+
 func TestWriteTable(t *testing.T) {
 	// Create a single table
 	table := models.InitTable("products", "public")

pkg/writers/sqlexec/writer.go

@@ -23,6 +23,11 @@ func NewWriter(options *writers.WriterOptions) *Writer {
 	}
 }
 
+// Options returns the writer options (useful for reading execution results)
+func (w *Writer) Options() *writers.WriterOptions {
+	return w.options
+}
+
 // WriteDatabase executes all scripts from all schemas in the database
 func (w *Writer) WriteDatabase(db *models.Database) error {
 	if db == nil {
@@ -92,6 +97,22 @@ func (w *Writer) executeScripts(ctx context.Context, conn *pgx.Conn, scripts []*
 		return nil
 	}
 
+	// Check if we should ignore errors
+	ignoreErrors := false
+	if val, ok := w.options.Metadata["ignore_errors"].(bool); ok {
+		ignoreErrors = val
+	}
+
+	// Track failed scripts and execution counts
+	var failedScripts []struct {
+		name     string
+		priority int
+		sequence uint
+		err      error
+	}
+	successCount := 0
+	totalCount := 0
+
 	// Sort scripts by Priority (ascending), Sequence (ascending), then Name (ascending)
 	sortedScripts := make([]*models.Script, len(scripts))
 	copy(sortedScripts, scripts)
@@ -111,18 +132,49 @@ func (w *Writer) executeScripts(ctx context.Context, conn *pgx.Conn, scripts []*
 			continue
 		}
 
+		totalCount++
 		fmt.Printf("Executing script: %s (Priority=%d, Sequence=%d)\n",
 			script.Name, script.Priority, script.Sequence)
 
 		// Execute the SQL script
 		_, err := conn.Exec(ctx, script.SQL)
 		if err != nil {
-			return fmt.Errorf("failed to execute script %s (Priority=%d, Sequence=%d): %w",
+			if ignoreErrors {
+				fmt.Printf("⚠ Error executing %s: %v (continuing due to --ignore-errors)\n", script.Name, err)
+				failedScripts = append(failedScripts, struct {
+					name     string
+					priority int
+					sequence uint
+					err      error
+				}{
+					name:     script.Name,
+					priority: script.Priority,
+					sequence: script.Sequence,
+					err:      err,
+				})
+				continue
+			}
+			return fmt.Errorf("script %s (Priority=%d, Sequence=%d): %w",
 				script.Name, script.Priority, script.Sequence, err)
 		}
 
+		successCount++
 		fmt.Printf("✓ Successfully executed: %s\n", script.Name)
 	}
 
+	// Store execution results in metadata for caller
+	w.options.Metadata["execution_total"] = totalCount
+	w.options.Metadata["execution_success"] = successCount
+	w.options.Metadata["execution_failed"] = len(failedScripts)
+
+	// Print summary of failed scripts if any
+	if len(failedScripts) > 0 {
+		fmt.Printf("\n⚠ Failed Scripts Summary (%d failed):\n", len(failedScripts))
+		for i, failed := range failedScripts {
+			fmt.Printf("  %d. %s (Priority=%d, Sequence=%d)\n     Error: %v\n",
+				i+1, failed.name, failed.priority, failed.sequence, failed.err)
+		}
+	}
+
 	return nil
 }