rubydb 0.1.4 → 0.1.6

data/lib/rubydb/execution/operator_selection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    class OperatorSelection
+      def initialize(engine)
+        @engine = engine
+      end
+
+      def choose_scan(plan)
+        return plan unless plan.type == :select
+
+        table_name = plan.table_name
+        return plan.set_scan_type(:sequential) unless table_name
+
+        index = matching_index(plan)
+        index ? plan.set_scan_type(:index, index) : plan.set_scan_type(:sequential)
+      end
+
+      def physical_operator(plan)
+        return :index_scan if plan.scan_type == :index
+        return :sequential_scan if plan.scan_type == :sequential
+        return :hash_join if plan.joins&.any?
+
+        plan.type
+      end
+
+      private
+
+      def matching_index(plan)
+        return nil unless @engine.respond_to?(:index_manager) && plan.predicate
+
+        columns = predicate_columns(plan.predicate).map(&:to_s)
+        @engine.index_manager.get_indexes_for_table(plan.table_name).find do |index|
+          index.columns.any? { |column| columns.include?(column.to_s) }
+        end
+      rescue
+        nil
+      end
+
+      def predicate_columns(predicate)
+        case predicate
+        when Predicate::Comparison
+          [predicate.left.respond_to?(:name) ? predicate.left.name : nil].compact
+        when Predicate::And, Predicate::Or
+          predicate_columns(predicate.left) + predicate_columns(predicate.right)
+        when Predicate::Not
+          predicate_columns(predicate.operand)
+        when Predicate::Between, Predicate::In, Predicate::IsNull, Predicate::Like
+          [predicate.expression.respond_to?(:name) ? predicate.expression.name : nil].compact
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/execution/optimizer.rb

