Enum VectorOp 

pub enum VectorOp {
    Search {
        collection: QualifiedCollection,
        query_vector: Vec<f32>,
        top_k: usize,
        ef_search: usize,
        metric: DistanceMetric,
        filter_bitmap: Option<SurrogateBitmap>,
        field_name: String,
        rls_filters: Vec<u8>,
        inline_prefilter_plan: Option<Box<PhysicalPlan>>,
        ann_options: VectorAnnOptions,
        skip_payload_fetch: bool,
        payload_filters: Vec<PayloadAtom>,
    },
    Insert {
        collection: QualifiedCollection,
        vector: Vec<f32>,
        dim: usize,
        field_name: String,
        surrogate: Surrogate,
        pk_bytes: Option<Vec<u8>>,
        provenance: Option<SyncProvenance>,
    },
    BatchInsert {
        collection: QualifiedCollection,
        vectors: Vec<Vec<f32>>,
        dim: usize,
        surrogates: Vec<Surrogate>,
    },
    MultiSearch {
        collection: QualifiedCollection,
        query_vector: Vec<f32>,
        top_k: usize,
        ef_search: usize,
        filter_bitmap: Option<SurrogateBitmap>,
        rls_filters: Vec<u8>,
    },
    Delete {
        collection: QualifiedCollection,
        vector_id: u32,
    },
    DeleteBySurrogate {
        collection: QualifiedCollection,
        surrogate: Option<Surrogate>,
        field_name: String,
        provenance: Option<SyncProvenance>,
    },
    SetParams {
        collection: QualifiedCollection,
        field_name: String,
        dim: usize,
        m: usize,
        ef_construction: usize,
        metric: String,
        index_type: String,
        pq_m: usize,
        ivf_cells: usize,
        ivf_nprobe: usize,
    },
    DropIndex {
        collection: QualifiedCollection,
        field_name: String,
    },
    QueryStats {
        collection: QualifiedCollection,
        field_name: String,
    },
    Seal {
        collection: QualifiedCollection,
        field_name: String,
    },
    CompactIndex {
        collection: QualifiedCollection,
        field_name: String,
    },
    Rebuild {
        collection: QualifiedCollection,
        field_name: String,
        m: usize,
        m0: usize,
        ef_construction: usize,
    },
    SparseInsert {
        collection: QualifiedCollection,
        field_name: String,
        doc_id: String,
        entries: Vec<(u32, f32)>,
    },
    SparseSearch {
        collection: QualifiedCollection,
        field_name: String,
        query_entries: Vec<(u32, f32)>,
        top_k: usize,
    },
    SparseDelete {
        collection: QualifiedCollection,
        field_name: String,
        doc_id: String,
    },
    MultiVectorInsert {
        collection: QualifiedCollection,
        field_name: String,
        document_surrogate: Surrogate,
        pk_bytes: Option<Vec<u8>>,
        vectors: Vec<f32>,
        count: usize,
        dim: usize,
    },
    MultiVectorDelete {
        collection: QualifiedCollection,
        field_name: String,
        document_surrogate: Surrogate,
    },
    MultiVectorScoreSearch {
        collection: QualifiedCollection,
        field_name: String,
        query_vector: Vec<f32>,
        top_k: usize,
        ef_search: usize,
        mode: String,
    },
    DirectUpsert {

        collection: QualifiedCollection,
        field: String,
        surrogate: Surrogate,
        pk_bytes: Vec<u8>,
        vector: Vec<f32>,
        payload: Vec<u8>,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
        on_conflict_updates: Vec<(String, UpdateValue)>,
        rls_write_check: RlsWriteCheck,
    
},
    DirectInsert {
        collection: QualifiedCollection,
        field: String,
        surrogate: Surrogate,
        pk_bytes: Vec<u8>,
        vector: Vec<f32>,
        payload: Vec<u8>,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
    },
    DirectInsertIfAbsent {
        collection: QualifiedCollection,
        field: String,
        surrogate: Surrogate,
        pk_bytes: Vec<u8>,
        vector: Vec<f32>,
        payload: Vec<u8>,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
    },
    DirectBatchWrite {
        collection: QualifiedCollection,
        field: String,
        intent: VectorDirectWriteIntent,
        rows: Vec<VectorDirectRow>,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
        on_conflict_updates: Vec<(String, UpdateValue)>,
        rls_write_check: RlsWriteCheck,
    },
    DirectDelete {
        collection: QualifiedCollection,
        field: String,
        targets: VectorWriteTargets,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
        rls_write_check: RlsWriteCheck,
    },
    DirectTruncate {
        collection: QualifiedCollection,
        field: String,
        restart_identity: bool,
    },
    DirectUpdate {
        collection: QualifiedCollection,
        field: String,
        targets: VectorWriteTargets,
        new_vector: Option<Vec<f32>>,
        payload_patch: Vec<(String, UpdateValue)>,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        returning: Option<ReturningSpec>,
        rls_filters: Vec<u8>,
        rls_write_check: RlsWriteCheck,
    },
    ResolveDirectWrite(Box<VectorOp>),
    ResolvedDirectWrite {
        collection: QualifiedCollection,
        field: String,
        quantization: VectorQuantization,
        storage_dtype: VectorStorageDtype,
        payload_indexes: Vec<(String, PayloadIndexKind)>,
        mutations: Vec<VectorResolvedMutation>,
        response_payload: Vec<u8>,
        rls_write_check: RlsWriteCheck,
    },
}

