rubydb 0.1.0

data/lib/rubydb/execution/expression.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # Expression - Represent values, columns, and operations
+    class Expression
+      attr_reader :type, :value, :name, :left, :right, :operator,
+                  :operand, :alias, :arguments
+
+      def initialize(type, **attrs)
+        @type = type
+        @value = attrs[:value]
+        @name = attrs[:name]
+        @left = attrs[:left]
+        @right = attrs[:right]
+        @operator = attrs[:operator]
+        @operand = attrs[:operand]
+        @alias = attrs[:alias]
+        @arguments = attrs[:arguments] || []
+      end
+
+      def to_s
+        case @type
+        when :literal
+          @value.to_s
+        when :column
+          @name.to_s
+        when :binary_op
+          "#{@left} #{@operator} #{@right}"
+        when :unary_op
+          "#{@operator} #{@operand}"
+        when :function
+          "#{@name}(#{@arguments.map(&:to_s).join(', ')})"
+        when :parameter
+          "?"
+        else
+          "?"
+        end
+      end
+
+      # Literal value
+      class Literal < Expression
+        def initialize(value)
+          super(:literal, value: value)
+        end
+
+        def evaluate(_row = nil)
+          @value
+        end
+
+        def to_s
+          if @value.nil?
+            "NULL"
+          elsif @value.is_a?(String)
+            "'#{@value}'"
+          else
+            @value.to_s
+          end
+        end
+      end
+
+      # Column reference
+      class Column < Expression
+        attr_reader :table
+
+        def initialize(name, table = nil)
+          super(:column, name: name)
+          @table = table
+        end
+
+        def evaluate(row)
+          return nil unless row
+          return row[@name] if row.key?(@name)
+          return row[@name.to_sym] if row.respond_to?(:key?) && row.key?(@name.to_sym)
+
+          nil
+        end
+
+        def to_s
+          @table ? "#{@table}.#{@name}" : @name.to_s
+        end
+      end
+
+      # Binary operation
+      class BinaryOp < Expression
+        def initialize(left, right, operator)
+          super(:binary_op, left: left, right: right, operator: operator)
+        end
+
+        def evaluate(row)
+          left_val = @left.evaluate(row)
+          right_val = @right.evaluate(row)
+
+          return nil if left_val.nil? || right_val.nil?
+
+          case @operator
+          when :plus then left_val + right_val
+          when :minus then left_val - right_val
+          when :multiply then left_val * right_val
+          when :divide then right_val != 0 ? left_val / right_val : nil
+          when :modulo then right_val != 0 ? left_val % right_val : nil
+          when :concat then left_val.to_s + right_val.to_s
+          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
+          else nil
+          end
+        end
+
+        def to_s
+          "#{@left} #{@operator} #{@right}"
+        end
+      end
+
+      # Unary operation
+      class UnaryOp < Expression
+        def initialize(operand, operator)
+          super(:unary_op, operand: operand, operator: operator)
+        end
+
+        def evaluate(row)
+          val = @operand.evaluate(row)
+          return nil if val.nil?
+
+          case @operator
+          when :negate then -val
+          when :not then !val
+          else val
+          end
+        end
+
+        def to_s
+          "#{@operator} #{@operand}"
+        end
+      end
+
+      # Function call
+      class Function < Expression
+        def initialize(name, arguments = [], alias_name = nil)
+          super(:function, name: name, arguments: arguments, alias: alias_name)
+        end
+
+        def evaluate(row)
+          args = @arguments.map { |arg| arg.evaluate(row) }
+
+          case @name.to_s.upcase
+          when "COUNT" then args.compact.size
+          when "SUM" then args.compact.sum
+          when "AVG"
+            vals = args.compact
+            vals.empty? ? 0 : vals.sum / vals.size.to_f
+          when "MIN" then args.compact.min
+          when "MAX" then args.compact.max
+          when "LOWER" then args.first.to_s.downcase
+          when "UPPER" then args.first.to_s.upcase
+          when "LENGTH" then args.first.to_s.length
+          when "COALESCE" then args.find { |arg| !arg.nil? }
+          when "NOW" then Time.now
+          when "CURRENT_DATE" then Date.today
+          when "CURRENT_TIME" then Time.now
+          else nil
+          end
+        end
+
+        def to_s
+          args = @arguments.map(&:to_s).join(", ")
+          "#{@name}(#{args})"
+        end
+      end
+
+      # Parameter placeholder
+      class Parameter < Expression
+        attr_reader :index
+
+        def initialize(index = nil)
+          super(:parameter, value: index)
+          @index = index
+        end
+
+        def evaluate(_row = nil)
+          @value
+        end
+
+        def to_s
+          @index ? "$#{@index}" : "?"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/execution/index_scan.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # IndexScan - Scans a table using an index
+    class IndexScan < Scan
+      attr_reader :engine, :index
+
+      def initialize(engine, plan)
+        super(plan)
+        @engine = engine
+        @index = plan.index
+        @index_scan = nil
+      end
+
+      def execute
+        start_time = Time.now
+
+        table_name = @plan.table_name
+        columns = @engine.table_columns(table_name)
+
+        # Create index scan
+        @index_scan = Indexes::IndexScan.new(
+          @index,
+          determine_scan_type,
+          build_scan_conditions
+        )
+
+        # Execute index scan
+        index_results = @index_scan.execute
+        @stats[:rows_scanned] = index_results.size
+        @stats[:pages_accessed] = @index_scan.stats[:index_pages_accessed] || 1
+
+        # Fetch rows by row_id
+        rows = []
+        index_results.each do |result|
+          row_id = result[:row_id]
+          row = @engine.select_row(table_name, row_id, columns)
+          rows << row if row
+        end
+
+        # Apply predicate if present (additional filtering)
+        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 determine_scan_type
+        return :full unless @plan.predicate
+
+        # Try to determine scan type from predicate
+        case @plan.predicate
+        when Predicate::Comparison
+          case @plan.predicate.operator
+          when :eq then :equal
+          when :lt, :lte, :gt, :gte then :range
+          else :full
+          end
+        when Predicate::Like
+          :prefix
+        when Predicate::Between
+          :range
+        when Predicate::In
+          :multi_key
+        else
+          :full
+        end
+      end
+
+      def build_scan_conditions
+        return {} unless @plan.predicate
+
+        case @plan.predicate
+        when Predicate::Comparison
+          build_comparison_conditions(@plan.predicate)
+        when Predicate::Between
+          {
+            start_key: @plan.predicate.low,
+            end_key: @plan.predicate.high
+          }
+        when Predicate::In
+          {
+            keys: @plan.predicate.values
+          }
+        when Predicate::Like
+          {
+            prefix: @plan.predicate.pattern.value
+          }
+        else
+          {}
+        end
+      end
+
+      def build_comparison_conditions(predicate)
+        case predicate.operator
+        when :eq
+          { key: predicate.right.value }
+        when :lt
+          { end_key: predicate.right.value, inclusive_end: false }
+        when :lte
+          { end_key: predicate.right.value, inclusive_end: true }
+        when :gt
+          { start_key: predicate.right.value, inclusive_start: false }
+        when :gte
+          { start_key: predicate.right.value, inclusive_start: true }
+        else
+          {}
+        end
+      end
+
+      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/insert_executor.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Execution
+    # InsertExecutor - Executes INSERT operations
+    class InsertExecutor
+      attr_reader :engine, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @stats = {
+          inserts: 0,
+          rows_inserted: 0,
+          conflicts: 0,
+          total_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def execute(plan, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:inserts] += 1
+
+          table_name = plan.table_name
+          columns = plan.columns
+          values = plan.values
+
+          # Get table columns
+          table_columns = @engine.table_columns(table_name)
+          raise ExecutionError, "Table '#{table_name}' does not exist" if table_columns.empty?
+
+          # Handle different value formats
+          rows_to_insert = prepare_rows(columns, values, table_columns)
+
+          # Check constraints
+          validate_constraints(table_name, rows_to_insert)
+
+          # Check for conflicts (if ON CONFLICT specified)
+          conflict_action = plan.options[:on_conflict] || :error
+          conflict_handled = false
+
+          if conflict_action != :error && plan.conflict_columns
+            rows_to_insert = handle_conflicts(table_name, rows_to_insert, conflict_action, plan.conflict_columns)
+            conflict_handled = true
+          end
+
+          # Insert rows
+          inserted_rows = []
+          rows_to_insert.each do |row_data|
+            row_id = @engine.insert_row(table_name, table_columns, row_data)
+            
+            # Update indexes
+            if @engine.respond_to?(:index_manager)
+              row = row_data.merge("_row_id" => row_id)
+              @engine.index_manager.insert_row(table_name, row)
+            end
+
+            inserted_rows << { row_id: row_id, row: row_data }
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_inserted] += inserted_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: inserted_rows,
+            row_count: inserted_rows.size,
+            row_ids: inserted_rows.map { |r| r[:row_id] },
+            message: "INSERT #{inserted_rows.size}",
+            conflict_handled: conflict_handled
+          }
+        end
+      end
+
+      def execute_batch(plan, rows, transaction_id = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:inserts] += 1
+
+          table_name = plan.table_name
+          table_columns = @engine.table_columns(table_name)
+          raise ExecutionError, "Table '#{table_name}' does not exist" if table_columns.empty?
+
+          prepared_rows = rows.map do |row|
+            prepare_single_row(plan.columns, row, table_columns)
+          end
+
+          # Bulk insert
+          inserted_rows = []
+          prepared_rows.each do |row_data|
+            row_id = @engine.insert_row(table_name, table_columns, row_data)
+            
+            if @engine.respond_to?(:index_manager)
+              row = row_data.merge("_row_id" => row_id)
+              @engine.index_manager.insert_row(table_name, row)
+            end
+
+            inserted_rows << { row_id: row_id, row: row_data }
+          end
+
+          elapsed_ms = ((Time.now - start_time) * 1000).round(2)
+          @stats[:rows_inserted] += inserted_rows.size
+          @stats[:total_time_ms] += elapsed_ms
+
+          {
+            rows: inserted_rows,
+            row_count: inserted_rows.size,
+            row_ids: inserted_rows.map { |r| r[:row_id] },
+            message: "INSERT #{inserted_rows.size}"
+          }
+        end
+      end
+
+      private
+
+      def prepare_rows(columns, values, table_columns)
+        return [] if values.empty?
+
+        # If values is a single array, treat as one row
+        if values.first.is_a?(Array) || values.first.is_a?(Hash)
+          values.map { |v| prepare_single_row(columns, v, table_columns) }
+        else
+          [prepare_single_row(columns, values, table_columns)]
+        end
+      end
+
+      def prepare_single_row(columns, values, table_columns)
+        row_data = {}
+
+        if values.is_a?(Hash)
+          # Values provided as hash
+          values.each do |key, val|
+            row_data[key.to_s] = val
+          end
+        elsif values.is_a?(Array)
+          # Values provided as array - match by position
+          columns.each_with_index do |col, idx|
+            row_data[col.to_s] = values[idx] if idx < values.size
+          end
+        else
+          # Single value - use first column
+          row_data[columns.first.to_s] = values if columns.any?
+        end
+
+        # Add default values for missing columns
+        table_columns.each do |col|
+          unless row_data.key?(col.name)
+            row_data[col.name] = col.default if col.has_default?
+          end
+        end
+
+        row_data
+      end
+
+      def validate_constraints(table_name, rows)
+        # Check NOT NULL constraints
+        table_columns = @engine.table_columns(table_name)
+        rows.each do |row|
+          table_columns.each do |col|
+            if !col.nullable? && row[col.name].nil?
+              raise ConstraintError, "Column '#{col.name}' cannot be NULL"
+            end
+          end
+        end
+      end
+
+      def handle_conflicts(table_name, rows, conflict_action, conflict_columns)
+        handled_rows = []
+        conflict_columns = conflict_columns.map(&:to_s)
+
+        rows.each do |row|
+          # Check if row conflicts with existing data
+          conflict = find_conflict(table_name, row, conflict_columns)
+
+          if conflict
+            @stats[:conflicts] += 1
+            if conflict_action == :ignore
+              next
+            elsif conflict_action == :update
+              # Update existing row with new values
+              update_conflict_row(table_name, conflict, row)
+              next
+            end
+          end
+
+          handled_rows << row
+        end
+
+        handled_rows
+      end
+
+      def find_conflict(table_name, row, conflict_columns)
+        # Check if any row exists with the same conflicting columns
+        conditions = {}
+        conflict_columns.each do |col|
+          conditions[col] = row[col] if row.key?(col)
+        end
+
+        return nil if conditions.empty?
+
+        table_columns = @engine.table_columns(table_name)
+        rows = @engine.select_rows(table_name, table_columns, conditions)
+        rows.first
+      end
+
+      def update_conflict_row(table_name, existing_row, new_row)
+        row_id = existing_row[:_row_id] || existing_row["_row_id"]
+        @engine.update_row(table_name, row_id, new_row)
+      end
+
+      def stats
+        @stats
+      end
+    end
+  end
+end