arel_extensions 2.0.21 → 2.2.2

data/lib/arel_extensions/visitors.rb

@@ -1,6 +1,32 @@
+# MSSQL visitors for java and rails ≥ 7 are painful to work with:
+# requiring the exact path to the visitor is needed even if the
+# AR adapter was loaded. It's also needed exactly here because:
+# 1. putting it inside the visitor or anywhere else will not
+#    guarantee its actual loading.
+# 2. it needs to load before arel_extensions/visitors.
+if RUBY_PLATFORM == 'java' \
+  && RUBY_ENGINE == 'jruby' \
+  && (version = JRUBY_VERSION.split('.').map(&:to_i)) && version[0] == 9 && version[1] >= 4 \
+  && Gem::Specification.find { |g| g.name == 'jdbc-mssql' }
+  begin
+    require 'arel/visitors/sqlserver'
+  rescue LoadError
+    warn 'arel/visitors/sqlserver not found: MSSQL might not work correctly.'
+  end
+elsif RUBY_PLATFORM != 'java' \
+  && Arel::VERSION.to_i < 10 \
+  && Gem::Specification.find { |g| g.name == 'activerecord-sqlserver-adapter' }
+  begin
+    require 'arel_sqlserver'
+  rescue LoadError
+    warn 'arel_sqlserver not found: SQLServer Visitor might not work correctly.'
+  end
+end
+
 require 'arel_extensions/visitors/convert_format'
 require 'arel_extensions/visitors/to_sql'
 require 'arel_extensions/visitors/mysql'
+require 'arel_extensions/visitors/mssql'
 require 'arel_extensions/visitors/postgresql'
 require 'arel_extensions/visitors/sqlite'
 
@@ -9,81 +35,68 @@ if defined?(Arel::Visitors::Oracle)
   require 'arel_extensions/visitors/oracle12'
 end
 
-if defined?(Arel::Visitors::MSSQL)
-  require 'arel_extensions/visitors/mssql'
-
-  class Arel::Visitors::MSSQL
+if defined?(Arel::Visitors::SQLServer)
+  class Arel::Visitors::SQLServer
     include ArelExtensions::Visitors::MSSQL
+  end
+end
 
-    alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
-    def visit_Arel_Nodes_As o, collector
-      if o.left.is_a?(Arel::Nodes::Binary)
-        collector << '('
-        collector = visit o.left, collector
-        collector << ')'
-      else
-        collector = visit o.left, collector
-      end
-      collector << " AS ["
-      collector = visit o.right, collector
-      collector << "]"
-      collector
+if defined?(Arel::Visitors::DepthFirst)
+  class Arel::Visitors::DepthFirst
+    def visit_Arel_SelectManager o
+        visit o.ast
     end
+  end
+end
 
-    alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
+if defined?(Arel::Visitors::MSSQL)
+  class Arel::Visitors::MSSQL
+    include ArelExtensions::Visitors::MSSQL
+
+    alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement)
     def visit_Arel_Nodes_SelectStatement o, collector
       if !collector.value.blank? && o.limit.blank? && o.offset.blank?
         o = o.dup
         o.orders = []
       end
-      old_visit_Arel_Nodes_SelectStatement(o,collector)
+      old_visit_Arel_Nodes_SelectStatement(o, collector)
     end
   end
+end
 
-  begin
-    require 'arel_sqlserver'
-    if Arel::VERSION.to_i == 6
-      if Arel::Visitors::VISITORS['sqlserver'] && Arel::Visitors::VISITORS['sqlserver'] != Arel::Visitors::MSSQL
-        Arel::Visitors::VISITORS['sqlserver'].class_eval do
-          include ArelExtensions::Visitors::MSSQL
-
-          alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
-          def visit_Arel_Nodes_SelectStatement o, collector
-            if !collector.value.blank? && o.limit.blank? && o.offset.blank?
-              o = o.dup
-              o.orders = []
-            end
-            old_visit_Arel_Nodes_SelectStatement(o,collector)
-          end
-
-          alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
-          def visit_Arel_Nodes_As o, collector
-            if o.left.is_a?(Arel::Nodes::Binary)
-              collector << '('
-              collector = visit o.left, collector
-              collector << ')'
-            else
-              collector = visit o.left, collector
-            end
-            collector << " AS ["
-            collector = visit o.right, collector
-            collector << "]"
-            collector
-          end
+if defined?(Arel::Visitors::SQLServer)
+  class Arel::Visitors::SQLServer
+    include ArelExtensions::Visitors::MSSQL
 
