rubydb 0.1.0

data/lib/rubydb/execution/predicate.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # Predicate - Represents conditions in WHERE clause
+    class Predicate
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def evaluate(row)
+        raise NotImplementedError
+      end
+
+      def to_s
+        raise NotImplementedError
+      end
+
+      def negate
+        Predicate::Not.new(self)
+      end
+
+      # Comparison predicate: column = value
+      class Comparison < Predicate
+        attr_reader :left, :right, :operator
+
+        def initialize(left, right, operator)
+          super(:comparison)
+          @left = left
+          @right = right
+          @operator = operator
+        end
+
+        def evaluate(row)
+          left_val = @left.evaluate(row)
+          right_val = @right.evaluate(row)
+
+          return false if left_val.nil? || right_val.nil?
+
+          case @operator
+          when :eq then left_val == right_val
+          when :ne then left_val != right_val
+          when :lt then left_val < right_val
+          when :lte then left_val <= right_val
+          when :gt then left_val > right_val
+          when :gte then left_val >= right_val
+          when :like then like_match?(left_val.to_s, right_val.to_s)
+          else false
+          end
+        end
+
+        def to_s
+          op = case @operator
+          when :eq then "="
+          when :ne then "!="
+          when :lt then "<"
+          when :lte then "<="
+          when :gt then ">"
+          when :gte then ">="
+          when :like then "LIKE"
+          else @operator.to_s
+          end
+          "#{@left} #{op} #{@right}"
+        end
+
+        private
+
+        def like_match?(value, pattern)
+          regex_str = Regexp.escape(pattern)
+            .gsub('%', '.*')
+            .gsub('_', '.')
+          Regexp.new("^#{regex_str}$", Regexp::IGNORECASE).match?(value)
+        end
+      end
+
+      # AND predicate
+      class And < Predicate
+        attr_reader :left, :right
+
+        def initialize(left, right)
+          super(:and)
+          @left = left
+          @right = right
+        end
+
+        def evaluate(row)
+          @left.evaluate(row) && @right.evaluate(row)
+        end
+
+        def to_s
+          "(#{@left}) AND (#{@right})"
+        end
+      end
+
+      # OR predicate
+      class Or < Predicate
+        attr_reader :left, :right
+
+        def initialize(left, right)
+          super(:or)
+          @left = left
+          @right = right
+        end
+
+        def evaluate(row)
+          @left.evaluate(row) || @right.evaluate(row)
+        end
+
+        def to_s
+          "(#{@left}) OR (#{@right})"
+        end
+      end
+
+      # NOT predicate
+      class Not < Predicate
+        attr_reader :operand
+
+        def initialize(operand)
+          super(:not)
+          @operand = operand
+        end
+
+        def evaluate(row)
+          !@operand.evaluate(row)
+        end
+
+        def to_s
+          "NOT (#{@operand})"
+        end
+      end
+
+      # BETWEEN predicate
+      class Between < Predicate
+        attr_reader :expression, :low, :high
+
+        def initialize(expression, low, high)
+          super(:between)
+          @expression = expression
+          @low = low
+          @high = high
+        end
+
+        def evaluate(row)
+          val = @expression.evaluate(row)
+          low_val = @low.evaluate(row)
+          high_val = @high.evaluate(row)
+
+          return false if val.nil? || low_val.nil? || high_val.nil?
+
+          val >= low_val && val <= high_val
+        end
+
+        def to_s
+          "#{@expression} BETWEEN #{@low} AND #{@high}"
+        end
+      end
+
+      # IN predicate
+      class In < Predicate
+        attr_reader :expression, :values
+
+        def initialize(expression, values)
+          super(:in)
+          @expression = expression
+          @values = values
+        end
+
+        def evaluate(row)
+          val = @expression.evaluate(row)
+          return false if val.nil?
+
+          @values.any? { |v| v.evaluate(row) == val }
+        end
+
+        def to_s
+          values = @values.map(&:to_s).join(", ")
+          "#{@expression} IN (#{values})"
+        end
+      end
+
+      # IS NULL predicate
+      class IsNull < Predicate
+        attr_reader :expression, :negated
+
+        def initialize(expression, negated = false)
+          super(:is_null)
+          @expression = expression
+          @negated = negated
+        end
+
+        def evaluate(row)
+          val = @expression.evaluate(row)
+          @negated ? !val.nil? : val.nil?
+        end
+
+        def to_s
+          @negated ? "#{@expression} IS NOT NULL" : "#{@expression} IS NULL"
+        end
+      end
+
+      # LIKE predicate
+      class Like < Predicate
+        attr_reader :expression, :pattern, :case_sensitive
+
+        def initialize(expression, pattern, case_sensitive = true)
+          super(:like)
+          @expression = expression
+          @pattern = pattern
+          @case_sensitive = case_sensitive
+        end
+
+        def evaluate(row)
+          val = @expression.evaluate(row)
+          pat = @pattern.evaluate(row)
+
+          return false if val.nil? || pat.nil?
+
+          str = @case_sensitive ? val.to_s : val.to_s.downcase
+          pat_str = @case_sensitive ? pat.to_s : pat.to_s.downcase
+
+          regex_str = Regexp.escape(pat_str)
+            .gsub('%', '.*')
+            .gsub('_', '.')
+          Regexp.new("^#{regex_str}$").match?(str)
+        end
+
+        def to_s
+          @case_sensitive ? "#{@expression} LIKE #{@pattern}" : "#{@expression} ILIKE #{@pattern}"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/execution/scan.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # Scan - Base class for table scans
+    class Scan
+      attr_reader :plan, :stats
+
+      def initialize(plan)
+        @plan = plan
+        @stats = {
+          rows_scanned: 0,
+          rows_returned: 0,
+          pages_accessed: 0,
+          scan_time_ms: 0
+        }
+        @position = 0
+        @results = nil
+        @executed = false
+      end
+
+      def execute
+        raise NotImplementedError
+      end
+
+      def next
+        return nil if @results.nil? || @position >= @results.size
+
+        result = @results[@position]
+        @position += 1
+        result
+      end
+
+      def reset
+        @position = 0
+        @results = nil
+        @executed = false
+      end
+
+      def count
+        @results ? @results.size : 0
+      end
+
+      def scan_stats
+        @stats
+      end
+    end
+  end
+end

