feat(pgsql): ✨ Add templates for constraints and sequences

* Introduce new templates for creating unique, check, and foreign key constraints with existence checks.
* Add templates for setting sequence values and creating sequences.
* Refactor existing SQL generation logic to utilize new templates for better maintainability and readability.
* Ensure identifiers are properly quoted to handle special characters and reserved keywords.

pkg/writers/pgsql/writer.go

@@ -22,6 +22,7 @@ type Writer struct {
 	options         *writers.WriterOptions
 	writer          io.Writer
 	executionReport *ExecutionReport
+	executor        *TemplateExecutor
 }
 
 // ExecutionReport tracks the execution status of SQL statements
@@ -57,8 +58,10 @@ type ExecutionError struct {
 
 // NewWriter creates a new PostgreSQL SQL writer
 func NewWriter(options *writers.WriterOptions) *Writer {
+	executor, _ := NewTemplateExecutor()
 	return &Writer{
-		options: options,
+		options:  options,
+		executor: executor,
 	}
 }
 
@@ -215,36 +218,19 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 				fmt.Sprintf("%s_%s_pkey", schema.Name, table.Name),
 			}
 
-			// Wrap in DO block to drop auto-generated PK and add our named PK
-			stmt := fmt.Sprintf("DO $$\nDECLARE\n"+
-				"  auto_pk_name text;\n"+
-				"BEGIN\n"+
-				"  -- Drop auto-generated primary key if it exists\n"+
-				"  SELECT constraint_name INTO auto_pk_name\n"+
-				"  FROM information_schema.table_constraints\n"+
-				"  WHERE table_schema = '%s'\n"+
-				"    AND table_name = '%s'\n"+
-				"    AND constraint_type = 'PRIMARY KEY'\n"+
-				"    AND constraint_name IN (%s);\n"+
-				"\n"+
-				"  IF auto_pk_name IS NOT NULL THEN\n"+
-				"    EXECUTE 'ALTER TABLE %s.%s DROP CONSTRAINT ' || quote_ident(auto_pk_name);\n"+
-				"  END IF;\n"+
-				"\n"+
-				"  -- Add named primary key if it doesn't exist\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 PRIMARY KEY (%s);\n"+
-				"  END IF;\n"+
-				"END;\n$$",
-				schema.Name, table.Name, formatStringList(autoGenPKNames),
-				schema.SQLName(), table.SQLName(),
-				schema.Name, table.Name, pkName,
-				schema.SQLName(), table.SQLName(), pkName, strings.Join(pkColumns, ", "))
+			// Use template to generate primary key statement
+			data := CreatePrimaryKeyWithAutoGenCheckData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: pkName,
+				AutoGenNames:   formatStringList(autoGenPKNames),
+				Columns:        strings.Join(pkColumns, ", "),
+			}
+
+			stmt, err := w.executor.ExecuteCreatePrimaryKeyWithAutoGenCheck(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate primary key for %s.%s: %w", schema.Name, table.Name, err)
+			}
 			statements = append(statements, stmt)
 		}
 	}
@@ -290,7 +276,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 			}
 
 			stmt := fmt.Sprintf("CREATE %sINDEX IF NOT EXISTS %s ON %s.%s USING %s (%s)%s",
-				uniqueStr, index.Name, schema.SQLName(), table.SQLName(), indexType, strings.Join(columnExprs, ", "), whereClause)
+				uniqueStr, quoteIdentifier(index.Name), schema.SQLName(), table.SQLName(), indexType, strings.Join(columnExprs, ", "), whereClause)
 			statements = append(statements, stmt)
 		}
 	}
@@ -302,20 +288,18 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 				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, ", "))
+			// Use template to generate unique constraint statement
+			data := CreateUniqueConstraintData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				Columns:        strings.Join(constraint.Columns, ", "),
+			}
+
+			stmt, err := w.executor.ExecuteCreateUniqueConstraint(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate unique constraint for %s.%s: %w", schema.Name, table.Name, err)
+			}
 			statements = append(statements, stmt)
 		}
 	}
