rubydb 0.1.4 → 0.1.6

data/lib/rubydb/history/as_of.rb

@@ -1,238 +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
+# 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
+            rows[change.row_id] = if rows.key?(change.row_id)
+              rows[change.row_id].merge(change.new_values)
+            else
+              # Row might have been inserted before tracking started
+              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

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