arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/visitors/mysql.rb

@@ -1,106 +1,39 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::MySQL
-      DATE_MAPPING = {
-        'd' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'WEEKDAY',
-        'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'
-      }.freeze
-
-      DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
+    Arel::Visitors::MySQL.class_eval do
+      Arel::Visitors::MySQL::COMMA = ", "
+      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
-        '%V' => '%v', '%G' => '%x',                                                                         # ISO week number and year of week
-        '%d' => '%d', '%e' => '%e', '%j' => '%j', '%w' => '%w', '%a' => '%a', '%A' => '%W',                 # day, weekday
+        '%d' => '%d', '%e' => '%e', '%j' => '%j', '%w' => '%w', '%A' => '%W',                               # day, weekday
         '%H' => '%H', '%k' => '%k', '%I' => '%I', '%l' => '%l', '%P' => '%p', '%p' => '%p',                 # hours
         '%M' => '%i', '%S' => '%S', '%L' =>   '', '%N' => '%f', '%z' => ''
-      }.freeze
-
-      # This helper method did not exist in rails < 5.2
-      if !Arel::Visitors::MySQL.method_defined?(:collect_nodes_for)
-        def collect_nodes_for(nodes, collector, spacer, connector = ', ')
-          if nodes&.any?
-            collector << spacer
-            inject_join nodes, collector, connector
-          end
-        end
-      end
-
-      if private_method_defined?(:visit_Arel_Nodes_SelectCore) || method_defined?(:visit_Arel_Nodes_SelectCore)
-        alias old_visit_Arel_Nodes_SelectCore visit_Arel_Nodes_SelectCore
-      end
-      # The whole purpose of this override is to fix the behavior of RollUp.
-      # All other databases treat RollUp sanely, execpt MySQL which requires
-      # that it figures as the last element of a GROUP BY.
-      def visit_Arel_Nodes_SelectCore(o, collector)
-        collector << 'SELECT'
-
-        collector = collect_optimizer_hints(o, collector) if respond_to?(:collect_optimizer_hints, true)
-        collector = maybe_visit o.set_quantifier, collector
+      }
 
-        collect_nodes_for o.projections, collector, ' '
 
-        if o.source && !o.source.empty?
-          collector << ' FROM '
-          collector = visit o.source, collector
-        end
-
-        # The actual work
-        groups = o.groups
-        rollup = groups.select { |g| g.expr.class == Arel::Nodes::RollUp }.map { |r| r.expr.value }
-        if rollup && !rollup.empty?
-          groups = o.groups.reject { |g| g.expr.class == Arel::Nodes::RollUp }
-          groups << Arel::Nodes::RollUp.new(rollup)
-        end
-        # FIN
-
-        collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
-        collect_nodes_for groups, collector, ' GROUP BY '
-        collect_nodes_for o.havings, collector, ' HAVING ', ' AND '
-        collect_nodes_for o.windows, collector, ' WINDOW '
-
-        if o.respond_to?(:comment)
-          maybe_visit o.comment, collector
-        else
+      #Math functions
+      def visit_ArelExtensions_Nodes_Log10 o, collector
+          collector << "LOG10("
+          o.expressions.each_with_index { |arg, i|
+            collector << Arel::Visitors::ToSql::COMMA unless i == 0
+            collector = visit arg, collector
+          }
+          collector << ")"
           collector
-        end
-      end
-
-      # Math functions
-      def visit_ArelExtensions_Nodes_Log10(o, collector)
-        collector << 'LOG10('
-        o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
-          collector = visit arg, collector
-        }
-        collector << ')'
-        collector
       end
 
-      def visit_ArelExtensions_Nodes_Power(o, collector)
-        collector << 'POW('
+      def visit_ArelExtensions_Nodes_Power o, collector
+        collector << "POW("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
-        collector
-      end
-
-      # String functions
-      def visit_ArelExtensions_Nodes_ByteSize(o, collector)
-        collector << 'LENGTH('
-        collector = visit o.expr.coalesce(''), collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_CharLength(o, collector)
-        collector << 'CHAR_LENGTH('
-        collector = visit o.expr.coalesce(''), collector
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_IMatches(o, collector) # insensitive on ASCII
+      #String functions
+      def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
         collector << 'LOWER('
         collector = visit o.left, collector
         collector << ') LIKE LOWER('
