Replace fragile null-check and materializer-based inference of
the Parquet export mode with explicit enum dispatch in both HTTP
and SQL export paths.

- Add TABLE_READER enum value for direct table reference exports
  (COPY tablename TO), eliminating null as a sentinel
- Store ParquetExportMode on HTTPSerialParquetExporter, set via
  setExportMode() before process(), switch on it explicitly
- Replace if/else chain in SQLSerialParquetExporter.process()
  with exhaustive switch
- Remove isPageFrameBacked field/method from RecordToColumnBuffers
  (was only used for the fragile inference)
- Remove @nullable from CopyExportRequestTask.exportMode since
  all paths now set a concrete enum value

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Move ownership transfer of pageFrameCursor, materializer, and
materializerColumnData from state to exporter to after setUp()
and setupXxxExport() succeed. Previously, state fields were
nulled before these calls, so if setUp() threw (e.g., from the
native createStreamingParquetWriter call), the resources would
be orphaned — state couldn't free them (fields already null)
and the exporter hadn't received them yet.

Also add a comment in CopyExportRequestTask.clear() documenting
why pageFrameCursor is nulled without Misc.free(): ownership
belongs to HTTPSerialParquetExporter or ExportQueryProcessorState.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

For streaming export modes (DIRECT_PAGE_FRAME, PAGE_FRAME_BACKED,
CURSOR_BASED), the SELECT query was compiled twice: once in
CopyExportFactory.getCursor() to call determineExportMode(), and
again in SQLSerialParquetExporter.processStreamingExport(). Pass
the RecordCursorFactory from the first compilation through the
ring queue task to the second location, removing the redundant
SqlCompiler.compile() call. The factory is transferred through
the ring queue using a null-transfer pattern to prevent
double-free on task.clear().

Also fix a latent bug in the partition-mismatch path: when
COPY specifies a different PARTITION BY than the table,
determineExportMode() was skipped, leaving exportMode at its
initial TABLE_READER value. The else branch now explicitly sets
TEMP_TABLE for re-partitioning.

Rename the two RecordCursorFactory fields in CopyExportRequestTask
from "factory"/"compiledFactory" to "tempTableFactory"/"selectFactory"
to clarify which export path each serves.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The two setUp() overloads duplicated column name/metadata
serialization and the createStreamingParquetWriter() call. The
1-arg overload now delegates to the 3-arg version with null
pfc and baseColumnMap, and the 3-arg version guards the symbol
table handling with a null check on baseColumnMap.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

RecordToColumnBuffers.resetBuffers() used to truncate native memory
buffers in place between page frames. Rust's pending_partitions still
held raw pointers to the old data, so when the next frame overwrote
the same addresses, Rust read corrupted data and panicked with
"range end index N out of range for slice of length M".

The fix replaces truncate-in-place with pin-and-replace: when buffers
contain data, they are moved to pinned lists and fresh buffers are
allocated. After a row group flush, an inFlightRows check determines
when all pinned partitions have been drained by Rust, and the pinned
buffers are freed. This applies to all four export loops (HTTP and SQL,
PAGE_FRAME_BACKED and CURSOR_BASED).

Tests are extended to cover var-size computed columns (STRING, VARCHAR,
ARRAY) in multi-row-group scenarios across all export paths, and
descending ORDER BY is forced to CURSOR_BASED mode since page frame
cursors cannot reverse row order within partitions.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

- Fix createOp use-after-free in CopyExportRequestJob: transfer
  ownership out of queue task before clear(), mirroring the existing
  selectFactory pattern.
- Fix createOp leak in CopyExportFactory when the export queue is
  full: hoist variable above try block and free in outer finally.
- Fix RecordToColumnBuffers leak in ExportQueryProcessor CURSOR_BASED
  setup: wrap in try-catch matching the PAGE_FRAME_BACKED path.
- Fix createParquetOp not freed in ExportQueryProcessorState.close().
- Fix createOp, tempTableFactory, pageFrameCursor not freed in
  CopyExportRequestTask.close().
- Fix factory not freed on PeerIsSlowToReadException in
  HTTPSerialParquetExporter.process().

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Add a dense int[] of computed column indices to avoid scanning
all outputColumnCount columns in hot loops that only need to
visit computed columns. For wide tables with few computed
columns (e.g., 100 columns, 2 computed), the inner loop in
materializeComputedColumns() was wasting ~100M branch iterations
per frame doing no work.

The computedColumnIndices array is built once during setUp() and
setUpPageFrameBacked(), then used in materializeComputedColumns()
and both loops in resetBuffers() (buffer pinning/reallocation
and STRING offset initialization).

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Replace per-row metadata and function lookups in
materializeComputedColumns() and buildColumnDataFromCursor()
with flat arrays populated once at setup time:

- computedOutputTypes[]: column types from adjustedMetadata
- computedFunctions[]: Function instances (page-frame path)
- computedIsSymbolToString[]: symbol-to-string conversion flag