@@ -1,215 +1,227 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Execution
-    # Optimizer - Query optimization with cost-based decisions
-    class Optimizer
-      attr_reader :stats
-
-      def initialize(engine)
-        @engine = engine
-        @stats = {
-          optimizations: 0,
-          plans_considered: 0,
-          best_plan_found: 0
-        }
-        @lock = Mutex.new
-      end
-
-      def optimize(plan)
-        @lock.synchronize do
-          @stats[:plans_considered] += 1
-
-          # Generate alternative plans
-          alternatives = generate_alternatives(plan)
-
-          # Choose the best plan
-          best_plan = choose_best_plan(alternatives)
-
-          @stats[:best_plan_found] += 1
-          @stats[:optimizations] += 1
-
-          best_plan
-        end
-      end
-
-      def generate_alternatives(plan)
-        alternatives = [plan]
-
-        # If SELECT, try different scan methods
-        if plan.is_a?(Plan::Select)
-          # Try sequential scan
-          seq_plan = plan.dup
-          seq_plan.set_scan_type(:sequential)
-          alternatives << seq_plan
-
-          # Try index scan if available
-          if @engine.respond_to?(:index_manager)
-            indexes = @engine.index_manager.get_indexes_for_table(plan.table_name)
-            indexes.each do |index|
-              idx_plan = plan.dup
-              idx_plan.set_scan_type(:index, index)
-              alternatives << idx_plan
-            end
-          end
-
-          # Join ordering is applied by Planner for inner-join chains. Keep
-          # this alternative generation focused on scan-method choices so it
-          # cannot reorder an outer join accidentally.
-        end
-
-        alternatives
-      end
-
-      def choose_best_plan(plans)
-        return plans.first if plans.size == 1
-
-        best_plan = nil
-        best_cost = Float::INFINITY
-
-        plans.each do |plan|
-          cost = calculate_cost(plan)
-          if cost < best_cost
-            best_cost = cost
-            best_plan = plan
-          end
-        end
-
-        best_plan || plans.first
-      end
-
-      def calculate_cost(plan)
-        case plan
-        when Plan::Select
-          calculate_select_cost(plan)
-        when Plan::Insert
-          1.0
-        when Plan::Update
-          calculate_update_cost(plan)
-        when Plan::Delete
-          calculate_delete_cost(plan)
-        else
-          1.0
-        end
-      end
-
-      def calculate_select_cost(plan)
-        table_name = plan.table_name
-        row_count = @engine.table_row_count(table_name) rescue 1000
-
-        base_cost = case plan.scan_type
-        when :sequential
-          row_count
-        when :index
-          row_count * 0.1
-        else
-          row_count
-        end
-
-        # Add predicate cost
-        if plan.predicate
-          selectivity = estimate_selectivity(plan.predicate)
-          base_cost *= selectivity
-        end
-
-        # Add order by cost
-        if plan.order_by && plan.order_by.any?
-          base_cost += row_count * Math.log2(row_count)
-        end
-
-        # Add group by cost
-        if plan.group_by && plan.group_by.any?
-          base_cost += row_count * 1.5
-        end
-
-        # Add limit/offset cost
-        if plan.limit
-          base_cost *= 0.5
-        end
-
-        base_cost
-      end
-
-      def calculate_update_cost(plan)
-        table_name = plan.table_name
-        row_count = @engine.table_row_count(table_name) rescue 1000
-
-        cost = row_count
-
-        if plan.predicate
-          selectivity = estimate_selectivity(plan.predicate)
-          cost *= selectivity
-        end
-
-        cost
-      end
-
-      def calculate_delete_cost(plan)
-        table_name = plan.table_name
-        row_count = @engine.table_row_count(table_name) rescue 1000
-
-        cost = row_count
-
-        if plan.predicate
-          selectivity = estimate_selectivity(plan.predicate)
-          cost *= selectivity
-        end
-
-        cost
-      end
-
-      def estimate_selectivity(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
-          when :LIKE then 0.1
-          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)
-        when Predicate::Between
-          0.3
-        when Predicate::In
-          0.02 * predicate.values.size
-        else
-          0.5
-        end
-      end
-
-      def analyze_plan(plan)
-        {
-          plan_type: plan.type,
-          table: plan.table_name,
-          scan_type: plan.scan_type,
-          has_predicate: !plan.predicate.nil?,
-          has_order_by: plan.order_by && plan.order_by.any?,
-          has_group_by: plan.group_by && plan.group_by.any?,
-          has_limit: !plan.limit.nil?,
-          estimated_cost: calculate_cost(plan)
-        }
-      end
-
-      def explain_optimization(plan)
-        before = calculate_cost(plan)
-        optimized = optimize(plan)
-        after = calculate_cost(optimized)
-
-        {
-          original_cost: before,
-          optimized_cost: after,
-          improvement: ((before - after) / before * 100).round(2),
-          optimized_plan: optimized
-        }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # Optimizer - Query optimization with cost-based decisions
+    class Optimizer
+      attr_reader :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          optimizations: 0,
+          plans_considered: 0,
+          best_plan_found: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def optimize(plan)
+        @lock.synchronize do
+          @stats[:plans_considered] += 1
+
+          # Generate alternative plans
+          alternatives = generate_alternatives(plan)
+
+          # Choose the best plan
+          best_plan = choose_best_plan(alternatives)
+
+          @stats[:best_plan_found] += 1
+          @stats[:optimizations] += 1
+
+          best_plan
+        end
+      end
+
+      def generate_alternatives(plan)
+        alternatives = [plan]
+
+        # If SELECT, try different scan methods
+        if plan.is_a?(Plan::Select)
+          # Try sequential scan
+          seq_plan = plan.dup
+          seq_plan.set_scan_type(:sequential)
+          alternatives << seq_plan
+
+          # Try index scan if available
+          if @engine.respond_to?(:index_manager)
+            indexes = @engine.index_manager.get_indexes_for_table(plan.table_name)
+            indexes.each do |index|
+              idx_plan = plan.dup
+              idx_plan.set_scan_type(:index, index)
+              alternatives << idx_plan
+            end
+          end
+
+          # Join ordering is applied by Planner for inner-join chains. Keep
+          # this alternative generation focused on scan-method choices so it
+          # cannot reorder an outer join accidentally.
+        end
+
+        alternatives
+      end
+
+      def choose_best_plan(plans)
+        return plans.first if plans.size == 1
+
+        best_plan = nil
+        best_cost = Float::INFINITY
+
+        plans.each do |plan|
+          cost = calculate_cost(plan)
+          if cost < best_cost
+            best_cost = cost
+            best_plan = plan
+          end
+        end
+
+        best_plan || plans.first
+      end
+
+      def calculate_cost(plan)
+        case plan
+        when Plan::Select
+          calculate_select_cost(plan)
+        when Plan::Insert
+          1.0
+        when Plan::Update
+          calculate_update_cost(plan)
+        when Plan::Delete
+          calculate_delete_cost(plan)
+        else
+          1.0
+        end
+      end
+
+      def calculate_select_cost(plan)
+        table_name = plan.table_name
+        row_count = begin
+          @engine.table_row_count(table_name)
+        rescue
+          1000
+        end
+
+        base_cost = case plan.scan_type
+        when :sequential
+          row_count
+        when :index
+          row_count * 0.1
+        else
+          row_count
+        end
+
+        # Add predicate cost
+        if plan.predicate
+          selectivity = estimate_selectivity(plan.predicate)
+          base_cost *= selectivity
+        end
+
+        # Add order by cost
+        if plan.order_by&.any?
+          base_cost += row_count * Math.log2(row_count)
+        end
+
+        # Add group by cost
+        if plan.group_by&.any?
+          base_cost += row_count * 1.5
+        end
+
+        # Add limit/offset cost
+        if plan.limit
+          base_cost *= 0.5
+        end
+
+        base_cost
+      end
+
+      def calculate_update_cost(plan)
+        table_name = plan.table_name
+        row_count = begin
+          @engine.table_row_count(table_name)
+        rescue
+          1000
+        end
+
+        cost = row_count
+
+        if plan.predicate
+          selectivity = estimate_selectivity(plan.predicate)
+          cost *= selectivity
+        end
+
+        cost
+      end
+
+      def calculate_delete_cost(plan)
+        table_name = plan.table_name
+        row_count = begin
+          @engine.table_row_count(table_name)
+        rescue
+          1000
+        end
+
+        cost = row_count
+
+        if plan.predicate
+          selectivity = estimate_selectivity(plan.predicate)
+          cost *= selectivity
+        end
+
+        cost
+      end
+
+      def estimate_selectivity(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
+          when :LIKE then 0.1
+          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)
+        when Predicate::Between
+          0.3
+        when Predicate::In
+          0.02 * predicate.values.size
+        else
+          0.5
+        end
+      end
+
+      def analyze_plan(plan)
+        {
+          plan_type: plan.type,
+          table: plan.table_name,
+          scan_type: plan.scan_type,
+          has_predicate: !plan.predicate.nil?,
+          has_order_by: plan.order_by&.any?,
+          has_group_by: plan.group_by&.any?,
+          has_limit: !plan.limit.nil?,
+          estimated_cost: calculate_cost(plan)
+        }
+      end
+
+      def explain_optimization(plan)
+        before = calculate_cost(plan)
+        optimized = optimize(plan)
+        after = calculate_cost(optimized)
+
+        {
+          original_cost: before,
+          optimized_cost: after,
+          improvement: ((before - after) / before * 100).round(2),
+          optimized_plan: optimized
+        }
+      end
+    end
+  end
+end

