rubydb 0.1.0

data/lib/rubydb/types/json.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyDB
+  module Types
+    # JSON type (stores JSON data)
+    class Json < Type
+      def initialize
+        super(:json)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "null".encode("UTF-8") if value.nil?
+        JSON.generate(value)
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        JSON.parse(bytes.force_encoding("UTF-8"))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid JSON: #{value}" unless value.is_a?(Hash) || value.is_a?(Array)
+        true
+      end
+
+      def default
+        {}
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/null.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # NULL type (represents absence of value)
+    class Null < Type
+      SIZE = 0
+
+      def initialize
+        super(:null, size: SIZE)
+      end
+
+      def serialize(value)
+        ""
+      end
+
+      def deserialize(bytes)
+        nil
+      end
+
+      def validate(value)
+        true  # Always valid
+      end
+
+      def default
+        nil
+      end
+
+      def storage_size
+        0
+      end
+    end
+  end
+end

data/lib/rubydb/types/smallint.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # 16-bit signed integer
+    class SmallInt < Type
+      RANGE = (-32_768..32_767).freeze
+      SIZE = 2
+
+      def initialize
+        super(:smallint, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        [value.to_i].pack("s>")  # Big-endian 16-bit signed
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.unpack("s>").first
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid smallint: #{value}" unless value.is_a?(::Integer)
+        raise ConstraintError, "SmallInt out of range: #{value}" unless RANGE.include?(value)
+        true
+      end
+
+      def default
+        0
+      end
+    end
+  end
+end

data/lib/rubydb/types/text.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Variable-length text string (unlimited)
+    class Text < Type
+      def initialize
+        super(:text)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "" if value.nil?
+        value.to_s.encode("UTF-8")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        bytes.force_encoding("UTF-8")
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid text: #{value}" unless value.respond_to?(:to_s)
+        true
+      end
+
+      def default
+        ""
+      end
+
+      def storage_size
+        nil  # Variable length
+      end
+    end
+  end
+end

data/lib/rubydb/types/time.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module Types
+    # Time type (hour, minute, second)
+    class Time < Type
+      SIZE = 8  # Microseconds since midnight
+
+      def initialize
+        super(:time, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        seconds = value.hour * 3600 + value.min * 60 + value.sec
+        microseconds = value.usec
+        total = seconds * 1_000_000 + microseconds
+        [total].pack("q>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        total = bytes.unpack("q>").first
+        seconds = total / 1_000_000
+        microseconds = total % 1_000_000
+        hour = seconds / 3600
+        minute = (seconds % 3600) / 60
+        sec = seconds % 60
+        ::Time.new(1970, 1, 1, hour, minute, sec, microseconds)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid time: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime)
+        true
+      end
+
+      def default
+        ::Time.now
+      end
+    end
+  end
+end

data/lib/rubydb/types/timestamp.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module Types
+    # Timestamp (date + time with timezone)
+    class Timestamp < Type
+      SIZE = 8  # Seconds since epoch (Unix timestamp)
+
+      def initialize
+        super(:timestamp, size: SIZE)
+      end
+
+      def serialize(value)
+        value = ::Time.parse(value) if value.is_a?(String)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        [value.to_i].pack("q>")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        seconds = bytes.unpack("q>").first
+        ::Time.at(seconds)
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid timestamp: #{value}" unless value.is_a?(::Time) || value.is_a?(::DateTime) || value.is_a?(::Date)
+        true
+      end
+
+      def default
+        ::Time.now
+      end
+    end
+  end
+end

data/lib/rubydb/types/type.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../errors/constraint_error"
+require_relative "../errors/configuration_error"
+
+module RubyDB
+  module Types
+    # Base class for all data types
+    class Type
+      attr_reader :name, :size, :precision, :scale
+
+      def initialize(name, size: nil, precision: nil, scale: nil)
+        @name = name
+        @size = size
+        @precision = precision
+        @scale = scale
+      end
+
+      def serialize(value)
+        raise NotImplementedError, "#{self.class} must implement #serialize"
+      end
+
+      def deserialize(bytes)
+        raise NotImplementedError, "#{self.class} must implement #deserialize"
+      end
+
+      def validate(value)
+        raise NotImplementedError, "#{self.class} must implement #validate"
+      end
+
+      def compare(a, b)
+        return 0 if a == b
+        return -1 if a < b
+        1
+      end
+
+      def default
+        nil
+      end
+
+      def sql_type
+        @name.to_s.upcase
+      end
+
+      def storage_size
+        @size
+      end
+
+      def to_s
+        sql_type
+      end
+
+      def inspect
+        "#<#{self.class} name=#{@name} size=#{@size}>"
+      end
+    end
+
+    # Type registry for looking up types by name
+    class TypeRegistry
+      @types = {}
+
+      class << self
+        attr_reader :types
+
+        def register(name, type_class = nil)
+          klass = type_class || resolve(name)
+          return if klass.nil?
+
+          @types[name.to_sym] = klass
+        end
+
+        def lookup(name, **kwargs)
+          type_class = @types[name.to_sym] || resolve(name)
+          if type_class
+            return type_class.new(kwargs.fetch(:limit, 255)) if type_class == Varchar
+
+            return type_class.new(**kwargs)
+          end
+
+          raise ConfigurationError, "Unknown type: #{name}"
+        end
+
+        def reset
+          @types = {}
+        end
+
+        private
+
+        def resolve(name)
+          name = name.to_sym
+          const_name = case name
+                       when :bigint then "BigInt"
+                       when :smallint then "SmallInt"
+                       when :float then "Float"
+                       when :decimal then "Decimal"
+                       when :boolean then "Boolean"
+                       when :text then "Text"
+                       when :varchar then "Varchar"
+                       when :blob then "Blob"
+                       when :date then "Date"
+                       when :time then "Time"
+                       when :timestamp then "Timestamp"
+                       when :json then "Json"
+                       when :uuid then "UUID"
+                       when :null then "Null"
+                       when :integer then "Integer"
+                       else name.to_s.split("_").map { |part| part.capitalize }.join
+                       end
+
+          klass = RubyDB::Types.const_get(const_name)
+          @types[name] = klass
+          klass
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/types/uuid.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RubyDB
+  module Types
+    # UUID type (Universally Unique Identifier)
+    class UUID < Type
+      SIZE = 16
+      UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+      def initialize
+        super(:uuid, size: SIZE)
+      end
+
+      def serialize(value)
+        validate(value)
+        return "\x00" * SIZE if value.nil?
+        # Remove hyphens and convert hex to bytes
+        hex = value.to_s.gsub("-", "")
+        [hex].pack("H*")
+      end
+
+      def deserialize(bytes)
+        return nil if bytes.nil? || bytes.empty?
+        hex = bytes.unpack("H*").first
+        # Add hyphens back
+        "#{hex[0...8]}-#{hex[8...12]}-#{hex[12...16]}-#{hex[16...20]}-#{hex[20...32]}"
+      end
+
+      def validate(value)
+        return true if value.nil?
+        str = value.to_s
+        raise ConstraintError, "Invalid UUID: #{value}" unless str.match?(UUID_REGEX)
+        true
+      end
+
+      def default
+        SecureRandom.uuid
+      end
+
+      def generate
+        SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/rubydb/types/varchar.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Types
+    # Variable-length text string with maximum length
+    class Varchar < Text
+      attr_reader :limit
+
+      def initialize(limit)
+        super()
+        @name = :varchar
+        @limit = limit
+        @size = limit
+      end
+
+      def serialize(value)
+        validate(value)
+        return "" if value.nil?
+        str = value.to_s.encode("UTF-8")
+        raise ConstraintError, "VARCHAR exceeds limit: #{str.length} > #{@limit}" if str.length > @limit
+        str
+      end
+
+      def validate(value)
+        return true if value.nil?
+        raise ConstraintError, "Invalid varchar: #{value}" unless value.respond_to?(:to_s)
+        str = value.to_s
+        raise ConstraintError, "VARCHAR exceeds limit: #{str.length} > #{@limit}" if str.length > @limit
+        true
+      end
+
+      def to_s
+        "VARCHAR(#{@limit})"
+      end
+    end
+  end
+end

data/lib/rubydb/version.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# RubyDB version information
+# Follows Semantic Versioning (SemVer) 2.0.0
+# See: https://semver.org/
+
+module RubyDB
+  # Current version of RubyDB
+  #
+  # Format: MAJOR.MINOR.PATCH
+  # - MAJOR: Incompatible API changes
+  # - MINOR: Backwards-compatible new functionality
+  # - PATCH: Backwards-compatible bug fixes
+  VERSION = "0.1.0"
+
+  # Version components for easy access
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    PRE = nil  # e.g., "alpha", "beta", "rc1"
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join(".")
+    end
+
+    def self.full
+      version = to_s
+      version += "-#{PRE}" if PRE
+      version
+    end
+  end
+end

data/lib/rubydb/wal/archive.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "zlib"
+require "time"
+
+module RubyDB
+  module WAL
+    # Archive - Manages WAL archiving and restoration
+    class Archive
+      attr_reader :stats
+
+      def initialize(wal_dir, archive_dir = nil, config = {})
+        @wal_dir = wal_dir
+        @archive_dir = archive_dir || File.join(wal_dir, "archive")
+        @config = config
+        @compression = config[:compression] || true
+        @max_archive_size = config[:max_size] || 10 * 1024 * 1024 * 1024  # 10GB
+        @retention_days = config[:retention_days] || 30
+        @stats = {
+          archives_created: 0,
+          archives_restored: 0,
+          archives_deleted: 0,
+          total_archive_size: 0,
+          compressed_bytes: 0,
+          uncompressed_bytes: 0,
+          archive_failures: 0
+        }
+        @lock = Mutex.new
+
+        # Create archive directory
+        FileUtils.mkdir_p(@archive_dir)
+      end
+
+      def archive_segment(segment)
+        @lock.synchronize do
+          start_time = Time.now
+
+          begin
+            # Check if segment exists
+            unless segment.exists?
+              return false
+            end
+
+            # Archive the segment
+            archive_path = segment.archive
+            archive_size = File.size(archive_path)
+
+            # Compress if enabled
+            if @compression && archive_size > 0
+              compressed_path = "#{archive_path}.gz"
+              compress_file(archive_path, compressed_path)
+              File.delete(archive_path)
+              archive_path = compressed_path
+              archive_size = File.size(archive_path)
+              @stats[:compressed_bytes] += archive_size
+            end
+
+            @stats[:archives_created] += 1
+            @stats[:total_archive_size] += archive_size
+            @stats[:uncompressed_bytes] += archive_size
+
+            # Clean old archives if needed
+            clean_old_archives
+
+            { path: archive_path, size: archive_size }
+
+          rescue => e
+            @stats[:archive_failures] += 1
+            raise
+          end
+        end
+      end
+
+      def restore_archive(segment_id)
+        @lock.synchronize do
+          # Find archive file
+          archive_path = File.join(@archive_dir, "wal_#{segment_id.to_s.rjust(8, '0')}.log")
+
+          unless File.exist?(archive_path)
+            # Try compressed
+            compressed_path = "#{archive_path}.gz"
+            if File.exist?(compressed_path)
+              archive_path = compressed_path
+            else
+              return false
+            end
+          end
+
+          # Decompress if needed
+          if archive_path.end_with?(".gz")
+            decompressed_path = archive_path.gsub(/\.gz$/, "")
+            decompress_file(archive_path, decompressed_path)
+            archive_path = decompressed_path
+          end
+
+          # Copy to WAL directory
+          wal_path = File.join(@wal_dir, "wal_#{segment_id.to_s.rjust(8, '0')}.log")
+          FileUtils.cp(archive_path, wal_path)
+
+          @stats[:archives_restored] += 1
+          wal_path
+        end
+      end
+
+      def list_archives
+        @lock.synchronize do
+          archives = []
+
+          Dir.glob(File.join(@archive_dir, "wal_*.log*")).each do |path|
+            if path =~ /wal_(\d+)\.log(?:\.gz)?$/
+              segment_id = $1.to_i
+              size = File.size(path)
+              modified = File.mtime(path)
+
+              archives << {
+                segment_id: segment_id,
+                path: path,
+                size: size,
+                modified: modified,
+                compressed: path.end_with?(".gz")
+              }
+            end
+          end
+
+          archives.sort_by { |a| a[:segment_id] }
+        end
+      end
+
+      def clean_old_archives
+        @lock.synchronize do
+          # Check total size
+          archives = list_archives
+          total_size = archives.sum { |a| a[:size] }
+
+          # If over limit, remove oldest
+          if total_size > @max_archive_size
+            archives.sort_by! { |a| a[:modified] }
+            archives.each do |archive|
+              break if total_size <= @max_archive_size
+
+              File.delete(archive[:path])
+              total_size -= archive[:size]
+              @stats[:archives_deleted] += 1
+            end
+          end
+
+          # Remove old archives
+          cutoff = Time.now - @retention_days * 24 * 60 * 60
+          archives.each do |archive|
+            if archive[:modified] < cutoff
+              File.delete(archive[:path])
+              @stats[:archives_deleted] += 1
+            end
+          end
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          archives = list_archives
+          total_size = archives.sum { |a| a[:size] }
+
+          @stats.merge({
+            archive_count: archives.size,
+            total_archive_size: total_size,
+            retention_days: @retention_days,
+            max_archive_size: @max_archive_size,
+            compression: @compression
+          })
+        end
+      end
+
+      private
+
+      def compress_file(source, destination)
+        File.open(source, "rb") do |input|
+          Zlib::GzipWriter.open(destination) do |output|
+            output.write(input.read)
+          end
+        end
+      end
+
+      def decompress_file(source, destination)
+        Zlib::GzipReader.open(source) do |input|
+          File.open(destination, "wb") do |output|
+            output.write(input.read)
+          end
+        end
+      end
+    end
+  end
+end