Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
38 commits
Select commit Hold shift + click to select a range
de2cd22
Complete Volume transfers through the native backend
aakash-saravanan-db Nov 13, 2026
82ca1e1
Pin the native source for Volume completion
aakash-saravanan-db Nov 14, 2026
277929b
Select the Windows-compatible Volume kernel
aakash-saravanan-db Nov 14, 2026
d90432b
Pin native Volume storage retry and terminal response fixes
aakash-saravanan-db Nov 14, 2026
a87a356
Preserve native staging error causes in dispatch checks
aakash-saravanan-db Nov 14, 2026
d445d87
Apply session validity policy by Volume failure origin
aakash-saravanan-db Nov 14, 2026
84ed9ee
Invalidate fatal instruction sessions before returning cancellation
aakash-saravanan-db Nov 14, 2026
23a569f
build(kernel): select corrected Volume completion
aakash-saravanan-db Nov 14, 2026
9c710a8
build: select native Volume cancellation and error handling
aakash-saravanan-db Nov 15, 2026
ae67199
build: use native root authorization fix
aakash-saravanan-db Nov 15, 2026
85738b8
build: update kernel source for replayable uploads
aakash-saravanan-db Nov 15, 2026
32b0a16
build: update kernel for local stream close
aakash-saravanan-db Nov 15, 2026
8d0c2c3
fix(volume): select replayable file uploads and tighten validation
aakash-saravanan-db Nov 15, 2026
4c5cc0d
fix(kernel): use permission-preserving Volume downloads
aakash-saravanan-db Nov 16, 2026
e37844b
fix(kernel): remove obsolete staging rejection example
aakash-saravanan-db Nov 16, 2026
aec3416
Pin kernel with statement lifecycle cleanup
aakash-saravanan-db Nov 16, 2026
b93dacd
build: select kernel with async result cleanup
aakash-saravanan-db Nov 16, 2026
c1afd7c
build: select kernel with Volume instruction error telemetry
aakash-saravanan-db Nov 16, 2026
a2b3600
build: pin kernel with complete Volume instruction handling
aakash-saravanan-db Nov 16, 2026
cfae119
build: use corrected kernel volume completion
aakash-saravanan-db Nov 17, 2026
71e111f
build: select kernel with origin-safe Volume redirects
aakash-saravanan-db Nov 17, 2026
f54641f
build: select kernel with normalized upload lengths
aakash-saravanan-db Nov 17, 2026
9c48227
docs: keep unreleased changelog entries in one list
aakash-saravanan-db Nov 17, 2026
c7553ab
build: pin kernel completion telemetry correction
aakash-saravanan-db Nov 17, 2026
5b61b68
Scope Volume timeout docs and isolate failure-origin fixture
aakash-saravanan-db Nov 18, 2026
6766d95
build: select kernel with restricted-directory GET support
aakash-saravanan-db Nov 18, 2026
233f91a
build: pin kernel with bounded symlink resolution
aakash-saravanan-db Nov 18, 2026
6cdd531
refactor(volume): use typed completion outcomes
aakash-saravanan-db Nov 19, 2026
caf4afc
build: select updated Volume kernel
aakash-saravanan-db Nov 19, 2026
e3930d5
fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
72e9816
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
deed114
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
1706da4
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
af3a000
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
b296100
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
82bf2e4
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 20, 2026
c0c9301
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 21, 2026
ef61222
fixup! fix(volume): enforce native staging dispatch and error policy
aakash-saravanan-db Nov 22, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@
- **Behavior change:** Report declared DECIMAL precision and scale through `sql.ColumnType.DecimalSize()` on Thrift and SEA, including zero-row results. Tools such as ORM migrators can now act on these qualifiers (databricks/databricks-sql-go#500).
- **Behavior change:** Support Arrow TIME results on Thrift and SEA as UTC `time.Time` values on `0001-01-01`, preserving precision and using clock-only nested JSON. TIME metadata now reports `TIME`/`time.Time` with no length, including empty and NULL-only results; previously Thrift reported `STRING`/`string` with unbounded length, and SEA reported an empty name with `*interface{}` (databricks/databricks-sql-go#505).
- **Behavior change:** Explicit `WithMaxDownloadThreads` / `maxDownloadThreads` settings tuned for Thrift also control kernel buffering and can change memory use and throughput. The kernel window defaults to 16 when unset; explicit chunk-setting overrides take precedence.
- **Behavior change:** Support Volume PUT/GET/REMOVE through kernel ExecContext with staging roots, including resolved-symlink authorization and context cancellation. QueryContext retains raw instructions (databricks/databricks-sql-go#560).
- **Breaking change:** Upgrade Apache Arrow Go from v12 to v18.8.0 (`github.com/apache/arrow-go/v18`). The public `rows.ArrowBatchIterator` now uses v18 `arrow.RecordBatch` and `*arrow.Schema` types; callers using Arrow batches must migrate their Arrow imports and dependent code. This requires a major driver release (v2.0.0), including a `/v2` driver module path before publication.
- Fix CloudFetch reads failing with `row number 0 is not contained in any arrow batch: EOF` when `WithMaxDownloadThreads` / `maxDownloadThreads` is 0 or negative. Such values now log a warning and use the default of 10 (databricks/databricks-sql-go#439).
- **Behavior change:** On the Thrift backend, `ExecuteStatement` is now retried (per `WithRetries`) when the connection to the server or proxy can't be opened, for example connection refused or a connect timeout, because the statement was never sent. Failures after the connection exists are still not retried, so a statement never runs twice. With default retry settings, a refused connection now fails after about 15 seconds instead of immediately (databricks/databricks-sql-go#423).
Expand Down
2 changes: 1 addition & 1 deletion KERNEL_REV
Original file line number Diff line number Diff line change
@@ -1 +1 @@
0b5d0edfed32c0745d5abc2468fc3070e2eb2a17
23e45bafa9b0d1688fbffa5ecc975e1d91f40f01
6 changes: 6 additions & 0 deletions connection.go
Original file line number Diff line number Diff line change
Expand Up @@ -821,6 +821,12 @@ func (c *conn) execStagingOperation(
}

if len(driverctx.StagingPathsFromContext(ctx)) != 0 {
if native, ok := op.(backend.StagingCompleter); ok {
if err := native.CompleteStaging(ctx); err != nil {
return dbsqlerrint.NewDriverError(ctx, "error performing staging operation", err)
}
return nil
}
// Telemetry callback for staging operation row fetching (chunk timing not tracked for staging ops).
telemetryUpdate := func(chunkCount int, bytesDownloaded int64, chunkIndex int, chunkLatencyMs int64, totalChunksPresent int32) {
if c.telemetry != nil {
Expand Down
42 changes: 42 additions & 0 deletions connection_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,9 @@ import (
"github.com/apache/thrift/lib/go/thrift"
"github.com/pkg/errors"

"github.com/databricks/databricks-sql-go/driverctx"
dbsqlerr "github.com/databricks/databricks-sql-go/errors"
"github.com/databricks/databricks-sql-go/internal/backend"
thriftbackend "github.com/databricks/databricks-sql-go/internal/backend/thrift"
"github.com/databricks/databricks-sql-go/internal/cli_service"
"github.com/databricks/databricks-sql-go/internal/client"
Expand Down Expand Up @@ -1074,3 +1076,43 @@ func TestConn_handleStagingRetry(t *testing.T) {
assert.Less(t, elapsed, 2*time.Second, "context cancel should abort PUT retry backoff promptly")
})
}

type nativeStagingStub struct {
backend.Operation
marked bool
completed bool
err error
}

func (o *nativeStagingStub) StatementID() string { return "volume-test" }
func (o *nativeStagingStub) IsStaging(context.Context) (bool, error) { return o.marked, nil }
func (o *nativeStagingStub) CompleteStaging(context.Context) error { o.completed = true; return o.err }

func TestConnNativeStagingDispatch(t *testing.T) {
Comment thread
peco-review-bot[bot] marked this conversation as resolved.
Resolved
completionErr := errors.New("native completion failed")
for _, tc := range []struct {
name string
marked, roots, wantCall, wantError bool
completionErr error
}{
{name: "missing roots", marked: true, wantError: true},
{name: "unmarked operation with roots", roots: true},
{name: "native completion", marked: true, roots: true, wantCall: true},
{name: "native completion error", marked: true, roots: true, wantCall: true, wantError: true, completionErr: completionErr},
} {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
if tc.roots {
ctx = driverctx.NewContextWithStagingInfo(ctx, []string{t.TempDir()})
}
op := &nativeStagingStub{marked: tc.marked, err: tc.completionErr}
err := (&conn{}).execStagingOperation(op, ctx)
assert.Equal(t, tc.wantError, err != nil)
assert.Equal(t, tc.wantCall, op.completed)
if tc.completionErr != nil {
assert.ErrorIs(t, err, dbsqlerr.DriverError)
assert.ErrorIs(t, err, tc.completionErr)
}
})
}
}
15 changes: 11 additions & 4 deletions doc.go
Original file line number Diff line number Diff line change
Expand Up @@ -227,13 +227,13 @@ RetryWaitMin / RetryWaitMax / RetryMax, including the disable form, forwarded to
kernel's HTTP retry config); and the TLS, proxy, and session-conf (query tags,
statement timeout, time zone) options. Federated token providers use one token snapshot
during setup. Nothing is silently ignored: WithTimeout and token-provider / external /
static authenticators are rejected at connect; staging (PUT/GET/REMOVE on a
Unity Catalog volume) is rejected at execute. WithMaxRows is accepted but inert (the
static authenticators are rejected at connect. WithMaxRows is accepted but inert (the
kernel manages fetching below the C ABI).

Kernel HTTP requests inherit the driver's ClientTimeout (900s by default). If
Kernel SQL HTTP requests inherit the driver's ClientTimeout (900s by default). If
that value is zero, the kernel uses its own 120s default; zero is neither
unlimited nor an immediate timeout.
unlimited nor an immediate timeout. Use a context deadline to bound Volume storage
transfers; ClientTimeout does not apply to storage requests.

OAuth U2M is interactive: on a cache miss, connecting launches the system browser and
blocks until login completes or the kernel's ~120s callback timeout expires. Because
Expand Down Expand Up @@ -371,6 +371,13 @@ After doing so, you can execute staging operations using this context using the

_, err1 := db.ExecContext(ctx, `PUT 'staging/file.csv' INTO '/Volumes/main/staging_test/e2etests/file.csv' OVERWRITE`)

With the kernel backend, ExecContext completes the transfer and reports zero
rows affected. QueryContext returns raw instruction rows without file effects.
Both the requested local path and its resolved symlink target must remain
within the configured staging roots. Symlinks within those roots are permitted;
escapes are rejected.
The staging context is required for REMOVE as well as PUT and GET.

# Errors

There are three error types exposed via dbsql/errors
Expand Down
10 changes: 0 additions & 10 deletions examples/kernel/main.go
Original file line number Diff line number Diff line change
Expand Up @@ -87,14 +87,4 @@ func main() {
log.Fatalf("query: %v", err)
}
fmt.Printf("server version: %s\n", version)

// Options the kernel can't honor are rejected with an error wrapping
// ErrNotSupportedByKernel, never silently ignored. Staging (PUT/GET/REMOVE on a
// Unity Catalog volume) is one such feature, rejected at execute.
_, err = db.ExecContext(ctx, "PUT '/tmp/local.csv' INTO '/Volumes/main/default/vol/f.csv' OVERWRITE")
if errors.Is(err, dbsqlerr.ErrNotSupportedByKernel) {
fmt.Println("staging is not supported on the kernel backend (use Thrift for staging)")
} else if err != nil {
fmt.Printf("staging: %v\n", err)
}
}
6 changes: 6 additions & 0 deletions internal/backend/backend.go
Original file line number Diff line number Diff line change
Expand Up @@ -114,6 +114,12 @@ type ResultFormatReporter interface {
ResultFormat() string
}

// StagingCompleter is implemented by operations that run the staging (Volume)
// file transfer themselves.
type StagingCompleter interface {
CompleteStaging(context.Context) error
}

// ExecRequest is a backend-neutral statement-execution request. Per-backend wire
// options (Arrow flags, CloudFetch, direct results, query tags, timeouts) are
// derived from the config and context inside the backend implementation.
Expand Down
15 changes: 1 addition & 14 deletions internal/backend/kernel/backend.go
Original file line number Diff line number Diff line change
Expand Up @@ -65,14 +65,12 @@ import "C"

import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"sync/atomic"
"time"

dbsqlerr "github.com/databricks/databricks-sql-go/errors"
"github.com/databricks/databricks-sql-go/internal/backend"
)

Expand Down Expand Up @@ -893,8 +891,7 @@ func (k *KernelBackend) markSessionDead() { k.valid = false }
// Uses errors.As, not a bare type assertion, so it still fires if a caller wraps
// the KernelError before passing it here.
func (k *KernelBackend) evictIfSessionFatal(err error) {
var ke *KernelError
if errors.As(err, &ke) && isSessionFatal(ke.Code) {
if isSessionFatal(err) {
k.markSessionDead()
}
}
Expand All @@ -908,15 +905,5 @@ func (k *KernelBackend) SessionID() string { return k.sessionID }
// parameters (req.Params) are bound onto the statement in execute (see
// bindParams).
func (k *KernelBackend) Execute(ctx context.Context, req backend.ExecRequest) (backend.Operation, error) {
// Staging (Unity Catalog volume PUT/GET/REMOVE) needs a local file transfer the
// kernel path can't perform, and the kernel C ABI surfaces no IsStagingOperation
// signal to drive conn.execStagingOperation. Reject it here rather than let
// IsStaging return false and report success with no file moved (silent data loss).
// (Bound parameters, by contrast, ARE now supported — bound in execute via the
// kernel's raw-param C ABI.)
if isStagingStatement(req.Query) {
return &kernelOp{}, fmt.Errorf("databricks: staging operations (PUT/GET/REMOVE on a volume) are %w; "+
"use the default (Thrift) backend", dbsqlerr.ErrNotSupportedByKernel)
}
return k.execute(ctx, req)
}
7 changes: 7 additions & 0 deletions internal/backend/kernel/cgo.go
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,9 @@ import "C"
import (
"context"
"fmt"
"os"
"runtime"
"syscall"
"unsafe"

"github.com/databricks/databricks-sql-go/driverctx"
Expand Down Expand Up @@ -178,6 +180,11 @@ func lastError(code C.KernelStatusCode) *KernelError {
if e.query_id != nil {
ke.QueryID = C.GoString(e.query_id)
}
ke.ErrorCode = C.GoString(C.kernel_get_last_error_code())

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟠 High — The PR adds cgo calls to new kernel symbols (e.g. kernel_result_stream_complete_volume_operation, kernel_get_last_error_code), but go.mod/go.sum still pin the v1.4.0 per-platform binding archives. Only KERNEL_REV and the Makefile source-build path get the new kernel, so a consumer's databricks_kernel build can fail to link. Bump the bindings pins and sums to a release that exports these symbols, and check a clean install.

🔀 Found by both reviewers · confirmed by the judge

if code := C.kernel_get_last_error_local_os_error(); code != 0 {
// The C ABI reports a path and errno without a syscall name.
ke.cause = &os.PathError{Op: "file", Path: C.GoString(C.kernel_get_last_error_local_path()), Err: syscall.Errno(code)}
}
klog("kernel error: code=%d sqlstate=%q vendor=%d http=%d retryable=%v msg=%q",
ke.Code, ke.SQLState, ke.VendorCode, ke.HTTPStatus, ke.Retryable, ke.Message)
// Also emit through the driver's logger — no SQL text or PII, just the
Expand Down
14 changes: 11 additions & 3 deletions internal/backend/kernel/errors_classify.go
Original file line number Diff line number Diff line change
Expand Up @@ -49,8 +49,12 @@ type KernelError struct {
HTTPStatus uint16
Retryable bool
QueryID string
ErrorCode string
cause error
}

func (e *KernelError) Unwrap() error { return e.cause }

func (e *KernelError) Error() string {
// Append the server query id when present — it is the one correlation handle
// to server-side query history, and on the execute-error path (no exec handle)
Expand Down Expand Up @@ -129,15 +133,19 @@ func isBadConnection(code int) bool {
}
}

// isSessionFatal reports whether a status code means the server-side session is no
// isSessionFatal reports whether an error means the server-side session is no
// longer usable, so the conn must be evicted from the pool rather than reused for
// the next query. Broader than isBadConnection: it also covers Unauthenticated (an
// expired/revoked token kills the session) — but unlike isBadConnection it is NOT
// used to produce driver.ErrBadConn on the statement path, so eviction happens
// without database/sql replaying the statement (see toStatementError + the
// KernelBackend.markSessionDead call sites).
func isSessionFatal(code int) bool {
switch code {
func isSessionFatal(err error) bool {
var detail *KernelError
if !errors.As(err, &detail) || detail.ErrorCode == "VOLUME_STORAGE_HTTP_ERROR" || detail.ErrorCode == "VOLUME_STORAGE_NETWORK_ERROR" {
return false
}
switch detail.Code {
case statusUnauthenticated, statusUnavailable, statusNetworkError:
return true
default:
Expand Down
12 changes: 10 additions & 2 deletions internal/backend/kernel/errors_classify_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -39,16 +39,24 @@ func TestIsBadConnection(t *testing.T) {
func TestIsSessionFatal(t *testing.T) {
fatal := []int{statusUnauthenticated, statusUnavailable, statusNetworkError}
for _, code := range fatal {
if !isSessionFatal(code) {
if !isSessionFatal(fmt.Errorf("call: %w", &KernelError{Code: code})) {
t.Errorf("code %d should be session-fatal", code)
}
}
notFatal := []int{statusInvalidArgument, statusSqlError, statusTimeout}
for _, code := range notFatal {
if isSessionFatal(code) {
if isSessionFatal(&KernelError{Code: code}) {
t.Errorf("code %d should not be session-fatal", code)
}
}
for _, err := range []*KernelError{
{Code: statusUnauthenticated, ErrorCode: "VOLUME_STORAGE_HTTP_ERROR"},
{Code: statusNetworkError, ErrorCode: "VOLUME_STORAGE_NETWORK_ERROR"},
} {
if isSessionFatal(err) {
t.Errorf("storage error %s should not be session-fatal", err.ErrorCode)
}
}
}

// isUserFault picks the log level for a kernel-call failure: user/query faults
Expand Down
46 changes: 42 additions & 4 deletions internal/backend/kernel/include/databricks_kernel.h
Original file line number Diff line number Diff line change
Expand Up @@ -54,8 +54,9 @@
* `KernelStatusCode_InvalidStatementHandle`. Don't hold two live
* executed handles from one statement.
* - **A result stream borrows its executed handle.** Closing the executed
* handle invalidates any stream obtained from it: subsequent stream
* calls return `InvalidStatementHandle` (a defined error, not UB).
* handle invalidates any stream obtained from it: schema access, fetching
* and Volume completion return `InvalidStatementHandle` (a defined error,
* not UB).
* - **Close is awaited.** `kernel_session_close` waits for the server-side
* delete to complete and flushes close-session telemetry before returning.
* If close fails, the kernel still schedules best-effort cleanup when the
Expand Down Expand Up @@ -190,6 +191,11 @@ typedef struct KernelError {
* last kernel call cleared the buffer.
*/
bool kernel_get_last_error(KernelError* out);
/* These accessors preserve the last error. Strings are borrowed until the next
* error-clearing kernel call; absent strings are NULL, absent OS code is zero. */
int32_t kernel_get_last_error_local_os_error(void);
const char* kernel_get_last_error_code(void);
const char* kernel_get_last_error_local_path(void);

/* ─── Opaque handles ──────────────────────────────────────────────────
*
Expand Down Expand Up @@ -369,10 +375,16 @@ KernelStatusCode kernel_session_config_set_sea_response_compression_enabled(
/* Configure the total timeout for one HTTP request, from connection start
* through response-body completion. A separate 30s connection timeout also
* applies, so connection establishment is bounded by the shorter limit.
* Does not apply to Volume file transfers; see the storage read timeout.
* `request_timeout_ms == 0` keeps the kernel default (120s). */
KernelStatusCode kernel_session_config_set_request_timeout(KernelSessionConfig* config,
uint64_t request_timeout_ms);

/* Idle limit for Volume file transfers: a transfer fails after this long without
* progress. Also caps connection setup. Zero sets no limit. */
KernelStatusCode kernel_session_config_set_storage_read_timeout(KernelSessionConfig* config,
uint64_t timeout_ms);

/* Configure the maximum number of idle HTTP connections retained per host.
* `max_connections` must be greater than zero. Omitting this setter keeps the
* kernel default (100). */
Expand Down Expand Up @@ -595,12 +607,12 @@ KernelStatusCode kernel_session_config_set_u2m_token_cache_config(KernelSessionC
*
* Recognised keys (case-insensitive):
* - "cloudfetch_enabled" = "true"|"false" — false serves every result
* inline (SEA disposition = INLINE), mirroring JDBC EnableQueryResultDownload=0.
* through paged inline delivery without cloud-storage downloads.
* - "cloudfetch_link_prefetch_window" = positive integer.
* - "cloudfetch_max_chunks_in_memory" = positive integer (bounds peak RSS;
* values above the kernel ceiling of 256 are clamped with a warning).
* - "inline_max_chunks_in_memory" = positive integer (inline-Arrow prefetch
* window, used when cloudfetch_enabled = false).
* window for paged inline results).
* - "complex_types_as_json" = "true"|"false" — render ARRAY / MAP / STRUCT /
* VARIANT / GEOMETRY / GEOGRAPHY as JSON text (PySQL
* _use_arrow_native_complex_types=False, JDBC complexDatatypeSupport=false).
Expand Down Expand Up @@ -966,6 +978,32 @@ KernelStatusCode kernel_executed_async_statement_close(
*/
KernelStatusCode kernel_result_stream_get_schema(kernel_result_stream_t* stream,
struct ArrowSchema* out);
typedef enum KernelVolumeCompletion {
KernelVolumeCompletion_NotVolume = 0,
KernelVolumeCompletion_NeedsInputStream = 1,
KernelVolumeCompletion_Completed = 2
} KernelVolumeCompletion;

/* Whether the statement is a Volume PUT, GET or REMOVE.
* out is written only on success. */
KernelStatusCode kernel_executed_statement_is_volume_operation(
const kernel_executed_statement_t* exec, bool* out);
/* Same flag, read from the stream. Still succeeds after the executed statement
* is closed.
* out is written only on success. */
KernelStatusCode kernel_result_stream_is_volume_operation(
const kernel_result_stream_t* stream, bool* out);
/* Runs the file transfer for a Volume PUT, GET or REMOVE result. Call before
* fetching; the rows stay readable afterwards.
* allowed_paths_json: JSON array of local directories the transfer may use.
* remove_not_found_is_success: report success when the remote file is missing.
* Returns NeedsInputStream for a stream upload, which this API cannot perform.
* kernel_result_stream_canceller_cancel interrupts it from another thread.
* out_status is written only on success. */
KernelStatusCode kernel_result_stream_complete_volume_operation(
kernel_result_stream_t* stream, const char* allowed_paths_json,
bool remove_not_found_is_success, KernelVolumeCompletion* out_status);

KernelStatusCode kernel_result_stream_next_batch(kernel_result_stream_t* stream,
struct ArrowArray* out_array,
struct ArrowSchema* out_schema);
Expand Down
Loading
Loading