This eliminates three repeated indirections per row per column:
adjustedMetadata.getColumnType() (3 dereferences through ObjList
and TableColumnMetadata), functions.getQuick() (2 dereferences),
and func.getType() (virtual dispatch). Also applies the same
optimization to resetBuffers() where it re-allocates after
pinning.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The three HTTP streaming export methods were logging at
INFO level on every frame/batch. For tables with many
partitions this produces hundreds of log lines per export.

Demote the six per-frame and resume progress messages to
DEBUG, keeping INFO only for start/completion messages.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Instead of freeing MemoryCARWImpl instances when pinned buffers are
released after a row group flush, return them to a reuse pool.
Subsequent frames draw from the pool via obtainBuffer(), which
truncates and reuses an existing buffer or allocates a new one only
when the pool is empty.

This eliminates short-lived Java object allocation in steady state.
For a 100-partition export with 5 computed columns, it avoids ~1000
MemoryCARWImpl allocations. The pool is naturally bounded by peak
usage (framesPerRowGroup * buffersPerFrame) and properly freed in
clear()/close().

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Pre-allocate RecordToColumnBuffers and DirectLongList as final
fields instead of creating them fresh on every export request.

HTTP path (ExportQueryProcessorState): materializer and
materializerColumnData are now final fields initialized once.
clear() calls .clear() on them; close() calls Misc.free().
ExportQueryProcessor no longer wraps setUp() in try-catch with
fresh allocation. copyQueryToParquetFile() no longer nulls out
the materializer fields since ownership stays with the state.
HTTPSerialParquetExporter now borrows these references instead
of owning them, so clearExportResources() nulls rather than
freeing them.

COPY path (SQLSerialParquetExporter): streamBuffers and
streamColumnData are new final fields reused across exports.
processStreamingExport() calls clear() instead of using
try-with-resources, and processCursorExport() uses the fields
directly instead of receiving them as parameters.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Replace the per-export lambda and long[1] array with a reusable
static nested FileWriteCallback class. A single instance is held
in a final field and re-initialized via of(ff, fd) for each
export, eliminating the heap allocation and lambda capture per
row group.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Replace six per-request array allocations in
RecordToColumnBuffers with pre-allocated final
collection fields (IntList, BoolList, ObjList).
The setUp() methods now use setPos()/setQuick()
to resize and populate, and clear() resets size
without freeing backing arrays.

Also convert the local int[] identityMap in
SQLSerialParquetExporter to a reusable IntList
field, and update CopyExportRequestTask.setUp()
to accept IntList instead of int[].

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The clear() method nulled pageFrameCursor unconditionally before
the tempTableFactory check, so the temp-table path (which owns
the cursor) would try to free an already-null reference, leaking
the native resource. Move the ownership check first so the cursor
is properly freed when tempTableFactory is non-null, and only
null-without-freeing in the non-owning paths.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Add comments at both PAGE_FRAME_BACKED cast sites in
ExportQueryProcessor explaining why the unchecked cast to
VirtualRecordCursorFactory is safe: determineExportMode() only
returns PAGE_FRAME_BACKED when the unwrapped factory is already
verified to be an instanceof VirtualRecordCursorFactory.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Add a class-level javadoc and per-value comments explaining when
each export mode is used and what it implies for how data flows
into the Parquet writer.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

processCursorStreamExport() and processPageFrameStreamExport()
in HTTPSerialParquetExporter shared nearly identical loop bodies
(writeHybridFrame, in-flight tracking, buffer pinning). Merge
them into processHybridStreamExport() with a boolean branch for
the data-source difference and partition release.

Apply the same merge in SQLSerialParquetExporter: the inline
PAGE_FRAME_BACKED block and processCursorExport() become a
single processHybridExport() method.

Net -43 lines with no behavioral change.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

                                                                                                                                                                                                        
The old name described the mechanism (records → column buffers)                                                                                                                                       
rather than the purpose. The new name reflects the class's key                                                                                                                                      
design: hybrid export where pass-through columns use zero-copy                                                                                                                                        
page frame pointers while computed columns are materialized into                                                                                                                                      
buffers.

Updated all 7 referencing files. Pure rename, no logic changes.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Extract the inner frame-drain loop that was duplicated between
HTTPSerialParquetExporter.processHybridStreamExport() and
SQLSerialParquetExporter.processHybridExport() into a shared
protected method drainHybridFrames() on the base class.

The two loops were identical in structure — fetch frame, materialize
columns, write hybrid frame, track in-flight rows, release pinned
buffers after row group flush — but differed only in which fields
they operated on. The new method takes the varying pieces (exporter,
materializer, column data list, pfc/cursor) as parameters. The
pfc != null check replaces the former isPageFrameBacked boolean
with no change in hot-path cost.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

When setUpPageFrameBacked() throws SqlException (via
Function.init()), the exception escapes the inner try block
and is caught by the outer SqlException handler. That handler
sends the error response but does not free the page frame
cursor already assigned to state.pageFrameCursor, leaking it
until the HTTP connection resets.

