arel_toolkit 0.4.0 → 0.4.5

data/lib/arel/extensions/least.rb

@@ -1,9 +1,23 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
 module Arel
   module Nodes
-    class Least < Arel::Nodes::NamedFunction
-      def initialize(args)
-        super 'LEAST', args
+    # https://www.postgresql.org/docs/10/functions-conditional.html
+    class Least < Arel::Nodes::Unary
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_Least(o, collector)
+        collector << 'LEAST('
+        collector = inject_join(o.expr, collector, ', ')
+        collector << ')'
       end
     end
   end
 end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/node.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Nodes
+    class Node
+      def to_sql_and_binds(engine = Arel::Table.engine)
+        collector = engine.connection.send(:collector)
+        engine.connection.visitor.accept(self, collector).value
+      end
+    end
+  end
+end

data/lib/arel/extensions/range_function.rb

@@ -5,15 +5,23 @@ module Arel
   module Nodes
     # Postgres: https://www.postgresql.org/docs/9.4/sql-select.html
     class RangeFunction < Arel::Nodes::Unary
+      attr_reader :is_rowsfrom
+
+      def initialize(*args, is_rowsfrom:, **kwargs)
+        @is_rowsfrom = is_rowsfrom
+        super(*args, **kwargs)
+      end
     end
   end
 
   module Visitors
     class ToSql
       def visit_Arel_Nodes_RangeFunction(o, collector)
-        collector << 'ROWS FROM ('
+        collector << 'ROWS FROM (' if o.is_rowsfrom
         visit o.expr, collector
-        collector << ')'
+        collector << ')' if o.is_rowsfrom
+
+        collector
       end
     end
   end

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
@@ -45,6 +59,7 @@ module Arel
           super
 
           visit_edge o, 'into'
+          visit_edge o, 'top'
         end
       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/tree_manager.rb

@@ -6,5 +6,10 @@ module Arel
 
       ::Arel::Visitors::DepthFirst.new(block).accept ast
     end
+
+    def to_sql_and_binds(engine = Arel::Table.engine)
+      collector = engine.connection.send(:collector)
+      engine.connection.visitor.accept(@ast, collector).value
+    end
   end
 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.rb

@@ -1,6 +1,10 @@
-require 'active_record'
+require_relative './middleware/active_record_extension'
 require_relative './middleware/railtie'
 require_relative './middleware/chain'
+require_relative './middleware/database_executor'
+require_relative './middleware/to_sql_executor'
+require_relative './middleware/to_sql_middleware'
+require_relative './middleware/result'
 require_relative './middleware/postgresql_adapter'
 
 module Arel

data/lib/arel/middleware/active_record_extension.rb

@@ -0,0 +1,13 @@
+module Arel
+  module Middleware
+    module ActiveRecordExtension
+      def load_schema!
+        # Prevent Rails from memoizing an empty response when using `Arel.middleware.to_sql`.
+        # Re-applying the middleware will use the database executor to fetch the actual data.
+        Arel.middleware.apply(Arel.middleware.current) do
+          super
+        end
+      end
+    end
+  end
+end

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,60 +1,90 @@
+require_relative './no_op_cache'
+require_relative './cache_accessor'
+
 module Arel
   module Middleware
     class Chain
-      def initialize(internal_middleware = [], internal_context = {})
+      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,
+        cache: nil
+      )
         @internal_middleware = internal_middleware
         @internal_context = internal_context
+        @executor = executor_class.new(internal_middleware)
+        @executing_middleware_depth = 0
+        @cache = cache || NoOpCache
       end
 
-      def execute(sql, binds = [])
-        return sql if internal_middleware.length.zero?
+      def cache_accessor
+        @cache_accessor ||= CacheAccessor.new @cache
+      end
 
-        result = Arel.sql_to_arel(sql, binds: binds)
-        updated_context = context.merge(original_sql: sql)
+      def execute(sql, binds = [], &execute_sql)
+        return execute_sql.call(sql, binds).to_casted_result if internal_middleware.length.zero?
 
-        internal_middleware.each do |middleware_item|
-          result = result.map do |arel|
-            middleware_item.call(arel, updated_context.dup)
-          end
+        if (cached_sql = cache_accessor.read(sql))
+          return execute_sql.call(cached_sql, binds).to_casted_result
         end
 
-        result.to_sql
+        execute_with_middleware(sql, binds, execute_sql).to_casted_result
+      rescue ::PgQuery::ParseError
+        execute_sql.call(sql, binds)
+      ensure
+        @executing_middleware_depth -= 1
       end
 
       def current
         internal_middleware.dup
       end
 
-      def apply(middleware, &block)
-        continue_chain(middleware, internal_context, &block)
+      def apply(middleware, cache: @cache, &block)
+        new_middleware = Array.wrap(middleware)
+        continue_chain(new_middleware, internal_context, cache: cache, &block)
       end
+      alias only apply
 
-      def only(middleware, &block)
-        continue_chain(middleware, internal_context, &block)
+      def none(&block)
+        continue_chain([], internal_context, cache: cache, &block)
       end
 
-      def none(&block)
-        continue_chain([], internal_context, &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, cache: cache, &block)
       end
 
-      def except(without_middleware, &block)
-        new_middleware = internal_middleware.reject do |middleware|
-          middleware == without_middleware
-        end
+      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, cache: cache, &block)
+      end
 
-        continue_chain(new_middleware, internal_context, &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, cache: cache, &block)
       end
 
-      def insert_before(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, new_middleware)
-        continue_chain(updated_middleware, internal_context, &block)
+        updated_middleware = internal_middleware.insert(index + 1, *new_middleware)
+        continue_chain(updated_middleware, internal_context, cache: cache, &block)
       end
 
-      def insert_after(new_middleware, existing_middleware, &block)
-        index = internal_middleware.index(existing_middleware)
-        updated_middleware = internal_middleware.insert(index + 1, new_middleware)
-        continue_chain(updated_middleware, internal_context, &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, cache: cache, &block)
       end
 
       def context(new_context = nil, &block)
@@ -64,7 +94,21 @@ 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)
+        middleware = Arel::Middleware::ToSqlMiddleware.new(type)
+
+        new_chain = Arel::Middleware::Chain.new(
+          internal_middleware + [middleware],
+          internal_context,
+          Arel::Middleware::ToSqlExecutor,
+        )
+
+        maybe_execute_block(new_chain, &block)
+
+        middleware.sql
       end
 
       protected
@@ -74,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
 
@@ -88,6 +147,26 @@ module Arel
       ensure
         Arel::Middleware.current_chain = previous_chain
       end
+
+      def check_middleware_recursion(sql)
+        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
+            inside middleware:
+
+              - Set middleware context before entering the middleware
+              - Use `Arel.middleware.none { ... }` to temporarily disable middleware
+
+            SQL that triggered the error:
+            #{sql}
+          ERROR
+
+          raise message
+        else
+          @executing_middleware_depth += 1
+        end
+      end
     end
   end
 end