This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new b685e2d4f1 chore: fix typos of expr, functions, optimizer,
physical-expr-common, physical-expr, and physical-plan packages (#11538)
b685e2d4f1 is described below
commit b685e2d4f1f245dd1dbe468b32b115ae99316689
Author: JasonLi <[email protected]>
AuthorDate: Fri Jul 19 03:22:39 2024 +0800
chore: fix typos of expr, functions, optimizer, physical-expr-common,
physical-expr, and physical-plan packages (#11538)
---
datafusion/expr/src/aggregate_function.rs | 4 ++--
datafusion/expr/src/expr.rs | 6 +++---
datafusion/expr/src/expr_rewriter/mod.rs | 4 ++--
datafusion/expr/src/logical_plan/builder.rs | 6 +++---
datafusion/expr/src/logical_plan/display.rs | 4 ++--
datafusion/expr/src/logical_plan/plan.rs | 6 +++---
datafusion/expr/src/partition_evaluator.rs | 2 +-
datafusion/expr/src/signature.rs | 2 +-
datafusion/expr/src/type_coercion/binary.rs | 4 ++--
datafusion/expr/src/type_coercion/functions.rs | 2 +-
datafusion/expr/src/type_coercion/mod.rs | 2 +-
datafusion/expr/src/utils.rs | 2 +-
.../src/approx_percentile_cont_with_weight.rs | 2 +-
datafusion/functions-array/src/remove.rs | 2 +-
datafusion/functions/src/core/arrow_cast.rs | 2 +-
datafusion/functions/src/datetime/to_local_time.rs | 4 ++--
datafusion/functions/src/regex/regexpreplace.rs | 2 +-
datafusion/functions/src/unicode/substrindex.rs | 8 ++++----
datafusion/optimizer/src/analyzer/subquery.rs | 4 ++--
datafusion/optimizer/src/common_subexpr_eliminate.rs | 4 ++--
datafusion/optimizer/src/decorrelate_predicate_subquery.rs | 2 +-
.../optimizer/src/optimize_projections/required_indices.rs | 2 +-
datafusion/optimizer/src/push_down_filter.rs | 2 +-
.../optimizer/src/simplify_expressions/expr_simplifier.rs | 4 ++--
datafusion/optimizer/src/unwrap_cast_in_comparison.rs | 2 +-
.../src/aggregate/groups_accumulator/accumulate.rs | 4 ++--
datafusion/physical-expr-common/src/aggregate/mod.rs | 4 ++--
datafusion/physical-expr-common/src/binary_map.rs | 4 ++--
datafusion/physical-expr-common/src/expressions/column.rs | 2 +-
.../src/aggregate/groups_accumulator/adapter.rs | 2 +-
datafusion/physical-expr/src/aggregate/min_max.rs | 2 +-
datafusion/physical-expr/src/equivalence/class.rs | 2 +-
datafusion/physical-expr/src/expressions/case.rs | 2 +-
datafusion/physical-expr/src/expressions/column.rs | 2 +-
datafusion/physical-expr/src/expressions/try_cast.rs | 2 +-
datafusion/physical-expr/src/utils/guarantee.rs | 2 +-
datafusion/physical-plan/src/aggregates/group_values/row.rs | 2 +-
datafusion/physical-plan/src/aggregates/mod.rs | 6 +++---
datafusion/physical-plan/src/analyze.rs | 2 +-
datafusion/physical-plan/src/display.rs | 2 +-
datafusion/physical-plan/src/joins/cross_join.rs | 2 +-
datafusion/physical-plan/src/joins/nested_loop_join.rs | 2 +-
datafusion/physical-plan/src/joins/sort_merge_join.rs | 2 +-
datafusion/physical-plan/src/joins/symmetric_hash_join.rs | 2 +-
datafusion/physical-plan/src/joins/utils.rs | 12 ++++++------
datafusion/physical-plan/src/limit.rs | 2 +-
datafusion/physical-plan/src/repartition/mod.rs | 6 +++---
datafusion/physical-plan/src/sorts/sort.rs | 8 ++++----
datafusion/physical-plan/src/streaming.rs | 2 +-
datafusion/physical-plan/src/test/exec.rs | 2 +-
datafusion/physical-plan/src/topk/mod.rs | 8 ++++----
datafusion/physical-plan/src/windows/mod.rs | 2 +-
datafusion/physical-plan/src/windows/window_agg_exec.rs | 2 +-
datafusion/physical-plan/src/work_table.rs | 2 +-
54 files changed, 89 insertions(+), 89 deletions(-)
diff --git a/datafusion/expr/src/aggregate_function.rs
b/datafusion/expr/src/aggregate_function.rs
index 3cae78eaed..39b3b4ed3b 100644
--- a/datafusion/expr/src/aggregate_function.rs
+++ b/datafusion/expr/src/aggregate_function.rs
@@ -152,8 +152,8 @@ mod tests {
use strum::IntoEnumIterator;
#[test]
- // Test for AggregateFuncion's Display and from_str() implementations.
- // For each variant in AggregateFuncion, it converts the variant to a
string
+ // Test for AggregateFunction's Display and from_str() implementations.
+ // For each variant in AggregateFunction, it converts the variant to a
string
// and then back to a variant. The test asserts that the original variant
and
// the reconstructed variant are the same. This assertion is also
necessary for
// function suggestion. See
https://github.com/apache/datafusion/issues/8082
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
index a344e621dd..e3620501d9 100644
--- a/datafusion/expr/src/expr.rs
+++ b/datafusion/expr/src/expr.rs
@@ -109,7 +109,7 @@ use sqlparser::ast::NullTreatment;
/// ## Binary Expressions
///
/// Exprs implement traits that allow easy to understand construction of more
-/// complex expresions. For example, to create `c1 + c2` to add columns "c1"
and
+/// complex expressions. For example, to create `c1 + c2` to add columns "c1"
and
/// "c2" together
///
/// ```
@@ -1398,7 +1398,7 @@ impl Expr {
}
Ok(TreeNodeRecursion::Continue)
})
- .expect("traversal is infallable");
+ .expect("traversal is infallible");
}
/// Return all references to columns and their occurrence counts in the
expression.
@@ -1433,7 +1433,7 @@ impl Expr {
}
Ok(TreeNodeRecursion::Continue)
})
- .expect("traversal is infallable");
+ .expect("traversal is infallible");
}
/// Returns true if there are any column references in this Expr
diff --git a/datafusion/expr/src/expr_rewriter/mod.rs
b/datafusion/expr/src/expr_rewriter/mod.rs
index 91bec501f4..8d460bdc8e 100644
--- a/datafusion/expr/src/expr_rewriter/mod.rs
+++ b/datafusion/expr/src/expr_rewriter/mod.rs
@@ -155,7 +155,7 @@ pub fn unnormalize_col(expr: Expr) -> Expr {
})
})
.data()
- .expect("Unnormalize is infallable")
+ .expect("Unnormalize is infallible")
}
/// Create a Column from the Scalar Expr
@@ -201,7 +201,7 @@ pub fn strip_outer_reference(expr: Expr) -> Expr {
})
})
.data()
- .expect("strip_outer_reference is infallable")
+ .expect("strip_outer_reference is infallible")
}
/// Returns plan with expressions coerced to types compatible with
diff --git a/datafusion/expr/src/logical_plan/builder.rs
b/datafusion/expr/src/logical_plan/builder.rs
index 4ad3bd5018..98e262f0b1 100644
--- a/datafusion/expr/src/logical_plan/builder.rs
+++ b/datafusion/expr/src/logical_plan/builder.rs
@@ -412,14 +412,14 @@ impl LogicalPlanBuilder {
/// Add missing sort columns to all downstream projection
///
- /// Thus, if you have a LogialPlan that selects A and B and have
+ /// Thus, if you have a LogicalPlan that selects A and B and have
/// not requested a sort by C, this code will add C recursively to
/// all input projections.
///
/// Adding a new column is not correct if there is a `Distinct`
/// node, which produces only distinct values of its
/// inputs. Adding a new column to its input will result in
- /// potententially different results than with the original column.
+ /// potentially different results than with the original column.
///
/// For example, if the input is like:
///
@@ -1763,7 +1763,7 @@ mod tests {
.unwrap();
assert_eq!(&expected, plan.schema().as_ref());
- // Note scan of "EMPLOYEE_CSV" is treated as a SQL identifer
+ // Note scan of "EMPLOYEE_CSV" is treated as a SQL identifier
// (and thus normalized to "employee"csv") as well
let projection = None;
let plan =
diff --git a/datafusion/expr/src/logical_plan/display.rs
b/datafusion/expr/src/logical_plan/display.rs
index 81fd03555a..343eda056f 100644
--- a/datafusion/expr/src/logical_plan/display.rs
+++ b/datafusion/expr/src/logical_plan/display.rs
@@ -338,9 +338,9 @@ impl<'a, 'b> PgJsonVisitor<'a, 'b> {
.collect::<Vec<_>>()
.join(", ");
- let elipse = if values.len() > 5 { "..." } else { "" };
+ let eclipse = if values.len() > 5 { "..." } else { "" };
- let values_str = format!("{}{}", str_values, elipse);
+ let values_str = format!("{}{}", str_values, eclipse);
json!({
"Node Type": "Values",
"Values": values_str
diff --git a/datafusion/expr/src/logical_plan/plan.rs
b/datafusion/expr/src/logical_plan/plan.rs
index bde9655b8a..48fa6270b2 100644
--- a/datafusion/expr/src/logical_plan/plan.rs
+++ b/datafusion/expr/src/logical_plan/plan.rs
@@ -263,7 +263,7 @@ pub enum LogicalPlan {
/// Prepare a statement and find any bind parameters
/// (e.g. `?`). This is used to implement SQL-prepared statements.
Prepare(Prepare),
- /// Data Manipulaton Language (DML): Insert / Update / Delete
+ /// Data Manipulation Language (DML): Insert / Update / Delete
Dml(DmlStatement),
/// Data Definition Language (DDL): CREATE / DROP TABLES / VIEWS / SCHEMAS
Ddl(DdlStatement),
@@ -1598,8 +1598,8 @@ impl LogicalPlan {
})
.collect();
- let elipse = if values.len() > 5 { "..." } else { "" };
- write!(f, "Values: {}{}", str_values.join(", "),
elipse)
+ let eclipse = if values.len() > 5 { "..." } else { ""
};
+ write!(f, "Values: {}{}", str_values.join(", "),
eclipse)
}
LogicalPlan::TableScan(TableScan {
diff --git a/datafusion/expr/src/partition_evaluator.rs
b/datafusion/expr/src/partition_evaluator.rs
index 04b6faf55a..a0f0988b4f 100644
--- a/datafusion/expr/src/partition_evaluator.rs
+++ b/datafusion/expr/src/partition_evaluator.rs
@@ -135,7 +135,7 @@ pub trait PartitionEvaluator: Debug + Send {
/// must produce an output column with one output row for every
/// input row.
///
- /// `num_rows` is requied to correctly compute the output in case
+ /// `num_rows` is required to correctly compute the output in case
/// `values.len() == 0`
///
/// Implementing this function is an optimization: certain window
diff --git a/datafusion/expr/src/signature.rs b/datafusion/expr/src/signature.rs
index fba793dd22..eadd7ac2f8 100644
--- a/datafusion/expr/src/signature.rs
+++ b/datafusion/expr/src/signature.rs
@@ -65,7 +65,7 @@ pub enum Volatility {
/// automatically coerces (add casts to) function arguments so they match the
type signature.
///
/// For example, a function like `cos` may only be implemented for `Float64`
arguments. To support a query
-/// that calles `cos` with a different argument type, such as
`cos(int_column)`, type coercion automatically
+/// that calls `cos` with a different argument type, such as
`cos(int_column)`, type coercion automatically
/// adds a cast such as `cos(CAST int_column AS DOUBLE)` during planning.
///
/// # Data Types
diff --git a/datafusion/expr/src/type_coercion/binary.rs
b/datafusion/expr/src/type_coercion/binary.rs
index 70139aaa4a..e1765b5c3e 100644
--- a/datafusion/expr/src/type_coercion/binary.rs
+++ b/datafusion/expr/src/type_coercion/binary.rs
@@ -370,7 +370,7 @@ impl From<&DataType> for TypeCategory {
/// The rules in the document provide a clue, but adhering strictly to them
doesn't precisely
/// align with the behavior of Postgres. Therefore, we've made slight
adjustments to the rules
/// to better match the behavior of both Postgres and DuckDB. For example, we
expect adjusted
-/// decimal percision and scale when coercing decimal types.
+/// decimal precision and scale when coercing decimal types.
pub fn type_union_resolution(data_types: &[DataType]) -> Option<DataType> {
if data_types.is_empty() {
return None;
@@ -718,7 +718,7 @@ pub fn get_wider_type(lhs: &DataType, rhs: &DataType) ->
Result<DataType> {
(Int16 | Int32 | Int64, Int8) | (Int32 | Int64, Int16) | (Int64,
Int32) |
// Left Float is larger than right Float.
(Float32 | Float64, Float16) | (Float64, Float32) |
- // Left String is larget than right String.
+ // Left String is larger than right String.
(LargeUtf8, Utf8) |
// Any left type is wider than a right hand side Null.
(_, Null) => lhs.clone(),
diff --git a/datafusion/expr/src/type_coercion/functions.rs
b/datafusion/expr/src/type_coercion/functions.rs
index b430b343e4..ef52a01e05 100644
--- a/datafusion/expr/src/type_coercion/functions.rs
+++ b/datafusion/expr/src/type_coercion/functions.rs
@@ -646,7 +646,7 @@ mod tests {
vec![DataType::UInt8, DataType::UInt16],
Some(vec![DataType::UInt8, DataType::UInt16]),
),
- // 2 entries, can coerse values
+ // 2 entries, can coerce values
(
vec![DataType::UInt16, DataType::UInt16],
vec![DataType::UInt8, DataType::UInt16],
diff --git a/datafusion/expr/src/type_coercion/mod.rs
b/datafusion/expr/src/type_coercion/mod.rs
index 86005da3da..e0d1236aac 100644
--- a/datafusion/expr/src/type_coercion/mod.rs
+++ b/datafusion/expr/src/type_coercion/mod.rs
@@ -19,7 +19,7 @@
//!
//! Coercion is performed automatically by DataFusion when the types
//! of arguments passed to a function or needed by operators do not
-//! exacty match the types required by that function / operator. In
+//! exactly match the types required by that function / operator. In
//! this case, DataFusion will attempt to *coerce* the arguments to
//! types accepted by the function by inserting CAST operations.
//!
diff --git a/datafusion/expr/src/utils.rs b/datafusion/expr/src/utils.rs
index 45155cbd2c..889aa0952e 100644
--- a/datafusion/expr/src/utils.rs
+++ b/datafusion/expr/src/utils.rs
@@ -1212,7 +1212,7 @@ pub fn merge_schema(inputs: Vec<&LogicalPlan>) ->
DFSchema {
}
}
-/// Build state name. State is the intermidiate state of the aggregate
function.
+/// Build state name. State is the intermediate state of the aggregate
function.
pub fn format_state_name(name: &str, state_name: &str) -> String {
format!("{name}[{state_name}]")
}
diff --git
a/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs
b/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs
index a64218c606..0dbea1fb1f 100644
--- a/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs
+++ b/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs
@@ -43,7 +43,7 @@ make_udaf_expr_and_func!(
approx_percentile_cont_with_weight_udaf
);
-/// APPROX_PERCENTILE_CONT_WITH_WEIGTH aggregate expression
+/// APPROX_PERCENTILE_CONT_WITH_WEIGHT aggregate expression
pub struct ApproxPercentileContWithWeight {
signature: Signature,
approx_percentile_cont: ApproxPercentileCont,
diff --git a/datafusion/functions-array/src/remove.rs
b/datafusion/functions-array/src/remove.rs
index 589dd4d0c4..0b7cfc283c 100644
--- a/datafusion/functions-array/src/remove.rs
+++ b/datafusion/functions-array/src/remove.rs
@@ -228,7 +228,7 @@ fn array_remove_internal(
}
}
-/// For each element of `list_array[i]`, removed up to `arr_n[i]` occurences
+/// For each element of `list_array[i]`, removed up to `arr_n[i]` occurrences
/// of `element_array[i]`.
///
/// The type of each **element** in `list_array` must be the same as the type
of
diff --git a/datafusion/functions/src/core/arrow_cast.rs
b/datafusion/functions/src/core/arrow_cast.rs
index 9c410d4e18..9227f9e3a2 100644
--- a/datafusion/functions/src/core/arrow_cast.rs
+++ b/datafusion/functions/src/core/arrow_cast.rs
@@ -444,7 +444,7 @@ fn is_separator(c: char) -> bool {
}
#[derive(Debug)]
-/// Splits a strings like Dictionary(Int32, Int64) into tokens sutable for
parsing
+/// Splits a strings like Dictionary(Int32, Int64) into tokens suitable for
parsing
///
/// For example the string "Timestamp(Nanosecond, None)" would be parsed into:
///
diff --git a/datafusion/functions/src/datetime/to_local_time.rs
b/datafusion/functions/src/datetime/to_local_time.rs
index c84d1015bd..634e28e6f3 100644
--- a/datafusion/functions/src/datetime/to_local_time.rs
+++ b/datafusion/functions/src/datetime/to_local_time.rs
@@ -84,7 +84,7 @@ impl ToLocalTimeFunc {
let arg_type = time_value.data_type();
match arg_type {
DataType::Timestamp(_, None) => {
- // if no timezone specificed, just return the input
+ // if no timezone specified, just return the input
Ok(time_value.clone())
}
// If has timezone, adjust the underlying time value. The current
time value
@@ -165,7 +165,7 @@ impl ToLocalTimeFunc {
match array.data_type() {
Timestamp(_, None) => {
- // if no timezone specificed, just return the
input
+ // if no timezone specified, just return the
input
Ok(time_value.clone())
}
Timestamp(Nanosecond, Some(_)) => {
diff --git a/datafusion/functions/src/regex/regexpreplace.rs
b/datafusion/functions/src/regex/regexpreplace.rs
index 378b6ced07..d820f991be 100644
--- a/datafusion/functions/src/regex/regexpreplace.rs
+++ b/datafusion/functions/src/regex/regexpreplace.rs
@@ -562,7 +562,7 @@ mod tests {
#[test]
fn test_static_pattern_regexp_replace_pattern_error() {
let values = StringArray::from(vec!["abc"; 5]);
- // Delibaretely using an invalid pattern to see how the single pattern
+ // Deliberately using an invalid pattern to see how the single pattern
// error is propagated on regexp_replace.
let patterns = StringArray::from(vec!["["; 5]);
let replacements = StringArray::from(vec!["foo"; 5]);
diff --git a/datafusion/functions/src/unicode/substrindex.rs
b/datafusion/functions/src/unicode/substrindex.rs
index a057e42985..f8ecab9073 100644
--- a/datafusion/functions/src/unicode/substrindex.rs
+++ b/datafusion/functions/src/unicode/substrindex.rs
@@ -122,15 +122,15 @@ pub fn substr_index<T: OffsetSizeTrait>(args:
&[ArrayRef]) -> Result<ArrayRef> {
let occurrences =
usize::try_from(n.unsigned_abs()).unwrap_or(usize::MAX);
let length = if n > 0 {
- let splitted = string.split(delimiter);
- splitted
+ let split = string.split(delimiter);
+ split
.take(occurrences)
.map(|s| s.len() + delimiter.len())
.sum::<usize>()
- delimiter.len()
} else {
- let splitted = string.rsplit(delimiter);
- splitted
+ let split = string.rsplit(delimiter);
+ split
.take(occurrences)
.map(|s| s.len() + delimiter.len())
.sum::<usize>()
diff --git a/datafusion/optimizer/src/analyzer/subquery.rs
b/datafusion/optimizer/src/analyzer/subquery.rs
index db39f8f773..9856ea271c 100644
--- a/datafusion/optimizer/src/analyzer/subquery.rs
+++ b/datafusion/optimizer/src/analyzer/subquery.rs
@@ -159,11 +159,11 @@ fn check_inner_plan(
let (correlated, _): (Vec<_>, Vec<_>) =
split_conjunction(predicate)
.into_iter()
.partition(|e| e.contains_outer());
- let maybe_unsupport = correlated
+ let maybe_unsupported = correlated
.into_iter()
.filter(|expr| !can_pullup_over_aggregation(expr))
.collect::<Vec<_>>();
- if is_aggregate && is_scalar && !maybe_unsupport.is_empty() {
+ if is_aggregate && is_scalar && !maybe_unsupported.is_empty() {
return plan_err!(
"Correlated column is not allowed in predicate:
{predicate}"
);
diff --git a/datafusion/optimizer/src/common_subexpr_eliminate.rs
b/datafusion/optimizer/src/common_subexpr_eliminate.rs
index e4b3665297..bbf2091c22 100644
--- a/datafusion/optimizer/src/common_subexpr_eliminate.rs
+++ b/datafusion/optimizer/src/common_subexpr_eliminate.rs
@@ -248,7 +248,7 @@ impl CommonSubexprEliminate {
}
/// Rewrites the expression in `exprs_list` with common sub-expressions
- /// replaced with a new colum and adds a ProjectionExec on top of `input`
+ /// replaced with a new column and adds a ProjectionExec on top of `input`
/// which computes any replaced common sub-expressions.
///
/// Returns a tuple of:
@@ -636,7 +636,7 @@ impl CommonSubexprEliminate {
/// Returns the window expressions, and the input to the deepest child
/// LogicalPlan.
///
-/// For example, if the input widnow looks like
+/// For example, if the input window looks like
///
/// ```text
/// LogicalPlan::Window(exprs=[a, b, c])
diff --git a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs
b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs
index 4e3ca7e33a..b6d49490d4 100644
--- a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs
+++ b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs
@@ -1232,7 +1232,7 @@ mod tests {
}
#[test]
- fn in_subquery_muti_project_subquery_cols() -> Result<()> {
+ fn in_subquery_multi_project_subquery_cols() -> Result<()> {
let table_scan = test_table_scan()?;
let subquery_scan = test_table_scan_with_name("sq")?;
diff --git a/datafusion/optimizer/src/optimize_projections/required_indices.rs
b/datafusion/optimizer/src/optimize_projections/required_indices.rs
index 3f32a0c36a..a9a18898c8 100644
--- a/datafusion/optimizer/src/optimize_projections/required_indices.rs
+++ b/datafusion/optimizer/src/optimize_projections/required_indices.rs
@@ -160,7 +160,7 @@ impl RequiredIndicies {
(l, r.map_indices(|idx| idx - n))
}
- /// Partitions the indicies in this instance into two groups based on the
+ /// Partitions the indices in this instance into two groups based on the
/// given predicate function `f`.
fn partition<F>(&self, f: F) -> (Self, Self)
where
diff --git a/datafusion/optimizer/src/push_down_filter.rs
b/datafusion/optimizer/src/push_down_filter.rs
index 20e2ac07df..33b2883d6e 100644
--- a/datafusion/optimizer/src/push_down_filter.rs
+++ b/datafusion/optimizer/src/push_down_filter.rs
@@ -1913,7 +1913,7 @@ mod tests {
assert_optimized_plan_eq(plan, expected)
}
- /// post-join predicates with columns from both sides are converted to
join filterss
+ /// post-join predicates with columns from both sides are converted to
join filters
#[test]
fn filter_join_on_common_dependent() -> Result<()> {
let table_scan = test_table_scan()?;
diff --git a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
index 8414f39f30..56556f387d 100644
--- a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
+++ b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
@@ -478,7 +478,7 @@ struct ConstEvaluator<'a> {
#[allow(dead_code)]
/// The simplify result of ConstEvaluator
enum ConstSimplifyResult {
- // Expr was simplifed and contains the new expression
+ // Expr was simplified and contains the new expression
Simplified(ScalarValue),
// Expr was not simplified and original value is returned
NotSimplified(ScalarValue),
@@ -519,7 +519,7 @@ impl<'a> TreeNodeRewriter for ConstEvaluator<'a> {
fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>> {
match self.can_evaluate.pop() {
// Certain expressions such as `CASE` and `COALESCE` are short
circuiting
- // and may not evalute all their sub expressions. Thus if
+ // and may not evaluate all their sub expressions. Thus if
// if any error is countered during simplification, return the
original
// so that normal evaluation can occur
Some(true) => {
diff --git a/datafusion/optimizer/src/unwrap_cast_in_comparison.rs
b/datafusion/optimizer/src/unwrap_cast_in_comparison.rs
index 7238dd5bbd..e0f50a470d 100644
--- a/datafusion/optimizer/src/unwrap_cast_in_comparison.rs
+++ b/datafusion/optimizer/src/unwrap_cast_in_comparison.rs
@@ -893,7 +893,7 @@ mod tests {
DataType::Timestamp(TimeUnit::Nanosecond, utc)
}
- // a dictonary type for storing string tags
+ // a dictionary type for storing string tags
fn dictionary_tag_type() -> DataType {
DataType::Dictionary(Box::new(DataType::Int32),
Box::new(DataType::Utf8))
}
diff --git
a/datafusion/physical-expr-common/src/aggregate/groups_accumulator/accumulate.rs
b/datafusion/physical-expr-common/src/aggregate/groups_accumulator/accumulate.rs
index f109079f6a..3fcd570f51 100644
---
a/datafusion/physical-expr-common/src/aggregate/groups_accumulator/accumulate.rs
+++
b/datafusion/physical-expr-common/src/aggregate/groups_accumulator/accumulate.rs
@@ -410,7 +410,7 @@ pub fn accumulate_indices<F>(
},
);
- // handle any remaining bits (after the intial 64)
+ // handle any remaining bits (after the initial 64)
let remainder_bits = bit_chunks.remainder_bits();
group_indices_remainder
.iter()
@@ -835,7 +835,7 @@ mod test {
}
}
- /// Parallel implementaiton of NullState to check expected values
+ /// Parallel implementation of NullState to check expected values
#[derive(Debug, Default)]
struct MockNullState {
/// group indices that had values that passed the filter
diff --git a/datafusion/physical-expr-common/src/aggregate/mod.rs
b/datafusion/physical-expr-common/src/aggregate/mod.rs
index 0e245fd0a6..7a4a3a6cac 100644
--- a/datafusion/physical-expr-common/src/aggregate/mod.rs
+++ b/datafusion/physical-expr-common/src/aggregate/mod.rs
@@ -346,7 +346,7 @@ impl AggregateExpr for AggregateFunctionExpr {
let accumulator = self.fun.create_sliding_accumulator(args)?;
// Accumulators that have window frame startings different
- // than `UNBOUNDED PRECEDING`, such as `1 PRECEEDING`, need to
+ // than `UNBOUNDED PRECEDING`, such as `1 PRECEDING`, need to
// implement retract_batch method in order to run correctly
// currently in DataFusion.
//
@@ -377,7 +377,7 @@ impl AggregateExpr for AggregateFunctionExpr {
// 3. Third sum we add to the state sum value between `[2, 3)`
// (`[0, 2)` is already in the state sum). Also we need to
// retract values between `[0, 1)` by this way we can obtain sum
- // between [1, 3) which is indeed the apropriate range.
+ // between [1, 3) which is indeed the appropriate range.
//
// When we use `UNBOUNDED PRECEDING` in the query starting
// index will always be 0 for the desired range, and hence the
diff --git a/datafusion/physical-expr-common/src/binary_map.rs
b/datafusion/physical-expr-common/src/binary_map.rs
index bff571f5b5..2328070101 100644
--- a/datafusion/physical-expr-common/src/binary_map.rs
+++ b/datafusion/physical-expr-common/src/binary_map.rs
@@ -355,7 +355,7 @@ where
assert_eq!(values.len(), batch_hashes.len());
for (value, &hash) in values.iter().zip(batch_hashes.iter()) {
- // hande null value
+ // handle null value
let Some(value) = value else {
let payload = if let Some(&(payload, _offset)) =
self.null.as_ref() {
payload
@@ -439,7 +439,7 @@ where
// Put the small values into buffer and offsets so it
// appears the output array, and store that offset
// so the bytes can be compared if needed
- let offset = self.buffer.len(); // offset of start fof data
+ let offset = self.buffer.len(); // offset of start for data
self.buffer.append_slice(value);
self.offsets.push(O::usize_as(self.buffer.len()));
diff --git a/datafusion/physical-expr-common/src/expressions/column.rs
b/datafusion/physical-expr-common/src/expressions/column.rs
index 956c33d59b..d972d35b9e 100644
--- a/datafusion/physical-expr-common/src/expressions/column.rs
+++ b/datafusion/physical-expr-common/src/expressions/column.rs
@@ -80,7 +80,7 @@ impl PhysicalExpr for Column {
Ok(input_schema.field(self.index).data_type().clone())
}
- /// Decide whehter this expression is nullable, given the schema of the
input
+ /// Decide whether this expression is nullable, given the schema of the
input
fn nullable(&self, input_schema: &Schema) -> Result<bool> {
self.bounds_check(input_schema)?;
Ok(input_schema.field(self.index).is_nullable())
diff --git
a/datafusion/physical-expr/src/aggregate/groups_accumulator/adapter.rs
b/datafusion/physical-expr/src/aggregate/groups_accumulator/adapter.rs
index 9856e1c989..592c130b69 100644
--- a/datafusion/physical-expr/src/aggregate/groups_accumulator/adapter.rs
+++ b/datafusion/physical-expr/src/aggregate/groups_accumulator/adapter.rs
@@ -69,7 +69,7 @@ impl AccumulatorState {
}
}
- /// Returns the amount of memory taken by this structre and its accumulator
+ /// Returns the amount of memory taken by this structure and its
accumulator
fn size(&self) -> usize {
self.accumulator.size()
+ std::mem::size_of_val(self)
diff --git a/datafusion/physical-expr/src/aggregate/min_max.rs
b/datafusion/physical-expr/src/aggregate/min_max.rs
index 65bb9e478c..9987e97b38 100644
--- a/datafusion/physical-expr/src/aggregate/min_max.rs
+++ b/datafusion/physical-expr/src/aggregate/min_max.rs
@@ -296,7 +296,7 @@ macro_rules! typed_min_max_batch_string {
}};
}
-// Statically-typed version of min/max(array) -> ScalarValue for binay types.
+// Statically-typed version of min/max(array) -> ScalarValue for binary types.
macro_rules! typed_min_max_batch_binary {
($VALUES:expr, $ARRAYTYPE:ident, $SCALAR:ident, $OP:ident) => {{
let array = downcast_value!($VALUES, $ARRAYTYPE);
diff --git a/datafusion/physical-expr/src/equivalence/class.rs
b/datafusion/physical-expr/src/equivalence/class.rs
index e483f935b7..ffa58e3853 100644
--- a/datafusion/physical-expr/src/equivalence/class.rs
+++ b/datafusion/physical-expr/src/equivalence/class.rs
@@ -67,7 +67,7 @@ impl ConstExpr {
pub fn new(expr: Arc<dyn PhysicalExpr>) -> Self {
Self {
expr,
- // By default, assume constant expressions are not same accross
partitions.
+ // By default, assume constant expressions are not same across
partitions.
across_partitions: false,
}
}
diff --git a/datafusion/physical-expr/src/expressions/case.rs
b/datafusion/physical-expr/src/expressions/case.rs
index cd73c5cb57..7a434c9402 100644
--- a/datafusion/physical-expr/src/expressions/case.rs
+++ b/datafusion/physical-expr/src/expressions/case.rs
@@ -931,7 +931,7 @@ mod tests {
}
#[test]
- fn case_tranform() -> Result<()> {
+ fn case_transform() -> Result<()> {
let schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
let when1 = lit("foo");
diff --git a/datafusion/physical-expr/src/expressions/column.rs
b/datafusion/physical-expr/src/expressions/column.rs
index f6525c7c04..38779c5460 100644
--- a/datafusion/physical-expr/src/expressions/column.rs
+++ b/datafusion/physical-expr/src/expressions/column.rs
@@ -67,7 +67,7 @@ impl PhysicalExpr for UnKnownColumn {
Ok(DataType::Null)
}
- /// Decide whehter this expression is nullable, given the schema of the
input
+ /// Decide whether this expression is nullable, given the schema of the
input
fn nullable(&self, _input_schema: &Schema) -> Result<bool> {
Ok(true)
}
diff --git a/datafusion/physical-expr/src/expressions/try_cast.rs
b/datafusion/physical-expr/src/expressions/try_cast.rs
index 3549a3df83..43b6c993d2 100644
--- a/datafusion/physical-expr/src/expressions/try_cast.rs
+++ b/datafusion/physical-expr/src/expressions/try_cast.rs
@@ -31,7 +31,7 @@ use datafusion_common::format::DEFAULT_FORMAT_OPTIONS;
use datafusion_common::{not_impl_err, Result, ScalarValue};
use datafusion_expr::ColumnarValue;
-/// TRY_CAST expression casts an expression to a specific data type and retuns
NULL on invalid cast
+/// TRY_CAST expression casts an expression to a specific data type and
returns NULL on invalid cast
#[derive(Debug, Hash)]
pub struct TryCastExpr {
/// The expression to cast
diff --git a/datafusion/physical-expr/src/utils/guarantee.rs
b/datafusion/physical-expr/src/utils/guarantee.rs
index 42e5e6fcf3..993ff56100 100644
--- a/datafusion/physical-expr/src/utils/guarantee.rs
+++ b/datafusion/physical-expr/src/utils/guarantee.rs
@@ -283,7 +283,7 @@ impl<'a> GuaranteeBuilder<'a> {
)
}
- /// Aggregates a new single column, multi literal term to ths builder
+ /// Aggregates a new single column, multi literal term to this builder
/// combining with previously known guarantees if possible.
///
/// # Examples
diff --git a/datafusion/physical-plan/src/aggregates/group_values/row.rs
b/datafusion/physical-plan/src/aggregates/group_values/row.rs
index 96a12d7b62..8c2a4ba5c4 100644
--- a/datafusion/physical-plan/src/aggregates/group_values/row.rs
+++ b/datafusion/physical-plan/src/aggregates/group_values/row.rs
@@ -190,7 +190,7 @@ impl GroupValues for GroupValuesRows {
let groups_rows = group_values.iter().take(n);
let output = self.row_converter.convert_rows(groups_rows)?;
// Clear out first n group keys by copying them to a new Rows.
- // TODO file some ticket in arrow-rs to make this more
efficent?
+ // TODO file some ticket in arrow-rs to make this more
efficient?
let mut new_group_values = self.row_converter.empty_rows(0, 0);
for row in group_values.iter().skip(n) {
new_group_values.push(row);
diff --git a/datafusion/physical-plan/src/aggregates/mod.rs
b/datafusion/physical-plan/src/aggregates/mod.rs
index 5f780f1ff8..4146dda764 100644
--- a/datafusion/physical-plan/src/aggregates/mod.rs
+++ b/datafusion/physical-plan/src/aggregates/mod.rs
@@ -75,12 +75,12 @@ pub enum AggregateMode {
/// Applies the entire logical aggregation operation in a single operator,
/// as opposed to Partial / Final modes which apply the logical
aggregation using
/// two operators.
- /// This mode requires tha the input is a single partition (like Final)
+ /// This mode requires that the input is a single partition (like Final)
Single,
/// Applies the entire logical aggregation operation in a single operator,
/// as opposed to Partial / Final modes which apply the logical
aggregation using
/// two operators.
- /// This mode requires tha the input is partitioned by group key (like
FinalPartitioned)
+ /// This mode requires that the input is partitioned by group key (like
FinalPartitioned)
SinglePartitioned,
}
@@ -733,7 +733,7 @@ impl ExecutionPlan for AggregateExec {
// - once expressions will be able to compute their own stats, use it
here
// - case where we group by on a column for which with have the
`distinct` stat
// TODO stats: aggr expression:
- // - aggregations somtimes also preserve invariants such as min, max...
+ // - aggregations sometimes also preserve invariants such as min,
max...
let column_statistics = Statistics::unknown_column(&self.schema());
match self.mode {
AggregateMode::Final | AggregateMode::FinalPartitioned
diff --git a/datafusion/physical-plan/src/analyze.rs
b/datafusion/physical-plan/src/analyze.rs
index b4c1e25e61..287446328f 100644
--- a/datafusion/physical-plan/src/analyze.rs
+++ b/datafusion/physical-plan/src/analyze.rs
@@ -206,7 +206,7 @@ impl ExecutionPlan for AnalyzeExec {
}
}
-/// Creates the ouput of AnalyzeExec as a RecordBatch
+/// Creates the output of AnalyzeExec as a RecordBatch
fn create_output_batch(
verbose: bool,
show_statistics: bool,
diff --git a/datafusion/physical-plan/src/display.rs
b/datafusion/physical-plan/src/display.rs
index 7f4ae5797d..0d2653c5c7 100644
--- a/datafusion/physical-plan/src/display.rs
+++ b/datafusion/physical-plan/src/display.rs
@@ -236,7 +236,7 @@ enum ShowMetrics {
/// Do not show any metrics
None,
- /// Show aggregrated metrics across partition
+ /// Show aggregated metrics across partition
Aggregated,
/// Show full per-partition metrics
diff --git a/datafusion/physical-plan/src/joins/cross_join.rs
b/datafusion/physical-plan/src/joins/cross_join.rs
index 33a9c061bf..8304ddc733 100644
--- a/datafusion/physical-plan/src/joins/cross_join.rs
+++ b/datafusion/physical-plan/src/joins/cross_join.rs
@@ -578,7 +578,7 @@ mod tests {
}
#[tokio::test]
- async fn test_stats_cartesian_product_with_unknwon_size() {
+ async fn test_stats_cartesian_product_with_unknown_size() {
let left_row_count = 11;
let left = Statistics {
diff --git a/datafusion/physical-plan/src/joins/nested_loop_join.rs
b/datafusion/physical-plan/src/joins/nested_loop_join.rs
index 754e55e496..f8ca389808 100644
--- a/datafusion/physical-plan/src/joins/nested_loop_join.rs
+++ b/datafusion/physical-plan/src/joins/nested_loop_join.rs
@@ -160,7 +160,7 @@ pub struct NestedLoopJoinExec {
}
impl NestedLoopJoinExec {
- /// Try to create a nwe [`NestedLoopJoinExec`]
+ /// Try to create a new [`NestedLoopJoinExec`]
pub fn try_new(
left: Arc<dyn ExecutionPlan>,
right: Arc<dyn ExecutionPlan>,
diff --git a/datafusion/physical-plan/src/joins/sort_merge_join.rs
b/datafusion/physical-plan/src/joins/sort_merge_join.rs
index e9124a7297..a03e4a83fd 100644
--- a/datafusion/physical-plan/src/joins/sort_merge_join.rs
+++ b/datafusion/physical-plan/src/joins/sort_merge_join.rs
@@ -634,7 +634,7 @@ struct SMJStream {
pub buffered: SendableRecordBatchStream,
/// Current processing record batch of streamed
pub streamed_batch: StreamedBatch,
- /// Currrent buffered data
+ /// Current buffered data
pub buffered_data: BufferedData,
/// (used in outer join) Is current streamed row joined at least once?
pub streamed_joined: bool,
diff --git a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs
b/datafusion/physical-plan/src/joins/symmetric_hash_join.rs
index c23dc2032c..2299b7ff07 100644
--- a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs
+++ b/datafusion/physical-plan/src/joins/symmetric_hash_join.rs
@@ -215,7 +215,7 @@ impl SymmetricHashJoinExec {
let left_schema = left.schema();
let right_schema = right.schema();
- // Error out if no "on" contraints are given:
+ // Error out if no "on" constraints are given:
if on.is_empty() {
return plan_err!(
"On constraints in SymmetricHashJoinExec should be non-empty"
diff --git a/datafusion/physical-plan/src/joins/utils.rs
b/datafusion/physical-plan/src/joins/utils.rs
index e3ec242ce8..51744730a5 100644
--- a/datafusion/physical-plan/src/joins/utils.rs
+++ b/datafusion/physical-plan/src/joins/utils.rs
@@ -145,7 +145,7 @@ impl JoinHashMap {
pub(crate) type JoinHashMapOffset = (usize, Option<u64>);
// Macro for traversing chained values with limit.
-// Early returns in case of reacing output tuples limit.
+// Early returns in case of reaching output tuples limit.
macro_rules! chain_traverse {
(
$input_indices:ident, $match_indices:ident, $hash_values:ident,
$next_chain:ident,
@@ -477,7 +477,7 @@ fn offset_ordering(
offset: usize,
) -> Vec<PhysicalSortExpr> {
match join_type {
- // In the case below, right ordering should be offseted with the left
+ // In the case below, right ordering should be offsetted with the left
// side length, since we append the right table to the left table.
JoinType::Inner | JoinType::Left | JoinType::Full | JoinType::Right =>
ordering
.iter()
@@ -910,7 +910,7 @@ fn estimate_inner_join_cardinality(
left_stats: Statistics,
right_stats: Statistics,
) -> Option<Precision<usize>> {
- // Immediatedly return if inputs considered as non-overlapping
+ // Immediately return if inputs considered as non-overlapping
if let Some(estimation) = estimate_disjoint_inputs(&left_stats,
&right_stats) {
return Some(estimation);
};
@@ -2419,7 +2419,7 @@ mod tests {
);
assert!(
absent_outer_estimation.is_none(),
- "Expected \"None\" esimated SemiJoin cardinality for absent outer
num_rows"
+ "Expected \"None\" estimated SemiJoin cardinality for absent outer
num_rows"
);
let absent_inner_estimation = estimate_join_cardinality(
@@ -2437,7 +2437,7 @@ mod tests {
&join_on,
).expect("Expected non-empty PartialJoinStatistics for SemiJoin with
absent inner num_rows");
- assert_eq!(absent_inner_estimation.num_rows, 500, "Expected
outer.num_rows esimated SemiJoin cardinality for absent inner num_rows");
+ assert_eq!(absent_inner_estimation.num_rows, 500, "Expected
outer.num_rows estimated SemiJoin cardinality for absent inner num_rows");
let absent_inner_estimation = estimate_join_cardinality(
&JoinType::LeftSemi,
@@ -2453,7 +2453,7 @@ mod tests {
},
&join_on,
);
- assert!(absent_inner_estimation.is_none(), "Expected \"None\" esimated
SemiJoin cardinality for absent outer and inner num_rows");
+ assert!(absent_inner_estimation.is_none(), "Expected \"None\"
estimated SemiJoin cardinality for absent outer and inner num_rows");
Ok(())
}
diff --git a/datafusion/physical-plan/src/limit.rs
b/datafusion/physical-plan/src/limit.rs
index 9c77a3d05c..f3dad6afab 100644
--- a/datafusion/physical-plan/src/limit.rs
+++ b/datafusion/physical-plan/src/limit.rs
@@ -393,7 +393,7 @@ impl ExecutionPlan for LocalLimitExec {
..
} if nr <= self.fetch => input_stats,
// if the input is greater than the limit, the num_row will be
greater
- // than the limit because the partitions will be limited separatly
+ // than the limit because the partitions will be limited separately
// the statistic
Statistics {
num_rows: Precision::Exact(nr),
diff --git a/datafusion/physical-plan/src/repartition/mod.rs
b/datafusion/physical-plan/src/repartition/mod.rs
index e5c506403f..4870e9e95e 100644
--- a/datafusion/physical-plan/src/repartition/mod.rs
+++ b/datafusion/physical-plan/src/repartition/mod.rs
@@ -1345,8 +1345,8 @@ mod tests {
#[tokio::test]
// As the hash results might be different on different platforms or
- // wiht different compilers, we will compare the same execution with
- // and without droping the output stream.
+ // with different compilers, we will compare the same execution with
+ // and without dropping the output stream.
async fn hash_repartition_with_dropping_output_stream() {
let task_ctx = Arc::new(TaskContext::default());
let partitioning = Partitioning::Hash(
@@ -1357,7 +1357,7 @@ mod tests {
2,
);
- // We first collect the results without droping the output stream.
+ // We first collect the results without dropping the output stream.
let input = Arc::new(make_barrier_exec());
let exec = RepartitionExec::try_new(
Arc::clone(&input) as Arc<dyn ExecutionPlan>,
diff --git a/datafusion/physical-plan/src/sorts/sort.rs
b/datafusion/physical-plan/src/sorts/sort.rs
index 5b99f8bc71..d576f77d9f 100644
--- a/datafusion/physical-plan/src/sorts/sort.rs
+++ b/datafusion/physical-plan/src/sorts/sort.rs
@@ -602,7 +602,7 @@ pub fn sort_batch(
.collect::<Result<Vec<_>>>()?;
let indices = if is_multi_column_with_lists(&sort_columns) {
- // lex_sort_to_indices doesn't support List with more than one colum
+ // lex_sort_to_indices doesn't support List with more than one column
// https://github.com/apache/arrow-rs/issues/5454
lexsort_to_indices_multi_columns(sort_columns, fetch)?
} else {
@@ -802,12 +802,12 @@ impl DisplayAs for SortExec {
match t {
DisplayFormatType::Default | DisplayFormatType::Verbose => {
let expr = PhysicalSortExpr::format_list(&self.expr);
- let preserve_partioning = self.preserve_partitioning;
+ let preserve_partitioning = self.preserve_partitioning;
match self.fetch {
Some(fetch) => {
- write!(f, "SortExec: TopK(fetch={fetch}),
expr=[{expr}], preserve_partitioning=[{preserve_partioning}]",)
+ write!(f, "SortExec: TopK(fetch={fetch}),
expr=[{expr}], preserve_partitioning=[{preserve_partitioning}]",)
}
- None => write!(f, "SortExec: expr=[{expr}],
preserve_partitioning=[{preserve_partioning}]"),
+ None => write!(f, "SortExec: expr=[{expr}],
preserve_partitioning=[{preserve_partitioning}]"),
}
}
}
diff --git a/datafusion/physical-plan/src/streaming.rs
b/datafusion/physical-plan/src/streaming.rs
index 5a9035c8db..e10e5c9a69 100644
--- a/datafusion/physical-plan/src/streaming.rs
+++ b/datafusion/physical-plan/src/streaming.rs
@@ -80,7 +80,7 @@ impl StreamingTableExec {
if !schema.eq(partition_schema) {
debug!(
"Target schema does not match with partition schema. \
- Target_schema: {schema:?}. Partiton Schema:
{partition_schema:?}"
+ Target_schema: {schema:?}. Partition Schema:
{partition_schema:?}"
);
return plan_err!("Mismatch between schema and batches");
}
diff --git a/datafusion/physical-plan/src/test/exec.rs
b/datafusion/physical-plan/src/test/exec.rs
index ac4eb1ca9e..cf1c0e3137 100644
--- a/datafusion/physical-plan/src/test/exec.rs
+++ b/datafusion/physical-plan/src/test/exec.rs
@@ -725,7 +725,7 @@ pub struct PanicExec {
schema: SchemaRef,
/// Number of output partitions. Each partition will produce this
- /// many empty output record batches prior to panicing
+ /// many empty output record batches prior to panicking
batches_until_panics: Vec<usize>,
cache: PlanProperties,
}
diff --git a/datafusion/physical-plan/src/topk/mod.rs
b/datafusion/physical-plan/src/topk/mod.rs
index 5366a57076..d3f1a4fd96 100644
--- a/datafusion/physical-plan/src/topk/mod.rs
+++ b/datafusion/physical-plan/src/topk/mod.rs
@@ -94,7 +94,7 @@ pub struct TopK {
impl TopK {
/// Create a new [`TopK`] that stores the top `k` values, as
/// defined by the sort expressions in `expr`.
- // TOOD: make a builder or some other nicer API to avoid the
+ // TODO: make a builder or some other nicer API to avoid the
// clippy warning
#[allow(clippy::too_many_arguments)]
pub fn try_new(
@@ -258,7 +258,7 @@ impl TopKMetrics {
/// Using the `Row` format handles things such as ascending vs
/// descending and nulls first vs nulls last.
struct TopKHeap {
- /// The maximum number of elemenents to store in this heap.
+ /// The maximum number of elements to store in this heap.
k: usize,
/// The target number of rows for output batches
batch_size: usize,
@@ -421,7 +421,7 @@ impl TopKHeap {
let num_rows = self.inner.len();
let (new_batch, mut topk_rows) = self.emit_with_state()?;
- // clear all old entires in store (this invalidates all
+ // clear all old entries in store (this invalidates all
// store_ids in `inner`)
self.store.clear();
@@ -453,7 +453,7 @@ impl TopKHeap {
/// Represents one of the top K rows held in this heap. Orders
/// according to memcmp of row (e.g. the arrow Row format, but could
-/// also be primtive values)
+/// also be primitive values)
///
/// Reuses allocations to minimize runtime overhead of creating new Vecs
#[derive(Debug, PartialEq)]
diff --git a/datafusion/physical-plan/src/windows/mod.rs
b/datafusion/physical-plan/src/windows/mod.rs
index 7f794556a2..5eca7af19d 100644
--- a/datafusion/physical-plan/src/windows/mod.rs
+++ b/datafusion/physical-plan/src/windows/mod.rs
@@ -805,7 +805,7 @@ mod tests {
}
#[tokio::test]
- async fn test_satisfiy_nullable() -> Result<()> {
+ async fn test_satisfy_nullable() -> Result<()> {
let schema = create_test_schema()?;
let params = vec![
((true, true), (false, false), false),
diff --git a/datafusion/physical-plan/src/windows/window_agg_exec.rs
b/datafusion/physical-plan/src/windows/window_agg_exec.rs
index b6330f65e0..1d5c6061a0 100644
--- a/datafusion/physical-plan/src/windows/window_agg_exec.rs
+++ b/datafusion/physical-plan/src/windows/window_agg_exec.rs
@@ -126,7 +126,7 @@ impl WindowAggExec {
// Get output partitioning:
// Because we can have repartitioning using the partition keys this
- // would be either 1 or more than 1 depending on the presense of
repartitioning.
+ // would be either 1 or more than 1 depending on the presence of
repartitioning.
let output_partitioning = input.output_partitioning().clone();
// Determine execution mode:
diff --git a/datafusion/physical-plan/src/work_table.rs
b/datafusion/physical-plan/src/work_table.rs
index 5f3cf6e2ae..ba95640a87 100644
--- a/datafusion/physical-plan/src/work_table.rs
+++ b/datafusion/physical-plan/src/work_table.rs
@@ -225,7 +225,7 @@ mod tests {
#[test]
fn test_work_table() {
let work_table = WorkTable::new();
- // cann't take from empty work_table
+ // can't take from empty work_table
assert!(work_table.take().is_err());
let pool = Arc::new(UnboundedMemoryPool::default()) as _;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