Vector engine physical operations.

Variants

Search

Vector similarity search.

Fields

collection: QualifiedCollection

query_vector: Vec<f32>

top_k: usize

ef_search: usize

Optional search beam width override. If 0, uses default 4 * top_k.

metric: DistanceMetric

Per-query distance metric override. Overrides the collection-default metric configured at index creation time.

filter_bitmap: Option<SurrogateBitmap>

Pre-computed bitmap of eligible surrogates (from filter evaluation).

field_name: String

Named vector field to search. Empty string = default field.

rls_filters: Vec<u8>

RLS post-candidate filters (serialized Vec<ScanFilter>). Applied after HNSW returns candidates, before returning to client. Result count may be less than requested top_k.

inline_prefilter_plan: Option<Box<PhysicalPlan>>

Optional sub-plan whose output rows materialize a SurrogateBitmap used as an additional prefilter (intersected with filter_bitmap).

Set by the planner when fusing Vector ORDER BY ... + JOIN ARRAY_SLICE(...) ON v.id = s.surrogate into a single op: the array slice runs first, its surrogate column becomes the vector engine’s pre-filter, then HNSW search runs against the reduced candidate set. Mirrors HashJoin’s inline_*_bitmap mechanism so the Data Plane composition is uniform.

ann_options: VectorAnnOptions

ANN tuning knobs from the SQL caller. Defaults to no overrides.

skip_payload_fetch: bool

When true, the SELECT projection contains only id and/or vector_distance(...) — no payload fields. The handler skips the document-body fetch. Ignored (treated as false) when RLS filters are active, as body fetch is required for RLS evaluation.

payload_filters: Vec<PayloadAtom>

Optional payload bitmap pre-filter for vector-primary collections. Each atom is Eq / In / Range — the handler ANDs all atoms and intersects the resulting bitmap with the HNSW candidate set before walking. The planner only emits atoms whose field has a registered payload index of the matching kind. Empty means no payload pre-filter.

Insert

Insert a vector into the HNSW index (write path).

Fields

collection: QualifiedCollection

vector: Vec<f32>

dim: usize

field_name: String

Named vector field. Empty string = default (unnamed) field.

surrogate: Surrogate

Global surrogate identifying this row. Allocated by the Control Plane via SurrogateAssigner before dispatch; the engine binds the HNSW node id to this surrogate.

pk_bytes: Option<Vec<u8>>

