arel_toolkit 0.4.2 → 0.4.6

data/lib/arel/enhance/node.rb

@@ -1,21 +1,15 @@
 module Arel
   module Enhance
     class Node
+      attr_reader :local_path
       attr_reader :object
       attr_reader :parent
-      attr_reader :local_path
-      attr_reader :fields
-      attr_reader :children
       attr_reader :root_node
-      attr_reader :context
 
       def initialize(object)
         @object = object
         @root_node = self
-        @fields = []
-        @children = {}
         @dirty = false
-        @context = {}
       end
 
       def inspect
@@ -25,7 +19,7 @@ module Arel
       def value
         return unless value?
 
-        @fields.first
+        fields.first
       end
 
       def each(&block)
@@ -58,7 +52,7 @@ module Arel
         node.local_path = path_node
         node.parent = self
         node.root_node = root_node
-        @children[path_node.value.to_s] = node
+        children[path_node.value.to_s] = node
       end
 
       def to_sql(engine = Table.engine)
@@ -78,19 +72,19 @@ module Arel
       end
 
       def method_missing(name, *args, &block)
-        child = @children[name.to_s]
+        child = children[name.to_s]
         return super if child.nil?
 
         child
       end
 
       def respond_to_missing?(method, include_private = false)
-        child = @children[method.to_s]
+        child = children[method.to_s]
         child.present? || super
       end
 
       def [](key)
-        @children.fetch(key.to_s)
+        children.fetch(key.to_s)
       end
 
       def child_at_path(path_items)
@@ -118,6 +112,18 @@ module Arel
         the_path.compact
       end
 
+      def children
+        @children ||= {}
+      end
+
+      def fields
+        @fields ||= []
+      end
+
+      def context
+        @context ||= {}
+      end
+
       protected
 
       attr_writer :local_path

data/lib/arel/extensions.rb

@@ -115,6 +115,7 @@ require 'arel/extensions/active_model_attribute_with_cast_value'
 require 'arel/extensions/exists'
 require 'arel/extensions/bind_param'
 require 'arel/extensions/node'
+require 'arel/extensions/top'
 
 module Arel
   module Extensions

data/lib/arel/extensions/conflict.rb

@@ -21,12 +21,12 @@ module Arel
         visit(o.infer, collector) if o.infer
 
         case o.action
-        when 1
+        when :ONCONFLICT_NOTHING
           collector << 'DO NOTHING'
-        when 2
+        when :ONCONFLICT_UPDATE
           collector << 'DO UPDATE SET '
         else
-          raise "Unknown conflict clause `#{action}`"
+          raise "Unknown conflict clause `#{o.action}`"
         end
 
         o.values.any? && (inject_join o.values, collector, ', ')

data/lib/arel/extensions/delete_statement.rb

@@ -9,11 +9,14 @@ module Arel
         attr_accessor :using
         attr_accessor :with
         attr_accessor :returning
+        attr_accessor :orders
 
         def initialize(relation = nil, wheres = [])
           super
 
           @returning = []
+          @orders = []
+          @using = []
         end
       end
 
@@ -27,27 +30,29 @@ module Arel
       def visit_Arel_Nodes_DeleteStatement(o, collector)
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << ' '
         end
 
-        collector << 'DELETE FROM '
-        collector = visit o.relation, collector
-
-        if o.using
-          collector << ' USING '
-          collector = inject_join o.using, collector, ', '
-        end
+        if Gem.loaded_specs['activerecord'].version >= Gem::Version.new('6.0.0')
+          o = prepare_delete_statement(o)
 
-        if o.wheres.any?
-          collector << WHERE
-          collector = inject_join o.wheres, collector, AND
+          if has_join_sources?(o)
+            collector << 'DELETE '
+            visit o.relation.left, collector
+            collector << ' FROM '
+          else
+            collector << 'DELETE FROM '
+          end
+        else
+          collector << 'DELETE FROM '
         end
 
-        unless o.returning.empty?
-          collector << ' RETURNING '
-          collector = inject_join o.returning, collector, ', '
-        end
+        collector = visit o.relation, collector
 
+        collect_nodes_for o.using, collector, ' USING ', ', '
+        collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
+        collect_nodes_for o.returning, collector, ' RETURNING ', ', '
+        collect_nodes_for o.orders, collector, ' ORDER BY '
         maybe_visit o.limit, collector
       end
       # rubocop:enable Metrics/AbcSize

