active_record_extended 0.7.0 → 1.0.0

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -49,7 +49,7 @@ module ActiveRecordExtended
         when Arel::Nodes::In, Arel::Nodes::Equality
           column = left_column(arel) || column_from_association(arel)
 
-          if %i[hstore jsonb].include?(column.type)
+          if [:hstore, :jsonb].include?(column.type)
             Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
           elsif column.try(:array)
             Arel::Nodes::ContainsArray.new(arel.left, arel.right)

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -2,16 +2,6 @@
 
 module ActiveRecordExtended
   module QueryMethods
-    module MergerCTE
-      def normal_values
-        super + [:with]
-      end
-    end
-
-    module QueryDelegationCTE
-      delegate :with, to: :all
-    end
-
     module WithCTE
       class WithChain
         def initialize(scope)
@@ -59,12 +49,6 @@ module ActiveRecordExtended
         self
       end
 
-      def build_arel(*aliases)
-        super.tap do |arel|
-          build_with(arel) if with_values?
-        end
-      end
-
       def build_with_hashed_value(with_value)
         with_value.map do |name, expression|
           select =
@@ -97,5 +81,3 @@ module ActiveRecordExtended
 end
 
 ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::WithCTE)
-ActiveRecord::Relation::Merger.prepend(ActiveRecordExtended::QueryMethods::MergerCTE)
-ActiveRecord::Querying.prepend(ActiveRecordExtended::QueryMethods::QueryDelegationCTE)

data/lib/active_record_extended/utilities.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module Utilities
+    A_TO_Z_KEYS = ("a".."z").to_a.freeze
+
+    # We need to ensure we can flatten nested ActiveRecord::Relations
+    # that might have been nested due to the (splat)*args parameters
+    #
+    # Note: calling `Array.flatten[!]/1` will actually remove all AR relations from the array.
+    #
+    def flatten_to_sql(*values)
+      flatten_safely(values) do |value|
+        value = yield value if block_given?
+        to_arel_sql(value)
+      end
+    end
+    alias to_sql_array flatten_to_sql
+
+    def flatten_safely(values, &block)
+      unless values.is_a?(Array)
+        values = yield values if block_given?
+        return [values]
+      end
+
+      values.map { |value| flatten_safely(value, &block) }.reduce(:+)
+    end
+
+    # Applies aliases to the given query
+    # Ex: `SELECT * FROM users` => `(SELECT * FROM users) AS "members"`
+    def nested_alias_escape(query, alias_name)
+      sql_query = Arel::Nodes::Grouping.new(to_arel_sql(query))
+      Arel::Nodes::As.new(sql_query, to_arel_sql(double_quote(alias_name)))
+    end
+
+    # Wraps subquery into an Aliased ARRAY
+    # Ex: `SELECT * FROM users` => (ARRAY(SELECT * FROM users)) AS "members"
+    def wrap_with_array(arel_or_rel_query, alias_name)
+      query = Arel::Nodes::NamedFunction.new("ARRAY", to_sql_array(arel_or_rel_query))
+      nested_alias_escape(query, alias_name)
+    end
+
+    # Will attempt to digest and resolve the from clause
+    #
+    # If the from clause is a String, it will check to see if a table reference key has been assigned.
+    #   - If one cannot be detected, one will be appended.
+    #   - Rails does not allow assigning table references using the `.from/2` method, when its a string / sym type.
+    #
+    # If the from clause is an AR relation; it will duplicate the object.
+    #   - Ensures any memorizers are reset (ex: `.to_sql` sets a memorizer on the instance)
+    #   - Key's can be assigned using the `.from/2` method.
+    #
+    def from_clause_constructor(from, reference_key)
+      case from
+      when /\s.?#{reference_key}.?$/ # The from clause is a string and has the tbl reference key
+        @scope.unscoped.from(from)
+      when String, Symbol
+        @scope.unscoped.from("#{from} #{reference_key}")
+      else
+        replicate_klass = from.respond_to?(:unscoped) ? from.unscoped : @scope.unscoped
+        replicate_klass.from(from.dup, reference_key)
+      end
+    end
+
+    # Will carry defined CTE tables from the nested sub-query and gradually pushes it up to the parents query stack
+    # I.E: It pushes `WITH [:cte_name:] AS(...), ..` to the top of the query structure tree
+    #
+    # SPECIAL GOTCHA NOTE: (if duplicate keys are found) This will favor the parents query `with's` over nested ones!
+    def pipe_cte_with!(subquery)
+      return self unless subquery.try(:with_values?)
+
+      cte_ary              = flatten_safely(subquery.with_values)
+      subquery.with_values = nil # Remove nested queries with values
+
+      # Add subquery's CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+      if @scope.with_values?
+        # combine top-level and lower level queries `.with` values into 1 structure
+        with_hash = cte_ary.each_with_object(@scope.with_values.first) do |from_cte, hash|
+          hash.reverse_merge!(from_cte)
+        end
+
+        @scope.with_values = [with_hash]
+      else
+        # Top level has no with values
+        @scope.with!(*cte_ary)
+      end
+
+      self
+    end
+
+    # Ensures the given value is properly double quoted.
+    # This also ensures we don't have conflicts with reversed keywords.
+    #
+    # IE: `user` is a reserved keyword in PG. But `"user"` is allowed and works the same
+    #     when used as an column/tbl alias.
+    def double_quote(value)
+      return if value.nil?
+
+      case value.to_s
+      when "*", /^".+"$/ # Ignore keys that contain double quotes or a Arel.star (*)[all columns]
+        value
+      else
+        PG::Connection.quote_ident(value.to_s)
+      end
+    end
+
+    # Ensures the key is properly single quoted and treated as a actual PG key reference.
+    def literal_key(key)
+      case key
+      when TrueClass  then "'t'"
+      when FalseClass then "'f'"
+      when Numeric    then key
+      else
+        key = key.to_s
+        key.start_with?("'") && key.end_with?("'") ? key : "'#{key}'"
+      end
+    end
+
+    # Converts a potential subquery into a compatible Arel SQL node.
+    #
+    # Note:
+    # We convert relations to SQL to maintain compatibility with Rails 5.[0/1].
+    # Only Rails 5.2+ maintains bound attributes in Arel, so its better to be safe then sorry.
+    # When we drop support for Rails 5.[0/1], we then can then drop the '.to_sql' conversation
+
+    def to_arel_sql(value)
+      case value
+      when Arel::Node, Arel::Nodes::SqlLiteral, nil
+        value
+      when ActiveRecord::Relation
+        Arel.sql(value.spawn.to_sql)
+      else
+        Arel.sql(value.respond_to?(:to_sql) ? value.to_sql : value.to_s)
+      end
+    end
+
+    def key_generator
+      A_TO_Z_KEYS.sample
+    end
+  end
+end