@@ -108,45 +41,49 @@ module ArelExtensions
         collector << ')'
         if o.escape
           collector << ' ESCAPE '
-          collector = visit o.escape, collector
+          visit o.escape, collector
+        else
+          collector
         end
-        collector
       end
 
-      def visit_ArelExtensions_Nodes_AiMatches(o, collector)
+      def visit_ArelExtensions_Nodes_AiMatches o, collector
         collector = visit o.left.ai_collate, collector
         collector << ' LIKE '
         collector = visit o.right.ai_collate, collector
         if o.escape
           collector << ' ESCAPE '
-          collector = visit o.escape, collector
+          visit o.escape, collector
+        else
+          collector
         end
-        collector
       end
 
-      def visit_ArelExtensions_Nodes_AiIMatches(o, collector)
+      def visit_ArelExtensions_Nodes_AiIMatches o, collector
         collector = visit o.left.ai_collate, collector
         collector << ' LIKE '
         collector = visit o.right.ai_collate, collector
         if o.escape
           collector << ' ESCAPE '
-          collector = visit o.escape, collector
+          visit o.escape, collector
+        else
+          collector
         end
-        collector
       end
 
-      def visit_ArelExtensions_Nodes_SMatches(o, collector)
-        collector = visit o.left.collate, collector
-        collector << ' LIKE '
-        collector = visit o.right.collate, collector
-        if o.escape
-          collector << ' ESCAPE '
-          collector = visit o.escape, collector
-        end
-        collector
+      def visit_ArelExtensions_Nodes_SMatches o, collector
+          collector = visit o.left.collate, collector
+          collector << ' LIKE '
+          collector = visit o.right.collate, collector
+          if o.escape
+            collector << ' ESCAPE '
+            visit o.escape, collector
+          else
+            collector
+          end
       end
 
-      def visit_ArelExtensions_Nodes_IDoesNotMatch(o, collector)
+      def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
         collector << 'LOWER('
         collector = visit o.left, collector
         collector << ') NOT LIKE LOWER('
@@ -154,189 +91,142 @@ module ArelExtensions
         collector << ')'
         if o.escape
           collector << ' ESCAPE '
-          collector = visit o.escape, collector
+          visit o.escape, collector
+        else
+          collector
         end
-        collector
       end
 
-      def visit_ArelExtensions_Nodes_Collate(o, collector)
-        charset =
-          case o.expressions.first
-          when Arel::Attributes::Attribute
-            case o.option
-            when 'latin1', 'utf8'
+      def visit_ArelExtensions_Nodes_Collate o, collector
+        case o.expressions.first
+        when Arel::Attributes::Attribute
+          charset = case o.option
+            when 'latin1','utf8'
               o.option
             else
               Arel::Table.engine.connection.charset || 'utf8'
             end
-          else
-            o.option == 'latin1' ? 'latin1' : 'utf8'
-          end
+        else
+          charset = (o.option == 'latin1') ? 'latin1' : 'utf8'
+        end
         collector = visit o.expressions.first, collector
-        collector <<
-          if o.ai
-            " COLLATE #{charset == 'latin1' ? 'latin1_general_ci' : "#{charset}_unicode_ci"}"
-          # doesn't work in latin1
-          elsif o.ci
-            " COLLATE #{charset == 'latin1' ? 'latin1_general_ci' : "#{charset}_unicode_ci"}"
-          else
-            " COLLATE #{charset}_bin"
-          end
+        if o.ai
+          collector << " COLLATE #{charset == 'latin1' ? 'latin1_general_ci' : 'utf8_unicode_ci' }"
+          #doesn't work in latin1
+        elsif o.ci
+          collector << " COLLATE #{charset == 'latin1' ? 'latin1_general_ci' : 'utf8_unicode_ci' }"
+        else
+          collector << " COLLATE #{charset}_bin"
+        end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Concat(o, collector)
-        collector << 'CONCAT('
+      def visit_ArelExtensions_Nodes_Concat o, collector
+        collector << "CONCAT("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
-          if arg.is_a?(Numeric) || arg.is_a?(Arel::Attributes::Attribute)
-            collector << 'CAST('
+          collector << Arel::Visitors::MySQL::COMMA unless i == 0
+          if (arg.is_a?(Numeric)) || (arg.is_a?(Arel::Attributes::Attribute))
+            collector << "CAST("
             collector = visit arg, collector
