Enum FilterExpr 

#[non_exhaustive]
pub enum FilterExpr {
    Simple(Filter),
    Compound(CompoundFilter),
}

A filter expression that can be simple or compound.

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.

Simple(Filter)

A simple field comparison.

Compound(CompoundFilter)

A compound filter with logical operator.

Implementations

impl FilterExpr

pub fn parse(json_str: &str) -> Result<Self, ParseError>

Parse a Mongo-style filter from a JSON string.

This is the recommended way to parse user-provided filters.

Example

use mik_sql::FilterExpr;

let filter = FilterExpr::parse(r#"{"name": "Alice", "active": true}"#).unwrap();

Errors

Returns ParseError if the JSON is invalid or malformed.

pub fn parse_bytes(bytes: &[u8]) -> Result<Self, ParseError>

Parse a Mongo-style filter from JSON bytes.

Useful when working with raw request bodies.

Example

use mik_sql::FilterExpr;

let bytes = br#"{"status": {"$in": ["active", "pending"]}}"#;
let filter = FilterExpr::parse_bytes(bytes).unwrap();

Errors

Returns ParseError if the bytes are not valid UTF-8 or valid JSON.

pub fn from_json(json: &JsonValue) -> Result<Self, ParseError>

Parse a Mongo-style filter from a parsed JSON value.

Use this when you already have a parsed miniserde::json::Value. For most cases, prefer parse or parse_bytes.

Errors

Returns ParseError if the JSON structure is invalid.

impl FilterExpr

pub fn collect_filters(&self) -> Vec<Filter>

Collect all simple filters from this expression into a vector.

This flattens compound filters, extracting all individual Filter items. Used by the merge: option in sql_read! to iterate over user filters.

pub fn iter(&self) -> FilterExprIter

Returns an iterator over all simple filters in this expression.

This flattens compound filters, yielding all individual Filter items.

Trait Implementations

impl Clone for FilterExpr

fn clone(&self) -> FilterExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterExpr

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

Formats the value using the given formatter.

impl IntoIterator for &FilterExpr

type Item = Filter

The type of the elements being iterated over.

type IntoIter = FilterExprIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for FilterExpr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for FilterExpr