optd-core/src/cascades/mod.rs:145:28:w:warning: using `clone` on type `ScalarGroupId` which implements the `Copy` trait
   --> optd-core/src/cascades/mod.rs:145:28
    |
145 |                 predicate: scan.predicate.clone(),
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `scan.predicate`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
    = note: `#[warn(clippy::clone_on_copy)]` on by default


__END__

optd-core/src/cascades/mod.rs:153:24:w:warning: using `clone` on type `RelationalGroupId` which implements the `Copy` trait
   --> optd-core/src/cascades/mod.rs:153:24
    |
153 |                 child: filter.child.clone(),
    |                        ^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `filter.child`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy


__END__

optd-core/src/cascades/mod.rs:154:28:w:warning: using `clone` on type `ScalarGroupId` which implements the `Copy` trait
   --> optd-core/src/cascades/mod.rs:154:28
    |
154 |                 predicate: filter.predicate.clone(),
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `filter.predicate`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy


__END__

optd-datafusion/src/converter/from_optd.rs:60:38:w:warning: unnecessary use of `to_vec`
  --> optd-datafusion/src/converter/from_optd.rs:60:38
   |
60 |                   let physical_exprs = project
   |  ______________________________________^
61 | |                     .fields
62 | |                     .to_vec()
63 | |                     .into_iter()
   | |________________________________^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
   = note: `#[warn(clippy::unnecessary_to_owned)]` on by default
help: use
   |
60 ~                 let physical_exprs = project
61 +                     .fields.iter().cloned()
   |


__END__

optd-datafusion/src/converter/from_optd.rs:130:10:w:warning: parameter is only used in recursion
   --> optd-datafusion/src/converter/from_optd.rs:130:10
    |
130 |         &self,
    |          ^^^^
    |
note: parameter used here
   --> optd-datafusion/src/converter/from_optd.rs:152:28
    |
152 |                 let left = self.conv_optd_to_df_scalar(&and.left, context);
    |                            ^^^^
153 |                 let right = self.conv_optd_to_df_scalar(&and.right, context);
    |                             ^^^^
...
158 |                 let left = self.conv_optd_to_df_scalar(&add.left, context);
    |                            ^^^^
159 |                 let right = self.conv_optd_to_df_scalar(&add.right, context);
    |                             ^^^^
...
164 |                 let left = self.conv_optd_to_df_scalar(&equal.left, context);
    |                            ^^^^
165 |                 let right = self.conv_optd_to_df_scalar(&equal.right, context);
    |                             ^^^^
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion
    = note: `#[warn(clippy::only_used_in_recursion)]` on by default


__END__

optd-datafusion/src/converter/into_optd.rs:42:48:w:warning: using `clone` on type `Option<bool>` which implements the `Copy` trait
  --> optd-datafusion/src/converter/into_optd.rs:42:48
   |
42 |                         value: OptdValue::Bool(val.clone().unwrap()),
   |                                                ^^^^^^^^^^^ help: try dereferencing it: `(*val)`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
   = note: `#[warn(clippy::clone_on_copy)]` on by default


__END__

optd-datafusion/src/converter/into_optd.rs:46:77:w:warning: using `clone` on type `Option<i64>` which implements the `Copy` trait
  --> optd-datafusion/src/converter/into_optd.rs:46:77
   |
46 |                     ScalarOperator::Constant(Constant::new(OptdValue::Int64(val.clone().unwrap())))
   |                                                                             ^^^^^^^^^^^ help: try dereferencing it: `(*val)`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy


__END__

optd-datafusion/src/converter/into_optd.rs:28:10:w:warning: parameter is only used in recursion
  --> optd-datafusion/src/converter/into_optd.rs:28:10
   |
28 |         &self,
   |          ^^^^
   |
note: parameter used here
  --> optd-datafusion/src/converter/into_optd.rs:54:28
   |
54 |                 let left = self.conv_df_to_optd_scalar(&binary_expr.left, context, col_offset)?;
   |                            ^^^^
55 |                 let right = self.conv_df_to_optd_scalar(&binary_expr.right, context, col_offset)?;
   |                             ^^^^
...
64 |                 return self.conv_df_to_optd_scalar(&cast.expr, context, col_offset);
   |                        ^^^^
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion


__END__

optd-datafusion/src/converter/into_optd.rs:97:17:w:warning: returning the result of a `let` binding from a block
   --> optd-datafusion/src/converter/into_optd.rs:105:17
    |
