use Into<String> as argument type wherever applicable

datafusion/src/datasource/csv.rs

@@ -59,11 +59,12 @@ pub struct CsvFile {
 
 impl CsvFile {
  /// Attempt to initialize a new `CsvFile` from a file path
- pub fn try_new(path: &str, options: CsvReadOptions) -> Result<Self> {
+ pub fn try_new(path: impl Into<String>, options: CsvReadOptions) -> Result<Self> {
+ let path = path.into();
  let schema = Arc::new(match options.schema {
  Some(s) => s.clone(),
  None => {
- let filenames = common::build_file_list(path, options.file_extension)?;
+ let filenames = common::build_file_list(&path, options.file_extension)?;
  if filenames.is_empty() {
  return Err(DataFusionError::Plan(format!(
  "No files found at {path} with file extension {file_extension}",
@@ -76,7 +77,7 @@ impl CsvFile {
  });
 
  Ok(Self {
- source: Source::Path(path.to_string()),
+ source: Source::Path(path),
  schema,
  has_header: options.has_header,
  delimiter: options.delimiter,

datafusion/src/datasource/parquet.rs

@@ -42,11 +42,12 @@ pub struct ParquetTable {
 
 impl ParquetTable {
  /// Attempt to initialize a new `ParquetTable` from a file path.
- pub fn try_new(path: &str, max_concurrency: usize) -> Result<Self> {
- let parquet_exec = ParquetExec::try_from_path(path, None, None, 0, 1, None)?;
+ pub fn try_new(path: impl Into<String>, max_concurrency: usize) -> Result<Self> {
+ let path = path.into();
+ let parquet_exec = ParquetExec::try_from_path(&path, None, None, 0, 1, None)?;
  let schema = parquet_exec.schema();
  Ok(Self {
- path: path.to_string(),
+ path,
  schema,
  statistics: parquet_exec.statistics().to_owned(),
  max_concurrency,

datafusion/src/execution/context.rs

@@ -270,7 +270,7 @@ impl ExecutionContext {
  /// Creates a DataFrame for reading a CSV data source.
  pub fn read_csv(
  &mut self,
- filename: &str,
+ filename: impl Into<String>,
  options: CsvReadOptions,
  ) -> Result<Arc<dyn DataFrame>> {
  Ok(Arc::new(DataFrameImpl::new(
@@ -280,7 +280,10 @@ impl ExecutionContext {
  }
 
  /// Creates a DataFrame for reading a Parquet data source.
- pub fn read_parquet(&mut self, filename: &str) -> Result<Arc<dyn DataFrame>> {
+ pub fn read_parquet(
+ &mut self,
+ filename: impl Into<String>,
+ ) -> Result<Arc<dyn DataFrame>> {
  Ok(Arc::new(DataFrameImpl::new(
  self.state.clone(),
  &LogicalPlanBuilder::scan_parquet(
@@ -474,10 +477,11 @@ impl ExecutionContext {
  pub async fn write_csv(
  &self,
  plan: Arc<dyn ExecutionPlan>,
- path: String,
+ path: impl AsRef<str>,
  ) -> Result<()> {
+ let path = path.as_ref();
  // create directory to contain the CSV files (one per partition)
- let fs_path = Path::new(&path);
+ let fs_path = Path::new(path);
  match fs::create_dir(fs_path) {
  Ok(()) => {
  let mut tasks = vec![];
@@ -511,11 +515,12 @@ impl ExecutionContext {
  pub async fn write_parquet(
  &self,
  plan: Arc<dyn ExecutionPlan>,
- path: String,
+ path: impl AsRef<str>,
  writer_properties: Option<WriterProperties>,
  ) -> Result<()> {
+ let path = path.as_ref();
  // create directory to contain the Parquet files (one per partition)
- let fs_path = Path::new(&path);
+ let fs_path = Path::new(path);
  match fs::create_dir(fs_path) {
  Ok(()) => {
  let mut tasks = vec![];

datafusion/src/logical_plan/builder.rs

@@ -115,39 +115,41 @@ impl LogicalPlanBuilder {
 
  /// Scan a CSV data source
  pub fn scan_csv(
- path: &str,
+ path: impl Into<String>,
  options: CsvReadOptions,
  projection: Option<Vec<usize>>,
  ) -> Result<Self> {
- Self::scan_csv_with_name(path, options, projection, path)
+ let path = path.into();
+ Self::scan_csv_with_name(path.clone(), options, projection, path)
  }
 
  /// Scan a CSV data source and register it with a given table name
  pub fn scan_csv_with_name(
- path: &str,
+ path: impl Into<String>,
  options: CsvReadOptions,
  projection: Option<Vec<usize>>,
- table_name: &str,
+ table_name: impl Into<String>,
  ) -> Result<Self> {
  let provider = Arc::new(CsvFile::try_new(path, options)?);
  Self::scan(table_name, provider, projection)
  }
 
  /// Scan a Parquet data source
  pub fn scan_parquet(
- path: &str,
+ path: impl Into<String>,
  projection: Option<Vec<usize>>,
  max_concurrency: usize,
  ) -> Result<Self> {
- Self::scan_parquet_with_name(path, projection, max_concurrency, path)
+ let path = path.into();
+ Self::scan_parquet_with_name(path.clone(), projection, max_concurrency, path)
  }
 
  /// Scan a Parquet data source and register it with a given table name
  pub fn scan_parquet_with_name(
- path: &str,
+ path: impl Into<String>,
  projection: Option<Vec<usize>>,
  max_concurrency: usize,
- table_name: &str,
+ table_name: impl Into<String>,
  ) -> Result<Self> {
  let provider = Arc::new(ParquetTable::try_new(path, max_concurrency)?);
  Self::scan(table_name, provider, projection)
@@ -166,10 +168,12 @@ impl LogicalPlanBuilder {
 
  /// Convert a table provider into a builder with a TableScan
  pub fn scan(
- table_name: &str,
+ table_name: impl Into<String>,
  provider: Arc<dyn TableProvider>,
  projection: Option<Vec<usize>>,
  ) -> Result<Self> {
+ let table_name = table_name.into();
+
  if table_name.is_empty() {
  return Err(DataFusionError::Plan(
  "table_name cannot be empty".to_string(),
@@ -184,17 +188,17 @@ impl LogicalPlanBuilder {
  DFSchema::new(
  p.iter()
  .map(|i| {
- DFField::from_qualified(table_name, schema.field(*i).clone())
+ DFField::from_qualified(&table_name, schema.field(*i).clone())
  })
  .collect(),
  )
  })
  .unwrap_or_else(|| {
- DFSchema::try_from_qualified_schema(table_name, &schema)
+ DFSchema::try_from_qualified_schema(&table_name, &schema)
  })?;
 
  let table_scan = LogicalPlan::TableScan {
- table_name: table_name.to_string(),
+ table_name,
  source: provider,
  projected_schema: Arc::new(projected_schema),
  projection,

datafusion/src/logical_plan/expr.rs

@@ -44,10 +44,10 @@ pub struct Column {
 
 impl Column {
  /// Create Column from unqualified name.
- pub fn from_name(name: String) -> Self {
+ pub fn from_name(name: impl Into<String>) -> Self {
  Self {
  relation: None,
- name,
+ name: name.into(),
  }
  }
 
@@ -131,7 +131,7 @@ impl fmt::Display for Column {
 /// ```
 /// # use datafusion::logical_plan::*;
 /// let expr = col("c1");
-/// assert_eq!(expr, Expr::Column(Column::from_name("c1".to_string())));
+/// assert_eq!(expr, Expr::Column(Column::from_name("c1")));
 /// ```
 ///
 /// ## Create the expression `c1 + c2` to add columns "c1" and "c2" together

datafusion/src/optimizer/filter_push_down.rs

@@ -890,8 +890,8 @@ mod tests {
  .join(
  &right,
  JoinType::Inner,
- vec![Column::from_name("a".to_string())],
- vec![Column::from_name("a".to_string())],
+ vec![Column::from_name("a")],
+ vec![Column::from_name("a")],
  )?
  .filter(col("a").lt_eq(lit(1i64)))?
  .build()?;
@@ -933,8 +933,8 @@ mod tests {
  .join(
  &right,
  JoinType::Inner,
- vec![Column::from_name("a".to_string())],
- vec![Column::from_name("a".to_string())],
+ vec![Column::from_name("a")],
+ vec![Column::from_name("a")],
  )?
  // "b" and "c" are not shared by either side: they are only available together after the join
  .filter(col("c").lt_eq(col("b")))?
@@ -972,8 +972,8 @@ mod tests {
  .join(
  &right,
  JoinType::Inner,
- vec![Column::from_name("a".to_string())],
- vec![Column::from_name("a".to_string())],
+ vec![Column::from_name("a")],
+ vec![Column::from_name("a")],
  )?
  .filter(col("b").lt_eq(lit(1i64)))?
  .build()?;

datafusion/src/optimizer/projection_push_down.rs

@@ -241,7 +241,7 @@ fn optimize_plan(
  {
  window_expr.iter().try_for_each(|expr| {
  let name = &expr.name(schema)?;
- let column = Column::from_name(name.to_string());
+ let column = Column::from_name(name);
  if required_columns.contains(&column) {
  new_window_expr.push(expr.clone());
  new_required_columns.insert(column);
@@ -286,7 +286,7 @@ fn optimize_plan(
  let mut new_aggr_expr = Vec::new();
  aggr_expr.iter().try_for_each(|expr| {
  let name = &expr.name(schema)?;
- let column = Column::from_name(name.to_string());
+ let column = Column::from_name(name);
 
  if required_columns.contains(&column) {
  new_aggr_expr.push(expr.clone());

datafusion/src/optimizer/utils.rs

@@ -516,7 +516,7 @@ mod tests {
  &mut accum,
  )?;
  assert_eq!(1, accum.len());
- assert!(accum.contains(&Column::from_name("a".to_string())));
+ assert!(accum.contains(&Column::from_name("a")));
  Ok(())
  }
 

datafusion/src/physical_plan/aggregates.rs

@@ -110,9 +110,9 @@ pub fn create_aggregate_expr(
  distinct: bool,
  args: &[Arc<dyn PhysicalExpr>],
  input_schema: &Schema,
- name: String,
+ name: impl Into<String>,
 ) -> Result<Arc<dyn AggregateExpr>> {
-// coerce
+let name = name.into();
  let arg = coerce(args, input_schema, &signature(fun))?;
  if arg.is_empty() {
  return Err(DataFusionError::Plan(format!(

datafusion/src/physical_plan/expressions/average.rs

@@ -64,9 +64,13 @@ pub fn avg_return_type(arg_type: &DataType) -> Result<DataType> {
 
 impl Avg {
  /// Create a new AVG aggregate function
- pub fn new(expr: Arc<dyn PhysicalExpr>, name: String, data_type: DataType) -> Self {
+ pub fn new(
+ expr: Arc<dyn PhysicalExpr>,
+ name: impl Into<String>,
+ data_type: DataType,
+ ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  nullable: true,

datafusion/src/physical_plan/expressions/count.rs

@@ -44,9 +44,13 @@ pub struct Count {
 
 impl Count {
  /// Create a new COUNT aggregate function.
- pub fn new(expr: Arc<dyn PhysicalExpr>, name: String, data_type: DataType) -> Self {
+ pub fn new(
+ expr: Arc<dyn PhysicalExpr>,
+ name: impl Into<String>,
+ data_type: DataType,
+ ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  nullable: true,

datafusion/src/physical_plan/expressions/min_max.rs

@@ -49,9 +49,13 @@ pub struct Max {
 
 impl Max {
  /// Create a new MAX aggregate function
- pub fn new(expr: Arc<dyn PhysicalExpr>, name: String, data_type: DataType) -> Self {
+ pub fn new(
+ expr: Arc<dyn PhysicalExpr>,
+ name: impl Into<String>,
+ data_type: DataType,
+ ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  nullable: true,
@@ -352,9 +356,13 @@ pub struct Min {
 
 impl Min {
  /// Create a new MIN aggregate function
- pub fn new(expr: Arc<dyn PhysicalExpr>, name: String, data_type: DataType) -> Self {
+ pub fn new(
+ expr: Arc<dyn PhysicalExpr>,
+ name: impl Into<String>,
+ data_type: DataType,
+ ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  nullable: true,

datafusion/src/physical_plan/expressions/nth_value.rs

@@ -45,12 +45,12 @@ pub struct NthValue {
 impl NthValue {
  /// Create a new FIRST_VALUE window aggregate function
  pub fn first_value(
- name: String,
+ name: impl Into<String>,
  expr: Arc<dyn PhysicalExpr>,
  data_type: DataType,
  ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  kind: NthValueKind::First,
@@ -59,12 +59,12 @@ impl NthValue {
 
  /// Create a new LAST_VALUE window aggregate function
  pub fn last_value(
- name: String,
+ name: impl Into<String>,
  expr: Arc<dyn PhysicalExpr>,
  data_type: DataType,
  ) -> Self {
  Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  kind: NthValueKind::Last,
@@ -73,7 +73,7 @@ impl NthValue {
 
  /// Create a new NTH_VALUE window aggregate function
  pub fn nth_value(
- name: String,
+ name: impl Into<String>,
  expr: Arc<dyn PhysicalExpr>,
  data_type: DataType,
  n: u32,
@@ -83,7 +83,7 @@ impl NthValue {
  "nth_value expect n to be > 0".to_owned(),
  )),
  _ => Ok(Self {
- name,
+ name: name.into(),
  expr,
  data_type,
  kind: NthValueKind::Nth(n),

datafusion/src/physical_plan/expressions/row_number.rs

@@ -32,8 +32,8 @@ pub struct RowNumber {
 
 impl RowNumber {
  /// Create a new ROW_NUMBER function
- pub fn new(name: String) -> Self {
- Self { name }
+ pub fn new(name: impl Into<String>) -> Self {
+ Self { name: name.into() }
  }
 }