Struct mz_expr::RowSetFinishing

pub struct RowSetFinishing<L = NonNeg<i64>> {
    pub order_by: Vec<ColumnOrder>,
    pub limit: Option<L>,
    pub offset: usize,
    pub project: Vec<usize>,
}

Instructions for finishing the result of a query.

The primary reason for the existence of this structure and attendant code is that SQL’s ORDER BY requires sorting rows (as already implied by the keywords), whereas much of the rest of SQL is defined in terms of unordered multisets. But as it turns out, the same idea can be used to optimize trivial peeks.

Fields

order_by: Vec<ColumnOrder>

Order rows by the given columns.

limit: Option<L>

Include only as many rows (after offset).

offset: usize

Omit as many rows.

project: Vec<usize>

Include only given columns.

Implementations

impl<L> RowSetFinishing<L>

pub fn trivial(arity: usize) -> RowSetFinishing<L>

Returns a trivial finishing, i.e., that does nothing to the result set.

pub fn is_trivial(&self, arity: usize) -> bool

True if the finishing does nothing to any result set.

impl RowSetFinishing

pub fn finish( &self, rows: RowCollection, max_result_size: u64, max_returned_query_size: Option<u64>, duration_histogram: &Histogram, ) -> Result<(SortedRowCollectionIter, usize), String>

Applies finishing actions to a RowCollection, and reports the total time it took to run.

Returns a SortedRowCollectionIter that contains all of the response data, as well as the size of the response in bytes.

fn finish_inner( &self, rows: RowCollection, max_result_size: u64, max_returned_query_size: Option<u64>, ) -> Result<(SortedRowCollectionIter, usize), String>

Implementation for RowSetFinishing::finish.

Trait Implementations

impl<L: Arbitrary> Arbitrary for RowSetFinishing<L>

type Parameters = (<Vec<ColumnOrder> as Arbitrary>::Parameters, <Option<L> as Arbitrary>::Parameters, <usize as Arbitrary>::Parameters, <Vec<usize> as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<Vec<ColumnOrder> as Arbitrary>::Strategy, <Option<L> as Arbitrary>::Strategy, <usize as Arbitrary>::Strategy, <Vec<usize> as Arbitrary>::Strategy), fn(_: (Vec<ColumnOrder>, Option<L>, usize, Vec<usize>)) -> RowSetFinishing<L>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<L: Clone> Clone for RowSetFinishing<L>

fn clone(&self) -> RowSetFinishing<L>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: Debug> Debug for RowSetFinishing<L>

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

Formats the value using the given formatter.

impl<'de, L> Deserialize<'de> for RowSetFinishing<L>

where L: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L: PartialEq> PartialEq for RowSetFinishing<L>

fn eq(&self, other: &RowSetFinishing<L>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RustType<ProtoRowSetFinishing> for RowSetFinishing

fn into_proto(&self) -> ProtoRowSetFinishing

Convert a Self into a Proto value.

fn from_proto(x: ProtoRowSetFinishing) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl<L> Serialize for RowSetFinishing<L>

where L: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L: Eq> Eq for RowSetFinishing<L>

impl<L> StructuralPartialEq for RowSetFinishing<L>