-            collector << ' AS char)'
+            collector << " AS char)"
           else
             collector = visit arg, collector
           end
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_Arel_Nodes_RollUp(o, collector)
-        visit o.expr, collector
-        collector << ' WITH ROLLUP'
-      end
-
-      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
-        collector << 'GROUP_CONCAT('
+      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+        collector << "GROUP_CONCAT("
         collector = visit o.left, collector
-        if !o.order.blank?
+        if !o.orders.blank?
           collector << ' ORDER BY '
-          o.order.each_with_index do |order, i|
-            collector << COMMA if i != 0
+          o.orders.each_with_index do |order,i|
+            collector << Arel::Visitors::ToSql::COMMA unless i == 0
             collector = visit order, collector
           end
         end
-        sep = o.separator.is_a?(Arel::Nodes::Quoted) ? o.separator.expr : o.separator
-        if 'NULL' != sep
+        if o.right && o.right != 'NULL'
           collector << ' SEPARATOR '
-          collector = visit o.separator, collector
+          collector = visit o.right, collector
         end
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim(o, collector)
-        collector << 'TRIM(' # BOTH
-        collector = visit o.right, collector
-        collector << ' FROM '
-        collector = visit o.left, collector
-        collector << ')'
-        collector
+      def visit_ArelExtensions_Nodes_Trim o, collector
+          collector << 'TRIM(' # BOTH
+          collector = visit o.right, collector
+          collector << " FROM "
+          collector = visit o.left, collector
+          collector << ")"
+          collector
       end
 
-      def visit_ArelExtensions_Nodes_Ltrim(o, collector)
-        collector << 'TRIM(LEADING '
-        collector = visit o.right, collector
-        collector << ' FROM '
-        collector = visit o.left, collector
-        collector << ')'
-        collector
+      def visit_ArelExtensions_Nodes_Ltrim o , collector
+          collector << 'TRIM(LEADING '
+          collector = visit o.right, collector
+          collector << " FROM "
+          collector = visit o.left, collector
+          collector << ")"
+          collector
       end
 
-      def visit_ArelExtensions_Nodes_Rtrim(o, collector)
+      def visit_ArelExtensions_Nodes_Rtrim o , collector
         collector << 'TRIM(TRAILING '
         collector = visit o.right, collector
-        collector << ' FROM '
+        collector << " FROM "
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Repeat(o, collector)
-        collector << 'REPEAT('
+      def visit_ArelExtensions_Nodes_Repeat o, collector
+        collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         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
-      end
-
-      def visit_ArelExtensions_Nodes_Format(o, collector)
-        # One use case we met is
-        # `case…when…then(valid_date).else(Arel.null).format(…)`.
-        #
-        # In this case, `o.col_type` is `nil` but we have a legitimate type in
-        # the expression to be formatted.  The following is a best effort to
-        # infer the proper type.
-        first = o.expressions[0]
-        type =
-          if o.col_type.nil? \
-            && first.respond_to?(:return_type) && !first&.return_type.nil?
-            first&.return_type
-          else
-            o.col_type
-          end
-
-        case type
-        when :date, :datetime, :time
-          visit_ArelExtensions_Nodes_FormattedDate o, collector
+      def visit_ArelExtensions_Nodes_Format o, collector
+        case o.col_type
+        when :date, :datetime
+          collector << "DATE_FORMAT("
+          collector = visit o.left, collector
+          collector << Arel::Visitors::MySQL::COMMA
+          f = o.iso_format.dup
+          Arel::Visitors::MySQL::DATE_FORMAT_DIRECTIVES.each { |d, r| f.gsub!(d, r) }
+          collector = visit Arel::Nodes.build_quoted(f), collector
+          collector << ")"
         when :integer, :float, :decimal