97  | /                 let filter = LogicalOperator::Filter(Filter {
98  | |                     child: self.conv_df_to_optd_relational(&df_filter.input)?,
99  | |                     predicate: self.conv_df_to_optd_scalar(
100 | |                         &df_filter.predicate,
...   |
103 | |                     )?,
104 | |                 });
    | |___________________- unnecessary `let` binding
105 |                   filter
    |                   ^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
    = note: `#[warn(clippy::let_and_return)]` on by default
help: return the expression directly
    |
97  ~                 
98  ~                 LogicalOperator::Filter(Filter {
99  +                     child: self.conv_df_to_optd_relational(&df_filter.input)?,
100 +                     predicate: self.conv_df_to_optd_scalar(
101 +                         &df_filter.predicate,
102 +                         df_filter.input.schema(),
103 +                         0,
104 +                     )?,
105 +                 })
    |


__END__

optd-datafusion/src/converter/into_optd.rs:125:17:w:warning: returning the result of a `let` binding from a block
   --> optd-datafusion/src/converter/into_optd.rs:131:17
    |
125 | /                 let join = LogicalOperator::Join(Join::new(
126 | |                     &join.join_type.to_string(),
127 | |                     self.conv_df_to_optd_relational(&join.left)?,
128 | |                     self.conv_df_to_optd_relational(&join.right)?,
129 | |                     Self::flatten_scalar_as_conjunction(join_cond, 0),
130 | |                 ));
    | |___________________- unnecessary `let` binding
131 |                   join
    |                   ^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
help: return the expression directly
    |
125 ~                 
126 ~                 LogicalOperator::Join(Join::new(
127 +                     &join.join_type.to_string(),
128 +                     self.conv_df_to_optd_relational(&join.left)?,
129 +                     self.conv_df_to_optd_relational(&join.right)?,
130 +                     Self::flatten_scalar_as_conjunction(join_cond, 0),
131 +                 ))
    |


__END__

optd-datafusion/src/converter/into_optd.rs:162:17:w:warning: returning the result of a `let` binding from a block
   --> optd-datafusion/src/converter/into_optd.rs:167:17
    |
162 | /                 let project = LogicalOperator::Project(Project {
163 | |                     child: input,
164 | |                     fields: exprs,
165 | |                 });
    | |___________________- unnecessary `let` binding
166 |
167 |                   project
    |                   ^^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
help: return the expression directly
    |
162 ~                 
163 |
164 ~                 LogicalOperator::Project(Project {
165 +                     child: input,
166 +                     fields: exprs,
167 +                 })
    |


__END__

optd-datafusion/src/planner.rs:80:5:w:warning: empty line after doc comment
  --> optd-datafusion/src/planner.rs:52:5
   |
52 | /     /// * `PhysicalPlan` - The optimized physical plan.
...  |
79 | |
   | |_^
80 | /     pub async fn mock_optimize(
81 | |         &self,
82 | |         logical_plan: &LogicalPlan,
83 | |     ) -> anyhow::Result<Arc<PhysicalPlan>> {
   | |__________________________________________- the comment documents this method
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_doc_comments
   = note: `#[warn(clippy::empty_line_after_doc_comments)]` on by default
   = help: if the empty line is unintentional remove it
help: if the doc comment should not document `mock_optimize` comment it out
   |
31 ~     // /// A mock optimization function for testing purposes.
32 ~     // ///
33 ~     // /// This function takes a logical plan, and for each node in the logical plan, it will
34 ~     // /// recursively traverse the node and its children and replace the node with a physical
35 ~     // /// operator. The physical operator is chosen based on the type of the logical operator.
36 ~     // /// For example, if the logical operator is a scan, the physical operator will be a
37 ~     // /// TableScan, if the logical operator is a filter, the physical operator will be a
38 ~     // /// Filter, and so on.
39 ~     // ///
40 ~     // /// The physical operators are chosen in a way that they mirror the structure of the
41 ~     // /// logical plan, but they are not actually optimized in any way. This is useful for
42 ~     // /// testing purposes, as it allows us to test the structure of the physical plan without
43 ~     // /// having to worry about the actual optimization process.
44 ~     // ///
45 ~     // /// The function returns a PhysicalPlan, which is a struct that contains the root node of
46 ~     // /// the physical plan.
47 ~     // ///
48 ~     // /// # Arguments
49 ~     // /// * `logical_plan` - The logical plan to optimize.
50 ~     // ///
51 ~     // /// # Returns
52 ~     // /// * `PhysicalPlan` - The optimized physical plan.
   |


__END__