rubydb 0.1.4 → 0.1.6

data/lib/rubydb/execution/aggregate_executor.rb

@@ -1,138 +1,134 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Execution
-    # AggregateExecutor - Executes aggregate operations (GROUP BY, aggregate functions)
-    class AggregateExecutor
-      attr_reader :engine, :stats
-
-      def initialize(engine)
-        @engine = engine
-        @stats = {
-          aggregations: 0,
-          groups_produced: 0,
-          total_time_ms: 0
-        }
-        @lock = Mutex.new
-      end
-
-      def execute(plan, transaction_id = nil)
-        @lock.synchronize do
-          start_time = Time.now
-          @stats[:aggregations] += 1
-
-          # Get input rows
-          rows = plan.input_rows || []
-          if rows.empty? && plan.input_plan
-            executor = Executor.new(@engine)
-            result = executor.execute(plan.input_plan, transaction_id)
-            rows = result[:rows] if result
-          end
-
-          group_by = plan.group_by || []
-          aggregates = plan.aggregates || []
-
-          # Perform aggregation
-          result = if group_by.empty?
-            # Global aggregation
-            aggregate_globally(rows, aggregates)
-          else
-            # Grouped aggregation
-            aggregate_by_groups(rows, group_by, aggregates)
-          end
-
-          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
-          @stats[:groups_produced] += result.size
-          @stats[:total_time_ms] += elapsed_ms
-
-          {
-            rows: result,
-            row_count: result.size,
-            groups: group_by,
-            aggregates: aggregates,
-            message: "AGGREGATE produced #{result.size} groups"
-          }
-        end
-      end
-
-      private
-
-      def aggregate_globally(rows, aggregates)
-        return [] if rows.empty? && aggregates.empty?
-
-        result = {}
-        
-        aggregates.each do |agg|
-          values = rows.map { |row| row[agg.column.to_s] }.compact
-          result[agg.alias || agg.name] = apply_aggregate(agg, values)
-        end
-
-        [result]
-      end
-
-      def aggregate_by_groups(rows, group_by, aggregates)
-        groups = {}
-        
-        rows.each do |row|
-          # Build group key
-          key = group_by.map { |col| row[col.to_s] }
-          key_str = key.join("||")
-          
-          groups[key_str] ||= {
-            key: key,
-            rows: [],
-            values: {}
-          }
-          groups[key_str][:rows] << row
-        end
-
-        result = []
-        groups.each do |_key_str, group|
-          row_result = {}
-          
-          # Add group by columns
-          group_by.each_with_index do |col, idx|
-            row_result[col.to_s] = group[:key][idx]
-          end
-          
-          # Apply aggregates
-          aggregates.each do |agg|
-            values = group[:rows].map { |r| r[agg.column.to_s] }.compact
-            row_result[agg.alias || agg.name] = apply_aggregate(agg, values)
-          end
-          
-          result << row_result
-        end
-        
-        result
-      end
-
-      def apply_aggregate(agg, values)
-        case agg.name.to_s.upcase
-        when "COUNT"
-          values.size
-        when "SUM"
-          values.sum
-        when "AVG"
-          values.empty? ? 0 : values.sum / values.size.to_f
-        when "MIN"
-          values.min
-        when "MAX"
-          values.max
-        when "GROUP_CONCAT"
-          values.join(",")
-        when "ARRAY_AGG"
-          values
-        when "STRING_AGG"
-          values.join(agg.separator || ",")
-        else
-          nil
-        end
-      end
-
-      def stats
-        @stats
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # AggregateExecutor - Executes aggregate operations (GROUP BY, aggregate functions)
+    class AggregateExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          aggregations: 0,
+          groups_produced: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:aggregations] += 1
+
+          # Get input rows
+          rows = plan.input_rows || []
+          if rows.empty? && plan.input_plan
+            executor = Executor.new(@engine)
+            result = executor.execute(plan.input_plan, transaction_id)
+            rows = result[:rows] if result
+          end
+
+          group_by = plan.group_by || []
+          aggregates = plan.aggregates || []
+
+          # Perform aggregation
+          result = if group_by.empty?
+            # Global aggregation
+            aggregate_globally(rows, aggregates)
+          else
+            # Grouped aggregation
+            aggregate_by_groups(rows, group_by, aggregates)
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:groups_produced] += result.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: result,
+            row_count: result.size,
+            groups: group_by,
+            aggregates: aggregates,
+            message: "AGGREGATE produced #{result.size} groups"
+          }
+        end
+      end
+
+      private
+
+      def aggregate_globally(rows, aggregates)
+        return [] if rows.empty? && aggregates.empty?
+
+        result = {}
+
+        aggregates.each do |agg|
+          values = rows.map { |row| row[agg.column.to_s] }.compact
+          result[agg.alias || agg.name] = apply_aggregate(agg, values)
+        end
+
+        [result]
+      end
+
+      def aggregate_by_groups(rows, group_by, aggregates)
+        groups = {}
+
+        rows.each do |row|
+          # Build group key
+          key = group_by.map { |col| row[col.to_s] }
+          key_str = key.join("||")
+
+          groups[key_str] ||= {
+            key: key,
+            rows: [],
+            values: {}
+          }
+          groups[key_str][:rows] << row
+        end
+
+        result = []
+        groups.each do |_key_str, group|
+          row_result = {}
+
+          # Add group by columns
+          group_by.each_with_index do |col, idx|
+            row_result[col.to_s] = group[:key][idx]
+          end
+
+          # Apply aggregates
+          aggregates.each do |agg|
+            values = group[:rows].map { |r| r[agg.column.to_s] }.compact
+            row_result[agg.alias || agg.name] = apply_aggregate(agg, values)
+          end
+
+          result << row_result
+        end
+
+        result
+      end
+
+      def apply_aggregate(agg, values)
+        case agg.name.to_s.upcase
+        when "COUNT"
+          values.size
+        when "SUM"
+          values.sum
+        when "AVG"
+          values.empty? ? 0 : values.sum / values.size.to_f
+        when "MIN"
+          values.min
+        when "MAX"
+          values.max
+        when "GROUP_CONCAT"
+          values.join(",")
+        when "ARRAY_AGG"
+          values
+        when "STRING_AGG"
+          values.join(agg.separator || ",")
+        end
+      end
+
+      attr_reader :stats
+    end
+  end
+end