data/lib/arel/extensions/function.rb

@@ -46,7 +46,7 @@ module Arel
         end
 
         if o.orders.any?
-          collector << SPACE unless o.within_group
+          collector << ' ' unless o.within_group
           collector << 'ORDER BY '
           collector = inject_join o.orders, collector, ', '
         end

data/lib/arel/extensions/infer.rb

@@ -13,13 +13,13 @@ module Arel
   module Visitors
     class ToSql
       def visit_Arel_Nodes_Infer(o, collector)
-        if o.name
+        if o.name.present?
           collector << 'ON CONSTRAINT '
           collector << o.left
-          collector << SPACE
+          collector << ' '
         end
 
-        if o.right
+        if o.right.present?
           collector << '('
           inject_join o.right, collector, ', '
           collector << ') '

data/lib/arel/extensions/insert_statement.rb

@@ -30,7 +30,7 @@ module Arel
       def visit_Arel_Nodes_InsertStatement(o, collector)
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << ' '
         end
 
         collector << 'INSERT INTO '
@@ -42,11 +42,11 @@ module Arel
         end
 
         case o.override
-        when nil, 0
+        when :OVERRIDING_KIND_UNDEFINED, :OVERRIDING_NOT_SET, nil
           collector << ''
-        when 1
+        when :OVERRIDING_USER_VALUE
           collector << ' OVERRIDING USER VALUE'
-        when 2
+        when :OVERRIDING_SYSTEM_VALUE
           collector << ' OVERRIDING SYSTEM VALUE'
         else
           raise "Unknown override `#{o.override}`"

data/lib/arel/extensions/select_core.rb

@@ -6,6 +6,22 @@ module Arel
   module Nodes
     class SelectCore < Arel::Nodes::Node
       attr_accessor :into
+      attr_accessor :top
+
+      private
+
+      def hash
+        [
+          @source, @set_quantifier, @projections, @optimizer_hints,
+          @wheres, @groups, @havings, @windows, @comment, @top, @into
+        ].hash
+      end
+
+      def eql?(other)
+        super &&
+          top == other.top &&
+          into == other.into
+      end
     end
   end
 
@@ -14,11 +30,9 @@ module Arel
       def visit_Arel_Nodes_SelectCore(o, collector)
         collector << 'SELECT'
 
-        collector = maybe_visit o.top, collector
-
         collector = maybe_visit o.set_quantifier, collector
 
-        collect_nodes_for o.projections, collector, SPACE
+        collect_nodes_for o.projections, collector, ' '
 
         maybe_visit o.into, collector
 
@@ -27,13 +41,13 @@ module Arel
           collector = visit o.source, collector
         end
 
-        collect_nodes_for o.wheres, collector, WHERE, AND
-        collect_nodes_for o.groups, collector, GROUP_BY
+        collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
+        collect_nodes_for o.groups, collector, ' GROUP BY '
         unless o.havings.empty?
           collector << ' HAVING '
-          inject_join o.havings, collector, AND
+          inject_join o.havings, collector, ' AND '
         end
-        collect_nodes_for o.windows, collector, WINDOW
+        collect_nodes_for o.windows, collector, ' WINDOW '
 
         collector
       end

data/lib/arel/extensions/top.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Top < Unary
+    end
+  end
+end

data/lib/arel/extensions/transaction.rb

@@ -16,21 +16,21 @@ module Arel
     class ToSql
       def visit_Arel_Nodes_Transaction(o, collector)
         case o.type
-        when 0
+        when 1
           collector << 'BEGIN'
-        when 2
-          collector << 'COMMIT'
         when 3
-          collector << 'ROLLBACK'
+          collector << 'COMMIT'
         when 4
-          collector << 'SAVEPOINT '
-          collector << o.options.join(' ')
+          collector << 'ROLLBACK'
         when 5
-          collector << 'RELEASE SAVEPOINT '
-          collector << o.options.join(' ')
+          collector << 'SAVEPOINT '
+          collector << o.right
         when 6
+          collector << 'RELEASE SAVEPOINT '
+          collector << o.right
+        when 7
           collector << 'ROLLBACK TO '
-          collector << o.options.join(' ')
+          collector << o.right
         else
           raise "Unknown transaction type `#{o.type}`"
         end

data/lib/arel/extensions/update_statement.rb

