pub struct MongoNullable<C> { /* private fields */ }mongo only.Expand description
A NULLABLE column’s comparison: C’s operators, plus the null test — which exists here and in no
other comparison type.
One wrapper rather than a nullable twin per kind, mirroring Nullable exactly, and it is that
mirroring that carries the guarantee across: a NOT NULL column’s filter has no null test, so
its comparison has nowhere to put one, so asking a NOT NULL column whether it is null is a
query that does not typecheck rather than one that matches nothing.
§The null test is TWO states, and MongoDB’s own convention is what makes it two
A BSON document is the set of fields that were written, so a field can be missing in a way a
table row’s column cannot. That does not make the question three-valued, because the server
reads the two the same way: {v: null} matches the document holding an explicit null AND the
document with no v at all, and the query vocabulary follows that reading throughout. Missing
IS null here, by the store’s own convention rather than by this crate’s arrangement.
The SQL family conflates the same pair from the other side, which is why one filter means one
thing across both backends: ALTER TABLE … ADD COLUMN backfills NULL, so a row written before
the column existed is indistinguishable from a row that stored NULL into it. Neither family can
tell a caller which of the two happened, and neither is asked to.
What IS three-way is the input face — not asked, asked for null, asked for a value — and
Nullable already carries it as Option<bool>, where None is not asked. That is a fact
about the query rather than about the cell, and it is the layer above this one.
§What each state renders
null | key | matches |
|---|---|---|
Some(true) | {$eq: null} | the field is null, or there is no such field |
Some(false) | {$ne: null} | the field is there and is not null |
None | (nothing) | the question was not asked |
Both are the server’s own spellings, and neither takes an $exists beside it. Measured on
MongoDB 8.2.12 over the nine-document corpus in this module’s tests, {v: {$ne: null}} and
{v: {$exists: true, $ne: null}} return the same five documents — so the presence test is
redundant rather than load-bearing, and writing it would state a distinction the convention above
says this layer does not draw.
The two keys PARTITION the corpus: every one of the nine documents answers exactly one of them. That is the property a two-state question is supposed to have, and it is what the tests check rather than assume.
§An ARRAY holding a null MEMBER answers the null test
MongoDB applies a field operator to an array’s members as well as to the array itself, so a cell
holding [1, null, 3] is returned by {$eq: null} and excluded by {$ne: null} — measured,
both of the corpus’ arrays with a null member answer that way, where each cell plainly holds a
value.
That is the engine’s reading of a stored array rather than anything this wrapper chooses, and
nothing this crate declares reaches it. A stored array is a COLLECTION column; a collection’s
element type needs a DefaultVecMarker row to be a Vec’s default
reading and Option<T> has none; and no shipped MongoCarrier row
produces Bson::Null or Bson::Array at all — the widest is Vec<u8>, which is BinData. A
downstream row that stored one would put its column’s null test under this reading — the same
standing the array-of-arrays contamination MongoListComparison
records has, and the same standing the $-in-a-field-name hazard has: stated, and the row
author’s.
Implementations§
Source§impl<C> MongoNullable<C>
impl<C> MongoNullable<C>
Sourcepub const fn inner(&self) -> &C
pub const fn inner(&self) -> &C
The wrapped comparison — its own operators only. The null test belongs to this type.
Sourcepub fn try_from_filter_with<F, D, V, E>(
filter: Nullable<F>,
f: impl FnMut(D) -> Result<V, E>,
) -> Result<Self, MongoNullableCrossingError<E, <C as TryFromFilter<F::Mapped>>::Error>>
pub fn try_from_filter_with<F, D, V, E>( filter: Nullable<F>, f: impl FnMut(D) -> Result<V, E>, ) -> Result<Self, MongoNullableCrossingError<E, <C as TryFromFilter<F::Mapped>>::Error>>
Cross a Nullable filter into this comparison, converting each OPERAND with f — the SQL
family’s own entry point, and the same one for the same reason.
See SqlNullable::try_from_filter_with
for the composition and for what a declared converter is handed. One vocabulary across the two
families: a declaration writes one operand leg, and which store compiled decides nothing about
what that leg is given.
§Errors
MongoNullableCrossingError::Operand when f refuses an operand and
MongoNullableCrossingError::Inner when the wrapped kind’s own crossing refuses — and this
family has the second in a way the SQL one barely does: MongoBytesComparison declines the
substring operators outright, whatever the operands were.
Sourcepub fn try_from_filter_with_inner<F, E>(
filter: Nullable<F>,
f: impl FnOnce(F) -> Result<C, E>,
) -> Result<Self, E>
pub fn try_from_filter_with_inner<F, E>( filter: Nullable<F>, f: impl FnOnce(F) -> Result<C, E>, ) -> Result<Self, E>
Cross a Nullable filter into this comparison, building the inner comparison with f.
f takes the whole wrapped FILTER rather than an operand, and the name says which: the null
test has no operand to convert, and the inner kind’s crossing is the thing that knows how to
convert its own. It is the entry try_from_filter_with composes.
§Errors
Whatever f refuses the wrapped filter with, and nothing of this wrapper’s own — the null test
has both of its states spelled here, so there is nothing left for the crossing to decline.
Trait Implementations§
Source§impl<C: Clone> Clone for MongoNullable<C>
impl<C: Clone> Clone for MongoNullable<C>
Source§impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoNullable<C>
The inner comparison’s keys, then the null test’s — merged into the same field’s operator
document, which is what keeps the wrapper from opening a second key for a field that already has
one.
impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoNullable<C>
The inner comparison’s keys, then the null test’s — merged into the same field’s operator document, which is what keeps the wrapper from opening a second key for a field that already has one.
§The two keys are SHARED with the kinds, and the fold is what keeps them apart
$eq and $ne are the two most-written keys in this family: the scalar kind spells its own eq
and ne with them, and a collection kind writes $eq for has_element and for a
whole-collection equality. A comparison asking one of those AND the null test is one key twice,
and MongoConjunction::merge folds the second into a top-level $and rather than over the
first.
The fold is an INTERSECTION rather than a last-writer-wins, and the corpus separates the three
possible readings: a nullable list asking has_element: 1 with null: true renders
{v: {$eq: 1}, $and: [{v: {$eq: null}}]}, which returns ONE document — where keeping only the
first key returns two and keeping only the second returns four.
§The null test composes with non-emptiness rather than colliding with it
A collection’s any slot with no operator set renders {$elemMatch: {$exists: true}} — this
field is a non-empty array — and the null test renders beside it under its own key. $exists is
written INSIDE the element scope and never at the field, so the two documents have nothing to
fold. Measured, the pair a nullable list renders for null: false returns exactly the one
non-empty array whose members are all values.
§The whole address passes DOWN untouched
No frame is pushed, because this wrapper is the same field of the same document as its inner — the two conjuncts name one key and the merge is what renders it once.
Source§fn conjuncts(&self) -> usize
fn conjuncts(&self) -> usize
The whole SUBTREE’s count — C’s conjuncts plus this wrapper’s null test — because the
question a caller asks with it is whether anything at all will be rendered.
Source§impl<C: Debug> Debug for MongoNullable<C>
impl<C: Debug> Debug for MongoNullable<C>
Source§impl<C: Default> Default for MongoNullable<C>
impl<C: Default> Default for MongoNullable<C>
Source§impl<C: PartialEq> PartialEq for MongoNullable<C>
impl<C: PartialEq> PartialEq for MongoNullable<C>
impl<C: PartialEq> StructuralPartialEq for MongoNullable<C>
Source§impl<F, C> TryFromFilter<Nullable<F>> for MongoNullable<C>where
C: TryFromFilter<F>,
The crossing composes through C’s, and the error is C’s too — a null test never fails, so the
wrapper adds no way for the crossing to.
impl<F, C> TryFromFilter<Nullable<F>> for MongoNullable<C>where
C: TryFromFilter<F>,
The crossing composes through C’s, and the error is C’s too — a null test never fails, so the
wrapper adds no way for the crossing to.
Auto Trait Implementations§
impl<C> Freeze for MongoNullable<C>where
C: Freeze,
impl<C> RefUnwindSafe for MongoNullable<C>where
C: RefUnwindSafe,
impl<C> Send for MongoNullable<C>where
C: Send,
impl<C> Sync for MongoNullable<C>where
C: Sync,
impl<C> Unpin for MongoNullable<C>where
C: Unpin,
impl<C> UnsafeUnpin for MongoNullable<C>where
C: UnsafeUnpin,
impl<C> UnwindSafe for MongoNullable<C>where
C: UnwindSafe,
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<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,
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.