Adapt the format classes to the current code base after merging master:
the `IOutputFormat` and `IRowInputFormat` constructors now take a
`SharedHeader`, `IOutputFormat::flush` is no longer virtual, and format
settings moved to `FormatFactorySettings.h`.

Address review feedback from the original review:

- Move the read-only VFS implementation out of `SQLiteInputVFS.h` and into
  `SQLiteInputVFS.cpp`, with the global state in an anonymous namespace and
  the registration guarded by `std::call_once`, so the VFS is registered
  exactly once even under concurrent reads.
- Pass the `arrow::io::RandomAccessFile` pointer to the VFS as a portable
  lowercase hex string via `getHexUIntLowercase`/`unhexUInt`, instead of
  relying on platform-dependent pointer formatting with `operator<<`.
- In `SQLiteOutputFormat`, throw a clear exception when the output is not a
  regular file: only writing to files is supported, and `fstat` is used to
  rule out pipes, sockets and terminals.
- Build the rows in `SQLiteOutputFormat` with a prepared statement and
  parameter binding instead of concatenating SQL text, which avoids quoting
  and escaping bugs, and wrap the inserts in a single transaction.
- Handle SQL `NULL` on input by checking `sqlite3_column_type` and reading
  the exact byte length with `sqlite3_column_bytes`.

Add a stateless test that round-trips a database through the output and
input formats, verifies the produced file is a real SQLite database, reads
a database created by the `sqlite3` CLI by table name, and checks that
writing to a non-file is rejected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

ClickHouse type names such as `Nullable(UInt64)` are not valid SQLite type
names, so creating the `result` table with them failed with a syntax error.
SQLite is dynamically typed, so the columns are now declared without a type:
this gives them no affinity and the values bound as text are stored as is,
which round-trips faithfully.

Also fix the `sqlite3` CLI quoting in the stateless test and add the
reference file. Verified end to end with a freshly built binary:
write via the output format, read back via the input format (including
NULLs), cross-check with the `sqlite3` CLI, read by table name, and reject
writing to a non-file.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The input format used `arrow::io::RandomAccessFile` (via `asArrowFile`)
purely as a seekable byte source for the read-only SQLite VFS. This coupled
the `SQLite` format to Arrow, which is disabled on some platforms, so the
build failed on `amd_freebsd`, `riscv64` and `loongarch64` with
`'arrow/io/interfaces.h' file not found`.

Replace the Arrow dependency with ClickHouse's own `SeekableReadBuffer`: the
VFS now reads through `seek`/`read` and reports the size cached in a small
`SQLiteReadSource`. When the input buffer is seekable and its size is known,
the database is read with true random access; otherwise (a pipe, a stream of
unknown length) it is loaded into a `ReadBufferFromOwnString`.

Also fix two NULL-handling issues in `readRow`:
- A SQLite `TEXT` value equal to the textual null marker (e.g. `NULL` or
  `ᴺᵁᴸᴸ`) in a `Nullable` column was mistaken for SQL `NULL`, because
  `deserializeWholeText` on a `Nullable` serialization treats the marker as
  null. Known-non-null values are now deserialized through the nested
  (non-nullable) serialization.
- SQL `NULL` in a non-nullable column silently became the type default,
  ignoring `input_format_null_as_default`. It now throws `INCORRECT_DATA`
  when the setting is disabled, matching other input formats.

The stateless test was renumbered to `04326` (the `04309` prefix collided
with tests merged from `master`) and extended with both NULL cases.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

`03251_insert_sparse_all_formats` and `02187_async_inserts_all_formats`
iterate over every format that is both input and output and round-trip data
through an HTTP socket / async-insert pipe. The `SQLite` format cannot
participate: its output requires a regular, seekable file (writing to a pipe
or socket throws `NOT_IMPLEMENTED`) and reading requires random access, so it
cannot stream. Add `SQLite` to the existing exclusion lists, next to the
other formats that cannot do a generic streaming round-trip.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

- Rethrow the exception saved by the VFS read callback in the format's error
  paths, so the original error is reported instead of a generic SQLite one.
- Handle `LowCardinality(Nullable)` columns: use
  `isNullableOrLowCardinalityNullable` instead of `isNullable`, insert SQL NULL
  as NULL, and deserialize known-non-NULL values with the non-nullable nested
  serialization (a text value equal to the textual null marker is not mistaken
  for SQL NULL).
- When `input_format_null_as_default` consumes a NULL for a non-nullable
  column, mark the column as not read in `RowReadExtension`, so that
  `AddingDefaultsTransform` computes the table DEFAULT expression for it.
- Honor `input_format_allow_seeks` (`FormatSettings::seekable_read`): when
  disabled, buffer the whole database in memory instead of seeking.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

`sqlite3_open_v2` can leave the database handle non-null even when it
returns an error, and that handle still has to be released with
`sqlite3_close_v2`. Previously the pointer was wrapped into the owning
`db` only after the status check, so every failed open leaked the
connection object; malformed input files could hit this path
repeatedly. Wrap the handle into `db` immediately after the call so the
connection is released on every path. The same fix is applied in both
`SQLiteInputFormat` and `SQLiteOutputFormat`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

`SQLiteOutputFormat::writePrefix` is not just a prefix: it opens the SQLite
connection, creates the `result` table, starts the transaction and prepares the
insert statement. Because the format was registered without
`markFormatHasNoAppendSupport`, `StorageFile` treated an existing non-empty
`.db` file as appendable and called `doNotWritePrefix` before writing, so the
next `consume` ran with `db`/`insert_stmt` unset and a second
`INSERT INTO FUNCTION file(..., SQLite)` against the same file failed in a
confusing way.

Mark `SQLite` as not append-supported, like `Parquet`/`ORC`, so `StorageFile`
produces the standard `CANNOT_APPEND_TO_FILE` error. Add a regression to
`04326_sqlite_format_input_output` with two inserts into the same file.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>