active_record_extended 0.7.0 → 1.0.0

data/lib/active_record_extended.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_extended/version"
-
+require "active_record_extended/utilities"
 require "active_record_extended/active_record"
 require "active_record_extended/arel"
 

data/lib/active_record_extended/active_record.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# TODO: Remove this when ruby 2.3 support is dropped
+unless Hash.instance_methods(false).include?(:compact!)
+  require "active_support/all"
+end
+
 require "active_record"
 require "active_record/relation"
 require "active_record/relation/merger"
@@ -7,11 +12,15 @@ require "active_record/relation/query_methods"
 
 require "active_record_extended/predicate_builder/array_handler_decorator"
 
+require "active_record_extended/active_record/relation_patch"
+
 require "active_record_extended/query_methods/where_chain"
 require "active_record_extended/query_methods/with_cte"
+require "active_record_extended/query_methods/unionize"
 require "active_record_extended/query_methods/any_of"
 require "active_record_extended/query_methods/either"
 require "active_record_extended/query_methods/inet"
+require "active_record_extended/query_methods/json"
 
 if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 1
   if ActiveRecord::VERSION::MINOR.zero?

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "active_record_extended/query_methods/unionize"
+require "active_record_extended/query_methods/json"
+
+module ActiveRecordExtended
+  module RelationPatch
+    module QueryDelegation
+      delegate :with, to: :all
+      delegate(*::ActiveRecordExtended::QueryMethods::Unionize::UNIONIZE_METHODS, to: :all)
+      delegate(*::ActiveRecordExtended::QueryMethods::Json::JSON_QUERY_METHODS, to: :all)
+    end
+
+    module Merger
+      def normal_values
+        super + [:with, :union]
+      end
+    end
+
+    module ArelBuildPatch
+      def build_arel(*aliases)
+        super.tap do |arel|
+          build_unions(arel) if union_values?
+          build_with(arel)   if with_values?
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::RelationPatch::ArelBuildPatch)
+ActiveRecord::Relation::Merger.prepend(ActiveRecordExtended::RelationPatch::Merger)
+ActiveRecord::Querying.prepend(ActiveRecordExtended::RelationPatch::QueryDelegation)

data/lib/active_record_extended/arel/nodes.rb

@@ -19,6 +19,26 @@ module Arel
     class ContainedInArray < Arel::Nodes::Binary
     end
 
+    class RowToJson < Arel::Nodes::Function
+      def initialize(*args)
+        super
+        unless @expressions.is_a?(Array)
+          @expressions = Arel.sql(@expressions) unless @expressions.is_a?(Arel::Nodes::SqlLiteral)
+          @expressions = [@expressions]
+        end
+      end
+    end
+
+    class JsonBuildObject < Arel::Nodes::Function
+      def initialize(*args)
+        super
+        @expressions = Array(@expressions)
+      end
+    end
+
+    class JsonbBuildObject < JsonBuildObject
+    end
+
     module Inet
       class ContainsEquals < Arel::Nodes::Binary
       end

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -18,7 +18,7 @@ module ActiveRecordExtended
           matchable_column?(col, object)
         end
 
-        if %i[hstore jsonb].include?(left_column&.type)
+        if [:hstore, :jsonb].include?(left_column&.type)
           visit_Arel_Nodes_ContainsHStore(object, collector)
         elsif left_column.try(:array)
           visit_Arel_Nodes_ContainsArray(object, collector)
@@ -47,6 +47,18 @@ module ActiveRecordExtended
         infix_value object, collector, " << "
       end
 
+      def visit_Arel_Nodes_RowToJson(object, collector)
+        aggregate "ROW_TO_JSON", object, collector
+      end
+
+      def visit_Arel_Nodes_JsonBuildObject(object, collector)
+        aggregate "JSON_BUILD_OBJECT", object, collector
+      end
+
+      def visit_Arel_Nodes_JsonbBuildObject(object, collector)
+        aggregate "JSONB_BUILD_OBJECT", object, collector
+      end
+
       def visit_Arel_Nodes_Inet_ContainedWithinEquals(object, collector)
         infix_value object, collector, " <<= "
       end

data/lib/active_record_extended/query_methods/either.rb

@@ -6,7 +6,7 @@ module ActiveRecordExtended
   module QueryMethods
     module Either
       XOR_FIELD_SQL  = "(CASE WHEN %<t1>s.%<c1>s IS NULL THEN %<t2>s.%<c2>s ELSE %<t1>s.%<c1>s END) "