data/lib/rubydb/execution/physical_plan.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # A compact description of the physical choices made for a logical Plan.
+    # Plan remains the executable object; this value is for explainability,
+    # cache keys, and the Ruby/Go dispatch boundary.
+    class PhysicalPlan
+      attr_reader :logical_plan, :operator, :estimated_cost, :estimated_rows, :properties
+
+      def self.from(plan, operator: nil, estimated_cost: nil, estimated_rows: nil, properties: {})
+        new(
+          plan,
+          operator: operator || default_operator(plan),
+          estimated_cost: estimated_cost.nil? ? plan.estimated_cost : estimated_cost,
+          estimated_rows: estimated_rows.nil? ? plan.estimated_rows : estimated_rows,
+          properties: properties
+        )
+      end
+
+      def self.default_operator(plan)
+        return :index_scan if plan.respond_to?(:scan_type) && plan.scan_type == :index
+        return :sequential_scan if plan.respond_to?(:scan_type) && plan.scan_type == :sequential
+
+        plan.type
+      end
+
+      def initialize(logical_plan, operator:, estimated_cost:, estimated_rows:, properties:)
+        @logical_plan = logical_plan
+        @operator = operator.to_sym
+        @estimated_cost = estimated_cost
+        @estimated_rows = estimated_rows
+        @properties = properties.freeze
+        freeze
+      end
+
+      def to_h
+        {
+          operator: @operator,
+          estimated_cost: @estimated_cost,
+          estimated_rows: @estimated_rows,
+          properties: @properties
+        }
+      end
+    end
+  end
+end