Prakrishta.Data.Bulk 1.0.0

Prakrishta.Data.Bulk

High performance, extensible bulk operations for .NET. Prakrishta.Data.Bulk is a provider agnostic, pipeline based bulk engine designed for speed, flexibility, and testability. It complements Prakrishta.Data by enabling large scale insert, update, and delete operations with minimal overhead.

Features

• Fastest‑in‑class bulk insert performance
• TVP‑based stored procedure strategy (fastest for pure inserts)
• Staging table strategy with MERGE (best for upsert/update/delete)
• Zero reflection, zero EF Core overhead
• Linear scaling from 1k → 50k+ rows
• Async/await support
• BenchmarkDotNet‑verified performance
• Works with SQL Server, Azure SQL, LocalDB
• Pure ADO.NET — no EF Core required
• Clean, extensible architecture

Feature Comparison Table

Getting Started (Quickstart Guide)

1. Install the NuGet package

dotnet add package Prakrishta.Data.Bulk

2. Define your entity

public sealed class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = default!;
    public decimal Balance { get; set; }
    public DateTime CreatedOn { get; set; }
}

3. Create a bulk engine

Stored Procedure Strategy (Fastest for Inserts)

var engine = BulkEngineFactory.CreateStoredProc(
    connectionString: "...",
    storedProcName: "dbo.InsertCustomers"
);

The stored procedure should accept a TVP:

CREATE TYPE dbo.CustomerType AS TABLE
(
    Id INT,
    Name NVARCHAR(200),
    Balance DECIMAL(18,2),
    CreatedOn DATETIME2
);

CREATE PROCEDURE dbo.InsertCustomers
    @Customers dbo.CustomerType READONLY
AS
BEGIN
    INSERT INTO dbo.Customers (Id, Name, Balance, CreatedOn)
    SELECT Id, Name, Balance, CreatedOn
    FROM @Customers;
END

Staging Table Strategy (Best for Upsert/Update/Delete)

var engine = BulkEngineFactory.CreateStaging(
    connectionString: "...",
    targetTable: "dbo.Customers",
    keyColumns: new[] { "Id" }
);

4. Execute a bulk insert

await engine.InsertAsync(customers, "dbo.Customers");

5. Execute an upsert (staging strategy only)

await engine.UpsertAsync(customers, "dbo.Customers");

Performance Benchmarks

Key Findings

• EFCore.BulkExtensions performs well for small batches due to low setup overhead.
• Prakrishta’s stored-proc strategy is the fastest overall, especially at large batch sizes.
• Prakrishta’s staging-table strategy is also extremely fast and scales linearly.
• At 10k–50k rows, Prakrishta is 2× faster than EFCore.BulkExtensions.
• Staging-table strategy even outperforms raw SqlBulkCopy at large sizes.
• Performance is linear, predictable, and optimized for high-volume ingestion.

Performance Chart (Markdown)

This chart visualizes the current benchmark results for 50,000 rows, the most meaningful scale for real‑world ETL and ingestion workloads.

Milliseconds (lower is better)

Bulk Insert Performance (50,000 rows)

Prakrishta (Stored Proc)   | ████████████████████████████ 188 ms
Prakrishta (Staging)       | ██████████████████████████████ 195 ms
Raw SqlBulkCopy            | ███████████████████████████████ 203 ms
EFCore.BulkExtensions      | █████████████████████████████████████████████ 395 ms

Bulk Insert Performance (10,000 rows)

Prakrishta (Stored Proc)   | ████████████████ 37.3 ms
Prakrishta (Staging)       | ████████████████████ 48.2 ms
Raw SqlBulkCopy            | ████████████████████ 49.2 ms
EFCore.BulkExtensions      | █████████████████████████████████ 87.4 ms

Bulk Insert Performance (1,000 rows)

Prakrishta (Stored Proc)   | ████████ 10.0 ms
EFCore.BulkExtensions      | ████████ 11.4 ms
Prakrishta (Staging)       | █████████ 12.8 ms
Raw SqlBulkCopy            | ██████████ 14.6 ms

Why Prakrishta Is Faster

Prakrishta.Data.Bulk achieves industry‑grade performance because it:

• Uses pure ADO.NET
• Avoids EF Core overhead
• Eliminates reflection
• Uses optimized TVP ingestion
• Uses linear‑scaling staging tables
• Minimizes SQL Server I/O and logging
• Reduces round trips
• Produces predictable, stable performance curves

This is why Prakrishta Data Bulk engine is:

• Faster than EFCore.BulkExtensions
• Faster than Raw SqlBulkCopy at scale
• The fastest overall at 50K rows (stored‑proc strategy)

Choosing the Right Strategy

Different workloads benefit from different bulk‑loading strategies. Prakrishta.Data.Bulk gives you three optimized paths — each designed for a specific class of problems.

1. Stored Procedure Strategy (TVP‑based) — Best Overall for Inserts

Use when you want:

• Maximum raw insert speed
• Minimal SQL Server overhead
• A single round‑trip to the database
• No MERGE logic
• No staging table

Ideal for:

• High‑volume inserts
• ETL ingestion
• Logging pipelines
• Append‑only tables
• Scenarios where the target table has no complex constraints

Why choose it:

Fastest strategy at 1k, 10k, and 50k rows. Outperforms EFCore.BulkExtensions and even Raw SqlBulkCopy.

2. Staging Table Strategy — Best for Upserts, Updates & Deletes

Use when you need:

• MERGE semantics
• Update‑or‑insert behavior
• Delete‑or‑insert behavior
• Full control over matching keys
• Idempotent ingestion

Ideal for:

• Slowly changing dimensions (SCD)
• Data warehouse loads
• Sync jobs
• Reconciliation pipelines
• Any scenario requiring deterministic upsert logic

Why choose it:

Linear scaling, extremely stable, and 2× faster than EFCore.BulkExtensions at medium and large batch sizes.

3. Raw SqlBulkCopy Strategy — Baseline / Custom Scenarios

Use when you want:

• Absolute minimal overhead
• Full control over the SqlBulkCopy pipeline
• Custom batching or streaming logic
• No MERGE or stored proc logic

Ideal for:

• Internal pipelines
• Custom ETL frameworks
• Scenarios where you want to build your own logic on top of SqlBulkCopy

Why choose it:

Great baseline — and your strategies outperform it at scale.

4. When to Choose Which Strategy

Performance Badges

License

MIT License — free for commercial and open‑source use.