Struct wundergraph::query_builder::selection::filter::FilterOption

pub struct FilterOption<T, C> where
    T: FilterValue<C>,  { /* fields omitted */ }

This struct summarize all possible filter operations for a given graphql field

There are two generic parameter

• T is a generic type that represents the (rust) type of the field the should be applied to
• C is the column type from diesel that matches the field in the database

Both types must be compatible

Trait Implementations

impl<T, C, DB> BuildFilter<DB> for FilterOption<T, C> where
    DB: Backend + HasSqlType<C::SqlType> + 'static,
    T: FilterValue<C>,
    T::AdditionalFilter: BuildFilter<DB> + 'static,
    <T::AdditionalFilter as BuildFilter<DB>>::Ret: AppearsOnTable<C::Table> + QueryFragment<DB> + 'static,
    T::RawValue: AsExpression<C::SqlType> + ToSql<C::SqlType, DB> + 'static,
    <T::RawValue as AsExpression<C::SqlType>>::Expression: NonAggregate + AppearsOnTable<C::Table> + QueryFragment<DB> + 'static,
    C: Column + NonAggregate + QueryFragment<DB> + Default + 'static,
    C::SqlType: SingleValue,
    C::Table: 'static,
    Eq<C, <T::RawValue as AsExpression<C::SqlType>>::Expression>: AppearsOnTable<C::Table, SqlType = Bool>,
    NotEq<C, <T::RawValue as AsExpression<C::SqlType>>::Expression>: AppearsOnTable<C::Table, SqlType = Bool>,
    In<C, Many<<T::RawValue as AsExpression<C::SqlType>>::Expression>>: AppearsOnTable<C::Table, SqlType = Bool>, 

type Ret = Box<dyn BoxableFilter<C::Table, DB, SqlType = Bool>>

The return type of the constructed filter

fn into_filter(self) -> Option<Self::Ret>

A function that convertes a given type into a diesel filter expression

impl<T, C> Clone for FilterOption<T, C> where
    T: Clone + FilterValue<C>,
    T::AdditionalFilter: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, C: Debug> Debug for FilterOption<T, C> where
    T: FilterValue<C>,
    T::RawValue: Debug,
    T::RawValue: Debug,
    T::RawValue: Debug,
    T::AdditionalFilter: Debug, 

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

Formats the value using the given formatter.

impl<T, C> FromInputValue<WundergraphScalarValue> for FilterOption<T, C> where
    T: FilterValue<C>,
    Self: InnerFilter, 

fn from_input_value(v: &InputValue<WundergraphScalarValue>) -> Option<Self>

Performs the conversion.

impl<T, C> FromLookAheadValue for FilterOption<T, C> where
    T: FromLookAheadValue + FilterValue<C>,
    C: Column,
    Self: InnerFilter, 

fn from_look_ahead(a: &LookAheadValue<WundergraphScalarValue>) -> Option<Self>

Try to convert a LookAheadValue into a specific type

impl<T, C> GraphQLType<WundergraphScalarValue> for FilterOption<T, C> where
    T: FilterValue<C>,
    T: GraphQLType<WundergraphScalarValue>,
    Self: InnerFilter<Context = T::Context> + Nameable, 

type Context = T::Context

The expected context type for this GraphQL type

type TypeInfo = NameBuilder<Self>

Type that may carry additional schema information

fn name(info: &Self::TypeInfo) -> Option<&str>

The name of the GraphQL type to expose.

fn meta<'r>(
    info: &Self::TypeInfo,
    registry: &mut Registry<'r, WundergraphScalarValue>
) -> MetaType<'r, WundergraphScalarValue> where
    WundergraphScalarValue: 'r, 

The meta type representing this GraphQL type.

fn resolve_field(
    &self,
    info: &Self::TypeInfo,
    field_name: &str,
    arguments: &Arguments<S>,
    executor: &Executor<Self::Context, S>
) -> Result<Value<S>, FieldError<S>>

Resolve the value of a single field on this type.

fn resolve_into_type(
    &self,
    info: &Self::TypeInfo,
    type_name: &str,
    selection_set: Option<&[Selection<S>]>,
    executor: &Executor<Self::Context, S>
) -> Result<Value<S>, FieldError<S>>

Resolve this interface or union into a concrete type

fn concrete_type_name(
    &self,
    context: &Self::Context,
    info: &Self::TypeInfo
) -> String

Return the concrete type name for this instance/union.

fn resolve(
    &self,
    info: &Self::TypeInfo,
    selection_set: Option<&[Selection<S>]>,
    executor: &Executor<Self::Context, S>
) -> Value<S>

Resolve the provided selection set against the current object.

impl<V, C> InnerFilter for FilterOption<V, C> where
    V: GraphQLType<WundergraphScalarValue, TypeInfo = ()> + FromInputValue<WundergraphScalarValue> + ToInputValue<WundergraphScalarValue> + FromLookAheadValue + FilterValue<C> + 'static,
    Self: Nameable,
    V::AdditionalFilter: InnerFilter, 

type Context = V::Context

The used context type

const FIELD_COUNT: usize

The number of fields created by this filter

fn from_inner_input_value(
    obj: IndexMap<&str, &InputValue<WundergraphScalarValue>>
) -> Option<Self>

Create the given filter from a graphql input value

fn from_inner_look_ahead(
    obj: &[(&str, LookAheadValue<WundergraphScalarValue>)]
) -> Self

Create the given filter from a graphql lookahead value

fn to_inner_input_value(
    &self,
    map: &mut IndexMap<&str, InputValue<WundergraphScalarValue>>
)

Covert the given filter into a graphql value

fn register_fields<'r>(
    _info: &NameBuilder<Self>,
    registry: &mut Registry<'r, WundergraphScalarValue>
) -> Vec<Argument<'r, WundergraphScalarValue>>

Register all fields of the the filter in a given graphql schema

impl<V, C> Nameable for FilterOption<V, C> where
    V: Nameable + FilterValue<C>, 

fn name() -> String

The name of the given type

impl<T, C> ToInputValue<WundergraphScalarValue> for FilterOption<T, C> where
    T: FilterValue<C>,
    Self: InnerFilter, 

fn to_input_value(&self) -> InputValue<WundergraphScalarValue>

Performs the conversion.