@@ -24,16 +24,17 @@ module Arel
 
   module Visitors
     class ToSql
-      # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/PerceivedComplexity
       def visit_Arel_Nodes_UpdateStatement(o, collector)
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << ' '
         end
 
-        wheres = if o.orders.empty? && o.limit.nil?
+        wheres = if Gem.loaded_specs['activerecord'].version >= Gem::Version.new('6.0.0')
+                   o = prepare_update_statement(o)
+                   o.wheres
+                 elsif o.orders.empty? && o.limit.nil?
                    o.wheres
                  else
                    [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
@@ -41,31 +42,16 @@ module Arel
 
         collector << 'UPDATE '
         collector = visit o.relation, collector
-        unless o.values.empty?
-          collector << ' SET '
-          collector = inject_join o.values, collector, ', '
-        end
-
-        unless o.froms.empty?
-          collector << ' FROM '
-          collector = inject_join o.froms, collector, ', '
-        end
 
-        unless wheres.empty?
-          collector << ' WHERE '
-          collector = inject_join wheres, collector, ' AND '
-        end
+        collect_nodes_for o.values, collector, ' SET '
+        collect_nodes_for o.froms, collector, ' FROM ', ', '
 
-        unless o.returning.empty?
-          collector << ' RETURNING '
-          collector = inject_join o.returning, collector, ', '
-        end
+        collect_nodes_for wheres, collector, ' WHERE ', ' AND '
+        collect_nodes_for o.returning, collector, ' RETURNING ', ', '
 
         collector
       end
       # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
 
     class Dot

data/lib/arel/middleware/cache_accessor.rb

@@ -0,0 +1,35 @@
+module Arel
+  module Middleware
+    class CacheAccessor
+      attr_reader :cache
+
+      def initialize(cache)
+        @cache = cache
+      end
+
+      def read(original_sql)
+        cache.read cache_key(original_sql)
+      end
+
+      def write(transformed_sql:, transformed_binds:, original_sql:, original_binds:)
+        # To play it safe, the order of binds was changed and therefore we won't reuse the query
+        return if transformed_binds != original_binds
+
+        cache.write(cache_key(original_sql), transformed_sql)
+      end
+
+      def cache_key_for_sql(sql)
+        Digest::SHA256.hexdigest(sql)
+      end
+
+      def cache_key(sql)
+        # An important aspect of this cache key method is that it includes hashes of all active
+        # middlewares. If multiple Arel middleware chains that are using the same cache backend,
+        # this cache key mechanism will prevent cache entries leak in the wrong chain.
+
+        active_middleware_cache_key = Arel.middleware.current.map(&:hash).join('&') || 0
+        active_middleware_cache_key + '|' + cache_key_for_sql(sql)
+      end
+    end
+  end
+end

data/lib/arel/middleware/chain.rb

@@ -1,81 +1,90 @@
+require_relative './no_op_cache'
+require_relative './cache_accessor'
+
 module Arel
   module Middleware
     class Chain
-      attr_reader :executing_middleware
+      attr_reader :executing_middleware_depth
       attr_reader :executor
+      attr_reader :cache
+
+      MAX_RECURSION_DEPTH = 10
 
       def initialize(
         internal_middleware = [],
         internal_context = {},
-        executor_class = Arel::Middleware::DatabaseExecutor
+        executor_class = Arel::Middleware::DatabaseExecutor,
+        cache: nil
       )
         @internal_middleware = internal_middleware
         @internal_context = internal_context
         @executor = executor_class.new(internal_middleware)
-        @executing_middleware = false
+        @executing_middleware_depth = 0
+        @cache = cache || NoOpCache
+      end
+
+      def cache_accessor
+        @cache_accessor ||= CacheAccessor.new @cache
       end
 
       def execute(sql, binds = [], &execute_sql)
         return execute_sql.call(sql, binds).to_casted_result if internal_middleware.length.zero?
 
-        check_middleware_recursion(sql)
-
-        updated_context = context.merge(original_sql: sql)
-        enhanced_arel = Arel.enhance(Arel.sql_to_arel(sql, binds: binds))
-
-        result = executor.run(enhanced_arel, updated_context, execute_sql)
+        if (cached_sql = cache_accessor.read(sql))
+          return execute_sql.call(cached_sql, binds).to_casted_result
+        end
 
-        result.to_casted_result
+        execute_with_middleware(sql, binds, execute_sql).to_casted_result
       rescue ::PgQuery::ParseError
         execute_sql.call(sql, binds)
       ensure
-        @executing_middleware = false
+        @executing_middleware_depth -= 1
       end
 
       def current
         internal_middleware.dup
       end
 
-      def apply(middleware, &block)
+      def apply(middleware, cache: @cache, &block)
         new_middleware = Array.wrap(middleware)
-        continue_chain(new_middleware, internal_context, &block)
+        continue_chain(new_middleware, internal_context, cache: cache, &block)
       end
       alias only apply
 
       def none(&block)
-        continue_chain([], internal_context, &block)
+        continue_chain([], internal_context, cache: cache, &block)
       end
 
-      def except(without_middleware, &block)
+      def except(without_middleware, cache: @cache, &block)
         without_middleware = Array.wrap(without_middleware)
         new_middleware = internal_middleware - without_middleware
-        continue_chain(new_middleware, internal_context, &block)
+        continue_chain(new_middleware, internal_context, cache: cache, &block)
       end
 
-      def insert_before(new_middleware, existing_middleware, &block)
+      def insert_before(new_middleware, existing_middleware, cache: @cache, &block)
         new_middleware = Array.wrap(new_middleware)
         index = internal_middleware.index(existing_middleware)
         updated_middleware = internal_middleware.insert(index, *new_middleware)
-        continue_chain(updated_middleware, internal_context, &block)
+        continue_chain(updated_middleware, internal_context, cache: cache, &block)
       end
 
-      def prepend(new_middleware, &block)
+      def prepend(new_middleware, cache: @cache, &block)
         new_middleware = Array.wrap(new_middleware)
         updated_middleware = new_middleware + internal_middleware
-        continue_chain(updated_middleware, internal_context, &block)
+        continue_chain(updated_middleware, internal_context, cache: cache, &block)
       end
 
-      def insert_after(new_middleware, existing_middleware, &block)
+      def insert_after(new_middleware, existing_middleware, cache: @cache, &block)
         new_middleware = Array.wrap(new_middleware)
         index = internal_middleware.index(existing_middleware)
         updated_middleware = internal_middleware.insert(index + 1, *new_middleware)
-        continue_chain(updated_middleware, internal_context, &block)
+        continue_chain(updated_middleware, internal_context, cache: cache, &block)
       end
 
-      def append(new_middleware, &block)
+      def append(new_middleware, cache: @cache, &block)
         new_middleware = Array.wrap(new_middleware)
         updated_middleware = internal_middleware + new_middleware
-        continue_chain(updated_middleware, internal_context, &block)
+        continue_chain(updated_middleware, internal_context, cache: cache, &block)
       end
 
       def context(new_context = nil, &block)
@@ -85,7 +94,7 @@ module Arel
 
         return internal_context if new_context.nil?
 
-        continue_chain(internal_middleware, new_context, &block)
+        continue_chain(internal_middleware, new_context, cache: @cache, &block)
       end
 
       def to_sql(type, &block)
@@ -109,8 +118,23 @@ module Arel
 
       private
 
-      def continue_chain(middleware, context, &block)
-        new_chain = Arel::Middleware::Chain.new(middleware, context)
+      def execute_with_middleware(sql, binds, execute_sql)
+        check_middleware_recursion(sql)
+
+        updated_context = context.merge(
+          original_sql: sql,
+          original_binds: binds,
+          cache_accessor: cache_accessor,
+        )
+
+        arel = Arel.sql_to_arel(sql, binds: binds)
+        enhanced_arel = Arel.enhance(arel)
+
+        executor.run(enhanced_arel, updated_context, execute_sql)
+      end
+
+      def continue_chain(middleware, context, cache:, &block)
+        new_chain = Arel::Middleware::Chain.new(middleware, context, cache: cache)
         maybe_execute_block(new_chain, &block)
       end
 
@@ -125,7 +149,7 @@ module Arel
       end
 
       def check_middleware_recursion(sql)
-        if executing_middleware
+        if executing_middleware_depth > MAX_RECURSION_DEPTH
           message = <<~ERROR
             Middleware is being called from within middleware, aborting execution
             to prevent endless recursion. You can do the following if you want to execute SQL
@@ -140,7 +164,7 @@ module Arel
 
           raise message
         else
-          @executing_middleware = true
+          @executing_middleware_depth += 1
         end
       end
     end