hoodoo 1.1.2 → 1.1.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGUwNzBiZDE0NDVjYjljNDM0MzNjYzYzMjYxMWY0MzhhYmY4NTI2OQ==
+    NWM1MTMyZWRmNGNkZDExY2IyYThiYjdhZDA2OGJmNWFiNTY2NDY4ZA==
   data.tar.gz: !binary |-
-    YmUxY2FiOWQzMDY1ZmEwZGM1NzYxM2YzNDVjYzFhNWE2N2FmNDZmNA==
+    N2YwMGE5ODIxNmFiNzEzMDc4YjE3YTk1ZWZiOTk2ODJhNTJmNjFhOQ==
 SHA512:
   metadata.gz: !binary |-
-    YjJkZGJkMTM4MmM5ZWNhYmQxOWI3Y2JkYzdmN2I3OGFjZTU4OGQ4MDY3MDI0
-    MWYwZGI5MDIzZDNmYjI2ZTJiNzE4ZmU3MjNkZDM5YjA0ZjU1ODA1OTM1MzA0
-    OWNmYjFlNjRlZTVjZThiMWIxNTJlZTA1NzU0MTQ1Y2U5NDFhMTA=
+    MmY2ODExNTRkZmJiYThmN2MyNGFkYTk0MjU4YjBhMzFkMTExZmU2YmNiMDNk
+    MjAwYzQ4NzRiM2FlMTA5NjQxNjdlMzM3OTA3YzQ3NzA2N2FlMTRhYTI4OGY4
+    NWUzNjFlNTE4NjdiNmE4YzMwYmZmMTJkZTg4NTdiZWVlYTVkODg=
   data.tar.gz: !binary |-
-    MDdmOTMyNTVhMGZiZDAxMzkyNDE1OGQ3MTIxNTJiMzViZWQ2MGJhMTUzYjRh
-    MGEwMWM1M2EyZTI3MWVlZTA5ZTE4ZjkwN2M5OGRiZDBlMTY3NjE3M2JhNTYw
-    NWQ5ZTYyN2EzODI2MWVmODBmMmQ4YzMyMDMyZjQ0OTc1MDdjMGI=
+    ZjViMjVmM2FjMzY5YzBmYTU2NTljM2FiMjAwNWU3OTRiYzZhZjdiMmMzNzgz
+    MmE2ZmNjYWE2NTA4MGU4ODkwNjhlOTI0OGRlNjQ5ZjM1ZjIxYTI0ZjA5YWMz
+    ZGQ1OWIyYzNhMzBmZTU4Njk2Nzc0YmJjNWI4OGNhYmY4NDIwNjY=

data/lib/hoodoo/active/active_record/finder.rb

@@ -152,48 +152,7 @@ module Hoodoo
         # Returns a found model instance or +nil+ for no match.
         #
         def acquire( ident )
-          extra_fields = self.acquired_with()
-
-          id_fields = [ :id ] + extra_fields
-          id_fields.each do | field |
-
-            # This is fiddly.
-            #
-            # You must use a string with field substitution approach, rather
-            # than e.g. ".where( :field => :ident )". AREL/ActiveRecord will,
-            # in the latter case, compose rational SQL based on column data
-            # types. If you have an *integer* ID field, then, it'll try to
-            # convert a *string* ident to an integer. This can give Hilarious
-            # Consequences. Consider looking up on (integer) field "id" or
-            # (text) field "uuid", with a string ident of "1f294942..." - the
-            # text UUID would be fine, but the integer ID may end up with the
-            # UUID being "to_i"'d, yielding integer 1. If the ID field is
-            # looked at first, you're highly likely to find the wrong record.
-            #
-            # The solution is, as written, simple; just use the substitution
-            # approach rather than higher level AREL, causing a string-like SQL
-            # query on all adapters which SQL handles just fine for varying
-            # field data types.
-            #
-            # The caveat is that should the database object to mismatched type
-            # comparisons it will actually raise an error - we see this on
-            # for example PostgreSQL where a column is an integer but we try
-            # to match it against a string that cannot be cleanly converted to
-            # one (e.g. trying to find an integer column 'id' based on a text
-            # UUID value containing alphabetic characters). That is still
-            # preferable to looking up the wrong record!
-
-            checker = where( [ "\"#{ self.table_name }\".\"#{ field }\" = ?", ident ] )
-
-            # If we have found a record return it, otherwise continue to loop
-            # through +id_fields+
-            #
-            if checker.first
-              return checker.first
-            end
-          end
-
-          return nil
+          return acquisition_scope( ident ).first
         end
 
         # Implicily secure, translated, dated etc. etc. version of #acquire,
@@ -294,6 +253,31 @@ module Hoodoo
           self.nz_co_loyalty_hoodoo_show_id_fields || []
         end
 
+        # Back-end to #acquire and therefore, in turn, #acquire_in. Returns
+        # an ActiveRecord::Relation instance which scopes the search for a
+        # record by +id+ and across any other columns specified by
+        # #acquire_with, via SQL +OR+.
+        #
+        # Normally such a scope could only ever return a single record based
+        # on an assuption of uniqueness constraints around columns which one
+        # might use in an equivalent of a +find+ call. In some instances
+        # however - e.g. a table that contains historic representations of a
+        # model as well as its 'current' representation - there may be more
+        # than one result and the returned value from this method may need to
+        # be chained in with other scopes to form a useful query.
+        #
+        def acquisition_scope( ident )
+          extra_fields = self.acquired_with()
+          arel_table   = self.arel_table()
+          arel_query   = arel_table[ :id ].eq( ident )
+
+          extra_fields.each do | field |
+            arel_query = arel_query.or( arel_table[ field ].eq( ident ) )
+          end
+
+          return where( arel_query )
+        end
+
         # Generate an ActiveRecord::Relation instance which can be used to
         # count, retrieve or further refine a list of model instances from
         # the database.

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
 
 end

data/spec/active/active_record/finder_spec.rb

@@ -154,47 +154,50 @@ describe Hoodoo::ActiveRecord::Finder do
       expect( found ).to eq(nil) # Not in 'group 1'
     end
 
-    # previously the finder would always cause an extra
-    # call to the database to preform a count
+    # Early versions of the 'acquire'-backed methods always inadvertently
+    # performed two database calls, via a count then a true find. This was
+    # refactored to only make one call per attribute, but that in turn can
+    # be much improved via the AREL table to compose a single query that
+    # uses "OR" to get the database to check each attribute in order. Thus
+    # every test below expects exactly one database call only.
     #
-    it 'does not do excessive database calls' do
+    context 'only makes one database call when' do
 
-      count = count_database_calls_in do
-        found = RSpecModelFinderTest.acquire( @id )
-        expect( found ).to eq(@a)
-      end
-      # the id will be the first searched in the finder
-      #  therefore only one call will be made
-      expect( count ).to eq( 1 )
+      it 'finding on the first attribute' do
+        count = count_database_calls_in do
+          found = RSpecModelFinderTest.acquire( @id )
+          expect( found ).to eq(@a)
+        end
 
-      count = count_database_calls_in do
-        found = RSpecModelFinderTest.acquire( @uuid )
-        expect( found ).to eq(@b)
+        expect( count ).to eq( 1 )
       end
 
-      # the uuid will be the second searched in the finder
-      #  therefore two calls will be made, one for the
-      #  id and one for the uuid
-      expect( count ).to eq( 2 )
+      it 'finding on the second attribute' do
+        count = count_database_calls_in do
+          found = RSpecModelFinderTest.acquire( @uuid )
+          expect( found ).to eq(@b)
+        end
 
-      count = count_database_calls_in do
-        found = RSpecModelFinderTest.acquire( @code )
-        expect( found ).to eq(@c)
+        expect( count ).to eq( 1 )
       end
 
-      # the code will be the third searched in the finder
-      #  therefore three calls will be made, one for the
-      #  id, one for the uuid and one for the code
-      expect( count ).to eq( 3 )
-
+      it 'finding on the third attribute' do
+        count = count_database_calls_in do
+          found = RSpecModelFinderTest.acquire( @code )
+          expect( found ).to eq(@c)
+        end
 
-      count = count_database_calls_in do
-        found = RSpecModelFinderTest.acquire( Hoodoo::UUID.generate )
-        expect( found ).to be_nil
+        expect( count ).to eq( 1 )
       end
 
-      # the finder will search all three
-      expect( count ).to eq( 3 )
+      it 'checking all three attributes but finding nothing' do
+        count = count_database_calls_in do
+          found = RSpecModelFinderTest.acquire( Hoodoo::UUID.generate )
+          expect( found ).to be_nil
+        end
+
+        expect( count ).to eq( 1 )
+      end
     end
   end
 
@@ -347,6 +350,23 @@ describe Hoodoo::ActiveRecord::Finder do
 
   # ==========================================================================
 
+  context 'acquisition_scope' do
+    it 'SQL generation is as expected' do
+      sql = RSpecModelFinderTest.acquisition_scope( @id ).to_sql()
+      expect( sql ).to eq( "SELECT \"r_spec_model_finder_tests\".* "<<
+                           "FROM \"r_spec_model_finder_tests\" " <<
+                           "WHERE (" <<
+                             "(" <<
+                               "\"r_spec_model_finder_tests\".\"id\" = '#{ @id }' OR " <<
+                               "\"r_spec_model_finder_tests\".\"uuid\" = '#{ @id }'" <<
+                             ") OR " <<
+                             "\"r_spec_model_finder_tests\".\"code\" = '#{ @id }'" <<
+                           ")" )
+    end
+  end
+
+  # ==========================================================================
+
   context 'lists' do
     it 'lists with pages, offsets and counts' do
       @list_params.offset = 1 # 0 is first record

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools