rubydb 0.1.0

data/lib/rubydb/constraints/not_null.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Constraints
+    # NotNullConstraint - Ensures column is not NULL
+    class NotNullConstraint < Constraint
+      attr_reader :column
+
+      def initialize(table_name, column, options = {})
+        super(
+          options[:name] || "nn_#{table_name}_#{column}",
+          TYPE_NOT_NULL,
+          table_name,
+          options
+        )
+        @column = column
+        @validated = false
+      end
+
+      def validate(row)
+        return true unless enabled?
+
+        if row[@column].nil?
+          @validation_errors << "Column '#{@column}' cannot be NULL"
+          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 find_null_rows(rows)
+        rows.select { |row| row[@column].nil? }
+      end
+
+      def to_sql
+        "#{@column} NOT NULL"
+      end
+
+      def to_hash
+        super.merge({
+          column: @column
+        })
+      end
+
+      def inspect
+        "#<NotNullConstraint name=#{@name} column=#{@column}>"
+      end
+    end
+  end
+end

data/lib/rubydb/constraints/primary_key.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Constraints
+    # PrimaryKeyConstraint - Ensures unique identification of rows
+    class PrimaryKeyConstraint < Constraint
+      attr_reader :columns
+
+      def initialize(table_name, columns, options = {})
+        super(
+          options[:name] || "pk_#{table_name}",
+          TYPE_PRIMARY_KEY,
+          table_name,
+          options
+        )
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @auto_increment = options[:auto_increment] || false
+        @sequence_name = options[:sequence_name] || "seq_#{table_name}_#{@columns.first}"
+        @validated = false
+      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 uniqueness
+        key = @columns.map { |col| row[col] }.join("||")
+        if @existing_keys && @existing_keys.include?(key)
+          @validation_errors << "Duplicate primary key: #{key}"
+          return false
+        end
+
+        true
+      end
+
+      def validate_batch(rows)
+        @existing_keys = Set.new
+        results = { valid: [], invalid: [] }
+
+        rows.each do |row|
+          # Check all columns are present
+          all_present = true
+          @columns.each do |col|
+            if row[col].nil?
+              all_present = false
+              @validation_errors << "Column '#{col}' cannot be NULL"
+            end
+          end
+
+          if all_present
+            key = @columns.map { |col| row[col] }.join("||")
+            if @existing_keys.include?(key)
+              @validation_errors << "Duplicate primary key: #{key}"
+              results[:invalid] << row
+            else
+              @existing_keys.add(key)
+              results[:valid] << row
+            end
+          else
+            results[:invalid] << row
+          end
+        end
+
+        results
+      end
+
+      def generate_next_id(current_max = 0)
+        return nil unless @auto_increment
+        current_max + 1
+      end
+
+      def to_sql
+        cols = @columns.join(", ")
+        sql = "PRIMARY KEY (#{cols})"
+        sql << " AUTO_INCREMENT" if @auto_increment
+        sql
+      end
+
+      def to_hash
+        super.merge({
+          columns: @columns,
+          auto_increment: @auto_increment,
+          sequence_name: @sequence_name
+        })
+      end
+
+      def inspect
+        "#<PrimaryKeyConstraint name=#{@name} columns=#{@columns.join(', ')}>"
+      end
+    end
+  end
+end

