Enum Condition 

#[non_exhaustive]
pub enum Condition {
    HasField {
        has_field: String,
    },
    FieldIn {
        key: String,
        any: Vec<Value>,
    },
    FieldNotIn {
        key: String,
        none: Vec<Value>,
    },
    FieldContains {
        key: String,
        contains: Value,
    },
    DocumentContains {
        document_contains: String,
    },
    DocumentRegex {
        document_regex: String,
    },
    Field {
        key: String,
        matches: Option<MatchValue>,
        range: Option<Range>,
    },
    HasId {
        has_id: Vec<PointId>,
    },
    Nested(Filter),
}

A predicate used inside a Filter.

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.

HasField

Matches when a dot-separated payload field exists.

Fields

has_field: String

Dot-separated payload path that must exist.

FieldIn

Matches when a scalar payload field is one of the supplied values.

Fields

key: String

Dot-separated payload path.

any: Vec<Value>

Accepted scalar values.

FieldNotIn

Matches when a scalar payload field is not one of the supplied values.

Fields

key: String

Dot-separated payload path.

none: Vec<Value>

Rejected scalar values.

FieldContains

Matches when an array payload field contains the supplied scalar value.

Fields

key: String

Dot-separated payload path.

contains: Value

Required array member.

DocumentContains

Matches when the reserved stored document contains a substring.

Fields

document_contains: String

Case-sensitive substring required in the stored document.

DocumentRegex

Matches when the reserved stored document satisfies a regular expression.

Fields

document_regex: String

Rust regular expression applied to the stored document.

Field

Matches or range-checks a dot-separated payload field.

Fields

key: String

Dot-separated payload path.

matches: Option<MatchValue>

Optional equality match.

range: Option<Range>

Optional numeric range.

HasId

Matches points whose typed ID is in the supplied set.

Fields

has_id: Vec<PointId>

Accepted typed IDs.

Nested(Filter)

Evaluates a nested Boolean filter.

Implementations

impl Condition

pub fn matches(key: impl Into<String>, value: impl Into<Value>) -> Self

Creates an equality condition for a dot-separated payload path.

Examples found in repository

examples/filtering.rs (line 13)

fn main() -> git_vdb::Result<()> {
    let temporary = tempfile::TempDir::new()?;
    let docs = open(temporary.path().join("vectors.git"))?.collection("docs");
    docs.upsert([
        Point::new("guide", [1.0, 0.0]).with_metadata(json!({"kind": "docs"}))?,
        Point::new("code", [0.9, 0.1]).with_metadata(json!({"kind": "source"}))?,
    ])?;
    let result = docs.advanced()?.query(
        Query::new([1.0, 0.0], 5)
            .with_filter(Filter::must([Condition::matches("kind", "docs")]))
            .with_payload(),
    )?;
    assert_eq!(result.points[0].id.to_string(), "guide");
    Ok(())
}

pub fn range(key: impl Into<String>, range: Range) -> Self

Creates a numeric-range condition for a dot-separated payload path.

Examples found in repository

examples/lancedb_git_vdb_runner.rs (lines 442-448)

fn selectivity_filter(selectivity: f64) -> Filter {
    Filter::must([Condition::range(
        "selectivity_bucket",
        Range {
            lt: Some((selectivity * 1000.0).round()),
            ..Range::default()
        },
    )])
}

pub fn has_id(ids: impl IntoIterator<Item = PointId>) -> Self

Creates a condition that accepts the supplied typed point IDs.

pub fn exists(key: impl Into<String>) -> Self

Creates a condition requiring a dot-separated payload path to exist.

pub fn is_in( key: impl Into<String>, values: impl IntoIterator<Item = Value>, ) -> Self

Creates a condition accepting any of a set of scalar field values.

pub fn not_in( key: impl Into<String>, values: impl IntoIterator<Item = Value>, ) -> Self

Creates a condition rejecting a set of scalar field values.

pub fn contains(key: impl Into<String>, value: impl Into<Value>) -> Self

Creates a condition requiring an array field to contain a scalar value.

pub fn document_contains(value: impl Into<String>) -> Self

Creates a case-sensitive substring condition over the stored document.

pub fn document_regex(value: impl Into<String>) -> Self

Creates a regular-expression condition over the stored document.

Trait Implementations

impl Clone for Condition

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 Condition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Condition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Condition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.