rubydb 0.1.4 → 0.1.6

data/lib/rubydb/execution/sequential_scan.rb

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

@@ -1,185 +1,194 @@
-# 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
+# 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 = order_value(a, col)
+            val_b = order_value(b, col)
+
+            comparison = compare_values(val_a, val_b)
+            comparison = -comparison if order.direction.to_s.casecmp?("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?
+
+        comparison = a <=> b
+        return comparison unless comparison.nil?
+
+        a.to_s <=> b.to_s
+      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 = order_value(a, col)
+          val_b = order_value(b, col)
+          comparison = compare_values(val_a, val_b)
+          comparison = -comparison if order.direction.to_s.casecmp?("desc")
+          return comparison unless comparison == 0
+        end
+        0
+      end
+
+      def order_value(row, column)
+        return row[column] if row.key?(column)
+        return row[column.to_sym] if row.key?(column.to_sym)
+
+        short_column = column.split(".").last
+        return row[short_column] if row.key?(short_column)
+        return row[short_column.to_sym] if row.key?(short_column.to_sym)
+
+        nil
+      end
+
+      attr_reader :stats
+    end
+  end
+end