-          collector << 'FORMAT('
+          collector << "FORMAT("
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::ToSql::COMMA
           collector << '2'
-          collector << COMMA
+          collector << Arel::Visitors::ToSql::COMMA
           collector = visit o.right, collector
-          collector << ')'
+          collector << ")"
         else
           collector = visit o.left, collector
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedDate(o, collector)
-        fmt = ArelExtensions::Visitors.strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
-        collector << 'DATE_FORMAT('
-        collector << 'CONVERT_TZ(' if o.time_zone
-        collector = visit o.left, collector
-        case o.time_zone
-        when Hash
-          src_tz, dst_tz = o.time_zone.first
-          collector << COMMA
-          collector = visit Arel.quoted(src_tz), collector
-          collector << COMMA
-          collector = visit Arel.quoted(dst_tz), collector
-          collector << ')'
-        when String
-          collector << COMMA << "'UTC'" << COMMA
-          collector = visit Arel.quoted(o.time_zone), collector
-          collector << ')'
-        end
-        collector << COMMA
-        collector = visit Arel.quoted(fmt), collector
-        collector << ')'
-      end
-
-      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
-        case o.right_node_type
-        when :ruby_date, :ruby_time, :date, :datetime, :time
-          collector <<
-            case o.left_node_type
-            when :ruby_time, :datetime, :time then 'TIMESTAMPDIFF(SECOND, '
-            else                                   'DATEDIFF('
-            end
+      def visit_ArelExtensions_Nodes_DateDiff o, collector
+        if o.right_node_type == :ruby_date || o.right_node_type == :ruby_time || o.right_node_type == :date || o.right_node_type == :datetime || o.right_node_type == :time
+          collector << if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
+                        'TIMESTAMPDIFF(SECOND, '
+                      else
+                        'DATEDIFF('
+                      end
           collector = visit o.right, collector
-          collector << COMMA
+          collector << Arel::Visitors::MySQL::COMMA
           collector = visit o.left, collector
-          collector << ')'
+          collector << ")"
         else
           collector << '('
           collector = visit o.left, collector
@@ -355,94 +245,103 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateAdd(o, collector)
-        collector << 'DATE_ADD('
+      def visit_ArelExtensions_Nodes_DateAdd o, collector
+        collector << "DATE_ADD("
         collector = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         collector = visit o.mysql_value(o.right), collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration(o, collector)
+
+      def visit_ArelExtensions_Nodes_Duration o, collector
         if o.left == 'wd'
-          collector << '(WEEKDAY('
+          collector << "(WEEKDAY("
           collector = visit o.right, collector
-          collector << ') + 1) % 7'
+          collector << ") + 1) % 7"
         else
           if o.with_interval
-            interval =
-              case o.left
-              when 'd', 'm', 'y'
-                'DAY'
-              when 'h', 'mn', 's'
-                'SECOND'
-              when /i\z/
-                DATE_MAPPING[o.left[0..-2]]
-              end
+            case o.left
+            when  'd','m','y'
+              interval = 'DAY'
+            when 'h','mn','s'
+              interval = 'SECOND'
+            when /i\z/
+              interval = Arel::Visitors::MySQL::DATE_MAPPING[o.left[0..-2]]
+            else
+              interval = nil
+            end
           end
-          collector << ' INTERVAL ' if o.with_interval && interval
-          collector << "#{DATE_MAPPING[o.left]}("
+          collector << " INTERVAL " if o.with_interval && interval
+          collector << "#{Arel::Visitors::MySQL::DATE_MAPPING[o.left]}("
           collector = visit o.right, collector
-          collector << ')'
+          collector << ")"
           collector << " #{interval} " if o.with_interval && interval
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNull(o, collector)
-        collector << 'ISNULL('
+
+      def visit_ArelExtensions_Nodes_IsNull o, collector
+        collector << "ISNULL("
         collector = visit o.expr, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNotNull(o, collector)
-        collector << 'NOT ISNULL('
-        collector = visit o.expr, collector
-        collector << ')'
-        collector
+      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+          collector << "NOT ISNULL("
+          collector = visit o.expr, collector
+          collector << ")"
+          collector
       end
 