@@ -327,20 +311,18 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 				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 CHECK (%s);\n"+
-				"  END IF;\n"+
-				"END;\n$$",
-				schema.Name, table.Name, constraint.Name,
-				schema.SQLName(), table.SQLName(), constraint.Name,
-				constraint.Expression)
+			// Use template to generate check constraint statement
+			data := CreateCheckConstraintData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				Expression:     constraint.Expression,
+			}
+
+			stmt, err := w.executor.ExecuteCreateCheckConstraint(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate check constraint for %s.%s: %w", schema.Name, table.Name, err)
+			}
 			statements = append(statements, stmt)
 		}
 	}
@@ -367,23 +349,24 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 				onUpdate = "NO ACTION"
 			}
 
-			// 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 FOREIGN KEY (%s) REFERENCES %s.%s(%s) ON DELETE %s ON UPDATE %s;\n"+
-				"  END IF;\n"+
-				"END;\n$$",
-				schema.Name, table.Name, constraint.Name,
-				schema.SQLName(), table.SQLName(), constraint.Name,
-				strings.Join(constraint.Columns, ", "),
-				strings.ToLower(refSchema), strings.ToLower(constraint.ReferencedTable),
-				strings.Join(constraint.ReferencedColumns, ", "),
-				onDelete, onUpdate)
+			// Use template to generate foreign key statement
+			data := CreateForeignKeyWithCheckData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				SourceColumns:  strings.Join(constraint.Columns, ", "),
+				TargetSchema:   refSchema,
+				TargetTable:    constraint.ReferencedTable,
+				TargetColumns:  strings.Join(constraint.ReferencedColumns, ", "),
+				OnDelete:       onDelete,
+				OnUpdate:       onUpdate,
+				Deferrable:     false,
+			}
+
+			stmt, err := w.executor.ExecuteCreateForeignKeyWithCheck(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate foreign key for %s.%s: %w", schema.Name, table.Name, err)
+			}
 			statements = append(statements, stmt)
 		}
 	}
@@ -431,19 +414,18 @@ func (w *Writer) GenerateAddColumnStatements(schema *models.Schema) ([]string, e
 		for _, col := range columns {
 			colDef := w.generateColumnDefinition(col)
 
-			// Generate DO block that checks if column exists before adding
-			stmt := fmt.Sprintf("DO $$\nBEGIN\n"+
-				"  IF NOT EXISTS (\n"+
-				"    SELECT 1 FROM information_schema.columns\n"+
-				"    WHERE table_schema = '%s'\n"+
-				"      AND table_name = '%s'\n"+
-				"      AND column_name = '%s'\n"+
-				"  ) THEN\n"+
-				"    ALTER TABLE %s.%s ADD COLUMN %s;\n"+
-				"  END IF;\n"+
-				"END;\n$$",
-				schema.Name, table.Name, col.Name,
-				schema.SQLName(), table.SQLName(), colDef)
+			// Use template to generate add column statement
+			data := AddColumnWithCheckData{
+				SchemaName:       schema.Name,
+				TableName:        table.Name,
+				ColumnName:       col.Name,
+				ColumnDefinition: colDef,
+			}
+
+			stmt, err := w.executor.ExecuteAddColumnWithCheck(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate add column for %s.%s.%s: %w", schema.Name, table.Name, col.Name, err)
+			}
 			statements = append(statements, stmt)
 		}
 	}
@@ -699,13 +681,23 @@ func (w *Writer) writeSequences(schema *models.Schema) error {
 		}
 
 		seqName := fmt.Sprintf("identity_%s_%s", table.SQLName(), pk.SQLName())
-		fmt.Fprintf(w.writer, "CREATE SEQUENCE IF NOT EXISTS %s.%s\n",
-			schema.SQLName(), seqName)
-		fmt.Fprintf(w.writer, "  INCREMENT 1\n")
-		fmt.Fprintf(w.writer, "  MINVALUE 1\n")
-		fmt.Fprintf(w.writer, "  MAXVALUE 9223372036854775807\n")
-		fmt.Fprintf(w.writer, "  START 1\n")
-		fmt.Fprintf(w.writer, "  CACHE 1;\n\n")
+
+		data := CreateSequenceData{
+			SchemaName:   schema.Name,
+			SequenceName: seqName,
+			Increment:    1,
+			MinValue:     1,
+			MaxValue:     9223372036854775807,
+			StartValue:   1,
+			CacheSize:    1,
+		}
+
+		sql, err := w.executor.ExecuteCreateSequence(data)
+		if err != nil {
+			return fmt.Errorf("failed to generate create sequence for %s.%s: %w", schema.Name, seqName, err)
+		}
+		fmt.Fprint(w.writer, sql)
+		fmt.Fprint(w.writer, "\n")
 	}
 
 	return nil