data/lib/rubydb/constraints/unique.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyDB
+  module Constraints
+    # UniqueConstraint - Ensures unique values in columns
+    class UniqueConstraint < Constraint
+      attr_reader :columns
+
+      def initialize(table_name, columns, options = {})
+        super(
+          options[:name] || "uniq_#{table_name}_#{columns.join('_')}",
+          TYPE_UNIQUE,
+          table_name,
+          options
+        )
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @nulls_distinct = options[:nulls_distinct] != false
+        @validated = false
+        @existing_keys = Set.new
+      end
+
+      def validate(row)
+        return true unless enabled?
+
+        # Build key from column values
+        key = build_key(row)
+
+        # Check if key already exists (duplicate)
+        if @existing_keys.include?(key)
+          @validation_errors << "Duplicate value for unique constraint: #{key}"
+          return false
+        end
+
+        @existing_keys.add(key)
+        true
+      end
+
+      def validate_batch(rows)
+        @existing_keys = Set.new
+        results = { valid: [], invalid: [] }
+
+        rows.each do |row|
+          key = build_key(row)
+
+          # Skip if all values are NULL and nulls_distinct is true
+          if @nulls_distinct && all_null?(row)
+            results[:valid] << row
+            next
+          end
+
+          if @existing_keys.include?(key)
+            @validation_errors << "Duplicate value for unique constraint: #{key}"
+            results[:invalid] << row
+          else
+            @existing_keys.add(key)
+            results[:valid] << row
+          end
+        end
+
+        results
+      end
+
+      def build_key(row)
+        @columns.map { |col| row[col] }.join("||")
+      end
+
+      def all_null?(row)
+        @columns.all? { |col| row[col].nil? }
+      end
+
+      def check_duplicates(rows)
+        seen = Set.new
+        duplicates = []
+
+        rows.each do |row|
+          key = build_key(row)
+          if seen.include?(key)
+            duplicates << row
+          else
+            seen.add(key)
+          end
+        end
+
+        duplicates
+      end
+
+      def to_sql
+        cols = @columns.join(", ")
+        sql = "UNIQUE (#{cols})"
+        sql << " NULLS NOT DISTINCT" unless @nulls_distinct
+        sql
+      end
+
+      def to_hash
+        super.merge({
+          columns: @columns,
+          nulls_distinct: @nulls_distinct
+        })
+      end
+
+      def inspect
+        "#<UniqueConstraint name=#{@name} columns=#{@columns.join(', ')}>"
+      end
+    end
+  end
+end