User PK bytes (UTF-8 of the document id) when the insert originates from a PK-bearing path; None for headless inserts. Carried on the replication wire so followers bind the leader-assigned surrogate to this exact key rather than re-allocating a divergent one.

provenance: Option<SyncProvenance>

Sync provenance: identifies the originating peer and sequence for idempotency.

BatchInsert

Batch insert vectors into the HNSW index.

Fields

collection: QualifiedCollection

vectors: Vec<Vec<f32>>

dim: usize

surrogates: Vec<Surrogate>

One surrogate per inserted vector, parallel to vectors. Empty vector = headless batch (no PK binding).

MultiSearch

Multi-vector search: query across all named vector fields, fuse via RRF.

Fields

collection: QualifiedCollection

query_vector: Vec<f32>

top_k: usize

ef_search: usize

filter_bitmap: Option<SurrogateBitmap>

rls_filters: Vec<u8>

RLS post-candidate filters.

Delete

Soft-delete a vector by internal node ID.

Fields

collection: QualifiedCollection

vector_id: u32

DeleteBySurrogate

Soft-delete a vector by surrogate (sync inbound path).

The Data Plane resolves surrogate → HNSW node_id via the surrogate_to_local map and tombstones the node. If the surrogate is not found the op is a no-op (idempotent).

Fields

collection: QualifiedCollection

surrogate: Option<Surrogate>

The row’s bound surrogate. None when the key’s home binds none: the delete removes nothing and still commits its sync provenance.

field_name: String

Named vector field; empty = default field.

provenance: Option<SyncProvenance>

Sync provenance: identifies the originating peer and sequence for idempotency.

SetParams

Set vector index parameters for a collection.

Fields

collection: QualifiedCollection

field_name: String

Named vector field this config applies to. Empty string = the default (unnamed) vector field. Lets one collection carry multiple vector indexes, one per VECTOR / embedding column.

dim: usize

Declared vector dimension. Enforced against every vector written to this field; 0 means “not declared” and leaves the index to adopt the width of whatever arrives first.

m: usize

ef_construction: usize

metric: String

index_type: String

Index type: “hnsw” (default), “hnsw_pq”, or “ivf_pq”.

pq_m: usize

PQ subvectors (for hnsw_pq and ivf_pq). Default: 8.

ivf_cells: usize

IVF cells (for ivf_pq only). Default: 256.

ivf_nprobe: usize

IVF probe count (for ivf_pq only). Default: 16.

DropIndex

Tear down one vector index: the materialized graph, its build parameters, its declared dimension, and its on-disk checkpoint.

The counterpart of VectorOp::SetParams. Without it a dropped vector index keeps answering searches until the process restarts and keeps its (collection, field) slot occupied so no replacement index can be created.

Fields

collection: QualifiedCollection

field_name: String

Named vector field the index covers. Empty string = the default (unnamed) vector field.

QueryStats

Query live vector index statistics. Returns VectorIndexStats as payload.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty string = default (unnamed) field.

Seal

Force-seal the growing segment, triggering background HNSW build.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty string = default field.

CompactIndex

Force tombstone compaction on sealed segments.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty string = default field.

Rebuild

Rebuild sealed segments with new HNSW parameters. Old index serves queries until rebuild completes, then swaps atomically.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty string = default field.

m: usize

New M parameter. 0 = keep current.

m0: usize

New M0 parameter. 0 = keep current.

ef_construction: usize

New ef_construction. 0 = keep current.

SparseInsert

Insert a sparse vector into the inverted index.

Fields

collection: QualifiedCollection

field_name: String

Named sparse vector field.

doc_id: String

Document ID to associate with this sparse vector.

entries: Vec<(u32, f32)>

Sparse vector entries as (dimension, weight) pairs.

SparseSearch

Search the sparse inverted index via dot-product scoring.

Fields

collection: QualifiedCollection

field_name: String

Named sparse vector field.

query_entries: Vec<(u32, f32)>

Query sparse vector entries.

top_k: usize

Maximum results to return.

SparseDelete

Delete a document from the sparse inverted index.

