fix some

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

Author: waynexia

datafusion/core/benches/spm.rs

@@ -66,7 +66,7 @@ fn generate_spm_for_round_robin_tie_breaker(
     };
 
     let rbs = (0..batch_count).map(|_| rb.clone()).collect::<Vec<_>>();
-    let partitiones = vec![rbs.clone(); partition_count];
+    let partitions = vec![rbs.clone(); partition_count];
 
     let schema = rb.schema();
     let sort = [
@@ -81,7 +81,7 @@ fn generate_spm_for_round_robin_tie_breaker(
     ]
     .into();
 
-    let exec = MemorySourceConfig::try_new_exec(&partitiones, schema, None).unwrap();
+    let exec = MemorySourceConfig::try_new_exec(&partitions, schema, None).unwrap();
     SortPreservingMergeExec::new(sort, exec)
         .with_round_robin_repartition(enable_round_robin_repartition)
 }

datafusion/core/src/datasource/listing/table.rs

@@ -502,7 +502,7 @@ impl ListingOptions {
     ///
     /// Currently this sets `target_partitions` and `collect_stat`
     /// but if more options are added in the future that need to be coordinated
-    /// they will be synchronized thorugh this method.
+    /// they will be synchronized through this method.
     pub fn with_session_config_options(mut self, config: &SessionConfig) -> Self {
         self = self.with_target_partitions(config.target_partitions());
         self = self.with_collect_stat(config.collect_statistics());

datafusion/core/tests/dataframe/mod.rs

@@ -92,8 +92,8 @@ async fn physical_plan_to_string(df: &DataFrame) -> String {
         .await
         .expect("Error creating physical plan");
 
-    let formated = displayable(physical_plan.as_ref()).indent(true);
-    formated.to_string()
+    let formatted = displayable(physical_plan.as_ref()).indent(true);
+    formatted.to_string()
 }
 
 pub fn table_with_constraints() -> Arc<dyn TableProvider> {

datafusion/core/tests/physical_optimizer/replace_with_order_preserving_variants.rs

@@ -667,7 +667,7 @@ async fn test_not_replacing_when_no_need_to_preserve_sorting(
 
 #[rstest]
 #[tokio::test]
-async fn test_with_multiple_replacable_repartitions(
+async fn test_with_multiple_replaceable_repartitions(
     #[values(false, true)] source_unbounded: bool,
     #[values(false, true)] prefer_existing_sort: bool,
 ) -> Result<()> {

datafusion/core/tests/physical_optimizer/window_optimize.rs

@@ -42,10 +42,14 @@ mod test {
             .schema(schema.clone())
             .alias("t")
             .build()?;
-        let parition = [col("a", &schema)?];
+        let partition = [col("a", &schema)?];
         let frame = WindowFrame::new(None);
-        let plain =
-            PlainAggregateWindowExpr::new(Arc::new(cnt), &parition, &[], Arc::new(frame));
+        let plain = PlainAggregateWindowExpr::new(
+            Arc::new(cnt),
+            &partition,
+            &[],
+            Arc::new(frame),
+        );
 
         let bounded_agg_exec = BoundedWindowAggExec::try_new(
             vec![Arc::new(plain)],

datafusion/core/tests/user_defined/user_defined_scalar_functions.rs

@@ -1445,7 +1445,7 @@ impl ScalarUDFImpl for MetadataBasedUdf {
             .get("modify_values")
             .map(|v| v == "double_output")
             .unwrap_or(false);
-        let mulitplier = if should_double { 2 } else { 1 };
+        let multiplier = if should_double { 2 } else { 1 };
 
         match &args.args[0] {
             ColumnarValue::Array(array) => {
@@ -1454,7 +1454,7 @@ impl ScalarUDFImpl for MetadataBasedUdf {
                     .downcast_ref::<UInt64Array>()
                     .unwrap()
                     .iter()
-                    .map(|v| v.map(|x| x * mulitplier))
+                    .map(|v| v.map(|x| x * multiplier))
                     .collect();
                 let array_ref = Arc::new(UInt64Array::from(array_values)) as ArrayRef;
                 Ok(ColumnarValue::Array(array_ref))
@@ -1465,7 +1465,7 @@ impl ScalarUDFImpl for MetadataBasedUdf {
                 };
 
                 Ok(ColumnarValue::Scalar(ScalarValue::UInt64(
-                    value.map(|v| v * mulitplier),
+                    value.map(|v| v * multiplier),
                 )))
             }
         }
@@ -1643,7 +1643,7 @@ impl ScalarUDFImpl for ExtensionBasedUdf {
 
     fn return_field_from_args(&self, _args: ReturnFieldArgs) -> Result<FieldRef> {
         Ok(Field::new("canonical_extension_udf", DataType::Utf8, true)
-            .with_extension_type(MyUserExtentionType {})
+            .with_extension_type(MyUserExtensionType {})
             .into())
     }
 
@@ -1691,10 +1691,10 @@ impl ScalarUDFImpl for ExtensionBasedUdf {
     }
 }
 
-struct MyUserExtentionType {}
+struct MyUserExtensionType {}
 
-impl ExtensionType for MyUserExtentionType {
-    const NAME: &'static str = "my_user_extention_type";
+impl ExtensionType for MyUserExtensionType {
+    const NAME: &'static str = "my_user_Extension_type";
     type Metadata = ();
 
     fn metadata(&self) -> &Self::Metadata {
@@ -1766,9 +1766,9 @@ async fn test_extension_based_udf() -> Result<()> {
     // To test for input extensions handling, we check the strings returned
     let expected_schema = Schema::new(vec![
         Field::new("without_bool8_extension", DataType::Utf8, true)
-            .with_extension_type(MyUserExtentionType {}),
+            .with_extension_type(MyUserExtensionType {}),
         Field::new("with_bool8_extension", DataType::Utf8, true)
-            .with_extension_type(MyUserExtentionType {}),
+            .with_extension_type(MyUserExtensionType {}),
     ]);
 
     let expected = record_batch!(

datafusion/datasource-parquet/src/opener.rs

@@ -1215,7 +1215,7 @@ mod test {
             }
         }
 
-        // Test that if no expression rewriter is provided we use a schemaadapter to adapt the data to the expresssion
+        // Test that if no expression rewriter is provided we use a schemaadapter to adapt the data to the expression
         let store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
         let batch = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap();
         // Write out the batch to a Parquet file

datafusion/datasource-parquet/src/row_filter.rs

@@ -184,7 +184,7 @@ pub(crate) struct FilterCandidate {
     /// Can this filter use an index (e.g. a page index) to prune rows?
     can_use_index: bool,
     /// The projection to read from the file schema to get the columns
-    /// required to pass thorugh a `SchemaMapper` to the table schema
+    /// required to pass through a `SchemaMapper` to the table schema
     /// upon which we then evaluate the filter expression.
     projection: Vec<usize>,
     ///  A `SchemaMapper` used to map batches read from the file schema to

datafusion/datasource-parquet/src/source.rs

@@ -492,7 +492,7 @@ impl FileSource for ParquetSource {
             }
             (None, Some(schema_adapter_factory)) => {
                 // If a custom schema adapter factory is provided but no expr adapter factory is provided use the custom SchemaAdapter for both projections and predicate pushdown.
-                // This maximizes compatiblity with existing code that uses the SchemaAdapter API and did not explicitly opt into the PhysicalExprAdapterFactory API.
+                // This maximizes compatibility with existing code that uses the SchemaAdapter API and did not explicitly opt into the PhysicalExprAdapterFactory API.
                 (None, Arc::clone(schema_adapter_factory) as _)
             }
             (None, None) => {

datafusion/functions/src/core/union_tag.rs

@@ -136,7 +136,7 @@ impl ScalarUDFImpl for UnionTagFunc {
                     })
                     .ok_or_else(|| {
                         exec_datafusion_err!(
-                            "union_tag: union scalar with unknow type_id {value_type_id}"
+                            "union_tag: union scalar with unknown type_id {value_type_id}"
                         )
                     }),
                 None => Ok(ColumnarValue::Scalar(ScalarValue::try_new_null(