-      def visit_ArelExtensions_Nodes_Wday(o, collector)
-        collector << '(WEEKDAY('
+      def visit_ArelExtensions_Nodes_Wday o, collector
+        collector << "(WEEKDAY("
         collector = visit o.date, collector
-        collector << ') + 1) % 7'
+        collector << ") + 1) % 7"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Cast(o, collector)
-        as_attr =
-          case o.as_attr
-          when :binary           then 'binary'
-          when :date             then 'date'
-          when :datetime         then 'datetime'
-          when :int              then 'signed'
-          when :number, :decimal then 'decimal(20,6)'
-          when :string           then 'char'
-          when :time             then 'time'
-          else                        o.as_attr.to_s
-          end
-
-        collector << 'CAST('
+      def visit_ArelExtensions_Nodes_Cast o, collector
+        collector << "CAST("
         collector = visit o.left, collector
-        collector << ' AS '
-        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), collector
-        collector << ')'
+        collector << " AS "
+        case o.as_attr
+        when :string
+          as_attr = Arel::Nodes::SqlLiteral.new('char')
+        when :time
+          as_attr = Arel::Nodes::SqlLiteral.new('time')
+        when :int
+          as_attr = Arel::Nodes::SqlLiteral.new('signed')
+        when :number, :decimal
+          as_attr = Arel::Nodes::SqlLiteral.new('decimal(20,6)')
+        when :datetime
+          as_attr = Arel::Nodes::SqlLiteral.new('datetime')
+        when :date
+          as_attr = Arel::Nodes::SqlLiteral.new('date')
+        when :binary
+          as_attr = Arel::Nodes::SqlLiteral.new('binary')
+        else
+          as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
+        end
+        collector = visit as_attr, collector
+        collector << ")"
         collector
       end
 