data/lib/rubydb/constraints/validator.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require "set"
+require "monitor"
+
+module RubyDB
+  module Constraints
+    # Validator - Validates rows against all constraints
+    class Validator
+      attr_reader :constraints, :stats
+
+      def initialize
+        @constraints = {
+          primary_key: [],
+          foreign_key: [],
+          unique: [],
+          not_null: [],
+          check: []
+        }
+        @stats = {
+          validations: 0,
+          valid_rows: 0,
+          invalid_rows: 0,
+          constraint_violations: 0,
+          validation_time_ms: 0,
+          total_validation_time_ms: 0,
+          avg_validation_time_ms: 0
+        }
+        # Validation calls get_constraints_for_table while holding the
+        # validator lock; use a re-entrant lock to avoid self-deadlock.
+        @lock = Monitor.new
+        @constraint_cache = {}
+        @deferred_constraints = []
+      end
+
+      def add_constraint(constraint)
+        @lock.synchronize do
+          type = constraint.type
+          @constraints[type] ||= []
+          @constraints[type] << constraint
+          @constraint_cache[constraint.name] = constraint
+          @constraint_cache["#{constraint.table_name}:#{constraint.name}"] = constraint
+        end
+      end
+
+      def remove_constraint(name)
+        @lock.synchronize do
+          @constraints.each do |type, list|
+            list.delete_if { |c| c.name == name }
+          end
+          @constraint_cache.delete(name)
+          @constraint_cache.each do |key, c|
+            if c.name == name
+              @constraint_cache.delete(key)
+            end
+          end
+        end
+      end
+
+      def get_constraint(name)
+        @constraint_cache[name]
+      end
+
+      def get_constraints_for_table(table_name)
+        @lock.synchronize do
+          result = []
+          @constraints.each do |_, list|
+            list.each do |c|
+              result << c if c.table_name == table_name
+            end
+          end
+          result
+        end
+      end
+
+      def validate_row(row, table_name, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:validations] += 1
+
+          result = {
+            valid: true,
+            errors: [],
+            warnings: [],
+            constraints_checked: [],
+            constraints_passed: [],
+            constraints_failed: []
+          }
+
+          constraints = get_constraints_for_table(table_name)
+
+          constraints.each do |constraint|
+            next unless constraint.enabled?
+            next if options[:skip] && options[:skip].include?(constraint.type)
+
+            @stats[:constraint_violations] += 1
+            result[:constraints_checked] << constraint.name
+
+            if constraint.validate(row)
+              result[:constraints_passed] << constraint.name
+            else
+              result[:valid] = false
+              result[:constraints_failed] << constraint.name
+              result[:errors] << {
+                constraint: constraint.name,
+                type: constraint.type,
+                message: constraint.validation_errors.last
+              }
+            end
+          end
+
+          # Handle deferred constraints
+          if options[:defer] != false
+            @deferred_constraints.each do |dc|
+              next unless dc[:table] == table_name
+
+              if options[:defer] == false
+                if dc[:constraint].validate(row)
+                  result[:constraints_passed] << dc[:constraint].name
+                else
+                  result[:valid] = false
+                  result[:constraints_failed] << dc[:constraint].name
+                  result[:errors] << {
+                    constraint: dc[:constraint].name,
+                    type: dc[:constraint].type,
+                    message: "Deferred constraint violation"
+                  }
+                end
+              elsif dc[:row_provider].nil?
+                dc[:captured_rows] << row
+              end
+            end
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:total_validation_time_ms] += elapsed_ms
+          @stats[:avg_validation_time_ms] = @stats[:total_validation_time_ms] / @stats[:validations]
+
+          if result[:valid]
+            @stats[:valid_rows] += 1
+          else
+            @stats[:invalid_rows] += 1
+          end
+
+          result
+        end
+      end
+
+      def validate_rows(rows, table_name, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:validations] += 1
+
+          results = {
+            valid: [],
+            invalid: [],
+            errors: [],
+            summary: {
+              total: rows.size,
+              valid: 0,
+              invalid: 0,
+              constraint_violations: 0
+            }
+          }
+
+          constraints = get_constraints_for_table(table_name)
+
+          # Group constraints by type for batch validation
+          constraints_by_type = {}
+          constraints.each do |c|
+            next unless c.enabled?
+            next if options[:skip] && options[:skip].include?(c.type)
+
+            constraints_by_type[c.type] ||= []
+            constraints_by_type[c.type] << c
+          end
+
+          # Validate each row
+          rows.each do |row|
+            row_valid = true
+            row_errors = []
+
+            constraints_by_type.each do |type, list|
+              list.each do |constraint|
+                @stats[:constraint_violations] += 1
+
+                if constraint.validate(row)
+                  # Passed
+                else
+                  row_valid = false
+                  row_errors << {
+                    constraint: constraint.name,
+                    type: type,
+                    message: constraint.validation_errors.last
+                  }
+                end
+              end
+            end
+
+            if row_valid
+              results[:valid] << row
+              results[:summary][:valid] += 1
+            else
+              results[:invalid] << row
+              results[:summary][:invalid] += 1
+              results[:errors] << { row: row, errors: row_errors }
+              results[:summary][:constraint_violations] += row_errors.size
+            end
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:total_validation_time_ms] += elapsed_ms
+          @stats[:avg_validation_time_ms] = @stats[:total_validation_time_ms] / @stats[:validations]
+
+          @stats[:valid_rows] += results[:summary][:valid]
+          @stats[:invalid_rows] += results[:summary][:invalid]
+
+          results
+        end
+      end
+
+      def validate_batch(table_name, rows, options = {})
+        validate_rows(rows, table_name, options)
+      end
+
+      def defer_constraint(constraint, table_name, rows: nil, row_provider: nil)
+        @lock.synchronize do
+          @deferred_constraints << {
+            constraint: constraint,
+            table: table_name,
+            rows: rows,
+            row_provider: row_provider,
+            captured_rows: [],
+            deferred_at: Time.now
+          }
+        end
+      end
+
+      def validate_deferred(table_name = nil, rows: nil)
+        @lock.synchronize do
+          results = {
+            valid: true,
+            errors: [],
+            constraints_checked: []
+          }
+
+          deferred = if table_name
+            @deferred_constraints.select { |dc| dc[:table] == table_name }
+          else
+            @deferred_constraints
+          end
+
+          deferred.each do |dc|
+            candidate_rows = rows || dc[:rows] || (dc[:captured_rows] unless dc[:captured_rows].empty?)
+            candidate_rows = dc[:row_provider].call if candidate_rows.nil? && dc[:row_provider]
+            candidate_rows = Array(candidate_rows) if candidate_rows
+
+            if candidate_rows.nil?
+              results[:valid] = false
+              results[:errors] << {
+                constraint: dc[:constraint].name,
+                error: "Deferred constraint validation requires rows or a row provider"
+              }
+              next
+            end
+
+            invalid_rows = candidate_rows.reject { |row| dc[:constraint].validate(row) }
+            results[:constraints_checked] << dc[:constraint].name
+            unless invalid_rows.empty?
+              results[:valid] = false
+              results[:errors] << {
+                constraint: dc[:constraint].name,
+                error: "Deferred constraint violation",
+                invalid_rows: invalid_rows
+              }
+            end
+          end
+
+          if results[:valid]
+            if table_name
+              @deferred_constraints.reject! { |dc| deferred.include?(dc) }
+            else
+              @deferred_constraints.clear
+            end
+          end
+          results
+        end
+      end
+
+      def check_constraints(table_name)
+        @lock.synchronize do
+          constraints = get_constraints_for_table(table_name)
+          results = {
+            total: constraints.size,
+            enabled: constraints.count(&:enabled?),
+            disabled: constraints.count { |c| !c.enabled? },
+            constraints: constraints.map(&:to_hash)
+          }
+          results
+        end
+      end
+
+      def enable_constraint(name)
+        @lock.synchronize do
+          constraint = get_constraint(name)
+          constraint&.enable
+        end
+      end
+
+      def disable_constraint(name)
+        @lock.synchronize do
+          constraint = get_constraint(name)
+          constraint&.disable
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            total_constraints: @constraints.values.flatten.size,
+            primary_keys: @constraints[:primary_key].size,
+            foreign_keys: @constraints[:foreign_key].size,
+            unique_constraints: @constraints[:unique].size,
+            not_null_constraints: @constraints[:not_null].size,
+            check_constraints: @constraints[:check].size,
+            deferred_constraints: @deferred_constraints.size,
+            cache_size: @constraint_cache.size
+          })
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @constraints.each { |_, list| list.clear }
+          @constraint_cache.clear
+          @deferred_constraints.clear
+          @stats = {
+            validations: 0,
+            valid_rows: 0,
+            invalid_rows: 0,
+            constraint_violations: 0,
+            validation_time_ms: 0,
+            total_validation_time_ms: 0,
+            avg_validation_time_ms: 0
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/errors/authentication_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when authentication fails
+  class AuthenticationError < Error
+    def initialize(message = "Authentication failed", details: nil)
+      super(message, code: ErrorCodes::PERMISSION_DENIED, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/authorization_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when authorization fails (permission denied)
+  class AuthorizationError < Error
+    attr_reader :user, :action, :resource
+
+    def initialize(message = "Permission denied", user: nil, action: nil, resource: nil, details: nil)
+      super(message, code: ErrorCodes::PERMISSION_DENIED, details: details)
+      @user = user
+      @action = action
+      @resource = resource
+    end
+
+    def to_s
+      msg = super
+      msg = "#{msg} for user #{@user}" if @user
+      msg = "#{msg} to #{@action}" if @action
+      msg = "#{msg} on #{@resource}" if @resource
+      msg
+    end
+  end
+end

data/lib/rubydb/errors/client_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised for client-side lifecycle and protocol usage errors.
+  class ClientError < Error
+    def initialize(message = "Client error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/configuration_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is an error in database configuration
+  class ConfigurationError < Error
+    def initialize(message = "Configuration error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end

data/lib/rubydb/errors/connection_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyDB
+  # Raised when there is an error connecting to the database
+  class ConnectionError < Error
+    def initialize(message = "Connection error", details: nil)
+      super(message, code: ErrorCodes::ERROR, details: details)
+    end
+  end
+end