data/lib/rubydb/execution/sequential_scan.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # SequentialScan - Scans a table sequentially
+    class SequentialScan < Scan
+      attr_reader :engine
+
+      def initialize(engine, plan)
+        super(plan)
+        @engine = engine
+        @filtered_rows = nil
+      end
+
+      def execute
+        start_time = Time.now
+
+        table_name = @plan.table_name
+        columns = @engine.table_columns(table_name)
+
+        # Get all rows
+        rows = @engine.select_rows(table_name, columns)
+        @stats[:rows_scanned] = rows.size
+        @stats[:pages_accessed] = (rows.size / 100.0).ceil + 1
+
+        # Apply predicate if present
+        if @plan.predicate
+          rows = rows.select do |row|
+            @plan.predicate.evaluate(row)
+          end
+        end
+
+        # Apply projections
+        if @plan.projections
+          rows = rows.map do |row|
+            project_row(row)
+          end
+        end
+
+        @results = rows
+        @stats[:rows_returned] = rows.size
+        @stats[:scan_time_ms] = ((Time.now - start_time) * 1000).round(2)
+        @executed = true
+
+        @results
+      end
+
+      private
+
+      def project_row(row)
+        result = {}
+        @plan.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
+    end
+  end
+end

data/lib/rubydb/execution/sort_executor.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # SortExecutor - Executes sorting operations
+    class SortExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          sorts: 0,
+          rows_sorted: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:sorts] += 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
+
+          order_by = plan.order_by || []
+
+          # Perform sorting
+          sorted_rows = sort_rows(rows, order_by)
+
+          # Apply limit if specified
+          if plan.limit
+            sorted_rows = sorted_rows.first(plan.limit)
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_sorted] += sorted_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: sorted_rows,
+            row_count: sorted_rows.size,
+            order_by: order_by,
+            message: "SORT produced #{sorted_rows.size} rows"
+          }
+        end
+      end
+
+      def execute_external_sort(plan, temp_dir = nil, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:sorts] += 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
+
+          order_by = plan.order_by || []
+
+          # External sort for large datasets
+          sorted_rows = external_sort(rows, order_by, temp_dir)
+
+          # Apply limit if specified
+          if plan.limit
+            sorted_rows = sorted_rows.first(plan.limit)
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_sorted] += sorted_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: sorted_rows,
+            row_count: sorted_rows.size,
+            order_by: order_by,
+            message: "EXTERNAL SORT produced #{sorted_rows.size} rows"
+          }
+        end
+      end
+
+      private
+
+      def sort_rows(rows, order_by)
+        return rows if order_by.empty?
+
+        rows.sort do |a, b|
+          comparison = 0
+          order_by.each do |order|
+            col = order.column.to_s
+            val_a = a[col]
+            val_b = b[col]
+
+            comparison = compare_values(val_a, val_b)
+            comparison = -comparison if order.direction == :desc
+            break unless comparison == 0
+          end
+          comparison
+        end
+      end
+
+      def compare_values(a, b)
+        return 0 if a.nil? && b.nil?
+        return -1 if a.nil?
+        return 1 if b.nil?
+
+        if a.is_a?(String) && b.is_a?(String)
+          a <=> b
+        else
+          a <=> b
+        end
+      end
+
+      def external_sort(rows, order_by, temp_dir)
+        # For large datasets, sort in chunks
+        chunk_size = 10000
+        chunks = []
+        
+        rows.each_slice(chunk_size) do |chunk|
+          chunks << sort_rows(chunk, order_by)
+        end
+
+        # Merge sorted chunks
+        merge_sorted_chunks(chunks, order_by)
+      end
+
+      def merge_sorted_chunks(chunks, order_by)
+        return [] if chunks.empty?
+        return chunks.first if chunks.size == 1
+
+        result = []
+        indices = Array.new(chunks.size, 0)
+
+        loop do
+          min_index = nil
+          min_value = nil
+          min_row = nil
+
+          chunks.each_with_index do |chunk, idx|
+            pos = indices[idx]
+            next if pos >= chunk.size
+
+            row = chunk[pos]
+            if min_value.nil? || compare_rows(row, min_row, order_by) < 0
+              min_index = idx
+              min_value = row
+              min_row = row
+            end
+          end
+
+          break if min_index.nil?
+
+          result << min_row
+          indices[min_index] += 1
+        end
+
+        result
+      end
+
+      def compare_rows(a, b, order_by)
+        order_by.each do |order|
+          col = order.column.to_s
+          val_a = a[col]
+          val_b = b[col]
+          comparison = compare_values(val_a, val_b)
+          return comparison unless comparison == 0
+        end
+        0
+      end
+
+      def stats
+        @stats
+      end
+    end
+  end
+end