Fields

collection: QualifiedCollection

field_name: String

Named sparse vector field.

doc_id: String

Document ID to remove.

MultiVectorInsert

Insert multiple vectors for a single document (ColBERT-style). All vectors are inserted as separate HNSW nodes sharing the same document_surrogate.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty = default.

document_surrogate: Surrogate

Surrogate shared by all vectors of the document.

pk_bytes: Option<Vec<u8>>

User PK bytes of the document when it has a key; None for a headless document, whose surrogate self-keys. Carried on the replication wire so every replica binds document_surrogate to this exact key, as Insert does.

vectors: Vec<f32>

Flat vector data: count × dim f32 values.

count: usize

Number of vectors.

dim: usize

Dimensionality of each vector.

MultiVectorDelete

Delete all vectors for a document from the multi-vector index.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty = default.

document_surrogate: Surrogate

Document surrogate whose vectors should be tombstoned.

MultiVectorScoreSearch

Search with multi-vector aggregated scoring (MaxSim, AvgSim, SumSim). Over-fetches from HNSW, groups by doc_id, aggregates, deduplicates.

Fields

collection: QualifiedCollection

field_name: String

Named vector field. Empty = default.

query_vector: Vec<f32>

Query vector.

top_k: usize

Maximum documents to return.

ef_search: usize

HNSW ef_search override. 0 = auto.

mode: String

Aggregation mode: “max_sim”, “avg_sim”, “sum_sim”.

DirectUpsert

Direct vector upsert for vector-primary collections: an existing primary key is replaced whole, or patched by on_conflict_updates.

Bypasses MessagePack document encoding — the Data Plane binds the vector to an HNSW node, updates the payload bitmap indexes from payload, and stores payload as the row’s sidecar. No full-document blob is written.

Ordering invariant (enforced by the handler):

1. Validate dim and storage dtype.
2. Decode payload bytes and probe the surrogate.
3. Remove the old node, bitmap entries, and sidecar when one exists.
4. Insert into HNSW (surrogate bound) and update the bitmap indexes.
5. Store the sidecar; a failed store rolls step 4 back.

Fields

collection: QualifiedCollection

field: String

Vector column name. Used to compute the vector index key so the SELECT path (which keys by (tid, collection, field)) finds the same index this insert wrote into.

surrogate: Surrogate

Global surrogate the Control Plane bound to pk_bytes.

pk_bytes: Vec<u8>

UTF-8 of the declared primary-key value. Followers bind the leader-assigned surrogate to this exact key.

vector: Vec<f32>

FP32 vector values.

payload: Vec<u8>

Pre-encoded MessagePack of every non-vector column the statement supplied. Empty when the row carried none.

Only the fields named in payload_indexes become bitmap-indexed downstream; the rest travel here so the whole row image is available to whatever has to decide it — a row-level-security write policy among them.

quantization: VectorQuantization

Collection-level quantization. Applied via set_quantization on first insert so subsequent seals trigger codec-dispatch rebuilds against the configured codec (RaBitQ / BBQ).

storage_dtype: VectorStorageDtype

Native storage dtype for vector values (F32 / F16 / BF16). The executor uses this to decide whether to transcode incoming f32 components before writing them into the HNSW index backing store.

payload_indexes: Vec<(String, PayloadIndexKind)>

Payload field bitmap indexes (name + kind). Registered via payload.add_index on the first insert into a new collection.

returning: Option<ReturningSpec>

When Some, return the STORED post-image of the upserted row — the metadata sidecar as it exists after the handler wrote it, decoded through the same normalizer the SELECT scan uses, so the returned row renders identically to a later read. Never the submitted values: the sidecar is zerompk TAGGED bytes and echoing the request would report a shape no read of the collection ever produces.

The vector goes to HNSW, every other column to the sidecar, and there is no companion document write to carry the clause instead.

rls_filters: Vec<u8>