-      XOR_FIELD_KEYS = %i[t1 c1 t2 c2].freeze
+      XOR_FIELD_KEYS = [:t1, :c1, :t2, :c2].freeze
 
       def either_join(initial_association, fallback_association)
         associations        = [initial_association, fallback_association]

data/lib/active_record_extended/query_methods/inet.rb

@@ -3,12 +3,6 @@
 module ActiveRecordExtended
   module QueryMethods
     module Inet
-      def contained_within(opts, *rest)
-        ActiveSupport::Deprecation.warn("#contained_within will soon be deprecated for version 1.0 release. "\
-                                        "Please use #inet_contained_within instead.", caller(1))
-        inet_contained_within(opts, *rest)
-      end
-
       # Finds matching inet column records that fall within a given submasked IP range
       #
       # Column(inet) << "127.0.0.1/24"
@@ -23,12 +17,6 @@ module ActiveRecordExtended
         substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainedWithin, "inet_contained_within")
       end
 
-      def contained_within_or_equals(opts, *rest)
-        ActiveSupport::Deprecation.warn("#contained_within_or_equals will soon be deprecated for version 1.0 release. "\
-                                        "Please use #inet_contained_within_or_equals instead.", caller(1))
-        inet_contained_within_or_equals(opts, *rest)
-      end
-
       # Finds matching inet column records that fall within a given submasked IP range and also finds records that also
       # contain a submasking field that fall within range too.
       #
@@ -44,12 +32,6 @@ module ActiveRecordExtended
         substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainedWithinEquals, "inet_contained_within_or_equals")
       end
 
-      def contains_or_equals(opts, *rest)
-        ActiveSupport::Deprecation.warn("#contains_or_equals will soon be deprecated for version 1.0 release. "\
-                                        "Please use #inet_contains_or_equals instead.", caller(1))
-        inet_contains_or_equals(opts, *rest)
-      end
-
       # Finds records that contain a submask and the supplied IP address falls within its range.
       #
       # Column(inet) >>= "127.0.0.1/24"

