Struct RemoteScandal 

pub struct RemoteScandal { /* private fields */ }

Scandal served by a remote scandal endpoint.

Implementations

impl RemoteScandal

pub fn new(base_url: Url) -> Result<Self, ScandalError>

Call the scandal service at base_url.

pub fn with_http(self, http: impl Into<ClientWithMiddleware>) -> Self

Use the shared client’s connection pool and transport configuration. Redirects must be disabled to protect bearer credentials.

pub fn with_caller( self, caller: TokenSource, auth_url: &Url, api_url: &Url, ) -> Result<Self, ScandalError>

Call scandal as caller: every request carries a scandal capability, the caller’s access token narrowed by the authorization server at auth_url to scandal and the stack at api_url, and renewed before it expires or when the caller’s token changes. Scandal admits and attributes each request by it, and binds the spiral:// addresses a read meets as the caller at the stack.

Trait Implementations

impl Clone for RemoteScandal

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Scandal for RemoteScandal

fn read_legacy_table<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 ReadLegacyTableRequest, ) -> Pin<Box<dyn Future<Output = Result<ByteStream, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a bounded legacy window from host-resolved metadata and scoped storage as Arrow IPC.

fn list_functions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<FunctionInfo>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The SPQL functions this scandal can run.

fn plan_scan<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scan: &'life1 Scan, storage: &'life2 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<ScanPlan, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Plan a scan: its output schema, its filter support, and one split per fragment that survives pruning by statistics, in stored order.

fn read_scan<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, scan: &'life1 Scan, split: &'life2 Split, storage: &'life3 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<SplitRead, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read one split in stored order. Each batch reports the stored row it reached.

fn take_rows<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, scan: &'life1 Scan, takes: &'life2 [SplitTake], storage: &'life3 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<SplitRead, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read rows of planned splits by position, in request order: each take’s rows in the order of its positions, a repeated position’s row again, the takes one after another. Positions count the rows the version keeps in each split. A batch’s next_row is how many of the request’s positions, across its takes, the batches so far delivered.

fn read_blob<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, blob: &'life1 Blob, range: Option<Range<u64>>, storage: &'life2 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<ByteStream, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Read a Table-owned blob, or a range of it. A whole read checks the payload’s digest.

fn stat_blob<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, blob: &'life1 Blob, storage: &'life2 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<BlobStat, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

What storage holds for a Table-owned blob, without reading its bytes.

fn write_blob<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 TableBinding, media_type: &'life2 str, max_bytes: u64, input: ByteStream, ) -> Pin<Box<dyn Future<Output = Result<Blob, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store one payload as a dedicated blob of table, before any row references it.

fn pack_blobs<'life0, 'life1, 'async_trait>( &'life0 self, table: &'life1 TableBinding, attempt: Option<Uuid>, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store the inline payloads of the spql.Blob columns of input as blobs of table, packed as append_rows packs them, under attempt’s directory when it names one. Returns the rows in order, each such payload replaced by its address, once every pack is stored.

fn start_blob_upload<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 TableBinding, attempt: Uuid, media_type: &'life2 str, part_bytes: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<BlobUpload, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Start a multipart upload of one blob into attempt’s directory of table, with the binding the Tables API issued for that attempt. Parts hold part_bytes each, a power of two, or DEFAULT_UPLOAD_PART_BYTES.

fn upload_blob_part<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, upload: &'life1 BlobUpload, part: u32, input: ByteStream, storage: &'life2 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<BlobPart, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store part part, counted from 1, of upload. Every part but the last holds exactly the upload’s part size. Sending a part again replaces it.

fn complete_blob_upload<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, upload: &'life1 BlobUpload, parts: &'life2 [BlobPart], storage: &'life3 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<Blob, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Join every part of upload, in order from part 1, into its blob, whose digest merges the parts’ hashes.

fn abort_blob_upload<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, upload: &'life1 BlobUpload, storage: &'life2 StorageBinding, ) -> Pin<Box<dyn Future<Output = Result<(), ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Discard the stored parts of upload. An abort removes no stored object.

fn append_rows<'life0, 'life1, 'async_trait>( &'life0 self, table: &'life1 TableBinding, base: Option<Uuid>, attempt: Option<Uuid>, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<Vec<FragmentReceipt>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write rows as fragments for a successor of base, or for the table’s first version when there is none. Appends may run concurrently; finalize adds the kept receipts.

fn append_partition<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 AppendRowsRequest, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<Vec<FragmentReceipt>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write one independent input stream, validating and retaining its physical properties.

fn patch_rows<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 PatchRowsRequest, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<Vec<FragmentReceipt>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write new values for existing rows of request.base, addressed by row ID in request.row_id_column, as patch files. Prepare them on an edit base.

fn delete_rows<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 DeleteRowsRequest, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<Vec<FragmentReceipt>, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Record deletions of rows of request.base, addressed by row ID. Prepare them on an edit base.

fn attach_columns<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 AttachColumnsRequest, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<AttachedColumns, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Attach values of the columns request.schema_changes adds, for every row one fragment of request.base keeps, in stored order, as column files of that fragment. Prepare them on an edit base.

fn write_aligned<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 WriteAlignedRequest, schema: SchemaRef, input: RecordBatchStream, ) -> Pin<Box<dyn Future<Output = Result<AlignedFragment, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write the mirror of fragment request.fragment_id of request.source from the rows the source keeps there, in stored order. Prepare it on an aligned base.

fn plan_changes<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 PlanChangesRequest, ) -> Pin<Box<dyn Future<Output = Result<ChangePlan, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

How one version of a Table changed since an earlier one, from metadata only.

fn finalize_write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 TableBinding, base: &'life2 WriteBase, receipts: &'life3 [FragmentReceipt], ) -> Pin<Box<dyn Future<Output = Result<PreparedWriteReceipt, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Prepare a version from appended fragments. The host registers and publishes it.

fn bind_projection<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 Schema, projection: &'life2 [NamedExpression], ) -> Pin<Box<dyn Future<Output = Result<SchemaRef, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The output schema of named expressions over an input schema, without data.

fn search_vectors<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 SearchVectorsRequest, ) -> Pin<Box<dyn Future<Output = Result<Evaluation, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Search an exact index and refine candidates from its pinned source version. Stream release stops further payload reads.

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, projection: &'life1 [NamedExpression], input_schema: SchemaRef, input: RecordBatchStream, tables: &'life2 [TableBinding], ) -> Pin<Box<dyn Future<Output = Result<Evaluation, ScandalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Evaluate named expressions over the caller’s batches, row for row. Blob reads use the storage of tables.

fn resolves_resources(&self) -> bool

Whether this host resolves logical resource roots internally, including write scopes.