-      alias old_visit_Arel_Nodes_SelectStatement visit_Arel_Nodes_SelectStatement rescue nil
-      def visit_Arel_Nodes_SelectStatement(o, collector)
+      alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+      def visit_Arel_Nodes_SelectStatement o, collector
         if !(collector.value.blank? || (collector.value.is_a?(Array) && collector.value[0].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
 
-      alias old_visit_Arel_Nodes_As visit_Arel_Nodes_As rescue nil
-      def visit_Arel_Nodes_As(o, collector)
+      alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+      def visit_Arel_Nodes_As o, collector
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
           collector = visit o.left, collector
@@ -450,56 +349,44 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        collector << ' AS '
-
-        # sometimes these values are already quoted, if they are, don't double quote it
-        quote = o.right.is_a?(Arel::Nodes::SqlLiteral) && o.right[0] != '`' && o.right[-1] != '`'
-
-        collector << '`' if quote
+        collector << " AS `"
         collector = visit o.right, collector
-        collector << '`' if quote
-
+        collector << "`"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber(o, collector)
+      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        params = o.locale ? [o.precision, Arel.quoted(o.locale)] : [o.precision]
-        sign = Arel.when(col < 0).
+        params = o.locale ? [o.precision,Arel::Nodes.build_quoted(o.locale)] : [o.precision]
+        sign = ArelExtensions::Nodes::Case.new.when(col<0).
                   then('-').
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
 
-        number =
-          if o.scientific_notation
-            ArelExtensions::Nodes::Concat.new([
-                    Arel::Nodes::NamedFunction.new('FORMAT', [
-                      col.abs / Arel.quoted(10).pow(col.abs.log10.floor)
-                    ] + params),
-                    o.type,
-                    Arel::Nodes::NamedFunction.new('FORMAT', [
-                      col.abs.log10.floor,
-                      0
-                    ])
+        if o.scientific_notation
+          number = ArelExtensions::Nodes::Concat.new([
+                  Arel::Nodes::NamedFunction.new('FORMAT',[
+                    col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor)
+                  ]+params),
+                  o.type,
+                  Arel::Nodes::NamedFunction.new('FORMAT',[
+                    col.abs.log10.floor,
+                    0
                   ])
-          else
-            Arel::Nodes::NamedFunction.new('FORMAT', [col.abs] + params)
-          end
+                ])
+        else
+          number = Arel::Nodes::NamedFunction.new('FORMAT',[col.abs]+params)
+        end
 
-        repeated_char =
-          if o.width == 0
-            Arel.quoted('')
-          else
-            Arel
-              .when(Arel.quoted(o.width).abs - (number.length + sign_length) > 0)
-              .then(Arel.quoted(
-                      o.flags.include?('-') ? ' ' : (o.flags.include?('0') ? '0' : ' ')
-                    ).repeat(Arel.quoted(o.width).abs - (number.length + sign_length))
-                   )
-              .else('')
-          end
-        before = !o.flags.include?('0') && !o.flags.include?('-') ? repeated_char : ''
-        middle = o.flags.include?('0') && !o.flags.include?('-')  ? repeated_char : ''
+        repeated_char = (o.width == 0) ? Arel::Nodes.build_quoted('') : ArelExtensions::Nodes::Case.new().
+          when(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length)>0).
+          then(Arel::Nodes.build_quoted(
+              o.flags.include?('-') ? ' ' : (o.flags.include?('0') ? '0' : ' ')
+            ).repeat(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length))
+          ).
+          else('')
+        before = (!o.flags.include?('0'))&&(!o.flags.include?('-')) ? repeated_char : ''
+        middle = (o.flags.include?('0'))&&(!o.flags.include?('-'))  ? repeated_char : ''
         after  = o.flags.include?('-') ? repeated_char : ''
         full_number = ArelExtensions::Nodes::Concat.new([
             before,
@@ -508,129 +395,66 @@ module ArelExtensions
             number,
             after
           ])
-        collector = visit ArelExtensions::Nodes::Concat.new([Arel.quoted(o.prefix), full_number, Arel.quoted(o.suffix)]), collector
+        collector = visit ArelExtensions::Nodes::Concat.new([Arel::Nodes.build_quoted(o.prefix),full_number,Arel::Nodes.build_quoted(o.suffix)]), collector
         collector
       end
 
-      def visit_Aggregate_For_AggregateFunction(o, collector)
-        if !window_supported?
-          warn('Warning: ArelExtensions: Window Functions are not available in the current version of the DBMS.')
-          return collector
-        end
-
-        if !o.order.empty? || !o.group.empty?
-          collector << ' OVER ('
-          if !o.group.empty?
-            collector << ' PARTITION BY ('
-            visit o.group, collector
-            collector << ')'
-          end
-          if !o.order.empty?
-            collector << ' ORDER BY ('
-            visit o.order, collector
-            collector << ')'
-          end
-          collector << ')'
-        end
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Std(o, collector)
-        collector << (o.unbiased_estimator ? 'STDDEV_SAMP(' : 'STDDEV_POP(')
+      def visit_ArelExtensions_Nodes_Std o, collector
+        collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
         visit o.left, collector
-        collector << ')'
-        visit_Aggregate_For_AggregateFunction o, collector
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Variance(o, collector)
-        collector << (o.unbiased_estimator ? 'VAR_SAMP(' : 'VAR_POP(')
+      def visit_ArelExtensions_Nodes_Variance o, collector
+        collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
         visit o.left, collector
-        collector << ')'
-        visit_Aggregate_For_AggregateFunction o, collector
+        collector << ")"
         collector
       end
 
-      # JSON if implemented only after 10.2.3 (aggregations after 10.5.0) in MariaDb and 5.7 (aggregations after 5.7.22) in MySql
+      # JSON if implemented only after 10.2.3 in MariaDb and 5.7 in MySql
       def json_supported?
-        version_supported?('10.5.0', '5.7.22')
-      end
-
-      def window_supported?
-        version_supported?('10.2.3', '8.0')
-      end
-
-      def regexp_replace_supported?
-        version_supported?('10.0.5', '8.0')
+        Arel::Table.engine.connection.send(:mariadb?) &&
+        Arel::Table.engine.connection.send(:version) >= '10.2.3' ||
+        !Arel::Table.engine.connection.send(:mariadb?) &&
+        Arel::Table.engine.connection.send(:version) >= '5.7.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) >= 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)
+      def visit_ArelExtensions_Nodes_Json o,collector
         return super if !json_supported?
-
         case o.dict
         when Array
           collector << 'JSON_ARRAY('
-          o.dict.each.with_index do |v, i|
+          o.dict.each.with_index do |v,i|
             if i != 0
-              collector << COMMA
+              collector << Arel::Visitors::MySQL::COMMA
             end
-            collector = visit_json_value(o, v, collector)
+            collector = visit v, collector
           end
           collector << ')'
         when Hash
           collector << 'JSON_OBJECT('
-          o.dict.each.with_index do |(k, v), i|
+          o.dict.each.with_index do |(k,v),i|
             if i != 0
-              collector << COMMA
+              collector << Arel::Visitors::MySQL::COMMA
             end
             collector = visit k, collector
-            collector << COMMA
-            collector = visit_json_value(o, v, collector)
+            collector << Arel::Visitors::MySQL::COMMA
+            collector = visit v, collector
           end
           collector << ')'
         else
-          collector = visit_json_value(o, o.dict, collector)
-        end
-        collector
-      end
-
-      # A JSON Boolean must render as `true`/`false`, not the integer `1`/`0` that MySQL
-      # collapses `TRUE`/`FALSE` into inside JSON functions (MariaDB keeps them boolean).
-      def visit_json_value(o, v, collector)
-        if o.boolean_literal?(v)
-          value = v.is_a?(Arel::Nodes::Quoted) ? v.expr : v
-          collector << "JSON_EXTRACT('#{value}', '$')"
-        elsif o.type_of_node(v) == :boolean
-          collector << 'JSON_EXTRACT(CASE WHEN '
-          collector = visit v, collector
-          collector << " IS NULL THEN NULL WHEN "
-          collector = visit v, collector
-          collector << " THEN 'true' ELSE 'false' END, '$')"
-        else
-          collector = visit v, collector
+          collector = visit o.dict, collector
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonMerge(o, collector)
+      def visit_ArelExtensions_Nodes_JsonMerge o,collector
         collector << 'JSON_MERGE_PATCH('
-        o.expressions.each.with_index do |v, i|
+        o.expressions.each.with_index do |v,i|
           if i != 0
-            collector << COMMA
+            collector << Arel::Visitors::MySQL::COMMA
           end
           collector = visit v, collector
         end
@@ -638,37 +462,36 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGet(o, collector)
+      def visit_ArelExtensions_Nodes_JsonGet o,collector
         collector << 'JSON_EXTRACT('
         collector = visit o.dict, collector
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         if o.key.is_a?(Integer)
           collector << "\"$[#{o.key}]\""
         else
-          collector = visit Arel.quoted('$.') + o.key, collector
+          collector = visit Arel::Nodes.build_quoted('$.')+o.key, collector
         end
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonSet(o, collector)
+      def visit_ArelExtensions_Nodes_JsonSet o,collector
         collector << 'JSON_SET('
         collector = visit o.dict, collector
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         if o.key.is_a?(Integer)
           collector << "\"$[#{o.key}]\""
         else
-          collector = visit Arel.quoted('$.') + o.key, collector
+          collector = visit Arel::Nodes.build_quoted('$.')+o.key, collector
         end
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         collector = visit o.value, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGroup(o, collector)
+      def visit_ArelExtensions_Nodes_JsonGroup o, collector
         return super if !json_supported?
-
         if o.as_array
           collector << 'JSON_ARRAYAGG('
           collector = visit o.dict, collector
@@ -677,13 +500,13 @@ module ArelExtensions
           case o.dict
           when Hash
             collector << 'JSON_MERGE_PATCH(' if o.dict.length > 1
-            o.dict.each.with_index do |(k, v), i|
+            o.dict.each.with_index do |(k,v),i|
               if i != 0
-                collector << COMMA
+                collector << Arel::Visitors::MySQL::COMMA
               end
               collector << 'JSON_OBJECTAGG('
               collector = visit k, collector
-              collector << COMMA
+              collector << Arel::Visitors::MySQL::COMMA
               collector = visit v, collector
               collector << ')'
             end
@@ -696,6 +519,7 @@ module ArelExtensions
         end
         collector
       end
+
     end
   end
 end