cleanup

Signed-off-by: jayzhan211 <[email protected]>

datafusion/physical-expr-common/Cargo.toml

@@ -17,7 +17,7 @@
 
 [package]
 name = "datafusion-physical-expr-common"
-description = "Core physical expression implementation for DataFusion query engine"
+description = "Common functionality of physical expression for DataFusion query engine"
 keywords = ["arrow", "query", "sql"]
 readme = "README.md"
 version = { workspace = true }

datafusion/physical-expr-common/src/physical_expr.rs

@@ -32,65 +32,8 @@ use datafusion_expr::ColumnarValue;
 use crate::sort_properties::SortProperties;
 use crate::utils::scatter;
 
-/// `PhysicalExpr` evaluate DataFusion expressions such as `A + 1`, or `CAST(c1
-/// AS int)`.
-///
-/// `PhysicalExpr` are the physical counterpart to [`Expr`] used in logical
-/// planning, and can be evaluated directly on a [`RecordBatch`]. They are
-/// normally created from `Expr` by a [`PhysicalPlanner`] and can be created
-/// directly using [`create_physical_expr`].
-///
-/// A Physical expression knows its type, nullability and how to evaluate itself.
-///
-/// [`Expr`]: datafusion_expr::Expr
-/// [`PhysicalPlanner`]: https://docs.rs/datafusion/latest/datafusion/physical_planner/trait.PhysicalPlanner.html
-/// [`create_physical_expr`]: https://docs.rs/datafusion/latest/datafusion/physical_expr/fn.create_physical_expr.html
-///
-/// # Example: Create `PhysicalExpr` from `Expr`
-/// ```ignore
-/// # use arrow::datatypes::{DataType, Field, Schema};
-/// # use datafusion_common::DFSchema;
-/// # use datafusion_expr::{Expr, col, lit};
-/// # use datafusion_physical_expr::create_physical_expr;
-/// # use datafusion_expr::execution_props::ExecutionProps;
-/// // For a logical expression `a = 1`, we can create a physical expression
-/// let expr = col("a").eq(lit(1));
-/// // To create a PhysicalExpr we need 1. a schema
-/// let schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
-/// let df_schema = DFSchema::try_from(schema).unwrap();
-/// // 2. ExecutionProps
-/// let props = ExecutionProps::new();
-/// // We can now create a PhysicalExpr:
-/// let physical_expr = create_physical_expr(&expr, &df_schema, &props).unwrap();
-/// ```
-///
-/// # Example: Executing a PhysicalExpr to obtain [`ColumnarValue`]
-/// ```ignore
-/// # use std::sync::Arc;
-/// # use arrow::array::{cast::AsArray, BooleanArray, Int32Array, RecordBatch};
-/// # use arrow::datatypes::{DataType, Field, Schema};
-/// # use datafusion_common::{assert_batches_eq, DFSchema};
-/// # use datafusion_expr::{Expr, col, lit, ColumnarValue};
-/// # use datafusion_physical_expr::create_physical_expr;
-/// # use datafusion_expr::execution_props::ExecutionProps;
-/// # let expr = col("a").eq(lit(1));
-/// # let schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
-/// # let df_schema = DFSchema::try_from(schema.clone()).unwrap();
-/// # let props = ExecutionProps::new();
-/// // Given a PhysicalExpr, for `a = 1` we can evaluate it against a RecordBatch like this:
-/// let physical_expr = create_physical_expr(&expr, &df_schema, &props).unwrap();
-/// // Input of [1,2,3]
-/// let input_batch = RecordBatch::try_from_iter(vec![
-///   ("a", Arc::new(Int32Array::from(vec![1, 2, 3])) as _)
-/// ]).unwrap();
-/// // The result is a ColumnarValue (either an Array or a Scalar)
-/// let result = physical_expr.evaluate(&input_batch).unwrap();
-/// // In this case, a BooleanArray with the result of the comparison
-/// let ColumnarValue::Array(arr) = result else {
-///  panic!("Expected an array")
-/// };
-/// assert_eq!(arr.as_boolean(), &BooleanArray::from(vec![true, false, false]));
-/// ```
+/// See [create_physical_expr](https://docs.rs/datafusion/latest/datafusion/physical_expr/fn.create_physical_expr.html)
+/// for examples of creating `PhysicalExpr` from `Expr`
 pub trait PhysicalExpr: Send + Sync + Display + Debug + PartialEq<dyn Any> {
     /// Returns the physical expression as [`Any`] so that it can be
     /// downcast to a specific implementation.

datafusion/physical-expr/src/expressions/mod.rs

@@ -81,7 +81,7 @@ pub use binary::{binary, BinaryExpr};
 pub use case::{case, CaseExpr};
 pub use cast::{cast, cast_with_options, CastExpr};
 pub use column::UnKnownColumn;
-pub use datafusion_physical_expr_core::expressions::column::{col, Column};
+pub use datafusion_physical_expr_common::expressions::column::{col, Column};
 pub use in_list::{in_list, InListExpr};
 pub use is_not_null::{is_not_null, IsNotNullExpr};
 pub use is_null::{is_null, IsNullExpr};

datafusion/physical-expr/src/planner.rs

@@ -33,6 +33,67 @@ use datafusion_expr::{
 };
 use std::sync::Arc;
 
+/// [PhysicalExpr] evaluate DataFusion expressions such as `A + 1`, or `CAST(c1
+/// AS int)`.
+///
+/// [PhysicalExpr] are the physical counterpart to [Expr] used in logical
+/// planning, and can be evaluated directly on a [RecordBatch]. They are
+/// normally created from [Expr] by a [PhysicalPlanner] and can be created
+/// directly using [create_physical_expr].
+///
+/// A Physical expression knows its type, nullability and how to evaluate itself.
+///
+/// [PhysicalPlanner]: https://docs.rs/datafusion/latest/datafusion/physical_planner/trait.PhysicalPlanner.html
+/// [RecordBatch]: https://docs.rs/arrow/latest/arrow/record_batch/struct.RecordBatch.html
+///
+/// # Example: Create `PhysicalExpr` from `Expr`
+/// ```
+/// # use arrow::datatypes::{DataType, Field, Schema};
+/// # use datafusion_common::DFSchema;
+/// # use datafusion_expr::{Expr, col, lit};
+/// # use datafusion_physical_expr::create_physical_expr;
+/// # use datafusion_expr::execution_props::ExecutionProps;
+/// // For a logical expression `a = 1`, we can create a physical expression
+/// let expr = col("a").eq(lit(1));
+/// // To create a PhysicalExpr we need 1. a schema
+/// let schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
+/// let df_schema = DFSchema::try_from(schema).unwrap();
+/// // 2. ExecutionProps
+/// let props = ExecutionProps::new();
+/// // We can now create a PhysicalExpr:
+/// let physical_expr = create_physical_expr(&expr, &df_schema, &props).unwrap();
+/// ```
+///
+/// # Example: Executing a PhysicalExpr to obtain [ColumnarValue]
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow::array::{cast::AsArray, BooleanArray, Int32Array, RecordBatch};
+/// # use arrow::datatypes::{DataType, Field, Schema};
+/// # use datafusion_common::{assert_batches_eq, DFSchema};
+/// # use datafusion_expr::{Expr, col, lit, ColumnarValue};
+/// # use datafusion_physical_expr::create_physical_expr;
+/// # use datafusion_expr::execution_props::ExecutionProps;
+/// # let expr = col("a").eq(lit(1));
+/// # let schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
+/// # let df_schema = DFSchema::try_from(schema.clone()).unwrap();
+/// # let props = ExecutionProps::new();
+/// // Given a PhysicalExpr, for `a = 1` we can evaluate it against a RecordBatch like this:
+/// let physical_expr = create_physical_expr(&expr, &df_schema, &props).unwrap();
+/// // Input of [1,2,3]
+/// let input_batch = RecordBatch::try_from_iter(vec![
+///   ("a", Arc::new(Int32Array::from(vec![1, 2, 3])) as _)
+/// ]).unwrap();
+/// // The result is a ColumnarValue (either an Array or a Scalar)
+/// let result = physical_expr.evaluate(&input_batch).unwrap();
+/// // In this case, a BooleanArray with the result of the comparison
+/// let ColumnarValue::Array(arr) = result else {
+///  panic!("Expected an array")
+/// };
+/// assert_eq!(arr.as_boolean(), &BooleanArray::from(vec![true, false, false]));
+/// ```
+///
+/// [ColumnarValue]: datafusion_expr::ColumnarValue
+///
 /// Create a physical expression from a logical expression ([Expr]).
 ///
 /// # Arguments