rubydb 0.1.0

data/lib/rubydb/branching/merge.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyDB
+  module Branching
+    # Merge - Handles branch merging
+    class Merge
+      attr_reader :stats
+
+      # Merge strategies
+      STRATEGY_FAST_FORWARD = :fast_forward
+      STRATEGY_RECURSIVE = :recursive
+      STRATEGY_OCTOPUS = :octopus
+      STRATEGY_SQUASH = :squash
+
+      def initialize(engine, branch_manager, config = {})
+        @engine = engine
+        @branch_manager = branch_manager
+        @config = config
+        @strategy = config[:strategy] || STRATEGY_FAST_FORWARD
+        @merge_history = []
+        @last_merge = nil
+        @stats = {
+          merges: 0,
+          successful_merges: 0,
+          failed_merges: 0,
+          conflicts_detected: 0,
+          conflicts_resolved: 0,
+          merge_time_ms: 0,
+          avg_merge_time_ms: 0
+        }
+        @lock = Mutex.new
+        @max_history = config[:max_history] || 100
+      end
+
+      def merge(source_branch, target_branch = nil, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:merges] += 1
+
+          target_branch ||= if @branch_manager.respond_to?(:current_branch_name)
+                              @branch_manager.current_branch_name
+                            else
+                              @branch_manager.current_branch&.name
+                            end
+          unless target_branch
+            @stats[:failed_merges] += 1
+            return { success: false, error: "No target branch specified" }
+          end
+
+          source = @branch_manager.get_branch(source_branch)
+          target = @branch_manager.get_branch(target_branch)
+
+          unless source
+            @stats[:failed_merges] += 1
+            return { success: false, error: "Source branch '#{source_branch}' not found" }
+          end
+
+          unless target
+            @stats[:failed_merges] += 1
+            return { success: false, error: "Target branch '#{target_branch}' not found" }
+          end
+
+          if source == target
+            @stats[:failed_merges] += 1
+            return { success: false, error: "Cannot merge a branch with itself" }
+          end
+
+          begin
+            # Detect conflicts
+            conflicts = detect_conflicts(source, target)
+
+            if conflicts.any?
+              @stats[:conflicts_detected] += 1
+
+              if options[:abort_on_conflict]
+                @stats[:failed_merges] += 1
+                return {
+                  success: false,
+                  conflicts: conflicts,
+                  message: "Conflicts detected, merge aborted"
+                }
+              end
+
+              # Try to resolve conflicts
+              if options[:resolve_conflicts]
+                resolved = resolve_conflicts(conflicts, options)
+                conflicts = resolved[:remaining] if resolved[:remaining]
+              end
+              if conflicts.any?
+                @stats[:failed_merges] += 1
+                return { success: false, conflicts: conflicts, message: "Unresolved conflicts" }
+              end
+            end
+
+            # Perform merge based on strategy
+            result = case @strategy
+            when STRATEGY_FAST_FORWARD
+              merge_fast_forward(source, target, options)
+            when STRATEGY_RECURSIVE
+              merge_recursive(source, target, options)
+            when STRATEGY_OCTOPUS
+              merge_octopus(source, target, options)
+            when STRATEGY_SQUASH
+              merge_squash(source, target, options)
+            else
+              merge_fast_forward(source, target, options)
+            end
+
+            if result[:success]
+              previous_changes = target.logical_changes
+              merge_changes = Array(result[:changes])
+              merged_changes = previous_changes + merge_changes
+              if @engine && @branch_manager.respond_to?(:current_branch_name) &&
+                  @branch_manager.current_branch_name == target_branch &&
+                  @engine.respond_to?(:apply_branch_state)
+                begin
+                  @engine.apply_branch_state(base: target.state_snapshot, changes: merged_changes)
+                rescue => error
+                  @stats[:failed_merges] += 1
+                  return { success: false, error: "Unable to apply merged state: #{error.message}" }
+                end
+              end
+
+              # Update branch manager
+              target.merge_changes(merge_changes)
+              @branch_manager.persist! if @branch_manager.respond_to?(:persist!)
+              @last_merge = {
+                source: source_branch,
+                target: target_branch,
+                previous_changes: previous_changes,
+                merged_count: merge_changes.size
+              }
+
+              @stats[:successful_merges] += 1
+
+              elapsed_ms = (Time.now - start_time) * 1000
+              @stats[:merge_time_ms] += elapsed_ms
+              @stats[:avg_merge_time_ms] = @stats[:merge_time_ms] / @stats[:successful_merges]
+
+              # Record history
+              record_merge(source_branch, target_branch, options)
+
+              result.merge(elapsed_ms: elapsed_ms)
+            else
+              @stats[:failed_merges] += 1
+              result
+            end
+
+          rescue => e
+            @stats[:failed_merges] += 1
+            { success: false, error: e.message }
+          end
+        end
+      end
+
+      def merge_abort
+        @lock.synchronize do
+          merge = @last_merge
+          return { success: false, error: "No merge to abort" } unless merge
+
+          target = @branch_manager.get_branch(merge[:target])
+          unless target
+            return { success: false, error: "Target branch '#{merge[:target]}' not found" }
+          end
+
+          target.rollback(merge[:merged_count]) if merge[:merged_count].positive?
+          if @engine && @branch_manager.respond_to?(:current_branch_name) &&
+              @branch_manager.current_branch_name == merge[:target] &&
+              @engine.respond_to?(:apply_branch_state)
+            @engine.apply_branch_state(base: target.state_snapshot, changes: merge[:previous_changes])
+          end
+          @branch_manager.persist! if @branch_manager.respond_to?(:persist!)
+          @merge_history.pop
+          @last_merge = nil
+
+          { success: true, target: merge[:target], reverted_changes: merge[:merged_count] }
+        end
+      end
+
+      def merge_history
+        @merge_history.dup
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            strategy: @strategy,
+            history_size: @merge_history.size,
+            max_history: @max_history
+          })
+        end
+      end
+
+      private
+
+      def detect_conflicts(source, target)
+        target_changes = target.respond_to?(:logical_changes) ? target.logical_changes : target.changes
+        source_changes = source.respond_to?(:logical_changes) ? source.logical_changes : source.changes
+        target_keys = target_changes.map { |change| change_key(change) }
+        source_changes.filter_map do |change|
+          next unless target_keys.include?(change_key(change))
+          other = target_changes.find { |candidate| change_key(candidate) == change_key(change) }
+          { key: change_key(change), source: change, target: other } unless other == change
+        end
+      end
+
+      def resolve_conflicts(conflicts, options)
+        resolver = options[:conflict_resolver]
+        raise ArgumentError, "conflict_resolver is required" unless resolver.respond_to?(:call)
+        remaining = conflicts.filter_map { |conflict| resolver.call(conflict) ? nil : conflict }
+        { remaining: remaining }
+      end
+
+      def change_key(change)
+        [change[:table] || change["table"], change[:row_id] || change["row_id"], change[:column] || change["column"]]
+      end
+
+      def merge_fast_forward(source, target, options)
+        # Fast-forward merge
+        changes = source.respond_to?(:logical_changes) ? source.logical_changes : source.changes
+
+        {
+          success: true,
+          changes: changes,
+          strategy: :fast_forward,
+          message: "Fast-forward merge completed"
+        }
+      end
+
+      def merge_recursive(source, target, options)
+        # Recursive merge
+        changes = source.respond_to?(:logical_changes) ? source.logical_changes : source.changes
+
+        {
+          success: true,
+          changes: changes,
+          strategy: :recursive,
+          message: "Recursive merge completed"
+        }
+      end
+
+      def merge_octopus(source, target, options)
+        # Octopus merge (for merging multiple branches)
+        changes = source.respond_to?(:logical_changes) ? source.logical_changes : source.changes
+
+        {
+          success: true,
+          changes: changes,
+          strategy: :octopus,
+          message: "Octopus merge completed"
+        }
+      end
+
+      def merge_squash(source, target, options)
+        # Squash merge (combine all changes into one commit)
+        changes = source.respond_to?(:logical_changes) ? source.logical_changes : source.changes
+
+        {
+          success: true,
+          changes: changes,
+          strategy: :squash,
+          message: "Squash merge completed"
+        }
+      end
+
+      def record_merge(source_branch, target_branch, options)
+        entry = {
+          source: source_branch,
+          target: target_branch,
+          timestamp: Time.now.iso8601,
+          options: options,
+          strategy: @strategy
+        }
+
+        @merge_history << entry
+
+        if @merge_history.size > @max_history
+          @merge_history.shift
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/build_info.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module BuildInfo
+    VERSION = RubyDB::VERSION if defined?(RubyDB::VERSION)
+
+    def self.to_h
+      {
+        version: (defined?(RubyDB::VERSION) ? RubyDB::VERSION : "unknown"),
+        ruby: RUBY_VERSION,
+        platform: RUBY_PLATFORM
+      }
+    end
+  end
+end

