rubydb 0.1.0

data/lib/rubydb/configuration/validation.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Configuration
+    # Validation - Configuration validation
+    class Validation
+      attr_reader :errors, :warnings
+
+      # Validation rules
+      RULES = {
+        "server.host" => { type: :string, required: true },
+        "server.port" => { type: :integer, required: true, min: 1, max: 65535 },
+        "server.max_connections" => { type: :integer, required: true, min: 1, max: 10000 },
+        "server.min_workers" => { type: :integer, required: true, min: 1 },
+        "server.max_workers" => { type: :integer, required: true, min: 1 },
+        "server.worker_queue_size" => { type: :integer, required: true, min: 1 },
+        "server.read_timeout" => { type: :integer, required: true, min: 1 },
+        "server.write_timeout" => { type: :integer, required: true, min: 1 },
+        "server.idle_timeout" => { type: :integer, required: true, min: 1 },
+        "server.max_request_size" => { type: :integer, required: true, min: 1024 },
+        "server.daemonize" => { type: :boolean, required: true },
+        "server.log_level" => { type: :string, required: true, enum: ["debug", "info", "warn", "error", "fatal"] },
+
+        "storage.data_dir" => { type: :string, required: true },
+        "storage.page_size" => { type: :integer, required: true, enum: [4096, 8192, 16384, 32768] },
+        "storage.buffer_pool_size" => { type: :integer, required: true, min: 10 },
+        "storage.wal_enabled" => { type: :boolean, required: true },
+        "storage.wal_dir" => { type: :string, required: true },
+        "storage.wal_segment_size" => { type: :integer, required: true, min: 1024 * 1024 },
+        "storage.wal_keep_segments" => { type: :integer, required: true, min: 1 },
+        "storage.fsync" => { type: :boolean, required: true },
+
+        "database.name" => { type: :string, required: true },
+        "database.encoding" => { type: :string, required: true },
+        "database.locale" => { type: :string, required: true },
+        "database.default_isolation_level" => { type: :string, required: true, enum: ["read_uncommitted", "read_committed", "repeatable_read", "serializable"] },
+        "database.max_connections" => { type: :integer, required: true, min: 1 },
+        "database.statement_timeout" => { type: :integer, required: true, min: 1 },
+        "database.idle_in_transaction_timeout" => { type: :integer, required: true, min: 1 },
+
+        "auth.method" => { type: :string, required: true, enum: ["none", "password", "md5", "scram_sha256", "token", "certificate"] },
+        "auth.session_timeout" => { type: :integer, required: true, min: 60 },
+        "auth.max_attempts" => { type: :integer, required: true, min: 1 },
+        "auth.lockout_duration" => { type: :integer, required: true, min: 1 },
+        "auth.password_algorithm" => { type: :string, required: true, enum: ["sha256", "sha512", "bcrypt", "pbkdf2", "argon2"] },
+        "auth.password_iterations" => { type: :integer, required: true, min: 1000 },
+        "auth.salt_length" => { type: :integer, required: true, min: 8 },
+
+        "ssl.enabled" => { type: :boolean, required: true },
+
+        "replication.enabled" => { type: :boolean, required: true },
+        "replication.role" => { type: :string, required: true, enum: ["standalone", "primary", "replica", "standby"] },
+        "replication.sync_mode" => { type: :string, required: true, enum: ["async", "sync", "quorum"] },
+        "replication.sync_replicas" => { type: :integer, required: true, min: 0 },
+        "replication.replication_port" => { type: :integer, required: true, min: 1, max: 65535 },
+        "replication.max_replicas" => { type: :integer, required: true, min: 0 },
+
+        "backup.backup_dir" => { type: :string, required: true },
+        "backup.retention_days" => { type: :integer, required: true, min: 1 },
+        "backup.max_backups" => { type: :integer, required: true, min: 1 },
+        "backup.verify_after_backup" => { type: :boolean, required: true },
+        "backup.include_wal" => { type: :boolean, required: true },
+        "backup.include_schema" => { type: :boolean, required: true },
+        "backup.compress" => { type: :boolean, required: true },
+        "backup.compression_level" => { type: :integer, required: true, min: 1, max: 9 },
+
+        "logging.log_dir" => { type: :string, required: true },
+        "logging.log_level" => { type: :string, required: true, enum: ["debug", "info", "warn", "error", "fatal"] },
+        "logging.log_format" => { type: :string, required: true, enum: ["json", "text"] },
+        "logging.rotate_size" => { type: :integer, required: true, min: 1024 * 1024 },
+        "logging.rotate_count" => { type: :integer, required: true, min: 1 },
+        "logging.audit_log" => { type: :boolean, required: true },
+        "logging.slow_query_threshold" => { type: :integer, required: true, min: 0 },
+
+        "monitoring.enabled" => { type: :boolean, required: true },
+        "monitoring.metrics_interval" => { type: :integer, required: true, min: 1 },
+        "monitoring.health_check_interval" => { type: :integer, required: true, min: 1 },
+        "monitoring.stats_collector" => { type: :boolean, required: true },
+        "monitoring.prometheus" => { type: :boolean, required: true },
+        "monitoring.prometheus_port" => { type: :integer, required: true, min: 1, max: 65535 }
+      }
+
+      def initialize
+        @errors = []
+        @warnings = []
+        @valid = false
+      end
+
+      def validate(config)
+        @errors = []
+        @warnings = []
+        @valid = true
+
+        RULES.each do |path, rules|
+          value = get_value(config, path)
+          validate_value(path, value, rules)
+        end
+
+        # Cross-field validations
+        validate_cross_fields(config)
+
+        @valid = @errors.empty?
+        @valid
+      end
+
+      def valid?
+        @valid
+      end
+
+      def errors
+        @errors.dup
+      end
+
+      def warnings
+        @warnings.dup
+      end
+
+      private
+
+      def get_value(config, path)
+        parts = path.split(".")
+        value = config
+        parts.each do |part|
+          return nil unless value.is_a?(Hash) && value.key?(part.to_sym)
+          value = value[part.to_sym]
+        end
+        value
+      end
+
+      def validate_value(path, value, rules)
+        # Check required
+        if rules[:required] && value.nil?
+          @errors << "#{path} is required"
+          return
+        end
+
+        return if value.nil?
+
+        # Check type
+        case rules[:type]
+        when :string
+          unless value.is_a?(String)
+            @errors << "#{path} must be a string"
+            return
+          end
+        when :integer
+          unless value.is_a?(Integer)
+            @errors << "#{path} must be an integer"
+            return
+          end
+        when :boolean
+          unless [true, false].include?(value)
+            @errors << "#{path} must be a boolean"
+            return
+          end
+        end
+
+        # Check min/max
+        if rules[:min] && value < rules[:min]
+          @errors << "#{path} must be at least #{rules[:min]}"
+        end
+
+        if rules[:max] && value > rules[:max]
+          @errors << "#{path} must be at most #{rules[:max]}"
+        end
+
+        # Check enum
+        if rules[:enum] && !rules[:enum].include?(value)
+          @errors << "#{path} must be one of: #{rules[:enum].join(', ')}"
+        end
+
+        # Check format
+        if rules[:format] && value !~ rules[:format]
+          @errors << "#{path} has invalid format"
+        end
+      end
+
+      def validate_cross_fields(config)
+        # Server validation
+        if config[:server]
+          if config[:server][:min_workers] > config[:server][:max_workers]
+            @errors << "server.min_workers must be less than or equal to server.max_workers"
+          end
+
+          if config[:server][:max_connections] < config[:server][:max_workers]
+            @warnings << "server.max_connections should be greater than server.max_workers"
+          end
+        end
+
+        # Storage validation
+        if config[:storage]
+          if config[:storage][:page_size] && config[:storage][:page_size] < 4096
+            @warnings << "storage.page_size is unusually small (recommended: 8192)"
+          end
+
+          if config[:storage][:buffer_pool_size] && config[:storage][:buffer_pool_size] < 10
+            @errors << "storage.buffer_pool_size must be at least 10"
+          end
+        end
+
+        # Replication validation
+        if config[:replication] && config[:replication][:enabled]
+          if config[:replication][:role] == "replica" && config[:replication][:primary_host].nil?
+            @errors << "replication.primary_host is required for replica role"
+          end
+
+          if config[:replication][:role] == "primary" && config[:replication][:sync_replicas] > config[:replication][:max_replicas]
+            @warnings << "replication.sync_replicas should not exceed replication.max_replicas"
+          end
+        end
+
+        # SSL validation
+        if config[:ssl] && config[:ssl][:enabled]
+          if config[:ssl][:cert_file].nil? || config[:ssl][:key_file].nil?
+            @errors << "ssl.cert_file and ssl.key_file are required when SSL is enabled"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/constants.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# RubyDB constants and configuration
+
+module RubyDB
+  # Database constants
+  module Constants
+    # Page size in bytes - 8KB default (same as PostgreSQL)
+    # This is a good balance between performance and storage efficiency
+    DEFAULT_PAGE_SIZE = 8192
+
+    # Page size options
+    PAGE_SIZES = [4096, 8192, 16384, 32768].freeze
+
+    # Database file extension
+    FILE_EXTENSION = ".rdb"
+
+    # WAL file extension
+    WAL_EXTENSION = ".rdb-wal"
+
+    # Shared memory file extension (for WAL)
+    SHM_EXTENSION = ".rdb-shm"
+
+    # Default port for RubyDB server
+    DEFAULT_PORT = 7432
+
+    # Maximum connections (server mode)
+    DEFAULT_MAX_CONNECTIONS = 100
+
+    # Buffer pool size (number of pages cached in memory)
+    DEFAULT_BUFFER_POOL_SIZE = 1000
+
+    # WAL segment size (16MB default)
+    DEFAULT_WAL_SEGMENT_SIZE = 16 * 1024 * 1024
+
+    # Maximum SQL statement length
+    MAX_SQL_LENGTH = 1_000_000
+
+    # Maximum identifier length
+    MAX_IDENTIFIER_LENGTH = 63
+
+    # Transaction isolation levels
+    module IsolationLevel
+      READ_UNCOMMITTED = 0
+      READ_COMMITTED = 1
+      REPEATABLE_READ = 2
+      SERIALIZABLE = 3
+    end
+
+    # Log levels
+    module LogLevel
+      DEBUG = 0
+      INFO = 1
+      WARN = 2
+      ERROR = 3
+      FATAL = 4
+    end
+  end
+
+  # Error codes
+  module ErrorCodes
+    OK = 0
+    ERROR = 1
+    IO_ERROR = 2
+    CORRUPTION = 3
+    CONSTRAINT_VIOLATION = 4
+    TRANSACTION_ABORTED = 5
+    LOCK_TIMEOUT = 6
+    DEADLOCK_DETECTED = 7
+    PERMISSION_DENIED = 8
+    NOT_FOUND = 9
+    ALREADY_EXISTS = 10
+  end
+end

