pub struct RowPacker<'a> {
row: &'a mut Row,
}
Expand description
Packs datums into a Row
.
Creating a RowPacker
via Row::packer
starts a packing operation on the
row. A packing operation always starts from scratch: the existing contents
of the underlying row are cleared.
To complete a packing operation, drop the RowPacker
.
Fields
row: &'a mut Row
Implementations
sourceimpl RowPacker<'_>
impl RowPacker<'_>
fn try_push_proto(&mut self, x: &ProtoDatum) -> Result<(), String>
sourceimpl RowPacker<'_>
impl RowPacker<'_>
sourcepub fn for_existing_row(row: &mut Row) -> RowPacker<'_>
pub fn for_existing_row(row: &mut Row) -> RowPacker<'_>
Constructs a row packer that will pack additional datums into the provided row.
This function is intentionally somewhat inconvenient to call. You
usually want to call Row::packer
instead to start packing from
scratch.
sourcepub fn push<'a, D>(&mut self, datum: D) where
D: Borrow<Datum<'a>>,
pub fn push<'a, D>(&mut self, datum: D) where
D: Borrow<Datum<'a>>,
Extend an existing Row
with a Datum
.
sourcepub fn extend<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
pub fn extend<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
Extend an existing Row
with additional Datum
s.
sourcepub fn try_extend<'a, I, E, D>(&mut self, iter: I) -> Result<(), E> where
I: IntoIterator<Item = Result<D, E>>,
D: Borrow<Datum<'a>>,
pub fn try_extend<'a, I, E, D>(&mut self, iter: I) -> Result<(), E> where
I: IntoIterator<Item = Result<D, E>>,
D: Borrow<Datum<'a>>,
Extend an existing Row
with additional Datum
s.
In the case the iterator produces an error, the pushing of
datums in terminated and the error returned. The Row
will
be incomplete, but it will be safe to read datums from it.
sourcepub fn extend_by_row(&mut self, row: &Row)
pub fn extend_by_row(&mut self, row: &Row)
Appends the datums of an entire Row
.
sourcepub fn push_list_with<F, R>(&mut self, f: F) -> R where
F: FnOnce(&mut RowPacker<'_>) -> R,
pub fn push_list_with<F, R>(&mut self, f: F) -> R where
F: FnOnce(&mut RowPacker<'_>) -> R,
Pushes a DatumList
that is built from a closure.
The supplied closure will be invoked once with a Row
that can be used
to populate the list. It is valid to call any method on the
RowPacker
except for RowPacker::clear
, RowPacker::truncate
,
or RowPacker::truncate_datums
.
Returns the value returned by the closure, if any.
let mut row = Row::default();
row.packer().push_list_with(|row| {
row.push(Datum::String("age"));
row.push(Datum::Int64(42));
});
assert_eq!(
row.unpack_first().unwrap_list().iter().collect::<Vec<_>>(),
vec![Datum::String("age"), Datum::Int64(42)],
);
sourcepub fn push_dict_with<F, R>(&mut self, f: F) -> R where
F: FnOnce(&mut RowPacker<'_>) -> R,
pub fn push_dict_with<F, R>(&mut self, f: F) -> R where
F: FnOnce(&mut RowPacker<'_>) -> R,
Pushes a DatumMap
that is built from a closure.
The supplied closure will be invoked once with a Row
that can be used
to populate the dict.
The closure must alternate pushing string keys and arbitrary values, otherwise reading the dict will cause a panic.
The closure must push keys in ascending order, otherwise equality
checks on the resulting Row
may be wrong and reading the dict IN DEBUG
MODE will cause a panic.
The closure must not call RowPacker::clear
,
RowPacker::truncate
, or RowPacker::truncate_datums
.
Example
let mut row = Row::default();
row.packer().push_dict_with(|row| {
// key
row.push(Datum::String("age"));
// value
row.push(Datum::Int64(42));
// key
row.push(Datum::String("name"));
// value
row.push(Datum::String("bob"));
});
assert_eq!(
row.unpack_first().unwrap_map().iter().collect::<Vec<_>>(),
vec![("age", Datum::Int64(42)), ("name", Datum::String("bob"))]
);
sourcepub fn push_array<'a, I, D>(
&mut self,
dims: &[ArrayDimension],
iter: I
) -> Result<(), InvalidArrayError> where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
pub fn push_array<'a, I, D>(
&mut self,
dims: &[ArrayDimension],
iter: I
) -> Result<(), InvalidArrayError> where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
Convenience function to construct an array from an iter of Datum
s.
Returns an error if the number of elements in iter
does not match
the cardinality of the array as described by dims
, or if the
number of dimensions exceeds MAX_ARRAY_DIMENSIONS
. If an error
occurs, the packer’s state will be unchanged.
sourcepub fn push_list<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
pub fn push_list<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = D>,
D: Borrow<Datum<'a>>,
Convenience function to push a DatumList
from an iter of Datum
s
See RowPacker::push_dict_with
if you need to be able to handle errors
sourcepub fn push_dict<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = (&'a str, D)>,
D: Borrow<Datum<'a>>,
pub fn push_dict<'a, I, D>(&mut self, iter: I) where
I: IntoIterator<Item = (&'a str, D)>,
D: Borrow<Datum<'a>>,
Convenience function to push a DatumMap
from an iter of (&str, Datum)
pairs
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clears the contents of the packer without de-allocating its backing memory.
sourcepub unsafe fn truncate(&mut self, pos: usize)
pub unsafe fn truncate(&mut self, pos: usize)
Truncates the underlying storage to the specified byte position.
Safety
pos
MUST specify a byte offset that lies on a datum boundary.
If pos
specifies a byte offset that is within a datum, the row
packer will produce an invalid row, the unpacking of which may
trigger undefined behavior!
To find the byte offset of a datum boundary, inspect the the packer’s
byte length by calling packer.data().len()
after pushing the desired
number of datums onto the packer.
sourcepub fn truncate_datums(&mut self, n: usize)
pub fn truncate_datums(&mut self, n: usize)
Truncates the underlying row to contain at most the first n
datums.
Trait Implementations
Auto Trait Implementations
impl<'a> RefUnwindSafe for RowPacker<'a>
impl<'a> Send for RowPacker<'a>
impl<'a> Sync for RowPacker<'a>
impl<'a> Unpin for RowPacker<'a>
impl<'a> !UnwindSafe for RowPacker<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> FutureExt for T
impl<T> FutureExt for T
sourcefn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
sourcefn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
sourcefn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
Wrap the input message T
in a tonic::Request
sourceimpl<P, R> ProtoType<R> for P where
R: RustType<P>,
impl<P, R> ProtoType<R> for P where
R: RustType<P>,
sourcefn into_rust(self) -> Result<R, TryFromProtoError>
fn into_rust(self) -> Result<R, TryFromProtoError>
See RustType::from_proto
.
sourcefn from_rust(rust: &R) -> P
fn from_rust(rust: &R) -> P
See RustType::into_proto
.
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more