data/lib/active_record_extended/query_methods/json.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Json
+      JSON_QUERY_METHODS = [
+        :select_row_to_json,
+        :json_build_object,
+        :jsonb_build_object,
+        :json_build_literal,
+        :jsonb_build_literal,
+      ].freeze
+
+      class JsonChain
+        include ::ActiveRecordExtended::Utilities
+        DEFAULT_ALIAS = '"results"'
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def row_to_json!(**args, &block)
+          options = json_object_options(args).except(:values, :value)
+          build_row_to_json(**options, &block)
+        end
+
+        def json_build_object!(*args)
+          options = json_object_options(args).except!(:values)
+          build_json_object(Arel::Nodes::JsonBuildObject, **options)
+        end
+
+        def jsonb_build_object!(*args)
+          options = json_object_options(args).except!(:values)
+          build_json_object(Arel::Nodes::JsonbBuildObject, **options)
+        end
+
+        def json_build_literal!(*args)
+          options = json_object_options(args).slice(:values, :col_alias)
+          build_json_literal(Arel::Nodes::JsonBuildObject, **options)
+        end
+
+        def jsonb_build_literal!(*args)
+          options = json_object_options(args).slice(:values, :col_alias)
+          build_json_literal(Arel::Nodes::JsonbBuildObject, **options)
+        end
+
+        private
+
+        def build_json_literal(arel_klass, values:, col_alias: DEFAULT_ALIAS)
+          json_values    = flatten_to_sql(values.to_a, &method(:literal_key))
+          col_alias      = double_quote(col_alias)
+          json_build_obj = arel_klass.new(json_values)
+          @scope.select(nested_alias_escape(json_build_obj, col_alias))
+        end
+
+        def build_json_object(arel_klass, from:, key: key_generator, value: nil, col_alias: DEFAULT_ALIAS)
+          tbl_alias         = double_quote(key)
+          col_alias         = double_quote(col_alias)
+          col_key           = literal_key(key)
+          col_value         = to_arel_sql(value.presence || tbl_alias)
+          json_build_object = arel_klass.new(to_sql_array(col_key, col_value))
+
+          # TODO: Change this to #match?(..) when we drop Rails 5.0 or Ruby 2.4 support
+          unless col_value.index(/".+"/)
+            warn("`#{col_value}`: the `value` argument should contain a double quoted key reference for safety")
+          end
+
+          @scope.select(nested_alias_escape(json_build_object, col_alias)).from(nested_alias_escape(from, tbl_alias))
+        end
+
+        def build_row_to_json(from:, key: key_generator, col_alias: nil, cast_to_array: false)
+          row_to_json = Arel::Nodes::RowToJson.new(double_quote(key))
+          dummy_table = from_clause_constructor(from, key).select(row_to_json)
+          dummy_table = yield dummy_table if block_given?
+
+          if col_alias.blank?
+            dummy_table
+          elsif cast_to_array
+            @scope.select(wrap_with_array(dummy_table, col_alias))
+          else
+            @scope.select(nested_alias_escape(dummy_table, col_alias))
+          end
+        end
+
+        def json_object_options(*args) # rubocop:disable Metrics/AbcSize
+          flatten_safely(args).each_with_object(values: []) do |arg, options|
+            next if arg.nil?
+
+            if arg.is_a?(Hash)
+              options[:key]           ||= arg.delete(:key)
+              options[:value]         ||= arg.delete(:value).presence
+              options[:col_alias]     ||= arg.delete(:as)
+              options[:cast_to_array] ||= arg.delete(:cast_as_array)
+              options[:from]          ||= arg.delete(:from).tap(&method(:pipe_cte_with!))
+            end
+
+            options[:values] << (arg.respond_to?(:to_a) ? arg.to_a : arg)
+          end.compact
+        end
+      end
+
+      # Appends a select statement that contains a subquery that is converted to a json response
+      #
+      # Arguments:
+      #   - from: [String, Arel, or ActiveRecord::Relation] A subquery that can be nested into a ROW_TO_JSON clause
+      #
+      # Options:
+      #   - as: [Symbol or String] (default="results"): What the column will be aliased to
+      #
+      #   - key: [Symbol or String] (default=[random letter]) What the row clause will be set as.
+      #         - This is useful if you would like to add additional mid-level clauses (see mid-level scope example)
+      #
+      #   - cast_as_array [boolean] (default=false): Determines if the query should be nested inside an Array() function
+      #
+      # Example:
+      #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
+      #
+      #  - Adding mid-level scopes:
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end
+      #
+
+      def select_row_to_json(from = nil, **options, &block)
+        from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
+        options.compact!
+        raise ArgumentError, "Required to provide a non-nilled from clause" unless options.key?(:from)
+        JsonChain.new(spawn).row_to_json!(**options, &block)
+      end
+
+      # Creates a json response object that will convert all subquery results into a json compatible response
+      #
+      # Arguments:
+      #   key: [Symbol or String]: What should this response return as
+      #   from: [String, Arel, or ActiveRecord::Relation] : A subquery that can be nested into the top-level from clause
+      #
+      # Options:
+      #   - as: [Symbol or String] (default="results"): What the column will be aliased to
+      #
+      #
+      #   - value: [Symbol or String] (defaults=[key]): How the response should handel the json value return
+      #
+      # Example:
+      #
+      #   - Generic example:
+      #
+      #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
+      #
+      #  - Setting a custom value:
+      #
+      #   Before:
+      #       subquery = User.select(:name).where(id: 100..110).group(:name)
+      #       User.build_json_object(:gang_members, subquery).take.results["gang_members"] #=> nil
+      #
+      #   After:
+      #    User.build_json_object(:gang_members, subquery, value: "COALESCE(array_agg(\"gang_members\"), 'BANG!')")
+      #        .take
+      #        .results["gang_members"] #=> "BANG!"
+      #
+      #
+      # - Adding mid-level scopes
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end  #=>  ```sql
+      #       SELECT ARRAY(
+      #             SELECT ROW_TO_JSON("group")
+      #             FROM(SELECT name, category_id FROM groups) AS group
+      #             WHERE group.name = 'Nerd Core'
+      #       )
+      #     ```
+      #
+
+      def json_build_object(key, from, **options)
+        options[:key]  = key
+        options[:from] = from
+        JsonChain.new(spawn).json_build_object!(options)
+      end
+
+      def jsonb_build_object(key, from, **options)
+        options[:key]  = key
+        options[:from] = from
+        JsonChain.new(spawn).jsonb_build_object!(options)
+      end
+
+      # Appends a hash literal to the calling relations response
+      #
+      # Arguments: Requires an Array or Hash set of values
+      #
+      # Options:
+      #
+      #  - as: [Symbol or String] (default="results"): What the column will be aliased to
+      #
+      # Example:
+      #  - Supplying inputs as a Hash
+      #      query = User.json_build_literal(number: 1, last_name: "json", pi: 3.14)
+      #      query.take.results #=> { "number" => 1, "last_name" => "json", "pi" => 3.14 }
+      #
+      #  - Supplying inputs as an Array
+      #
+      #      query = User.json_build_literal(:number, 1, :last_name, "json", :pi, 3.14)
+      #      query.take.results #=> { "number" => 1, "last_name" => "json", "pi" => 3.14 }
+      #
+
+      def json_build_literal(*args)
+        JsonChain.new(spawn).json_build_literal!(args)
+      end
+
+      def jsonb_build_literal(*args)
+        JsonChain.new(spawn).jsonb_build_literal!(args)
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Json)