data/lib/rubydb/constraints/check.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Constraints
+    # CheckConstraint - Ensures row satisfies a condition
+    class CheckConstraint < Constraint
+      attr_reader :expression
+
+      def initialize(table_name, expression, options = {})
+        super(
+          options[:name] || "chk_#{table_name}_#{Time.now.to_i}",
+          TYPE_CHECK,
+          table_name,
+          options
+        )
+        @expression = expression
+        @expression_type = options[:expression_type] || :sql
+        @validated = false
+      end
+
+      def validate(row)
+        return true unless enabled?
+
+        result = evaluate_expression(row)
+        if result == false
+          @validation_errors << "Check constraint failed: #{@expression}"
+          return false
+        end
+
+        true
+      end
+
+      def validate_batch(rows)
+        results = { valid: [], invalid: [] }
+
+        rows.each do |row|
+          if validate(row)
+            results[:valid] << row
+          else
+            results[:invalid] << row
+          end
+        end
+
+        results
+      end
+
+      def evaluate_expression(row)
+        case @expression_type
+        when :ruby
+          # Evaluate Ruby expression
+          eval_expression(@expression, row)
+        when :lambda
+          # Call lambda with row
+          @expression.call(row)
+        else
+          # Evaluate SQL expression - simplified
+          eval_sql_expression(@expression, row)
+        end
+      rescue => e
+        @validation_errors << "Expression evaluation error: #{e.message}"
+        false
+      end
+
+      def eval_expression(expr, row)
+        case expr
+        when Symbol, String
+          evaluate_predicate(expr.to_s.strip, row)
+        when Proc
+          expr.call(row)
+        else
+          true
+        end
+      end
+
+      def eval_sql_expression(expr, row)
+        evaluate_predicate(expr.to_s.strip, row)
+      end
+
+      def evaluate_predicate(expression, row)
+        expression = strip_outer_parentheses(expression.strip)
+
+        split_top_level(expression, "OR").any? do |part|
+          split_top_level(part, "AND").all? { |term| evaluate_term(term, row) }
+        end
+      end
+
+      def evaluate_term(term, row)
+        term = strip_outer_parentheses(term.strip)
+        if term =~ /\A([\w.]+)\s+IS\s+(NOT\s+)?NULL\z/i
+          value = row_value(row, Regexp.last_match(1))
+          return Regexp.last_match(2).nil? ? value.nil? : !value.nil?
+        end
+
+        match = term.match(/\A([\w.]+)\s*(>=|<=|<>|!=|=|>|<)\s*(.+)\z/i)
+        return false unless match
+
+        compare_value(row_value(row, match[1]), match[3].strip, match[2])
+      end
+
+      def row_value(row, column)
+        key = column.to_s.split(".").last
+        row.key?(key) ? row[key] : row[key.to_sym]
+      end
+
+      def strip_outer_parentheses(expression)
+        while expression.start_with?("(") && expression.end_with?( ")") && balanced_parentheses?(expression[1...-1])
+          expression = expression[1...-1].strip
+        end
+        expression
+      end
+
+      def balanced_parentheses?(expression)
+        depth = 0
+        expression.each_char do |char|
+          depth += 1 if char == "("
+          depth -= 1 if char == ")"
+          return false if depth.negative?
+        end
+        depth.zero?
+      end
+
+      def split_top_level(expression, operator)
+        parts = []
+        depth = 0
+        start = 0
+        expression.to_enum(:scan, /\(|\)|\b#{operator}\b/i).each do
+          match = Regexp.last_match
+          token = match[0]
+          if token == "("
+            depth += 1
+          elsif token == ")"
+            depth -= 1
+          elsif depth.zero?
+            parts << expression[start...match.begin(0)].strip
+            start = match.end(0)
+          end
+        end
+        parts << expression[start..].strip
+        parts.size > 1 ? parts : [expression]
+      end
+
+      def compare_value(row_val, val, op)
+        # Parse the value
+        parsed_val = case val
+        when /^'(.+)'$/ then $1
+        when /^\d+$/ then val.to_i
+        when /^\d+\.\d+$/ then val.to_f
+        when /^true$/i then true
+        when /^false$/i then false
+        when /^null$/i then nil
+        else val
+        end
+
+        case op
+        when "=" then row_val == parsed_val
+        when "!=", "<>" then row_val != parsed_val
+        when ">" then row_val > parsed_val
+        when ">=" then row_val >= parsed_val
+        when "<" then row_val < parsed_val
+        when "<=" then row_val <= parsed_val
+        else false
+        end
+      end
+
+      def to_sql
+        "CHECK (#{@expression})"
+      end
+
+      def to_hash
+        super.merge({
+          expression: @expression,
+          expression_type: @expression_type
+        })
+      end
+
+      def inspect
+        "#<CheckConstraint name=#{@name} expression=#{@expression}>"
+      end
+    end
+  end
+end

data/lib/rubydb/constraints/constraint.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Constraints
+    # Constraint - Base class for all constraints
+    class Constraint
+      attr_reader :name, :type, :table_name, :options, :created_at, :validation_errors
+
+      # Constraint types
+      TYPE_PRIMARY_KEY = :primary_key
+      TYPE_FOREIGN_KEY = :foreign_key
+      TYPE_UNIQUE = :unique
+      TYPE_NOT_NULL = :not_null
+      TYPE_CHECK = :check
+
+      def initialize(name, type, table_name, options = {})
+        @name = name || generate_name(type, table_name)
+        @type = type
+        @table_name = table_name
+        @options = options
+        @created_at = Time.now
+        @enabled = options[:enabled] != false
+        @deferrable = options[:deferrable] || false
+        @deferred = options[:deferred] || false
+        @validated = false
+        @validation_errors = []
+      end
+
+      def validate(row)
+        raise NotImplementedError, "#{self.class} must implement #validate"
+      end
+
+      def validate_batch(rows)
+        results = { valid: [], invalid: [] }
+        rows.each do |row|
+          if validate(row)
+            results[:valid] << row
+          else
+            results[:invalid] << row
+          end
+        end
+        results
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def enable
+        @enabled = true
+      end
+
+      def disable
+        @enabled = false
+      end
+
+      def deferrable?
+        @deferrable
+      end
+
+      def deferred?
+        @deferred
+      end
+
+      def defer
+        @deferred = true if @deferrable
+      end
+
+      def immediate
+        @deferred = false if @deferrable
+      end
+
+      def to_sql
+        raise NotImplementedError, "#{self.class} must implement #to_sql"
+      end
+
+      def to_hash
+        {
+          name: @name,
+          type: @type,
+          table_name: @table_name,
+          options: @options,
+          enabled: @enabled,
+          deferrable: @deferrable,
+          deferred: @deferred,
+          created_at: @created_at.iso8601
+        }
+      end
+
+      def inspect
+        "#<Constraint name=#{@name} type=#{@type} table=#{@table_name}>"
+      end
+
+      private
+
+      def generate_name(type, table_name)
+        "#{table_name}_#{type}_#{Time.now.to_i}_#{rand(1000)}"
+      end
+    end
+  end
+end

data/lib/rubydb/constraints/foreign_key.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Constraints
+    # ForeignKeyConstraint - Ensures referential integrity
+    class ForeignKeyConstraint < Constraint
+      attr_reader :columns, :reference_table, :reference_columns
+      attr_reader :on_delete, :on_update, :match_type
+
+      # Referential actions
+      ACTION_RESTRICT = :restrict
+      ACTION_CASCADE = :cascade
+      ACTION_SET_NULL = :set_null
+      ACTION_SET_DEFAULT = :set_default
+      ACTION_NO_ACTION = :no_action
+
+      def initialize(table_name, columns, reference_table, reference_columns = nil, options = {})
+        super(
+          options[:name] || "fk_#{table_name}_#{reference_table}",
+          TYPE_FOREIGN_KEY,
+          table_name,
+          options
+        )
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @reference_table = reference_table
+        @reference_columns = reference_columns.is_a?(Array) ? reference_columns : [reference_columns || :id]
+        @on_delete = options[:on_delete] || ACTION_NO_ACTION
+        @on_update = options[:on_update] || ACTION_NO_ACTION
+        @match_type = options[:match] || :simple
+        @validated = false
+        @reference_cache = {}
+      end
+
+      def validate(row)
+        return true unless enabled?
+
+        # Check all columns are present
+        @columns.each do |col|
+          if row[col].nil?
+            @validation_errors << "Column '#{col}' cannot be NULL"
+            return false
+          end
+        end
+
+        # Check if referenced row exists
+        key = @columns.map { |col| row[col] }.join("||")
+        return true if @reference_cache.key?(key)
+
+        # Check reference table
+        ref_exists = check_reference_exists(row)
+        if ref_exists
+          @reference_cache[key] = true
+          true
+        else
+          @validation_errors << "Referenced row does not exist: #{key}"
+          false
+        end
+      end
+
+      def validate_batch(rows)
+        @reference_cache.clear
+        results = { valid: [], invalid: [] }
+
+        rows.each do |row|
+          if validate(row)
+            results[:valid] << row
+          else
+            results[:invalid] << row
+          end
+        end
+
+        results
+      end
+
+      def check_reference_exists(row)
+        lookup = @options[:reference_lookup]
+        return false unless lookup.respond_to?(:call)
+
+        conditions = {}
+        @columns.each_with_index do |col, idx|
+          ref_col = @reference_columns[idx] || @reference_columns[0]
+          value = row.key?(col) ? row[col] : row[col.to_sym]
+          conditions[ref_col] = value
+        end
+
+        !!lookup.call(@reference_table, conditions)
+      end
+
+      def check_referential_integrity(table_name, row_id)
+        return false unless table_name.to_s == @table_name.to_s
+
+        lookup = @options[:reference_lookup]
+        return false unless lookup.respond_to?(:call)
+
+        # This API is used for a referenced-row delete check. The lookup is
+        # intentionally authoritative: inability to query the referencing
+        # table fails closed instead of allowing an orphaned row.
+        conditions = { @reference_columns.first => row_id }
+        !lookup.call(@reference_table, conditions)
+      end
+
+      def to_sql
+        cols = @columns.join(", ")
+        ref_cols = @reference_columns.join(", ")
+        sql = "FOREIGN KEY (#{cols}) REFERENCES #{@reference_table}(#{ref_cols})"
+        sql << " ON DELETE #{@on_delete.to_s.upcase}" if @on_delete != ACTION_NO_ACTION
+        sql << " ON UPDATE #{@on_update.to_s.upcase}" if @on_update != ACTION_NO_ACTION
+        # MATCH SIMPLE is the SQL default and is not part of RubyDB's
+        # documented parser surface. Emit only an explicitly non-default mode.
+        sql << " MATCH #{@match_type.to_s.upcase}" unless @match_type == :simple
+        sql
+      end
+
+      def to_hash
+        super.merge({
+          columns: @columns,
+          reference_table: @reference_table,
+          reference_columns: @reference_columns,
+          on_delete: @on_delete,
+          on_update: @on_update,
+          match_type: @match_type
+        })
+      end
+
+      def inspect
+        "#<ForeignKeyConstraint name=#{@name} columns=#{@columns.join(', ')} references=#{@reference_table}>"
+      end
+    end
+  end
+end