Struct FieldRef 

pub struct FieldRef<S, T>
where
    S: Schema,
{ /* private fields */ }

Type-safe field reference holding schema and Rust type information.

This struct binds a field to both its schema and expected Rust type, enabling compile-time type checking for filter operations.

NOTE: FieldRef equality and hashing are based solely on the underlying schema field. The generic type parameter T is a phantom type used only for compile-time validation of operations and is not part of the field identity.

Type Parameters

• S - The schema type implementing Schema
• T - The Rust type this field represents (e.g., String, uuid::Uuid)

Implementations

impl<S, T> FieldRef<S, T>

where S: Schema,

pub const fn new(field: <S as Schema>::Field) -> FieldRef<S, T>

Create a new typed field reference.

Example

const NAME: FieldRef<UserSchema, String> = FieldRef::new(UserField::Name);

pub fn name(&self) -> &'static str

Get the field name as a string.

impl<S, T> FieldRef<S, T>

where S: Schema,

Comparison operations for any field type.

pub fn eq<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create an equality comparison: field eq value

Example

let filter = ID.eq(user_id);

pub fn ne<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create a not-equal comparison: field ne value

pub fn gt<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create a greater-than comparison: field gt value

pub fn ge<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create a greater-than-or-equal comparison: field ge value

pub fn lt<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create a less-than comparison: field lt value

pub fn le<V>(self, value: V) -> Expr

where V: IntoODataValue,

Create a less-than-or-equal comparison: field le value

pub fn is_null(self) -> Expr

Create a null check: field eq null

Example

let filter = OPTIONAL_FIELD.is_null();

pub fn is_not_null(self) -> Expr

Create a not-null check: field ne null

Example

let filter = OPTIONAL_FIELD.is_not_null();

impl<S> FieldRef<S, String>

where S: Schema,

String-specific operations (only available for String fields).

pub fn contains(self, substring: &str) -> Expr

Create a contains function call: contains(field, 'value')

Example

let filter = NAME.contains("john");

pub fn startswith(self, prefix: &str) -> Expr

Create a startswith function call: startswith(field, 'prefix')

Example

let filter = NAME.startswith("Dr");

pub fn endswith(self, suffix: &str) -> Expr

Create an endswith function call: endswith(field, 'suffix')

Example

let filter = EMAIL.endswith("@example.com");

Trait Implementations

impl<S, T> Clone for FieldRef<S, T>

where S: Schema,

fn clone(&self) -> FieldRef<S, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, T> Debug for FieldRef<S, T>

where S: Schema,

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

Formats the value using the given formatter.

impl<S, T> Hash for FieldRef<S, T>

where S: Schema, <S as Schema>::Field: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S, T> PartialEq for FieldRef<S, T>

where S: Schema,

fn eq(&self, other: &FieldRef<S, T>) -> 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<S, T> Copy for FieldRef<S, T>

where S: Schema,

impl<S, T> Eq for FieldRef<S, T>

where S: Schema,