-          alias_method(:old_primary_Key_From_Table, :primary_Key_From_Table) rescue nil
-          def primary_Key_From_Table t
-            return unless t
+    # There's a bug when working with jruby 9.4 that prevents us from
+    # refactoring this and putting it in the main module, or even in a separate
+    # module then including it.
+    #
+    # Reason: the line in this file that does:
+    #
+    #   require 'arel_extensions/visitors/mssql'
+    #
+    # The error could be seen by:
+    #
+    #   1. placing the visit_ inside the visitor, or placing it in a module
+    #      then including it here.
+    #   2. replacing the `rescue nil` from aliasing trick, and printing the
+    #      error.
+    #
+    # It complains that the visit_ does not exist in the module, as if it's
+    # evaluating the module eagerly, instead of lazily like in other versions
+    # of ruby.
+    #
+    # It might be something different, but this is the first thing we should
+    # investigate.
 
-            column_name = @connection.schema_cache.primary_keys(t.name) ||
-                          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
-            column_name ? t[column_name] : nil
-          end
-        end
+    alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
+    def visit_Arel_Nodes_SelectStatement o, collector
+      if !collector.value.blank? && o.limit.blank? && o.offset.blank?
+        o = o.dup
+        o.orders = []
       end
+      old_visit_Arel_Nodes_SelectStatement(o, collector)
     end
-  rescue LoadError
-  rescue => e
-      e
   end
 end

data/lib/arel_extensions.rb

@@ -1,4 +1,5 @@
 require 'arel'
+require 'base64'
 
 require 'arel_extensions/railtie' if defined?(Rails::Railtie)
 
@@ -16,7 +17,7 @@ class Arel::Nodes::Casted
   include Arel::AliasPredication
 
   # They forget to define hash.
-  if Gem::Version.new(Arel::VERSION) < Gem::Version.new("10.0.0")
+  if Gem::Version.new(Arel::VERSION) < Gem::Version.new('10.0.0')
     def hash
       [self.class, self.val, self.attribute].hash
     end
@@ -34,9 +35,9 @@ class Arel::Nodes::Grouping
 end
 
 class Arel::Nodes::Ordering
-	def eql? other
-		self.hash.eql? other.hash
-	end
+  def eql? other
+    self.hash.eql? other.hash
+  end
 end
 
 class Arel::Nodes::Function
@@ -44,14 +45,16 @@ class Arel::Nodes::Function
   include Arel::Expressions
 end
 
-if Gem::Version.new(Arel::VERSION) >= Gem::Version.new("7.1.0")
+if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('7.1.0')
   class Arel::Nodes::Case
     include Arel::Math
     include Arel::Expressions
   end
 end
 
+require 'arel_extensions/helpers'
 require 'arel_extensions/version'
+require 'arel_extensions/aliases'
 require 'arel_extensions/attributes'
 require 'arel_extensions/visitors'
 require 'arel_extensions/nodes'
@@ -75,45 +78,107 @@ require 'arel_extensions/nodes/case'
 require 'arel_extensions/nodes/soundex'
 require 'arel_extensions/nodes/cast'
 require 'arel_extensions/nodes/json'
+require 'arel_extensions/nodes/rollup'
+require 'arel_extensions/nodes/select'
+
+# It seems like the code in lib/arel_extensions/visitors.rb that is supposed
+# to inject ArelExtension is not enough. Different versions of the sqlserver
+# adapter behave differently. It doesn't always proc, so we added this for
+# coverage.
+if defined?(Arel::Visitors::SQLServer)
+  Arel::Visitors.const_set('MSSQL', Arel::Visitors::SQLServer)
+  require 'arel_extensions/visitors/mssql'
+  class Arel::Visitors::SQLServer
+    include ArelExtensions::Visitors::MSSQL
+  end
+end
 
+module Arel
+  def self.column_of table_name, column_name
+    ArelExtensions.column_of(table_name, column_name)
+  end
 
+  def self.duration s, expr
+    ArelExtensions::Nodes::Duration.new("#{s}i", expr)
+  end
 
-module Arel
-  def self.rand
-    ArelExtensions::Nodes::Rand.new
+  # The FALSE pseudo literal.
+  def self.false
+    Arel::Nodes::Equality.new(1, 0)
   end
 
-  def self.shorten s
-    Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
+  def self.grouping *v
+    Arel::Nodes::Grouping.new(*v)
   end
 
   def self.json *expr
-    if expr.length == 1
-      ArelExtensions::Nodes::Json.new(expr.first)
-    else
-      ArelExtensions::Nodes::Json.new(expr)
-    end
+    ArelExtensions::Nodes::Json.new(
+      if expr.length == 1
+        expr.first
+      else
+        expr
+      end
+    )
   end
 
-  def self.when condition
-    ArelExtensions::Nodes::Case.new.when(condition)
+  def self.json_true
+    res = Arel.grouping(Arel.quoted('true'))
+    res.instance_eval {
+      def return_type
+        :boolean
+      end
+    }
+    res
   end
 
