rubydb 0.1.0

data/lib/rubydb/history/as_of.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module History
+    # AsOf - Handles AS OF queries (time travel)
+    class AsOf
+      attr_reader :stats
+
+      def initialize(engine, history_manager, config = {})
+        @engine = engine
+        @history_manager = history_manager
+        @config = config
+        @stats = {
+          as_of_queries: 0,
+          as_of_restores: 0,
+          snapshot_queries: 0,
+          query_time_ms: 0,
+          avg_query_time_ms: 0
+        }
+        @lock = Mutex.new
+        @snapshot_cache = {}
+        @cache_size = config[:cache_size] || 100
+      end
+
+      def as_of(table_name, time, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:as_of_queries] += 1
+
+          # Parse time
+          query_time = parse_time(time)
+
+          # Get changes up to time
+          changes = @history_manager.get_changes_for_table(table_name, query_time)
+
+          # Reconstruct state
+          result = reconstruct_state(table_name, changes, query_time, options)
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:as_of_queries]
+
+          result
+        end
+      end
+
+      def as_of_row(table_name, row_id, time)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:as_of_queries] += 1
+
+          query_time = parse_time(time)
+          changes = @history_manager.get_changes_for_row(table_name, row_id)
+
+          # Find version at time
+          version = find_version_at_time(changes, row_id, query_time)
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:as_of_queries]
+
+          {
+            row_id: row_id,
+            table: table_name,
+            as_of: query_time.iso8601,
+            data: version,
+            exists: !version.nil?
+          }
+        end
+      end
+
+      def as_of_snapshot(time, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:snapshot_queries] += 1
+
+          query_time = parse_time(time)
+
+          # Check cache
+          cache_key = "snapshot_#{query_time.to_i}"
+          if @snapshot_cache.key?(cache_key)
+            return @snapshot_cache[cache_key]
+          end
+
+          # Get all changes up to time
+          tables = options[:tables] || @engine.list_tables
+          snapshot = {}
+
+          tables.each do |table|
+            changes = @history_manager.get_changes_for_table(table, query_time)
+            snapshot[table] = reconstruct_state(table, changes, query_time)
+          end
+
+          result = {
+            as_of: query_time.iso8601,
+            snapshot: snapshot,
+            tables: tables.size
+          }
+
+          # Cache snapshot
+          if @snapshot_cache.size < @cache_size
+            @snapshot_cache[cache_key] = result
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:snapshot_queries]
+
+          result
+        end
+      end
+
+      def restore_to_time(time, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:as_of_restores] += 1
+
+          query_time = parse_time(time)
+
+          # Get all changes up to time
+          changes = @history_manager.get_changes_until(query_time)
+
+          # Apply changes in reverse to reach desired state
+          restore_changes = changes.reverse
+          restore_changes.each do |change|
+            undo_change(change)
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:query_time_ms] += elapsed_ms
+          @stats[:avg_query_time_ms] = @stats[:query_time_ms] / @stats[:as_of_restores]
+
+          {
+            success: true,
+            restored_to: query_time.iso8601,
+            changes_applied: changes.size
+          }
+        end
+      end
+
+      def clear_cache
+        @lock.synchronize do
+          @snapshot_cache.clear
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            cache_size: @snapshot_cache.size,
+            max_cache_size: @cache_size
+          })
+        end
+      end
+
+      private
+
+      def parse_time(time)
+        case time
+        when Time
+          time
+        when String
+          Time.parse(time)
+        when Integer
+          Time.at(time)
+        when DateTime
+          time.to_time
+        else
+          raise ArgumentError, "Invalid time format: #{time}"
+        end
+      end
+
+      def reconstruct_state(table_name, changes, time, options = {})
+        rows = {}
+        columns = options[:columns]
+
+        changes.each do |change|
+          case change.operation
+          when Change::OP_INSERT
+            rows[change.row_id] = change.new_values
+          when Change::OP_UPDATE
+            if rows.key?(change.row_id)
+              rows[change.row_id] = rows[change.row_id].merge(change.new_values)
+            else
+              # Row might have been inserted before tracking started
+              rows[change.row_id] = change.new_values
+            end
+          when Change::OP_DELETE
+            rows.delete(change.row_id)
+          end
+        end
+
+        # Apply column filter
+        if columns
+          rows.each do |row_id, data|
+            rows[row_id] = data.select { |k| columns.include?(k) }
+          end
+        end
+
+        {
+          table: table_name,
+          as_of: time.iso8601,
+          rows: rows.values,
+          count: rows.size
+        }
+      end
+
+      def find_version_at_time(changes, row_id, time)
+        current = nil
+
+        changes.each do |change|
+          if change.row_id == row_id && change.timestamp <= time
+            if change.operation == Change::OP_DELETE
+              current = nil
+            elsif change.operation == Change::OP_UPDATE || change.operation == Change::OP_INSERT
+              current = (current || {}).merge(change.new_values)
+            end
+          end
+        end
+
+        current
+      end
+
+      def undo_change(change)
+        case change.operation
+        when Change::OP_INSERT
+          @engine.delete_row(change.table_name, change.row_id)
+        when Change::OP_UPDATE
+          @engine.update_row(change.table_name, change.row_id, change.old_values)
+        when Change::OP_DELETE
+          @engine.insert_row(change.table_name, change.old_values.keys, change.old_values)
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/history/change.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "time"
+require "json"
+
+module RubyDB
+  module History
+    # Change - Represents a single change in history
+    class Change
+      attr_reader :id, :timestamp, :transaction_id, :table_name
+      attr_reader :row_id, :operation, :old_values, :new_values
+      attr_reader :user, :branch, :lsn, :metadata
+
+      # Operation types
+      OP_INSERT = :insert
+      OP_UPDATE = :update
+      OP_DELETE = :delete
+      OP_CREATE_TABLE = :create_table
+      OP_DROP_TABLE = :drop_table
+      OP_ALTER_TABLE = :alter_table
+      OP_CREATE_INDEX = :create_index
+      OP_DROP_INDEX = :drop_index
+
+      def initialize(attributes = {})
+        @id = attributes[:id] || generate_change_id
+        @timestamp = attributes[:timestamp] || Time.now
+        @transaction_id = attributes[:transaction_id]
+        @table_name = attributes[:table_name]
+        @row_id = attributes[:row_id]
+        @operation = attributes[:operation]
+        @old_values = attributes[:old_values] || {}
+        @new_values = attributes[:new_values] || {}
+        @user = attributes[:user]
+        @branch = attributes[:branch]
+        @lsn = attributes[:lsn]
+        @metadata = attributes[:metadata] || {}
+      end
+
+      def insert?
+        @operation == OP_INSERT
+      end
+
+      def update?
+        @operation == OP_UPDATE
+      end
+
+      def delete?
+        @operation == OP_DELETE
+      end
+
+      def ddl?
+        [:create_table, :drop_table, :alter_table, :create_index, :drop_index].include?(@operation)
+      end
+
+      def to_hash
+        {
+          id: @id,
+          timestamp: @timestamp.iso8601,
+          transaction_id: @transaction_id,
+          table_name: @table_name,
+          row_id: @row_id,
+          operation: @operation,
+          old_values: @old_values,
+          new_values: @new_values,
+          user: @user,
+          branch: @branch,
+          lsn: @lsn,
+          metadata: @metadata
+        }
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      def self.from_json(json_data)
+        data = JSON.parse(json_data, symbolize_names: true)
+        new(
+          id: data[:id],
+          timestamp: Time.parse(data[:timestamp]),
+          transaction_id: data[:transaction_id],
+          table_name: data[:table_name],
+          row_id: data[:row_id],
+          operation: data[:operation].to_sym,
+          old_values: data[:old_values],
+          new_values: data[:new_values],
+          user: data[:user],
+          branch: data[:branch],
+          lsn: data[:lsn],
+          metadata: data[:metadata] || {}
+        )
+      end
+
+      def inspect
+        "#<Change id=#{@id} op=#{@operation} table=#{@table_name} row=#{@row_id}>"
+      end
+
+      private
+
+      def generate_change_id
+        "change_#{Time.now.to_i}_#{rand(10000)}"
+      end
+    end
+  end
+end

