Struct wundergraph::query_builder::selection::filter::Filter

pub struct Filter<F, T> { /* fields omitted */ }

Main filter struct

This struct is the main entry point to wundergraphs filter api The exact field specfic filters are given by a subtype (inner)

Methods

impl<F, T> Filter<F, T> where
    F: InnerFilter, 

pub fn apply_filter<'a, ST, DB>(
    self,
    q: BoxedSelectStatement<'a, ST, T, DB>
) -> BoxedSelectStatement<'a, ST, T, DB> where
    T: Table + 'a,
    DB: Backend + 'a,
    Self: BuildFilter<DB>,
    Self::Ret: AppearsOnTable<T> + QueryFragment<DB> + 'a, 

Apply the filter to a given select statement

This function will extend the where clause with the given filter expression In case there is already an existing filter the new filter will by connected connected by and

Trait Implementations

impl<F, DB, T> BuildFilter<DB> for Filter<F, T> where
    DB: Backend + 'static,
    F: InnerFilter + BuildFilter<DB> + 'static,
    T: 'static,
    F::Ret: AppearsOnTable<T>, 

type Ret = Box<dyn BoxableFilter<T, 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<F: Debug, T: Debug> Debug for Filter<F, T>

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

Formats the value using the given formatter.

impl<F, T> FromInputValue<WundergraphScalarValue> for Filter<F, T> where
    F: InnerFilter, 

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

Performs the conversion.

impl<F, T> FromLookAheadValue for Filter<F, T> where
    F: InnerFilter, 

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

Try to convert a LookAheadValue into a specific type

impl<F, T> GraphQLType<WundergraphScalarValue> for Filter<F, T> where
    F: InnerFilter, 

type Context = F::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<F, T> InnerFilter for Filter<F, T> where
    F: InnerFilter, 

type Context = F::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(
    objs: &[(&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<F, T> Nameable for Filter<F, T> where
    F: Nameable, 

fn name() -> String

The name of the given type

impl<F, T> ToInputValue<WundergraphScalarValue> for Filter<F, T> where
    F: InnerFilter, 

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

Performs the conversion.