Fix typo

gabotechs · gabotechs · commit 68ccdb4d0869 · 2025-10-22T16:52:28.000+02:00
diff --git a/src/distributed_ext.rs b/src/distributed_ext.rs
@@ -6,7 +6,7 @@ use crate::distributed_planner::{
     set_distributed_network_coalesce_tasks, set_distributed_network_shuffle_tasks,
 };
 use crate::protobuf::{set_distributed_user_codec, set_distributed_user_codec_arc};
-use crate::{ChannelResolver, IntoPlanDependantUsize};
+use crate::{ChannelResolver, IntoPlanDependentUsize};
 use datafusion::common::DataFusionError;
 use datafusion::config::ConfigExtension;
 use datafusion::execution::{SessionState, SessionStateBuilder};
@@ -233,10 +233,10 @@ pub trait DistributedExt: Sized {
     ///  ( task 1 )  ( task 2 ) ( task 3 )  N tasks
     /// ```
     /// This parameter defines N
-    fn with_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(self, tasks: T) -> Self;
+    fn with_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(self, tasks: T) -> Self;
 
     /// Same as [DistributedExt::with_distributed_network_coalesce_tasks] but with an in-place mutation.
-    fn set_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+    fn set_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
 
     /// Upon shuffling data, this defines how many tasks are employed into performing the shuffling.
     /// ```text
@@ -246,10 +246,10 @@ pub trait DistributedExt: Sized {
     ///       ( task 1 )  ( task 2 )       N tasks
     /// ```
     /// This parameter defines N
-    fn with_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(self, tasks: T) -> Self;
+    fn with_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(self, tasks: T) -> Self;
 
     /// Same as [DistributedExt::with_distributed_network_shuffle_tasks] but with an in-place mutation.
-    fn set_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+    fn set_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
 }
 
 impl DistributedExt for SessionConfig {
@@ -282,11 +282,11 @@ impl DistributedExt for SessionConfig {
         set_distributed_channel_resolver(self, resolver)
     }
 
-    fn set_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T) {
+    fn set_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T) {
         set_distributed_network_coalesce_tasks(self, tasks)
     }
 
-    fn set_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T) {
+    fn set_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T) {
         set_distributed_network_shuffle_tasks(self, tasks)
     }
 
@@ -314,11 +314,11 @@ impl DistributedExt for SessionConfig {
 
             #[call(set_distributed_network_coalesce_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
 
             #[call(set_distributed_network_shuffle_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
         }
     }
 }
@@ -351,15 +351,15 @@ impl DistributedExt for SessionStateBuilder {
             #[expr($;self)]
             fn with_distributed_channel_resolver<T: ChannelResolver + Send + Sync + 'static>(mut self, resolver: T) -> Self;
 
-            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_coalesce_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
 
-            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_shuffle_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
         }
     }
 }
@@ -392,15 +392,15 @@ impl DistributedExt for SessionState {
             #[expr($;self)]
             fn with_distributed_channel_resolver<T: ChannelResolver + Send + Sync + 'static>(mut self, resolver: T) -> Self;
 
-            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_coalesce_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
 
-            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_shuffle_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(mut self, tasks: T) -> Self;
+            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(mut self, tasks: T) -> Self;
         }
     }
 }
@@ -433,15 +433,15 @@ impl DistributedExt for SessionContext {
             #[expr($;self)]
             fn with_distributed_channel_resolver<T: ChannelResolver + Send + Sync + 'static>(self, resolver: T) -> Self;
 
-            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_coalesce_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependantUsize>(self, tasks: T) -> Self;
+            fn with_distributed_network_coalesce_tasks<T: IntoPlanDependentUsize>(self, tasks: T) -> Self;
 
-            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(&mut self, tasks: T);
+            fn set_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(&mut self, tasks: T);
             #[call(set_distributed_network_shuffle_tasks)]
             #[expr($;self)]
-            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependantUsize>(self, tasks: T) -> Self;
+            fn with_distributed_network_shuffle_tasks<T: IntoPlanDependentUsize>(self, tasks: T) -> Self;
         }
     }
 }
diff --git a/src/distributed_planner/distributed_config.rs b/src/distributed_planner/distributed_config.rs
@@ -7,57 +7,57 @@ use std::sync::Arc;
 
 #[derive(Clone)]
 #[allow(clippy::type_complexity)]