data/lib/rubydb/catalog/catalog.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyDB
+  module Catalog
+    # Main catalog - manages all database metadata
+    class Catalog
+      attr_reader :databases, :current_database, :tables, :system_catalog
+
+      def initialize
+        @databases = {}
+        @current_database = nil
+        @tables = {}
+        @sequences = {}
+        @views = {}
+        @triggers = {}
+        @system_catalog = SystemCatalog.new(self)
+        @version = 1
+        @created_at = Time.now
+        @modified_at = Time.now
+      end
+
+      # --- Database Management ---
+
+      def create_database(name, if_not_exists: false)
+        if @databases.key?(name)
+          return if if_not_exists
+          raise DatabaseError, "Database '#{name}' already exists"
+        end
+
+        db = Database.new(name)
+        @databases[name] = db
+        @current_database = db if @databases.size == 1
+        @modified_at = Time.now
+        db
+      end
+
+      def drop_database(name, if_exists: false)
+        unless @databases.key?(name)
+          return if if_exists
+          raise DatabaseError, "Database '#{name}' does not exist"
+        end
+
+        @databases.delete(name)
+        @current_database = @databases.values.first if @current_database&.name == name
+        @modified_at = Time.now
+        true
+      end
+
+      def find_database(name)
+        @databases[name]
+      end
+
+      def create_schema(name, if_not_exists: false, authorization: nil)
+        raise DatabaseError, "No database selected" unless @current_database
+        schema = @current_database.create_schema(name, if_not_exists: if_not_exists, authorization: authorization)
+        @modified_at = Time.now
+        schema
+      end
+
+      def drop_schema(name, if_exists: false, cascade: false)
+        raise DatabaseError, "No database selected" unless @current_database
+        result = @current_database.drop_schema(name, if_exists: if_exists, cascade: cascade)
+        @modified_at = Time.now
+        result
+      end
+
+      def find_schema(name)
+        @current_database&.find_schema(name)
+      end
+
+      def use_database(name)
+        db = @databases[name]
+        raise DatabaseError, "Database '#{name}' does not exist" unless db
+        @current_database = db
+        @modified_at = Time.now
+        db
+      end
+
+      def current_database_name
+        @current_database&.name
+      end
+
+      # --- Table Management ---
+
+      def create_table(name, &block)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        if @current_database.table_exists?(name)
+          raise DatabaseError, "Table '#{name}' already exists in database '#{@current_database.name}'"
+        end
+
+        table = Table.new(name, @current_database)
+        @current_database.add_table(table)
+
+        # Execute block to define columns
+        if block_given?
+          builder = TableBuilder.new(table)
+          yield builder
+        end
+
+        @tables[name] = table
+        @modified_at = Time.now
+        table
+      end
+
+      def drop_table(name, if_exists: false)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        unless @current_database.table_exists?(name)
+          return if if_exists
+          raise DatabaseError, "Table '#{name}' does not exist"
+        end
+
+        table = @current_database.drop_table(name)
+        @tables.delete(name)
+        @modified_at = Time.now
+        table
+      end
+
+      def find_table(name)
+        return nil unless @current_database
+        @current_database.find_table(name)
+      end
+
+      def tables
+        return [] unless @current_database
+        @current_database.tables.values
+      end
+
+      def table_exists?(name)
+        return false unless @current_database
+        @current_database.table_exists?(name)
+      end
+
+      # --- Sequence Management ---
+
+      def create_sequence(name, options = {})
+        raise DatabaseError, "No database selected" unless @current_database
+
+        if @current_database.sequence_exists?(name)
+          raise DatabaseError, "Sequence '#{name}' already exists"
+        end
+
+        sequence = Sequence.new(name, options)
+        @current_database.add_sequence(sequence)
+        @sequences[name] = sequence
+        @modified_at = Time.now
+        sequence
+      end
+
+      def drop_sequence(name, if_exists: false)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        unless @current_database.sequence_exists?(name)
+          return if if_exists
+          raise DatabaseError, "Sequence '#{name}' does not exist"
+        end
+
+        sequence = @current_database.drop_sequence(name)
+        @sequences.delete(name)
+        @modified_at = Time.now
+        sequence
+      end
+
+      def find_sequence(name)
+        return nil unless @current_database
+        @current_database.find_sequence(name)
+      end
+
+      def next_value_for_sequence(name)
+        seq = find_sequence(name)
+        raise DatabaseError, "Sequence '#{name}' does not exist" unless seq
+        seq.next_value
+      end
+
+      # --- View Management ---
+
+      def create_view(name, query, if_not_exists: false)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        if @current_database.view_exists?(name)
+          return @current_database.find_view(name) if if_not_exists
+          raise DatabaseError, "View '#{name}' already exists"
+        end
+
+        view = View.new(name, query)
+        @current_database.add_view(view)
+        @views[name] = view
+        @modified_at = Time.now
+        view
+      end
+
+      def drop_view(name, if_exists: false)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        unless @current_database.view_exists?(name)
+          return if if_exists
+          raise DatabaseError, "View '#{name}' does not exist"
+        end
+
+        view = @current_database.drop_view(name)
+        @views.delete(name)
+        @modified_at = Time.now
+        view
+      end
+
+      def find_view(name)
+        return nil unless @current_database
+        @current_database.find_view(name)
+      end
+
+      # --- Trigger Management ---
+
+      def create_trigger(name, event, table_name, definition, **options)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        if @current_database.trigger_exists?(name)
+          raise DatabaseError, "Trigger '#{name}' already exists"
+        end
+
+        trigger = Trigger.new(name, event, table_name, definition, options)
+        @current_database.add_trigger(trigger)
+        @triggers[name] = trigger
+        @modified_at = Time.now
+        trigger
+      end
+
+      def drop_trigger(name, if_exists: false)
+        raise DatabaseError, "No database selected" unless @current_database
+
+        unless @current_database.trigger_exists?(name)
+          return if if_exists
+          raise DatabaseError, "Trigger '#{name}' does not exist"
+        end
+
+        trigger = @current_database.drop_trigger(name)
+        @triggers.delete(name)
+        @modified_at = Time.now
+        trigger
+      end
+
+      def find_trigger(name)
+        return nil unless @current_database
+        @current_database.find_trigger(name)
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        data = {
+          version: @version,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601,
+          current_database: @current_database&.name,
+          databases: @databases.transform_values(&:serialize),
+          system_catalog: @system_catalog.serialize
+        }
+        JSON.generate(data)
+      end
+
+      def self.deserialize(json_data)
+        data = JSON.parse(json_data, symbolize_names: true)
+        catalog = new
+
+        data[:databases].each do |name, db_data|
+          db = Database.deserialize(db_data)
+          catalog.databases[name.to_s] = db
+        end
+
+        if data[:current_database]
+          current = catalog.databases[data[:current_database]] || catalog.databases[data[:current_database].to_sym]
+          catalog.send(:current_database=, current)
+        end
+
+        # Rebuild indexes
+        catalog.databases.each do |_name, db|
+          db.tables.each do |table|
+            catalog.instance_variable_get(:@tables)[table.name] = table
+            table.columns.each do |col|
+              # Build indexes for columns
+              if col.primary_key?
+                index = Index.new("primary_#{table.name}", table.name, [col.name], unique: true)
+                table.add_index(index)
+              end
+              if col.unique?
+                index = Index.new("unique_#{table.name}_#{col.name}", table.name, [col.name], unique: true)
+                table.add_index(index)
+              end
+            end
+          end
+        end
+
+        catalog
+      end
+
+      protected
+
+      attr_writer :current_database
+    end
+
+    # Builder for creating tables with a DSL
+    class TableBuilder
+      attr_reader :table
+
+      def initialize(table)
+        @table = table
+      end
+
+      def column(name, type, **options)
+        @table.add_column(Column.new(name, type, **options))
+      end
+
+      def integer(name, **options)
+        column(name, :integer, **options)
+      end
+
+      def bigint(name, **options)
+        column(name, :bigint, **options)
+      end
+
+      def smallint(name, **options)
+        column(name, :smallint, **options)
+      end
+
+      def float(name, **options)
+        column(name, :float, **options)
+      end
+
+      def decimal(name, precision: 10, scale: 2, **options)
+        column(name, :decimal, precision: precision, scale: scale, **options)
+      end
+
+      def boolean(name, **options)
+        column(name, :boolean, **options)
+      end
+
+      def text(name, **options)
+        column(name, :text, **options)
+      end
+
+      def varchar(name, limit: 255, **options)
+        column(name, :varchar, limit: limit, **options)
+      end
+
+      def blob(name, **options)
+        column(name, :blob, **options)
+      end
+
+      def date(name, **options)
+        column(name, :date, **options)
+      end
+
+      def time(name, **options)
+        column(name, :time, **options)
+      end
+
+      def timestamp(name, **options)
+        column(name, :timestamp, **options)
+      end
+
+      def json(name, **options)
+        column(name, :json, **options)
+      end
+
+      def uuid(name, **options)
+        column(name, :uuid, **options)
+      end
+
+      def primary_key(name = :id, **options)
+        column(name, :integer, primary_key: true, **options)
+      end
+
+      def timestamps
+        timestamp(:created_at, default: "CURRENT_TIMESTAMP")
+        timestamp(:updated_at, default: "CURRENT_TIMESTAMP")
+      end
+
+      def index(name, **options)
+        @table.add_index(Index.new(name, @table.name, **options))
+      end
+
+      def foreign_key(column, ref_table, ref_column = :id, **options)
+        @table.add_constraint(
+          ForeignKeyConstraint.new(column, ref_table, ref_column, **options)
+        )
+      end
+    end
+  end
+end