frozen_record 0.18.0 → 0.19.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a47352d34eb964f32bf8d253cffe682abc221f80db5782ed7dce6aee76967661
-  data.tar.gz: ea62e1c1bcc0cf927a2614f2fb4cfc1acbb6780cdfec273a44dbbe1bd14a55e2
+  metadata.gz: 2fe4a43299f20ff72c35ee4093ef5f6c8d49214aabc82cf67108da083980b28e
+  data.tar.gz: 7023b4b75d3eb733ef534ae85f1b25e0efb7aac3ba8548dd9e1a25bdbe1ec804
 SHA512:
-  metadata.gz: 33f76d7869d6a1e8a9cae954b074fa93cb89ffa3fcee9bc170d3e23b5ee2fcb39164a7e9de0b0f1570588bd7919d88b288bb35bc9c965cb32b77e3e9c6b5928a
-  data.tar.gz: e38977cfbdb6136aed4042060e130bc260f6e33c8db9c876f05f832d65037ba504fe7119a5b338c62e9a17391b2d1472ab2e2de5df5ae2c90b72772bd0599cd8
+  metadata.gz: 4031cf6cd49bec9dc97c246a0999736ed178d9f6b1e623ef6e60070da454e1141fb7ca25056d2d55f2f808d2812f0f1c14e856cecaf73b0dd403a2a047debf62
+  data.tar.gz: 823f999ec6e21c55b4b0cad6b39008c55377052d194a29af96edb0e85cc9a33227635246a9187fdc7207eac9ec515c352f54ac8c568a7ec7bd3589ef74dea0dd

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 vendor
+.byebug_history

data/README.md

@@ -140,6 +140,22 @@ Country.european.republics.part_of_nato.order(id: :desc)
   - average
 
 
+## Indexing
+
+Querying is implemented as a simple linear search (`O(n)`). However if you are using Frozen Record with larger datasets, or are querying
+a collection repetedly, you can define indices for faster access.
+
+```ruby
+class Country < FrozenRecord::Base
+  add_index :name, unique: true
+  add_index :continent
+end
+```
+
+Composite index keys are not supported.
+
+The primary key isn't indexed by default.
+
 ## Configuration
 
 ### Reloading

data/lib/frozen_record.rb

@@ -7,6 +7,7 @@ require 'active_model'
 
 require 'frozen_record/version'
 require 'frozen_record/scope'
+require 'frozen_record/index'
 require 'frozen_record/base'
 require 'frozen_record/compact'
 require 'frozen_record/deduplication'

data/lib/frozen_record/base.rb

@@ -21,6 +21,8 @@ module FrozenRecord
     FALSY_VALUES = [false, nil, 0, -''].to_set
 
     class_attribute :base_path, :primary_key, :backend, :auto_reloading, :default_attributes, instance_accessor: false
+    class_attribute :index_definitions, instance_accessor: false
+    self.index_definitions = {}.freeze
 
     self.primary_key = 'id'
 
@@ -103,6 +105,11 @@ module FrozenRecord
         end
       end
 
+      def add_index(attribute, unique: false)
+        index = unique ? UniqueIndex.new(self, attribute) : Index.new(self, attribute)
+        self.index_definitions = index_definitions.merge(index.attribute => index).freeze
+      end
+
       def memsize(object = self, seen = Set.new.compare_by_identity)
         return 0 unless seen.add?(object)
 
@@ -143,15 +150,14 @@ module FrozenRecord
           records = Deduplication.deep_deduplicate!(records)
           @attributes = list_attributes(records).freeze
           define_attribute_methods(@attributes.to_a)
-          records.map { |r| load(r) }.freeze
+          records = records.map { |r| load(r) }.freeze
+          index_definitions.values.each { |index| index.build(records) }
+          records
         end
       end
 
       def scope(name, body)
-        unless body.respond_to?(:call)
-          raise ArgumentError, "The scope body needs to be callable."
-        end
-        singleton_class.send(:define_method, name) { |*args| body.call(*args) }
+        singleton_class.send(:define_method, name, &body)
       end
 
       alias_method :load, :new

data/lib/frozen_record/compact.rb

@@ -18,7 +18,9 @@ module FrozenRecord
           @attributes = list_attributes(records).freeze
           build_attributes_cache
           define_attribute_methods(@attributes.to_a)
-          records.map { |r| load(r) }.freeze
+          records = records.map { |r| load(r) }.freeze
+          index_definitions.values.each { |index| index.build(records) }
+          records
         end
       end
 