data/lib/active_record_extended/query_methods/unionize.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Unionize
+      UNION_RELATION_METHODS = [:order_union, :reorder_union, :union_as].freeze
+      UNIONIZE_METHODS       = [:union, :union_all, :union_except, :union_intersect].freeze
+
+      class UnionChain
+        include ::ActiveRecordExtended::Utilities
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def as(from_clause_name)
+          @scope.unionized_name = from_clause_name.to_s
+          @scope
+        end
+        alias union_as as
+
+        def order(*ordering_args)
+          process_ordering_arguments!(ordering_args)
+          @scope.union_ordering_values += ordering_args
+          @scope
+        end
+        alias order_union order
+
+        def reorder(*ordering_args)
+          @scope.union_ordering_values.clear
+          order(*ordering_args)
+        end
+        alias reorder_union reorder
+
+        def union(*args)
+          append_union_order!(:union, args)
+          @scope
+        end
+
+        def all(*args)
+          append_union_order!(:union_all, args)
+          @scope
+        end
+        alias union_all all
+
+        def except(*args)
+          append_union_order!(:except, args)
+          @scope
+        end
+        alias union_except except
+
+        def intersect(*args)
+          append_union_order!(:intersect, args)
+          @scope
+        end
+        alias union_intersect intersect
+
+        protected
+
+        def append_union_order!(union_type, args)
+          args.each(&method(:pipe_cte_with!))
+          flatten_scopes       = flatten_to_sql(args)
+          @scope.union_values += flatten_scopes
+          calculate_union_operation!(union_type, flatten_scopes.size)
+        end
+
+        def calculate_union_operation!(union_type, scope_count)
+          scope_count             -= 1 unless @scope.union_operations?
+          scope_count              = 1 if scope_count <= 0 && @scope.union_values.size <= 1
+          @scope.union_operations += [union_type] * scope_count
+        end
+
+        # We'll need to preprocess these arguments for allowing `ActiveRecord::Relation#preprocess_order_args`,
+        # to check for sanitization issues and convert over to `Arel::Nodes::[Ascending/Descending]`.
+        # Without reflecting / prepending the parent's table name.
+
+        if ActiveRecord.gem_version < Gem::Version.new("5.1")
+          # TODO: Rails 5.0.x order logic will *always* append the parents name to the column when its an HASH obj
+          #       We should really do this stuff better. Maybe even just ignore `preprocess_order_args` altogether?
+          #       Maybe I'm just stupidly over paranoid on just the 'ORDER BY' for some odd reason.
+          def process_ordering_arguments!(ordering_args)
+            ordering_args.flatten!
+            ordering_args.compact!
+            ordering_args.map! do |arg|
+              next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
+              arg.each_with_object([]) do |(field, dir), ordering_object|
+                ordering_object << to_arel_sql(field).send(dir.to_s.downcase)
+              end
+            end.flatten!
+          end
+        else
+          def process_ordering_arguments!(ordering_args)
+            ordering_args.flatten!
+            ordering_args.compact!
+            ordering_args.map! do |arg|
+              next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
+              arg.each_with_object({}) do |(field, dir), ordering_obj|
+                # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
+                ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
+              end
+            end
+          end
+        end
+      end
+
+      def unionize_storage
+        @values.fetch(:unionize, {})
+      end
+
+      def unionize_storage!
+        @values[:unionize] ||= {
+          union_values:          [],
+          union_operations:      [],
+          union_ordering_values: [],
+          unionized_name:        nil,
+        }
+      end
+
+      {
+        union_values:          Array,
+        union_operations:      Array,
+        union_ordering_values: Array,
+        unionized_name:        lambda { |klass| klass.arel_table.name },
+      }.each_pair do |method_name, default|
+        define_method(method_name) do
+          return unionize_storage[method_name] if send("#{method_name}?")
+          (default.is_a?(Proc) ? default.call(@klass) : default.new)
+        end
+
+        define_method("#{method_name}?") do
+          unionize_storage.key?(method_name) && !unionize_storage[method_name].presence.nil?
+        end
+
+        define_method("#{method_name}=") do |value|
+          unionize_storage![method_name] = value
+        end
+      end
+
+      def union(opts = :chain, *args)
+        return UnionChain.new(spawn) if opts == :chain
+        opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
+      end
+
+      (UNIONIZE_METHODS + UNION_RELATION_METHODS).each do |union_method|
+        next if union_method == :union
+        alias_method union_method, :union
+      end
+
+      def union!(opts = :chain, *args, chain_method: :union)
+        union_chain    = UnionChain.new(self)
+        chain_method ||= :union
+        return union_chain if opts == :chain
+
+        union_chain.public_send(chain_method, *([opts] + args))
+      end
+
+      # Will construct *Just* the union SQL statement that was been built thus far
+      def to_union_sql
+        return unless union_values?
+        apply_union_ordering(build_union_nodes!(false)).to_sql
+      end
+
+      def to_nice_union_sql(color = true)
+        return to_union_sql unless defined?(::Niceql)
+        ::Niceql::Prettifier.prettify_sql(to_union_sql, color)
+      end
+
+      protected
+
+      def build_unions(arel = @klass.arel_table)
+        return unless union_values?
+
+        union_nodes      = apply_union_ordering(build_union_nodes!)
+        table_name       = Arel::Nodes::SqlLiteral.new(unionized_name)
+        table_alias      = arel.create_table_alias(arel.grouping(union_nodes), table_name)
+        arel.from(table_alias)
+      end
+
+      # Builds a set of nested nodes that union each other's results
+      #
+      # Note: Order of chained unions *DOES* matter
+      #
+      # Example:
+      #
+      #   User.union(User.select(:id).where(id: 8))
+      #       .union(User.select(:id).where(id: 50))
+      #       .union.except(User.select(:id).where(id: 8))
+      #
+      #   #=> [<#User id: 50]]
+      #
+      #   ```sql
+      #   SELECT users.*
+      #   FROM(
+      #       (
+      #         (SELECT users.id FROM users WHERE id = 8)
+      #         UNION
+      #         (SELECT users.id FROM users WHERE id = 50)
+      #       )
+      #       EXCEPT
+      #       (SELECT users.id FROM users WHERE id = 8)
+      #    ) users;
+      #   ```
+
+      def build_union_nodes!(raise_error = true)
+        unionize_error_or_warn!(raise_error)
+        union_values.each_with_index.inject(nil) do |union_node, (relation_node, index)|
+          next resolve_relation_node(relation_node) if union_node.nil?
+
+          operation = union_operations.fetch(index - 1, :union)
+          left      = union_node
+          right     = resolve_relation_node(relation_node)
+
+          case operation
+          when :union_all
+            Arel::Nodes::UnionAll.new(left, right)
+          when :except
+            Arel::Nodes::Except.new(left, right)
+          when :intersect
+            Arel::Nodes::Intersect.new(left, right)
+          else
+            Arel::Nodes::Union.new(left, right)
+          end
+        end
+      end
+
+      # Apply's the allowed ORDER BY to the end of the final union statement
+      #
+      # Note: This will only apply at the very end of the union statements. Not nested ones.
+      #       (I guess you could double nest a union and apply it, but that would be dumb)
+      #
+      # Example:
+      #   User.union(User.select(:id).where(id: 8))
+      #       .union(User.select(:id).where(id: 50))
+      #       .union.order(id: :desc)
+      #  #=> [<#User id: 50>, <#User id: 8>]
+      #
+      #   ```sql
+      #   SELECT users.*
+      #   FROM(
+      #       (SELECT users.id FROM users WHERE id = 8)
+      #       UNION
+      #       (SELECT users.id FROM users WHERE id = 50)
+      #       ORDER BY id DESC
+      #    ) users;
+      #   ```
+      #
+      def apply_union_ordering(union_nodes)
+        return union_nodes unless union_ordering_values?
+
+        # Sanitation check / resolver (ActiveRecord::Relation#preprocess_order_args)
+        preprocess_order_args(union_ordering_values)
+        union_ordering_values.uniq!
+        Arel::Nodes::InfixOperation.new("ORDER BY", union_nodes, union_ordering_values)
+      end
+
+      private
+
+      def unionize_error_or_warn!(raise_error = true)
+        if raise_error && union_values.size <= 1
+          raise ArgumentError, "You are required to provide 2 or more unions to join!"
+        elsif !raise_error && union_values.size <= 1
+          warn("Warning: You are required to provide 2 or more unions to join.")
+        end
+      end
+
+      def resolve_relation_node(relation_node)
+        case relation_node
+        when String
+          Arel::Nodes::Grouping.new(Arel.sql(relation_node))
+        else
+          relation_node.arel
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Unionize)