Add state.clear() after syntaxError() in the outer
SqlException catch block to immediately release the cursor,
materializer, and factory resources.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The test expected only "timeout, query aborted" but there are
two racing code paths when the circuit breaker trips during
PAGE_FRAME_BACKED parquet export: the page-frame factory throws
"timeout, query aborted" while the HTTP exporter throws
"cancelled by user". Accept either message as a valid outcome.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Eliminate the intermediate `impl` variable for
CreateTableOperationImpl by assigning directly to `createOp`
(narrowed from the interface type). This resolves the
AutoCloseableResource warning about a resource not being in a
try-with-resources block.

Remove redundant Misc.free() calls from the inner catch blocks,
since the outer finally block already handles freeing both
`selectFactory` and `createOp` on all exception paths. This also
resolves the ConstantValue warning where `selectFactory` was
always null at the point of the inner catch.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The test expected only "peer disconnect" when the server aborts
mid-stream due to timeout, but the client can also receive a
"malformed chunk" error when chunked transfer encoding is
interrupted. Accept both error messages as valid outcomes.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Apply the same fix from aa0850a to the three remaining
test methods that assert on HttpClientException messages
during server-side abort. When chunked transfer encoding
is interrupted, the client may receive either "peer
disconnect" or "malformed chunk", so both must be accepted.

Affected methods:
- testParquetExportCancel
- testParquetExportTimeout
- testParquetExportTimeoutNodelay

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The test was not exercising the temp table export path because
the streaming export path (introduced on this branch) handled
the query without creating a temp table. Restore the original
FilesFacade mmap-failure injection from master, and change the
table schema to include a BINARY column with a WHERE clause to
force the TEMP_TABLE export mode. This ensures the test actually
triggers temp table creation, mmap failure, and cleanup.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Move determineExportMode(), hasComputedBinaryColumn(), and
unwrapFactory() from HybridColumnMaterializer to ParquetExportMode.
These are general-purpose dispatch methods that determine which
export strategy to use — they don't belong on one specific
strategy implementation.

Also fold the descending-order fallback (PAGE_FRAME_BACKED to
CURSOR_BASED) into determineExportMode() via a new isDescending
parameter, eliminating duplicated post-hoc fixups in
ExportQueryProcessor.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The three setUp() overloads in StreamPartitionParquetExporter
shared ~80% of their structure (buffer init, column iteration,
SYMBOL handling, createStreamingParquetWriter call). The
parameterless setUp() was a full copy of the three-arg version
with slightly different SYMBOL resolution and writer index logic.

Collapse into a single implementation that the other two delegate
to. The key insight is that meta.getWriterIndex(i) already returns
the correct value for all paths: the physical writer column index
for table metadata, and i for GenericRecordMetadata (hybrid/cursor
paths). The baseColumnMap nullity distinguishes "all columns are
real table columns" from "only mapped columns are pass-through".

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Both HTTPSerialParquetExporter.process() and
SQLSerialParquetExporter.process() had nearly identical finally
blocks for dropping the temporary table used in TEMP_TABLE export
mode: set phase, update status, resolve table token, drop table,
and handle CairoException/Throwable with identical log-and-update
logic.

Extract this into a protected dropTempTable() method on the base
class. The SQL subclass previously used its fromParquet Path field
for the drop call; the shared method uses Path.getThreadLocal()
instead, which is equivalent since dropTableOrViewOrMatView
consumes the path immediately. The HTTP-specific
freeOwnedPageFrameCursor() call remains at the call site since it
is not part of the drop logic.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Extract shared state and methods from HTTPSerialParquetExporter
into a new abstract BaseParquetExporter class. Both
HTTPSerialParquetExporter and SQLSerialParquetExporter now extend
this base directly.

The base class holds fields (copyExportContext,
insertSelectReporter, sqlExecutionContext, circuitBreaker, task)
and methods (of(), dropTempTable(), drainHybridFrames()) that both
export paths need. HTTP-specific streaming state (exportMode,
fullCursor, materializer, materializerColumnData, streamingPfc)
stays in HTTPSerialParquetExporter where it belongs.

This removes the awkward dependency where SQLSerialParquetExporter
extended HTTPSerialParquetExporter despite not using any of its
HTTP-specific fields or methods.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

The identity column map [0, 1, 2, ..., n-1] was rebuilt on every
DIRECT_PAGE_FRAME export invocation. Since the field is an instance
variable and its contents are deterministic for a given size, guard
the rebuild with a size check so it is only constructed once per
distinct column count.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Replace three separate catch blocks (SqlException, CairoException,
Throwable) in HTTPSerialParquetExporter.process() with a single
catch (Throwable) that uses pattern variables to extract the error
message and errno per type. All three blocks performed identical
cleanup: log, free factory, clear export resources, update status,
and rethrow — differing only in how they obtained the message and
errno.

Co-Authored-By: Claude Opus 4.6 <[email protected]>