arel_toolkit 0.4.0 → 0.4.1

data/lib/arel/extensions/active_model_attribute_with_cast_value.rb

@@ -0,0 +1,22 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Visitors
+    class Dot
+      def visit_ActiveModel_Attribute_WithCastValue(o)
+        visit_edge o, 'name'
+        visit_edge o, 'value_before_type_cast'
+      end
+    end
+
+    class ToSql
+      def visit_ActiveModel_Attribute_WithCastValue(_o, collector)
+        collector
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/active_record_relation_query_attribute.rb

@@ -0,0 +1,22 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Visitors
+    class Dot
+      def visit_ActiveRecord_Relation_QueryAttribute(o)
+        visit_edge o, 'name'
+        visit_edge o, 'value_before_type_cast'
+      end
+    end
+
+    class ToSql
+      def visit_ActiveRecord_Relation_QueryAttribute(_o, collector)
+        collector
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/active_record_type_caster_connection.rb

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

data/lib/arel/extensions/attributes_attribute.rb

@@ -0,0 +1,47 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Attributes
+    class Attribute
+      module AttributeExtension
+        # postgres only: https://www.postgresql.org/docs/10/ddl-schemas.html
+        attr_accessor :schema_name
+        attr_accessor :database
+      end
+
+      prepend AttributeExtension
+    end
+  end
+
+  module Visitors
+    class ToSql
+      module AttributesAttributeExtension
+        def visit_Arel_Attributes_Attribute(o, collector)
+          collector << "#{quote_table_name(o.database)}." if o.database
+          collector << "#{quote_table_name(o.schema_name)}." if o.schema_name
+
+          super
+        end
+      end
+
+      prepend AttributesAttributeExtension
+    end
+
+    class Dot
+      module AttributesAttributeExtension
+        def visit_Arel_Attributes_Attribute(o)
+          super
+
+          visit_edge o, 'schema_name'
+          visit_edge o, 'database'
+        end
+      end
+
+      prepend AttributesAttributeExtension
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/bind_param.rb

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

data/lib/arel/extensions/coalesce.rb

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

data/lib/arel/extensions/exists.rb

@@ -0,0 +1,59 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # This is a copy of https://github.com/rails/arel/blob/v9.0.0/lib/arel/nodes/function.rb
+    # Only difference is the superclass, because EXISTS is not a function but a subquery expression.
+    # Semantic meaning is important when transforming the Arel using the enhanced AST,
+    # because EXISTS cannot be processed as a function. For example it does not have a schema
+    # like a normal function.
+    #
+    # To change the superclass we're removing the existing Exists class `Arel::Nodes::Exists`
+    # and recreating it extending from `Arel::Nodes::Unary`.
+    remove_const(:Exists)
+
+    # https://www.postgresql.org/docs/10/functions-subquery.html
+    class Exists < Arel::Nodes::Unary
+      include Arel::Predications
+      include Arel::WindowPredications
+      include Arel::OrderPredications
+      attr_accessor :expressions, :alias, :distinct
+
+      def initialize(expr, aliaz = nil)
+        @expressions = expr
+        @alias       = aliaz && SqlLiteral.new(aliaz)
+        @distinct    = false
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@expressions, @alias, @distinct].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          expressions == other.expressions &&
+          self.alias == other.alias &&
+          distinct == other.distinct
+      end
+      alias == eql?
+    end
+  end
+
+  module Visitors
+    class Dot
+      def visit_Arel_Nodes_Exists(o)
+        visit_edge o, 'expressions'
+        visit_edge o, 'alias'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/function.rb

@@ -80,13 +80,14 @@ module Arel
           visit_edge o, 'filter'
           visit_edge o, 'within_group'
           visit_edge o, 'variardic'
+          visit_edge o, 'schema_name'
         end
 
-        alias visit_Arel_Nodes_Exists function
         alias visit_Arel_Nodes_Min    function
         alias visit_Arel_Nodes_Max    function
         alias visit_Arel_Nodes_Avg    function
         alias visit_Arel_Nodes_Sum    function
+        alias visit_Arel_Nodes_Count  function
       end
 
       prepend FunctionExtension

data/lib/arel/extensions/greatest.rb

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

data/lib/arel/extensions/insert_statement.rb

