Rust-powered · Free and open source · Apache-2.0

Loads you can trust.

Exact types. Loud failures. Bounded memory.

sqlload plan shows every column's type, every refusal and the memory budget before any data moves. Then load does exactly that, carrying on from the warehouse's own maximum, with no state kept anywhere else.

$ pip install sqlload
Read the docs View on GitHub
sqlload plan -v…Objects (3)                                         sqlload apply…├── raw.app__orders                                 create table│   ├── order_id    int             -> BIGINT│   ├── customer_id int             -> BIGINT│   ├── status      text            -> VARCHAR│   ├── total       decimal(12,2)   -> DECIMAL(12,2)│   ├── currency    text            -> VARCHAR│   ├── items       int             -> BIGINT│   ├── created_at  timestamp_tz    -> TIMESTAMP WITH TIME ZONE  (stored as a UTC instant; the offset is not kept)│   ├── updated_at  timestamp_tz    -> TIMESTAMP WITH TIME ZONE  (stored as a UTC instant; the offset is not kept)│   └── + _sqlload_load_id, _loaded_at… # the source changes total to numeric(14,4)sqlload load…altered  raw.app__orders     widen  total decimal(12,2) -> decimal(14,4) (DECIMAL(14,4))  in placeloaded  raw.app__orders         4,023 rows 0.4s

Faster, in a fraction of the memory

How we measured →

S3 Parquet → Snowflake · 100M rows

sqlload
134.4 s
ingestr
182.3 s

S3 Parquet → Snowflake · 100M rows · peak memory

sqlload
54 MiB
ingestr
+ 5.7 GiB temp disk3,836 MiB

Postgres → Snowflake · 1M rows

sqlload
14.56 s
ingestr
16.38 s
dlt
29.36 s

Lower is better, on one 4-vCPU, 8 GB machine. S3 Parquet → Snowflake: wall time and peak memory from the same 100M-row runs, median of 3, 18 November 2026, sqlload 0.70.1 and ingestr 1.1.82. On SQLLoad's default route Snowflake copies the files itself, so no row passes through SQLLoad and it uses no disk; ingestr streams every row through its own process and spilled 5.7 GiB to disk. Postgres → Snowflake: median of 5 runs, 6 November 2026, sqlload 0.11.1, ingestr 1.1.82, dlt 1.32.0 (its connectorx backend for Postgres); peak memory 131 MiB for sqlload, 495 MiB for ingestr and 341 MiB for dlt. dlt was not run in the S3 scenario.

Where loads go wrong

Hidden state drifts from reality

A stored copy of the schema or the cursor disagrees with the warehouse, and the fix is deleting state you can't see.

Types quietly change

Decimals lose digits, JSON turns into strings, a column that's all NULL never gets created, and a stray value becomes a second column.

Big tables take the server down

A large first load buffers everything in memory, and the run dies with no report.

Nothing says no

No step shows what a run will change, or stops when something's wrong.

Plan, apply, load

One sqlload.toml, three commands, and nothing kept outside your warehouse.

01 · Plan

See every change first

Every table, column, type mapping, write strategy, route and cursor, before anything runs. Problems come with the fix.

Reading a plan →

sqlload plan
…
Objects (2)                                                                     sqlload apply
├── raw.app__orders  create table, 7 columns
└── raw.events       create table, 8 columns

Loads (2)  into DuckDB local                                                    sqlload load
├── app postgres  into raw
│   └── orders   merge on order_id     updated_at: first run, everything
└── events ./lake/events/  into raw
    └── events   delete_insert on dt   3 new of 3 files
        └── route  DuckDB reads directly from ./lake/events/ (nothing through the loader)

Errors (1)
└── raw.app__customers
    └── reason  lifetime_value has type numeric(12,2), which cannot be read as int

✗ Plan failed  2 objects to create, 2 to load, 1 error
02 · Load

Bulk copy, not row inserts

Files in S3 load into Snowflake straight from an external stage, and Parquet in S3 into Databricks through an external location. Parquet loads into DuckDB through DuckDB's own reader, Parquet in S3 or Google Cloud Storage into MotherDuck on its servers, and Parquet in Google Cloud Storage into BigQuery as a temporary external table. Snowflake tables load into Snowflake on the same connection, or through an external stage that covers the unload, without leaving Snowflake, and BigQuery tables into BigQuery on the same connection. Snowflake tables unloaded to S3 load into DuckDB, Databricks and ClickHouse with no row passing through SQLLoad. Rows are staged as Parquet and copied in bulk.