-pub struct PlanDependantUsize(
+pub struct PlanDependentUsize(
     pub(crate) Arc<dyn Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync>,
 );
 
-impl PlanDependantUsize {
+impl PlanDependentUsize {
     pub fn call(&self, plan: &Arc<dyn ExecutionPlan>) -> usize {
         self.0(plan)
     }
 }
 
-pub trait IntoPlanDependantUsize {
-    fn into_plan_dependant_usize(self) -> PlanDependantUsize;
+pub trait IntoPlanDependentUsize {
+    fn into_plan_dependent_usize(self) -> PlanDependentUsize;
 }
 
-impl IntoPlanDependantUsize for usize {
-    fn into_plan_dependant_usize(self) -> PlanDependantUsize {
-        PlanDependantUsize(Arc::new(move |_| self))
+impl IntoPlanDependentUsize for usize {
+    fn into_plan_dependent_usize(self) -> PlanDependentUsize {
+        PlanDependentUsize(Arc::new(move |_| self))
     }
 }
 
-impl<T: Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync + 'static> IntoPlanDependantUsize for T {
-    fn into_plan_dependant_usize(self) -> PlanDependantUsize {
-        PlanDependantUsize(Arc::new(self))
+impl<T: Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync + 'static> IntoPlanDependentUsize for T {
+    fn into_plan_dependent_usize(self) -> PlanDependentUsize {
+        PlanDependentUsize(Arc::new(self))
     }
 }
 
-impl Default for PlanDependantUsize {
+impl Default for PlanDependentUsize {
     fn default() -> Self {
-        PlanDependantUsize(Arc::new(|_| 0))
+        PlanDependentUsize(Arc::new(|_| 0))
     }
 }
 
-impl Debug for PlanDependantUsize {
+impl Debug for PlanDependentUsize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "PlanDependantUsize")
     }
 }
 
-impl Display for PlanDependantUsize {
+impl Display for PlanDependentUsize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "PlanDependantUsize")
     }
 }
 
-impl ConfigField for PlanDependantUsize {
+impl ConfigField for PlanDependentUsize {
     fn visit<V: Visit>(&self, v: &mut V, key: &str, description: &'static str) {
         v.some(key, self, description);
     }
 
     fn set(&mut self, _: &str, value: &str) -> datafusion::common::Result<()> {
-        *self = default_config_transform::<usize>(value)?.into_plan_dependant_usize();
+        *self = default_config_transform::<usize>(value)?.into_plan_dependent_usize();
         Ok(())
     }
 }
@@ -72,7 +72,7 @@ extensions_options! {
         ///       ( task 1 )  ( task 2 )       N tasks
         /// ```
         /// This parameter defines N
-        pub network_shuffle_tasks: Option<PlanDependantUsize>, default = None
+        pub network_shuffle_tasks: Option<PlanDependentUsize>, default = None
         /// Upon merging multiple tasks into one, this defines how many tasks are merged.
         /// ```text
         ///              ( task 1 )
@@ -81,7 +81,7 @@ extensions_options! {
         ///  ( task 1 )  ( task 2 ) ( task 3 )  N tasks
         /// ```
         /// This parameter defines N
-        pub network_coalesce_tasks: Option<PlanDependantUsize>, default = None
+        pub network_coalesce_tasks: Option<PlanDependentUsize>, default = None
     }
 }
 
@@ -91,36 +91,36 @@ impl ConfigExtension for DistributedConfig {
 
 impl DistributedConfig {
     /// Sets the amount of tasks used in a network shuffle operation.
-    pub fn with_network_shuffle_tasks(mut self, tasks: impl IntoPlanDependantUsize) -> Self {
-        self.network_shuffle_tasks = Some(tasks.into_plan_dependant_usize());
+    pub fn with_network_shuffle_tasks(mut self, tasks: impl IntoPlanDependentUsize) -> Self {
+        self.network_shuffle_tasks = Some(tasks.into_plan_dependent_usize());
         self
     }
 
     /// Sets the amount of tasks used in a network coalesce operation.
-    pub fn with_network_coalesce_tasks(mut self, tasks: impl IntoPlanDependantUsize) -> Self {
-        self.network_coalesce_tasks = Some(tasks.into_plan_dependant_usize());
+    pub fn with_network_coalesce_tasks(mut self, tasks: impl IntoPlanDependentUsize) -> Self {
+        self.network_coalesce_tasks = Some(tasks.into_plan_dependent_usize());
         self
     }
 }
 
 pub(crate) fn set_distributed_network_coalesce_tasks(
     cfg: &mut SessionConfig,
-    tasks: impl IntoPlanDependantUsize,
+    tasks: impl IntoPlanDependentUsize,
 ) {
     let ext = &mut cfg.options_mut().extensions;
     let Some(prev) = ext.get_mut::<DistributedConfig>() else {
         return ext.insert(DistributedConfig::default().with_network_coalesce_tasks(tasks));
     };
-    prev.network_coalesce_tasks = Some(tasks.into_plan_dependant_usize());
+    prev.network_coalesce_tasks = Some(tasks.into_plan_dependent_usize());
 }
 
 pub(crate) fn set_distributed_network_shuffle_tasks(
     cfg: &mut SessionConfig,
-    tasks: impl IntoPlanDependantUsize,
+    tasks: impl IntoPlanDependentUsize,
 ) {
     let ext = &mut cfg.options_mut().extensions;
     let Some(prev) = ext.get_mut::<DistributedConfig>() else {
         return ext.insert(DistributedConfig::default().with_network_shuffle_tasks(tasks));
     };
-    prev.network_shuffle_tasks = Some(tasks.into_plan_dependant_usize());
+    prev.network_shuffle_tasks = Some(tasks.into_plan_dependent_usize());
 }
diff --git a/src/distributed_planner/mod.rs b/src/distributed_planner/mod.rs
@@ -7,7 +7,7 @@ pub(crate) use distributed_config::{
     set_distributed_network_coalesce_tasks, set_distributed_network_shuffle_tasks,
 };
 
-pub use distributed_config::{DistributedConfig, IntoPlanDependantUsize, PlanDependantUsize};
+pub use distributed_config::{DistributedConfig, IntoPlanDependentUsize, PlanDependentUsize};
 pub use distributed_physical_optimizer_rule::{
     DistributedPhysicalOptimizerRule, apply_network_boundaries, distribute_plan,
 };
diff --git a/src/lib.rs b/src/lib.rs
@@ -17,8 +17,8 @@ pub mod test_utils;
 pub use channel_resolver_ext::{BoxCloneSyncChannel, ChannelResolver};
 pub use distributed_ext::DistributedExt;
 pub use distributed_planner::{
-    DistributedConfig, DistributedPhysicalOptimizerRule, InputStageInfo, IntoPlanDependantUsize,
-    NetworkBoundary, NetworkBoundaryExt, PlanDependantUsize, apply_network_boundaries,
+    DistributedConfig, DistributedPhysicalOptimizerRule, InputStageInfo, IntoPlanDependentUsize,
+    NetworkBoundary, NetworkBoundaryExt, PlanDependentUsize, apply_network_boundaries,
     distribute_plan,
 };
 pub use execution_plans::{

Original file line number	Diff line number	Diff line change
`@@ -7,57 +7,57 @@ use std::sync::Arc;`
`7`	`7`
`8`	`8`	`#[derive(Clone)]`
`9`	`9`	`#[allow(clippy::type_complexity)]`
`10`		`-pub struct PlanDependantUsize(`
	`10`	`+pub struct PlanDependentUsize(`
`11`	`11`	`pub(crate) Arc<dyn Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync>,`
`12`	`12`	`);`
`13`	`13`
`14`		`-impl PlanDependantUsize {`
	`14`	`+impl PlanDependentUsize {`
`15`	`15`	`pub fn call(&self, plan: &Arc<dyn ExecutionPlan>) -> usize {`
`16`	`16`	`self.0(plan)`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`-pub trait IntoPlanDependantUsize {`
`21`		`- fn into_plan_dependant_usize(self) -> PlanDependantUsize;`
	`20`	`+pub trait IntoPlanDependentUsize {`
	`21`	`+ fn into_plan_dependent_usize(self) -> PlanDependentUsize;`
`22`	`22`	`}`
`23`	`23`
`24`		`-impl IntoPlanDependantUsize for usize {`
`25`		`- fn into_plan_dependant_usize(self) -> PlanDependantUsize {`
`26`		`- PlanDependantUsize(Arc::new(move \|_\| self))`
	`24`	`+impl IntoPlanDependentUsize for usize {`
	`25`	`+ fn into_plan_dependent_usize(self) -> PlanDependentUsize {`
	`26`	`+ PlanDependentUsize(Arc::new(move \|_\| self))`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`-impl<T: Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync + 'static> IntoPlanDependantUsize for T {`
`31`		`- fn into_plan_dependant_usize(self) -> PlanDependantUsize {`
`32`		`- PlanDependantUsize(Arc::new(self))`
	`30`	`+impl<T: Fn(&Arc<dyn ExecutionPlan>) -> usize + Send + Sync + 'static> IntoPlanDependentUsize for T {`
	`31`	`+ fn into_plan_dependent_usize(self) -> PlanDependentUsize {`
	`32`	`+ PlanDependentUsize(Arc::new(self))`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-impl Default for PlanDependantUsize {`
	`36`	`+impl Default for PlanDependentUsize {`
`37`	`37`	`fn default() -> Self {`
`38`		`- PlanDependantUsize(Arc::new(\|_\| 0))`
	`38`	`+ PlanDependentUsize(Arc::new(\|_\| 0))`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-impl Debug for PlanDependantUsize {`
	`42`	`+impl Debug for PlanDependentUsize {`
`43`	`43`	`fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {`
`44`	`44`	`write!(f, "PlanDependantUsize")`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`-impl Display for PlanDependantUsize {`
	`48`	`+impl Display for PlanDependentUsize {`
`49`	`49`	`fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {`
`50`	`50`	`write!(f, "PlanDependantUsize")`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`-impl ConfigField for PlanDependantUsize {`
	`54`	`+impl ConfigField for PlanDependentUsize {`
`55`	`55`	`fn visit<V: Visit>(&self, v: &mut V, key: &str, description: &'static str) {`
`56`	`56`	`v.some(key, self, description);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`fn set(&mut self, _: &str, value: &str) -> datafusion::common::Result<()> {`
`60`		`- *self = default_config_transform::<usize>(value)?.into_plan_dependant_usize();`
	`60`	`+ *self = default_config_transform::<usize>(value)?.into_plan_dependent_usize();`
`61`	`61`	`Ok(())`
`62`	`62`	`}`
`63`	`63`	`}`
`@@ -72,7 +72,7 @@ extensions_options! {`
`72`	`72`	`/// ( task 1 ) ( task 2 ) N tasks`
`73`	`73`	/// ```
`74`	`74`	`/// This parameter defines N`
`75`		`- pub network_shuffle_tasks: Option<PlanDependantUsize>, default = None`
	`75`	`+ pub network_shuffle_tasks: Option<PlanDependentUsize>, default = None`
`76`	`76`	`/// Upon merging multiple tasks into one, this defines how many tasks are merged.`
`77`	`77`	/// ```text
`78`	`78`	`/// ( task 1 )`
`@@ -81,7 +81,7 @@ extensions_options! {`
`81`	`81`	`/// ( task 1 ) ( task 2 ) ( task 3 ) N tasks`
`82`	`82`	/// ```
`83`	`83`	`/// This parameter defines N`
`84`		`- pub network_coalesce_tasks: Option<PlanDependantUsize>, default = None`
	`84`	`+ pub network_coalesce_tasks: Option<PlanDependentUsize>, default = None`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`@@ -91,36 +91,36 @@ impl ConfigExtension for DistributedConfig {`
`91`	`91`
`92`	`92`	`impl DistributedConfig {`
`93`	`93`	`/// Sets the amount of tasks used in a network shuffle operation.`
`94`		`- pub fn with_network_shuffle_tasks(mut self, tasks: impl IntoPlanDependantUsize) -> Self {`
`95`		`- self.network_shuffle_tasks = Some(tasks.into_plan_dependant_usize());`
	`94`	`+ pub fn with_network_shuffle_tasks(mut self, tasks: impl IntoPlanDependentUsize) -> Self {`
	`95`	`+ self.network_shuffle_tasks = Some(tasks.into_plan_dependent_usize());`
`96`	`96`	`self`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`/// Sets the amount of tasks used in a network coalesce operation.`
`100`		`- pub fn with_network_coalesce_tasks(mut self, tasks: impl IntoPlanDependantUsize) -> Self {`
`101`		`- self.network_coalesce_tasks = Some(tasks.into_plan_dependant_usize());`
	`100`	`+ pub fn with_network_coalesce_tasks(mut self, tasks: impl IntoPlanDependentUsize) -> Self {`
	`101`	`+ self.network_coalesce_tasks = Some(tasks.into_plan_dependent_usize());`
`102`	`102`	`self`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`pub(crate) fn set_distributed_network_coalesce_tasks(`
`107`	`107`	`cfg: &mut SessionConfig,`
`108`		`- tasks: impl IntoPlanDependantUsize,`
	`108`	`+ tasks: impl IntoPlanDependentUsize,`
`109`	`109`	`) {`
`110`	`110`	`let ext = &mut cfg.options_mut().extensions;`
`111`	`111`	`let Some(prev) = ext.get_mut::<DistributedConfig>() else {`
`112`	`112`	`return ext.insert(DistributedConfig::default().with_network_coalesce_tasks(tasks));`
`113`	`113`	`};`
`114`		`- prev.network_coalesce_tasks = Some(tasks.into_plan_dependant_usize());`
	`114`	`+ prev.network_coalesce_tasks = Some(tasks.into_plan_dependent_usize());`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`pub(crate) fn set_distributed_network_shuffle_tasks(`
`118`	`118`	`cfg: &mut SessionConfig,`
`119`		`- tasks: impl IntoPlanDependantUsize,`
	`119`	`+ tasks: impl IntoPlanDependentUsize,`
`120`	`120`	`) {`
`121`	`121`	`let ext = &mut cfg.options_mut().extensions;`
`122`	`122`	`let Some(prev) = ext.get_mut::<DistributedConfig>() else {`
`123`	`123`	`return ext.insert(DistributedConfig::default().with_network_shuffle_tasks(tasks));`
`124`	`124`	`};`
`125`		`- prev.network_shuffle_tasks = Some(tasks.into_plan_dependant_usize());`
	`125`	`+ prev.network_shuffle_tasks = Some(tasks.into_plan_dependent_usize());`
`126`	`126`	`}`