-  def self.duration s, expr
-    ArelExtensions::Nodes::Duration.new(s.to_s+'i',expr)
+  def self.json_false
+    res = Arel.grouping(Arel.quoted('false'))
+    res.instance_eval {
+      def return_type
+        :boolean
+      end
+    }
+    res
   end
 
-  def self.true
-    Arel::Nodes::Equality.new(1,1)
+  # The NULL literal.
+  def self.null
+    Arel.quoted(nil)
   end
 
-  def self.false
-    Arel::Nodes::Equality.new(1,0)
+  def self.quoted *args
+    Arel::Nodes.build_quoted(*args)
+  end
+
+  def self.rand
+    ArelExtensions::Nodes::Rand.new
+  end
+
+  def self.rollup(*args)
+    Arel::Nodes::RollUp.new(args)
+  end
+
+  def self.shorten s
+    Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
+  end
+
+  # The TRUE pseudo literal.
+  def self.true
+    Arel::Nodes::Equality.new(1, 1)
   end
 
   def self.tuple *v
-    tmp = Arel::Nodes::Grouping.new(nil)
-    Arel::Nodes::Grouping.new(v.map{|e| tmp.convert_to_node(e)})
+    tmp = Arel.grouping(nil)
+    Arel.grouping v.map{|e| tmp.convert_to_node(e)}
+  end
+
+  # For instance
+  #
+  # ```
+  # Arel.when(at[field].is_null).then(0).else(1)
+  # ```
+  def self.when condition
+    ArelExtensions::Nodes::Case.new.when(condition)
   end
 end
 
@@ -123,6 +188,7 @@ class Arel::Attributes::Attribute
 end
 
 class Arel::Nodes::Function
+  include ArelExtensions::Aliases
   include ArelExtensions::Math
   include ArelExtensions::Comparators
   include ArelExtensions::DateDuration
@@ -135,7 +201,7 @@ class Arel::Nodes::Function
   alias_method(:old_as, :as) rescue nil
   def as other
     res = Arel::Nodes::As.new(self.clone, Arel.sql(other))
-    if Gem::Version.new(Arel::VERSION) >= Gem::Version.new("9.0.0")
+    if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
       self.alias = Arel.sql(other)
     end
     res
@@ -143,13 +209,13 @@ class Arel::Nodes::Function
 end
 
 class Arel::Nodes::Grouping
-    include ArelExtensions::Math
-    include ArelExtensions::Comparators
-    include ArelExtensions::DateDuration
-    include ArelExtensions::MathFunctions
-    include ArelExtensions::NullFunctions
-    include ArelExtensions::StringFunctions
-    include ArelExtensions::Predications
+  include ArelExtensions::Math
+  include ArelExtensions::Comparators
+  include ArelExtensions::DateDuration
+  include ArelExtensions::MathFunctions
+  include ArelExtensions::NullFunctions
+  include ArelExtensions::StringFunctions
+  include ArelExtensions::Predications
 end
 
 class Arel::Nodes::Unary
@@ -158,6 +224,9 @@ class Arel::Nodes::Unary
   include ArelExtensions::MathFunctions
   include ArelExtensions::Comparators
   include ArelExtensions::Predications
+  def eql? other
+    hash == other.hash
+  end
 end
 
 class Arel::Nodes::Binary
@@ -167,6 +236,9 @@ class Arel::Nodes::Binary
   include ArelExtensions::Comparators
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::Predications
+  def eql? other
+    hash == other.hash
+  end
 end
 
 class Arel::Nodes::Equality
@@ -183,6 +255,19 @@ end
 class Arel::SelectManager
   include ArelExtensions::SetFunctions
   include ArelExtensions::Nodes
+
+  def as table_name
+    Arel::Nodes::TableAlias.new(self, table_name)
+  end
+
+  # Install an alias, if present.
+  def xas table_name
+    if table_name.present?
+      as table_name
+    else
+      self
+    end
+  end
 end
 
 class Arel::Nodes::As
@@ -191,8 +276,19 @@ end
 
 class Arel::Table
   alias_method(:old_alias, :alias) rescue nil
+
+  # activerecord 7.1 removed the alias. We might need to remove our dependency
+  # on the alias if it proves problematic.
+  if !self.respond_to?(:table_name)
+    alias :table_name :name
+  end
+
   def alias(name = "#{self.name}_2")
-    name.blank? ? self : Arel::Nodes::TableAlias.new(self,name)
+    if name.present?
+      Arel::Nodes::TableAlias.new(self, name)
+    else
+      self
+    end
   end
 end
 
@@ -200,9 +296,50 @@ class Arel::Nodes::TableAlias
   def method_missing(*args)
     met = args.shift.to_sym
     if self.relation.respond_to?(met)