data/lib/active_record_extended/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  VERSION = "0.7.0"
+  VERSION = "1.0.0"
 end

data/spec/query_methods/inet_query_spec.rb

@@ -3,17 +3,6 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Inet Query Methods" do
-  describe "Deprecation Notices" do
-    %i[contained_within contained_within_or_equals contains_or_equals].each do |method|
-      it "Should display a deprecation warning for #{method}" do
-        new_method  = "inet_#{method}".to_sym
-        warning_msg = "##{method} will soon be deprecated for version 1.0 release. Please use ##{new_method} instead."
-        expect_any_instance_of(ActiveRecordExtended::QueryMethods::Inet).to receive(new_method)
-        expect { Person.where.send(method, nil) }.to output(Regexp.new(warning_msg)).to_stderr
-      end
-    end
-  end
-
   describe "#inet_contained_within" do
     let!(:local_1)     { Person.create!(ip: "127.0.0.1") }
     let!(:local_44)    { Person.create!(ip: "127.0.0.44") }

data/spec/query_methods/json_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+RSpec.describe "Active Record JSON methods" do
+  let!(:person_one) { Person.create! }
+  let!(:person_two) { Person.create! }
+
+  describe ".select_row_to_json" do
+    let!(:tag_one)    { Tag.create!(person: person_one, tag_number: 2) }
+    let!(:tag_two)    { Tag.create!(person: person_two, tag_number: 5) }
+    let(:sub_query)   { Tag.select(:tag_number).where("tags.person_id = people.id") }
+
+    it "should nest a json object in the query results" do
+      query = Person.select(:id).select_row_to_json(sub_query, as: :results).where(id: person_one.id)
+      expect(query.size).to eq(1)
+      expect(query.take.results).to be_a(Hash).and(match("tag_number" => 2))
+    end
+
+    # ugh wording here sucks, brain is fried.
+    it "accepts a block for appending additional scopes to the middle-top level" do
+      query = Person.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do |scope|
+        scope.where("tag_row.tag_number = 5")
+      end
+
+      expect(query.size).to eq(2)
+      query.each do |result|
+        if result.id == person_one.id
+          expect(result.results).to be_blank
+        else
+          expect(result.results).to be_present.and(match("tag_number" => 5))
+        end
+      end
+    end
+
+    it "allows for casting results in an aggregate-able Array function" do
+      query = Person.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_as_array: true)
+      expect(query.take.results).to be_a(Array).and(be_present)
+      expect(query.take.results.first).to be_a(Hash)
+    end
+
+    it "raises an error if a from clause key is missing" do
+      expect do
+        Person.select(:id).select_row_to_json(key: :tag_row, as: :results)
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ".json_build_object" do
+    let(:sub_query) do
+      Person.select_row_to_json(from: Person.select(:id), cast_as_array: true, as: :ids).where(id: person_one.id)
+    end
+
+    it "defaults the column alias if one is not provided" do
+      query = Person.json_build_object(:personal, sub_query)
+      expect(query.size).to eq(1)
+      expect(query.take.results).to match(
+        "personal" => match("ids" => match_array([{ "id" => person_one.id }, { "id" => person_two.id }])),
+      )
+    end
+
+    it "allows for re-aliasing the default 'results' column" do
+      query = Person.json_build_object(:personal, sub_query, as: :cool_dudes)
+      expect(query.take).to respond_to(:cool_dudes)
+    end
+  end
+
+  describe ".jsonb_build_object" do
+    let(:sub_query) { Person.select(:id, :number).where(id: person_one.id) }
+
+    it "defaults the column alias if one is not provided" do
+      query = Person.jsonb_build_object(:personal, sub_query)
+      expect(query.size).to eq(1)
+      expect(query.take.results).to be_a(Hash).and(be_present)
+      expect(query.take.results).to match("personal" => match("id" => person_one.id, "number" => person_one.number))
+    end
+
+    it "allows for re-aliasing the default 'results' column" do
+      query = Person.jsonb_build_object(:personal, sub_query, as: :cool_dudes)
+      expect(query.take).to respond_to(:cool_dudes)
+    end
+
+    it "allows for custom value statement" do
+      query = Person.jsonb_build_object(
+        :personal,
+        sub_query.where.not(id: person_one),
+        value: "COALESCE(array_agg(\"personal\"), '{}')",
+        as:    :cool_dudes,
+      )
+
+      expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
+    end
+
+    it "will raise a warning if the value doesn't include a double quoted input" do
+      expect do
+        Person.jsonb_build_object(
+          :personal,
+          sub_query.where.not(id: person_one),
+          value: "COALESCE(array_agg(personal), '{}')",
+          as:    :cool_dudes,
+        )
+      end.to output.to_stderr
+    end
+  end
+
+  describe "Json literal builds" do
+    let(:original_hash)      { { p: 1, b: "three", x: 3.14 } }
+    let(:hash_as_array_objs) { original_hash.to_a.flatten }
+
+    shared_examples_for "literal builds" do
+      let(:method) { raise "You are expected to over ride this!" }
+
+      it "will accept a hash arguments that will return itself" do
+        query = Person.send(method.to_sym, original_hash)
+        expect(query.take.results).to be_a(Hash).and(be_present)
+        expect(query.take.results).to match(original_hash.stringify_keys)
+      end
+
+      it "will accept a standard array of key values" do
+        query = Person.send(method.to_sym, hash_as_array_objs)
+        expect(query.take.results).to be_a(Hash).and(be_present)
+        expect(query.take.results).to match(original_hash.stringify_keys)
+      end
+
+      it "will accept a splatted array of key-values" do
+        query = Person.send(method.to_sym, *hash_as_array_objs)
+        expect(query.take.results).to be_a(Hash).and(be_present)
+        expect(query.take.results).to match(original_hash.stringify_keys)
+      end
+    end
+
+    describe ".json_build_literal" do
+      it_behaves_like "literal builds" do
+        let!(:method) { :json_build_literal }
+      end
+    end
+
+    describe ".jsonb_build_literal" do
+      it_behaves_like "literal builds" do
+        let!(:method) { :jsonb_build_literal }
+      end
+    end
+  end
+end

