pub struct Timestamp(/* private fields */);Expand description
An instant on the UTC timeline, to the NANOSECOND, from -9999-01-02T01:59:59Z to
9999-12-30T22:00:00.999999999Z.
The framework’s own temporal citizen, present in EVERY build: jiff is a required dependency
here rather than a vocabulary feature, so a record the FRAMEWORK ships can stamp a time without
the build having asked for a temporal vocabulary first.
Temporal<T> is the other temporal name in this crate and answers the other question — it is the
storage WRAPPER a user-declared jiff or time value crosses into, behind the jiff and time
features, where this type is the framework’s own instant and stands whatever the features say.
§Why a newtype and not jiff::Timestamp itself
The orphan rule, at the one place it actually bites. A filter registration would not have needed
this — to_filter!’s two traits are local, so jiff’s own types are registered here already — but
the WIRE FACE cannot be written for a foreign type: impl async_graphql::ScalarType for jiff::Timestamp is E0117, both halves foreign, which is the same wall graphql::filter:: duration hit and answered with a newtype of its own. A citizen this crate is going to give a
scalar, a comparison and a storage shape to has to be a type this crate owns.
It is also what keeps the SHAPE the framework’s decision rather than jiff’s: the range and the precision above are promises made here, and the columns an instant occupies are chosen here.
§The range, and what refuses
MIN and MAX are jiff’s own bounds and they are not the i64
nanosecond ceiling a Unix timestamp usually carries: there is no 2262 problem here, and no
1677 one either. What they ARE is ±9999 years, chosen by jiff so that either bound combined with
any legal zone offset still lands on a representable civil date.
So the one lossy direction is a SystemTime from outside that span, and it REFUSES —
TryFrom rather than a saturating From, because an instant substituted for the one a
caller handed over is a wrong answer reported as a right one. Nothing else about that crossing is
lossy: nanoseconds survive it in both directions.
§Ordering, equality and hashing are the INSTANT’s
All three are derived, and on a one-field newtype a derive IS the delegation. What makes it the
right delegation is that an instant has nothing to normalise: this type holds no zone and no
offset, so two spellings of one moment — 2026-08-09T21:14:03+09:00 and
2026-08-09T12:14:03Z — parse to one value that compares, hashes and renders as one.
Implementations§
Source§impl Timestamp
impl Timestamp
Sourcepub const UNIX_EPOCH: Self
pub const UNIX_EPOCH: Self
1970-01-01T00:00:00Z, the zero of the timeline.
Sourcepub const fn get(&self) -> Timestamp
pub const fn get(&self) -> Timestamp
The instant as jiff’s own type — the whole of jiff’s arithmetic, zone and calendar surface, reached rather than re-exposed.
By VALUE because jiff::Timestamp is Copy, so a reference would buy an indirection and
no ownership.
Sourcepub fn as_second(&self) -> i64
pub fn as_second(&self) -> i64
The WHOLE seconds since the epoch — the first of the two columns this type occupies.
jiff’s own name for jiff’s own answer. It TRUNCATES towards zero rather than flooring, so a
pre-epoch instant answers a negative second and a negative fraction beside it: -0.5s is
(0, -500_000_000) and not (-1, 500_000_000). That is the pairing
from_parts reads back, and the two halves therefore never disagree in
sign.
Sourcepub fn subsec_nanosecond(&self) -> i32
pub fn subsec_nanosecond(&self) -> i32
The FRACTION, in nanoseconds — the second of the two columns.
Signed, and the sign is the instant’s: see as_second for the pairing the
two answers make together. Its magnitude is always below one second.
Sourcepub fn from_parts(
second: i64,
nanosecond: i32,
) -> Result<Self, TimestampPartsError>
pub fn from_parts( second: i64, nanosecond: i32, ) -> Result<Self, TimestampPartsError>
The instant those two columns hold — the read half of the pair
as_second and subsec_nanosecond write.
§It REFUSES what it would otherwise have NORMALISED, and that is the whole of the check
jiff::Timestamp::new accepts a pair whose halves disagree in sign and quietly resolves it:
(2, -999_999_999) becomes (1, 1), the same instant spelled another way. Read from a column
that is exactly the failure this crate refuses everywhere else — a stored value nothing here
wrote, silently turned into one that could have been. So the pair is built through jiff and
then held against what it answers: a pair that survives unchanged is the pair this encoding
writes, and every other one is Unnormalised.
It is the round trip MongoExtract’s f32 row already
makes for the same reason — narrow, widen, and compare — applied to a value of two integers
rather than to one float.
§Errors
TimestampPartsError::Range carries jiff’s own refusal: a nanosecond outside
-999_999_999..=999_999_999, or a pair naming an instant outside the ±9999-year span.
TimestampPartsError::Unnormalised is the check above, and carries the pair that failed it.
§Examples
use ingraph::Timestamp;
let at: Timestamp = "2026-08-09T21:14:03.123456789Z".parse().unwrap();
assert_eq!(
Timestamp::from_parts(at.as_second(), at.subsec_nanosecond()).unwrap(),
at
);
// The sign-crossing spelling of the same instant is REFUSED rather than resolved.
assert!(Timestamp::from_parts(2, -999_999_999).is_err());
assert_eq!(
Timestamp::from_parts(1, 1).unwrap(),
"1970-01-01T00:00:01.000000001Z".parse::<Timestamp>().unwrap()
);Trait Implementations§
Source§impl<'a, R> Assemble<'a, R> for Timestamp
Available on crate feature sqlx only.AND TWO COLUMNS BACK IN, with the teeth on the way — the read half of the framework’s own
composite, and the third of the three facts a stored one states.
impl<'a, R> Assemble<'a, R> for Timestamp
sqlx only.AND TWO COLUMNS BACK IN, with the teeth on the way — the read half of the framework’s own composite, and the third of the three facts a stored one states.
Each part reads through assembled, so under carries the holder’s segment for a field that
lends its name and nothing extra for one marked flatten, and this one body serves both without
knowing which it is reading. A missing or undecodable part is try_get’s own error naming
at_nanos rather than at, exactly as the trait’s note promises.
§It is the ONE row here that CONSTRUCTS an error, and the reason is the recomposition
Every other row hands try_get’s answer straight back, because a column that decodes into its
Rust type is the whole of what a scalar has to check. Two columns that each decode can still
fail to be an instant — a nanos past a second, a pair whose halves disagree in sign — and
nothing beneath this can see the pair. So the refusal is built here, as
ColumnDecode naming the nanos column: it is the half that
cannot stand beside the other, and it is a name a SELECT can be pointed at.
What is refused rather than resolved is from_parts’s, stated
once for both families — the MongoDB row makes the same call and gives the same answer in its
own vocabulary.
Source§impl<Db> Carrier<Db> for Timestamp
Available on crate feature sqlx only.TWO BINDS OUT, and the comma between them is this row’s.
impl<Db> Carrier<Db> for Timestamp
sqlx only.TWO BINDS OUT, and the comma between them is this row’s.
The framework’s own instant occupies two columns — see
ColumnKind’s row for the width, which is the claim this one has to agree
with. A caller writing a VALUES list counts FIELDS and puts a comma between them; the comma
inside a field is here, because the count is the type’s.
§Generic over the dialect, where a DOWNSTREAM composite names one
The derive corpus’s Timebase writes three rows, one per dialect, and its own note says why: a
generic header from outside this crate would overlap the framework’s rows for a backend that is
not an sqlx::Database, and rustc cannot see from out there that none will arrive. From INSIDE
there is nothing to overlap — this is the only row for this self type — so the header states the
two parts’ own requirements and every dialect that carries an i64 and an i32 gets the
instant for free. All three do.
The parts bind through their OWN rows rather than through push_bind directly, which is what
keeps a dialect’s decision about an integer the dialect’s: Postgres widens four integer widths
here, and a composite that reached past those rows would be a second binding path for the same
value.
Source§fn push_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_bind(&self, qb: &mut QueryBuilder<Db>)
qb. Read moreSource§fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
impl CollectionElement for Timestamp
The framework’s own instant is the first COMPOSITE element, and it carries no collection — its two segments are a whole-seconds integer and a nanosecond one.
It is the row every composite-element form in this crate is measured against, which is what makes
it worth stating here rather than only in the corpus: a Vec<Timestamp> reaches an edge table of
(key…, ordinal, at_secs, at_nanos), and each of the DDL, the write and the correlated predicate
reads those two names off ColumnKind’s row above.
Source§impl ColumnKind for Timestamp
The framework’s own instant is TWO columns, and it is the first shipped type that is.
impl ColumnKind for Timestamp
The framework’s own instant is TWO columns, and it is the first shipped type that is.
It is stated here rather than listed in scalar_columns above, and the list is the
reason: every entry there takes the default and says Plain, so a composite added to it would
be a row whose body contradicts the macro’s own sentence. A composite states its parts, and this
is what stating them looks like for a type this crate owns.
The parts are read from Timestamp’s own module rather than spelled here,
which is the arrangement a DECLARED composite already has — one const its predicate, its
binds, its reads and its sub-document keys all share. A rename there moves SELECT "at_secs",
WHERE "at_secs" = ? and the secs key of a MongoDB sub-document together, and there is no
second list to drift from.
Source§const SEGMENTS: &'static [ColumnShape] = crate::primitives::timestamp::SEGMENTS
const SEGMENTS: &'static [ColumnShape] = crate::primitives::timestamp::SEGMENTS
Source§const ORDER: &'static [OrderLevel] = _
const ORDER: &'static [OrderLevel] = _
impl Copy for Timestamp
Source§impl CursorValue for Timestamp
The framework’s own instant: twelve bytes, both of its columns, and the pair CHECKED on the
way back.
impl CursorValue for Timestamp
The framework’s own instant: twelve bytes, both of its columns, and the pair CHECKED on the way back.
The first row here whose value spans more than one column, and the caller that asks for it is
the storability audit — a record storing a Timestamp cannot be paged past without it, which is
the compile error this row answers rather than a page that resumes at the wrong row. It is
therefore a row written WITH its caller, which is the standard the module note holds Score and
Temporal to while they wait for theirs.
FIXED WIDTH — eight big-endian bytes of seconds and four of nanoseconds — so a client’s eleven are refused rather than zero-extended into a plausible instant. That is the discipline the integer rows above follow, applied to a value of two of them, and it is the derive corpus’s own composite row read one type over.
The recomposition is from_parts’s, which makes this row the
THIRD caller of one authority — the SQL decode and the MongoDB read are the other two — and the
reason it matters here is the trait’s own: returning a plausible value for bytes this type did
not write is how a forged cursor becomes a page. A pair jiff would have normalised is exactly
such a value, so it is refused here as it is refused there.
impl DeclaredLeaves for Timestamp
One leaf, and it is the value. The framework’s instant means its two columns in the sequence it writes them, so a term over one stays the wide term it always was.
Source§impl DefaultMarker for Timestamp
impl DefaultMarker for Timestamp
Source§type Marker = ScalarMarker<Timestamp>
type Marker = ScalarMarker<Timestamp>
Source§impl DefaultVecMarker for Timestamp
impl DefaultVecMarker for Timestamp
Source§impl Display for Timestamp
RFC 3339, with the fewest fractional digits that render the value exactly — 2026-08-09T21:14:03Z
for a whole second, 2026-08-09T21:14:03.123456789Z for one carrying nanoseconds. Never a bare
integer, which is the form a client cannot read.
impl Display for Timestamp
RFC 3339, with the fewest fractional digits that render the value exactly — 2026-08-09T21:14:03Z
for a whole second, 2026-08-09T21:14:03.123456789Z for one carrying nanoseconds. Never a bare
integer, which is the form a client cannot read.
A NEGATIVE year has no RFC 3339 spelling and takes ISO 8601’s expanded form instead
(-009999-01-02T01:59:59Z, which is MIN); every instant from the epoch onwards is
RFC 3339 exactly.
The Formatter is PASSED THROUGH rather than written into, so jiff’s own
precision option survives the newtype: {:.3} still asks for milliseconds and {:.0} still
truncates the fraction away. A write!(f, "{}", …) here would drop both in silence.
impl Eq for Timestamp
Source§impl From<Timestamp> for Timestamp
Legal though jiff::Timestamp is foreign and From is: the trait’s PARAMETER is this
crate’s type, which is what the orphan rule asks for.
impl From<Timestamp> for Timestamp
Legal though jiff::Timestamp is foreign and From is: the trait’s PARAMETER is this
crate’s type, which is what the orphan rule asks for.
Source§impl From<Timestamp> for SystemTime
From and not TryFrom, because jiff’s own crossing is a From and this delegates to it
rather than inventing a second policy. What that impl assumes is a platform time wide enough for
the whole span, which is true where this crate runs — a timespec’s i64 seconds hold ±9999
years many times over — and is not a universal fact: a FILETIME-based SystemTime begins at
1601, and an instant before it would panic inside jiff. Recorded rather than guarded, since a
guard here would be this crate answering for a conversion it does not own.
impl From<Timestamp> for SystemTime
From and not TryFrom, because jiff’s own crossing is a From and this delegates to it
rather than inventing a second policy. What that impl assumes is a platform time wide enough for
the whole span, which is true where this crate runs — a timespec’s i64 seconds hold ±9999
years many times over — and is not a universal fact: a FILETIME-based SystemTime begins at
1601, and an instant before it would panic inside jiff. Recorded rather than guarded, since a
guard here would be this crate answering for a conversion it does not own.
Source§impl FromStr for Timestamp
The inverse of Display, and jiff’s parser rather than a second one: an offset
spelling is accepted and NORMALISED to the instant it names, and a string with no offset at all is
refused — a civil datetime is not an instant, and guessing UTC for it would invent the one fact it
is missing.
impl FromStr for Timestamp
The inverse of Display, and jiff’s parser rather than a second one: an offset
spelling is accepted and NORMALISED to the instant it names, and a string with no offset at all is
refused — a civil datetime is not an instant, and guessing UTC for it would invent the one fact it
is missing.
The error is jiff’s own, kept rather than re-worded: it names the component it refused and where in the input, which is more than a wrapper of this crate’s would say.
Source§impl InputType for Timestamp
impl InputType for Timestamp
Source§type RawValueType = Timestamp
type RawValueType = Timestamp
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 MongoCarrier for Timestamp
Available on crate feature mongo only.The framework’s own instant, as the two flat integers it is — a sub-document holding secs
as an Int64 and nanos as an Int32, under the same two names the SQL family’s columns take.
impl MongoCarrier for Timestamp
mongo only.The framework’s own instant, as the two flat integers it is — a sub-document holding secs
as an Int64 and nanos as an Int32, under the same two names the SQL family’s columns take.
§The Temporal refusal above does not reach it, and the licence is one sentence
That refusal is about BSON’s DATE type: UtcDateTime is an i64 of milliseconds, so a row for
a nanosecond-carrying instant would drop six digits in silence. No BSON date type is involved
here — the value is two integers, both of which BSON holds exactly — so nothing is lost and
the refusal has nothing to say about this row.
A sub-document rather than two fields spliced into the holder, which is the same asymmetry the
flatten refusal on this backend already states: a composite is FLATTENED into columns wherever
a table stores it and stays nested wherever a document does. So the two names are the segment
names unjoined, and a filter reaches them as at.secs and at.nanos where SQL reaches
at_secs and at_nanos.
BSON’s own comparison order compares two sub-documents field by field, in the order they were
written, so a pair written by this row compares by seconds and then by nanoseconds — which IS
the instant’s order, jiff’s signs being matched between the two halves. That is read from
MongoDB’s documented BSON order rather than measured against a live server here, the same
posture this module takes for BinData; the sort itself is not built.
§What a DOCUMENT can hold is a narrower question, and the answer today is measured
This row is what a FILTER operand and — since the write half landed — what a STORED DOCUMENT is
written through: MongoWrite::document walks this
table exactly as from_document walks
MongoExtract’s. So nothing about this type stops it being
stored by the lane.
What still narrows it is the EMITTED row’s own derives: ingraph-codegen’s mongo family derives
serde’s pair on the document struct, and no storage type this crate ships carries a serde row — so
a declaration naming a bare Timestamp column under mongo(…) is E0277 at the declaration,
the trait bound Timestamp: serde::Serialize is not satisfied. That is the same answer a
BeU64 column gets there and the same escape applies: the declaration names a type = "…" with
its own conversions, which is what the derive corpus’s StoredTrack already does for exactly this
reason.
The two halves no longer agree about WHY, and the gap is recorded rather than closed here: the
derive is kept for a consumer’s own bson::to_document/from_document — see emit::mongo, which
says so — and it is now the only party asking for serde, the framework’s own read and write both
going through this crate’s two tables. Removing it would widen what a mongo row may hold to
exactly what those tables cover, and that is the emitter’s change rather than this file’s.
Source§impl MongoExtract for Timestamp
Available on crate feature mongo only.The framework’s own instant, read back out of the two flat integers its carrier wrote.
impl MongoExtract for Timestamp
mongo only.The framework’s own instant, read back out of the two flat integers its carrier wrote.
object, because the pair is a sub-document — see MongoCarrier’s row
for why a composite nests here and flattens in a table, and for the licence that makes this row
exist at all beside the Temporal refusal.
The recomposition is from_parts’s, which is the SAME call the
SQL family’s Assemble row makes: a pair that jiff would have NORMALISED is
refused rather than resolved, so one document and one row cannot disagree about which pairs are
instants. What differs between the two families is only the vocabulary the refusal is spoken in.
Each part is read at ITS OWN BSON type rather than through the i64 and i32 rows above, which
is the shape the derive corpus’s composite takes too: those rows answer for a whole FIELD, and
these two integers are parts of one.
Source§impl Ord for Timestamp
impl Ord for Timestamp
1.21.0 (const: unstable) · Source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.21.0 (const: unstable) · Source§fn min(self, other: Self) -> Selfwhere
Self: Sized,
fn min(self, other: Self) -> Selfwhere
Self: Sized,
Source§impl OutputType for Timestamp
impl OutputType for Timestamp
Source§fn create_type_info(registry: &mut Registry) -> String
fn create_type_info(registry: &mut Registry) -> String
Source§async fn resolve(
&self,
_: &ContextSelectionSet<'_>,
_field: &Positioned<Field>,
) -> ServerResult<Value>
async fn resolve( &self, _: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>
boxed-trait only.async_graphql::Value.Source§fn qualified_type_name() -> String
fn qualified_type_name() -> String
Source§impl PartialOrd for Timestamp
impl PartialOrd for Timestamp
Source§impl ScalarFilterMarker for Timestamp
impl ScalarFilterMarker for Timestamp
Source§type Filter = ScalarFilter<Timestamp>
type Filter = ScalarFilter<Timestamp>
Source§impl ScalarType for Timestamp
An instant on the UTC timeline as RFC 3339 text — 2026-08-09T21:14:03.123456789Z — to the
NANOSECOND, and never a bare integer.
impl ScalarType for Timestamp
An instant on the UTC timeline as RFC 3339 text — 2026-08-09T21:14:03.123456789Z — to the
NANOSECOND, and never a bare integer.
An offset is accepted and normalised: 2026-08-09T21:14:03+09:00 is the same instant as
2026-08-09T12:14:03Z and comes back in the second form. A string with no offset is REFUSED,
because a civil datetime is not an instant and the missing fact is not one a server may invent.
The range is ±9999 years, so a client is not writing against a 2262 ceiling.
Source§fn is_valid(value: &Value) -> bool
fn is_valid(value: &Value) -> bool
The SAME parser parse runs, which is what makes a document that validates a document that
parses. async-graphql’s default is_valid answers true for every value, so a scalar that
narrows in parse alone ships a validator admitting what its own parser rejects — the reason
ConfidenceOperand’s two halves read through one pair of constructors, applied here to a
grammar rather than to a range.
Source§fn parse(value: Value) -> InputValueResult<Self>
fn parse(value: Value) -> InputValueResult<Self>
Source§impl ScalarWire<Timestamp> for Builtin
impl ScalarWire<Timestamp> for Builtin
Source§const NAME: &'static str = "TimestampFilter"
const NAME: &'static str = "TimestampFilter"
T under this reading is published as.Source§type Error = !
type Error = !
Infallible where a crossing cannot refuse.Source§impl<Db> StoredAs<Db> for Timestamp
TWO WORDS OUT, and the pair is read off the parts rather than restated.
impl<Db> StoredAs<Db> for Timestamp
TWO WORDS OUT, and the pair is read off the parts rather than restated.
The framework’s own instant occupies two columns — an i64 second and an i32 subsecond
nanosecond, which is what its Carrier row binds — so its declaration is those
two types’ own words in that order. Nothing here spells bigint or INTEGER: a dialect that
changed its mind about how it stores an i64 would move this row with it.
§Generic over the dialect, which is what the FIXED arity buys
The array has length two whatever Db is, so one impl covers every dialect that carries both
parts — all three do. This is the shape every composite in this crate takes, and the boundary it
stops at is TimeRanged<T>’s: see this module’s note, where the two
compiler refusals are recorded.
impl StructuralPartialEq for Timestamp
Source§impl<Db> ToDatabaseComparison<Timestamp, Db> for TimeRangeFilterwhere
Db: Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
Available on crate feature sqlx only.Every SQL dialect takes the range filter to the range comparison, and the storage type is
Timestamp — the ONE type all four columns hold, so one word covers them.
impl<Db> ToDatabaseComparison<Timestamp, Db> for TimeRangeFilterwhere
Db: Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
sqlx only.Every SQL dialect takes the range filter to the range comparison, and the storage type is
Timestamp — the ONE type all four columns hold, so one word covers them.
Source§type Comparison = SqlTimeRangeComparison<Db>
type Comparison = SqlTimeRangeComparison<Db>
V and lowering for Db.Source§impl ToDatabaseComparison<Timestamp, Mongo> for TimeRangeFilter
Available on crate feature mongo only.The range filter crosses into the range comparison for the one backend this family has, and the
header naming Mongo concretely is what keeps it from overlapping the SQL row — see
MongoScalarComparison’s own note, where the coherence argument is made.
impl ToDatabaseComparison<Timestamp, Mongo> for TimeRangeFilter
mongo only.The range filter crosses into the range comparison for the one backend this family has, and the
header naming Mongo concretely is what keeps it from overlapping the SQL row — see
MongoScalarComparison’s own note, where the coherence argument is made.
Source§type Comparison = MongoTimeRangeComparison
type Comparison = MongoTimeRangeComparison
V and lowering for Db.Source§impl ToGraphqlInput for Timestamp
impl ToGraphqlInput for Timestamp
Source§type Error = !
type Error = !
Infallible where a crossing cannot refuse.Source§impl ToGraphqlOutput for Timestamp
impl ToGraphqlOutput for Timestamp
Source§impl TryFrom<SystemTime> for Timestamp
Fallible in this direction alone, and by RANGE rather than by precision — see the type’s note.
jiff’s own crossing has the same shape and the same reason, so this is a delegation rather than a
second policy.
impl TryFrom<SystemTime> for Timestamp
Fallible in this direction alone, and by RANGE rather than by precision — see the type’s note. jiff’s own crossing has the same shape and the same reason, so this is a delegation rather than a second policy.
Auto Trait Implementations§
impl Freeze for Timestamp
impl RefUnwindSafe for Timestamp
impl Send for Timestamp
impl Sync for Timestamp
impl Unpin for Timestamp
impl UnsafeUnpin for Timestamp
impl UnwindSafe for Timestamp
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<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
Source§impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
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<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
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> OrderLeaves for T
impl<T> OrderLeaves for T
Source§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<K> PositionKey for K
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
impl<T> RootKey for T
impl<T> RuleType for T
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.Source§impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
Source§type Wire<'a> = <T as ToGraphqlOutput>::Output<'a>
where
T: 'a
type Wire<'a> = <T as ToGraphqlOutput>::Output<'a> where T: 'a
async-graphql only.OutputType — the BACKEND’s demand, made where the
backend spends the form.Source§fn wire_score(&self) -> <T as WireScore>::Wire<'_>
fn wire_score(&self) -> <T as WireScore>::Wire<'_>
async-graphql only.