-      self.relation.send(met,args)
+      self.relation.send(met, args)
     else
-      super(met,*args)
+      super(met, *args)
+    end
+  end
+end
+
+
+class Arel::Attributes::Attribute
+  def to_sql(engine = Arel::Table.engine)
+    collector = Arel::Collectors::SQLString.new
+    collector = engine.connection.visitor.accept self, collector
+    collector.value
+  end
+
+  def rollup
+    Arel::Nodes::RollUp.new([self])
+  end
+end
+
+class Arel::Nodes::Node
+  def rollup
+    Arel::Nodes::RollUp.new([self])
+  end
+end
+
+require 'active_record'
+if ActiveRecord.version >= Gem::Version.create('7.2')
+  class ActiveRecord::Relation::WhereClause
+    def except_predicates(columns)
+      attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
+      non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
+
+      predicates.reject do |node|
+        if !non_attrs.empty? && node.equality? && node.left.is_a?(Arel::Predications)
+          non_attrs.include?(node.left)
+        end || Arel.fetch_attribute(node) do |attr|
+          attrs.find { |v| v.eql? attr } || columns.include?(attr.name.to_s) # 👈 replces
+          # attrs.include?(attr) || columns.include?(attr.name.to_s)         # 👈 this
+          #
+          # And that's because our attributes override `==`, so `attrs.include?(attr)` always
+          # passes because it returns an equality node.
+        end
+      end
     end
   end
 end

data/test/arelx_test_helper.rb

@@ -6,8 +6,56 @@ require 'active_record'
 
 require 'support/fake_record'
 
+def colored(color, msg)
+  /^xterm|-256color$/.match?(ENV['TERM']) ? "\x1b[#{color}m#{msg}\x1b[89m\x1b[0m" : "#{msg}"
+end
+
+YELLOW = '33'
+
+# Load gems specific to databases.
+#
+# NOTE:
+#     It's strongly advised to test each database on its own. Loading multiple
+#     backend gems leads to undefined behavior according to tests; the backend
+#     might not recognize the correct DB visitor and will fallback to `ToSQL`
+#     and screw all tests.
+#
+#     The issue also seems to be related to arel version: at some point, arel
+#     dropped its wide support for DBs and kept Postgres, MySQL and SQLite.
+#     Here, we're just trying to load the correct ones.
+#
+# NOTE:
+#     As of jruby 9.4 (and maybe 9.3, but I couldn't test it given the state of
+#     the alt-adapter), we need to load jdbc/mssql manually.
+db_and_gem =
+  if RUBY_PLATFORM == 'java'
+    {
+      'oracle'     => ['activerecord-oracle_enhanced-adapter'],
+      'mssql'      => ['jdbc/mssql', 'activerecord-jdbcsqlserver-adapter'],
+    }
+  else
+    {
+      'oracle'     => ['activerecord-oracle_enhanced-adapter'],
+      'mssql'      => ['activerecord-sqlserver-adapter'],
+    }
+  end
+
+def load_lib(gems)
+  if gems && (RUBY_PLATFORM == 'java' || Arel::VERSION.to_i > 9)
+    gems.each do |gem|
+      begin
+        require gem
+      rescue Exception => e
+        warn "Warning: failed to load gem #{gem}. Are you sure it's installed?"
+        warn e.message
+      end
+    end
+  end
+end
+
+load_lib(db_and_gem[ENV['DB']])
+
 require 'arel_extensions'
-Arel::Table.engine = FakeRecord::Base.new
 
 $arel_silence_type_casting_deprecation = true
 

data/test/database.yml

@@ -8,24 +8,30 @@ jdbc-sqlite:
   timeout: 500
 mysql:
   adapter: mysql2
-  database: arext_test
-  username: travis
+  database: arelx_test
+  username: root
   host: 127.0.0.1
   port: 3306
   encoding: utf8
 jdbc-mysql:
   adapter: jdbcmysql
-  database: arext_test
-  username: travis
+  database: arelx_test
+  username: root
   encoding: utf8
 postgresql:
   adapter: postgresql
-  database: arext_test
+  database: arelx_test
   username: postgres
+  password: secret
+  host: 127.0.0.1
+  port: 5432
 jdbc-postgresql:
   adapter: jdbcpostgresql
-  database: arext_test
+  database: arelx_test
   username: postgres
+  password: secret
+  host: 127.0.0.1
+  port: 5432
 oracle:
   adapter: oracle_enhanced
   database: xe
@@ -39,7 +45,7 @@ jdbc-oracle:
 ibm_db:
   adapter:  ibm_db
   username: travis
-  database: arext_test
+  database: arelx_test
 mssql:
   adapter: sqlserver
   host: localhost