arel_extensions 1.2.8 → 1.2.12

data/lib/arel_extensions/boolean_functions.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'arel_extensions/nodes/then'
 
 module ArelExtensions
@@ -8,7 +9,7 @@ module ArelExtensions
     end
 
     def and *others
-      Arel::Nodes::And.new([self]+ others.flatten)
+      Arel::Nodes::And.new self, others
     end
 
     def ⋁(other)
@@ -16,28 +17,54 @@ module ArelExtensions
     end
 
     def or *others
-      args = others.flatten
-      if args.length == 1
-        Arel::Nodes::Or.new(self, args.first)
-      else
-        ArelExtensions::Nodes::Or.new([self]+ args)
-      end
+      Arel::Nodes::Or.new self, others
     end
 
     def then(t, f = nil)
       ArelExtensions::Nodes::Then.new [self, t, f]
     end
+
   end
 end
 
-Arel::Nodes::And.class_eval do
+class Arel::Nodes::And
   include ArelExtensions::BooleanFunctions
-end
 
-Arel::Nodes::Or.class_eval do
-  include ArelExtensions::BooleanFunctions
+  def self.new *children
+    children =
+      children.flatten.map { |c|
+      c.is_a?(self) ? c.children : c
+    }.flatten
+    super(children)
+  end
+
 end
 
-ArelExtensions::Nodes.const_set('Or',Class.new(Arel::Nodes::And)).class_eval do
+# For some reason, Arel's And is properly defined as variadic (it
+# stores @children, and hashes it all).  However Arel's Or is defined
+# as binary, with only @left and @right, and hashing only @left and @right.
+#
+# So reimplement its ctor and accessors.
+
+class Arel::Nodes::Or
   include ArelExtensions::BooleanFunctions
+
+  attr_reader :children
+
+  def self.new *children
+    children =
+      children.flatten.map { |c|
+      c.is_a?(self) ? c.children : c
+    }.flatten
+    super(*children)
+  end
+
+  def initialize *children
+    @children = children
+  end
+
+  def hash
+    children.hash
+  end
+
 end

data/lib/arel_extensions/insert_manager.rb

@@ -4,21 +4,23 @@ module ArelExtensions
   module InsertManager
 
     def bulk_insert(cols, data)
+    res_columns = []
       case cols.first
       when String, Symbol
         cols.each { |c|
-          @ast.columns << @ast.relation[c]
+          res_columns << @ast.relation[c]
         }
       when Array
         if String === cols.first.first
-          @ast.columns = cols.map {|c| [@ast.relation[c.first]] }
+          res_columns = cols.map {|c| [@ast.relation[c.first]] }
         elsif Arel::Attributes::Attribute == cols.first.first
-          @ast.columns = cols
+          res_columns = cols
         end
       when NilClass
-        @ast.columns = @ast.relation.columns
+        res_columns = @ast.relation.columns
       end
-      self.values = BulkValues.new(@ast.columns, data)
+      self.values = BulkValues.new(res_columns, data)
+      @ast.columns = res_columns
     end
 
     class BulkValues < Arel::Nodes::Node

data/lib/arel_extensions/nodes/case.rb

@@ -26,7 +26,7 @@ module ArelExtensions
       end
     end
 
-    ArelExtensions::Nodes::Case.class_eval do
+    class ArelExtensions::Nodes::Case
       include Arel::Expressions
       include Arel::OrderPredications
       include ArelExtensions::Math

data/lib/arel_extensions/predications.rb

@@ -1,5 +1,6 @@
 module ArelExtensions
   module Predications
+
     def when right, expression = nil
       ArelExtensions::Nodes::Case.new(self).when(right,expression)
     end
@@ -20,23 +21,25 @@ module ArelExtensions
       ArelExtensions::Nodes::Cast.new([self,right])
     end
 
-    def in(other) #In should handle nil element in the Array
+    def in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         self.between(other)
+      when Arel::Nodes::Grouping
+        Arel::Nodes::In.new(self, quoted_node(other))
       when Enumerable
         nils, values   = other.partition{ |v| v.nil? }
         ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
-
         # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
         clauses =
           nils.uniq.map { |r| self.in(r) } \
           + (case values.uniq.size
               when 0 then []
-              when 1 then [self == values[0]]
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.in(values[0]) : self.eq(values[0])]
               else [Arel::Nodes::In.new(self, quoted_array(values))] end) \
           + ranges.uniq.map { |r| self.in(r) }
