arel_toolkit 0.2.0 → 0.4.3

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

@@ -0,0 +1,44 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/10/functions-string.html
+    class Trim < Arel::Nodes::Node
+      attr_reader :type
+      attr_reader :substring
+      attr_reader :string
+
+      def initialize(type, substring, string)
+        @type = type
+        @substring = substring
+        @string = string
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_Trim(o, collector)
+        collector << "trim(#{o.type} "
+        if o.substring
+          visit o.substring, collector
+          collector << ' from '
+        end
+        visit o.string, collector
+        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
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

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

@@ -12,6 +12,10 @@ module Arel
         @arg = arg
         @type_name = type_name
       end
+
+      def ==(other)
+        arg == other.arg && type_name == other.type_name
+      end
     end
   end
 
@@ -23,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

@@ -0,0 +1,25 @@
+# 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
+
+    attr_reader :ctx
+  end
+
+  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,11 +3,22 @@
 
 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
+
+        def initialize
+          super
+
+          @froms = []
+          @returning = []
+        end
+      end
+
+      prepend UpdateStatementExtension
     end
   end
 
@@ -19,7 +30,7 @@ module Arel
       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?
@@ -56,6 +67,20 @@ module Arel
       # 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

@@ -0,0 +1,55 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/9.3/sql-set.html
+    class VariableSet < Arel::Nodes::Node
+      attr_reader :type
+      attr_reader :args
+      attr_reader :name
+      attr_reader :local
+
+      def initialize(type, args, name, local)
+        @type = type
+        @args = args
+        @name = name
+        @local = local
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_VariableSet(o, collector)
+        collector << 'SET '
+        collector << 'LOCAL ' if o.local
+
+        if o.name == 'timezone'
+          collector << 'TIME ZONE '
+        else
+          collector << o.name
+          collector << ' TO '
+        end
+
+        if o.args.empty?
+          collector << 'DEFAULT'
+        else
+          inject_join(o.args, collector, ', ')
+        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
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/variable_show.rb

@@ -0,0 +1,26 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/9.1/sql-show.html
+    class VariableShow < Arel::Nodes::Unary
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_VariableShow(o, collector)
+        collector << 'SHOW '
+        collector << if o.expr == 'timezone'
+                       'TIME ZONE'
+                     else
+                       o.expr
+                     end
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/middleware.rb

@@ -0,0 +1,27 @@
+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
+  module Middleware
+    class << self
+      def current_chain
+        Thread.current[:arel_toolkit_middleware_current_chain] ||=
+          Arel::Middleware::Chain.new
+      end
+
+      def current_chain=(new_chain)
+        Thread.current[:arel_toolkit_middleware_current_chain] = new_chain
+      end
+    end
+  end
+
+  def self.middleware
+    Arel::Middleware.current_chain
+  end
+end

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

@@ -0,0 +1,172 @@
+require_relative './no_op_cache'
+require_relative './cache_accessor'
+
+module Arel
+  module Middleware
+    class Chain
+      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 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?
+
+        if (cached_sql = cache_accessor.read(sql))
+          return execute_sql.call(cached_sql, binds).to_casted_result
+        end
+
+        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, cache: @cache, &block)
+        new_middleware = Array.wrap(middleware)
+        continue_chain(new_middleware, internal_context, cache: cache, &block)
+      end
+      alias only apply
+
+      def none(&block)
+        continue_chain([], internal_context, cache: cache, &block)
+      end
+
+      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 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
+
+      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_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, cache: cache, &block)
+      end
+
+      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)
+        if new_context.nil? && !block.nil?
+          raise 'You cannot do a block statement while calling context without arguments'
+        end
+
+        return internal_context if new_context.nil?
+
+        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
+
+      attr_reader :internal_middleware
+      attr_reader :internal_context
+
+      private
+
+      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
+
+      def maybe_execute_block(new_chain, &block)
+        return new_chain if block.nil?
+
+        previous_chain = Middleware.current_chain
+        Arel::Middleware.current_chain = new_chain
+        yield block
+      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