feat: update job configuration for infraestructura_site_holder__attach; enhance storage handling and retry logic

.atl/skill-registry.md

@@ -0,0 +1,24 @@
+# Skill Registry — go-migrate
+
+Generated: 2026-04-21
+
+## Compact Rules
+
+### Go conventions
+- Use existing error wrapping pattern: `fmt.Errorf("context: %w", err)`
+- Channel-based pipeline — keep goroutine lifecycle clean (close channels in correct order)
+- No comments unless non-obvious WHY; no docstrings
+- Prefer named returns only when it aids clarity in short functions
+- Use `strings.EqualFold` for case-insensitive column name comparison
+
+### Project conventions
+- Config structs live in `internal/app/config/`
+- ETL interfaces live in `internal/app/etl/types.go`
+- Transformer implementations in `internal/app/etl/transformers/`
+- Azure operations via `internal/app/azure/main.go`
+- Per-job transformer creation (not shared) when job has storage config
+
+## User Skills
+| Trigger | Skill |
+|---------|-------|
+| sdd-* | SDD workflow skills |

.env.example

@@ -1,2 +1,12 @@
-PG_FROM_DB_URL=postgresql://postgres:password@localhost:5432/db
-PG_TO_DB_URL=postgresql://postgres:password@localhost:5432/db
+SOURCE_DB_URL=sqlserver://sa:password@localhost:1433?database=master&packet+size=32767&loc=UTC
+TARGET_DB_URL=postgresql://postgres:password@localhost:5432/db
+
+LOG_LEVEL=INFO
+
+AZ_STORAGE_ENABLED=false
+AZ_ACCOUNT_NAME=
+AZ_CONTAINER=
+AZ_ACCOUNT_KEY=
+AZ_USE_HTTPS=true
+AZ_SERVICE_URL=
+AZ_PREFIX=

.gitignore

@@ -4,6 +4,7 @@
 *.dll
 *.so
 *.dylib
+bin/
 
 # Test binary, built with `go test -c`
 *.test
@@ -26,5 +27,5 @@ go.work.sum
 
 # Editor/IDE
 # .idea/
-# .vscode/
+.vscode/
 .temp

Makefile