@@ -747,18 +739,19 @@ func (w *Writer) writeAddColumns(schema *models.Schema) error {
 		for _, col := range columns {
 			colDef := w.generateColumnDefinition(col)
 
-			// Generate DO block that checks if column exists before adding
-			fmt.Fprintf(w.writer, "DO $$\nBEGIN\n")
-			fmt.Fprintf(w.writer, "  IF NOT EXISTS (\n")
-			fmt.Fprintf(w.writer, "    SELECT 1 FROM information_schema.columns\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 column_name = '%s'\n", col.Name)
-			fmt.Fprintf(w.writer, "  ) THEN\n")
-			fmt.Fprintf(w.writer, "    ALTER TABLE %s.%s ADD COLUMN %s;\n",
-				schema.SQLName(), table.SQLName(), colDef)
-			fmt.Fprintf(w.writer, "  END IF;\n")
-			fmt.Fprintf(w.writer, "END;\n$$;\n\n")
+			data := AddColumnWithCheckData{
+				SchemaName:       schema.Name,
+				TableName:        table.Name,
+				ColumnName:       col.Name,
+				ColumnDefinition: colDef,
+			}
+
+			sql, err := w.executor.ExecuteAddColumnWithCheck(data)
+			if err != nil {
+				return fmt.Errorf("failed to generate add column for %s.%s.%s: %w", schema.Name, table.Name, col.Name, err)
+			}
+			fmt.Fprint(w.writer, sql)
+			fmt.Fprint(w.writer, "\n")
 		}
 	}
 
@@ -812,37 +805,20 @@ func (w *Writer) writePrimaryKeys(schema *models.Schema) error {
 			fmt.Sprintf("%s_%s_pkey", schema.Name, table.Name),
 		}
 
-		fmt.Fprintf(w.writer, "DO $$\nDECLARE\n")
-		fmt.Fprintf(w.writer, "  auto_pk_name text;\nBEGIN\n")
+		data := CreatePrimaryKeyWithAutoGenCheckData{
+			SchemaName:     schema.Name,
+			TableName:      table.Name,
+			ConstraintName: pkName,
+			AutoGenNames:   formatStringList(autoGenPKNames),
+			Columns:        strings.Join(columnNames, ", "),
+		}
 
-		// Check for and drop auto-generated primary keys
-		fmt.Fprintf(w.writer, "  -- Drop auto-generated primary key if it exists\n")
-		fmt.Fprintf(w.writer, "  SELECT constraint_name INTO auto_pk_name\n")
-		fmt.Fprintf(w.writer, "  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_type = 'PRIMARY KEY'\n")
-		fmt.Fprintf(w.writer, "    AND constraint_name IN (%s);\n", formatStringList(autoGenPKNames))
-		fmt.Fprintf(w.writer, "\n")
-		fmt.Fprintf(w.writer, "  IF auto_pk_name IS NOT NULL THEN\n")
-		fmt.Fprintf(w.writer, "    EXECUTE 'ALTER TABLE %s.%s DROP CONSTRAINT ' || quote_ident(auto_pk_name);\n",
-			schema.SQLName(), table.SQLName())
-		fmt.Fprintf(w.writer, "  END IF;\n")
-		fmt.Fprintf(w.writer, "\n")
-
-		// Add our named primary key if it doesn't exist
-		fmt.Fprintf(w.writer, "  -- Add named primary key if it doesn't exist\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", pkName)
-		fmt.Fprintf(w.writer, "  ) THEN\n")
-		fmt.Fprintf(w.writer, "    ALTER TABLE %s.%s\n", schema.SQLName(), table.SQLName())
-		fmt.Fprintf(w.writer, "      ADD CONSTRAINT %s PRIMARY KEY (%s);\n",
-			pkName, strings.Join(columnNames, ", "))
-		fmt.Fprintf(w.writer, "  END IF;\n")
-		fmt.Fprintf(w.writer, "END;\n$$;\n\n")
+		sql, err := w.executor.ExecuteCreatePrimaryKeyWithAutoGenCheck(data)
+		if err != nil {
+			return fmt.Errorf("failed to generate primary key for %s.%s: %w", schema.Name, table.Name, err)
+		}
+		fmt.Fprint(w.writer, sql)
+		fmt.Fprint(w.writer, "\n")
 	}
 
 	return nil
