re_protos::manifest_registry::v1alpha1::manifest_registry_service_server

Trait ManifestRegistryService

Source 
pub trait ManifestRegistryService:
    Send
    + Sync
    + 'static {
    type WriteChunksStream: Stream<Item = Result<WriteChunksResponse, Status>> + Send + 'static;
    type ScanPartitionTableStream: Stream<Item = Result<ScanPartitionTableResponse, Status>> + Send + 'static;
    type SearchDatasetStream: Stream<Item = Result<SearchDatasetResponse, Status>> + Send + 'static;
    type QueryDatasetStream: Stream<Item = Result<QueryDatasetResponse, Status>> + Send + 'static;
    type GetChunksStream: Stream<Item = Result<GetChunksResponse, Status>> + Send + 'static;
    type FetchChunkManifestStream: Stream<Item = Result<FetchChunkManifestResponse, Status>> + Send + 'static;
    type FetchPartitionManifestStream: Stream<Item = Result<FetchPartitionManifestResponse, Status>> + Send + 'static;


Show 14 methods    // Required methods
    fn register_with_dataset<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterWithDatasetRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterWithDatasetResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_with_dataset_blocking<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterWithDatasetBlockingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterWithDatasetBlockingResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn write_chunks<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<WriteChunksRequest>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::WriteChunksStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_partition_table_schema<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetPartitionTableSchemaRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetPartitionTableSchemaResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn scan_partition_table<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ScanPartitionTableRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ScanPartitionTableStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_dataset_schema<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetDatasetSchemaRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetDatasetSchemaResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_index<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateIndexRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateIndexResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn re_index<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ReIndexRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ReIndexResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn search_dataset<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SearchDatasetRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SearchDatasetStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn query_dataset<'life0, 'async_trait>(
        &'life0 self,
        request: Request<QueryDatasetRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::QueryDatasetStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_chunks<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetChunksRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::GetChunksStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn fetch_chunk_manifest<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FetchChunkManifestRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::FetchChunkManifestStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_partition_manifests<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreatePartitionManifestsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreatePartitionManifestsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn fetch_partition_manifest<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FetchPartitionManifestRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::FetchPartitionManifestStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

}
Expand description

Generated trait containing gRPC methods that should be implemented for use with ManifestRegistryServiceServer.

Required Associated Types§

Source

type WriteChunksStream: Stream<Item = Result<WriteChunksResponse, Status>> + Send + 'static

Server streaming response type for the WriteChunks method.

Source

type ScanPartitionTableStream: Stream<Item = Result<ScanPartitionTableResponse, Status>> + Send + 'static

Server streaming response type for the ScanPartitionTable method.

Source

type SearchDatasetStream: Stream<Item = Result<SearchDatasetResponse, Status>> + Send + 'static

Server streaming response type for the SearchDataset method.

Source

type QueryDatasetStream: Stream<Item = Result<QueryDatasetResponse, Status>> + Send + 'static

Server streaming response type for the QueryDataset method.

Source

type GetChunksStream: Stream<Item = Result<GetChunksResponse, Status>> + Send + 'static

Server streaming response type for the GetChunks method.

Source

type FetchChunkManifestStream: Stream<Item = Result<FetchChunkManifestResponse, Status>> + Send + 'static

Server streaming response type for the FetchChunkManifest method.

Source

type FetchPartitionManifestStream: Stream<Item = Result<FetchPartitionManifestResponse, Status>> + Send + 'static

Server streaming response type for the FetchPartitionManifest method.

Required Methods§

Source

fn register_with_dataset<'life0, 'async_trait>( &'life0 self, request: Request<RegisterWithDatasetRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterWithDatasetResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register new partitions with the Dataset (asynchronously)

Source

fn register_with_dataset_blocking<'life0, 'async_trait>( &'life0 self, request: Request<RegisterWithDatasetBlockingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterWithDatasetBlockingResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register new partitions with the Dataset (blocking)

Source

fn write_chunks<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<WriteChunksRequest>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::WriteChunksStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Unimplemented.

Source

fn get_partition_table_schema<'life0, 'async_trait>( &'life0 self, request: Request<GetPartitionTableSchemaRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetPartitionTableSchemaResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.
Source

fn scan_partition_table<'life0, 'async_trait>( &'life0 self, request: Request<ScanPartitionTableRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::ScanPartitionTableStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

The returned data will follow the schema specified by GetPartitionTableSchema.

Source

fn get_dataset_schema<'life0, 'async_trait>( &'life0 self, request: Request<GetDatasetSchemaRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetDatasetSchemaResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn create_index<'life0, 'async_trait>( &'life0 self, request: Request<CreateIndexRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateIndexResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn re_index<'life0, 'async_trait>( &'life0 self, request: Request<ReIndexRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ReIndexResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn search_dataset<'life0, 'async_trait>( &'life0 self, request: Request<SearchDatasetRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SearchDatasetStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn query_dataset<'life0, 'async_trait>( &'life0 self, request: Request<QueryDatasetRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::QueryDatasetStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn get_chunks<'life0, 'async_trait>( &'life0 self, request: Request<GetChunksRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::GetChunksStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn fetch_chunk_manifest<'life0, 'async_trait>( &'life0 self, request: Request<FetchChunkManifestRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::FetchChunkManifestStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Retrieves the chunk manifest for a specific index.

Source

fn create_partition_manifests<'life0, 'async_trait>( &'life0 self, request: Request<CreatePartitionManifestsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreatePartitionManifestsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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.

Source

fn fetch_partition_manifest<'life0, 'async_trait>( &'life0 self, request: Request<FetchPartitionManifestRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::FetchPartitionManifestStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Fetch the internal state of a Partition Manifest.

Implementors§