Enum SteVecQueryTerm 

#[non_exhaustive]
pub enum SteVecQueryTerm {
    Selector {
        selector: String,
    },
    Hmac {
        hmac_256: String,
    },
    OreCllw {
        ore_cllw_8: String,
    },
    Ope {
        ope_cllw: String,
    },
    Containment {
        query_vec: SteQueryVec<16>,
    },
}

Per-STE-vector query term. Exactly one of s, hm, oc, op, or q.

Containment carries the full STE query vector emitted for JSON containment (@>) queries (one (selector, term) per path in the query JSON). Other variants carry a single per-element lookup term.

#[non_exhaustive] for the same reason as SteVecEntryTerm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Selector

Fields

selector: String

Hmac

Fields

hmac_256: String

OreCllw

Fields

ore_cllw_8: String

Ope

CLLW OPE query term (op) — a single hex-encoded order-preserving ciphertext, matched bytewise against a stored sv-element op term (Compat mode).

Fields

ope_cllw: String

Containment

Full STE query vector for JSON containment queries.

Serialized under q to avoid collision with SteVecPayload::ste_vec (sv). The wire shape of SteQueryVec is opaque to this layer; the proxy / database decodes it via the encryption crate’s serde impls.

Fields

query_vec: SteQueryVec<16>

Trait Implementations

impl Debug for SteVecQueryTerm

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SteVecQueryTerm

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SteVecEntryTerm> for SteVecQueryTerm

Lifts a stored per-element term onto the query term that matches it.

SteVecQueryTerm is a strict superset of SteVecEntryTerm — it adds Selector and Containment, which have no stored-entry counterpart. Every shared variant keeps its wire key, so a query term always matches the entries the same mode produced.

fn from(term: SteVecEntryTerm) -> Self

Converts to this type from the input type.

impl Serialize for SteVecQueryTerm

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

where __S: Serializer,

Serialize this value into the given Serde serializer.