-        clauses.empty? ? self.is_null : clauses.reduce(&:or)
+        clauses.empty? ? Arel.false : clauses.reduce(&:or)
       when nil
         self.is_null
       when Arel::SelectManager
@@ -46,24 +49,25 @@ module ArelExtensions
       end
     end
 
-    def not_in(other) #In should handle nil element in the Array
+    def not_in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         Arel::Nodes::Not.new(self.between(other))
+      when Arel::Nodes::Grouping
+        Arel::Nodes::NotIn.new(self, quoted_node(other))
       when Enumerable
-        if other.include?(nil)
-          other.delete(nil)
-          case other.length
-          when 0
-            self.is_not_null
-          when 1
-            self.is_not_null.and(self!=other[0])
-          else
-            self.is_not_null.and(Arel::Nodes::NotIn.new(self,quoted_array(other)))
-          end
-        else
-          Arel::Nodes::NotIn.new(self,quoted_array(other))
-        end
+        nils, values   = other.partition{ |v| v.nil? }
+        ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
+        # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
+        clauses =
+          nils.uniq.map { |r| self.not_in(r) } \
+          + (case values.uniq.size
+              when 0 then []
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.not_in(values[0]) : self.not_eq(values[0])]
+              else [Arel::Nodes::NotIn.new(self, quoted_array(values))] end) \
+          + ranges.uniq.map { |r| self.not_in(r) }
+        Arel::Nodes::And.new clauses
       when nil
         self.is_not_null
       when Arel::SelectManager
@@ -93,6 +97,5 @@ module ArelExtensions
         raise(ArgumentError, "#{object.class} can not be converted to CONCAT arg")
       end
     end
-
   end
 end

data/lib/arel_extensions/set_functions.rb

@@ -23,10 +23,10 @@ module ArelExtensions
   end
 end
 
-Arel::Nodes::Union.class_eval do
+class Arel::Nodes::Union
   include ArelExtensions::SetFunctions
 end
 
-Arel::Nodes::UnionAll.class_eval do
+class Arel::Nodes::UnionAll
   include ArelExtensions::SetFunctions
 end

data/lib/arel_extensions/string_functions.rb

@@ -64,6 +64,19 @@ module ArelExtensions
       grouping_any :imatches, others, escape
     end
 
+#    def grouping_any method, others, *extra
+#      puts "*******************"
+#      puts method
+#      puts others.inspect
+#      puts extra.inspect
+#      puts "-------------------"
+#      res = super(method,others,*extra)
+#      puts res.to_sql
+#      puts res.inspect
+#      puts "*******************"
+#      res
+#    end
+
     def imatches_all others, escape = nil
       grouping_all :imatches, others, escape, escape
     end

data/lib/arel_extensions/version.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = "1.2.8".freeze
+  VERSION = "1.2.12".freeze
 end

data/lib/arel_extensions/visitors.rb

@@ -6,7 +6,7 @@ require 'arel_extensions/visitors/postgresql'
 require 'arel_extensions/visitors/sqlite'
 require 'arel_extensions/visitors/mssql'
 
-Arel::Visitors::MSSQL.class_eval do
+class Arel::Visitors::MSSQL
   include ArelExtensions::Visitors::MSSQL
 
   alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As

data/lib/arel_extensions/visitors/ibm_db.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::IBM_DB.class_eval do
+    class Arel::Visitors::IBM_DB
 
       def visit_ArelExtensions_Nodes_Ceil o, collector
         collector << "CEILING("

data/lib/arel_extensions/visitors/mysql.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::MySQL.class_eval do
+    class Arel::Visitors::MySQL
       Arel::Visitors::MySQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'WEEKDAY', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
       Arel::Visitors::MySQL::DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
         '%Y' => '%Y', '%C' =>   '', '%y' => '%y', '%m' => '%m', '%B' => '%M', '%b' => '%b', '%^b' => '%b',  # year, month
@@ -193,6 +193,13 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        if !regexp_replace_supported?
+          warn("Warning : ArelExtensions: REGEXP_REPLACE does not seem to be available in the current version of the DBMS, it might crash")
+        end
+        super(o,collector)
+      end
+
       def visit_ArelExtensions_Nodes_Format o, collector
         case o.col_type
         when :date, :datetime
@@ -403,7 +410,7 @@ module ArelExtensions
 
       def visit_Aggregate_For_AggregateFunction o, collector
         if !window_supported?
