feat: add exponential backoff retry strategy

Introduce a retry policy with exponential backoff and jitter for extractor and loader errors, with configurable max attempts and delay caps.
2026-04-13 14:00:00 -05:00
parent 7f3d2b8cc4
commit 74abf12dcf
21 changed files with 847 additions and 684 deletions
--- a/internal/app/etl/extractors/mssql.go
+++ b/internal/app/etl/extractors/mssql.go
@@ -70,20 +70,20 @@ func buildExtractQueryMssql(
 	return sbQuery.String()
 }

-func extractorErrorFromLastRowMssql(
+func errorFromLastRow(
 	lastRow models.UnknownRowValues,
 	indexPrimaryKey int,
-	batch *models.Partition,
+	partition *models.Partition,
 	previousError error,
 ) *custom_errors.ExtractorError {
 	lastIdRawValue := lastRow[indexPrimaryKey]

 	lastId, ok := convert.ToInt64(lastIdRawValue)
 	if !ok {
-		currentBatch := *batch
-		currentBatch.RetryCounter = 3
+		currentPartition := *partition
+		currentPartition.RetryCounter = 3
 		return &custom_errors.ExtractorError{
-			Batch:     currentBatch,
+			Partition: currentPartition,
 			HasLastId: true,
 			Msg:       fmt.Sprintf("Couldn't cast last id value as int: %s", previousError.Error()),
 		}
@@ -91,78 +91,78 @@ func extractorErrorFromLastRowMssql(
 	}

 	return &custom_errors.ExtractorError{
-		Batch:     *batch,
+		Partition: *partition,
 		HasLastId: true,
 		LastId:    lastId,
 		Msg:       previousError.Error(),
 	}
 }

-func (mssqlEx *MssqlExtractor) ProcessBatch(
+func (mssqlEx *MssqlExtractor) ProcessPartition(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
-	chunkSize int,
-	batch models.Partition,
+	batchSize int,
+	partition models.Partition,
 	indexPrimaryKey int,
-	chChunksOut chan<- models.Batch,
+	chBatchesOut chan<- models.Batch,
 	rowsRead *int64,
 ) error {
-	query := buildExtractQueryMssql(tableInfo, columns, batch.ShouldUseRange, batch.IsLowerLimitInclusive)
+	query := buildExtractQueryMssql(tableInfo, columns, partition.ShouldUseRange, partition.IsLowerLimitInclusive)

 	var queryArgs []any
-	if batch.ShouldUseRange {
+	if partition.ShouldUseRange {
 		queryArgs = append(queryArgs,
-			sql.Named("min", batch.LowerLimit),
-			sql.Named("max", batch.UpperLimit),
+			sql.Named("min", partition.LowerLimit),
+			sql.Named("max", partition.UpperLimit),
 		)
 	}

 	rows, err := mssqlEx.db.QueryContext(ctx, query, queryArgs...)
 	if err != nil {
-		return &custom_errors.ExtractorError{Batch: batch, HasLastId: false, Msg: err.Error()}
+		return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 	defer rows.Close()

-	rowsChunk := make([]models.UnknownRowValues, 0, chunkSize)
+	batchRows := make([]models.UnknownRowValues, 0, batchSize)

 	for rows.Next() {
-		values := make([]any, len(columns))
+		rowValues := make([]any, len(columns))
 		scanArgs := make([]any, len(columns))

-		for i := range values {
-			scanArgs[i] = &values[i]
+		for i := range rowValues {
+			scanArgs[i] = &rowValues[i]
 		}

 		if err := rows.Scan(scanArgs...); err != nil {
-			if len(rowsChunk) == 0 {
-				return &custom_errors.ExtractorError{Batch: batch, HasLastId: false, Msg: err.Error()}
+			if len(batchRows) == 0 {
+				return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 			}

-			lastRow := rowsChunk[len(rowsChunk)-1]
+			lastRow := batchRows[len(batchRows)-1]

 			select {
-			case chChunksOut <- models.Batch{Id: uuid.New(), PartitionId: batch.Id, Data: rowsChunk, RetryCounter: 0}:
+			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
 				return nil
 			}

-			atomic.AddInt64(rowsRead, int64(len(rowsChunk)))
+			atomic.AddInt64(rowsRead, int64(len(batchRows)))

-			return extractorErrorFromLastRowMssql(lastRow, indexPrimaryKey, &batch, err)
+			return errorFromLastRow(lastRow, indexPrimaryKey, &partition, err)
 		}

-		rowsChunk = append(rowsChunk, values)
+		batchRows = append(batchRows, rowValues)

-		if len(rowsChunk) >= chunkSize {
+		if len(batchRows) >= batchSize {
 			select {
-			case chChunksOut <- models.Batch{Id: uuid.New(), PartitionId: batch.Id, Data: rowsChunk, RetryCounter: 0}:
+			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
 				return nil
 			}

-			atomic.AddInt64(rowsRead, int64(len(rowsChunk)))
-			rowsChunk = make([]models.UnknownRowValues, 0, chunkSize)
+			atomic.AddInt64(rowsRead, int64(len(batchRows)))
+			batchRows = make([]models.UnknownRowValues, 0, batchSize)
 		}
 	}

@@ -171,22 +171,22 @@ func (mssqlEx *MssqlExtractor) ProcessBatch(
 			return ctx.Err()
 		}

-		if len(rowsChunk) == 0 {
-			return &custom_errors.ExtractorError{Batch: batch, HasLastId: false, Msg: err.Error()}
+		if len(batchRows) == 0 {
+			return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 		}

-		lastRow := rowsChunk[len(rowsChunk)-1]
-		return extractorErrorFromLastRowMssql(lastRow, indexPrimaryKey, &batch, err)
+		lastRow := batchRows[len(batchRows)-1]
+		return errorFromLastRow(lastRow, indexPrimaryKey, &partition, err)
 	}

-	if len(rowsChunk) > 0 {
+	if len(batchRows) > 0 {
 		select {
-		case chChunksOut <- models.Batch{Id: uuid.New(), PartitionId: batch.Id, Data: rowsChunk, RetryCounter: 0}:
+		case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 		case <-ctx.Done():
 			return nil
 		}

-		atomic.AddInt64(rowsRead, int64(len(rowsChunk)))
+		atomic.AddInt64(rowsRead, int64(len(batchRows)))
 	}

 	return nil
@@ -196,12 +196,12 @@ func (mssqlEx *MssqlExtractor) Exec(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
-	chunkSize int,
-	chBatchesIn <-chan models.Partition,
-	chChunksOut chan<- models.Batch,
+	batchSize int,
+	chPartitionsIn <-chan models.Partition,
+	chBatchesOut chan<- models.Batch,
 	chErrorsOut chan<- custom_errors.ExtractorError,
 	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActiveBatches *sync.WaitGroup,
+	wgActivePartitions *sync.WaitGroup,
 	rowsRead *int64,
 ) {
 	indexPrimaryKey := slices.IndexFunc(columns, func(col models.ColumnType) bool {
@@ -229,45 +229,49 @@ func (mssqlEx *MssqlExtractor) Exec(
 		select {
 		case <-ctx.Done():
 			return
-		case batch, ok := <-chBatchesIn:
+		case partition, ok := <-chPartitionsIn:
 			if !ok {
 				return
 			}

-			err := mssqlEx.ProcessBatch(
+			err := mssqlEx.ProcessPartition(
 				ctx,
 				tableInfo,
 				columns,
-				chunkSize,
-				batch,
+				batchSize,
+				partition,
 				indexPrimaryKey,
-				chChunksOut,
+				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:
 					}
-				}
-
-				var jobError *custom_errors.JobError
-				if errors.As(err, &jobError) {
+				} 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()}:
+					}
 				}

-				return
+				continue
 			}

-			wgActiveBatches.Done()
+			wgActivePartitions.Done()
 		}
 	}
 }
--- a/internal/app/etl/extractors/postgres.go
+++ b/internal/app/etl/extractors/postgres.go
@@ -52,29 +52,29 @@ 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)
 }

-func (postgresEx *PostgresExtractor) ProcessBatch(
+func (postgresEx *PostgresExtractor) ProcessPartition(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
-	chunkSize int,
-	batch models.Partition,
+	batchSize int,
+	partition models.Partition,
 	indexPrimaryKey int,
-	chChunksOut chan<- models.Batch,
+	chBatchesOut chan<- models.Batch,
 	rowsRead *int64,
 ) error {
 	query := buildExtractQueryPostgres(tableInfo, columns)

-	if batch.ShouldUseRange {
+	if partition.ShouldUseRange {
 		return errors.New("Batch config not yet supported")
 	}

 	rows, err := postgresEx.db.Query(ctx, query)
 	if err != nil {
-		return &custom_errors.ExtractorError{Batch: batch, HasLastId: false, Msg: err.Error()}
+		return &custom_errors.ExtractorError{Partition: partition, HasLastId: false, Msg: err.Error()}
 	}
 	defer rows.Close()

-	rowsChunk := make([]models.UnknownRowValues, 0, chunkSize)
+	batchRows := make([]models.UnknownRowValues, 0, batchSize)

 	for rows.Next() {
 		values, err := rows.Values()
@@ -82,17 +82,17 @@ func (postgresEx *PostgresExtractor) ProcessBatch(
 			return errors.New("Unexpected error reading rows from source")
 		}

-		rowsChunk = append(rowsChunk, values)
+		batchRows = append(batchRows, values)

-		if len(rowsChunk) >= chunkSize {
+		if len(batchRows) >= batchSize {
 			select {
-			case chChunksOut <- models.Batch{Id: uuid.New(), PartitionId: batch.Id, Data: rowsChunk, RetryCounter: 0}:
+			case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 			case <-ctx.Done():
 				return nil
 			}

-			atomic.AddInt64(rowsRead, int64(len(rowsChunk)))
-			rowsChunk = make([]models.UnknownRowValues, 0, chunkSize)
+			atomic.AddInt64(rowsRead, int64(len(batchRows)))
+			batchRows = make([]models.UnknownRowValues, 0, batchSize)
 		}
 	}

@@ -100,14 +100,14 @@ func (postgresEx *PostgresExtractor) ProcessBatch(
 		return errors.New("Unexpected error reading rows from source")
 	}

-	if len(rowsChunk) > 0 {
+	if len(batchRows) > 0 {
 		select {
-		case chChunksOut <- models.Batch{Id: uuid.New(), PartitionId: batch.Id, Data: rowsChunk, RetryCounter: 0}:
+		case chBatchesOut <- models.Batch{Id: uuid.New(), PartitionId: partition.Id, Rows: batchRows, RetryCounter: 0}:
 		case <-ctx.Done():
 			return nil
 		}

-		atomic.AddInt64(rowsRead, int64(len(rowsChunk)))
+		atomic.AddInt64(rowsRead, int64(len(batchRows)))
 	}

 	return nil
@@ -117,12 +117,12 @@ func (postgresEx *PostgresExtractor) Exec(
 	ctx context.Context,
 	tableInfo config.SourceTableInfo,
 	columns []models.ColumnType,
-	chunkSize int,
-	chBatchesIn <-chan models.Partition,
-	chChunksOut chan<- models.Batch,
+	batchSize int,
+	chPartitionsIn <-chan models.Partition,
+	chBatchesOut chan<- models.Batch,
 	chErrorsOut chan<- custom_errors.ExtractorError,
 	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActiveBatches *sync.WaitGroup,
+	wgActivePartitions *sync.WaitGroup,
 	rowsRead *int64,
 ) {
 }
--- a/internal/app/etl/loaders/postgres.go
+++ b/internal/app/etl/loaders/postgres.go
@@ -34,18 +34,18 @@ func mapSlice[T any, V any](input []T, mapper func(T) V) []V {
 	return result
 }

-func (postgresLd *PostgresLoader) ProcessChunk(
+func (postgresLd *PostgresLoader) ProcessBatch(
 	ctx context.Context,
 	tableInfo config.TargetTableInfo,
 	colNames []string,
-	chunk models.Batch,
+	batch models.Batch,
 ) (int, error) {
 	tableId := pgx.Identifier{tableInfo.Schema, tableInfo.Table}
 	_, err := postgresLd.db.CopyFrom(
 		ctx,
 		tableId,
 		colNames,
-		pgx.CopyFromRows(chunk.Data),
+		pgx.CopyFromRows(batch.Rows),
 	)

 	if err != nil {
@@ -60,20 +60,20 @@ func (postgresLd *PostgresLoader) ProcessChunk(
 			}
 		}

-		return 0, &custom_errors.LoaderError{Batch: chunk, Msg: err.Error()}
+		return 0, &custom_errors.LoaderError{Batch: batch, Msg: err.Error()}
 	}

-	return len(chunk.Data), nil
+	return len(batch.Rows), nil
 }

 func (postgresLd *PostgresLoader) Exec(
 	ctx context.Context,
 	tableInfo config.TargetTableInfo,
 	columns []models.ColumnType,
-	chChunksIn <-chan models.Batch,
+	chBatchesIn <-chan models.Batch,
 	chErrorsOut chan<- custom_errors.LoaderError,
 	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActiveChunks *sync.WaitGroup,
+	wgActiveBatches *sync.WaitGroup,
 	rowsLoaded *int64,
 ) {
 	colNames := mapSlice(columns, func(col models.ColumnType) string {
@@ -88,36 +88,40 @@ func (postgresLd *PostgresLoader) Exec(
 		select {
 		case <-ctx.Done():
 			return
-		case chunk, ok := <-chChunksIn:
+		case batch, ok := <-chBatchesIn:
 			if !ok {
 				return
 			}

-			processedRows, err := postgresLd.ProcessChunk(ctx, tableInfo, colNames, chunk)
+			processedRows, err := postgresLd.ProcessBatch(ctx, tableInfo, colNames, batch)

 			if err != nil {
 				var ldError *custom_errors.LoaderError
+				var jobError *custom_errors.JobError
 				if errors.As(err, &ldError) {
 					select {
 					case <-ctx.Done():
 						return
 					case chErrorsOut <- *ldError:
 					}
-				}
-
-				var jobError *custom_errors.JobError
-				if errors.As(err, &jobError) {
+				} else if errors.As(err, &jobError) {
 					select {
 					case <-ctx.Done():
 						return
 					case chJobErrorsOut <- *jobError:
 					}
+				} else {
+					select {
+					case <-ctx.Done():
+						return
+					case chErrorsOut <- custom_errors.LoaderError{Batch: batch, Msg: err.Error()}:
+					}
 				}

-				return
+				continue
 			}

-			wgActiveChunks.Done()
+			wgActiveBatches.Done()
 			atomic.AddInt64(rowsLoaded, int64(processedRows))
 		}
 	}
--- a/internal/app/etl/table_analyzers/main.go
+++ b/internal/app/etl/table_analyzers/main.go
@@ -0,0 +1,40 @@
+package table_analyzers
+
+import (
+	"context"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/etl"
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
+	"github.com/google/uuid"
+)
+
+func PartitionRangeGenerator(
+	ctx context.Context,
+	tableAnalyzer etl.TableAnalyzer,
+	tableInfo config.TableInfo,
+	partitionColumn string,
+	rowsPerPartition int64,
+) ([]models.Partition, error) {
+	rowsCount, err := tableAnalyzer.EstimateTotalRows(ctx, tableInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	if rowsCount <= rowsPerPartition {
+		return []models.Partition{{
+			Id:             uuid.New(),
+			ShouldUseRange: false,
+			RetryCounter:   0,
+		}}, nil
+
+	}
+
+	partitionsCount := rowsCount / rowsPerPartition
+	partitions, err := tableAnalyzer.CalculatePartitionRanges(ctx, tableInfo, partitionColumn, partitionsCount)
+	if err != nil {
+		return nil, err
+	}
+
+	return partitions, nil
+}
--- a/internal/app/etl/table_analyzers/mssql.go
+++ b/internal/app/etl/table_analyzers/mssql.go
@@ -0,0 +1,249 @@
+package table_analyzers
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	"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
+}
+
+func NewMssqlTableAnalyzer(db *sql.DB) etl.TableAnalyzer {
+	return &MssqlTableAnalyzer{db: db}
+}
+
+const mssqlColumnMetadataQuery string = `
+SELECT 
+	c.name AS name,
+	t.name AS user_type,
+	CASE WHEN t.is_user_defined = 0 THEN t.name ELSE bt.name END AS system_type,
+	c.is_nullable AS nullable,
+	c.max_length AS max_length,
+	c.precision AS precision,
+	c.scale AS scale
+FROM sys.columns c
+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%'
+ORDER BY c.column_id;`
+
+type rawColumnMssql struct {
+	name       string
+	userType   string
+	systemType string
+	nullable   bool
+	maxLength  int64
+	precision  int64
+	scale      int64
+}
+
+func (ta *MssqlTableAnalyzer) systemTypeToUnifiedType(systemType string) string {
+	systemType = strings.ToLower(systemType)
+
+	if systemType == "varchar" || systemType == "char" || systemType == "nvarchar" || systemType == "nchar" || systemType == "text" || systemType == "ntext" {
+		return "STRING"
+	}
+
+	if systemType == "int" || systemType == "int4" || systemType == "integer" || systemType == "smallint" || systemType == "int2" || systemType == "bigint" || systemType == "int8" || systemType == "tinyint" {
+		return "INTEGER"
+	}
+
+	if systemType == "decimal" || systemType == "numeric" {
+		return "DECIMAL"
+	}
+
+	if systemType == "float" || systemType == "real" || systemType == "double precision" {
+		return "FLOAT"
+	}
+
+	if systemType == "bit" || systemType == "boolean" {
+		return "BOOLEAN"
+	}
+
+	if systemType == "date" {
+		return "DATE"
+	}
+	if systemType == "time" || systemType == "time without time zone" {
+		return "TIME"
+	}
+	if systemType == "datetime" || systemType == "datetime2" || systemType == "timestamp" || systemType == "timestamptz" || systemType == "timestamp with time zone" {
+		return "TIMESTAMP"
+	}
+
+	if systemType == "binary" || systemType == "varbinary" || systemType == "image" || systemType == "bytea" {
+		return "BINARY"
+	}
+
+	if systemType == "uniqueidentifier" || systemType == "uuid" {
+		return "UUID"
+	}
+
+	if systemType == "json" {
+		return "JSON"
+	}
+
+	if systemType == "geometry" || systemType == "geography" {
+		return "GEOMETRY"
+	}
+
+	return strings.ToUpper(systemType)
+}
+
+func (ta *MssqlTableAnalyzer) rawColumnToColumnType(rawColumn rawColumnMssql) models.ColumnType {
+	const nullValue int64 = -1
+	stringTypes := map[string]bool{"varchar": true, "char": true, "nvarchar": true, "nchar": true, "text": true, "ntext": true}
+	decimalTypes := map[string]bool{"decimal": true, "numeric": true}
+
+	if stringTypes[rawColumn.systemType] {
+		if rawColumn.systemType == "nvarchar" || rawColumn.systemType == "nchar" {
+			if rawColumn.maxLength > 0 {
+				rawColumn.maxLength = rawColumn.maxLength / 2
+			}
+		}
+
+		rawColumn.precision, rawColumn.scale = nullValue, nullValue
+	} else if decimalTypes[rawColumn.systemType] {
+		rawColumn.maxLength = nullValue
+	} else {
+		rawColumn.maxLength, rawColumn.precision, rawColumn.scale = nullValue, nullValue, nullValue
+	}
+
+	columnType := models.NewColumnType(
+		rawColumn.name,
+		rawColumn.maxLength != nullValue,
+		rawColumn.precision != nullValue || rawColumn.scale != nullValue,
+		rawColumn.userType,
+		rawColumn.systemType,
+		ta.systemTypeToUnifiedType(rawColumn.systemType),
+		rawColumn.nullable,
+		rawColumn.maxLength,
+		rawColumn.precision,
+		rawColumn.scale,
+	)
+
+	return columnType
+}
+
+func (ta *MssqlTableAnalyzer) QueryColumnTypes(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+) ([]models.ColumnType, error) {
+	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))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var columnTypes []models.ColumnType
+
+	for rows.Next() {
+		var rawColumn rawColumnMssql
+
+		if err := rows.Scan(
+			&rawColumn.name,
+			&rawColumn.userType,
+			&rawColumn.systemType,
+			&rawColumn.nullable,
+			&rawColumn.maxLength,
+			&rawColumn.precision,
+			&rawColumn.scale,
+		); err != nil {
+			return nil, err
+		}
+
+		columnTypes = append(columnTypes, ta.rawColumnToColumnType(rawColumn))
+	}
+
+	return columnTypes, nil
+}
+
+func (ta *MssqlTableAnalyzer) EstimateTotalRows(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+) (int64, error) {
+	query := `
+SELECT SUM(p.rows) AS count
+FROM sys.tables t
+JOIN sys.schemas s ON t.schema_id = s.schema_id
+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)
+	defer cancel()
+
+	var rowsCount int64
+	err := ta.db.QueryRowContext(ctxTimeout, query, sql.Named("schema", tableInfo.Schema), sql.Named("table", tableInfo.Table)).Scan(&rowsCount)
+	if err != nil {
+		return 0, err
+	}
+
+	return rowsCount, nil
+}
+
+func (ta *MssqlTableAnalyzer) CalculatePartitionRanges(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+	partitionColumn string,
+	maxPartitions int64,
+) ([]models.Partition, error) {
+	query := fmt.Sprintf(`
+SELECT
+	MIN([%s]) AS lower_limit,
+	MAX([%s]) AS upper_limit
+FROM (SELECT [%s], NTILE(@maxPartitions) OVER (ORDER BY [%s]) AS batch_id FROM [%s].[%s]) AS T
+GROUP BY batch_id
+ORDER BY batch_id`,
+		partitionColumn,
+		partitionColumn,
+		partitionColumn,
+		partitionColumn,
+		tableInfo.Schema,
+		tableInfo.Table)
+
+	ctxTimeout, cancel := context.WithTimeout(ctx, time.Second*20)
+	defer cancel()
+
+	rows, err := ta.db.QueryContext(ctxTimeout, query, sql.Named("maxPartitions", maxPartitions))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	partitions := make([]models.Partition, 0, maxPartitions)
+
+	for rows.Next() {
+		partition := models.Partition{
+			Id:                    uuid.New(),
+			ShouldUseRange:        true,
+			RetryCounter:          0,
+			IsLowerLimitInclusive: true,
+		}
+
+		if err := rows.Scan(&partition.LowerLimit, &partition.UpperLimit); err != nil {
+			return nil, err
+		}
+
+		partitions = append(partitions, partition)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return partitions, nil
+}
--- a/internal/app/etl/table_analyzers/postgres.go
+++ b/internal/app/etl/table_analyzers/postgres.go
@@ -0,0 +1,174 @@
+package table_analyzers
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
+	"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
+}
+
+func NewPostgresTableAnalyzer(db *pgxpool.Pool) etl.TableAnalyzer {
+	return &PostgresTableAnalyzer{db: db}
+}
+
+const postgresColumnMetadataQuery string = `
+SELECT 
+  c.column_name AS name,
+  c.data_type AS user_type,
+  c.udt_name AS system_type,
+  (CASE WHEN c.is_nullable = 'YES' THEN TRUE ELSE FALSE END) AS nullable,
+  COALESCE(c.character_maximum_length, -1) AS max_length,
+  COALESCE(c.numeric_precision, -1) AS precision,
+  COALESCE(c.numeric_scale, -1) AS scale
+FROM information_schema.columns c
+WHERE c.table_schema = $1 AND c.table_name = $2
+ORDER BY c.ordinal_position;`
+
+type rawColumnPostgres struct {
+	name       string
+	userType   string
+	systemType string
+	nullable   bool
+	maxLength  int64
+	precision  int64
+	scale      int64
+}
+
+func (ta *PostgresTableAnalyzer) systemTypeToUnifiedType(systemType string) string {
+	systemType = strings.ToLower(systemType)
+
+	if systemType == "varchar" || systemType == "char" || systemType == "nvarchar" || systemType == "nchar" || systemType == "text" || systemType == "ntext" {
+		return "STRING"
+	}
+
+	if systemType == "int" || systemType == "int4" || systemType == "integer" || systemType == "smallint" || systemType == "int2" || systemType == "bigint" || systemType == "int8" || systemType == "tinyint" {
+		return "INTEGER"
+	}
+
+	if systemType == "decimal" || systemType == "numeric" {
+		return "DECIMAL"
+	}
+
+	if systemType == "float" || systemType == "real" || systemType == "double precision" {
+		return "FLOAT"
+	}
+
+	if systemType == "bit" || systemType == "boolean" {
+		return "BOOLEAN"
+	}
+
+	if systemType == "date" {
+		return "DATE"
+	}
+	if systemType == "time" || systemType == "time without time zone" {
+		return "TIME"
+	}
+	if systemType == "datetime" || systemType == "datetime2" || systemType == "timestamp" || systemType == "timestamptz" || systemType == "timestamp with time zone" {
+		return "TIMESTAMP"
+	}
+
+	if systemType == "binary" || systemType == "varbinary" || systemType == "image" || systemType == "bytea" {
+		return "BINARY"
+	}
+
+	if systemType == "uniqueidentifier" || systemType == "uuid" {
+		return "UUID"
+	}
+
+	if systemType == "json" {
+		return "JSON"
+	}
+
+	if systemType == "geometry" || systemType == "geography" {
+		return "GEOMETRY"
+	}
+
+	return strings.ToUpper(systemType)
+}
+
+func (ta *PostgresTableAnalyzer) rawColumnToColumnType(rawColumn rawColumnPostgres) models.ColumnType {
+	const nullValue int64 = -1
+	stringTypes := map[string]bool{"varchar": true, "char": true, "text": true}
+	decimalTypes := map[string]bool{"decimal": true, "numeric": true}
+
+	if stringTypes[rawColumn.systemType] {
+		rawColumn.precision, rawColumn.scale = nullValue, nullValue
+	} else if decimalTypes[rawColumn.systemType] {
+		rawColumn.maxLength = nullValue
+	} else {
+		rawColumn.maxLength, rawColumn.precision, rawColumn.scale = nullValue, nullValue, nullValue
+	}
+
+	return models.NewColumnType(
+		rawColumn.name,
+		rawColumn.maxLength != nullValue,
+		rawColumn.precision != nullValue || rawColumn.scale != nullValue,
+		rawColumn.userType,
+		rawColumn.systemType,
+		ta.systemTypeToUnifiedType(rawColumn.systemType),
+		rawColumn.nullable,
+		rawColumn.maxLength,
+		rawColumn.precision,
+		rawColumn.scale,
+	)
+}
+
+func (ta *PostgresTableAnalyzer) QueryColumnTypes(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+) ([]models.ColumnType, error) {
+	localCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
+	defer cancel()
+
+	rows, err := ta.db.Query(localCtx, postgresColumnMetadataQuery, tableInfo.Schema, tableInfo.Table)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var colTypes []models.ColumnType
+
+	for rows.Next() {
+		var column rawColumnPostgres
+
+		if err := rows.Scan(
+			&column.name,
+			&column.userType,
+			&column.systemType,
+			&column.nullable,
+			&column.maxLength,
+			&column.precision,
+			&column.scale,
+		); err != nil {
+			return nil, err
+		}
+
+		colTypes = append(colTypes, ta.rawColumnToColumnType(column))
+	}
+
+	return colTypes, nil
+}
+
+func (ta *PostgresTableAnalyzer) EstimateTotalRows(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+) (int64, error) {
+	return 0, nil
+}
+
+func (ta *PostgresTableAnalyzer) CalculatePartitionRanges(
+	ctx context.Context,
+	tableInfo config.TableInfo,
+	partitionColumn string,
+	maxPartitions int64,
+) ([]models.Partition, error) {
+	return []models.Partition{}, nil
+}
--- a/internal/app/etl/transformers/mssql.go
+++ b/internal/app/etl/transformers/mssql.go
@@ -60,15 +60,15 @@ func computeTransformationPlan(columns []models.ColumnType) []etl.ColumnTransfor
 	return plan
 }

-const processChunkCtxCheck = 4096
+const processBatchCtxCheck = 4096

-func (mssqlTr *MssqlTransformer) ProcessChunk(
+func (mssqlTr *MssqlTransformer) ProcessBatch(
 	ctx context.Context,
-	chunk *models.Batch,
+	batch *models.Batch,
 	transformationPlan []etl.ColumnTransformPlan,
 ) error {
-	for i, rowValues := range chunk.Data {
-		if i%processChunkCtxCheck == 0 {
+	for i, rowValues := range batch.Rows {
+		if i%processBatchCtxCheck == 0 {
 			if err := ctx.Err(); err != nil {
 				return err
 			}
@@ -94,10 +94,10 @@ func (mssqlTr *MssqlTransformer) ProcessChunk(
 func (mssqlTr *MssqlTransformer) Exec(
 	ctx context.Context,
 	columns []models.ColumnType,
-	chChunksIn <-chan models.Batch,
-	chChunksOut chan<- models.Batch,
+	chBatchesIn <-chan models.Batch,
+	chBatchesOut chan<- models.Batch,
 	chJobErrorsOut chan<- custom_errors.JobError,
-	wgActiveChunks *sync.WaitGroup,
+	wgActiveBatches *sync.WaitGroup,
 ) {
 	transformationPlan := computeTransformationPlan(columns)

@@ -110,22 +110,22 @@ func (mssqlTr *MssqlTransformer) Exec(
 		case <-ctx.Done():
 			return

-		case chunk, ok := <-chChunksIn:
+		case batch, ok := <-chBatchesIn:
 			if !ok {
 				return
 			}

 			if len(transformationPlan) == 0 {
 				select {
-				case chChunksOut <- chunk:
-					wgActiveChunks.Add(1)
+				case chBatchesOut <- batch:
+					wgActiveBatches.Add(1)
 					continue
 				case <-ctx.Done():
 					return
 				}
 			}

-			err := mssqlTr.ProcessChunk(ctx, &chunk, transformationPlan)
+			err := mssqlTr.ProcessBatch(ctx, &batch, transformationPlan)
 			if err != nil {
 				if errors.Is(err, ctx.Err()) {
 					return
@@ -139,12 +139,12 @@ func (mssqlTr *MssqlTransformer) Exec(
 			}

 			select {
-			case chChunksOut <- chunk:
+			case chBatchesOut <- batch:
 			case <-ctx.Done():
 				return
 			}

-			wgActiveChunks.Add(1)
+			wgActiveBatches.Add(1)
 		}
 	}
 }
--- a/internal/app/etl/types.go
+++ b/internal/app/etl/types.go
@@ -10,14 +10,14 @@ import (
 )

 type Extractor interface {
-	ProcessBatch(
+	ProcessPartition(
 		ctx context.Context,
 		tableInfo config.SourceTableInfo,
 		columns []models.ColumnType,
-		chunkSize int,
-		batch models.Partition,
+		batchSize int,
+		partition models.Partition,
 		indexPrimaryKey int,
-		chChunksOut chan<- models.Batch,
+		chBatchesOut chan<- models.Batch,
 		rowsRead *int64,
 	) error

@@ -25,12 +25,12 @@ type Extractor interface {
 		ctx context.Context,
 		tableInfo config.SourceTableInfo,
 		columns []models.ColumnType,
-		chunkSize int,
-		chBatchesIn <-chan models.Partition,
-		chChunksOut chan<- models.Batch,
+		batchSize int,
+		chPartitionsIn <-chan models.Partition,
+		chBatchesOut chan<- models.Batch,
 		chErrorsOut chan<- custom_errors.ExtractorError,
 		chJobErrorsOut chan<- custom_errors.JobError,
-		wgActiveBatches *sync.WaitGroup,
+		wgActivePartitions *sync.WaitGroup,
 		rowsRead *int64,
 	)
 }
@@ -43,43 +43,43 @@ type ColumnTransformPlan struct {
 }

 type Transformer interface {
-	ProcessChunk(
+	ProcessBatch(
 		ctx context.Context,
-		chunk *models.Batch,
+		batch *models.Batch,
 		transformationPlan []ColumnTransformPlan,
 	) error

 	Exec(
 		ctx context.Context,
 		columns []models.ColumnType,
-		chChunksIn <-chan models.Batch,
-		chChunksOut chan<- models.Batch,
+		chBatchesIn <-chan models.Batch,
+		chBactchesOut chan<- models.Batch,
 		chJobErrorsOut chan<- custom_errors.JobError,
-		wgActiveChunks *sync.WaitGroup,
+		wgActiveBatches *sync.WaitGroup,
 	)
 }

 type Loader interface {
-	ProcessChunk(
+	ProcessBatch(
 		ctx context.Context,
 		tableInfo config.TargetTableInfo,
 		colNames []string,
-		chunk models.Batch,
+		batch models.Batch,
 	) (int, error)

 	Exec(
 		ctx context.Context,
 		tableInfo config.TargetTableInfo,
 		columns []models.ColumnType,
-		chChunksIn <-chan models.Batch,
+		chBatchesIn <-chan models.Batch,
 		chErrorsOut chan<- custom_errors.LoaderError,
 		chJobErrorsOut chan<- custom_errors.JobError,
-		wgActiveChunks *sync.WaitGroup,
+		wgActiveBatches *sync.WaitGroup,
 		rowsLoaded *int64,
 	)
 }

-type TableAnalizer interface {
+type TableAnalyzer interface {
 	QueryColumnTypes(
 		ctx context.Context,
 		tableInfo config.TableInfo,
@@ -93,6 +93,7 @@ type TableAnalizer interface {
 	CalculatePartitionRanges(
 		ctx context.Context,
 		tableInfo config.TableInfo,
-		totalPartitions int,
-	) (models.Partition, error)
+		partitionColumn string,
+		maxPartitions int64,
+	) ([]models.Partition, error)
 }