use f64 for cost calculation

Author: JanKaul

datafusion/optimizer/src/reorder_join/cost.rs

@@ -2,7 +2,7 @@ use datafusion_common::{plan_datafusion_err, plan_err, stats::Precision, Result}
 use datafusion_expr::{Join, JoinType, LogicalPlan};
 
 pub trait JoinCostEstimator: std::fmt::Debug {
-    fn cardinality(&self, plan: &LogicalPlan) -> Option<usize> {
+    fn cardinality(&self, plan: &LogicalPlan) -> Option<f64> {
         estimate_cardinality(plan).ok()
     }
 
@@ -13,8 +13,8 @@ pub trait JoinCostEstimator: std::fmt::Debug {
         }
     }
 
-    fn cost(&self, selectivity: f64, cardinality: usize) -> f64 {
-        selectivity * cardinality as f64
+    fn cost(&self, selectivity: f64, cardinality: f64) -> f64 {
+        selectivity * cardinality
     }
 }
 
@@ -24,15 +24,15 @@ pub struct DefaultCostEstimator;
 
 impl JoinCostEstimator for DefaultCostEstimator {}
 
-fn estimate_cardinality(plan: &LogicalPlan) -> Result<usize> {
+fn estimate_cardinality(plan: &LogicalPlan) -> Result<f64> {
     match plan {
         LogicalPlan::Filter(filter) => {
             let input_cardinality = estimate_cardinality(&filter.input)?;
-            Ok((0.1 * input_cardinality as f64) as usize)
+            Ok(0.1 * input_cardinality)
         }
         LogicalPlan::Aggregate(agg) => {
             let input_cardinality = estimate_cardinality(&agg.input)?;
-            Ok((0.1 * input_cardinality as f64) as usize)
+            Ok(0.1 * input_cardinality)
         }
         LogicalPlan::TableScan(scan) => {
             let statistics = scan
@@ -42,7 +42,7 @@ fn estimate_cardinality(plan: &LogicalPlan) -> Result<usize> {
             if let Precision::Exact(num_rows) | Precision::Inexact(num_rows) =
                 statistics.num_rows
             {
-                Ok(num_rows)
+                Ok(num_rows as f64)
             } else {
                 plan_err!("Number of rows not available")
             }

datafusion/optimizer/src/reorder_join/left_deep_join_plan.rs

@@ -167,14 +167,14 @@ pub fn query_graph_to_optimal_left_deep_join_plan(
 struct QueryNode {
     node_id: NodeId,
     // T in [IbarakiKameda84]
-    selectivity: usize,
+    selectivity: f64,
     // C in [IbarakiKameda84]
     cost: f64,
 }
 
 impl QueryNode {
     fn rank(&self) -> f64 {
-        (self.selectivity - 1) as f64 / self.cost
+        (self.selectivity - 1.0) / self.cost
     }
 }
 
@@ -303,7 +303,7 @@ impl<'graph> PrecedenceTreeNode<'graph> {
         let node = query_graph
             .get_node(node_id)
             .ok_or_else(|| plan_datafusion_err!("Root node not found"))?;
-        let input_cardinality = cost_estimator.cardinality(&node.plan).unwrap_or(1);
+        let input_cardinality = cost_estimator.cardinality(&node.plan).unwrap_or(1.0);
 
         let children = node
             .connections()
@@ -331,7 +331,7 @@ impl<'graph> PrecedenceTreeNode<'graph> {
         Ok(PrecedenceTreeNode {
             query_nodes: vec![QueryNode {
                 node_id,
-                selectivity: (selectivity * input_cardinality as f64) as usize,
+                selectivity: (selectivity * input_cardinality),
                 cost: if is_root {
                     0.0
                 } else {
@@ -348,15 +348,15 @@ impl<'graph> PrecedenceTreeNode<'graph> {
         let (cardinality, cost) =
             self.query_nodes
                 .iter()
-                .fold((1, 0.0), |(cardinality, cost), node| {
-                    let cost = cost + cardinality as f64 * node.cost;
+                .fold((1.0, 0.0), |(cardinality, cost), node| {
+                    let cost = cost + cardinality * node.cost;
                     let cardinality = cardinality * node.selectivity;
                     (cardinality, cost)
                 });
         if cost == 0.0 {
             0.0
         } else {
-            (cardinality.saturating_sub(1)) as f64 / cost
+            (cardinality - 1.0) as f64 / cost
         }
     }
 
@@ -642,12 +642,12 @@ impl<'graph> PrecedenceTreeNode<'graph> {
         self.cost_recursive(self.query_nodes[0].selectivity, 0.0)
     }
 
-    fn cost_recursive(&self, cardinality: usize, cost: f64) -> Result<f64> {
+    fn cost_recursive(&self, cardinality: f64, cost: f64) -> Result<f64> {
         let cost = match self.children.len() {
-            0 => cost + cardinality as f64 * self.query_nodes[0].cost,
+            0 => cost + cardinality * self.query_nodes[0].cost,
             1 => self.children[0].cost_recursive(
                 cardinality * self.query_nodes[0].selectivity,
-                cost + cardinality as f64 * self.query_nodes[0].cost,
+                cost + cardinality * self.query_nodes[0].cost,
             )?,
             _ => {
                 return plan_err!(