@@ -954,20 +930,17 @@ func (w *Writer) writeUniqueConstraints(schema *models.Schema) error {
 				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")
+			sql, err := w.executor.ExecuteCreateUniqueConstraint(CreateUniqueConstraintData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				Columns:        strings.Join(columnExprs, ", "),
+			})
+			if err != nil {
+				return fmt.Errorf("failed to generate unique constraint: %w", err)
+			}
+
+			fmt.Fprintf(w.writer, "%s\n\n", sql)
 		}
 	}
 
@@ -996,20 +969,17 @@ func (w *Writer) writeCheckConstraints(schema *models.Schema) error {
 				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 CHECK (%s);\n",
-				schema.SQLName(), table.SQLName(), constraint.Name, constraint.Expression)
-			fmt.Fprintf(w.writer, "  END IF;\n")
-			fmt.Fprintf(w.writer, "END;\n")
-			fmt.Fprintf(w.writer, "$$;\n\n")
+			sql, err := w.executor.ExecuteCreateCheckConstraint(CreateCheckConstraintData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				Expression:     constraint.Expression,
+			})
+			if err != nil {
+				return fmt.Errorf("failed to generate check constraint: %w", err)
+			}
+
+			fmt.Fprintf(w.writer, "%s\n\n", sql)
 		}
 	}
 
@@ -1093,24 +1063,24 @@ func (w *Writer) writeForeignKeys(schema *models.Schema) error {
 				refTable = rel.ToTable
 			}
 
-			// Use DO block to check if constraint exists before adding
-			fmt.Fprintf(w.writer, "DO $$\nBEGIN\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", fkName)
-			fmt.Fprintf(w.writer, "  ) THEN\n")
-			fmt.Fprintf(w.writer, "    ALTER TABLE %s.%s\n", schema.SQLName(), table.SQLName())
-			fmt.Fprintf(w.writer, "      ADD CONSTRAINT %s\n", fkName)
-			fmt.Fprintf(w.writer, "      FOREIGN KEY (%s)\n", strings.Join(sourceColumns, ", "))
-			fmt.Fprintf(w.writer, "      REFERENCES %s.%s (%s)\n",
-				refSchema, refTable, strings.Join(targetColumns, ", "))
-			fmt.Fprintf(w.writer, "      ON DELETE %s\n", onDelete)
-			fmt.Fprintf(w.writer, "      ON UPDATE %s\n", onUpdate)
-			fmt.Fprintf(w.writer, "      DEFERRABLE;\n")
-			fmt.Fprintf(w.writer, "  END IF;\n")
-			fmt.Fprintf(w.writer, "END;\n$$;\n\n")
+			// Use template executor to generate foreign key with existence check
+			data := CreateForeignKeyWithCheckData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: fkName,
+				SourceColumns:  strings.Join(sourceColumns, ", "),
+				TargetSchema:   refSchema,
+				TargetTable:    refTable,
+				TargetColumns:  strings.Join(targetColumns, ", "),
+				OnDelete:       onDelete,
+				OnUpdate:       onUpdate,
+				Deferrable:     true,
+			}
+			sql, err := w.executor.ExecuteCreateForeignKeyWithCheck(data)
+			if err != nil {
+				return fmt.Errorf("failed to generate foreign key for %s.%s: %w", schema.Name, table.Name, err)
+			}
+			fmt.Fprint(w.writer, sql)
 		}
 
 		// Also process any foreign key constraints that don't have a relationship
@@ -1172,23 +1142,24 @@ func (w *Writer) writeForeignKeys(schema *models.Schema) error {
 			}
 			refTable := constraint.ReferencedTable
 