data/lib/rubydb/execution/update_executor.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # UpdateExecutor - Executes UPDATE operations
+    class UpdateExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          updates: 0,
+          rows_updated: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:updates] += 1
+
+          table_name = plan.table_name
+          assignments = plan.assignments
+          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 update
+          rows = find_rows(table_name, predicate)
+
+          updated_count = 0
+          updated_rows = []
+
+          rows.each do |row|
+            # Get row ID
+            row_id = row[:_row_id] || row["_row_id"] || row[:id] || row["id"]
+            
+            # Apply updates
+            row_data = row.dup
+            assignments.each do |assignment|
+              column = assignment.column.to_s
+              value = evaluate_expression(assignment.value, row)
+              row_data[column] = value
+            end
+
+            # Validate constraints
+            validate_constraints(table_name, row_data)
+
+            # Update in engine
+            @engine.update_row(table_name, row_id, row_data, transaction_id: transaction_id)
+
+            updated_count += 1
+            updated_rows << { row_id: row_id, old: row, new: row_data }
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_updated] += updated_count
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: updated_rows,
+            row_count: updated_count,
+            row_ids: updated_rows.map { |r| r[:row_id] },
+            message: "UPDATE #{updated_count}"
+          }
+        end
+      end
+
+      def execute_batch(plan, updates, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:updates] += 1
+
+          table_name = plan.table_name
+          table_columns = @engine.table_columns(table_name)
+
+          updated_count = 0
+          updated_rows = []
+
+          updates.each do |update|
+            row_id = update[:row_id]
+            row_data = update[:values]
+
+            # Validate constraints
+            validate_constraints(table_name, row_data)
+
+            # Update in engine
+            old_row = @engine.select_row(table_name, row_id, table_columns)
+            @engine.update_row(table_name, row_id, row_data, transaction_id: transaction_id)
+
+            updated_count += 1
+            updated_rows << { row_id: row_id, old: old_row, new: row_data }
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_updated] += updated_count
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: updated_rows,
+            row_count: updated_count,
+            row_ids: updated_rows.map { |r| r[:row_id] },
+            message: "UPDATE #{updated_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 evaluate_expression(expr, row)
+        case expr
+        when Expression
+          expr.evaluate(row)
+        when Hash
+          expr.transform_values { |v| evaluate_expression(v, row) }
+        when Array
+          expr.map { |v| evaluate_expression(v, row) }
+        else
+          expr
+        end
+      end
+
+      def validate_constraints(table_name, row_data)
+        table_columns = @engine.table_columns(table_name)
+        table_columns.each do |col|
+          # Check NOT NULL
+          if !col.nullable? && row_data[col.name].nil?
+            raise ConstraintError, "Column '#{col.name}' cannot be NULL"
+          end
+
+          # Check UNIQUE
+          if col.unique?
+            conditions = { col.name => row_data[col.name] }
+            existing = @engine.select_rows(table_name, table_columns, conditions)
+            if existing.any? && existing.first[:_row_id] != row_data[:_row_id]
+              raise ConstraintError, "Duplicate value for unique column '#{col.name}'"
+            end
+          end
+        end
+      end
+
+      def stats
+        @stats
+      end
+    end
+  end
+end