arel_toolkit 0.3.0 → 0.4.4

data/lib/arel/extensions/time_with_precision.rb

@@ -10,4 +10,10 @@ module Arel
       end
     end
   end
+
+  module Visitors
+    class Dot
+      alias visit_Arel_Nodes_TimeWithPrecision terminal
+    end
+  end
 end

data/lib/arel/extensions/to_sql.rb

@@ -0,0 +1,27 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_Arel_Attributes_Attribute(o, collector)
+        if o.relation
+          join_name = o.relation.table_alias || o.relation.name
+          collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
+        else
+          visit_Arel_Nodes_UnqualifiedColumn o, collector
+        end
+      end
+
+      alias visit_Arel_Attributes_Integer visit_Arel_Attributes_Attribute
+      alias visit_Arel_Attributes_Float visit_Arel_Attributes_Attribute
+      alias visit_Arel_Attributes_Decimal visit_Arel_Attributes_Attribute
+      alias visit_Arel_Attributes_String visit_Arel_Attributes_Attribute
+      alias visit_Arel_Attributes_Time visit_Arel_Attributes_Attribute
+      alias visit_Arel_Attributes_Boolean visit_Arel_Attributes_Attribute
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

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

@@ -6,14 +6,9 @@
 module Arel
   module Nodes
     # https://www.postgresql.org/docs/8.3/tutorial-transactions.html
-    class Transaction < Arel::Nodes::Node
-      attr_reader :type
-      attr_reader :options
-
-      def initialize(type, options)
-        @type = type
-        @options = options
-      end
+    class Transaction < Arel::Nodes::Binary
+      alias type left
+      alias options right
     end
   end
 

data/lib/arel/extensions/tree_manager.rb

@@ -0,0 +1,15 @@
+module Arel
+  class TreeManager
+    # Iterate through AST, nodes will be yielded depth-first
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      ::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/trim.rb

@@ -29,6 +29,14 @@ module Arel
         collector << ')'
       end
     end
+
+    class Dot
+      def visit_Arel_Nodes_Trim(o)
+        visit_edge o, 'type'
+        visit_edge o, 'substring'
+        visit_edge o, 'string'
+      end
+    end
   end
 end
 

data/lib/arel/extensions/true.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Visitors
+    class Dot
+      alias visit_Arel_Nodes_True terminal
+    end
+  end
+end

data/lib/arel/extensions/type_cast.rb

@@ -27,6 +27,13 @@ module Arel
         collector << o.type_name
       end
     end
+
+    class Dot
+      def visit_Arel_Nodes_TypeCast(o)
+        visit_edge(o, 'arg')
+        visit_edge(o, 'type_name')
+      end
+    end
   end
 end
 

data/lib/arel/extensions/unary.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Visitors
+    class Dot
+      alias visit_Arel_Nodes_Unary unary
+    end
+  end
+end

data/lib/arel/extensions/unary_operation.rb

@@ -0,0 +1,16 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Visitors
+    class Dot
+      def visit_Arel_Nodes_UnaryOperation(o)
+        visit_edge o, 'operator'
+        visit_edge o, 'expr'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/unknown.rb

@@ -13,6 +13,10 @@ module Arel
         collector << 'UNKNOWN'
       end
     end
+
+    class Dot
+      alias visit_Arel_Nodes_Unknown terminal
+    end
   end
 end
 

data/lib/arel/extensions/update_manager.rb

@@ -1,9 +1,25 @@
-Arel::UpdateManager.class_eval do
-  def ==(other)
-    @ast == other.ast && @ctx == other.ctx
-  end
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  class UpdateManager < Arel::TreeManager
+    def ==(other)
+      other.is_a?(self.class) && @ast == other.ast && @ctx == other.ctx
+    end
+
+    protected
 
-  protected
+    attr_reader :ctx
+  end
 
-  attr_reader :ctx
+  module Visitors
+    class Dot
+      def visit_Arel_UpdateManager(o)
+        visit_edge o, 'ast'
+      end
+    end
+  end
 end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/update_statement.rb

@@ -3,34 +3,38 @@
 
 module Arel
   module Nodes
-    # https://www.postgresql.org/docs/10/sql-update.html
-    Arel::Nodes::UpdateStatement.class_eval do
-      attr_accessor :with
-      attr_accessor :froms
-      attr_accessor :returning
+    class UpdateStatement
+      module UpdateStatementExtension
+        # https://www.postgresql.org/docs/10/sql-update.html
+        attr_accessor :with
+        attr_accessor :froms
+        attr_accessor :returning
 
-      alias_method :old_initialize, :initialize
-      def initialize
-        old_initialize
+        def initialize
+          super
 
-        @froms = []
-        @returning = []
+          @froms = []
+          @returning = []
+        end
       end
+
+      prepend UpdateStatementExtension
     end
   end
 
   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)])]
@@ -38,31 +42,30 @@ 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
+      module UpdateStatementExtension
+        def visit_Arel_Nodes_UpdateStatement(o)
+          super
+
+          visit_edge o, 'with'
+          visit_edge o, 'froms'
+          visit_edge o, 'returning'
+        end
+      end
+
+      prepend UpdateStatementExtension
     end
   end
 end

data/lib/arel/extensions/user.rb

@@ -13,6 +13,10 @@ module Arel
         collector << 'user'
       end
     end
+
+    class Dot
+      alias visit_Arel_Nodes_User terminal
+    end
   end
 end
 

data/lib/arel/extensions/values_list.rb

@@ -0,0 +1,15 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Visitors
+    class Dot
+      def visit_Arel_Nodes_ValuesList(o)
+        visit_edge o, 'rows'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/variable_set.rb

@@ -39,6 +39,15 @@ module Arel
         end
       end
     end
+
+    class Dot
+      def visit_Arel_Nodes_VariableSet(o)
+        visit_edge o, 'type'
+        visit_edge o, 'args'
+        visit_edge o, 'name'
+        visit_edge o, 'local'
+      end
+    end
   end
 end
 

data/lib/arel/extensions/variable_show.rb

@@ -4,12 +4,7 @@
 module Arel
   module Nodes
     # https://www.postgresql.org/docs/9.1/sql-show.html
-    class VariableShow < Arel::Nodes::Node
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
+    class VariableShow < Arel::Nodes::Unary
     end
   end
 
@@ -17,10 +12,10 @@ module Arel
     class ToSql
       def visit_Arel_Nodes_VariableShow(o, collector)
         collector << 'SHOW '
-        collector << if o.name == 'timezone'
+        collector << if o.expr == 'timezone'
                        'TIME ZONE'
                      else
-                       o.name
+                       o.expr
                      end
       end
     end

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)
-          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
 
@@ -89,8 +148,24 @@ module Arel
         Arel::Middleware.current_chain = previous_chain
       end
 
-      def current_chain
-        Arel::Middleware.current_chain
+      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