data/lib/frozen_record/index.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module FrozenRecord
+  class Index
+    EMPTY_ARRAY = [].freeze
+    private_constant :EMPTY_ARRAY
+
+    AttributeNonUnique = Class.new(StandardError)
+
+    attr_reader :attribute, :model
+
+    def initialize(model, attribute, unique: false)
+      @model = model
+      @attribute = -attribute.to_s
+      @index = nil
+    end
+
+    def unique?
+      false
+    end
+
+    def query(value)
+      case value
+      when Array, Range
+        lookup_multi(value)
+      else
+        lookup(value)
+      end
+    end
+
+    def lookup_multi(values)
+      values.flat_map { |v| lookup(v) }
+    end
+
+    def lookup(value)
+      @index.fetch(value, EMPTY_ARRAY)
+    end
+
+    def reset
+      @index = nil
+    end
+
+    def build(records)
+      @index = records.each_with_object({}) do |record, index|
+        entry = (index[record[attribute]] ||= [])
+        entry << record
+      end
+      @index.values.each(&:freeze)
+      @index.freeze
+    end
+  end
+
+  class UniqueIndex < Index
+    def unique?
+      true
+    end
+
+    def lookup_multi(values)
+      results = @index.values_at(*values)
+      results.compact!
+      results
+    end
+
+    def lookup(value)
+      record = @index[value]
+      record ? [record] : EMPTY_ARRAY
+    end
+
+    def build(records)
+      @index = records.each_with_object({}) { |r, index| index[r[attribute]] = r }
+      if @index.size != records.size
+        raise AttributeNonUnique, "#{model}##{attribute.inspect} is not unique."
+      end
+      @index.freeze
+    end
+  end
+end

data/lib/frozen_record/scope.rb

@@ -175,9 +175,20 @@ module FrozenRecord
     def select_records(records)
       return records if @where_values.empty? && @where_not_values.empty?
 
+      indices = @klass.index_definitions
+      indexed_where_values, unindexed_where_values = @where_values.partition { |criteria| indices.key?(criteria.first) }
+
+      unless indexed_where_values.empty?
+        attribute, value = indexed_where_values.shift
+        records = indices[attribute].query(value)
+        indexed_where_values.each do |(attribute, value)|
+          records &= indices[attribute].query(value)
+        end
+      end
+
       records.select do |record|
-        @where_values.all? { |attr, value| compare_value(record[attr], value) } &&
-        @where_not_values.all? { |attr, value| !compare_value(record[attr], value) }
+        unindexed_where_values.all? { |attr, value| compare_value(record[attr], value) } &&
+        !@where_not_values.any? { |attr, value| compare_value(record[attr], value) }
       end
     end
 
@@ -226,12 +237,12 @@ module FrozenRecord
     end
 
     def where!(criterias)
-      @where_values += criterias.to_a
+      @where_values += criterias.map { |k, v| [k.to_s, v] }
       self
     end
 
     def where_not!(criterias)
-      @where_not_values += criterias.to_a
+      @where_not_values += criterias.map { |k, v| [k.to_s, v] }
       self
     end
 

data/lib/frozen_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FrozenRecord
-  VERSION = '0.18.0'
+  VERSION = '0.19.4'
 end

data/spec/frozen_record_spec.rb

@@ -83,7 +83,7 @@ RSpec.shared_examples 'main' do
   describe '.scope' do
 
     it 'defines a scope method' do
-      country_model.scope :north_american, -> { country_model.where(continent: 'North America') }
+      country_model.scope :north_american, -> { where(continent: 'North America') }
       expect(country_model).to respond_to(:north_american)
       expect(country_model.north_american.first.name).to be == 'Canada'
     end

data/spec/scope_spec.rb

@@ -203,6 +203,18 @@ describe 'querying' do
       expect(countries.length).to be == 2
     end
 
+    it 'can combine indices' do
+      countries = Country.where(name: 'France', continent: 'Europe')
+      expect(countries.length).to be == 1
+    end
+
+    it 'can use indices with inclusion query' do
+      countries = Country.where(continent: ['Europe', 'North America'])
+      expect(countries.length).to be == 3
+
+      countries = Country.where(name: ['France', 'Canada'])
+      expect(countries.length).to be == 2
+    end
   end
 
   describe '.where.not' do
@@ -428,8 +440,8 @@ describe 'querying' do
     it 'returns true when the same scope has be rechained' do
       scope_a = Country.nato.republics.nato.republics
       scope_b = Country.republics.nato
-      expect(scope_a.instance_variable_get(:@where_values)).to be == [[:nato, true ], [:king, nil ], [:nato, true], [:king, nil]]
-      expect(scope_b.instance_variable_get(:@where_values)).to be == [[:king, nil ], [:nato, true]]
+      expect(scope_a.instance_variable_get(:@where_values)).to be == [['nato', true], ['king', nil], ['nato', true], ['king', nil]]
+      expect(scope_b.instance_variable_get(:@where_values)).to be == [['king', nil], ['nato', true]]
       expect(scope_a).to be == scope_b
     end
   end

data/spec/support/country.rb

@@ -1,6 +1,9 @@
 class Country < FrozenRecord::Base
   self.default_attributes = { contemporary: true, available: true }
 
+  add_index :name, unique: true
+  add_index :continent
+
   def self.republics
     where(king: nil)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frozen_record
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.4
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -119,6 +119,7 @@ files:
 - lib/frozen_record/base.rb
 - lib/frozen_record/compact.rb
 - lib/frozen_record/deduplication.rb
+- lib/frozen_record/index.rb
 - lib/frozen_record/railtie.rb
 - lib/frozen_record/scope.rb
 - lib/frozen_record/test_helper.rb