rubydb 0.1.4 → 0.1.6

data/lib/rubydb/constraints/foreign_key.rb

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

data/lib/rubydb/constraints/not_null.rb

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

@@ -1,99 +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
+# 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&.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