Filter API Reference

The Filter enum provides composable filter expressions for querying documents.

Installation

Add PocketDB to your Cargo.toml:

[dependencies]
pocketdb = "0.1"

Or via the command line:

cargo add pocketdb

Import

use pocketdb::query::Filter;

Or use the filter! macro:

use pocketdb::filter;

Comparison Operators

Filter::eq

pub fn eq(field: &str, value: PocketValue) -> Self

Equality comparison.

let f = Filter::eq("name", PocketValue::String("Alice".to_string()));

---

Filter::ne

pub fn ne(field: &str, value: PocketValue) -> Self

Not-equal comparison.

---

Filter::gt

pub fn gt(field: &str, value: PocketValue) -> Self

Greater-than comparison.

---

Filter::gte

pub fn gte(field: &str, value: PocketValue) -> Self

Greater-than-or-equal comparison.

---

Filter::lt

pub fn lt(field: &str, value: PocketValue) -> Self

Less-than comparison.

---

Filter::lte

pub fn lte(field: &str, value: PocketValue) -> Self

Less-than-or-equal comparison.

---

Filter::in_list

pub fn in_list(field: &str, values: Vec<PocketValue>) -> Self

Matches if the field value is in the given list.

let f = Filter::in_list("color", vec![
    PocketValue::String("red".to_string()),
    PocketValue::String("blue".to_string()),
]);

---

Filter::nin

pub fn nin(field: &str, values: Vec<PocketValue>) -> Self

Matches if the field value is NOT in the given list.

Logical Operators

Filter::and

pub fn and(left: Filter, right: Filter) -> Self

Logical AND of two filters.

let f = Filter::and(
    Filter::gt("age", PocketValue::Int(18)),
    Filter::eq("active", PocketValue::Bool(true)),
);

---

Filter::or

pub fn or(left: Filter, right: Filter) -> Self

Logical OR of two filters.

---

Filter::not

pub fn not(inner: Filter) -> Self

Logical NOT of a filter.

---

Filter::nor

pub fn nor(left: Filter, right: Filter) -> Self

Logical NOR — neither condition matches.

Element Operators

Filter::exists

pub fn exists(field: &str, should_exist: bool) -> Self

Checks whether a field exists.

let f = Filter::exists("email", true);    // Field must exist
let f = Filter::exists("phone", false);   // Field must NOT exist

---

Filter::type_is

pub fn type_is(field: &str, type_name: &str) -> Self

Checks the type of a field. Type names: "null", "bool", "int", "float", "string", "array", "object", "objectId", "binary".

String Operators

Filter::regex

pub fn regex(field: &str, pattern: &str) -> Self

Regular expression match on a string field.

---

Filter::starts_with

pub fn starts_with(field: &str, prefix: &str) -> Self

String starts with prefix.

---

Filter::ends_with

pub fn ends_with(field: &str, suffix: &str) -> Self

String ends with suffix.

---

Filter::contains

pub fn contains(field: &str, value: PocketValue) -> Self

Array contains element, or string contains substring.

Array Operators

Filter::all

pub fn all(field: &str, values: Vec<PocketValue>) -> Self

Array contains all specified values.

---

Filter::size

pub fn size(field: &str, size: usize) -> Self

Array has exactly the specified number of elements.

Utility

Filter::always_true

pub fn always_true() -> Self

Matches any document.

---

Filter::matches

pub fn matches(&self, doc: &Document) -> bool

Returns true if the given document matches this filter.

filter! Macro

use pocketdb::filter;

// Simple equality
let f = filter! { "name" => == "Alice" };

// Multiple conditions (implicit AND)
let f = filter! { "age" => > 18, "active" => == true };

// Supported operators: ==, !=, >, >=, <, <=

Combining Filters

Filters are composable — build complex queries by nesting:

let f = Filter::and(
    Filter::eq("active", PocketValue::Bool(true)),
    Filter::or(
        Filter::eq("role", PocketValue::String("admin".to_string())),
        Filter::gt("age", PocketValue::Int(25)),
    ),
);