torque-postgresql 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4fac19ef8680f477df0f79502331ddda06266658a54c8128321d68145a9f18b
-  data.tar.gz: 0e93ec49f80d40ec9ce9b7fcc5ef0eff65a882cad79a63e5429657ad9c66691b
+  metadata.gz: dc0fe29b7ec2c1478b6718efaddbb7ba2be2c6fd18dc56dc5e52ca52575811dd
+  data.tar.gz: b1f7c28054bb9ed68ebc2506ca71cb0d4c42563102438f39202d638278d45ee9
 SHA512:
-  metadata.gz: 4a9abd492b544296c29e0949e1ad0ad4852a1ed0c48379551e5ffbbaad7018579cad994ac2a841231603bdddd8da4b448d7771a9086312289f818124d842d6a6
-  data.tar.gz: 8019255d20eff471ed177078e1bd6042a0a9b95752d32578bdb8ce86afdf9cffbefa8ed181caab0143f0dbbf80cfc39c99fd005cfc2b28089687b26a635268ef
+  metadata.gz: a13fa4357d31fed2106ebcef94ff51decb7003e30a1f0a2fe5af83ceb3d18cc7d909fcf1c6f65ea63c7c11eccb1e312d7c85ff66d16125d50bd10b1e1772ab14
+  data.tar.gz: 7f2a2951c337e2326ad0c808423f6017b11086538a8bcd0b40078729e26b02232f7b97c39de96ab70e81c5eac5382ce7f0aff9965e4fbd36571b4b89bcdcbcab

data/lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -40,34 +40,29 @@ module Torque
           result
         end
 
-        # Build the id constraint checking if both types are perfect matching
+        # Build the id constraint checking if both types are perfect matching.
+        # The klass attribute (left side) will always be a column attribute
         def build_id_constraint(klass_attr, source_attr)
           return klass_attr.eq(source_attr) unless connected_through_array?
 
           # Klass and key are associated with the reflection Class
-          klass_type = klass.columns_hash[join_primary_key.to_s]
-          # active_record and foreign_key are associated with the source Class
-          source_type = active_record.columns_hash[join_foreign_key.to_s]
-
-          # If both are attributes but the left side is not an array, and the
-          # right side is, use the ANY operation
-          any_operation = arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
-          return klass_attr.eq(any_operation) if any_operation
+          klass_type = klass.columns_hash[join_keys.key.to_s]
+
+          # Apply an ANY operation which checks if the single value on the left
+          # side exists in the array on the right side
+          if source_attr.is_a?(AREL_ATTR)
+            any_value = [klass_attr, source_attr]
+            any_value.reverse! if klass_type.try(:array?)
+            return any_value.shift.eq(::Arel::Nodes::NamedFunction.new('ANY', any_value))
+          end
 
           # If the left side is not an array, just use the IN condition
           return klass_attr.in(source_attr) unless klass_type.try(:array)
 
-          # Decide if should apply a cast to ensure same type comparision
-          should_cast = klass_type.type.eql?(:integer) && source_type.type.eql?(:integer)
-          should_cast &= !klass_type.sql_type.eql?(source_type.sql_type)
-          should_cast |= !(klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR))
-
-          # Apply necessary transformations to values
-          klass_attr = cast_constraint_to_array(klass_type, klass_attr, should_cast)
-          source_attr = cast_constraint_to_array(source_type, source_attr, should_cast)
-
-          # Return the overlap condition
-          klass_attr.overlaps(source_attr)
+          # Build the overlap condition (array && array) ensuring that the right
+          # side has the same type as the left side
+          source_attr = ::Arel::Nodes.build_quoted(Array.wrap(source_attr))
+          klass_attr.overlaps(source_attr.cast(klass_type.sql_type_metadata.sql_type))
         end
 
         # TODO: Deprecate this method
@@ -83,24 +78,6 @@ module Torque
 
             build_id_constraint(klass_attr, source_attr)
           end
-
-          # Prepare a value for an array constraint overlap condition
-          def cast_constraint_to_array(type, value, should_cast)
-            base_ready = type.try(:array) && value.is_a?(AREL_ATTR)
-            return value if base_ready && (type.sql_type.eql?(ARR_NO_CAST) || !should_cast)
-
-            value = ::Arel::Nodes.build_quoted(Array.wrap(value)) unless base_ready
-            value = value.cast(ARR_CAST) if should_cast
-            value
-          end
-
-          # Check if it's possible to turn both attributes into an ANY condition
-          def arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
-            return unless !klass_type.try(:array) && source_type.try(:array) &&
-              klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR)
-
-            ::Arel::Nodes::NamedFunction.new('ANY', [source_attr])
-          end
       end
 
       ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.0.0'
+    VERSION = '3.0.1'
   end
 end

data/spec/spec_helper.rb

@@ -39,6 +39,7 @@ RSpec.configure do |config|
 
   # Handles acton before rspec initialize
   config.before(:suite) do
+    ActiveSupport::Deprecation.silenced = true
     DatabaseCleaner.clean_with(:truncation)
   end
 

data/spec/tests/belongs_to_many_spec.rb

@@ -393,4 +393,51 @@ RSpec.describe 'BelongsToMany' do
       end
     end
   end
+
+  context 'using uuid' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:game) { Class.new(ActiveRecord::Base) }
+    let(:player) { Class.new(ActiveRecord::Base) }
+    let(:other) { player.create }
+
+    # TODO: Set as a shred example
+    before do
+      connection.create_table(:players, id: :uuid) { |t| t.string :name }
+      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
+
+      game.table_name = 'games'
+      player.table_name = 'players'
+      game.belongs_to_many :players, anonymous_class: player,
+        inverse_of: false, foreign_key: :player_ids
+    end
+
+    subject { game.create }
+
+    it 'loads associated records' do
+      subject.update(player_ids: [other.id])
+      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
+        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
+      SQL
+
+      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.players.to_a).to be_eql([other])
+    end
+
+    it 'can preload records' do
+      records = 5.times.map { player.create }
+      subject.players.concat(records)
+
+      entries = game.all.includes(:players).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.players).to be_loaded
+      expect(entries.first.players.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = game.all.joins(:players)
+      expect(query.to_sql).to match(/INNER JOIN "players"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
 end

data/spec/tests/has_many_spec.rb

@@ -411,4 +411,48 @@ RSpec.describe 'HasMany' do
       expect { query.load }.not_to raise_error
     end
   end
+
+  context 'using uuid' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:game) { Class.new(ActiveRecord::Base) }
+    let(:player) { Class.new(ActiveRecord::Base) }
+
+    # TODO: Set as a shred example
+    before do
+      connection.create_table(:players, id: :uuid) { |t| t.string :name }
+      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
+
+      game.table_name = 'games'
+      player.table_name = 'players'
+      player.has_many :games, array: true, anonymous_class: game,
+        inverse_of: false, foreign_key: :player_ids
+    end
+
+    subject { player.create }
+
+    it 'loads associated records' do
+      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
+        SELECT "games"\\.\\* FROM "games"
+        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
+      SQL
+
+      expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.games.to_a).to be_eql([])
+    end
+
+    it 'can preload records' do
+      5.times { game.create(player_ids: [subject.id]) }
+      entries = player.all.includes(:games).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.games).to be_loaded
+      expect(entries.first.games.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = player.all.joins(:games)
+      expect(query.to_sql).to match(/INNER JOIN "games"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Carlos Silva
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-04 00:00:00.000000000 Z
+date: 2022-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails