rubydb 0.1.0

data/lib/rubydb/execution/join_executor.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # JoinExecutor - Executes JOIN operations
+    class JoinExecutor
+      attr_reader :engine, :stats
+
+      # Join types
+      INNER_JOIN = :inner
+      LEFT_JOIN = :left
+      RIGHT_JOIN = :right
+      FULL_JOIN = :full
+      CROSS_JOIN = :cross
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          joins: 0,
+          rows_produced: 0,
+          total_time_ms: 0,
+          join_type_counts: Hash.new(0)
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:joins] += 1
+          @stats[:join_type_counts][plan.join_type] += 1
+
+          left_rows = plan.left_rows || []
+          right_rows = plan.right_rows || []
+
+          # If no rows provided, execute sub-plans
+          if left_rows.empty? && plan.left_plan
+            left_executor = Executor.new(@engine)
+            left_result = left_executor.execute(plan.left_plan, transaction_id)
+            left_rows = left_result[:rows] if left_result
+          end
+
+          if right_rows.empty? && plan.right_plan
+            right_executor = Executor.new(@engine)
+            right_result = right_executor.execute(plan.right_plan, transaction_id)
+            right_rows = right_result[:rows] if right_result
+          end
+
+          # Perform join
+          result = case plan.join_type
+          when INNER_JOIN
+            inner_join(left_rows, right_rows, plan.join_condition)
+          when LEFT_JOIN
+            left_join(left_rows, right_rows, plan.join_condition)
+          when RIGHT_JOIN
+            right_join(left_rows, right_rows, plan.join_condition)
+          when FULL_JOIN
+            full_join(left_rows, right_rows, plan.join_condition)
+          when CROSS_JOIN
+            cross_join(left_rows, right_rows)
+          else
+            inner_join(left_rows, right_rows, plan.join_condition)
+          end
+
+          # Apply projections if specified
+          if plan.projections
+            result = result.map do |row|
+              project_row(row, plan.projections)
+            end
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_produced] += result.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: result,
+            row_count: result.size,
+            left_rows: left_rows.size,
+            right_rows: right_rows.size,
+            message: "#{plan.join_type.to_s.upcase} JOIN produced #{result.size} rows"
+          }
+        end
+      end
+
+      def inner_join(left_rows, right_rows, condition)
+        return [] if left_rows.empty? || right_rows.empty?
+        return cross_join(left_rows, right_rows) if condition.nil?
+
+        return hash_join(left_rows, right_rows, condition) if infer_hash_keys(condition).all?
+
+        nested_loop_join(left_rows, right_rows, condition)
+      end
+
+      def nested_loop_join(left_rows, right_rows, condition)
+        result = []
+        left_rows.each do |left_row|
+          right_rows.each do |right_row|
+            if evaluate_join_condition(condition, left_row, right_row)
+              result << merge_rows(left_row, right_row)
+            end
+          end
+        end
+        result
+      end
+
+      def left_join(left_rows, right_rows, condition)
+        result = []
+        left_rows.each do |left_row|
+          matched = false
+          right_rows.each do |right_row|
+            if evaluate_join_condition(condition, left_row, right_row)
+              result << merge_rows(left_row, right_row)
+              matched = true
+            end
+          end
+          unless matched
+            result << merge_rows(left_row, nil)
+          end
+        end
+        result
+      end
+
+      def right_join(left_rows, right_rows, condition)
+        result = []
+        right_rows.each do |right_row|
+          matched = false
+          left_rows.each do |left_row|
+            if evaluate_join_condition(condition, left_row, right_row)
+              result << merge_rows(left_row, right_row)
+              matched = true
+            end
+          end
+          unless matched
+            result << merge_rows(nil, right_row)
+          end
+        end
+        result
+      end
+
+      def full_join(left_rows, right_rows, condition)
+        # Left join
+        left_result = left_join(left_rows, right_rows, condition)
+        
+        # Right join (only rows not already matched)
+        right_rows.each do |right_row|
+          matched = left_result.any? do |row|
+            row["_right_row"] && row["_right_row"] == right_row
+          end
+          unless matched
+            left_result << merge_rows(nil, right_row)
+          end
+        end
+        
+        left_result
+      end
+
+      def cross_join(left_rows, right_rows)
+        result = []
+        left_rows.each do |left_row|
+          right_rows.each do |right_row|
+            result << merge_rows(left_row, right_row)
+          end
+        end
+        result
+      end
+
+      def hash_join(left_rows, right_rows, condition, left_key: nil, right_key: nil)
+        left_key, right_key = infer_hash_keys(condition) if left_key.nil? || right_key.nil?
+        return nested_loop_join(left_rows, right_rows, condition) unless left_key && right_key
+
+        hash_table = Hash.new { |hash, key| hash[key] = [] }
+        right_rows.each { |row| hash_table[right_key.call(row)] << row }
+
+        left_rows.flat_map do |left_row|
+          key = left_key.call(left_row)
+          hash_table[key].filter_map do |right_row|
+            merge_rows(left_row, right_row) if evaluate_join_condition(condition, left_row, right_row)
+          end
+        end
+      end
+
+      private
+
+      def evaluate_join_condition(condition, left_row, right_row)
+        return true if condition.nil?
+        
+        # Bind row context
+        # Include both original sides and the merged column namespace. The
+        # latter lets ordinary column expressions evaluate during joins while
+        # preserving explicit _left/_right access for join predicates.
+        context = { "_left" => left_row, "_right" => right_row }
+        context.merge!(merge_rows(left_row, right_row))
+        condition.evaluate(context)
+      end
+
+      def infer_hash_keys(condition)
+        return [nil, nil] unless condition.is_a?(Predicate::Comparison) && condition.operator == :eq
+        left = condition.left
+        right = condition.right
+        return [nil, nil] unless left.respond_to?(:evaluate) && right.respond_to?(:evaluate)
+
+        [->(row) { left.evaluate(row) }, ->(row) { right.evaluate(row) }]
+      end
+
+      def merge_rows(left_row, right_row)
+        result = {}
+        
+        # Add left row with prefix
+        if left_row
+          left_row.each do |key, value|
+            result["_left_#{key}"] = value
+            result[key] = value unless result.key?(key)
+          end
+        end
+        
+        # Add right row with prefix
+        if right_row
+          right_row.each do |key, value|
+            result["_right_#{key}"] = value
+            result[key] = value unless result.key?(key)
+          end
+        end
+        
+        # Store original rows for reference
+        result["_left_row"] = left_row
+        result["_right_row"] = right_row
+        
+        result
+      end
+
+      def project_row(row, projections)
+        result = {}
+        projections.each do |proj|
+          if proj.is_a?(String) || proj.is_a?(Symbol)
+            result[proj.to_s] = row[proj.to_s]
+          elsif proj.respond_to?(:evaluate)
+            result[proj.alias || proj.to_s] = proj.evaluate(row)
+          end
+        end
+        result
+      end
+
+      def stats
+        @stats
+      end
+    end
+  end
+end

data/lib/rubydb/execution/limit_executor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # LimitExecutor - Executes LIMIT and OFFSET operations
+    class LimitExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          limits: 0,
+          rows_returned: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:limits] += 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
+
+          limit = plan.limit
+          offset = plan.offset || 0
+
+          # Apply limit and offset
+          result_rows = if limit
+            rows[offset, limit] || []
+          elsif offset > 0
+            rows[offset..-1] || []
+          else
+            rows
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_returned] += result_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: result_rows,
+            row_count: result_rows.size,
+            limit: limit,
+            offset: offset,
+            total_rows: rows.size,
+            message: "LIMIT #{limit} OFFSET #{offset} produced #{result_rows.size} rows"
+          }
+        end
+      end
+
+      def execute_with_count(plan, transaction_id = nil)
+        result = execute(plan, transaction_id)
+        
+        # Also get total count without limit
+        if plan.input_plan
+          count_plan = plan.input_plan.dup
+          count_plan.set_limit(nil)
+          count_plan.set_offset(nil)
+          
+          executor = Executor.new(@engine)
+          count_result = executor.execute(count_plan, transaction_id)
+          result[:total_available] = count_result[:row_count]
+        else
+          result[:total_available] = result[:total_rows]
+        end
+        
+        result
+      end
+
+      private
+
+      def stats
+        @stats
+      end
+    end
+  end
+end

data/lib/rubydb/execution/optimizer.rb

@@ -0,0 +1,215 @@
+# 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