-			// Use DO block to check if constraint exists before adding
-			fmt.Fprintf(w.writer, "DO $$\nBEGIN\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\n", schema.SQLName(), table.SQLName())
-			fmt.Fprintf(w.writer, "      ADD CONSTRAINT %s\n", constraint.Name)
-			fmt.Fprintf(w.writer, "      FOREIGN KEY (%s)\n", strings.Join(sourceColumns, ", "))
-			fmt.Fprintf(w.writer, "      REFERENCES %s.%s (%s)\n",
-				refSchema, refTable, strings.Join(targetColumns, ", "))
-			fmt.Fprintf(w.writer, "      ON DELETE %s\n", onDelete)
-			fmt.Fprintf(w.writer, "      ON UPDATE %s;\n", onUpdate)
-			fmt.Fprintf(w.writer, "  END IF;\n")
-			fmt.Fprintf(w.writer, "END;\n$$;\n\n")
+			// Use template executor to generate foreign key with existence check
+			data := CreateForeignKeyWithCheckData{
+				SchemaName:     schema.Name,
+				TableName:      table.Name,
+				ConstraintName: constraint.Name,
+				SourceColumns:  strings.Join(sourceColumns, ", "),
+				TargetSchema:   refSchema,
+				TargetTable:    refTable,
+				TargetColumns:  strings.Join(targetColumns, ", "),
+				OnDelete:       onDelete,
+				OnUpdate:       onUpdate,
+				Deferrable:     false,
+			}
+			sql, err := w.executor.ExecuteCreateForeignKeyWithCheck(data)
+			if err != nil {
+				return fmt.Errorf("failed to generate foreign key for %s.%s: %w", schema.Name, table.Name, err)
+			}
+			fmt.Fprint(w.writer, sql)
 		}
 	}
 
@@ -1207,26 +1178,19 @@ func (w *Writer) writeSetSequenceValues(schema *models.Schema) error {
 
 		seqName := fmt.Sprintf("identity_%s_%s", table.SQLName(), pk.SQLName())
 
-		fmt.Fprintf(w.writer, "DO $$\n")
-		fmt.Fprintf(w.writer, "DECLARE\n")
-		fmt.Fprintf(w.writer, "  m_cnt bigint;\n")
-		fmt.Fprintf(w.writer, "BEGIN\n")
-		fmt.Fprintf(w.writer, "  IF EXISTS (\n")
-		fmt.Fprintf(w.writer, "    SELECT 1 FROM pg_class c\n")
-		fmt.Fprintf(w.writer, "    INNER JOIN pg_namespace n ON n.oid = c.relnamespace\n")
-		fmt.Fprintf(w.writer, "    WHERE c.relname = '%s'\n", seqName)
-		fmt.Fprintf(w.writer, "      AND n.nspname = '%s'\n", schema.Name)
-		fmt.Fprintf(w.writer, "      AND c.relkind = 'S'\n")
-		fmt.Fprintf(w.writer, "  ) THEN\n")
-		fmt.Fprintf(w.writer, "    SELECT COALESCE(MAX(%s), 0) + 1\n", pk.SQLName())
-		fmt.Fprintf(w.writer, "    FROM %s.%s\n", schema.SQLName(), table.SQLName())
-		fmt.Fprintf(w.writer, "    INTO m_cnt;\n")
-		fmt.Fprintf(w.writer, "    \n")
-		fmt.Fprintf(w.writer, "    PERFORM setval('%s.%s'::regclass, m_cnt);\n",
-			schema.SQLName(), seqName)
-		fmt.Fprintf(w.writer, "  END IF;\n")
-		fmt.Fprintf(w.writer, "END;\n")
-		fmt.Fprintf(w.writer, "$$;\n\n")
+		// Use template executor to generate set sequence value statement
+		data := SetSequenceValueData{
+			SchemaName:   schema.Name,
+			TableName:    table.Name,
+			SequenceName: seqName,
+			ColumnName:   pk.Name,
+		}
+		sql, err := w.executor.ExecuteSetSequenceValue(data)
+		if err != nil {
+			return fmt.Errorf("failed to generate set sequence value for %s.%s: %w", schema.Name, table.Name, err)
+		}
+		fmt.Fprint(w.writer, sql)
+		fmt.Fprint(w.writer, "\n")
 	}
 
 	return nil
@@ -1580,3 +1544,9 @@ func truncateStatement(stmt string) string {
 func getCurrentTimestamp() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
+
+// quoteIdentifier wraps an identifier in double quotes if necessary
+// This is needed for identifiers that start with numbers or contain special characters
+func quoteIdentifier(s string) string {
+	return quoteIdent(s)
+}