Read filters gating the row returning emits. A vector-primary write’s policy admission happens Control-Plane-side against the payload image (RlsCtx::admit_write_value_map_image), which decides whether the write happens at all; this bounds what may be shown back, so a RETURNING row never exceeds a SELECT by the same principal.

on_conflict_updates: Vec<(String, UpdateValue)>

ON CONFLICT (pk) DO UPDATE SET assignments applied to the stored payload when the key exists. Empty means whole-row replace.

rls_write_check: RlsWriteCheck

Write policy for the merged post-image an on_conflict_updates patch produces; the image exists only on the Data Plane. Decided Control-Plane-side when the patch is empty.

DirectInsert

Vector-primary INSERT: an existing primary key raises unique_violation. Same fields as VectorOp::DirectUpsert minus the conflict patch.

Fields

collection: QualifiedCollection

field: String

surrogate: Surrogate

pk_bytes: Vec<u8>

vector: Vec<f32>

payload: Vec<u8>

quantization: VectorQuantization

storage_dtype: VectorStorageDtype

payload_indexes: Vec<(String, PayloadIndexKind)>

returning: Option<ReturningSpec>

rls_filters: Vec<u8>

DirectInsertIfAbsent

Vector-primary INSERT ... ON CONFLICT DO NOTHING: an existing primary key leaves the stored row alone and reports zero rows.

Fields

collection: QualifiedCollection

field: String

surrogate: Surrogate

pk_bytes: Vec<u8>

vector: Vec<f32>

payload: Vec<u8>

quantization: VectorQuantization

storage_dtype: VectorStorageDtype

payload_indexes: Vec<(String, PayloadIndexKind)>

returning: Option<ReturningSpec>

rls_filters: Vec<u8>

DirectBatchWrite

Multi-row vector-primary INSERT / INSERT ... ON CONFLICT / UPSERT: one statement, one page. Every row is judged before any row lands, so the page lands whole or not at all.

Each row means what one DirectInsert / DirectInsertIfAbsent / DirectUpsert of the same intent means, applied in page order. A key the page names twice is judged against the body its earlier row produced, and is stored once, with the final body.

The page always resolves to a VectorOp::ResolvedDirectWrite before it is logged or replicated: the record names the rows the page stores, so replay never judges existence again.

Fields

collection: QualifiedCollection

field: String

Vector column name; keys the HNSW index.

intent: VectorDirectWriteIntent

What an existing key means for every row of the page.

rows: Vec<VectorDirectRow>

The rows, in statement order.

quantization: VectorQuantization

storage_dtype: VectorStorageDtype

payload_indexes: Vec<(String, PayloadIndexKind)>

returning: Option<ReturningSpec>

When Some, return one row per row the page writes, each its key’s stored post-image.

rls_filters: Vec<u8>

Read filters gating the rows returning emits.

on_conflict_updates: Vec<(String, UpdateValue)>

See DirectUpsert::on_conflict_updates. Only an Upsert page carries one; one clause for every row.

rls_write_check: RlsWriteCheck

See DirectUpsert::rls_write_check.

DirectDelete

Vector-primary DELETE. Removes the HNSW node, its payload bitmap entries, and the payload sidecar row of every targeted surrogate. Reports the number of rows that existed.

Fields

collection: QualifiedCollection

field: String

Vector column name; keys the HNSW index.

targets: VectorWriteTargets

returning: Option<ReturningSpec>

When Some, return the removed rows’ sidecar images.

rls_filters: Vec<u8>

Read filters gating the rows returning emits.

rls_write_check: RlsWriteCheck

Write policy decided against each removed row’s sidecar image.

DirectTruncate

Vector-primary TRUNCATE. Removes every live row of the collection’s primary index: each HNSW node, its payload bitmap entries, and its payload sidecar row. Reports the number of rows that existed.

Fields

collection: QualifiedCollection

field: String

Vector column name; keys the HNSW index.

restart_identity: bool

TRUNCATE ... RESTART IDENTITY: the Control Plane resets the collection’s sequences after the Data Plane clears the rows.

DirectUpdate