@@ -5,7 +5,7 @@ module Arel
   module Nodes
     class InsertStatement
       # https://www.postgresql.org/docs/9.5/sql-insert.html
-      module InsertStatementExtensions
+      module InsertStatementExtension
         attr_accessor :with
         attr_accessor :conflict
         attr_accessor :override
@@ -18,7 +18,7 @@ module Arel
         end
       end
 
-      prepend(InsertStatementExtensions)
+      prepend(InsertStatementExtension)
     end
   end
 

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

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

@@ -1,24 +1,35 @@
 module Arel
   module Middleware
     class Chain
-      def initialize(internal_middleware = [], internal_context = {})
+      attr_reader :executing_middleware
+      attr_reader :executor
+
+      def initialize(
+        internal_middleware = [],
+        internal_context = {},
+        executor_class = Arel::Middleware::DatabaseExecutor
+      )
         @internal_middleware = internal_middleware
         @internal_context = internal_context
+        @executor = executor_class.new(internal_middleware)
+        @executing_middleware = false
       end
 
-      def execute(sql, binds = [])
-        return sql if internal_middleware.length.zero?
+      def execute(sql, binds = [], &execute_sql)
+        return execute_sql.call(sql, binds).to_casted_result if internal_middleware.length.zero?
+
+        check_middleware_recursion(sql)
 
-        result = Arel.sql_to_arel(sql, binds: binds)
         updated_context = context.merge(original_sql: sql)
+        enhanced_arel = Arel.enhance(Arel.sql_to_arel(sql, binds: binds))
 
-        internal_middleware.each do |middleware_item|
-          result = result.map do |arel|
-            middleware_item.call(arel, updated_context.dup)
-          end
-        end
+        result = executor.run(enhanced_arel, updated_context, execute_sql)
 
-        result.to_sql
+        result.to_casted_result
+      rescue ::PgQuery::ParseError
+        execute_sql.call(sql, binds)
+      ensure
+        @executing_middleware = false
       end
 
       def current
@@ -26,34 +37,44 @@ module Arel
       end
 
       def apply(middleware, &block)
-        continue_chain(middleware, internal_context, &block)
-      end
-
-      def only(middleware, &block)
-        continue_chain(middleware, internal_context, &block)
+        new_middleware = Array.wrap(middleware)
+        continue_chain(new_middleware, internal_context, &block)
       end
+      alias only apply
 
       def none(&block)
         continue_chain([], internal_context, &block)
       end
 
       def except(without_middleware, &block)
-        new_middleware = internal_middleware.reject do |middleware|
-          middleware == without_middleware
-        end
-
+        without_middleware = Array.wrap(without_middleware)
+        new_middleware = internal_middleware - without_middleware
         continue_chain(new_middleware, internal_context, &block)
       end
 
       def insert_before(new_middleware, existing_middleware, &block)
+        new_middleware = Array.wrap(new_middleware)
         index = internal_middleware.index(existing_middleware)
-        updated_middleware = internal_middleware.insert(index, new_middleware)
+        updated_middleware = internal_middleware.insert(index, *new_middleware)
+        continue_chain(updated_middleware, internal_context, &block)
+      end
+
+      def prepend(new_middleware, &block)
+        new_middleware = Array.wrap(new_middleware)
+        updated_middleware = new_middleware + internal_middleware
         continue_chain(updated_middleware, internal_context, &block)
       end
 
       def insert_after(new_middleware, existing_middleware, &block)
+        new_middleware = Array.wrap(new_middleware)
         index = internal_middleware.index(existing_middleware)
-        updated_middleware = internal_middleware.insert(index + 1, new_middleware)
+        updated_middleware = internal_middleware.insert(index + 1, *new_middleware)
+        continue_chain(updated_middleware, internal_context, &block)
+      end
+
+      def append(new_middleware, &block)
+        new_middleware = Array.wrap(new_middleware)
+        updated_middleware = internal_middleware + new_middleware
         continue_chain(updated_middleware, internal_context, &block)
       end
 
@@ -67,6 +88,20 @@ module Arel
         continue_chain(internal_middleware, new_context, &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
@@ -88,6 +123,26 @@ module Arel
       ensure
         Arel::Middleware.current_chain = previous_chain
       end
+
+      def check_middleware_recursion(sql)
+        if executing_middleware
+          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 = true
+        end
+      end
     end
   end
 end