pub struct ListFilter<T, VF = <<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter> { /* private fields */ }Expand description
The sequence filter — for an ORDERED collection column, generic over the element type T.
eq/ne compare the whole collection element by element, so [1, 2] and [2, 1] are different
operands; gt/gte/lt/lte compare it lexicographically; has_element is membership.
§The set operators are SetFilter’s, and that is the whole of the split
This kind carried encloses, enclosed_by and overlaps under a shape parameter naming the
column ordered or unordered. All three ignore order and multiplicity, so they read a list as a
set whatever the parameter said, and the parameter decided one operator: what eq MEANT. Five of
six operators were set semantics, which is a second kind rather than a second rendering.
Postgres draws the same line in its own operator table — @> / <@ / && are the set
operators and = is the sequence one, so ARRAY[1,1,2] @> ARRAY[1] holds while
ARRAY[1,2] = ARRAY[2,1] does not.
has_element is on BOTH kinds. Membership is order- and multiplicity-blind like the three that
left, but it is the one question about a single element a sequence still answers, and a sequence
filter without it would send a caller to a whole-collection operator for it.
§The four ordering operators are not answerable everywhere, and the filter still carries them
gt/gte/lt/lte compare whole collections ELEMENT-WISE and lexicographically, which is what
a Postgres array’s own < does. Neither of the other two SQL dialects has that operator for a
collection kept in a COLUMN: both store one as JSON, and JSON’s ordering — where it exists at all
— ranks by element TYPE before value, so adopting it would answer a different question under the
same name. Stored in an edge table those two answer the four exactly, because an ordinal column is
the thing that was missing.
A filter is BACKEND-NEUTRAL, so the operators live here whole and the refusal lives at the
crossing, where the dialect and the storage strategy are both known — see
ListCrossingError. That is the arrangement
BytesFilter already uses for its fixed-width substring refusal: a
vocabulary that is smaller on one backend is not a smaller filter type, it is a typed no at the
boundary.
§VF is the ELEMENT’s filter, and it is what any asks with
The second parameter is the filter kind ONE element of this collection is guarded by, and it
defaults to the element type’s own reading — <<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter, the same projection a scalar column of T resolves through. So
ListFilter<i64> is ListFilter<i64, ScalarFilter<i64>> and nothing that spelled the one
parameter has to learn the second.
A DEFAULT rather than a bound, because T need not have a reading at all: an element type with
no DefaultMarker row is still filterable by naming VF outright, which
is the shape a downstream collection of a foreign element type takes.
§has_element is any: { eq: … }, and it stays
has_element: x and any: { eq: x } are the same question, and the second subsumes the first
the moment the element’s filter has an equality — which every kind this crate ships does. What
keeps the older spelling is that it is the one a caller reaches for, and that removing an
operator from a wire face is a breaking change for a client that never asked for the general
form. The overlap is real and is stated rather than resolved.
The two are not the same RENDERING. has_element lowers as containment of the singleton — one
operand, one bind, an index seek on every strategy — while any opens an element scope and
applies a whole comparison inside it. Where both express a question, the narrower one is the
cheaper plan.
§The polarsync COVERAGE AUDIT, per operator
polarsync is the reference this crate’s collection surface was measured against, and its whole
collection vocabulary is ONE type: ArrayFilter<I> with nine operators, OptionalArrayFilter<I>
adding a tenth. It draws no sequence/set line at all — Vec<H<N>> and Vec<String> both reach
the same filter — so the audit is that one list against this crate’s two kinds.
| polarsync | its Postgres operator | here |
|---|---|---|
eq | = | eq, on both kinds |
not | <> | ne, on both kinds |
gt / gte / lt / lte | > >= < <= | this type’s four; a set has no ordering to ask about |
contains | @> | SetFilter’s encloses |
is_contained_by | <@ | SetFilter’s enclosed_by |
overlaps | && | SetFilter’s overlaps |
null, on the optional form | IS NULL | NOT HERE, by ruling — a collection has no null state, and is it empty is count: { eq: 0 } |
| — | — | has_element, any and count have no counterpart there at all |
Every operator is covered, and what differs is which KIND carries it. The three set operators
are on SetFilter here, so a column declared set(…) has polarsync’s whole vocabulary and a
column declared list(…) has its ordering half. That is the split this type’s own note argues
for — five of six operators under the old shape parameter were set semantics — and moving them
back would be a RULING about what a sequence MEANS rather than a lowering nobody wrote: all three
already lower on every dialect and both storage strategies, through
SqlSetComparison,
SqlEdgeSetComparison and
MongoSetComparison, so whatever answers that
question spends no new machinery.
The other direction is where this crate is wider, and the widest of the three is any: polarsync
can ask does this array contain exactly this value and cannot ask does some element of it
satisfy this filter, which is the element scope any opens.
§count is a whole scalar filter, and usize is what a length is
A cardinality is asked with the eight operators a number is asked — count: { gt: 3 },
count: { in: [1, 2] } — rather than with a bare equality, because how many is an ordered
question and half of what a caller wants to say about one is a bound rather than a value.
The operand is a usize because a collection’s LENGTH is one: Vec::len returns it, and the
number this operator compares against is the same number. The platform dependence is therefore
the operand’s own rather than something the filter introduced — see the wire name that follows
from it, CountFilter, in this module’s registration table.
Implementations§
Source§impl<T, VF> ListFilter<T, VF>
impl<T, VF> ListFilter<T, VF>
Sourcepub const fn is_empty(&self) -> bool
pub const fn is_empty(&self) -> bool
True while NO operator slot is set — so a lowering would emit nothing for this field.
Inherent, not the backend traits’ provided is_empty: “is anything set” is a property of the
FILTER, identical on every backend, and asking it should not make a caller name a dialect (with
two families compiled, f.is_empty() through the traits is E0283). The inherent method wins
method resolution, so every call site reads the same either way.
§The two nested slots answer the empty case differently, and the QUANTIFIER is the whole reason
A present any holding an EMPTY element filter is not empty: every element satisfies the empty
filter, so some element satisfies it is this collection has an element. ∃x ∈ S. true is
S ≠ ∅, which is a predicate and not the absence of one.
A present count holding an empty scalar filter IS empty, because nothing quantifies it —
asking no question about one number excludes no row. That is Nullable’s
fold-in, which is this crate’s rule for a nested filter; the element slot is the one exception
and it is the quantifier that earns it.
Sourcepub fn eq(&self) -> Option<&[T]>
pub fn eq(&self) -> Option<&[T]>
The eq operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_eq(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_eq(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set eq to Some(value) (in place).
Sourcepub fn maybe_eq(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_eq(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the eq list option (consuming).
Sourcepub fn update_eq(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_eq(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the eq list option (in place).
Sourcepub fn ne(&self) -> Option<&[T]>
pub fn ne(&self) -> Option<&[T]>
The ne operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_ne(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_ne(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set ne to Some(value) (in place).
Sourcepub fn maybe_ne(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_ne(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the ne list option (consuming).
Sourcepub fn update_ne(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_ne(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the ne list option (in place).
Sourcepub fn gt(&self) -> Option<&[T]>
pub fn gt(&self) -> Option<&[T]>
The gt operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_gt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_gt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set gt to Some(value) (in place).
Sourcepub fn maybe_gt(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_gt(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the gt list option (consuming).
Sourcepub fn update_gt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_gt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the gt list option (in place).
Sourcepub fn gte(&self) -> Option<&[T]>
pub fn gte(&self) -> Option<&[T]>
The gte operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_gte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_gte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set gte to Some(value) (in place).
Sourcepub fn maybe_gte(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_gte(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the gte list option (consuming).
Sourcepub fn update_gte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_gte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the gte list option (in place).
Sourcepub fn lt(&self) -> Option<&[T]>
pub fn lt(&self) -> Option<&[T]>
The lt operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_lt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_lt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set lt to Some(value) (in place).
Sourcepub fn maybe_lt(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_lt(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the lt list option (consuming).
Sourcepub fn update_lt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_lt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the lt list option (in place).
Sourcepub fn lte(&self) -> Option<&[T]>
pub fn lte(&self) -> Option<&[T]>
The lte operands, or None while the operator is absent.
A PRESENT but empty list is not the same as an absent operator: the first asks for no
rows, the second for every row, so Some(&[]) and None say different things.
Sourcepub fn set_lte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
pub fn set_lte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self
Set lte to Some(value) (in place).
Sourcepub fn maybe_lte(self, value: Option<impl Into<Box<[T]>>>) -> Self
pub fn maybe_lte(self, value: Option<impl Into<Box<[T]>>>) -> Self
Assign the lte list option (consuming).
Sourcepub fn update_lte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
pub fn update_lte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self
Assign the lte list option (in place).
Sourcepub const fn has_element(&self) -> Option<&T>
pub const fn has_element(&self) -> Option<&T>
The has_element operand, or None while the operator is absent.
Sourcepub fn with_has_element(self, value: T) -> Self
pub fn with_has_element(self, value: T) -> Self
Set has_element to Some(value) (consuming).
Sourcepub fn set_has_element(&mut self, value: T) -> &mut Self
pub fn set_has_element(&mut self, value: T) -> &mut Self
Set has_element to Some(value) (in place).
Sourcepub fn maybe_has_element(self, value: Option<T>) -> Self
pub fn maybe_has_element(self, value: Option<T>) -> Self
Assign the raw has_element option (consuming).
Sourcepub fn update_has_element(&mut self, value: Option<T>) -> &mut Self
pub fn update_has_element(&mut self, value: Option<T>) -> &mut Self
Assign the raw has_element option (in place).
Sourcepub fn update_any(&mut self, value: Option<VF>) -> &mut Self
pub fn update_any(&mut self, value: Option<VF>) -> &mut Self
Assign the raw any option (in place).
Sourcepub const fn count(&self) -> Option<&ScalarFilter<usize>>
pub const fn count(&self) -> Option<&ScalarFilter<usize>>
The count operand, or None while the operator is absent.
Sourcepub fn with_count(self, value: ScalarFilter<usize>) -> Self
pub fn with_count(self, value: ScalarFilter<usize>) -> Self
Set count to Some(value) (consuming).
Sourcepub fn set_count(&mut self, value: ScalarFilter<usize>) -> &mut Self
pub fn set_count(&mut self, value: ScalarFilter<usize>) -> &mut Self
Set count to Some(value) (in place).
Sourcepub fn maybe_count(self, value: Option<ScalarFilter<usize>>) -> Self
pub fn maybe_count(self, value: Option<ScalarFilter<usize>>) -> Self
Assign the raw count option (consuming).
Sourcepub fn update_count(&mut self, value: Option<ScalarFilter<usize>>) -> &mut Self
pub fn update_count(&mut self, value: Option<ScalarFilter<usize>>) -> &mut Self
Assign the raw count option (in place).
Sourcepub fn try_map<U, E, F>(self, f: F) -> Result<ListFilter<U, VF>, E>
pub fn try_map<U, E, F>(self, f: F) -> Result<ListFilter<U, VF>, E>
Convert every ELEMENT operand with f, keeping the operator set exactly as it stands — see
ScalarFilter::try_map for what this primitive is for and what it promises about lists.
f maps ONE ELEMENT, not a collection. Six of the seven element slots hold a whole collection
operand and the seventh a single element, and both are made of the same T — so a single
element converter serves all seven, and has_element is not a special case.
any and count pass through UNTOUCHED. Each holds a whole FILTER rather than an operand, and
this method’s parameter ranges over T — so a nested filter’s own operands are converted by its
own crossing, which is the same division Nullable::try_map draws between
the wrapper and the kind it wraps. count’s operands are not made of T at all: a length is a
usize whatever the elements are.
Trait Implementations§
Source§impl<T, VF> Default for ListFilter<T, VF>
impl<T, VF> Default for ListFilter<T, VF>
Source§impl<T, VF> GraphqlFilter for ListFilter<T, VF>
impl<T, VF> GraphqlFilter for ListFilter<T, VF>
impl<T, VF> InputObjectType for ListFilter<T, VF>
async-graphql only.Source§impl<T, VF> InputType for ListFilter<T, VF>
Available on crate feature async-graphql only.The WIRE FACE, written over the two PARAMETERS rather than per instantiation.
impl<T, VF> InputType for ListFilter<T, VF>
async-graphql only.The WIRE FACE, written over the two PARAMETERS rather than per instantiation.
§One row where there was a table, and the table is what pins it
A sequence column’s face used to be a hand-maintained row per element type — eleven of them, each
naming its own SDL string. Every one of those rows is reproduced by this impl, name for name, and
the elements the table could not reach are reached too: a declarer’s own vocabulary
(ListFilter<Tag, EnumFilter<Tag>>), and the gated types the table deliberately left out. That
is what makes it ONE row rather than a wider table — a collection’s face is a fact about the
element’s face, and the element’s face is already registered.
Nothing is orphaned by it. ListFilter is this crate’s own type, so the impl is LOCAL at every
pair of parameters; a declaring crate supplies its element’s face and its element filter’s, both
impls on its own types, and this row does the rest.
§The bounds are the two faces the body spends, and nothing more
T: ToGraphqlInput because six operator slots hold Box<[T]> and one holds a bare T, and what
goes on the wire for each is the ELEMENT’S CROSSING — not the element. That bound is what a plain
T: InputType cost: u128 has no InputType in any crate but async-graphql’s, so a Vec<u128>
column could not reach a schema at all, and Vec<u8> has one that renders [Int!], so a
Vec<Vec<u8>> column reached a schema that LIED — a list of lists of small integers where the
same blob’s own filter published hex. Both are the element’s own crossing here.
VF: InputType because any holds the element’s own filter, and because the schema NAME is
derived from it — see operand_of for why the element’s own name cannot
serve. ScalarFilter<usize> needs no bound: count is a cardinality, so it is one registered
input object for every element type there is.
T::Input: InputType IS async-graphql’s demand on the crossed form, and it is written here rather
than on ToGraphqlInput’s seat because that is the law: the map says
which form an element crosses as, and each backend asks what it needs of that form where it
SPENDS it. An element whose crossing this library cannot parse is E0277 at this face, and its
row stays legal for a second binding to read.
T: Send + Sync is not a further face — it is InputType’s own supertrait, asked of Self and
reaching T through the Option<T> slots. It used to arrive free with T: InputType and is
restated now that the element’s bound is this crate’s own trait. Every element that could ever
have reached a schema already satisfied it.
§What the table’s own rules were, and which of them the row keeps
The four ORDERING fields are on the wire for every element type, including the ones whose only compiled backend cannot answer them. A filter is backend-neutral and a schema is rendered without naming a dialect, so the alternative would be a wire face that varied with a Cargo feature — a client’s schema changing because a server was rebuilt. The refusal is the CROSSING’s, and it names the operator.
any renders as the ELEMENT’s own input object — I64ListFilter.any is an I64Filter —
so nothing new is registered for it: the element’s value filter is already on the wire, which is
what makes Vec<T> reach a schema exactly when T does. count renders as CountFilter
whatever the element is, a cardinality having no operand to be named after.
Two of the table’s rows were ABSENCES with reasons, and this row answers both by construction
rather than by discipline. ListFilter<u8> had no row because a Vec<u8> is a BLOB here, so no
field’s default resolves to it and an input object for it would be unreachable — and an impl is
REGISTERED only where a field names it, so UInt8ListFilter still reaches no schema. The gated
temporal and text vocabularies had none because giving one to them alone would have made them the
exception among the gated rows — and now none of them is an exception: a Vec<Timestamp> column
resolves to ListFilter<Timestamp> and reaches a schema as DateTimeListFilter, closing the gap
filter’s own note used to describe as designed.
Source§type RawValueType = ListFilter<T, VF>
type RawValueType = ListFilter<T, VF>
Source§fn create_type_info(registry: &mut Registry) -> String
fn create_type_info(registry: &mut Registry) -> String
Source§fn parse(value: Option<Value>) -> InputValueResult<Self>
fn parse(value: Option<Value>) -> InputValueResult<Self>
Value. None represents undefined.Source§fn as_raw_value(&self) -> Option<&Self::RawValueType>
fn as_raw_value(&self) -> Option<&Self::RawValueType>
Source§fn qualified_type_name() -> String
fn qualified_type_name() -> String
Source§impl<T, VF> NullableFace for ListFilter<T, VF>
Available on crate feature async-graphql only.The NULLABLE row, fed from the same face for the reason filter_input_object! feeds one from
every invocation: nullability is a TYPE here, so a face with no NullableFace leaves every
Option<Vec<T>> column unspellable.
impl<T, VF> NullableFace for ListFilter<T, VF>
async-graphql only.The NULLABLE row, fed from the same face for the reason filter_input_object! feeds one from
every invocation: nullability is a TYPE here, so a face with no NullableFace leaves every
Option<Vec<T>> column unspellable.
The twin the blanket assembles is flat, and its parse hands the SAME object to the bare face’s
own — so the nine operator fields keep exactly one parser.
Source§fn bare_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>
fn bare_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>
isNull appended.impl<T: PartialEq, VF: PartialEq> StructuralPartialEq for ListFilter<T, VF>
Source§impl<D, VF, V, Db: CollectionStorage<V, VF>> ToDatabaseComparison<V, Db> for ListFilter<D, VF>
Available on crate feature sqlx only.The type-level map, keyed on the dialect’s declared strategy: a ListFilter crosses into
whichever comparison the database that answers keeps a SEQUENCE in.
impl<D, VF, V, Db: CollectionStorage<V, VF>> ToDatabaseComparison<V, Db> for ListFilter<D, VF>
sqlx only.The type-level map, keyed on the dialect’s declared strategy: a ListFilter crosses into
whichever comparison the database that answers keeps a SEQUENCE in.
It is the crossing where the choice lands rather than anything below it, because
ToDatabaseComparison’s Comparison is already keyed on Db. Nothing about
ComplexComparison changes and no other filter kind pays for it.
§The element filter crosses FIRST, and the collection reads its answer
VF is the element’s filter kind, and the comparison the collection holds is whatever THAT
filter crosses into over the SAME storage type and the same dialect — because a collection’s
members are stored as V, whether in a column, an array or an edge row. So this row projects
through VF’s own crossing and hands the result to the storage map, which is what keeps the
element’s vocabulary the element’s: a text element brings the substring family and a scalar one
does not, with nothing here choosing between them.
Source§type Comparison = <Db as CollectionStorage<V, VF>>::Sequence
type Comparison = <Db as CollectionStorage<V, VF>>::Sequence
V and lowering for Db.Source§impl<D, VF, V> ToDatabaseComparison<V, Mongo> for ListFilter<D, VF>
Available on crate feature mongo only.The sequence filter crosses into the sequence comparison, and the ELEMENT filter crosses FIRST.
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for ListFilter<D, VF>
mongo only.The sequence filter crosses into the sequence comparison, and the ELEMENT filter crosses FIRST.
VF is the member’s filter kind, and the comparison this collection holds is whatever THAT
filter crosses into over the SAME storage type — because a collection’s members are stored as
V, in the array beside its siblings. So this row projects through VF’s own crossing, which is
what keeps the member’s vocabulary the member’s.
The projection sits in the associated type and in the where-clause rather than in this header’s
ARGUMENTS, which is what keeps it resolvable: V and Mongo are both concrete here, so an
expansion assuming this predicate at a database it has not named yet has nothing to infer. The
SQL family reaches the same property by a different route — its projection lives inside a storage
row, because there the dialect is the thing not yet named.
It does not overlap the SQL family’s row for the same filter, for the coherence reason
MongoScalarComparison’s row records: that one is keyed on
Db: CollectionStorage<V, VF>, whose supertrait is the FOREIGN sqlx::Database, and Mongo
is local and has no such row.
Source§type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
V and lowering for Db.Source§impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for MongoListComparison<V, C>
Available on crate feature mongo only.The identity crossing for a sequence — a Vec<String> stored as an array of strings is the
common one.
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for MongoListComparison<V, C>
mongo only.The identity crossing for a sequence — a Vec<String> stored as an array of strings is the
common one.
§Errors
Source§type Error = MongoCollectionCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
type Error = MongoCollectionCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
Source§fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
filter into this comparison, or report why an operand could not follow.Source§impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, MySql>
Available on crate features mysql and sqlx only.
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, MySql>
mysql and sqlx only.Source§type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
Source§fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
filter into this comparison, or report why an operand could not follow.Source§impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Postgres>
Available on crate features postgres and sqlx only.The identity crossing for a Postgres sequence column — a Vec<String> stored as a text[] is
the common one.
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Postgres>
postgres and sqlx only.The identity crossing for a Postgres sequence column — a Vec<String> stored as a text[] is
the common one.
§Errors
Source§type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
Source§fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
filter into this comparison, or report why an operand could not follow.Source§impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Sqlite>
Available on crate features sqlite and sqlx only.
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Sqlite>
sqlite and sqlx only.Source§type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
Source§fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
filter into this comparison, or report why an operand could not follow.Source§impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>, Db> TryFromFilter<ListFilter<D, VF>> for SqlEdgeComparison<V, C, Db>
Available on crate feature sqlx only.The identity crossing for an edge-table sequence — a Vec<String> whose elements are stored as
TEXT is the common one.
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>, Db> TryFromFilter<ListFilter<D, VF>> for SqlEdgeComparison<V, C, Db>
sqlx only.The identity crossing for an edge-table sequence — a Vec<String> whose elements are stored as
TEXT is the common one.
This is the impl the whole At design exists to make writable, and it is generic over the
dialect because the crossing is: which strategy stores a collection is
CollectionStorage’s answer, and by the time a filter reaches here
it has been given.
§Errors
Source§type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>
Source§fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>
filter into this comparison, or report why an operand could not follow.Auto Trait Implementations§
impl<T, VF> Freeze for ListFilter<T, VF>
impl<T, VF> RefUnwindSafe for ListFilter<T, VF>
impl<T, VF> Send for ListFilter<T, VF>
impl<T, VF> Sync for ListFilter<T, VF>
impl<T, VF> Unpin for ListFilter<T, VF>
impl<T, VF> UnsafeUnpin for ListFilter<T, VF>
impl<T, VF> UnwindSafe for ListFilter<T, VF>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
Source§impl<C> FlattenFace for Cwhere
C: NullableFace,
impl<C> FlattenFace for Cwhere
C: NullableFace,
Source§fn flat_read<F>(
object: &IndexMap<Name, ConstValue>,
) -> Result<C, InputValueError<F>>where
F: InputType,
Available on crate feature async-graphql only.
fn flat_read<F>(
object: &IndexMap<Name, ConstValue>,
) -> Result<C, InputValueError<F>>where
F: InputType,
async-graphql only.The object is CLONED, and the clone is the honest cost of splicing: the component’s parser takes an owned value, and the host’s other fields are read off the same object either side of this call. Handing the last splice the owned map would save one clone in the one-splice case and make the emission depend on which field came last.
Source§fn flat_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>
fn flat_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>
async-graphql only.Source§fn flat_values(&self) -> IndexMap<Name, ConstValue>
fn flat_values(&self) -> IndexMap<Name, ConstValue>
async-graphql only.Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.impl<T> Fruit for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
impl<T> SearchOptionsFace for Twhere
T: InputType,
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.