-            warn("Warning : ArelExtensions: Window Functions are not available in the current version on the DBMS.")
+            warn("Warning : ArelExtensions: Window Functions are not available in the current version of the DBMS.")
             return collector
         end
 
@@ -449,14 +456,22 @@ module ArelExtensions
         version_supported?('10.2.3', '8.0')
       end
 
-      def version_supported?(mysql_v = '10.2.3',mariadb_v = '5.7.0')
+      def regexp_replace_supported?
+        version_supported?('10.0.5', '8.0')
+      end
+
+      def version_supported?(mariadb_v = '10.2.3', mysql_v = '5.7.0')
         conn = Arel::Table.engine.connection
-        conn.send(:mariadb?) &&
-          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v ||
-          conn.respond_to?(:version) && conn.send(:version) >= mysql_v) ||
-          !Arel::Table.engine.connection.send(:mariadb?) &&
-          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v ||
-          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v)
+        conn.send(:mariadb?) && \
+          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v || \
+          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v || \
+          conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mariadb_v) || \
+          !conn.send(:mariadb?) && \
+          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v || \
+          conn.respond_to?(:version) && conn.send(:version) >= mysql_v || \
+          conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mysql_v)
+        # ideally we should parse the instance_variable @full_version because @version contains only the supposedly
+        # corresponding mysql version of the current mariadb version (which is not very helpful most of the time)
       end
 
       def visit_ArelExtensions_Nodes_Json o,collector

data/lib/arel_extensions/visitors/oracle.rb

@@ -1,7 +1,7 @@
 #require 'oracle_visitor'
 module ArelExtensions
   module Visitors
-    Arel::Visitors::Oracle.class_eval do
+    class Arel::Visitors::Oracle
 
       SPECIAL_CHARS = {"\t" => 'CHR(9)', "\n" => 'CHR(10)', "\r" => 'CHR(13)'}
       Arel::Visitors::Oracle::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
@@ -467,14 +467,12 @@ module ArelExtensions
           o.left.each_with_index do |row, idx| # values
           collector << " UNION ALL " if idx != 0
             collector << "(SELECT "
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.each_with_index { |value, i|
+            len = row.length - 1
+            row.zip(o.cols).each_with_index { |(value, attr), i|
                 case value
                 when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
                   collector = visit value, collector
                 else
-                  attr = v.columns[i]
                   collector << quote(value, attr && column_for(attr)).to_s
                 end
                 collector << Arel::Visitors::Oracle::COMMA unless i == len
@@ -490,12 +488,13 @@ module ArelExtensions
           o.left.each_with_index do |row, idx|
             collector << " UNION ALL " if idx != 0
             collector << "(SELECT "
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            len = row.length - 1
+            row.zip(o.cols).each_with_index { |(value, attr), i|
               case value
               when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
                 collector = visit value, collector
+              when Integer
+                collector << value.to_s
               else
                 collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
               end

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::PostgreSQL.class_eval do
+    class Arel::Visitors::PostgreSQL
       Arel::Visitors::PostgreSQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
       Arel::Visitors::PostgreSQL::DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'IYYY', '%C' => 'CC', '%y' => 'YY', '%m' => 'MM', '%B' => 'Month', '%^B' => 'MONTH', '%b' => 'Mon', '%^b' => 'MON',

data/lib/arel_extensions/visitors/sqlite.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::SQLite.class_eval do
+    class Arel::Visitors::SQLite
       Arel::Visitors::SQLite::DATE_MAPPING = {'d' => '%d', 'm' => '%m', 'w' => '%W', 'y' => '%Y', 'wd' => '%w', 'M' => '%M', 'h' => '%H', 'mn' => '%M', 's' => '%S'}
       Arel::Visitors::SQLite::DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
         '%Y' => '%Y', '%C' =>   '', '%y' => '%y', '%m' => '%m', '%B' => '%M', '%b' => '%b', '%^b' => '%b', # year, month
@@ -235,9 +235,8 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            len = row.length - 1
+            row.zip(o.cols).each_with_index { |(value, attr), i|
                 case value
                 when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
                   collector = visit value.as(attr.name), collector
@@ -258,12 +257,17 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            len = row.length - 1
+            row.zip(o.cols).each_with_index { |(value, attr), i|
                 case value
                 when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
                   collector = visit value.as(attr.name), collector
+                when Integer
+                  collector <<  value.to_s
+                  if idx == 0
+                    collector << " AS "
+                    collector << quote(attr.name)
+                  end
                 else
                   collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
                   if idx == 0