data/spec/query_methods/unionize_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Union Methods" do
+  let!(:person_one)     { Person.create!(number: 8) }
+  let!(:person_two)     { Person.create!(number: 10) }
+  let!(:person_three)   { Person.create!(number: 1) }
+  let!(:person_one_pl)  { ProfileL.create!(person: person_one, likes: 100) }
+  let!(:person_two_pl)  { ProfileL.create!(person: person_two, likes: 200) }
+
+  shared_examples_for "standard set of errors" do
+    let(:person_one_query)  { Person.select(:id).where(id: person_one.id) }
+    let(:person_two_query)  { Person.select(:id, :tags).where(id: person_two.id) }
+    let(:misaligned_cmd)    { raise("required to override this 'let' statement") }
+    let(:lacking_union_cmd) { raise("required to override this 'let' statement") }
+
+    it "should raise an error if the select statements do not align" do
+      expect { misaligned_cmd.to_a }.to(
+        raise_error(ActiveRecord::StatementInvalid, /each [[:alpha:]]+ query must have the same number of columns/),
+      )
+    end
+
+    it "should raise an argument error if there are less then two union statements" do
+      expect { lacking_union_cmd.to_a }.to(
+        raise_error(ArgumentError, "You are required to provide 2 or more unions to join!"),
+      )
+    end
+  end
+
+  describe ".union" do
+    it_behaves_like "standard set of errors" do
+      let!(:misaligned_cmd)    { Person.union(person_one_query, person_two_query) }
+      let!(:lacking_union_cmd) { Person.union(person_one_query) }
+    end
+
+    it "should return two users that match the where conditions" do
+      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id))
+      expect(query).to match_array([person_one, person_three])
+    end
+
+    it "should allow joins on union statements" do
+      query = Person.union(Person.where(id: person_one.id), Person.joins(:profile_l).where.not(id: person_one.id))
+      expect(query).to match_array([person_one, person_two])
+    end
+
+    it "should eliminate duplicate results" do
+      expected_ids = Person.pluck(:id)
+      query        = Person.union(Person.select(:id), Person.select(:id))
+      expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
+    end
+  end
+
+  describe ".union.all" do
+    it_behaves_like "standard set of errors" do
+      let!(:misaligned_cmd)    { Person.union.all(person_one_query, person_two_query) }
+      let!(:lacking_union_cmd) { Person.union.all(person_one_query) }
+    end
+
+    it "should keep duplicate results from each union statement" do
+      expected_ids = Person.pluck(:id) * 2
+      query        = Person.union.all(Person.select(:id), Person.select(:id))
+      expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
+    end
+  end
+
+  describe ".union.except" do
+    it_behaves_like "standard set of errors" do
+      let!(:misaligned_cmd)    { Person.union.except(person_one_query, person_two_query) }
+      let!(:lacking_union_cmd) { Person.union.except(person_one_query) }
+    end
+
+    it "should eliminate records that match a given except statement" do
+      query = Person.union.except(Person.select(:id), Person.select(:id).where(id: person_one.id))
+      expect(query).to match_array([person_two, person_three])
+    end
+  end
+
+  describe "union.intersect" do
+    it_behaves_like "standard set of errors" do
+      let!(:misaligned_cmd)    { Person.union.intersect(person_one_query, person_two_query) }
+      let!(:lacking_union_cmd) { Person.union.intersect(person_one_query) }
+    end
+
+    it "should find records with similar attributes" do
+      ProfileL.create!(person: person_three, likes: 120)
+
+      query =
+        Person.union.intersect(
+          Person.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
+          Person.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150"),
+        )
+
+      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([person_one_pl.id]))
+      expect(query.first.likes).to eq(person_one_pl.likes)
+    end
+  end
+
+  describe "union.as" do
+    let(:query) do
+      Person.select("happy_people.id")
+            .union(Person.where(id: person_one.id), Person.where(id: person_three.id))
+            .union_as(:happy_people)
+    end
+
+    it "should return two people" do
+      expect(query.size).to eq(2)
+    end
+
+    it "should return two peoples id's" do
+      expect(query.map(&:id)).to match_array([person_one.id, person_three.id])
+    end
+
+    it "should alias the tables being union'd but still allow for accessing table methods" do
+      query.each do |happy_person|
+        expect(happy_person).to respond_to(:profile_l)
+      end
+    end
+  end
+
+  describe "union.order_union" do
+    it "should order the .union commands" do
+      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id)).order_union(id: :desc)
+      expect(query).to eq([person_three, person_one])
+    end
+
+    it "should order the .union.all commands" do
+      query =
+        Person.union.all(
+          Person.where(id: person_one.id),
+          Person.where(id: person_three.id),
+        ).order_union(id: :desc)
+
+      expect(query).to eq([person_three, person_one])
+    end
+
+    it "should order the union.except commands" do
+      query = Person.union.except(Person.order(id: :asc), Person.where(id: person_one.id)).order_union(id: :desc)
+      expect(query).to eq([person_three, person_two])
+    end
+
+    it "should order the .union.intersect commands" do
+      query =
+        Person.union.intersect(
+          Person.where("id < ?", person_three.id),
+          Person.where("id >= ?", person_one.id),
+        ).order_union(id: :desc)
+
+      expect(query).to eq([person_two, person_one])
+    end
+  end
+
+  describe "union.reorder_union" do
+    it "should replace the ordering with the new parameters" do
+      person_a         = Person.create!(number: 1)
+      person_b         = Person.create!(number: 10)
+      initial_ordering = [person_b, person_a]
+      query            = Person.union(Person.where(id: person_a.id), Person.where(id: person_b.id))
+                               .order_union(id: :desc)
+
+      expect(query).to eq(initial_ordering)
+      expect(query.reorder_union(number: :asc)).to eq(initial_ordering.reverse)
+    end
+  end
+end