Merge pull request rails#47729 from Shopify/pm/cpk-where-syntax

Introduce query-by-tuple syntax

Author: eileencodes

activerecord/CHANGELOG.md

@@ -1,3 +1,26 @@
+*   Allow specifying where clauses with column-tuple syntax.
+
+    Querying through `#where` now accepts a new tuple-syntax which accepts, as
+    a key, an array of columns and, as a value, an array of corresponding tuples.
+    The key specifies a list of columns, while the value is an array of
+    ordered-tuples that conform to the column list.
+
+    For instance:
+
+    ```ruby
+    # Cpk::Book => Cpk::Book(author_id: integer, number: integer, title: string, revision: integer)
+    # Cpk::Book.primary_key => ["author_id", "number"]
+
+    book = Cpk::Book.create!(author_id: 1, number: 1)
+    Cpk::Book.where(Cpk::Book.primary_key => [[1, 2]]) # => [book]
+
+    # Topic => Topic(id: integer, title: string, author_name: string...)
+
+    Topic.where([:title, :author_name] => [["The Alchemist", "Paul Coelho"], ["Harry Potter", "J.K Rowling"]])
+    ```
+
+    *Paarth Madan*
+
 *   Allow warning codes to be ignore when reporting SQL warnings.
 
     Active Record config that can ignore warning codes

activerecord/lib/active_record/destroy_association_async_job.rb

@@ -23,15 +23,8 @@ def perform(
         raise DestroyAssociationAsyncError, "owner record not destroyed"
       end
 
-      if association_model.query_constraints_list
-        association_ids
-          .map { |assoc_ids| association_model.where(association_primary_key_column.zip(assoc_ids).to_h) }
-          .inject(&:or)
-          .find_each { |r| r.destroy }
-      else
-        association_model.where(association_primary_key_column => association_ids).find_each do |r|
-          r.destroy
-        end
+      association_model.where(association_primary_key_column => association_ids).find_each do |r|
+        r.destroy
       end
     end
 

activerecord/lib/active_record/encryption/extended_deterministic_queries.rb

@@ -44,7 +44,13 @@ def process_arguments(owner, args, check_for_additional_values)
             return args if owner.deterministic_encrypted_attributes&.empty?
 
             if args.is_a?(Array) && (options = args.first).is_a?(Hash)
-              options = options.stringify_keys
+              options = options.transform_keys do |key|
+                if key.is_a?(Array)
+                  key.map(&:to_s)
+                else
+                  key.to_s
+                end
+              end
               args[0] = options
 
               owner.deterministic_encrypted_attributes&.each do |attribute_name|

activerecord/lib/active_record/relation/predicate_builder.rb

@@ -78,7 +78,13 @@ def expand_from_hash(attributes, &block)
         return ["1=0"] if attributes.empty?
 
         attributes.flat_map do |key, value|
-          if value.is_a?(Hash) && !table.has_column?(key)
+          if key.is_a?(Array)
+            queries = Array(value).map do |ids_set|
+              raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+              expand_from_hash(key.zip(ids_set).to_h)
+            end
+            grouping_queries(queries)
+          elsif value.is_a?(Hash) && !table.has_column?(key)
             table.associated_table(key, &block)
               .predicate_builder.expand_from_hash(value.stringify_keys)
           elsif table.associated_with?(key)

activerecord/lib/active_record/relation/query_methods.rb

@@ -1476,8 +1476,12 @@ def build_where_clause(opts, rest = []) # :nodoc:
           parts = [klass.sanitize_sql(rest.empty? ? opts : [opts, *rest])]
         when Hash
           opts = opts.transform_keys do |key|
-            key = key.to_s
-            klass.attribute_aliases[key] || key
+            if key.is_a?(Array)
+              key.map { |k| klass.attribute_aliases[k.to_s] || k.to_s }
+            else
+              key = key.to_s
+              klass.attribute_aliases[key] || key
+            end
           end
           references = PredicateBuilder.references(opts)
           self.references_values |= references unless references.empty?

activerecord/test/cases/primary_keys_test.rb

@@ -386,6 +386,10 @@ def test_assigning_a_composite_primary_key
     book.save!
 
     assert_equal [1, 2], book.id
+    assert_equal 1, book.author_id
+    assert_equal 2, book.number
+  ensure
+    Cpk::Book.delete_all
   end
 
   def test_assigning_a_non_array_value_to_model_with_composite_primary_key_raises

activerecord/test/cases/relation/where_test.rb

@@ -16,6 +16,7 @@
 require "models/topic"
 require "models/treasure"
 require "models/vertex"
+require "models/cpk"
 require "support/stubs/strong_parameters"
 
 module ActiveRecord
@@ -95,6 +96,53 @@ def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
 
+    def test_where_with_tuple_syntax
+      first_topic = topics(:first)
+      third_topic = topics(:third)
+
+      key = [:title, :author_name]
+
+      conditions = [
+        [first_topic.title, first_topic.author_name],
+        [third_topic.title, third_topic.author_name],
+      ]
+
+      assert_equal [first_topic], Topic.where([:id] => [[first_topic.id]])
+      assert_equal [first_topic, third_topic].sort, Topic.where(key => conditions).sort
+    end
+
+    def test_where_with_tuple_syntax_on_composite_models
+      book_one = Cpk::Book.create!(author_id: 1, number: 2)
+      book_two = Cpk::Book.create!(author_id: 3, number: 4)
+
+      assert_equal [book_one], Cpk::Book.where([:author_id, :number] => [[1, 2]])
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(Cpk::Book.primary_key => [[1, 2], [3, 4]]).sort
+      assert_empty Cpk::Book.where([:author_id, :number] => [[1, 4], [3, 2]])
+    end
+
+    def test_where_with_tuple_syntax_with_incorrect_arity
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one, :two, :three] => [1, 2, 3])
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+
+      error = assert_raise ArgumentError do
+        Cpk::Book.where([:one] => 1)
+      end
+
+      assert_match(/Expected corresponding value for.*to be an Array/, error.message)
+    end
+
+    def test_where_with_tuple_syntax_and_regular_syntax_combined
+      book_one = Cpk::Book.create!(author_id: 1, number: 2, title: "The Alchemist")
+      book_two = Cpk::Book.create!(author_id: 3, number: 4, title: "The Alchemist")
+
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist").sort
+      assert_equal [book_one, book_two].sort, Cpk::Book.where(title: "The Alchemist", [:author_id, :number] => [[1, 2], [3, 4]]).sort
+      assert_equal [book_two], Cpk::Book.where(title: "The Alchemist", [:author_id, :number] => [[3, 4]])
+    end
+
     def test_belongs_to_shallow_where
       author = Author.new
       author.id = 1