Docs.rs
  • datafusion-physical-expr-47.0.0
    • datafusion-physical-expr 47.0.0
    • Permalink
    • Docs.rs crate page
    • Apache-2.0
    • Links
    • Homepage
    • Repository
    • crates.io
    • Source
    • Owners
    • andygrove
    • alamb
    • Dependencies
      • ahash ^0.8 normal
      • arrow ^55.0.0 normal
      • datafusion-common ^47.0.0 normal
      • datafusion-expr ^47.0.0 normal
      • datafusion-expr-common ^47.0.0 normal
      • datafusion-functions-aggregate-common ^47.0.0 normal
      • datafusion-physical-expr-common ^47.0.0 normal
      • half ^2.5.0 normal
      • hashbrown ^0.14.5 normal
      • indexmap ^2.9.0 normal
      • itertools ^0.14 normal
      • log ^0.4 normal
      • paste ^1.0 normal
      • petgraph ^0.7.1 normal
      • arrow ^55.0.0 dev
      • criterion ^0.5.1 dev
      • datafusion-functions ^47.0.0 dev
      • insta ^1.41.1 dev
      • rand ^0.8.5 dev
      • rstest ^0.24.0 dev
    • Versions
    • 78.67% of the crate is documented
  • Platform
    • i686-unknown-linux-gnu
    • x86_64-unknown-linux-gnu
  • Feature flags
  • docs.rs
    • About docs.rs
    • Privacy policy
  • Rust
    • Rust website
    • The Book
    • Standard Library API Reference
    • Rust by Example
    • The Cargo Guide
    • Clippy Documentation

Crate datafusion_physical_expr

logo

datafusion_physical_expr47.0.0

  • All Items

Crate Items

  • Re-exports
  • Modules
  • Structs
  • Enums
  • Traits
  • Functions
  • Type Aliases

Crates

  • datafusion_physical_expr

Crate datafusion_physical_expr

Source

Re-exports§

pub use analysis::analyze;
pub use analysis::AnalysisContext;
pub use analysis::ExprBoundaries;
pub use equivalence::calculate_union;
pub use equivalence::AcrossPartitions;
pub use equivalence::ConstExpr;
pub use equivalence::EquivalenceProperties;
pub use planner::create_physical_expr;
pub use planner::create_physical_exprs;
pub use utils::conjunction;
pub use utils::conjunction_opt;
pub use utils::split_conjunction;

Modules§

aggregate
analysis
Interval and selectivity in AnalysisContext
binary_map
equivalence
execution_props
expressions
Defines physical expressions that can evaluated at runtime during query execution
intervals
Interval arithmetic and constraint propagation library
planner
statistics
Statistics and constraint propagation library
tree_node
utils
window

Structs§

GroupsAccumulatorAdapter
An adapter that implements GroupsAccumulator for any Accumulator
LexOrdering
LexOrdering contains a Vec<PhysicalSortExpr>, which represents a lexicographical ordering.
LexRequirement
LexRequirement is an struct containing a Vec<PhysicalSortRequirement>, which represents a lexicographical ordering requirement.
NullState
Track the accumulator null state per row: if any values for that group were null and if any values have been seen at all for that group.
PhysicalSortExpr
Represents Sort operation for a column in a RecordBatch
PhysicalSortRequirement
Represents sort requirement associated with a plan
ScalarFunctionExpr
Physical expression of a scalar function

Enums§

Distribution
How data is distributed amongst partitions. See Partitioning for more details.
Partitioning
Output partitioning supported by ExecutionPlans.

Traits§

PhysicalExpr
PhysicalExprs represent expressions such as A + 1 or CAST(c1 AS int).

Functions§

create_ordering
Converts logical sort expressions to physical sort expressions
create_physical_sort_expr
Create a physical sort expression from a logical expression
create_physical_sort_exprs
Create vector of physical sort expression from a vector of logical expression
physical_exprs_bag_equal
Checks whether the given physical expression slices are equal in the sense of bags (multi-sets), disregarding their orderings.
physical_exprs_contains
This function is similar to the contains method of Vec. It finds whether expr is among physical_exprs.
physical_exprs_equal
Checks whether the given physical expression slices are equal.
reverse_order_bys
Reverses the ORDER BY expression, which is useful during equivalent window expression construction. For instance, ‘ORDER BY a ASC, NULLS LAST’ turns into ‘ORDER BY a DESC, NULLS FIRST’.

Type Aliases§

PhysicalExprRef
Shared PhysicalExpr.

Results

Settings
Help

Type "create_physical_expr" not found. Showing results for closest type name "physicalexpr" instead.

    function
    datafusion_physical_expr::planner::create_physical_expr
    PhysicalExpr evaluate DataFusion expressions such as A + 1…
    function
    datafusion_physical_expr::planner::create_physical_exprs
    Create vector of Physical Expression from a vector of …
    method
    datafusion_physical_expr::equivalence::ConstExpr::new
    Arc<PhysicalExpr> -> ConstExpr
    Create a new constant expression from a physical …
    method
    datafusion_physical_expr::expressions::IsNotNullExpr::new
    Arc<PhysicalExpr> -> IsNotNullExpr
    Create new not expression
    method
    datafusion_physical_expr::expressions::IsNullExpr::new
    Arc<PhysicalExpr> -> IsNullExpr
    Create new not expression
    method
    datafusion_physical_expr::expressions::NegativeExpr::new
    Arc<PhysicalExpr> -> NegativeExpr
    Create new not expression
    method
    datafusion_physical_expr::expressions::NotExpr::new
    Arc<PhysicalExpr> -> NotExpr
    Create new not expression
    method
    datafusion_physical_expr::equivalence::ConstExpr::from
    Arc<PhysicalExpr> -> ConstExpr
    method
    datafusion_physical_expr::PhysicalSortExpr::new_default
    Arc<PhysicalExpr> -> PhysicalSortExpr
    Create a new PhysicalSortExpr with default SortOptions
    method
    datafusion_physical_expr::PhysicalSortExpr::new
    Arc<PhysicalExpr>, SortOptions -> PhysicalSortExpr
    Create a new PhysicalSortExpr
    method
    datafusion_physical_expr::expressions::TryCastExpr::new
    Arc<PhysicalExpr>, DataType -> TryCastExpr
    Create a new CastExpr
    trait method
    datafusion_physical_expr::PhysicalExpr::as_any
    &PhysicalExpr -> &Any
    Returns the physical expression as Any so that it can be …
    method
    datafusion_physical_expr::PhysicalSortRequirement::with_expr
    PhysicalSortRequirement, Arc<PhysicalExpr> -> PhysicalSortRequirement
    Replace the required expression for this requirement with …
    method
    datafusion_physical_expr::tree_node::ExprContext::new_unknown
    Arc<PhysicalExpr> -> ExprContext<ExprProperties>
    Constructs a new ExprPropertiesNode with unknown …
    method
    datafusion_physical_expr::intervals::cp_solver::ExprIntervalGraphNode::new_with_interval
    Arc<PhysicalExpr>, Interval -> ExprIntervalGraphNode
    Constructs a new DAEG node with the given range.
    method
    datafusion_physical_expr::PhysicalExpr::eq
    &PhysicalExpr, &PhysicalExpr -> bool
    method
    datafusion_physical_expr::PhysicalSortRequirement::new
    Arc<PhysicalExpr>, Option<SortOptions> -> PhysicalSortRequirement
    Creates a new requirement.
    function
    datafusion_physical_expr::expressions::not
    Arc<PhysicalExpr> -> Result<Arc<PhysicalExpr>>
    Creates a unary expression NOT
    method
    datafusion_physical_expr::utils::LiteralGuarantee::analyze
    &Arc<PhysicalExpr> -> Vec<LiteralGuarantee>
    Return a list of LiteralGuarantees that must be satisfied …
    function
    datafusion_physical_expr::expressions::is_null
    Arc<PhysicalExpr> -> Result<Arc<PhysicalExpr>>
    Create an IS NULL expression
    function
    datafusion_physical_expr::expressions::is_not_null
    Arc<PhysicalExpr> -> Result<Arc<PhysicalExpr>>
    Create an IS NOT NULL expression
    method
    datafusion_physical_expr::tree_node::ExprContext::new_default
    Arc<PhysicalExpr> -> ExprContext<T>
    function
    datafusion_physical_expr::utils::collect_columns
    &Arc<PhysicalExpr> -> HashSet<Column>
    Recursively extract referenced Columns within a …
    function
    datafusion_physical_expr::equivalence::add_offset_to_expr
    Arc<PhysicalExpr>, usize -> Arc<PhysicalExpr>
    Adds the offset value to Column indices inside expr. This …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::get_expr_properties
    &EquivalenceProperties, Arc<PhysicalExpr> -> ExprProperties
    Retrieves the properties for a given physical expression.
    method
    datafusion_physical_expr::expressions::BinaryExpr::new
    Arc<PhysicalExpr>, Operator, Arc<PhysicalExpr> -> BinaryExpr
    Create new binary expression
    method
    datafusion_physical_expr::expressions::CastExpr::new
    Arc<PhysicalExpr>, DataType, Option<CastOptions> -> CastExpr
    Create a new CastExpr
    method
    datafusion_physical_expr::equivalence::EquivalenceClass::push
    &mut EquivalenceClass, Arc<PhysicalExpr> -> ()
    Insert the expression into this class, meaning it is known …
    method
    datafusion_physical_expr::intervals::cp_solver::ExprIntervalGraph::try_new
    Arc<PhysicalExpr>, &Schema -> Result<ExprIntervalGraph>
    method
    datafusion_physical_expr::statistics::stats_solver::ExprStatisticsGraph::try_new
    Arc<PhysicalExpr>, &Schema -> Result<ExprStatisticsGraph>
    trait method
    datafusion_physical_expr::PhysicalExpr::children
    &PhysicalExpr -> Vec<&Arc<PhysicalExpr>>
    Get a list of child PhysicalExpr that provide the input …
    method
    datafusion_physical_expr::equivalence::EquivalenceClass::contains
    &EquivalenceClass, &Arc<PhysicalExpr> -> bool
    Returns true if this equivalence class contains t …
    method
    datafusion_physical_expr::PhysicalExpr::arc_children
    &PhysicalExpr -> Vec<&Arc<PhysicalExpr>>
    function
    datafusion_physical_expr::intervals::utils::check_support
    &Arc<PhysicalExpr>, &SchemaRef -> bool
    Indicates whether interval arithmetic is supported for the …
    method
    datafusion_physical_expr::intervals::cp_solver::ExprIntervalGraphNode::new_unbounded
    Arc<PhysicalExpr>, &DataType -> Result<ExprIntervalGraphNode>
    Constructs a new DAEG node with an [-∞, ∞] range.
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::normalize_expr
    &EquivalenceGroup, Arc<PhysicalExpr> -> Arc<PhysicalExpr>
    Normalizes the given physical expression according to this …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::is_expr_constant
    &EquivalenceProperties, &Arc<PhysicalExpr> -> bool
    This function determines whether the provided expression …
    method
    datafusion_physical_expr::equivalence::OrderingEquivalenceClass::is_expr_partial_const
    &OrderingEquivalenceClass, &Arc<PhysicalExpr> -> bool
    Checks whether the given expression is partially constant …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::get_expr_constant_value
    &EquivalenceProperties, &Arc<PhysicalExpr> -> AcrossPartitions
    Retrieves the constant value of a given physical …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::is_expr_constant_across_partitions
    &EquivalenceProperties, &Arc<PhysicalExpr> -> bool
    This function determines whether the provided expression …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::is_expr_constant_accross_partitions
    &EquivalenceProperties, &Arc<PhysicalExpr> -> bool
    This function determines whether the provided expression …
    method
    datafusion_physical_expr::expressions::LikeExpr::new
    bool, bool, Arc<PhysicalExpr>, Arc<PhysicalExpr> -> LikeExpr
    method
    datafusion_physical_expr::PhysicalExpr::hash
    &PhysicalExpr, &mut H -> ()
    trait method
    datafusion_physical_expr::PhysicalExpr::evaluate
    &PhysicalExpr, &RecordBatch -> Result<ColumnarValue, DataFusionError>
    Evaluate an expression against a RecordBatch
    function
    datafusion_physical_expr::expressions::negative
    Arc<PhysicalExpr>, &Schema -> Result<Arc<PhysicalExpr>>
    Creates a unary expression NEGATIVE
    trait method
    datafusion_physical_expr::PhysicalExpr::nullable
    &PhysicalExpr, &Schema -> Result<bool, DataFusionError>
    Determine whether this expression is nullable, given the …
    method
    datafusion_physical_expr::PhysicalExpr::snapshot
    &PhysicalExpr -> Result<Option<Arc<PhysicalExpr>>, DataFusionError>
    Take a snapshot of this PhysicalExpr, if it is dynamic.
    trait method
    datafusion_physical_expr::PhysicalExpr::data_type
    &PhysicalExpr, &Schema -> Result<DataType, DataFusionError>
    Get the data type of this expression, given the schema of …
    method
    datafusion_physical_expr::equivalence::OrderingEquivalenceClass::get_options
    &OrderingEquivalenceClass, &Arc<PhysicalExpr> -> Option<SortOptions>
    Gets sort options associated with this expression if it is …
    function
    datafusion_physical_expr::expressions::with_new_schema
    Arc<PhysicalExpr>, &SchemaRef -> Result<Arc<PhysicalExpr>>
    Rewrites an expression according to new schema; i.e. …
    function
    datafusion_physical_expr::utils::split_conjunction
    &Arc<PhysicalExpr> -> Vec<&Arc<PhysicalExpr>>
    Assume the predicate is in the form of CNF, split the …
    function
    datafusion_physical_expr::utils::split_disjunction
    &Arc<PhysicalExpr> -> Vec<&Arc<PhysicalExpr>>
    Assume the predicate is in the form of DNF, split the …
    method
    datafusion_physical_expr::tree_node::ExprContext::new
    Arc<PhysicalExpr>, T, Vec<ExprContext<T>> -> ExprContext<T>
    function
    datafusion_physical_expr::expressions::cast
    Arc<PhysicalExpr>, &Schema, DataType -> Result<Arc<PhysicalExpr>>
    Return a PhysicalExpression representing expr casted to …
    function
    datafusion_physical_expr::analysis::analyze
    &Arc<PhysicalExpr>, AnalysisContext, &Schema -> Result<AnalysisContext>
    Attempts to refine column boundaries and compute a …
    trait method
    datafusion_physical_expr::PhysicalExpr::fmt_sql
    &PhysicalExpr, &mut Formatter -> Result<(), Error>
    Format this PhysicalExpr in nice human readable “SQL” …
    function
    datafusion_physical_expr::expressions::try_cast
    Arc<PhysicalExpr>, &Schema, DataType -> Result<Arc<PhysicalExpr>>
    Return a PhysicalExpression representing expr casted to …
    method
    datafusion_physical_expr::equivalence::ProjectionMapping::target_expr
    &ProjectionMapping, &Arc<PhysicalExpr> -> Option<Arc<PhysicalExpr>>
    This function returns the target expression for a given …
    method
    datafusion_physical_expr::PhysicalExpr::get_properties
    &PhysicalExpr, &[ExprProperties] -> Result<ExprProperties, DataFusionError>
    Calculates the properties of this PhysicalExpr based on its
    function
    datafusion_physical_expr::physical_exprs_contains
    &[Arc<PhysicalExpr>], &Arc<PhysicalExpr> -> bool
    This function is similar to the contains method of Vec. It …
    function
    datafusion_physical_expr::utils::reassign_predicate_columns
    Arc<PhysicalExpr>, &SchemaRef, bool -> Result<Arc<PhysicalExpr>>
    Re-assign column indices referenced in predicate according …
    method
    datafusion_physical_expr::expressions::InListExpr::new
    Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>>, bool, Option<Arc<>> -> InListExpr
    Create a new InList expression
    function
    datafusion_physical_expr::expressions::similar_to
    bool, bool, Arc<PhysicalExpr>, Arc<PhysicalExpr> -> Result<Arc<PhysicalExpr>>
    Create a similar to expression
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::exprs_equal
    &EquivalenceGroup, &Arc<PhysicalExpr>, &Arc<PhysicalExpr> -> bool
    Checks if two expressions are equal either directly or …
    method
    datafusion_physical_expr::PhysicalExpr::evaluate_bounds
    &PhysicalExpr, &[&Interval] -> Result<Interval, DataFusionError>
    Computes the output interval for the expression, given the …
    trait method
    datafusion_physical_expr::PhysicalExpr::with_new_children
    Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>> -> Result<Arc<PhysicalExpr>, DataFusionError>
    Returns a new PhysicalExpr where all children were …
    method
    datafusion_physical_expr::PhysicalExpr::evaluate_selection
    &PhysicalExpr, &RecordBatch, &BooleanArray -> Result<ColumnarValue, DataFusionError>
    Evaluate an expression against a RecordBatch after first …
    method
    datafusion_physical_expr::PhysicalExpr::evaluate_statistics
    &PhysicalExpr, &[&Distribution] -> Result<Distribution, DataFusionError>
    Computes the output statistics for the expression, given …
    function
    datafusion_physical_expr::expressions::binary
    Arc<PhysicalExpr>, Operator, Arc<PhysicalExpr>, &Schema -> Result<Arc<PhysicalExpr>>
    Create a binary expression whose arguments are correctly …
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::project_expr
    &EquivalenceGroup, &ProjectionMapping, &Arc<PhysicalExpr> -> Option<Arc<PhysicalExpr>>
    Projects expr according to the given projection mapping. …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::project_expr
    &EquivalenceProperties, &Arc<PhysicalExpr>, &ProjectionMapping -> Option<Arc<PhysicalExpr>>
    Projects argument expr according to projection_mapping, …
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::add_equal_conditions
    &mut EquivalenceGroup, &Arc<PhysicalExpr>, &Arc<PhysicalExpr> -> ()
    Adds the equality left = right to this equivalence group. …
    function
    datafusion_physical_expr::expressions::like
    bool, bool, Arc<PhysicalExpr>, Arc<PhysicalExpr>, &Schema -> Result<Arc<PhysicalExpr>>
    Create a like expression, erroring if the argument types …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::add_equal_conditions
    &mut EquivalenceProperties, &Arc<PhysicalExpr>, &Arc<PhysicalExpr> -> Result<()>
    Adds a new equality condition into the existing …
    method
    datafusion_physical_expr::PhysicalExpr::with_new_arc_children
    &PhysicalExpr, Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>> -> Result<Arc<PhysicalExpr>, DataFusionError>
    function
    datafusion_physical_expr::expressions::in_list
    Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>>, &bool, &Schema -> Result<Arc<PhysicalExpr>>
    Creates a unary expression InList
    method
    datafusion_physical_expr::PhysicalExpr::propagate_statistics
    &PhysicalExpr, &Distribution, &[&Distribution] -> Result<Option<Vec<Distribution>>, DataFusionError>
    Updates children statistics using the given parent …
    method
    datafusion_physical_expr::PhysicalExpr::propagate_constraints
    &PhysicalExpr, &Interval, &[&Interval] -> Result<Option<Vec<Interval>>, DataFusionError>
    Updates bounds for child expressions, given a known …
    method
    datafusion_physical_expr::expressions::CaseExpr::try_new
    Option<Arc<PhysicalExpr>>, Vec<(Arc<PhysicalExpr>, Arc<PhysicalExpr>)>, Option<Arc<PhysicalExpr>> -> Result<CaseExpr>
    Create a new CASE WHEN expression
    function
    datafusion_physical_expr::expressions::case
    Option<Arc<PhysicalExpr>>, Vec<(Arc<PhysicalExpr>, Arc<PhysicalExpr>)>, Option<Arc<PhysicalExpr>> -> Result<Arc<PhysicalExpr>>
    Create a CASE expression
    function
    datafusion_physical_expr::utils::build_dag
    Arc<PhysicalExpr>, &F -> Result<(NodeIndex, StableGraph<T, usize>)>
    function
    datafusion_physical_expr::intervals::test_utils::gen_conjunctive_temporal_expr
    Arc<PhysicalExpr>, Arc<PhysicalExpr>, Operator, Operator, Operator, Operator, ScalarValue, ScalarValue, ScalarValue, ScalarValue, &Schema -> Result<Arc<PhysicalExpr>, DataFusionError>
    This test function generates a conjunctive statement with …
    function
    datafusion_physical_expr::intervals::test_utils::gen_conjunctive_numerical_expr
    Arc<PhysicalExpr>, Arc<PhysicalExpr>, (Operator, Operator, Operator, Operator), ScalarValue, ScalarValue, ScalarValue, ScalarValue, (Operator, Operator) -> Arc<PhysicalExpr>
    This test function generates a conjunctive statement with …
    method
    datafusion_physical_expr::equivalence::ConstExpr::owned_expr
    ConstExpr -> Arc<PhysicalExpr>
    function
    datafusion_physical_expr::expressions::lit
    T -> Arc<PhysicalExpr>
    Create a literal expression
    method
    datafusion_physical_expr::PhysicalSortExpr::as_ref
    &PhysicalSortExpr -> &PhysicalExpr
    method
    datafusion_physical_expr::expressions::IsNotNullExpr::arg
    &IsNotNullExpr -> &Arc<PhysicalExpr>
    Get the input expression
    method
    datafusion_physical_expr::expressions::IsNullExpr::arg
    &IsNullExpr -> &Arc<PhysicalExpr>
    Get the input expression
    method
    datafusion_physical_expr::expressions::NegativeExpr::arg
    &NegativeExpr -> &Arc<PhysicalExpr>
    Get the input expression
    method
    datafusion_physical_expr::expressions::NotExpr::arg
    &NotExpr -> &Arc<PhysicalExpr>
    Get the input expression
    method
    datafusion_physical_expr::expressions::InListExpr::expr
    &InListExpr -> &Arc<PhysicalExpr>
    Input expression
    method
    datafusion_physical_expr::expressions::CastExpr::expr
    &CastExpr -> &Arc<PhysicalExpr>
    The expression to cast
    method
    datafusion_physical_expr::expressions::LikeExpr::expr
    &LikeExpr -> &Arc<PhysicalExpr>
    Input expression
    method
    datafusion_physical_expr::expressions::TryCastExpr::expr
    &TryCastExpr -> &Arc<PhysicalExpr>
    The expression to cast
    method
    datafusion_physical_expr::equivalence::ConstExpr::expr
    &ConstExpr -> &Arc<PhysicalExpr>
    method
    datafusion_physical_expr::expressions::BinaryExpr::left
    &BinaryExpr -> &Arc<PhysicalExpr>
    Get the left side of the binary expression
    method
    datafusion_physical_expr::expressions::BinaryExpr::right
    &BinaryExpr -> &Arc<PhysicalExpr>
    Get the right side of the binary expression
    method
    datafusion_physical_expr::expressions::LikeExpr::pattern
    &LikeExpr -> &Arc<PhysicalExpr>
    Pattern expression
    method
    datafusion_physical_expr::expressions::CaseExpr::expr
    &CaseExpr -> Option<&Arc<PhysicalExpr>>
    Optional base expression that can be compared to literal …
    method
    datafusion_physical_expr::expressions::CaseExpr::else_expr
    &CaseExpr -> Option<&Arc<PhysicalExpr>>
    Optional “else” expression
    function
    datafusion_physical_expr::planner::logical2physical
    &Expr, &Schema -> Arc<PhysicalExpr>
    Convert a logical expression to a physical expression …
    function
    datafusion_physical_expr::utils::conjunction
    IntoIterator<Item=Arc<PhysicalExpr>> -> Arc<PhysicalExpr>
    Create a conjunction of the given predicates. If the input …
    function
    datafusion_physical_expr::utils::conjunction_opt
    IntoIterator<Item=Arc<PhysicalExpr>> -> Option<Arc<PhysicalExpr>>
    Create a conjunction of the given predicates. If the input …
    function
    datafusion_physical_expr::equivalence::add_offset_to_expr
    Arc<PhysicalExpr>, usize -> Arc<PhysicalExpr>
    Adds the offset value to Column indices inside expr. This …
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::normalize_expr
    &EquivalenceGroup, Arc<PhysicalExpr> -> Arc<PhysicalExpr>
    Normalizes the given physical expression according to this …
    method
    datafusion_physical_expr::PhysicalExpr::snapshot
    &PhysicalExpr -> Result<Option<Arc<PhysicalExpr>>, DataFusionError>
    Take a snapshot of this PhysicalExpr, if it is dynamic.
    method
    datafusion_physical_expr::equivalence::ProjectionMapping::target_expr
    &ProjectionMapping, &Arc<PhysicalExpr> -> Option<Arc<PhysicalExpr>>
    This function returns the target expression for a given …
    trait method
    datafusion_physical_expr::PhysicalExpr::with_new_children
    Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>> -> Result<Arc<PhysicalExpr>, DataFusionError>
    Returns a new PhysicalExpr where all children were …
    method
    datafusion_physical_expr::equivalence::EquivalenceGroup::project_expr
    &EquivalenceGroup, &ProjectionMapping, &Arc<PhysicalExpr> -> Option<Arc<PhysicalExpr>>
    Projects expr according to the given projection mapping. …
    method
    datafusion_physical_expr::equivalence::EquivalenceProperties::project_expr
    &EquivalenceProperties, &Arc<PhysicalExpr>, &ProjectionMapping -> Option<Arc<PhysicalExpr>>
    Projects argument expr according to projection_mapping, …
    method
    datafusion_physical_expr::PhysicalExpr::with_new_arc_children
    &PhysicalExpr, Arc<PhysicalExpr>, Vec<Arc<PhysicalExpr>> -> Result<Arc<PhysicalExpr>, DataFusionError>
    function
    datafusion_physical_expr::intervals::test_utils::gen_conjunctive_temporal_expr
    Arc<PhysicalExpr>, Arc<PhysicalExpr>, Operator, Operator, Operator, Operator, ScalarValue, ScalarValue, ScalarValue, ScalarValue, &Schema -> Result<Arc<PhysicalExpr>, DataFusionError>
    This test function generates a conjunctive statement with …
    function
    datafusion_physical_expr::intervals::test_utils::gen_conjunctive_numerical_expr
    Arc<PhysicalExpr>, Arc<PhysicalExpr>, (Operator, Operator, Operator, Operator), ScalarValue, ScalarValue, ScalarValue, ScalarValue, (Operator, Operator) -> Arc<PhysicalExpr>
    This test function generates a conjunctive statement with …