Vector-primary UPDATE. A new_vector rebuilds the HNSW node under the same surrogate; payload_patch merges into the sidecar and moves the payload bitmap entries. Reports the number of rows that existed.

Fields

collection: QualifiedCollection

field: String

Vector column name; keys the HNSW index.

targets: VectorWriteTargets

new_vector: Option<Vec<f32>>

Replacement vector, when the statement assigns the vector column.

payload_patch: Vec<(String, UpdateValue)>

Assignments to non-vector columns, applied to the stored payload.

quantization: VectorQuantization

storage_dtype: VectorStorageDtype

payload_indexes: Vec<(String, PayloadIndexKind)>

returning: Option<ReturningSpec>

When Some, return the rows’ stored post-images.

rls_filters: Vec<u8>

Read filters gating the rows returning emits.

rls_write_check: RlsWriteCheck

Write policy decided against each row’s post-image.

ResolveDirectWrite(Box<VectorOp>)

Read-only: report every row mutation the wrapped vector-primary write would apply, and the response payload it would return, without applying anything.

Wraps a VectorOp::DirectDelete, VectorOp::DirectUpdate, VectorOp::DirectUpsert, or VectorOp::DirectBatchWrite verbatim, live write predicate included — the handler resolves the targets, reads each row’s sidecar, computes the post-image, and decides the policy here, where the writing identity is still available. A follower has none, so the predicate can never cross the Raft wire.

ResolvedDirectWrite

Apply exactly the mutations a VectorOp::ResolveDirectWrite reported, then return response_payload verbatim.

No predicate is evaluated and no image is recomputed: the Control Plane already decided both, and rls_write_check carries the verdict (RlsWriteCheck::DecidedEarlierInRequest). Every mutation’s pre-image is checked against the stored sidecar before the first one applies, so a resolution that drifted under a concurrent write applies nothing and asks for a retry.

Fields

collection: QualifiedCollection

field: String

Vector column name; keys the HNSW index.

quantization: VectorQuantization

Index settings a first write into a new index registers; an Upsert mutation into an empty collection creates the index.

storage_dtype: VectorStorageDtype

payload_indexes: Vec<(String, PayloadIndexKind)>

mutations: Vec<VectorResolvedMutation>

response_payload: Vec<u8>

The statement’s reply, decided while resolving. Applying nodes return it unchanged, so leader and follower report the same thing.

rls_write_check: RlsWriteCheck

Implementations

impl VectorOp

pub fn direct_write_collection(&self) -> Option<&str>

The vector-primary collection a direct write targets, or None for every op outside that family. ResolveDirectWrite reports the wrapped write’s collection so the resolve dispatch routes to the core that owns exactly the rows the write reads.

impl VectorOp

pub fn direct_batch_point_writes(&self) -> Option<Vec<VectorOp>>

One DirectInsert / DirectInsertIfAbsent / DirectUpsert per row of a DirectBatchWrite page, in page order, by the page’s intent. None for every other op.

Trait Implementations

impl Clone for VectorOp

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VectorOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for VectorOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'__msgpack_de> FromMessagePack<'__msgpack_de> for VectorOp

fn read<R: Read<'__msgpack_de>>(reader: &mut R) -> Result<Self, Error>

where Self: Sized,

Reads the MessagePack representation of this value from the provided reader.

impl PartialEq for VectorOp

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for VectorOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for VectorOp

impl ToMessagePack for VectorOp

fn write<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Writes the MessagePack representation of this value into the provided writer.

fn write_slice<W>(values: &[Self], writer: &mut W) -> Result<(), Error>

where W: Write, Self: Sized,

Writes the MessagePack representation of a slice of values into the provided writer.

fn size_hint(&self) -> Option<TrustedSizeHint>

Returns a trusted upper bound for the number of bytes written by the next call to Self::write, or None when it cannot be determined cheaply.

fn max_size() -> Option<TrustedSizeHint>

where Self: Sized,

Returns a trusted upper bound valid for every value of this type.