rubydb 0.1.0

data/lib/rubydb/errors/constraint_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when a constraint is violated
+  class ConstraintError < Error
+    attr_reader :constraint_name, :table_name, :column_name
+
+    def initialize(message = "Constraint violation", constraint_name: nil, table_name: nil, column_name: nil, details: nil)
+      super(message, code: ErrorCodes::CONSTRAINT_VIOLATION, details: details)
+      @constraint_name = constraint_name
+      @table_name = table_name
+      @column_name = column_name
+    end
+
+    def to_s
+      msg = super
+      msg = "#{msg} on table #{@table_name}" if @table_name
+      msg = "#{msg} column #{@column_name}" if @column_name
+      msg = "#{msg} constraint #{@constraint_name}" if @constraint_name
+      msg
+    end
+  end
+end

data/lib/rubydb/errors/corruption_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when database corruption is detected
+  class CorruptionError < Error
+    def initialize(message = "Database corruption detected", details: nil)
+      super(message, code: ErrorCodes::CORRUPTION, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/database_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is a general database error
+  class DatabaseError < Error
+    def initialize(message = "Database error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Base error class for all RubyDB errors
+  class Error < StandardError
+    attr_reader :code, :details
+
+    def initialize(message = nil, code: nil, details: nil)
+      super(message)
+      @code = code || ErrorCodes::ERROR
+      @details = details || {}
+    end
+
+    def to_s
+      msg = super
+      msg = "#{msg} (code: #{@code})" if @code
+      msg
+    end
+  end
+end

data/lib/rubydb/errors/execution_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when query execution fails
+  class ExecutionError < Error
+    def initialize(message = "Execution error", code: ErrorCodes::ERROR, details: nil)
+      super(message, code: code, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/parser_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when SQL parsing fails
+  class ParserError < Error
+    def initialize(message = "SQL parsing error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/recovery_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when recovery from crash fails
+  class RecoveryError < Error
+    def initialize(message = "Recovery failed", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/replication_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is an error with replication
+  class ReplicationError < Error
+    def initialize(message = "Replication error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/server_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RubyDB
+  class ServerError < Error
+  end
+end

data/lib/rubydb/errors/storage_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is an error with storage operations
+  class StorageError < Error
+    def initialize(message = "Storage error", details: nil)
+      super(message, code: ErrorCodes::IO_ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/transaction_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is an error with transactions
+  class TransactionError < Error
+    def initialize(message = "Transaction error", details: nil)
+      super(message, code: ErrorCodes::TRANSACTION_ABORTED, details: details)
+    end
+  end
+end

data/lib/rubydb/execution/aggregate_executor.rb

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

data/lib/rubydb/execution/delete_executor.rb

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

data/lib/rubydb/execution/distinct_executor.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyDB
+  module Execution
+    # DistinctExecutor - Executes DISTINCT operations
+    class DistinctExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          distincts: 0,
+          rows_input: 0,
+          rows_output: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:distincts] += 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
+
+          distinct_columns = plan.distinct_columns || []
+          
+          @stats[:rows_input] += rows.size
+
+          # Perform distinct
+          result_rows = if distinct_columns.empty?
+            # Distinct on all columns
+            distinct_all(rows)
+          else
+            # Distinct on specific columns
+            distinct_on_columns(rows, distinct_columns)
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_output] += result_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: result_rows,
+            row_count: result_rows.size,
+            distinct_columns: distinct_columns,
+            total_input: rows.size,
+            message: "DISTINCT produced #{result_rows.size} rows"
+          }
+        end
+      end
+
+      def distinct_all(rows)
+        seen = Set.new
+        result = []
+
+        rows.each do |row|
+          # Create key from row values
+          key = row.values_at(*row.keys).join("||")
+          unless seen.include?(key)
+            seen.add(key)
+            result << row
+          end
+        end
+
+        result
+      end
+
+      def distinct_on_columns(rows, columns)
+        seen = Set.new
+        result = []
+
+        columns = columns.map(&:to_s)
+
+        rows.each do |row|
+          # Create key from specified columns
+          key = columns.map { |col| row[col] }.join("||")
+          unless seen.include?(key)
+            seen.add(key)
+            result << row
+          end
+        end
+
+        result
+      end
+
+      # Optimized distinct using hash aggregation
+      def distinct_using_hash(rows, columns = [])
+        hash = {}
+        columns = columns.map(&:to_s)
+
+        rows.each do |row|
+          key = if columns.empty?
+            row.values_at(*row.keys).join("||")
+          else
+            columns.map { |col| row[col] }.join("||")
+          end
+          
+          hash[key] = row unless hash.key?(key)
+        end
+
+        hash.values
+      end
+
+      # Distinct with ordering
+      def distinct_with_order(rows, columns, order_by)
+        distinct_rows = distinct_on_columns(rows, columns)
+        
+        # Sort results
+        sort_executor = SortExecutor.new(@engine)
+        sort_plan = Plan::Select.new(nil)
+        sort_plan.input_rows = distinct_rows
+        sort_plan.set_order_by(order_by)
+        
+        result = sort_executor.execute(sort_plan)
+        result[:rows]
+      end
+
+      private
+
+      def stats
+        @stats
+      end
+    end
+  end
+end