Load methods and routes →

sqlload plan
…
Loads (3)  into DuckDB local                                                    sqlload load
├── app postgres  into raw
│   ├── customers   merge on customer_id
│   └── orders      merge on order_id     updated_at ≥ 2026-11-02 08:04:00+00 (max)
└── events ./lake/events/  into raw
    └── events      delete_insert on dt   dt ≥ 2026-11-03 (max) · 2 new of 4 files
        └── route  DuckDB reads directly from ./lake/events/ (nothing through the loader)

sqlload load
…
loaded  raw.events             12 rows 0.0s
loaded  raw.app__customers     20 rows 0.0s
loaded  raw.app__orders         2 rows 0.0s

✓ Completed  3 loaded, 34 rows, 0.3s
├── slowest      raw.app__orders 0.0s
└── peak memory  97.8 MiB
03 · Stay stateless

The warehouse is the state

Incremental tables continue from the destination's own maximum. The schema is the live table. No local cache, no schema tables to fall out of sync.

Cursors and state →

sqlload plan app__orders
…
Loads (1)  into DuckDB local                                                    sqlload load
└── app postgres  into raw
    └── orders   merge on order_id   updated_at ≥ 2026-11-16 14:01:06+00 (max)

sqlload load app__orders
…
loaded  raw.app__orders      5 rows 0.0s

✓ Completed  1 loaded, 5 rows, 0.3s
├── slowest      raw.app__orders 0.0s
└── peak memory  85.8 MiB
04 · Keep types exact

Declare what matters

Portable types, mapped per warehouse. Pin a column and SQLLoad widens the table in place; check declarations against live tables in CI.

Contracts and schema changes →

# sqlload.toml
[sources.app.tables."public.orders"]
columns = { total = "decimal(18,2)" }

sqlload plan app__orders
…
Objects (1)                                                                     sqlload apply
└── raw.app__orders  alter table
    └── widen  total decimal(12,2) -> decimal(18,2) (DECIMAL(18,2))  in place

sqlload contract diff
  OK    table:app__orders
0 contract difference(s)
05 · Write sources in Python

APIs without the plumbing

Yield dicts, Arrow data or JSON bytes. HTTP pagination, fan-out, retries and rate limits run in Rust.

Python sources →

import sqlload as sl

shop = sl.source("shop", connection="shop")
api = sl.http(shop)  # auth, rate_limit, max_in_flight: [connections.shop]

@shop.table(unique_key="order_id")
def orders(ctx):
    """Orders, one row per order."""
    return api.paginate("/orders", select="$.items",
                        paginator=sl.page_number("page"))

Each panel shows real sqlload output on a small orders example, cut down where marked ….

Start in a minute

Install it, then copy a folder or a Postgres table with one command. No configuration file needed.

SystemSourceTarget
Postgres✓ (incl. CDC)✓
Snowflake✓✓
BigQuery Beta✓✓
Databricks Beta✓✓
ClickHouse✓
DuckDB✓
MotherDuck Beta✓
ODBC✓ SQL Server, MySQL, OpenEdge
Files: S3, GCS, local, SFTP✓ Parquet, CSV, JSON, Excel, XML✓ Parquet, CSV
Google Sheets✓
APIs, Python✓
Kafka✓ to Snowflake, Databricks, BigQuery

Every combination, version and write strategy is in the connector matrix.

  • Linux, macOS and Windows; Python only for Python sources.
  • Free and open source, Apache-2.0.
pip install sqlload
sqlload copy \
  'postgresql://postgres:${ENV:PGPASSWORD}@localhost/shop#public.orders' \
  duckdb://shop.duckdb#raw.orders --cursor-column updated_at
…
created  raw.orders  7 columns
loaded  raw.orders  1,000 rows 0.1s

✓ Completed  1 loaded, 1,000 rows, 0.3s
├── slowest      raw.orders 0.1s
└── peak memory  80.1 MiB

Load your first table

Follow the quickstart, or read how SQLLoad compares with dlt and ingestr.