@@ -0,0 +1,80 @@
+.PHONY: build build-linux build-windows build-all clean help
+
+# Variables
+BINARY_NAME=go-migrate
+CMD_PATH=./cmd/go_migrate
+OUTPUT_DIR=bin
+VERSION?=$(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+BUILD_TIME=$(shell date -u '+%Y-%m-%d_%H:%M:%S')
+GIT_COMMIT=$(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+
+# Flags de compilación
+LD_FLAGS=-ldflags="-s -w -X main.Version=$(VERSION) -X main.BuildTime=$(BUILD_TIME) -X main.GitCommit=$(GIT_COMMIT)"
+
+# Default: compilar para el SO actual
+build: build-$(OS)
+
+ifeq ($(OS),Windows_NT)
+build-native: build-windows
+else
+build-native: build-linux
+endif
+
+# Compilar para Linux (sin CGO para máxima compatibilidad)
+build-linux:
+	@echo "Compilando para Linux..."
+	@mkdir -p $(OUTPUT_DIR)
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+		$(LD_FLAGS) \
+		-o $(OUTPUT_DIR)/$(BINARY_NAME)-linux-amd64 \
+		$(CMD_PATH)
+	@echo "Binario creado: $(OUTPUT_DIR)/$(BINARY_NAME)-linux-amd64"
+
+# Compilar para Windows
+build-windows:
+	@echo "Compilando para Windows..."
+	@mkdir -p $(OUTPUT_DIR)
+	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build \
+		$(LD_FLAGS) \
+		-o $(OUTPUT_DIR)/$(BINARY_NAME)-windows-amd64.exe \
+		$(CMD_PATH)
+	@echo "Binario creado: $(OUTPUT_DIR)/$(BINARY_NAME)-windows-amd64.exe"
+
+# Compilar para ambas plataformas
+build-all: build-linux build-windows
+	@echo ""
+	@echo "Binarios compilados:"
+	@ls -lh $(OUTPUT_DIR)/$(BINARY_NAME)*
+
+# Compilar para Linux arm64 (opcional, para Raspberry Pi, etc.)
+build-linux-arm64:
+	@echo "Compilando para Linux ARM64..."
+	@mkdir -p $(OUTPUT_DIR)
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build \
+		$(LD_FLAGS) \
+		-o $(OUTPUT_DIR)/$(BINARY_NAME)-linux-arm64 \
+		$(CMD_PATH)
+	@echo "Binario creado: $(OUTPUT_DIR)/$(BINARY_NAME)-linux-arm64"
+
+# Limpiar binarios
+clean:
+	@echo "Limpiando binarios..."
+	@rm -rf $(OUTPUT_DIR)
+	@echo "Limpieza completada"
+
+# Ayuda
+help:
+	@echo "Comandos disponibles:"
+	@echo ""
+	@echo "  make build              - Compilar para el SO actual (Linux/Windows)"
+	@echo "  make build-linux        - Compilar para Linux x86_64"
+	@echo "  make build-windows      - Compilar para Windows x86_64"
+	@echo "  make build-linux-arm64  - Compilar para Linux ARM64 (opcional)"
+	@echo "  make build-all          - Compilar para Linux y Windows"
+	@echo "  make clean              - Eliminar binarios compilados"
+	@echo "  make help               - Mostrar esta ayuda"
+	@echo ""
+	@echo "Ejemplos de uso:"
+	@echo "  make build-all          # Crear binarios para ambas plataformas"
+	@echo "  make build-linux OS=    # Crear solo para Linux"
+	@echo ""

cmd/go_migrate/connect.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
-	"github.com/jackc/pgx/v5/pgxpool"
-	_ "github.com/microsoft/go-mssqldb"
-	log "github.com/sirupsen/logrus"
-)
-
-func connectToSqlServer() (*sql.DB, error) {
-	db, err := sql.Open("sqlserver", config.App.SourceDbUrl)
-	if err != nil {
-		return nil, fmt.Errorf("Unable to connect to sqlserver: %w", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
-	defer cancel()
-
-	if err := db.PingContext(ctx); err != nil {
-		return nil, fmt.Errorf("Unable to ping sqlserver: %w", err)
-	}
-
-	return db, nil
-}
-
-func connectToPostgres() (*pgxpool.Pool, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
-	defer cancel()
-
-	pool, err := pgxpool.New(ctx, config.App.TargetDbUrl)
-	if err != nil {
-		return nil, fmt.Errorf("Unable to connect to postgres: %w", err)
-	}
-
-	if err := pool.Ping(ctx); err != nil {
-		pool.Close()
-		return nil, fmt.Errorf("Unable to ping postgres: %w", err)
-	}
-
-	return pool, nil
-}
-
-func connectToDatabases() (*sql.DB, *pgxpool.Pool, error) {
-	var sourceDbErr, targetDbErr error
-	var sourceDb *sql.DB
-	var targetDb *pgxpool.Pool
-	var wg sync.WaitGroup
-
-	wg.Go(func() {
-		sourceDb, sourceDbErr = connectToSqlServer()
-		if sourceDbErr != nil {
-			log.Error("Unable to connect to source db: ", sourceDbErr)
-		}
-	})
-
-	wg.Go(func() {
-		targetDb, targetDbErr = connectToPostgres()
-		if targetDbErr != nil {
-			log.Error("Unable to connect to target db: ", targetDbErr)
-		}
-	})
-
-	wg.Wait()
-
-	if sourceDbErr != nil || targetDbErr != nil {
-		return nil, nil, errors.New("Unable to connect to databases")
-	}
-
-	return sourceDb, targetDb, nil
-}

cmd/go_migrate/log.go

@@ -3,6 +3,7 @@ package main
 import (
 	"time"
 
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -13,5 +14,13 @@ func configureLog() {
 		DisableSorting:  false,
 		PadLevelText:    true,
 	})
-	log.SetLevel(log.InfoLevel)
+
+	logLevelEnv := config.App.LogLevel
+	logLevel, err := log.ParseLevel(logLevelEnv)
+	if err != nil {
+		log.Warnf("Nivel de log inválido '%s', usando INFO por defecto", logLevelEnv)
+		logLevel = log.InfoLevel
+	}
+
+	log.SetLevel(logLevel)
 }

cmd/go_migrate/main.go

@@ -2,17 +2,18 @@ package main
 
 import (
 	"context"
-	"database/sql"
 	"sync"
 	"time"
 
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/azure"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/extractors"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/loaders"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/table_analyzers"
-	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/transformers"
-	"github.com/jackc/pgx/v5/pgxpool"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	log "github.com/sirupsen/logrus"
+	"golang.org/x/sync/errgroup"
 )
 
 func main() {
@@ -23,7 +24,7 @@ func main() {
 		log.Fatalf("error leyendo configuracion: %v", err)
 	}
 
-	log.Debugf("Config: %+v", migrationConfig)
+	// log.Debugf("Config: %+v", migrationConfig)
 
 	startTime := time.Now()
 
@@ -32,11 +33,33 @@ func main() {
 
 	log.Info("=== Starting migration ===")
 
-	sourceDb, targetDb, connError := connectToDatabases()
-	if connError != nil {
-		log.Fatal("Connection error: ", connError)
-	}
+	var wgConnect errgroup.Group
+	var sourceDb, targetDb dbwrapper.DbWrapper
 
+	wgConnect.Go(func() error {
+		var err error
+		sourceDb, err = connectWithTimeout(ctx, migrationConfig.SourceDbType, config.App.SourceDbUrl, 20*time.Second)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	wgConnect.Go(func() error {
+		var err error
+		targetDb, err = connectWithTimeout(ctx, migrationConfig.TargetDbType, config.App.TargetDbUrl, 20*time.Second)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err := wgConnect.Wait(); err != nil {
+		log.Error("Connection error: ", err)
+		return
+	}
 	defer sourceDb.Close()
 	defer targetDb.Close()
 
@@ -49,8 +72,10 @@ func main() {
 		status := "OK"
 		if res.Error != nil {
 			status = "FAILED"
+			log.Infof("[%s] Status: %s | Read: %d | Loaded: %d | Errors: %d | Time: %v | Error: %v", res.JobName, status, res.RowsRead, res.RowsLoaded, res.RowsFailed, res.Duration, res.Error)
+		} else {
+			log.Infof("[%s] Status: %s | Read: %d | Loaded: %d | Errors: %d | Time: %v", res.JobName, status, res.RowsRead, res.RowsLoaded, res.RowsFailed, res.Duration)
 		}
-		log.Infof("[%s] Status: %s | Read: %d | Loaded: %d | Errors: %d | Time: %v", res.JobName, status, res.RowsRead, res.RowsLoaded, res.RowsFailed, res.Duration)
 
 		totalProcessed += res.RowsLoaded
 		if res.Error != nil {
@@ -67,14 +92,14 @@ func main() {
 
 func processMigrationJobs(
 	ctx context.Context,
-	sourceDb *sql.DB,
-	targetDb *pgxpool.Pool,
+	sourceDb dbwrapper.DbWrapper,
+	targetDb dbwrapper.DbWrapper,
 	jobs []config.Job,
 	maxParallelWorkers int,
-) []JobResult {
+) []models.JobResult {
 	if len(jobs) == 0 {
 		log.Info("No migration jobs configured")
-		return []JobResult{}
+		return []models.JobResult{}
 	}
 
 	if maxParallelWorkers <= 0 {
@@ -87,15 +112,23 @@ func processMigrationJobs(
 
 	log.Infof("Starting migration with %d parallel worker(s)", maxParallelWorkers)
 
-	chJobResults := make(chan JobResult, len(jobs))
+	chJobResults := make(chan models.JobResult, len(jobs))
 	chJobs := make(chan config.Job, len(jobs))
 	var wgJobs sync.WaitGroup
 
 	sourceTableAnalyzer := table_analyzers.NewMssqlTableAnalyzer(sourceDb)
 	targetTableAnalyzer := table_analyzers.NewPostgresTableAnalyzer(targetDb)
 	extractor := extractors.NewMssqlExtractor(sourceDb)
-	transformer := transformers.NewMssqlTransformer()
-	loader := loaders.NewPostgresLoader(targetDb)
+	loader := loaders.NewGenericLoader(targetDb)
+
+	var azureClient *azure.Client
+	if config.App.AzureStorage.Enabled {
+		var err error
+		azureClient, err = azure.NewClient(config.App.AzureStorage)
+		if err != nil {
+			log.Fatalf("Failed to create Azure storage client: %v", err)
+		}
+	}
 
 	for i := range maxParallelWorkers {
 		wgJobs.Go(func() {
@@ -103,12 +136,14 @@ func processMigrationJobs(
 				log.Infof("[worker %d] >>> Processing job: %s.%s <<<", i, job.SourceTable.Schema, job.SourceTable.Table)
 				res := processMigrationJob(
 					ctx,
+					targetDb,
 					sourceTableAnalyzer,
 					targetTableAnalyzer,
 					extractor,
-					transformer,
+					azureClient,
 					loader,
 					job,
+					targetDb.GetDialect(),
 				)
 
 				chJobResults <- res
@@ -126,10 +161,26 @@ func processMigrationJobs(
 		close(chJobResults)
 	}()
 
-	var finalResults []JobResult
+	var finalResults []models.JobResult
 	for res := range chJobResults {
 		finalResults = append(finalResults, res)
 	}
 
 	return finalResults
 }
+
+func connectWithTimeout(ctx context.Context, dbType string, dbUrl string, timeout time.Duration) (dbwrapper.DbWrapper, error) {
+	localCtx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	sourceDb, err := dbwrapper.New(dbType)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = sourceDb.Connect(localCtx, dbUrl); err != nil {
+		return nil, err
+	}
+
+	return sourceDb, nil
+}

cmd/go_migrate/metrics.go

@@ -1,13 +0,0 @@
-package main
-
-import "time"
-
-type JobResult struct {
-	JobName    string
-	StartTime  time.Time
-	Duration   time.Duration
-	RowsRead   int64
-	RowsLoaded int64
-	RowsFailed int64
-	Error      error
-}

cmd/go_migrate/process.go

@@ -2,32 +2,54 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/azure"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/extractors"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/table_analyzers"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl/transformers"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	log "github.com/sirupsen/logrus"
 	"golang.org/x/sync/errgroup"
 )
 
+func buildTruncateQuery(targetDbType, schema, table, truncateMethod string) string {
+	if truncateMethod == "DELETE" {
+		if targetDbType == "postgres" {
+			return fmt.Sprintf(`DELETE FROM "%s"."%s"`, schema, table)
+		}
+		return fmt.Sprintf(`DELETE FROM [%s].[%s]`, schema, table)
+	}
+
+	if targetDbType == "postgres" {
+		return fmt.Sprintf(`TRUNCATE TABLE "%s"."%s"`, schema, table)
+	}
+	return fmt.Sprintf(`TRUNCATE TABLE [%s].[%s]`, schema, table)
+}
+
 func processMigrationJob(
 	ctx context.Context,
+	targetDbWrapper dbwrapper.DbWrapper,
 	sourceTableAnalyzer etl.TableAnalyzer,
 	targetTableAnalyzer etl.TableAnalyzer,
 	extractor etl.Extractor,
-	transformer etl.Transformer,
+	azureClient *azure.Client,
 	loader etl.Loader,
 	job config.Job,
-) JobResult {
-	jobCtx, cancel := context.WithCancel(ctx)
+	targetDbType string,
+) models.JobResult {
+	transformer := transformers.NewMssqlTransformer(job.ToStorage, job.SourceTable, azureClient)
+	localCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	result := JobResult{
+	result := models.JobResult{
 		JobName:   job.Name,
 		StartTime: time.Now(),
 	}
@@ -39,7 +61,7 @@ func processMigrationJob(
 
 	wgQueryColumnTypes.Go(func() error {
 		var err error
-		sourceColTypes, err = sourceTableAnalyzer.QueryColumnTypes(jobCtx, job.SourceTable.TableInfo)
+		sourceColTypes, err = sourceTableAnalyzer.QueryColumnTypes(localCtx, job.SourceTable.TableInfo)
 		if err != nil {
 			return err
 		}
@@ -49,7 +71,7 @@ func processMigrationJob(
 
 	wgQueryColumnTypes.Go(func() error {
 		var err error
-		targetColTypes, err = targetTableAnalyzer.QueryColumnTypes(jobCtx, job.TargetTable.TableInfo)
+		targetColTypes, err = targetTableAnalyzer.QueryColumnTypes(localCtx, job.TargetTable.TableInfo)
 		if err != nil {
 			return err
 		}
@@ -63,12 +85,26 @@ func processMigrationJob(
 		return result
 	}
 
+	preSqlQueries := job.TargetTable.PreSQL
+	if job.TruncateTarget {
+		truncateQuery := buildTruncateQuery(targetDbType, job.TargetTable.Schema, job.TargetTable.Table, job.TruncateMethod)
+		preSqlQueries = append([]string{truncateQuery}, job.TargetTable.PreSQL...)
+	}
+
+	for _, query := range preSqlQueries {
+		if _, err := targetDbWrapper.Exec(localCtx, query); err != nil {
+			result.Error = err
+			return result
+		}
+	}
+
 	partitions, err := table_analyzers.PartitionRangeGenerator(
-		jobCtx,
+		localCtx,
 		sourceTableAnalyzer,
 		job.SourceTable.TableInfo,
 		job.SourceTable.PrimaryKey,
 		job.RowsPerPartition,
+		job.Range,
 	)
 	if err != nil {
 		log.Error("Unexpected error calculating batch ranges: ", err)
@@ -88,7 +124,7 @@ func processMigrationJob(
 	var wgLoaders sync.WaitGroup
 
 	go func() {
-		if err := custom_errors.JobErrorHandler(jobCtx, chJobErrors); err != nil {
+		if err := custom_errors.JobErrorHandler(localCtx, chJobErrors); err != nil {
 			log.Error("Fatal error received from JobErrorHandler, canceling job... - ", err)
 			cancel()
 			result.Error = err
@@ -96,16 +132,18 @@ func processMigrationJob(
 	}()
 
 	go custom_errors.ExtractorErrorHandler(
-		jobCtx,
+		localCtx,
 		job.Retry,
+		job.MaxPartitionErrrors,
 		chExtractorErrors,
 		chPartitions,
 		chJobErrors,
 		&wgActivePartitions,
 	)
 	go custom_errors.LoaderErrorHandler(
-		jobCtx,
+		localCtx,
 		job.Retry,
+		job.MaxChunkErrors,
 		chLoadersErrors,
 		chBatchesTransformed,
 		chJobErrors,
@@ -117,8 +155,9 @@ func processMigrationJob(
 
 	for range maxExtractors {
 		wgExtractors.Go(func() {
-			extractor.Exec(
-				jobCtx,
+			extractors.Consume(
+				localCtx,
+				extractor,
 				job.SourceTable,
 				sourceColTypes,
 				job.BatchSize,
@@ -144,7 +183,7 @@ func processMigrationJob(
 	for range maxExtractors {
 		wgTransformers.Go(func() {
 			transformer.Exec(
-				jobCtx,
+				localCtx,
 				sourceColTypes,
 				chBatchesRaw,
 				chBatchesTransformed,
@@ -159,7 +198,7 @@ func processMigrationJob(
 	for range job.MaxLoaders {
 		wgLoaders.Go(func() {
 			loader.Exec(
-				jobCtx,
+				localCtx,
 				job.TargetTable,
 				targetColTypes,
 				chBatchesTransformed,
@@ -202,8 +241,15 @@ func processMigrationJob(
 		cancel()
 	}()
 
+	for _, query := range job.TargetTable.PostSQL {
+		if _, err := targetDbWrapper.Exec(localCtx, query); err != nil {
+			result.Error = err
+			return result
+		}
+	}
+
 	log.Debugf("waiting for local context to be done (%v)", job.Name)
-	<-jobCtx.Done()
+	<-localCtx.Done()
 	log.Debugf("local context done (%v)", job.Name)
 
 	if ctx.Err() != nil {
@@ -215,5 +261,9 @@ func processMigrationJob(
 	result.RowsLoaded = atomic.LoadInt64(&rowsLoaded)
 	result.RowsFailed = atomic.LoadInt64(&rowsFailed)
 
+	if result.RowsRead != result.RowsLoaded {
+		result.Error = fmt.Errorf("Row count mismatch: extracted %d rows but loaded %d rows (failed: %d)", result.RowsRead, result.RowsLoaded, result.RowsFailed)
+	}
+
 	return result
 }

config.yaml

@@ -10,6 +10,8 @@ defaults:
   batches_per_partition: 8
   truncate_target: true
   truncate_method: TRUNCATE # TRUNCATE | DELETE
+  max_partition_errrors: 5
+  max_chunk_errors: 5
   retry:
     attempts: 3
     base_delay_ms: 500
@@ -26,6 +28,13 @@ jobs:
     target:
       schema: Cartografia
       table: MANZANA
+      pre_sql: 
+        - 'SELECT 1'
+    range:
+      min: 1000000
+      max: 2000000
+      is_min_inclusive: false
+      is_max_inclusive: true
 
   - name: red_puerto
     enabled: true
@@ -36,3 +45,30 @@ jobs:
     target:
       schema: Red
       table: PUERTO
+      pre_sql: 
+        - 'SELECT 1'
+      post_sql: 
+        - "SELECT 1"
+
+  - name: infraestructura_site_holder__attach
+    source:
+      schema: Infraestructura
+      table: SITE_HOLDER__ATTACH
+      primary_key: GDB_ARCHIVE_OID
+    target:
+      schema: Infraestructura
+      table: SITE_HOLDER__ATTACH
+    to_storage:
+      columns:
+        - source: DATA
+          target: FILE_URL
+          mode: REFERENCE_ONLY
+    max_extractors: 8
+    max_loaders: 4
+    queue_size: 32
+    batch_size: 1
+    retry:
+      attempts: 5
+      base_delay_ms: 1000
+      max_delay_ms: 15000
+      max_jitter_ms: 500

go.mod

@@ -1,12 +1,13 @@
 module git.ksdemosapps.com/kylesoda/go-migrate
 
-go 1.25.7
+go 1.26
 
 require (
+	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.4
 	github.com/gaspardle/go-mssqlclrgeo v0.0.0-20160129143314-97ceabf987a4
 	github.com/google/uuid v1.6.0
+	github.com/ilyakaznacheev/cleanenv v1.5.0
 	github.com/jackc/pgx/v5 v5.9.1
-	github.com/joho/godotenv v1.5.1
 	github.com/microsoft/go-mssqldb v1.9.8
 	github.com/sirupsen/logrus v1.9.4
 	github.com/twpayne/go-geom v1.6.1
@@ -15,15 +16,20 @@ require (
 )
 
 require (
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
+	github.com/BurntSushi/toml v1.6.0 // indirect
 	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
 	github.com/golang-sql/sqlexp v0.1.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
-	github.com/kr/text v0.2.0 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/shopspring/decimal v1.4.0 // indirect
 	golang.org/x/crypto v0.48.0 // indirect
+	golang.org/x/net v0.51.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect
 	golang.org/x/text v0.34.0 // indirect
+	olympos.io/encoding/edn v0.0.0-20201019073823-d3554ca0b0a3 // indirect
 )

go.sum

@@ -4,19 +4,25 @@ github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpz
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 h1:9iefClla7iYpfYWdzPCRDozdmndjTm8DXdpCzPajMgA=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2/go.mod h1:XtLgD3ZD34DAaVIIAyG3objl5DynM3CQ/vMcbBNJZGI=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1 h1:/Zt+cDPnpC3OVDm/JKLOs7M2DKmLRIIp3XIx9pHHiig=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1/go.mod h1:Ng3urmn6dYe8gnbCMoHHVl5APYz2txho3koEkV2o2HA=
 github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.4.0 h1:E4MgwLBGeVB5f2MdcIVD3ELVAWpr+WD6MUe1i+tM/PA=
 github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.4.0/go.mod h1:Y2b/1clN4zsAoUd/pgNAQHjLDnTis/6ROkUfyob6psM=
 github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0 h1:nCYfgcSyHZXJI8J0IWE5MsCGlb2xp9fJiXyxWgmOFg4=
 github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0/go.mod h1:ucUjca2JtSZboY8IoUqyQyuuXvwbMBVwFOm0vdQPNhA=
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.4 h1:jWQK1GI+LeGGUKBADtcH2rRqPxYB1Ljwms5gFA2LqrM=
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.4/go.mod h1:8mwH4klAm9DUgR2EEHyEEAQlRDvLPyg5fQry3y+cDew=
 github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 h1:XRzhVemXdgvJqCH0sFfrBUTnUJSBrBf7++ypk+twtRs=
 github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk=
+github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk=
+github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
 github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
 github.com/alecthomas/assert/v2 v2.10.0 h1:jjRCHsj6hBJhkmhznrCzoNpbA3zqy0fYiUcYZP/GkPY=
 github.com/alecthomas/assert/v2 v2.10.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -32,6 +38,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/ilyakaznacheev/cleanenv v1.5.0 h1:0VNZXggJE2OYdXE87bfSSwGxeiGt9moSR2lOrsHHvr4=
+github.com/ilyakaznacheev/cleanenv v1.5.0/go.mod h1:a5aDzaJrLCQZsazHol1w8InnDcOX0OColm64SlIi6gk=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
@@ -42,8 +50,8 @@ github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
@@ -83,3 +91,5 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+olympos.io/encoding/edn v0.0.0-20201019073823-d3554ca0b0a3 h1:slmdOY3vp8a7KQbHkL+FLbvbkgMqmXojpFUO/jENuqQ=
+olympos.io/encoding/edn v0.0.0-20201019073823-d3554ca0b0a3/go.mod h1:oVgVk4OWVDi43qWBEyGhXgYxt7+ED4iYNpTngSLX2Iw=

internal/app/azure/main.go

@@ -0,0 +1,87 @@
+package azure
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
+)
+
+var (
+	ErrInvalidConnectionString = errors.New("invalid connection string")
+	ErrContainerNotFound       = errors.New("container not found")
+	ErrBlobNotFound            = errors.New("blob not found")
+	ErrInvalidInput            = errors.New("invalid input parameters")
+)
+
+type Client struct {
+	client             *azblob.Client
+	azureStorageConfig config.AzureStorageConfig
+}
+
+func NewClient(azureStorageConfig config.AzureStorageConfig) (*Client, error) {
+	protocol := "https"
+	if !azureStorageConfig.UseHTTPS {
+		protocol = "http"
+	}
+
+	blobEndpoint, _ := url.JoinPath(azureStorageConfig.ServiceURL, azureStorageConfig.AccountName)
+	connStr := fmt.Sprintf("DefaultEndpointsProtocol=%s;AccountName=%s;AccountKey=%s;BlobEndpoint=%s;",
+		protocol, azureStorageConfig.AccountName, azureStorageConfig.AccountKey, blobEndpoint)
+
+	client, err := azblob.NewClientFromConnectionString(connStr, nil)
+	if err != nil {
+		return nil, fmt.Errorf("creating azure storage client: %w", err)
+	}
+
+	return &Client{
+		client:             client,
+		azureStorageConfig: azureStorageConfig,
+	}, nil
+}
+
+func (c *Client) CreateContainer(ctx context.Context, containerName string) error {
+	if containerName == "" {
+		return ErrInvalidInput
+	}
+
+	_, err := c.client.CreateContainer(ctx, containerName, nil)
+	if err != nil {
+		return fmt.Errorf("creating container %s: %w", containerName, err)
+	}
+	return nil
+}
+
+func (c *Client) UploadBuffer(ctx context.Context, containerName, blobPath string, buffer []byte) error {
+	if containerName == "" || blobPath == "" || buffer == nil {
+		return ErrInvalidInput
+	}
+
+	_, err := c.client.UploadBuffer(ctx, containerName, blobPath, buffer, nil)
+	if err != nil {
+		return fmt.Errorf("uploading blob %s: %w", blobPath, err)
+	}
+	return nil
+}
+
+func (c *Client) UploadAndGetURL(ctx context.Context, blobPath string, buffer []byte) (string, error) {
+	if blobPath == "" || buffer == nil {
+		return "", ErrInvalidInput
+	}
+
+	fullPath := blobPath
+	if c.azureStorageConfig.Prefix != "" {
+		fullPath, _ = url.JoinPath(c.azureStorageConfig.Prefix, blobPath)
+	}
+
+	if err := c.UploadBuffer(ctx, c.azureStorageConfig.Container, fullPath, buffer); err != nil {
+		return "", err
+	}
+
+	blobEndpoint, _ := url.JoinPath(c.azureStorageConfig.ServiceURL, c.azureStorageConfig.AccountName)
+	blobURL, _ := url.JoinPath(blobEndpoint, c.azureStorageConfig.Container, fullPath)
+	return blobURL, nil
+}

internal/app/config/main.go

@@ -1,41 +1,41 @@
 package config
 
 import (
-	"os"
-
-	"github.com/joho/godotenv"
+	"github.com/ilyakaznacheev/cleanenv"
 	log "github.com/sirupsen/logrus"
 )
 
-type appConfig struct {
-	SourceDbUrl string
-	TargetDbUrl string
+type AzureStorageConfig struct {
+	AccountName string `env:"AZ_ACCOUNT_NAME"`
+	Container   string `env:"AZ_CONTAINER"`
+	AccountKey  string `env:"AZ_ACCOUNT_KEY"`
+	UseHTTPS    bool   `env:"AZ_USE_HTTPS" env-default:"true"`
+	ServiceURL  string `env:"AZ_SERVICE_URL"`
+	Prefix      string `env:"AZ_PREFIX"`
+	Enabled     bool   `env:"AZ_STORAGE_ENABLED"`
 }
 
-func loadEnv() {
-	err := godotenv.Load()
-	if err != nil {
-		log.Warn("Warning: could not load .env file")
-	}
+type appConfig struct {
+	SourceDbUrl  string `env:"SOURCE_DB_URL" env-required:"true"`
+	TargetDbUrl  string `env:"TARGET_DB_URL" env-required:"true"`
+	LogLevel     string `env:"LOG_LEVEL" env-default:"INFO"`
+	AzureStorage AzureStorageConfig
 }
 
 func getAppConfig() appConfig {
-	loadEnv()
+	var cfg appConfig
 
-	sourceDbUrl := os.Getenv("SOURCE_DB_URL")
-	if sourceDbUrl == "" {
-		log.Fatal("SOURCE_DB_URL environment variable not set")
+	err := cleanenv.ReadConfig(".env", &cfg)
+	if err != nil {
+		log.Warn("Could not load .env file")
 	}
 
-	targetDbUrl := os.Getenv("TARGET_DB_URL")
-	if targetDbUrl == "" {
-		log.Fatal("TARGET_DB_URL environment variable not set")
+	err = cleanenv.ReadEnv(&cfg)
+	if err != nil {
+		log.Fatalf("Error al cargar variables: %v", err)
 	}
 
-	return appConfig{
-		SourceDbUrl: sourceDbUrl,
-		TargetDbUrl: targetDbUrl,
-	}
+	return cfg
 }
 
 var App appConfig = getAppConfig()

internal/app/config/migration.go

@@ -8,12 +8,22 @@ import (
 )
 
 type RetryConfig struct {
-	Attempts int `yaml:"attempts"`
+	Attempts    int `yaml:"attempts"`
 	BaseDelayMs int `yaml:"base_delay_ms"`
-	MaxDelayMs int `yaml:"max_delay_ms"`
+	MaxDelayMs  int `yaml:"max_delay_ms"`
 	MaxJitterMs int `yaml:"max_jitter_ms"`
 }
 
+type ToStorageColumnConfig struct {
+	Source string `yaml:"source"`
+	Target string `yaml:"target"`
+	Mode   string `yaml:"mode"`
+}
+
+type ToStorageConfig struct {
+	Columns []ToStorageColumnConfig `yaml:"columns"`
+}
+
 type JobConfig struct {
 	MaxExtractors       int         `yaml:"max_extractors"`
 	MaxLoaders          int         `yaml:"max_loaders"`
@@ -22,8 +32,11 @@ type JobConfig struct {
 	BatchesPerPartition int         `yaml:"batches_per_partition"`
 	TruncateTarget      bool        `yaml:"truncate_target"`
 	TruncateMethod      string      `yaml:"truncate_method"`
+	MaxPartitionErrrors int         `yaml:"max_partition_errrors"`
+	MaxChunkErrors      int         `yaml:"max_chunk_errors"`
 	Retry               RetryConfig `yaml:"retry"`
 	RowsPerPartition    int64
+	ToStorage           ToStorageConfig `yaml:"to_storage"`
 }
 
 type TableInfo struct {
@@ -31,23 +44,31 @@ type TableInfo struct {
 	Table  string `yaml:"table"`
 }
 
-type TargetTableInfo struct {
-	TableInfo `yaml:",inline"`
-}
-
 type SourceTableInfo struct {
 	TableInfo  `yaml:",inline"`
 	PrimaryKey string `yaml:"primary_key"`
 }
 
+type TargetTableInfo struct {
+	TableInfo `yaml:",inline"`
+	PreSQL    []string `yaml:"pre_sql"`
+	PostSQL   []string `yaml:"post_sql"`
+}
+
+type RangeConfig struct {
+	Min            int64 `yaml:"min"`
+	Max            int64 `yaml:"max"`
+	IsMinInclusive bool  `yaml:"is_min_inclusive"`
+	IsMaxInclusive bool  `yaml:"is_max_inclusive"`
+}
+
 type Job struct {
 	Name        string          `yaml:"name"`
 	Enabled     bool            `yaml:"enabled"`
 	SourceTable SourceTableInfo `yaml:"source"`
 	TargetTable TargetTableInfo `yaml:"target"`
-	PreSQL      []string        `yaml:"pre_sql"`
-	PostSQL     []string        `yaml:"post_sql"`
 	JobConfig   `yaml:",inline"`
+	Range       RangeConfig `yaml:"range"`
 }
 
 type MigrationConfig struct {
@@ -74,6 +95,8 @@ func (c *MigrationConfig) UnmarshalYAML(value *yaml.Node) error {
 
 	c.MaxParallelWorkers = raw.MaxParallelWorkers
 	c.Defaults = raw.Defaults
+	c.SourceDbType = raw.SourceDbType
+	c.TargetDbType = raw.TargetDbType
 	c.Defaults.RowsPerPartition = int64(raw.Defaults.BatchSize * raw.Defaults.BatchesPerPartition)
 
 	for _, node := range raw.Jobs {

internal/app/custom_errors/extractor.error.go

@@ -24,11 +24,14 @@ func (e *ExtractorError) Error() string {
 func ExtractorErrorHandler(
 	ctx context.Context,
 	retryConfig config.RetryConfig,
+	maxPartitionErrors int,
 	chErrorsIn <-chan ExtractorError,
 	chPartitionsOut chan<- models.Partition,
 	chJobErrorsOut chan<- JobError,
 	wgActivePartitions *sync.WaitGroup,
 ) {
+	definitiveErrors := 0
+
 	for {
 		if ctx.Err() != nil {
 			return
@@ -45,6 +48,7 @@ func ExtractorErrorHandler(
 
 			if err.Partition.RetryCounter >= retryConfig.Attempts {
 				wgActivePartitions.Done()
+				definitiveErrors++
 				jobError := JobError{
 					ShouldCancelJob: false,
 					Msg:             fmt.Sprintf("Partition %v reached max retries (%d)", err.Partition.Id, retryConfig.Attempts),
@@ -57,6 +61,20 @@ func ExtractorErrorHandler(
 					return
 				}
 
+				if maxPartitionErrors > 0 && definitiveErrors >= maxPartitionErrors {
+					fatalError := JobError{
+						ShouldCancelJob: true,
+						Msg:             fmt.Sprintf("Partition error limit reached (%d)", maxPartitionErrors),
+						Prev:            &err,
+					}
+
+					select {
+					case chJobErrorsOut <- fatalError:
+					case <-ctx.Done():
+						return
+					}
+				}
+
 				continue
 			} else {
 				jobError := JobError{
@@ -85,8 +103,8 @@ func ExtractorErrorHandler(
 			if err.HasLastId {
 				newPartition.ParentId = err.Partition.Id
 				newPartition.Id = uuid.New()
-				newPartition.LowerLimit = err.LastId
-				newPartition.IsLowerLimitInclusive = false
+				newPartition.Range.Min = err.LastId
+				newPartition.Range.IsMinInclusive = false
 			}
 
 			requeueWithBackoff(ctx, delay, func() {

internal/app/custom_errors/loader.error.go

@@ -21,11 +21,14 @@ func (e *LoaderError) Error() string {
 func LoaderErrorHandler(
 	ctx context.Context,
 	retryConfig config.RetryConfig,
+	maxChunkErrors int,
 	chErrorsIn <-chan LoaderError,
 	chBatchesOut chan<- models.Batch,
 	chJobErrorsOut chan<- JobError,
 	wgActiveBatches *sync.WaitGroup,
 ) {
+	definitiveErrors := 0
+
 	for {
 		if ctx.Err() != nil {
 			return
@@ -42,6 +45,7 @@ func LoaderErrorHandler(
 
 			if err.Batch.RetryCounter >= retryConfig.Attempts {
 				wgActiveBatches.Done()
+				definitiveErrors++
 				jobError := JobError{
 					ShouldCancelJob: false,
 					Msg:             fmt.Sprintf("Batch %v reached max retries (%d)", err.Batch.Id, retryConfig.Attempts),
@@ -54,6 +58,20 @@ func LoaderErrorHandler(
 					return
 				}
 
+				if maxChunkErrors > 0 && definitiveErrors >= maxChunkErrors {
+					fatalError := JobError{
+						ShouldCancelJob: true,
+						Msg:             fmt.Sprintf("Chunk error limit reached (%d)", maxChunkErrors),
+						Prev:            &err,
+					}
+
+					select {
+					case chJobErrorsOut <- fatalError:
+					case <-ctx.Done():
+						return
+					}
+				}
+
 				continue
 			} else {
 				jobError := JobError{

internal/app/db-wrapper/main.go

@@ -0,0 +1,19 @@
+package dbwrapper
+
+import "fmt"
+
+type Factory func() DbWrapper
+
+var drivers = make(map[string]Factory)
+
+func Register(name string, factory Factory) {
+	drivers[name] = factory
+}
+
+func New(driverType string) (DbWrapper, error) {
+	factory, ok := drivers[driverType]
+	if !ok {
+		return nil, fmt.Errorf("driver not yet supported: %s", driverType)
+	}
+	return factory(), nil
+}

internal/app/db-wrapper/mssql.go

@@ -0,0 +1,176 @@
+package dbwrapper
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	mssql "github.com/microsoft/go-mssqldb"
+)
+
+func init() {
+	Register("sqlserver", func() DbWrapper {
+		return &mssqlDbWrapper{dialect: "sqlserver"}
+	})
+}
+
+type mssqlRowResult struct {
+	row *sql.Row
+}
+
+func (mr *mssqlRowResult) Scan(dest ...any) error {
+	return mr.row.Scan(dest...)
+}
+
+type mssqlRowsResult struct {
+	columns []string
+	rows    *sql.Rows
+}
+
+func (mr *mssqlRowsResult) Close() error {
+	return mr.rows.Close()
+}
+
+func (mr *mssqlRowsResult) Columns() ([]string, error) {
+	if mr.columns != nil {
+		return mr.columns, nil
+	}
+
+	return mr.rows.Columns()
+}
+
+func (mr *mssqlRowsResult) Err() error {
+	return mr.rows.Err()
+}
+
+func (mr *mssqlRowsResult) Next() bool {
+	return mr.rows.Next()
+}
+
+func (mr *mssqlRowsResult) Scan(dest ...any) error {
+	return mr.rows.Scan(dest...)
+}
+
+func (mr *mssqlRowsResult) Values() ([]any, error) {
+	columns, err := mr.Columns()
+	if err != nil {
+		return nil, err
+	}
+
+	rowValues := make([]any, len(columns))
+	scanArgs := make([]any, len(columns))
+	for i := range rowValues {
+		scanArgs[i] = &rowValues[i]
+	}
+
+	if err := mr.rows.Scan(scanArgs...); err != nil {
+		return nil, err
+	}
+
+	return rowValues, nil
+}
+
+type mssqlDbWrapper struct {
+	db      *sql.DB
+	dialect string
+}
+
+func (mw *mssqlDbWrapper) Connect(ctx context.Context, dbUrl string) error {
+	db, err := sql.Open("sqlserver", dbUrl)
+	if err != nil {
+		return err
+	}
+
+	if err := db.PingContext(ctx); err != nil {
+		if err := db.Close(); err != nil {
+			return err
+		}
+		return err
+	}
+
+	mw.db = db
+	return nil
+}
+
+func (mw *mssqlDbWrapper) Close() error {
+	return mw.db.Close()
+}
+
+func (mw *mssqlDbWrapper) Exec(ctx context.Context, query string, args ...any) (ExecResult, error) {
+	result, execErr := mw.db.ExecContext(ctx, query, args...)
+	if execErr != nil {
+		return ExecResult{}, execErr
+	}
+
+	affectedRows, err := result.RowsAffected()
+	if err != nil {
+		return ExecResult{}, err
+	}
+
+	return ExecResult{AffectedRows: affectedRows}, nil
+}
+
+func (mw *mssqlDbWrapper) GetDialect() string {
+	return mw.dialect
+}
+
+func (mw *mssqlDbWrapper) Query(ctx context.Context, query string, args ...any) (RowsResult, error) {
+	rows, err := mw.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &mssqlRowsResult{columns: nil, rows: rows}, nil
+}
+
+func (mw *mssqlDbWrapper) QueryRow(ctx context.Context, query string, args ...any) RowResult {
+	row := mw.db.QueryRowContext(ctx, query, args...)
+	return &mssqlRowResult{row: row}
+}
+
+func (mw *mssqlDbWrapper) SaveMassive(ctx context.Context, schema string, table string, columnNames []string, rows [][]any) (int64, error) {
+	tx, err := mw.db.BeginTx(ctx, nil)
+	if err != nil {
+		return 0, err
+	}
+
+	fullTableName := fmt.Sprintf("[%s].[%s]", schema, table)
+
+	stmt, err := tx.PrepareContext(ctx, mssql.CopyIn(fullTableName, mssql.BulkOptions{}, columnNames...))
+	if err != nil {
+		tx.Rollback()
+		return 0, err
+	}
+
+	for _, row := range rows {
+		_, err = stmt.ExecContext(ctx, row...)
+		if err != nil {
+			stmt.Close()
+			tx.Rollback()
+			return 0, err
+		}
+	}
+
+	result, err := stmt.ExecContext(ctx)
+	if err != nil {
+		stmt.Close()
+		tx.Rollback()
+		return 0, err
+	}
+
+	if err := stmt.Close(); err != nil {
+		tx.Rollback()
+		return 0, err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return 0, err
+	}
+
+	rowsAffected, raErr := result.RowsAffected()
+	if raErr != nil {
+		return 0, nil
+	}
+
+	return rowsAffected, nil
+}

internal/app/db-wrapper/postgres.go

@@ -0,0 +1,128 @@
+package dbwrapper
+
+import (
+	"context"
+	"errors"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func init() {
+	Register("postgres", func() DbWrapper {
+		return &postgresDbWrapper{dialect: "postgres"}
+	})
+}
+
+type postgresRowResult struct {
+	row pgx.Row
+}
+
+func (pr *postgresRowResult) Scan(dest ...any) error {
+	return pr.row.Scan(dest...)
+}
+
+type postgresRowsResult struct {
+	columns []string
+	rows    pgx.Rows
+}
+
+func (pr *postgresRowsResult) Close() error {
+	pr.rows.Close()
+	return nil
+}
+
+func (pr *postgresRowsResult) Columns() ([]string, error) {
+	if pr.columns != nil {
+		return pr.columns, nil
+	}
+
+	rawColumns := pr.rows.FieldDescriptions()
+	if rawColumns == nil {
+		return nil, errors.New("error retrieving columns")
+	}
+
+	columns := make([]string, 0, len(rawColumns))
+	for _, rc := range rawColumns {
+		columns = append(columns, rc.Name)
+	}
+
+	return columns, nil
+}
+
+func (pr *postgresRowsResult) Err() error {
+	return pr.rows.Err()
+}
+
+func (pr *postgresRowsResult) Next() bool {
+	return pr.rows.Next()
+}
+
+func (pr *postgresRowsResult) Scan(dest ...any) error {
+	return pr.rows.Scan(dest...)
+}
+
+func (pr *postgresRowsResult) Values() ([]any, error) {
+	return pr.rows.Values()
+}
+
+type postgresDbWrapper struct {
+	db      *pgxpool.Pool
+	dialect string
+}
+
+func (pw *postgresDbWrapper) Connect(ctx context.Context, dbUrl string) error {
+	pool, err := pgxpool.New(ctx, dbUrl)
+	if err != nil {
+		return err
+	}
+
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return err
+	}
+
+	pw.db = pool
+	return nil
+}
+
+func (pw *postgresDbWrapper) Close() error {
+	pw.db.Close()
+	return nil
+}
+
+func (pw *postgresDbWrapper) Exec(ctx context.Context, query string, args ...any) (ExecResult, error) {
+	result, err := pw.db.Exec(ctx, query, args...)
+	if err != nil {
+		return ExecResult{}, err
+	}
+
+	return ExecResult{AffectedRows: result.RowsAffected()}, nil
+}
+
+func (pw *postgresDbWrapper) GetDialect() string {
+	return pw.dialect
+}
+
+func (pw *postgresDbWrapper) Query(ctx context.Context, query string, args ...any) (RowsResult, error) {
+	rows, err := pw.db.Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &postgresRowsResult{columns: nil, rows: rows}, nil
+}
+
+func (pw *postgresDbWrapper) QueryRow(ctx context.Context, query string, args ...any) RowResult {
+	row := pw.db.QueryRow(ctx, query, args...)
+	return &postgresRowResult{row: row}
+}
+
+func (pw *postgresDbWrapper) SaveMassive(ctx context.Context, schema string, table string, columnNames []string, rows [][]any) (int64, error) {
+	affectedRows, err := pw.db.CopyFrom(ctx, pgx.Identifier{schema, table}, columnNames, pgx.CopyFromRows(rows))
+	if err != nil {
+		return 0, err
+	}
+
+	return affectedRows, nil
+}

internal/app/db-wrapper/types.go

@@ -0,0 +1,35 @@
+package dbwrapper
+
+import (
+	"context"
+	"errors"
+)
+
+var MethodNotSupported error = errors.New("Method not supported by driver... yet :P")
+
+type ExecResult struct {
+	AffectedRows int64
+}
+
+type RowsResult interface {
+	Close() error
+	Columns() ([]string, error)
+	Err() error
+	Next() bool
+	Scan(dest ...any) error
+	Values() ([]any, error)
+}
+
+type RowResult interface {
+	Scan(dest ...any) error
+}
+
+type DbWrapper interface {
+	Close() error
+	Connect(ctx context.Context, dbUrl string) error
+	Exec(ctx context.Context, query string, args ...any) (ExecResult, error)
+	GetDialect() string
+	Query(ctx context.Context, query string, args ...any) (RowsResult, error)
+	QueryRow(ctx context.Context, query string, args ...any) RowResult
+	SaveMassive(ctx context.Context, schema string, table string, columnNames []string, rows [][]any) (int64, error)
+}

internal/app/db/postgres.go

@@ -1,28 +0,0 @@
-package db
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func Connect(ctx context.Context, dbURL string) (*pgxpool.Pool, error) {
-	pool, err := pgxpool.New(ctx, dbURL)
-	if err != nil {
-		return nil, fmt.Errorf("unable to connect to database: %w", err)
-	}
-
-	if err := pool.Ping(ctx); err != nil {
-		pool.Close()
-		return nil, fmt.Errorf("unable to ping database: %w", err)
-	}
-
-	return pool, nil
-}
-
-func Close(pool *pgxpool.Pool) {
-	if pool != nil {
-		pool.Close()
-	}
-}

internal/app/etl/extractors/main.go

@@ -0,0 +1,101 @@
+package extractors
+
+import (
+	"context"
+	"errors"
+	"slices"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
+)
+
+func Consume(
+	ctx context.Context,
+	extractor etl.Extractor,
+	tableInfo config.SourceTableInfo,
+	columns []models.ColumnType,
+	batchSize int,
+	chPartitionsIn <-chan models.Partition,
+	chBatchesOut chan<- models.Batch,
+	chErrorsOut chan<- custom_errors.ExtractorError,
+	chJobErrorsOut chan<- custom_errors.JobError,
+	wgActivePartitions *sync.WaitGroup,
+	rowsRead *int64,
+) {
+	indexPrimaryKey := slices.IndexFunc(columns, func(col models.ColumnType) bool {
+		return strings.EqualFold(col.Name(), tableInfo.PrimaryKey)
+	})
+
+	if indexPrimaryKey == -1 {
+		select {
+		case <-ctx.Done():
+			return
+		case chJobErrorsOut <- custom_errors.JobError{
+			ShouldCancelJob: true,
+			Msg:             "Primary key not found in provided columns",
+		}:
+		}
+
+		return
+	}
+
+	for {
+		if ctx.Err() != nil {
+			return
+		}
+
+		select {
+		case <-ctx.Done():
+			return
+		case partition, ok := <-chPartitionsIn:
+			if !ok {
+				return
+			}
+
+			rowsReadResult, err := extractor.Exec(
+				ctx,
+				tableInfo,
+				columns,
+				batchSize,
+				partition,
+				indexPrimaryKey,
+				chBatchesOut,
+			)
+
+			if rowsReadResult > 0 {
+				atomic.AddInt64(rowsRead, int64(rowsReadResult))
+			}
+
+			if err != nil {
+				if exError, ok := errors.AsType[*custom_errors.ExtractorError](err); ok {
+					select {
+					case <-ctx.Done():
+						return
+					case chErrorsOut <- *exError:
+					}
+				} else if jobError, ok := errors.AsType[*custom_errors.JobError](err); ok {
+					select {
+					case <-ctx.Done():
+						return
+					case chJobErrorsOut <- *jobError:
+					}
+				} else {
+					select {
+					case <-ctx.Done():
+						return
+					case chErrorsOut <- custom_errors.ExtractorError{Partition: partition, Msg: err.Error()}:
+					}
+				}
+
+				continue
+			}
+
+			wgActivePartitions.Done()
+		}
+	}
+}

internal/app/etl/extractors/mssql.go

@@ -5,24 +5,22 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"slices"
 	"strings"
-	"sync"
-	"sync/atomic"
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/convert"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	"github.com/google/uuid"
 )
 
 type MssqlExtractor struct {
-	db *sql.DB
+	db dbwrapper.DbWrapper
 }
 
-func NewMssqlExtractor(db *sql.DB) etl.Extractor {
+func NewMssqlExtractor(db dbwrapper.DbWrapper) etl.Extractor {
 	return &MssqlExtractor{db: db}
 }
 
@@ -31,6 +29,9 @@ func buildExtractQueryMssql(
 	columns []models.ColumnType,
 	includeRange bool,
 	isMinInclusive bool,
+	isMaxInclusive bool,
+	hasMin bool,
+	hasMax bool,
 ) string {
 	var sbQuery strings.Builder
 
@@ -54,15 +55,32 @@ func buildExtractQueryMssql(
 
 	fmt.Fprintf(&sbQuery, " FROM [%s].[%s]", tableInfo.Schema, tableInfo.Table)
 
-	if includeRange {
-		fmt.Fprintf(&sbQuery, " WHERE [%s]", tableInfo.PrimaryKey)
-		if isMinInclusive {
-			sbQuery.WriteString(" >=")
-		} else {
-			sbQuery.WriteString(" >")
+	if includeRange && (hasMin || hasMax) {
+		sbQuery.WriteString(" WHERE ")
+
+		if hasMin {
+			fmt.Fprintf(&sbQuery, "[%s]", tableInfo.PrimaryKey)
+			if isMinInclusive {
+				sbQuery.WriteString(" >=")
+			} else {
+				sbQuery.WriteString(" >")
+			}
+			sbQuery.WriteString(" @min")
 		}
 
-		fmt.Fprintf(&sbQuery, " @min AND [%s] <= @max", tableInfo.PrimaryKey)
+		if hasMin && hasMax {
+			sbQuery.WriteString(" AND ")
+		}
+
+		if hasMax {
+			fmt.Fprintf(&sbQuery, "[%s]", tableInfo.PrimaryKey)
+			if isMaxInclusive {
+				sbQuery.WriteString(" <=")
+			} else {
+				sbQuery.WriteString(" <")
+			}
+			sbQuery.WriteString(" @max")
+		}
 	}
 
 	fmt.Fprintf(&sbQuery, " ORDER BY [%s] ASC", tableInfo.PrimaryKey)
@@ -73,14 +91,14 @@ func buildExtractQueryMssql(
 func errorFromLastRow(
 	lastRow models.UnknownRowValues,
 	indexPrimaryKey int,
-	partition *models.Partition,
+	partition models.Partition,
 	previousError error,
 ) *custom_errors.ExtractorError {
 	lastIdRawValue := lastRow[indexPrimaryKey]
 
 	lastId, ok := convert.ToInt64(lastIdRawValue)
 	if !ok {
-		currentPartition := *partition
+		currentPartition := partition
 		currentPartition.RetryCounter = 3
 		return &custom_errors.ExtractorError{
 			Partition: currentPartition,
@@ -91,14 +109,14 @@ func errorFromLastRow(
 	}
 
 	return &custom_errors.ExtractorError{
-		Partition: *partition,
+		Partition: partition,
 		HasLastId: true,
 		LastId:    lastId,
 		Msg:       previousError.Error(),
 	}
 }
 
-func (mssqlEx *MssqlExtractor) ProcessPartition(
+func (mssqlEx *MssqlExtractor) Exec(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
@@ -106,21 +124,23 @@ func (mssqlEx *MssqlExtractor) ProcessPartition(
 	partition models.Partition,
 	indexPrimaryKey int,
 	chBatchesOut chan<- models.Batch,
-	rowsRead *int64,
-) error {
-	query := buildExtractQueryMssql(tableInfo, columns, partition.ShouldUseRange, partition.IsLowerLimitInclusive)
+) (int, error) {
+	hasMin := partition.HasRange && partition.Range.Min > 0
+	hasMax := partition.HasRange && partition.Range.Max > 0
+	query := buildExtractQueryMssql(tableInfo, columns, partition.HasRange, partition.Range.IsMinInclusive, partition.Range.IsMaxInclusive, hasMin, hasMax)
 
 	var queryArgs []any
-	if partition.ShouldUseRange {
-		queryArgs = append(queryArgs,
-			sql.Named("min", partition.LowerLimit),
-			sql.Named("max", partition.UpperLimit),
-		)
+	if hasMin {
+		queryArgs = append(queryArgs, sql.Named("min", partition.Range.Min))
+	}
+	if hasMax {
+		queryArgs = append(queryArgs, sql.Named("max", partition.Range.Max))
 	}
 
-	rows, err := mssqlEx.db.QueryContext(ctx, query, queryArgs...)
+	rowsRead := 0
+	rows, err := mssqlEx.db.Query(ctx, query, queryArgs...)
 	if err != nil {
-		return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
+		return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 	defer rows.Close()
 
@@ -136,7 +156,7 @@ func (mssqlEx *MssqlExtractor) ProcessPartition(
 
 		if err := rows.Scan(scanArgs...); err != nil {
 			if len(batchRows) == 0 {
-				return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
+				return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 			}
 
 			lastRow := batchRows[len(batchRows)-1]
@@ -144,134 +164,46 @@ func (mssqlEx *MssqlExtractor) ProcessPartition(
 			select {
 			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
-				return nil
+				return rowsRead, ctx.Err()
 			}
 
-			atomic.AddInt64(rowsRead, int64(len(batchRows)))
-
-			return errorFromLastRow(lastRow, indexPrimaryKey, &partition, err)
+			return rowsRead, errorFromLastRow(lastRow, indexPrimaryKey, partition, err)
 		}
+		rowsRead++
 
 		batchRows = append(batchRows, rowValues)
-
 		if len(batchRows) >= batchSize {
 			select {
 			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
-				return nil
+				return rowsRead, ctx.Err()
 			}
 
-			atomic.AddInt64(rowsRead, int64(len(batchRows)))
 			batchRows = make([]models.UnknownRowValues, 0, batchSize)
 		}
+
 	}
 
 	if err := rows.Err(); err != nil {
 		if errors.Is(err, ctx.Err()) {
-			return ctx.Err()
+			return rowsRead, ctx.Err()
 		}
 
-		if len(batchRows) == 0 {
-			return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
+		if len(batchRows) > 0 {
+			lastRow := batchRows[len(batchRows)-1]
+			return rowsRead, errorFromLastRow(lastRow, indexPrimaryKey, partition, err)
 		}
 
-		lastRow := batchRows[len(batchRows)-1]
-		return errorFromLastRow(lastRow, indexPrimaryKey, &partition, err)
+		return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 
 	if len(batchRows) > 0 {
 		select {
 		case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 		case <-ctx.Done():
-			return nil
+			return rowsRead, ctx.Err()
 		}
-
-		atomic.AddInt64(rowsRead, int64(len(batchRows)))
 	}
 
-	return nil
-}
-
-func (mssqlEx *MssqlExtractor) Exec(
-	ctx context.Context,
-	tableInfo config.SourceTableInfo,
-	columns []models.ColumnType,
-	batchSize int,
-	chPartitionsIn <-chan models.Partition,
-	chBatchesOut chan<- models.Batch,
-	chErrorsOut chan<- custom_errors.ExtractorError,
-	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActivePartitions *sync.WaitGroup,
-	rowsRead *int64,
-) {
-	indexPrimaryKey := slices.IndexFunc(columns, func(col models.ColumnType) bool {
-		return strings.EqualFold(col.Name(), tableInfo.PrimaryKey)
-	})
-
-	if indexPrimaryKey == -1 {
-		select {
-		case <-ctx.Done():
-			return
-		case chJobErrorsOut <- custom_errors.JobError{
-			ShouldCancelJob: true,
-			Msg:             "Primary key not found in provided columns",
-		}:
-		}
-
-		return
-	}
-
-	for {
-		if ctx.Err() != nil {
-			return
-		}
-
-		select {
-		case <-ctx.Done():
-			return
-		case partition, ok := <-chPartitionsIn:
-			if !ok {
-				return
-			}
-
-			err := mssqlEx.ProcessPartition(
-				ctx,
-				tableInfo,
-				columns,
-				batchSize,
-				partition,
-				indexPrimaryKey,
-				chBatchesOut,
-				rowsRead,
-			)
-
-			if err != nil {
-				var exError *custom_errors.ExtractorError
-				var jobError *custom_errors.JobError
-				if errors.As(err, &exError) {
-					select {
-					case <-ctx.Done():
-						return
-					case chErrorsOut <- *exError:
-					}
-				} else if errors.As(err, &jobError) {
-					select {
-					case <-ctx.Done():
-						return
-					case chJobErrorsOut <- *jobError:
-					}
-				} else {
-					select {
-					case <-ctx.Done():
-						return
-					case chErrorsOut <- custom_errors.ExtractorError{Partition: partition, Msg: err.Error()}:
-					}
-				}
-
-				continue
-			}
-
-			wgActivePartitions.Done()
-		}
-	}
+	return rowsRead, nil
 }

internal/app/etl/extractors/postgres.go

@@ -2,29 +2,34 @@ package extractors
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strings"
-	"sync"
-	"sync/atomic"
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 type PostgresExtractor struct {
-	db *pgxpool.Pool
+	db dbwrapper.DbWrapper
 }
 
-func NewPostgresExtractor(pool *pgxpool.Pool) etl.Extractor {
-	return &PostgresExtractor{db: pool}
+func NewPostgresExtractor(db dbwrapper.DbWrapper) etl.Extractor {
+	return &PostgresExtractor{db: db}
 }
 
-func buildExtractQueryPostgres(sourceDbInfo config.SourceTableInfo, columns []models.ColumnType) string {
+func buildExtractQueryPostgres(
+	sourceDbInfo config.SourceTableInfo,
+	columns []models.ColumnType,
+	includeRange bool,
+	isMinInclusive bool,
+	isMaxInclusive bool,
+	hasMin bool,
+	hasMax bool,
+) string {
 	var sbColumns strings.Builder
 
 	if len(columns) == 0 {
@@ -49,10 +54,44 @@ func buildExtractQueryPostgres(sourceDbInfo config.SourceTableInfo, columns []mo
 		}
 	}
 
-	return fmt.Sprintf(`SELECT %s FROM "%s"."%s"  ORDER BY "%s" ASC`, sbColumns.String(), sourceDbInfo.Schema, sourceDbInfo.Table, sourceDbInfo.PrimaryKey)
+	query := fmt.Sprintf(`SELECT %s FROM "%s"."%s"`, sbColumns.String(), sourceDbInfo.Schema, sourceDbInfo.Table)
+
+	if includeRange && (hasMin || hasMax) {
+		query += " WHERE "
+		paramIdx := 1
+
+		if hasMin {
+			query += fmt.Sprintf(`"%s"`, sourceDbInfo.PrimaryKey)
+			if isMinInclusive {
+				query += " >="
+			} else {
+				query += " >"
+			}
+			query += fmt.Sprintf(" $%d", paramIdx)
+			paramIdx++
+		}
+
+		if hasMin && hasMax {
+			query += " AND "
+		}
+
+		if hasMax {
+			query += fmt.Sprintf(`"%s"`, sourceDbInfo.PrimaryKey)
+			if isMaxInclusive {
+				query += " <="
+			} else {
+				query += " <"
+			}
+			query += fmt.Sprintf(" $%d", paramIdx)
+		}
+	}
+
+	query += fmt.Sprintf(` ORDER BY "%s" ASC`, sourceDbInfo.PrimaryKey)
+
+	return query
 }
 
-func (postgresEx *PostgresExtractor) ProcessPartition(
+func (postgresEx *PostgresExtractor) Exec(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
@@ -60,17 +99,23 @@ func (postgresEx *PostgresExtractor) ProcessPartition(
 	partition models.Partition,
 	indexPrimaryKey int,
 	chBatchesOut chan<- models.Batch,
-	rowsRead *int64,
-) error {
-	query := buildExtractQueryPostgres(tableInfo, columns)
+) (int, error) {
+	hasMin := partition.HasRange && partition.Range.Min > 0
+	hasMax := partition.HasRange && partition.Range.Max > 0
+	query := buildExtractQueryPostgres(tableInfo, columns, partition.HasRange, partition.Range.IsMinInclusive, partition.Range.IsMaxInclusive, hasMin, hasMax)
 
-	if partition.ShouldUseRange {
-		return errors.New("Batch config not yet supported")
+	var queryArgs []any
+	if hasMin {
+		queryArgs = append(queryArgs, partition.Range.Min)
+	}
+	if hasMax {
+		queryArgs = append(queryArgs, partition.Range.Max)
 	}
 
-	rows, err := postgresEx.db.Query(ctx, query)
+	rowsRead := 0
+	rows, err := postgresEx.db.Query(ctx, query, queryArgs...)
 	if err != nil {
-		return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
+		return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 	defer rows.Close()
 
@@ -79,8 +124,9 @@ func (postgresEx *PostgresExtractor) ProcessPartition(
 	for rows.Next() {
 		values, err := rows.Values()
 		if err != nil {
-			return errors.New("Unexpected error reading rows from source")
+			return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 		}
+		rowsRead++
 
 		batchRows = append(batchRows, values)
 
@@ -88,41 +134,24 @@ func (postgresEx *PostgresExtractor) ProcessPartition(
 			select {
 			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
-				return nil
+				return rowsRead, ctx.Err()
 			}
 
-			atomic.AddInt64(rowsRead, int64(len(batchRows)))
 			batchRows = make([]models.UnknownRowValues, 0, batchSize)
 		}
 	}
 
 	if err := rows.Err(); err != nil {
-		return errors.New("Unexpected error reading rows from source")
+		return rowsRead, &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 
 	if len(batchRows) > 0 {
 		select {
 		case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 		case <-ctx.Done():
-			return nil
+			return rowsRead, nil
 		}
-
-		atomic.AddInt64(rowsRead, int64(len(batchRows)))
 	}
 
-	return nil
-}
-
-func (postgresEx *PostgresExtractor) Exec(
-	ctx context.Context,
-	tableInfo config.SourceTableInfo,
-	columns []models.ColumnType,
-	batchSize int,
-	chPartitionsIn <-chan models.Partition,
-	chBatchesOut chan<- models.Batch,
-	chErrorsOut chan<- custom_errors.ExtractorError,
-	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActivePartitions *sync.WaitGroup,
-	rowsRead *int64,
-) {
+	return rowsRead, nil
 }

internal/app/etl/extractors/types.go

@@ -1 +0,0 @@
-package extractors

internal/app/etl/loaders/main.go

@@ -9,43 +9,32 @@ import (
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
-	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgconn"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-type PostgresLoader struct {
-	db *pgxpool.Pool
+type GenericLoader struct {
+	db dbwrapper.DbWrapper
 }
 
-func NewPostgresLoader(pool *pgxpool.Pool) etl.Loader {
-	return &PostgresLoader{db: pool}
+func NewGenericLoader(db dbwrapper.DbWrapper) etl.Loader {
+	return &GenericLoader{db: db}
 }
 
-func mapSlice[T any, V any](input []T, mapper func(T) V) []V {
-	result := make([]V, len(input))
-
-	for i, v := range input {
-		result[i] = mapper(v)
-	}
-
-	return result
-}
-
-func (postgresLd *PostgresLoader) ProcessBatch(
+func (gl *GenericLoader) ProcessBatch(
 	ctx context.Context,
 	tableInfo config.TargetTableInfo,
 	colNames []string,
 	batch models.Batch,
 ) (int, error) {
-	tableId := pgx.Identifier{tableInfo.Schema, tableInfo.Table}
-	_, err := postgresLd.db.CopyFrom(
+	_, err := gl.db.SaveMassive(
 		ctx,
-		tableId,
+		tableInfo.Schema,
+		tableInfo.Table,
 		colNames,
-		pgx.CopyFromRows(batch.Rows),
+		batch.Rows,
 	)
 
 	if err != nil {
@@ -54,7 +43,7 @@ func (postgresLd *PostgresLoader) ProcessBatch(
 			if pgErr.Code == "23505" {
 				return 0, &custom_errors.JobError{
 					ShouldCancelJob: true,
-					Msg:             fmt.Sprintf("Fatal error in table %s", tableId.Sanitize()),
+					Msg:             fmt.Sprintf("Fatal error in table %s.%s", tableInfo.Schema, tableInfo.Table),
 					Prev:            err,
 				}
 			}
@@ -66,7 +55,7 @@ func (postgresLd *PostgresLoader) ProcessBatch(
 	return len(batch.Rows), nil
 }
 
-func (postgresLd *PostgresLoader) Exec(
+func (gl *GenericLoader) Exec(
 	ctx context.Context,
 	tableInfo config.TargetTableInfo,
 	columns []models.ColumnType,
@@ -93,7 +82,7 @@ func (postgresLd *PostgresLoader) Exec(
 				return
 			}
 
-			processedRows, err := postgresLd.ProcessBatch(ctx, tableInfo, colNames, batch)
+			processedRows, err := gl.ProcessBatch(ctx, tableInfo, colNames, batch)
 
 			if err != nil {
 				var ldError *custom_errors.LoaderError

internal/app/etl/loaders/types.go

@@ -1 +0,0 @@
-package loaders

internal/app/etl/loaders/utils.go

@@ -0,0 +1,11 @@
+package loaders
+
+func mapSlice[T any, V any](input []T, mapper func(T) V) []V {
+	result := make([]V, len(input))
+
+	for i, v := range input {
+		result[i] = mapper(v)
+	}
+
+	return result
+}

internal/app/etl/table_analyzers/main.go

@@ -15,7 +15,22 @@ func PartitionRangeGenerator(
 	tableInfo config.TableInfo,
 	partitionColumn string,
 	rowsPerPartition int64,
+	jobRange config.RangeConfig,
 ) ([]models.Partition, error) {
+	if jobRange.Min > 0 {
+		return []models.Partition{{
+			Id:           uuid.New(),
+			HasRange:     true,
+			RetryCounter: 0,
+			Range: models.PartitionRange{
+				Min:            jobRange.Min,
+				Max:            jobRange.Max,
+				IsMinInclusive: jobRange.IsMinInclusive,
+				IsMaxInclusive: jobRange.IsMaxInclusive,
+			},
+		}}, nil
+	}
+
 	rowsCount, err := tableAnalyzer.EstimateTotalRows(ctx, tableInfo)
 	if err != nil {
 		return nil, err
@@ -23,9 +38,9 @@ func PartitionRangeGenerator(
 
 	if rowsCount <= rowsPerPartition {
 		return []models.Partition{{
-			Id:             uuid.New(),
-			ShouldUseRange: false,
-			RetryCounter:   0,
+			Id:           uuid.New(),
+			HasRange:     false,
+			RetryCounter: 0,
 		}}, nil
 
 	}

internal/app/etl/table_analyzers/mssql.go

@@ -8,16 +8,17 @@ import (
 	"time"
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	"github.com/google/uuid"
 )
 
 type MssqlTableAnalyzer struct {
-	db *sql.DB
+	db dbwrapper.DbWrapper
 }
 
-func NewMssqlTableAnalyzer(db *sql.DB) etl.TableAnalyzer {
+func NewMssqlTableAnalyzer(db dbwrapper.DbWrapper) etl.TableAnalyzer {
 	return &MssqlTableAnalyzer{db: db}
 }
 
@@ -35,7 +36,7 @@ JOIN sys.types t ON c.user_type_id = t.user_type_id
 LEFT JOIN sys.types bt ON t.is_user_defined = 1 AND bt.user_type_id = t.system_type_id
 JOIN sys.tables st ON c.object_id = st.object_id
 JOIN sys.schemas s ON st.schema_id = s.schema_id
-WHERE s.name = @schema AND st.name = @table AND c.name NOT LIKE 'graph_id%'
+WHERE s.name = @schema AND st.name = @table AND (c.is_hidden = 0 OR (c.graph_type IS NOT NULL AND c.name LIKE '$%'))
 ORDER BY c.column_id;`
 
 type rawColumnMssql struct {
@@ -142,7 +143,7 @@ func (ta *MssqlTableAnalyzer) QueryColumnTypes(
 	localCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
 	defer cancel()
 
-	rows, err := ta.db.QueryContext(localCtx, mssqlColumnMetadataQuery, sql.Named("schema", tableInfo.Schema), sql.Named("table", tableInfo.Table))
+	rows, err := ta.db.Query(localCtx, mssqlColumnMetadataQuery, sql.Named("schema", tableInfo.Schema), sql.Named("table", tableInfo.Table))
 	if err != nil {
 		return nil, err
 	}
@@ -183,11 +184,11 @@ JOIN sys.partitions p ON t.object_id = p.object_id
 WHERE s.name = @schema AND t.name = @table AND p.index_id IN (0, 1)
 GROUP BY t.name`
 
-	ctxTimeout, cancel := context.WithTimeout(ctx, time.Second*20)
+	ctxTimeout, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 
 	var rowsCount int64
-	err := ta.db.QueryRowContext(ctxTimeout, query, sql.Named("schema", tableInfo.Schema), sql.Named("table", tableInfo.Table)).Scan(&rowsCount)
+	err := ta.db.QueryRow(ctxTimeout, query, sql.Named("schema", tableInfo.Schema), sql.Named("table", tableInfo.Table)).Scan(&rowsCount)
 	if err != nil {
 		return 0, err
 	}
@@ -215,10 +216,10 @@ ORDER BY batch_id`,
 		tableInfo.Schema,
 		tableInfo.Table)
 
-	ctxTimeout, cancel := context.WithTimeout(ctx, time.Second*20)
+	ctxTimeout, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 
-	rows, err := ta.db.QueryContext(ctxTimeout, query, sql.Named("maxPartitions", maxPartitions))
+	rows, err := ta.db.Query(ctxTimeout, query, sql.Named("maxPartitions", maxPartitions))
 	if err != nil {
 		return nil, err
 	}
@@ -228,13 +229,15 @@ ORDER BY batch_id`,
 
 	for rows.Next() {
 		partition := models.Partition{
-			Id:                    uuid.New(),
-			ShouldUseRange:        true,
-			RetryCounter:          0,
-			IsLowerLimitInclusive: true,
+			Id:           uuid.New(),
+			HasRange:     true,
+			RetryCounter: 0,
+			Range: models.PartitionRange{
+				IsMinInclusive: true,
+			},
 		}
 
-		if err := rows.Scan(&partition.LowerLimit, &partition.UpperLimit); err != nil {
+		if err := rows.Scan(&partition.Range.Min, &partition.Range.Max); err != nil {
 			return nil, err
 		}
 

internal/app/etl/table_analyzers/postgres.go

@@ -6,16 +6,16 @@ import (
 	"time"
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	dbwrapper "git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db-wrapper"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 type PostgresTableAnalyzer struct {
-	db *pgxpool.Pool
+	db dbwrapper.DbWrapper
 }
 
-func NewPostgresTableAnalyzer(db *pgxpool.Pool) etl.TableAnalyzer {
+func NewPostgresTableAnalyzer(db dbwrapper.DbWrapper) etl.TableAnalyzer {
 	return &PostgresTableAnalyzer{db: db}
 }
 
@@ -125,7 +125,7 @@ func (ta *PostgresTableAnalyzer) QueryColumnTypes(
 	ctx context.Context,
 	tableInfo config.TableInfo,
 ) ([]models.ColumnType, error) {
-	localCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
+	localCtx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 
 	rows, err := ta.db.Query(localCtx, postgresColumnMetadataQuery, tableInfo.Schema, tableInfo.Table)

internal/app/etl/transformers/mssql.go

@@ -3,18 +3,32 @@ package transformers
 import (
 	"context"
 	"errors"
+	"fmt"
+	"strings"
 	"sync"
 	"time"
 
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/azure"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/custom_errors"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
+	"github.com/google/uuid"
+	log "github.com/sirupsen/logrus"
 )
 
-type MssqlTransformer struct{}
+type MssqlTransformer struct {
+	toStorage   config.ToStorageConfig
+	sourceTable config.SourceTableInfo
+	azureClient *azure.Client
+}
 
-func NewMssqlTransformer() etl.Transformer {
-	return &MssqlTransformer{}
+func NewMssqlTransformer(toStorage config.ToStorageConfig, sourceTable config.SourceTableInfo, azureClient *azure.Client) etl.Transformer {
+	return &MssqlTransformer{
+		toStorage:   toStorage,
+		sourceTable: sourceTable,
+		azureClient: azureClient,
+	}
 }
 
 func computeTransformationPlan(columns []models.ColumnType) []etl.ColumnTransformPlan {
@@ -60,6 +74,65 @@ func computeTransformationPlan(columns []models.ColumnType) []etl.ColumnTransfor
 	return plan
 }
 
+func computeStorageTransformationPlan(
+	ctx context.Context,
+	azureClient *azure.Client,
+	toStorage config.ToStorageConfig,
+	sourceColumns []models.ColumnType,
+	sourceTable config.SourceTableInfo,
+) []etl.ColumnTransformPlan {
+	if azureClient == nil || len(toStorage.Columns) == 0 {
+		return nil
+	}
+
+	colIndex := make(map[string]int, len(sourceColumns))
+	for i, col := range sourceColumns {
+		colIndex[strings.ToUpper(col.Name())] = i
+	}
+
+	var plan []etl.ColumnTransformPlan
+	for _, storageCol := range toStorage.Columns {
+		if storageCol.Mode != "REFERENCE_ONLY" {
+			log.Warnf("to_storage: unsupported mode %q for column %s — skipping", storageCol.Mode, storageCol.Source)
+			continue
+		}
+
+		idx, ok := colIndex[strings.ToUpper(storageCol.Source)]
+		if !ok {
+			log.Warnf("to_storage: source column %q not found in source schema — skipping", storageCol.Source)
+			continue
+		}
+
+		sourceColName := storageCol.Source
+		schema := sourceTable.Schema
+		table := sourceTable.Table
+
+		plan = append(plan, etl.ColumnTransformPlan{
+			Index: idx,
+			Fn: func(v any) (any, error) {
+				if v == nil {
+					return nil, nil
+				}
+				b, ok := v.([]byte)
+				if !ok {
+					log.Warnf("to_storage: expected []byte for %s.%s.%s, got %T — passing through",
+						schema, table, sourceColName, v)
+					return v, nil
+				}
+				start := time.Now()
+				blobPath := fmt.Sprintf("%s/%s/%s", schema, table, uuid.New().String())
+				blobURL, err := azureClient.UploadAndGetURL(ctx, blobPath, b)
+				if err != nil {
+					return nil, fmt.Errorf("uploading %s.%s.%s: %w", schema, table, sourceColName, err)
+				}
+				log.Debugf(`Succesfully uploaded "%s", (%vms)`, blobURL, time.Since(start).Milliseconds())
+				return blobURL, nil
+			},
+		})
+	}
+	return plan
+}
+
 const processBatchCtxCheck = 4096
 
 func (mssqlTr *MssqlTransformer) ProcessBatch(
@@ -100,6 +173,8 @@ func (mssqlTr *MssqlTransformer) Exec(
 	wgActiveBatches *sync.WaitGroup,
 ) {
 	transformationPlan := computeTransformationPlan(columns)
+	storagePlan := computeStorageTransformationPlan(ctx, mssqlTr.azureClient, mssqlTr.toStorage, columns, mssqlTr.sourceTable)
+	transformationPlan = append(transformationPlan, storagePlan...)
 
 	for {
 		if ctx.Err() != nil {

internal/app/etl/types.go

@@ -10,7 +10,7 @@ import (
 )
 
 type Extractor interface {
-	ProcessPartition(
+	Exec(
 		ctx context.Context,
 		tableInfo config.SourceTableInfo,
 		columns []models.ColumnType,
@@ -18,21 +18,7 @@ type Extractor interface {
 		partition models.Partition,
 		indexPrimaryKey int,
 		chBatchesOut chan<- models.Batch,
-		rowsRead *int64,
-	) error
-
-	Exec(
-		ctx context.Context,
-		tableInfo config.SourceTableInfo,
-		columns []models.ColumnType,
-		batchSize int,
-		chPartitionsIn <-chan models.Partition,
-		chBatchesOut chan<- models.Batch,
-		chErrorsOut chan<- custom_errors.ExtractorError,
-		chJobErrorsOut chan<- custom_errors.JobError,
-		wgActivePartitions *sync.WaitGroup,
-		rowsRead *int64,
-	)
+	) (int, error)
 }
 
 type TransformerFunc func(any) (any, error)

internal/app/models/main.go

@@ -1,6 +1,10 @@
 package models
 
-import "github.com/google/uuid"
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
 
 type UnknownRowValues = []any
 
@@ -11,12 +15,27 @@ type Batch struct {
 	RetryCounter int
 }
 
-type Partition struct {
-	Id                    uuid.UUID
-	ParentId              uuid.UUID
-	LowerLimit            int64
-	UpperLimit            int64
-	IsLowerLimitInclusive bool
-	ShouldUseRange        bool
-	RetryCounter          int
+type PartitionRange struct {
+	Min            int64
+	Max            int64
+	IsMinInclusive bool
+	IsMaxInclusive bool
+}
+
+type Partition struct {
+	Id           uuid.UUID
+	ParentId     uuid.UUID
+	Range        PartitionRange
+	HasRange     bool
+	RetryCounter int
+}
+
+type JobResult struct {
+	JobName    string
+	StartTime  time.Time
+	Duration   time.Duration
+	RowsRead   int64
+	RowsLoaded int64
+	RowsFailed int64
+	Error      error
 }

scripts/az-blob/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"math/rand"
+	"sync"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/azure"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+)
+
+func main() {
+	cfg := config.App.AzureStorage
+	containerName := cfg.Container
+
+	client, err := azure.NewClient(cfg)
+	if err != nil {
+		log.Fatalf("Error creando cliente: %v", err)
+	}
+	ctx := context.Background()
+
+	var wg sync.WaitGroup
+
+	for i := 1; i <= 10; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+
+			blobName := fmt.Sprintf("%sarchivo-%d.txt", cfg.Prefix, id)
+			content := fmt.Sprintf("Contenido aleatorio: %d", rand.Intn(100000))
+
+			err := client.UploadBuffer(ctx, containerName, blobName, []byte(content))
+			if err != nil {
+				log.Printf("Fallo al subir %s: %v", blobName, err)
+			} else {
+				fmt.Printf("Subido exitosamente: %s\n", blobName)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}

scripts/pg-info-test/main.go

@@ -8,13 +8,32 @@ import (
 	"time"
 
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
-	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/db"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/jackc/pgx/v5/pgxpool"
 	log "github.com/sirupsen/logrus"
 )
 
+func Connect(ctx context.Context, dbURL string) (*pgxpool.Pool, error) {
+	pool, err := pgxpool.New(ctx, dbURL)
+	if err != nil {
+		return nil, fmt.Errorf("unable to connect to database: %w", err)
+	}
+
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, fmt.Errorf("unable to ping database: %w", err)
+	}
+
+	return pool, nil
+}
+
+func Close(pool *pgxpool.Pool) {
+	if pool != nil {
+		pool.Close()
+	}
+}
+
 func main() {
 	log.SetFormatter(&log.TextFormatter{
 		FullTimestamp:   true,
@@ -27,8 +46,8 @@ func main() {
 	ctxSource, cancel := context.WithTimeout(context.Background(), 20*time.Second)
 	defer cancel()
 
-	sourcePool, err := db.Connect(ctxSource, config.App.SourceDbUrl)
-	defer db.Close(sourcePool)
+	sourcePool, err := Connect(ctxSource, config.App.SourceDbUrl)
+	defer Close(sourcePool)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -37,8 +56,8 @@ func main() {
 	ctxTarget, cancel := context.WithTimeout(context.Background(), 20*time.Second)
 	defer cancel()
 
-	targetPool, err := db.Connect(ctxTarget, config.App.TargetDbUrl)
-	defer db.Close(targetPool)
+	targetPool, err := Connect(ctxTarget, config.App.TargetDbUrl)
+	defer Close(targetPool)
 	if err != nil {
 		log.Fatal(err)
 	}