Struct ExprProperties 

pub struct ExprProperties {
    pub sort_properties: SortProperties,
    pub range: Interval,
    pub preserves_lex_ordering: bool,
    pub strictly_order_preserving: bool,
}

Represents the properties of a PhysicalExpr, including its sorting, range, and whether it preserves lexicographical ordering.

Fields

sort_properties: SortProperties

Properties that describe the sorting behavior of the expression, such as whether it is ordered, unordered, or a singleton value.

range: Interval

A closed interval representing the range of possible values for the expression. Used to compute reliable bounds.

preserves_lex_ordering: bool

Indicates whether the expression preserves lexicographical ordering of its inputs.

This is a non-strict (monotone) property: inputs advancing in lexicographical order never make the output decrease, but distinct inputs may map to equal outputs (ties). See Self::strictly_order_preserving for the strict variant and an explanation of the difference.

strictly_order_preserving: bool

Indicates whether the expression is strictly order-preserving with respect to its inputs that are Ordered: the output is ordered in the same direction, equal outputs can only result from equal values of those inputs (i.e. the mapping is one-to-one), and nulls map to nulls.

i.e. setting this to true means that a.cmp(b) == f(a).cmp(f(b))

Difference from Self::preserves_lex_ordering

The two properties differ in both their premise and their strictness:

• preserves_lex_ordering assumes the inputs advance in lexicographical order (a later input may decrease whenever an earlier one increases), and only promises a non-decreasing output, allowing distinct inputs to collapse into equal outputs; floor, date_trunc and narrowing casts do exactly that.
• strictly_order_preserving assumes every Ordered input advances simultaneously (component-wise, which is what actually holds when all of them are sorted in the data), and promises a strict output: equal outputs only from equal inputs.

For an expression with a single ordered input the premises coincide, and this field is simply the stronger claim: it implies preserves_lex_ordering. With multiple ordered inputs, neither implies the other: a lexicographical-ordering-preserving expression need not be strict (distinct inputs may still produce equal outputs), while a + b over two ordered, overflow-free inputs is strict but not lexicographical (under the lexicographical premise b may decrease while a increases, making the sum decrease).

The distinction matters for suffix sort keys. Optimizers use this field to substitute a sort key with an expression computed from it: if data is sorted by [x, y], it is also sorted by [expr(x), y]. That claim requires y to be sorted within each run of equal expr(x) values, which only holds if equal outputs imply equal x values. With a merely monotone expression such as floor, one output run can span several x groups, and y restarts at each group:

sorted by [x, y]:  (1.2, 5), (1.8, 1), (2.5, 3)
[floor(x), y]:     (1, 5),   (1, 1),   (2, 3)   <-- y not sorted within
                                                    the "1" run

Hence a monotone expression only justifies the length-1 ordering [expr(x)], while a strictly order-preserving one keeps the entire suffix valid. When in doubt, set to false.

Implementations

impl ExprProperties

pub fn new_unknown() -> Self

Creates a new ExprProperties instance with unknown sort properties, unknown range, and unknown lexicographical ordering preservation.

pub fn with_order(self, order: SortProperties) -> Self

Sets the sorting properties of the expression and returns the modified instance.

pub fn with_range(self, range: Interval) -> Self

Sets the range of the expression and returns the modified instance.

pub fn with_preserves_lex_ordering(self, preserves_lex_ordering: bool) -> Self

Sets whether the expression maintains lexicographical ordering and returns the modified instance.

pub fn with_strictly_order_preserving( self, strictly_order_preserving: bool, ) -> Self

Sets whether the expression is strictly order-preserving and returns the modified instance.

Trait Implementations

impl Clone for ExprProperties

fn clone(&self) -> ExprProperties

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprProperties

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

Formats the value using the given formatter.