Concepts
Cursors and state
How incremental tables find where to read from, how large loads commit along the way, and logged state for positions the data can't carry.
An incremental table has a cursor_column, such as updated_at or id. Each run reads from the
destination’s maximum of that column. SQLLoad doesn’t store the position anywhere else: it reads
it from the table, so a table you change, truncate or drop by hand is followed on the next run.
$ sqlload plan -v app__orders… ├── reads updated_at >= 2026-10-12 16:00:00.000+00 (warehouse maximum)…Cursor settings
Section titled “Cursor settings”| Setting | Meaning |
|---|---|
cursor_column |
The column runs continue from: an integer, date, timestamp or text column. A list of columns of one type family, such as ["updated_at", "created_at"], reads the first non-NULL of them in each row. See NULL cursor values. |
null_cursor |
fail (default), include or ignore: what a read does with source rows whose cursor is NULL. See NULL cursor values. |
cursor_start |
Where the first run starts, when the table is empty. Without it, the first run reads everything. |
lookback |
Read this far before the maximum, to pick up late rows: a duration on a date or timestamp cursor, such as "1h" or "2d" (a date cursor moves back by whole days); a number of cursor units on an integer cursor, such as 1. See Fiscal year tables. Not with append. |
lookback_from |
destination (default) counts lookback back from the destination’s maximum; now counts it back from the time of the run. See Reload a window. |
lookahead |
Read only cursor values before now plus this; a date cursor reads up to and including today plus that many days. Date and timestamp cursors only. |
append_cursor_inclusive |
false (default) reads strictly after the maximum; true reads from the maximum itself, inserting its rows again on every run. See append. |
on_cursor_out_of_range |
Python tables only. fail (default), skip or warn: what a load does with rows the function returns outside the window it was asked for. See Rows outside the window. |
timezone |
The IANA zone, such as "Europe/Paris", that cursor_start, --start-cursor and --end-cursor without an offset are read in on a cursor of times, and that a Python table’s ctx.cursor_value and ctx.cursor_end arrive in; UTC when unset. See Times without an offset. |
Where the read starts, in order:
--start-cursor, or the typed flag of the table’s cursor (--start-cursor-tsor--start-cursor-int), when given.- With
lookback_from = "now", now minuslookback, on every run, the first one too. Otherwise the destination’s maximum ofcursor_column, minuslookback.appendreads strictly after it, whichplanshows as>rather than>=. cursor_start, when the table is empty.- Otherwise, everything.
plan says which one applies, on the table’s reads line.
Text cursors compare by Unicode code point on both sides,
whatever collation the source column or the destination uses, so 'B1' comes before 'a9'.
Postgres sources and targets compare with COLLATE "C", and Snowflake with utf8.
- Postgres stops using a plain index on a text cursor for the read, the destination’s
maximum and
delete_insert’s deletes, unless the column is alreadyCOLLATE "C". Create the index asCREATE INDEX ... (event_key COLLATE "C"). On Snowflake, a cursor column declared with another collation may prune fewer micro-partitions. - If an existing table’s keys only increase in a linguistic order (
apple1,Banana2,cherry3,Date4), code point order puts some new keys below the maximum, so they are not read. Use keys that increase in either order, such as zero-padded numbers, ULIDs or ISO timestamps. - DuckDB, BigQuery and Databricks compare by code point unless a dataset, schema, table or column sets a collation, which SQLLoad doesn’t override.
NULL cursor values
Section titled “NULL cursor values”A read from the destination’s maximum compares each row’s cursor with it, and a NULL compares with nothing. A row whose cursor is NULL loads on the first run, which reads everything, and is never read again while its cursor stays NULL: an edit to it, or a new row with a NULL cursor, never loads. Systems that set a modified date only after the first edit leave it NULL on every row never edited.
A load that would skip such rows fails the table instead. Before the read, SQLLoad
counts the source rows with a NULL cursor (SELECT count(*) ... WHERE <cursor> IS NULL on a
database or warehouse source; a Python table counts the rows it yields). On a database or warehouse
source, the table fails before its read when there are any, and nothing is written. A Python table
counts while it reads, so it fails at the end of the window holding them: the windows before it are
already committed, and that window and the ones after it aren’t written:
$ sqlload load…failed raw.app__orders 2 source rows have a NULL updated_at, which an incremental read never selects, so they would never load; set null_cursor = "include" to read them on every run, list a column that is always set to coalesce with it (such as cursor_column = ["updated_at", "created_at"]), or set null_cursor = "ignore" to skip them…Choose one fix per table:
| Fix | Effect |
|---|---|
cursor_column = ["updated_at", "created_at"] |
The cursor is the first non-NULL of the columns in each row (COALESCE), for the read, the destination’s maximum, lookback and batch_size. A row never edited is read by its created_at, and again once its updated_at is set. The columns must be of one type family: integers, text, dates, timestamps, or timestamps with a time zone. A row where every one is NULL follows null_cursor. |
null_cursor = "include" |
Every run reads the rows whose cursor is NULL as well as its range: cursor >= ? OR cursor IS NULL. merge only, which merges them again on each run; plan refuses it on append and delete_insert, which would insert them again on every run. |
null_cursor = "ignore" |
Skip them, for tables where a NULL cursor marks rows that should not load. |
[sources.app.tables."public.orders"]description = "Orders, one row per order."write_strategy = "merge"unique_key = "{primary_key}"cursor_column = ["updated_at", "created_at"]plan names the rule on the table’s reads line. fail the load shows when the source reports the
cursor column nullable, and nothing when it reports it NOT NULL, which skips the count:
$ sqlload plan -v app__orders… ├── reads updated_at >= 2026-10-12 16:00:00.000+00 (warehouse maximum) (NULL cursors: included)…null_cursor |
reads line ends with |
|---|---|
fail, cursor nullable at the source |
(NULL cursors: fail the load) |
include |
(NULL cursors: included) |
ignore |
(NULL cursors: skipped) |
The count is one more query on the source before each read that has a lower or upper bound. It filters on the cursor alone, so its cost depends on the source:
- On Postgres, a cursor column without an index makes it a sequential scan of the table.
- On BigQuery, a table read through a read session gets a query job for it, which needs
bigquery.jobs.create(as inbigquery.jobUser) and bills a scan of the cursor column. See BigQuery permissions.
null_cursor = "ignore" and null_cursor = "include" skip the count, as does a cursor column the
source declares NOT NULL.
Sources differ in what they check:
- Postgres, ODBC, Snowflake and BigQuery sources count with one query per load, and a table read
through
sqlcounts that query’s rows. ODBC counts the same way under eithercursor_bounds. - A Python table counts the rows it yields with a NULL cursor. A function that filters by
ctx.cursor_valueitself drops them before SQLLoad sees them, so yield them too, or undernull_cursor = "include". A Python table takes onecursor_column: yield the first set value as one field and name that field. - A files source’s cursor is a partition or path column, set from each file’s path, so it is never
NULL. Its
cursor_columnis one column. - A files target, and
delete_insert, take onecursor_column: they partition and replace by one column’s values.
Backfilling a range
Section titled “Backfilling a range”--start-cursor and --end-cursor read a range instead, from the start up to but not including the
end. Values are typed from each selected table’s cursor: an integer, an RFC 3339 timestamp or a
date.
$ sqlload plan -v app__orders --start-cursor 2026-10-01 --end-cursor 2026-10-08… ├── reads updated_at from 2026-10-01 00:00:00.000000+00 (--start-cursor), below 2026-10-08 00:00:00.000000+00 (--end-cursor)…Every selected table must have the same kind of cursor. Select tables of one cursor type per run.
The typed flags range a selection with both kinds, as in SQLBuild. --start-cursor-ts
and --end-cursor-ts take an RFC 3339 timestamp or a date, and apply to date and timestamp cursors.
--start-cursor-int and --end-cursor-int take an integer, and apply to integer cursors. Give
both kinds in one run, and each table takes the flags of its cursor’s kind:
$ sqlload plan -v --start-cursor-ts 2026-10-01 --end-cursor-ts 2026-10-08 --start-cursor-int 2024…├── raw.erp__gl_balances delete_insert (cursor: fiscal_year)│ ├── source postgres erp public.gl_balances│ ├── route read as Arrow -> DuckDB takes Arrow│ └── reads fiscal_year >= 2024 (--start-cursor-int)└── raw.erp__orders merge (unique_key: order_id ← {primary_key}) ├── source postgres erp public.orders ├── route read as Arrow -> DuckDB takes Arrow ├── reads updated_at from 2026-10-01 00:00:00.000000+00 (--start-cursor-ts), below 2026-10-08 00:00:00.000000+00 (--end-cursor-ts) └── commits once, at the end of the read (updated_at isn't read in order)…A selected table whose cursor gets only the other kind’s flags fails plan:
$ sqlload plan --start-cursor-int 2024 erp__orders…└── raw.erp__orders └── reason --start-cursor-int is for integer cursors, but cursor updated_at is timestamp_tz; give this table --start-cursor-ts/--end-cursor-ts, or leave it out of the selection…A date cursor refuses a -ts value with a time of day. A text cursor takes only --start-cursor
and --end-cursor, and those can’t be combined with the typed flags: “–start-cursor/–end-cursor
cannot be combined with the -ts or -int cursor flags”. A Python table whose cursor has no type yet,
before its first load, takes one kind of typed flag only.
Fiscal year tables
Section titled “Fiscal year tables”lookback on an integer cursor counts back that many cursor units. An ERP table
with no timestamp, only fiscal_year and fiscal_period, can reload from the destination’s
latest year with delete_insert. With lookback = 1 it reloads the year before too, so late
adjustments to last year still land after the year-end close:
[sources.erp.tables."public.gl_balances"]description = "General ledger balances, one row per account and fiscal period."write_strategy = "delete_insert"cursor_column = "fiscal_year"lookback = 1$ sqlload plan -v erp__gl_balances…└── raw.erp__gl_balances delete_insert (cursor: fiscal_year) ├── source postgres erp public.gl_balances ├── route read as Arrow -> DuckDB takes Arrow ├── reads fiscal_year >= 2025 (warehouse maximum 2026 minus lookback 1) ├── columns 4 └── commits about every 1 GB, in fiscal_year order (an index leads with it, NULLs first), between distinct values; each commit replaces its own cursor range…Each run deletes and reloads fiscal years 2025 and 2026. Without lookback, it reads from 2026 only,
and a change to FY2025 period 12 stays stale until a run with --start-cursor-int 2025.
plan refuses a lookback that doesn’t fit the cursor, naming the table and the fix: a number on a
date or timestamp cursor (use a duration, such as lookback = "1d"), a duration on an integer
cursor (use a number of cursor units, such as lookback = 1), any lookback on a text cursor, and 0
or less. As with a duration, append takes none, and lookback_from = "now" and lookahead stay for
date and timestamp cursors. --start-cursor and the typed flags win over it. With an integer
batch_size, the windows start at the looked-back value. A Python table takes it the same way:
lookback=1.
Batches
Section titled “Batches”A large load commits along the way instead of all at the end, so a failure keeps what committed and
the next run carries on from there. The exception is ClickHouse, where delete_insert, append
and merge publish once per run (last row below). plan -v of one table shows how it commits, on its
commits line, or batch for a table with neither a cursor nor logged state.
| Table | Commits |
|---|---|
batch_size = "1d" (date or timestamp cursor) or batch_size = 1000 (integer cursor) |
One cursor window at a time, up to 100,000 windows (32,767 for a Snowflake table read through an unload). |
A Postgres table whose cursor_column leads an index, without batch_size |
About every 1 GB, reading in cursor order (NULLs first), only between distinct cursor values. batch_size = "none" opts out. |
Other cursor tables, text cursors, and append without a cursor or logged state |
Once per read, since committing part of an unordered read could skip or duplicate rows. |
| Files sources | At 1,000 files or about 1 GB; under delete_insert a partition is never split. A merge, or delete_insert by replace_key, commits consecutive files together, in order, recording them in the run log; with on_duplicate_keys = "fail" a merge commits each file. |
replace and --reload |
Once, at the end: the new table is swapped in. |
delete_insert into ClickHouse in windows or cursor order, and append and merge |
Once, at the end: everything read is staged and published together. A merge also commits every 10 million waiting rows, and with on_duplicate_keys = "fail" it commits each batch. A stopped run publishes nothing after its last commit, so split a long backfill with --end-cursor. |
With batch_size, the first run needs a start, from cursor_start or --start-cursor. A Postgres
integer cursor without --end-cursor ends at its maximum when plan ran. Other sources can’t report
their maximum, so an integer batch_size there needs --end-cursor. That includes
--reload, which reads the windows from cursor_start (or --start-cursor) up to --end-cursor
into a new table and swaps it in once at the end. The rebuilt table holds only that range; see
Reloading.
$ sqlload plan -v --reload --end-cursor 200000 shop__orders…└── raw.shop__orders recreate from the whole source (--reload)… ├── reads order_id reload, from cursor_start 0, below 200000 (--end-cursor)… └── commits 4 windows of 50000, read one after another into a new table, swapped in once at the endWithout --end-cursor, plan stops and asks for it: “an integer batch needs –end-cursor to know
where the last window ends, with –reload too”.
[sources.app.tables."public.orders"]description = "Orders, one row per order."write_strategy = "merge"unique_key = "{primary_key}"cursor_column = "updated_at"cursor_start = "2026-09-01"batch_size = "7d"lookback = "1h"$ sqlload plan -v… ├── reads updated_at >= 2026-09-01 00:00:00.000+00 (first run, from cursor_start) ├── commits 11 windows of 7days, one commit each ├── route read as Arrow -> DuckDB takes Arrow └── note windows are read in one REPEATABLE READ snapshot, held open on the source for the whole table load (mind idle_in_transaction_session_timeout and vacuum)…$ sqlload load…loaded raw.app__orders 1,000 rows 0.1s…A Python table with batch_size is called once per window, with ctx.cursor_value and
ctx.cursor_end set to it.
Reading windows at once
Section titled “Reading windows at once”A Postgres table with batch_size can read several windows at once while still
committing them one at a time, in window order. Set microbatch_concurrency = true at the top of
the project, then batch_concurrency on the table or its source:
microbatch_concurrency = true
[sources.app.tables."public.events"]description = "Events, one row per event."write_strategy = "delete_insert"cursor_column = "occurred_at"cursor_start = "2026-01-01"batch_size = "1d"batch_concurrency = 4Each window is read over its own connection, and every connection shares one snapshot, so the
windows see the source as it was when the load began and no row is read twice or missed while the
source changes. A window read ahead of its turn is held, masked, in a local folder (the target’s
staging_dir, or the system’s temporary folder) until every window before it has committed; at
most batch_concurrency windows are held at once, counting the one committing, so a read starts
only once the window that many places before it has committed. batch_concurrency is at most 16. A
window that fails stops the load with only the windows before it committed, as a read of one
window at a time would, and the next run carries on from there.
It pays off when reading a window takes longer than committing it. In a local run of 8 daily windows of 400,000 rows from Postgres, 4 at once cut a ClickHouse load from 8.9 s to 6.7 s, while a DuckDB load, whose commits take longer than its reads, gained nothing.
plan -v shows it on the commits line, such as 5 windows of 1day, one commit each, read 4 at once, and notes the connections the read uses. Other sources, and tables that commit no
batch_size windows, read one window at a time; plan warns that the setting is ignored.
Rows outside the window
Section titled “Rows outside the window”A Python table’s function is asked for one window at a time, from ctx.cursor_value
to ctx.cursor_end, and SQLLoad checks the rows it returns against that window by the read’s own
rule: from its start, or after it when ctx.cursor_inclusive is False, and before its end. The
start that lookback or append_cursor_inclusive = true gives is part of the window, so the rows
they read again aren’t outside it. A row whose cursor is NULL follows null_cursor.
Rows outside the window mean the request didn’t ask for what the function was given. Loading rows
after the window’s end would move the cursor past rows not read yet, and loading rows before its
start would load again rows an earlier window read. on_cursor_out_of_range decides what happens:
on_cursor_out_of_range |
Rows outside a window |
|---|---|
fail (default) |
The window doesn’t commit, and the table fails. The message gives how many rows, the window, the range of their cursor values, the first of them and the likely cause. |
skip |
Dropped. The next window reads the rows after the end, and an earlier one read those before the start. The load report says how many each window dropped. |
warn |
Loaded, with a line in the load report. |
plan shows the rule on the table’s reads line. This API takes whole days and returns both of
them:
@shop.table(description="Orders.", cursor_column="updated_at", cursor_start="2026-09-01 00:00:00", batch_size="7d")def orders(ctx): yield fetch(since=ctx.cursor_value.date(), until=ctx.cursor_end.date())$ sqlload plan -v… ├── reads updated_at >= 2026-09-01 00:00:00 (first run, from cursor_start); rows outside a window fail the table; times without an offset in UTC (the default, as timezone is not set)…$ sqlload load --end-cursor "2026-09-15 00:00:00"…failed raw.shop__orders the function returned 24 rows outside the window it was asked for, updated_at >= 2026-09-01 00:00:00+00:00 and < 2026-09-08 00:00:00+00:00: 24 after its end, 2026-09-08 00:00:00+00:00 → 2026-09-08 23:00:00+00:00, the first at row 169 (updated_at 2026-09-08 00:00:00+00:00); all on 2026-09-08, the day the window ends: the API may filter by whole days. Loading them would move the cursor past rows not read yet. If it does, set on_cursor_out_of_range = "skip": the next window reads them.The cause is the first of these that fits the rows outside, with days counted in the table’s
timezone:
| Rows outside | Likely cause |
|---|---|
| Before the start on the day it starts, and after the end on the day it ends | The API filters by whole days. |
All at the window’s end, or at a start it leaves out (ctx.cursor_inclusive is False) |
The API includes that end. |
| All on the day the window ends, or all on the day it starts, before a start after midnight | The API filters by whole days. |
| All within 14 hours of one end of a window of times | The window is sent in another time zone than the API reads it in. |
| Only after the end | The function doesn’t send ctx.cursor_end, or the API ignores it. |
| Otherwise | The API ignores the filter. |
An API that filters by whole days is correct to return the boundary day, so skip suits it: each
window keeps its own rows, and the boundary day loads once, in the window it belongs to.
$ sqlload load --end-cursor "2026-09-15 00:00:00"…loaded raw.shop__orders 336 rows 0.0s ⚠ 24 rows outside the window updated_at >= 2026-09-01 00:00:00+00:00 and < 2026-09-08 00:00:00+00:00: 24 after its end, 2026-09-08 00:00:00+00:00 → 2026-09-08 23:00:00+00:00; all on 2026-09-08, the day the window ends: the API may filter by whole days; skipped (on_cursor_out_of_range = "skip") ⚠ 24 rows outside the window updated_at >= 2026-09-08 00:00:00+00:00 and < 2026-09-15 00:00:00+00:00: 24 after its end, 2026-09-15 00:00:00+00:00 → 2026-09-15 23:00:00+00:00; all on 2026-09-15, the day the window ends: the API may filter by whole days; skipped (on_cursor_out_of_range = "skip")…The report has a line for each of the first three windows with rows outside, and sums the rest
into one, such as ⚠ 1,152 more rows outside 2 later windows. load --json lists the same lines
in each table’s warnings.
Other sources filter their reads themselves, so the check is for Python tables only. plan refuses
on_cursor_out_of_range on a table without a cursor and on other sources.
Times without an offset
Section titled “Times without an offset”On a cursor of times with a time zone, timezone sets the zone that a cursor_start,
--start-cursor or --end-cursor without an offset is read in. A Python table’s
ctx.cursor_value and ctx.cursor_end arrive in that zone, as datetime values with a
zoneinfo.ZoneInfo, so a function can send them to an API that reads times in it. Without
timezone, both are UTC. plan names the zone, and where it came from, on the reads line:
$ sqlload plan -v --start-cursor "2026-09-03 00:00:00" --end-cursor "2026-09-05 00:00:00"… ├── reads updated_at from 2026-09-03 00:00:00 (--start-cursor), below 2026-09-05 00:00:00 (--end-cursor); rows outside a window fail the table; times without an offset in Europe/Paris (the table's timezone)…A cursor of times without a time zone (timestamp_ntz) gets the zone in ctx too. With
timezone = "Europe/Paris", a cursor_start of 2026-03-01 00:00:00 arrives as
datetime(2026, 3, 1, 0, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/Paris')): the same wall-clock
time, now aware. Without timezone, it arrives naive. Python can’t compare an aware datetime with
a naive one, so a function that compares ctx.cursor_value with naive times from the API must make
them alike itself, such as since = ctx.cursor_value.replace(tzinfo=None).
A time that doesn’t exist in the zone, because its clocks go forward past it, fails plan. A time
the zone has twice, when its clocks go back, is the earlier of the two. A date cursor has no zone,
and lookahead, lookback_from = "now" and the end of today are counted in UTC.
Logged state
Section titled “Logged state”Some positions aren’t in the data, such as an API’s sync token. A Python table with
state="logged" keeps its position in ctx.state, and SQLLoad records it in an append-only run log
with each commit. Most projects never need it: a table with a cursor_column finds its position in
the loaded data.
@shop.table(write_strategy="append", state="logged")def events(ctx: sl.Context): """Shop events, read page by page with a sync token.""" token = ctx.state while True: page = fetch_events(since=token) yield from page.items token = page.next_token or token yield sl.checkpoint(token) if not page.has_more: breakctx.stateis the position the last successful run left:Noneon the first run, after--reload, or aftersqlload logged-state reset --clear.yield sl.checkpoint(token)after a page’s rows marks exactly what those rows cover. A run that fails part-way resumes from the last committed checkpoint without loading any row twice.sl.checkpointneedsstate="logged"and a JSON value.- Rows yielded after the last checkpoint load again on the next run, unless the function leaves
the final position in
ctx.state. Once a function yields a checkpoint, only checkpoints move the position during the run; a value it leaves inctx.statewhen it finishes still becomes the final one. sl.checkpoint(None)clears the position, so the next run starts from the beginning. For an API whose last page has no next token, keep the last real one, asor tokendoes above.- Without checkpoints, assign
ctx.stateonce per page. Each commit records the valuectx.statehad one assignment before its current one, so a run that fails part-way never loses rows, but underappendthe next run may load up to about two pages again. Assigning more than once per page can lose rows after a crash.
The run log is _sqlload_runs in the table’s schema, or objects under <table folder>/_sqlload/runs/
on a files target. It’s written in the same transaction as the data where the warehouse allows it,
so a failed load never moves the position. Beside it, a DuckDB or MotherDuck schema may hold
_sqlload_unfinished, which marks appends that stopped part-way; see
Unfinished appends.
A logged table with a cursor_column also logs the data’s cursor. When the log and the data
disagree, the data wins, and the load appends a visible reconciliation. Deleting the log is safe: the
next run reads as a stateless one would.
Inspecting and correcting the log
Section titled “Inspecting and correcting the log”$ sqlload logged-state showraw.shop__events state 4 (run 54ab366a-bca1-4088-9723-4c6d1723ad02 at 2026-11-09T18:02:47.844103Z) 2026-11-09T18:02:47.552256Z e1bf5051-3333-4fdd-aa31-18bf2d74a51c run - -> -, state 2 6 rows 2026-11-09T18:02:47.844103Z 54ab366a-bca1-4088-9723-4c6d1723ad02 run - -> -, state 4 6 rowslogged-state verify compares the logged cursor with the data. logged-state reconcile --yes
adopts the data’s position where they disagree. logged-state reset --to VALUE --yes sets the next
position, and --clear forgets it. Nothing is ever deleted from the log; each correction is
appended. load --reload also starts a logged table over.
A record SQLLoad can’t read, because it’s corrupt or written by a newer version, blocks only its
own table. logged-state show lists it, and a reset ... --yes starts a new position after it.
See sqlload logged-state for every subcommand and flag.
Unfinished appends
Section titled “Unfinished appends”A DuckDB or MotherDuck table can commit one load in
pieces when its rows are too large for one commit. A rerun
of a merge or delete_insert replaces what a stopped load’s pieces wrote, but an append would
add those rows again. So an append’s first piece also writes a row to _sqlload_unfinished, in
the run log’s schema, in the same transaction. Every append into DuckDB or MotherDuck under a
memory budget creates that table when it starts, so it’s there, empty, even when no load needed
pieces. With memory_limit = "off" nothing is cut into pieces,
and an append neither needs nor creates it. A row holds the
table, the load’s id, the column holding it (_sqlload_load_id) and when the load started. The
load’s last commit removes the row in its own transaction, so a crash between them can’t leave
rows without a marker, or a marker without rows.
The next load that loads that table, after it plans and before it loads, deletes the table’s rows
of each marked load, the load’s records in _sqlload_runs and the marker, in one transaction. It
then plans again, from where the table was before that load, and warns. Only the markers of the
tables it loads are read, since on MotherDuck another process may be loading other tables of the
same database at the time; don’t run two loads of one table at once:
$ sqlload loadWarnings (1)└── raw.attachments: removed the rows of load 5a401302-7d41-4426-83d0-e1cb1168174d, which stopped before its last commit, so this load reads from before it
✓ Plan complete 2 to load (sqlload plan shows the tree)
loaded raw.customers 2 rows 0.0sloaded raw.attachments 300 rows 4.1sOnly the marked load’s rows go; rows of other loads stay.