data/lib/rubydb/execution/cost_model.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # Conservative planner estimates. They are deliberately independent from
+    # the Go runtime: a wrong estimate must never change SQL semantics.
+    class CostModel
+      attr_reader :engine
+
+      def initialize(engine)
+        @engine = engine
+      end
+
+      def apply(plan)
+        row_count = table_row_count(plan.table_name)
+        selectivity = estimate_selectivity(plan.predicate)
+        estimated_rows = [(row_count * selectivity).ceil, 0].max
+        cost = case plan.scan_type
+        when :index
+          plan.predicate ? estimated_rows * 0.1 : row_count * 0.5
+        when :sequential
+          row_count
+        else
+          row_count
+        end
+        cost += sort_cost(estimated_rows) if plan.order_by&.any?
+        cost += estimated_rows if plan.aggregates&.any?
+        plan.set_cost(cost, estimated_rows)
+      end
+
+      def estimate_selectivity(predicate)
+        return 1.0 unless predicate
+
+        case predicate
+        when Predicate::Comparison
+          case predicate.operator
+          when :EQ then 0.01
+          when :NE then 0.9
+          when :LT, :LTE, :GT, :GTE then 0.5
+          else 0.5
+          end
+        when Predicate::And
+          estimate_selectivity(predicate.left) * estimate_selectivity(predicate.right)
+        when Predicate::Or
+          left = estimate_selectivity(predicate.left)
+          right = estimate_selectivity(predicate.right)
+          left + right - (left * right)
+        when Predicate::Not
+          1.0 - estimate_selectivity(predicate.operand)
+        else
+          0.5
+        end
+      end
+
+      private
+
+      def table_row_count(table_name)
+        return 0 unless table_name
+
+        Integer(@engine.table_row_count(table_name))
+      rescue
+        0
+      end
+
+      def sort_cost(rows)
+        return 0 if rows < 2
+
+        rows * Math.log2(rows)
+      end
+    end
+  end
+end

data/lib/rubydb/execution/delete_executor.rb

