Struct ManifestRegistryServiceClient

pub struct ManifestRegistryServiceClient<T> {
    inner: Grpc<T>,
}

Fields

inner: Grpc<T>

Implementations

impl<T> ManifestRegistryServiceClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> ManifestRegistryServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn register_with_dataset( &mut self, request: impl IntoRequest<RegisterWithDatasetRequest>, ) -> Result<Response<RegisterWithDatasetResponse>, Status>

Register new partitions with the Dataset (asynchronously)

pub async fn register_with_dataset_blocking( &mut self, request: impl IntoRequest<RegisterWithDatasetBlockingRequest>, ) -> Result<Response<RegisterWithDatasetBlockingResponse>, Status>

Register new partitions with the Dataset (blocking)

pub async fn write_chunks( &mut self, request: impl IntoStreamingRequest<Message = WriteChunksRequest>, ) -> Result<Response<Streaming<WriteChunksResponse>>, Status>

Unimplemented.

pub async fn get_partition_table_schema( &mut self, request: impl IntoRequest<GetPartitionTableSchemaRequest>, ) -> Result<Response<GetPartitionTableSchemaResponse>, Status>

Returns the schema of the partition table (i.e. the dataset manifest) itself, not the underlying dataset.

• To inspect the data of the partition table, use ScanPartitionTable.
• To retrieve the schema of the underlying dataset, use GetDatasetSchema instead.

pub async fn scan_partition_table( &mut self, request: impl IntoRequest<ScanPartitionTableRequest>, ) -> Result<Response<Streaming<ScanPartitionTableResponse>>, Status>

Inspect the contents of the partition table (i.e. the dataset manifest).

The returned data will follow the schema specified by GetPartitionTableSchema.

pub async fn get_dataset_schema( &mut self, request: impl IntoRequest<GetDatasetSchemaRequest>, ) -> Result<Response<GetDatasetSchemaResponse>, Status>

Returns the schema of the dataset.

This is the union of all the schemas from all the underlying partitions. It will contain all the indexes, entities and components present in the dataset.

pub async fn create_index( &mut self, request: impl IntoRequest<CreateIndexRequest>, ) -> Result<Response<CreateIndexResponse>, Status>

Creates a custom index for a specific column (vector search, full-text search, etc).

Index can be created for all or specific partitions. Creating an index will create a new index-specific chunk manifest for the Dataset. Chunk manifest contains information about individual chunk rows for all chunks containing relevant index data.

pub async fn re_index( &mut self, request: impl IntoRequest<ReIndexRequest>, ) -> Result<Response<ReIndexResponse>, Status>

Recreate an index with the same configuration but (potentially) new data.

pub async fn search_dataset( &mut self, request: impl IntoRequest<SearchDatasetRequest>, ) -> Result<Response<Streaming<SearchDatasetResponse>>, Status>

Search a previously created index.

Do a full text, vector or scalar search. Currently only an Indexed search is supported, user must first call CreateIndex for the relevant column.

The response is a RecordBatch with 4 columns:

• ‘partition_id’: which partition the data is from
• ‘timepoint’: represents the points in time where index query matches. What time points are matched depends on the type of index that is queried. For example: for vector search it might be timepoints where top-K matches are found within each partition in the indexed entry. For inverted index it might be timepoints where the query string is found in the indexed column
• instance column: if index column contains a batch of values (for example a list of embeddings), then each instance of the batch is a separate row in the resulting RecordBatch
• instance_id: this is a simple element index in the batch array. For example if indexed column is a list of embeddings [a,b,c] (where each embedding is of same length) then ‘instance_id’ of embedding ‘a’ is 0, ‘instance_id’ of ‘b’ is 1, etc.

TODO(zehiko) add support for “brute force” search.

pub async fn query_dataset( &mut self, request: impl IntoRequest<QueryDatasetRequest>, ) -> Result<Response<Streaming<QueryDatasetResponse>>, Status>

Perform Rerun-native queries on a dataset, returning the matching chunk IDs.

These Rerun-native queries include:

• Filtering by specific partition and chunk IDs.
• Latest-at, range and dataframe queries.
• Arbitrary Lance filters.

To fetch the actual chunks themselves, see GetChunks.

Passing chunk IDs to this method effectively acts as a IF_EXIST filter.

pub async fn get_chunks( &mut self, request: impl IntoRequest<GetChunksRequest>, ) -> Result<Response<Streaming<GetChunksResponse>>, Status>

Perform Rerun-native queries on a dataset, returning the underlying chunks.

These Rerun-native queries include:

• Filtering by specific partition and chunk IDs.
• Latest-at, range and dataframe queries.
• Arbitrary Lance filters.

To fetch only the actual chunk IDs rather than the chunks themselves, see QueryDataset.

pub async fn fetch_chunk_manifest( &mut self, request: impl IntoRequest<FetchChunkManifestRequest>, ) -> Result<Response<Streaming<FetchChunkManifestResponse>>, Status>

Retrieves the chunk manifest for a specific index.

pub async fn create_partition_manifests( &mut self, request: impl IntoRequest<CreatePartitionManifestsRequest>, ) -> Result<Response<CreatePartitionManifestsResponse>, Status>

Create manifests for all partitions in the Dataset. Partition manifest contains information about the chunks in the partitions.

This is normally automatically done as part of the registration process.

pub async fn fetch_partition_manifest( &mut self, request: impl IntoRequest<FetchPartitionManifestRequest>, ) -> Result<Response<Streaming<FetchPartitionManifestResponse>>, Status>

Fetch the internal state of a Partition Manifest.

Trait Implementations

impl<T: Clone> Clone for ManifestRegistryServiceClient<T>

fn clone(&self) -> ManifestRegistryServiceClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ManifestRegistryServiceClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.