data/lib/rubydb/history/history.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module History
+    # History - Main history interface
+    class History
+      attr_reader :manager, :as_of, :temporal_query, :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @manager = HistoryManager.new(engine, config)
+        @as_of = AsOf.new(engine, @manager, config)
+        @temporal_query = TemporalQuery.new(engine, @manager, config)
+        @stats = {
+          operations: 0,
+          records: 0,
+          queries: 0,
+          restores: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def record(change_data)
+        @lock.synchronize do
+          change = Change.new(change_data)
+          @manager.record_change(change)
+          @stats[:records] += 1
+          change
+        end
+      end
+
+      def record_insert(table_name, row_id, values, options = {})
+        record({
+          table_name: table_name,
+          row_id: row_id,
+          operation: Change::OP_INSERT,
+          new_values: values,
+          user: options[:user],
+          branch: options[:branch],
+          transaction_id: options[:transaction_id]
+        })
+      end
+
+      def record_update(table_name, row_id, old_values, new_values, options = {})
+        record({
+          table_name: table_name,
+          row_id: row_id,
+          operation: Change::OP_UPDATE,
+          old_values: old_values,
+          new_values: new_values,
+          user: options[:user],
+          branch: options[:branch],
+          transaction_id: options[:transaction_id]
+        })
+      end
+
+      def record_delete(table_name, row_id, old_values, options = {})
+        record({
+          table_name: table_name,
+          row_id: row_id,
+          operation: Change::OP_DELETE,
+          old_values: old_values,
+          user: options[:user],
+          branch: options[:branch],
+          transaction_id: options[:transaction_id]
+        })
+      end
+
+      def query_as_of(table_name, time, columns = nil)
+        @stats[:queries] += 1
+        @as_of.as_of(table_name, time, columns: columns)
+      end
+
+      def query_between(table_name, start_time, end_time, columns = nil)
+        @stats[:queries] += 1
+        @temporal_query.query_between(table_name, start_time, end_time, columns)
+      end
+
+      def query_version(table_name, row_id, time)
+        @stats[:queries] += 1
+        @as_of.as_of_row(table_name, row_id, time)
+      end
+
+      def query_history(table_name, row_id)
+        @stats[:queries] += 1
+        @temporal_query.query_history(table_name, row_id)
+      end
+
+      def query_snapshot(time, options = {})
+        @stats[:queries] += 1
+        @as_of.as_of_snapshot(time, options)
+      end
+
+      def restore_to_time(time, options = {})
+        @stats[:restores] += 1
+        @as_of.restore_to_time(time, options)
+      end
+
+      def get_timeline(name = "main")
+        @manager.get_timeline(name)
+      end
+
+      def delete_timeline(name)
+        @manager.delete_timeline(name)
+      end
+
+      def prune(keep_count = nil)
+        @manager.prune_history(keep_count)
+      end
+
+      def clear
+        @manager.clear_history
+        @as_of.clear_cache
+        @temporal_query.clear_cache
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge(@manager.stats)
+        end
+      end
+
+      def history_size
+        @manager.history_size
+      end
+    end
+  end
+end

data/lib/rubydb/history/history_manager.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require "monitor"
+
+module RubyDB
+  module History
+    # HistoryManager - Manages all history operations
+    class HistoryManager
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @history_dir = config[:history_dir] || "history"
+        @max_history = config[:max_history] || 10000
+        @retention_days = config[:retention_days] || 30
+        @changes = []
+        @timelines = {}
+        @change_index = {}
+        @stats = {
+          changes_recorded: 0,
+          changes_queried: 0,
+          changes_deleted: 0,
+          timelines_created: 0,
+          timelines_deleted: 0,
+          history_size: 0
+        }
+        @lock = Monitor.new
+
+        FileUtils.mkdir_p(@history_dir)
+        load_history
+      end
+
+      def record_change(change)
+        @lock.synchronize do
+          @changes << change
+          @stats[:changes_recorded] += 1
+          @stats[:history_size] = @changes.size
+
+          # Update index
+          @change_index[change.id] = change
+          @change_index["#{change.table_name}:#{change.row_id}"] ||= []
+          @change_index["#{change.table_name}:#{change.row_id}"] << change
+
+          # Update timeline
+          timeline_name = change.branch || "main"
+          get_timeline(timeline_name).add_change(change)
+
+          # Prune if needed
+          prune_history if @changes.size > @max_history
+
+          save_history
+        end
+      end
+
+      def get_changes_for_table(table_name, time = nil)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+
+          changes = @changes.select do |c|
+            c.table_name == table_name && (time.nil? || c.timestamp <= time)
+          end
+
+          changes.sort_by(&:timestamp)
+        end
+      end
+
+      def get_changes_for_row(table_name, row_id)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+          @change_index["#{table_name}:#{row_id}"] || []
+        end
+      end
+
+      def get_changes_between(table_name, start_time, end_time)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+
+          @changes.select do |c|
+            c.table_name == table_name &&
+            c.timestamp >= start_time &&
+            c.timestamp <= end_time
+          end
+        end
+      end
+
+      def get_changes_until(time)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+
+          @changes.select { |c| c.timestamp <= time }
+        end
+      end
+
+      def get_changes_by_user(user)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+
+          @changes.select { |c| c.user == user }
+        end
+      end
+
+      def get_changes_by_branch(branch)
+        @lock.synchronize do
+          @stats[:changes_queried] += 1
+
+          @changes.select { |c| c.branch == branch }
+        end
+      end
+
+      def get_timeline(name)
+        @lock.synchronize do
+          @timelines[name] ||= Timeline.new(name)
+        end
+      end
+
+      def delete_timeline(name)
+        @lock.synchronize do
+          timeline = @timelines.delete(name)
+          @stats[:timelines_deleted] += 1 if timeline
+          timeline
+        end
+      end
+
+      def prune_history(keep_count = nil)
+        @lock.synchronize do
+          keep_count ||= @max_history
+
+          if @changes.size > keep_count
+            removed = @changes.shift(@changes.size - keep_count)
+            @stats[:changes_deleted] += removed.size
+
+            # Clean up index
+            removed.each do |change|
+              @change_index.delete(change.id)
+              key = "#{change.table_name}:#{change.row_id}"
+              if @change_index[key]
+                @change_index[key].delete(change)
+                @change_index.delete(key) if @change_index[key].empty?
+              end
+            end
+
+            @stats[:history_size] = @changes.size
+          end
+        end
+      end
+
+      def clear_history
+        @lock.synchronize do
+          @changes.clear
+          @change_index.clear
+          @timelines.clear
+          @stats[:history_size] = 0
+          @stats[:changes_deleted] += 1
+          save_history
+        end
+      end
+
+      def history_size
+        @changes.size
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            timelines: @timelines.size,
+            max_history: @max_history,
+            retention_days: @retention_days,
+            history_dir: @history_dir
+          })
+        end
+      end
+
+      private
+
+      def load_history
+        history_file = File.join(@history_dir, "history.json")
+        return unless File.exist?(history_file)
+
+        begin
+          data = JSON.parse(File.read(history_file), symbolize_names: true)
+
+          data[:changes].each do |change_data|
+            change = Change.from_json(change_data.to_json)
+            @changes << change
+            @change_index[change.id] = change
+            key = "#{change.table_name}:#{change.row_id}"
+            @change_index[key] ||= []
+            @change_index[key] << change
+          end
+
+          data[:timelines].each do |name, timeline_data|
+            timeline = Timeline.from_json(timeline_data.to_json)
+            @timelines[name] = timeline
+          end
+
+          @stats[:changes_recorded] = data[:stats][:changes_recorded] || 0
+          @stats[:history_size] = @changes.size
+
+        rescue => e
+          @changes = []
+          @change_index = {}
+          @timelines = {}
+        end
+      end
+
+      def save_history
+        data = {
+          changes: @changes.map(&:to_hash),
+          timelines: @timelines.transform_values(&:to_hash),
+          stats: {
+            changes_recorded: @stats[:changes_recorded],
+            changes_deleted: @stats[:changes_deleted],
+            timelines_created: @stats[:timelines_created],
+            updated_at: Time.now.iso8601
+          }
+        }
+
+        history_file = File.join(@history_dir, "history.json")
+        temp_file = "#{history_file}.tmp"
+        File.write(temp_file, JSON.generate(data))
+        File.rename(temp_file, history_file)
+      end
+    end
+  end
+end