@@ -1,112 +1,110 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Execution
-    # DeleteExecutor - Executes DELETE operations
-    class DeleteExecutor
-      attr_reader :engine, :stats
-
-      def initialize(engine)
-        @engine = engine
-        @stats = {
-          deletes: 0,
-          rows_deleted: 0,
-          total_time_ms: 0
-        }
-        @lock = Mutex.new
-      end
-
-      def execute(plan, transaction_id = nil)
-        @lock.synchronize do
-          start_time = Time.now
-          @stats[:deletes] += 1
-
-          table_name = plan.table_name
-          predicate = plan.predicate
-
-          # Get table columns
-          table_columns = @engine.table_columns(table_name)
-          raise ExecutionError, "Table '#{table_name}' does not exist" if table_columns.empty?
-
-          # Find rows to delete
-          rows = find_rows(table_name, predicate)
-
-          deleted_count = 0
-          deleted_rows = []
-
-          rows.each do |row|
-            row_id = row[:_row_id] || row["_row_id"] || row[:id] || row["id"]
-
-            # Delete from engine
-            @engine.delete_row(table_name, row_id, transaction_id: transaction_id)
-
-            deleted_count += 1
-            deleted_rows << row
-          end
-
-          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
-          @stats[:rows_deleted] += deleted_count
-          @stats[:total_time_ms] += elapsed_ms
-
-          {
-            rows: deleted_rows,
-            row_count: deleted_count,
-            row_ids: deleted_rows.map { |r| r[:_row_id] || r["_row_id"] },
-            message: "DELETE #{deleted_count}"
-          }
-        end
-      end
-
-      def execute_batch(plan, row_ids, transaction_id = nil)
-        @lock.synchronize do
-          start_time = Time.now
-          @stats[:deletes] += 1
-
-          table_name = plan.table_name
-          table_columns = @engine.table_columns(table_name)
-
-          deleted_count = 0
-          deleted_rows = []
-
-          row_ids.each do |row_id|
-            row = @engine.select_row(table_name, row_id, table_columns)
-            next unless row
-
-            @engine.delete_row(table_name, row_id, transaction_id: transaction_id)
-
-            deleted_count += 1
-            deleted_rows << row
-          end
-
-          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
-          @stats[:rows_deleted] += deleted_count
-          @stats[:total_time_ms] += elapsed_ms
-
-          {
-            rows: deleted_rows,
-            row_count: deleted_count,
-            row_ids: row_ids,
-            message: "DELETE #{deleted_count}"
-          }
-        end
-      end
-
-      private
-
-      def find_rows(table_name, predicate)
-        table_columns = @engine.table_columns(table_name)
-        rows = @engine.select_rows(table_name, table_columns)
-
-        if predicate
-          rows.select { |row| predicate.evaluate(row) }
-        else
-          rows
-        end
-      end
-
-      def stats
-        @stats
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # DeleteExecutor - Executes DELETE operations
+    class DeleteExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          deletes: 0,
+          rows_deleted: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:deletes] += 1
+
+          table_name = plan.table_name
+          predicate = plan.predicate
+
+          # Get table columns
+          table_columns = @engine.table_columns(table_name)
+          raise ExecutionError, "Table '#{table_name}' does not exist" if table_columns.empty?
+
+          # Find rows to delete
+          rows = find_rows(table_name, predicate)
+
+          deleted_count = 0
+          deleted_rows = []
+
+          rows.each do |row|
+            row_id = row[:_row_id] || row["_row_id"] || row[:id] || row["id"]
+
+            # Delete from engine
+            @engine.delete_row(table_name, row_id, transaction_id: transaction_id)
+
+            deleted_count += 1
+            deleted_rows << row
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_deleted] += deleted_count
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: deleted_rows,
+            row_count: deleted_count,
+            row_ids: deleted_rows.map { |r| r[:_row_id] || r["_row_id"] },
+            message: "DELETE #{deleted_count}"
+          }
+        end
+      end
+
+      def execute_batch(plan, row_ids, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:deletes] += 1
+
+          table_name = plan.table_name
+          table_columns = @engine.table_columns(table_name)
+
+          deleted_count = 0
+          deleted_rows = []
+
+          row_ids.each do |row_id|
+            row = @engine.select_row(table_name, row_id, table_columns)
+            next unless row
+
+            @engine.delete_row(table_name, row_id, transaction_id: transaction_id)
+
+            deleted_count += 1
+            deleted_rows << row
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_deleted] += deleted_count
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: deleted_rows,
+            row_count: deleted_count,
+            row_ids: row_ids,
+            message: "DELETE #{deleted_count}"
+          }
+        end
+      end
+
+      private
+
+      def find_rows(table_name, predicate)
+        table_columns = @engine.table_columns(table_name)
+        rows = @engine.select_rows(table_name, table_columns)
+
+        if predicate
+          rows.select { |row| predicate.evaluate(row) }
+        else
+          rows
+        end
+      end
+
+      attr_reader :stats
+    end
+  end
+end