arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,96 +1,75 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::PostgreSQL
-      DATE_MAPPING = {
-        'd' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW',
-        'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'
-      }.freeze
-
-      DATE_FORMAT_DIRECTIVES = {
-        '%Y' => 'YYYY', '%C' => 'CC', '%y' => 'YY',
-        '%m' => 'MM', '%B' => 'TMMonth', '%^B' => 'TMMONTH', '%b' => 'TMMon', '%^b' => 'TMMON',
-        '%V' => 'IW', '%G' => 'IYYY',                                                              # ISO week number and year of week
-        '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%a' => 'TMDy', '%A' => 'TMDay',  # day, weekday
-        '%H' => 'HH24', '%k' => '', '%I' => 'HH', '%l' => '', '%P' => 'am', '%p' => 'AM',          # hours
-        '%M' => 'MI', '%S' => 'SS', '%L' => 'MS', '%N' => 'US', '%z' => 'tz',                      # seconds, subseconds
-        '%%' => '%',
-      }.freeze
-
-      NUMBER_COMMA_MAPPING = {
-        'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '
-      }.freeze
-
-      def visit_ArelExtensions_Nodes_ByteSize(o, collector)
-        collector << 'octet_length('
-        collector = visit o.expr.coalesce(''), collector
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_CharLength(o, collector)
-        collector << 'length('
-        collector = visit o.expr.coalesce(''), collector
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Rand(o, collector)
-        collector << 'RANDOM('
-        if !o.left.nil? && !o.right.nil?
+    Arel::Visitors::PostgreSQL.class_eval do
+      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',
+        '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%A' => 'Day', # day, weekday
+        '%H' => 'HH24', '%k' => '', '%I' => 'HH', '%l' => '', '%P' => 'am', '%p' => 'AM', # hours
+        '%M' => 'MI', '%S' => 'SS', '%L' => 'MS', '%N' => 'US', '%z' => 'tz' # seconds, subseconds
+      }
+      Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
+
+      def visit_ArelExtensions_Nodes_Rand o, collector
+        collector << "RANDOM("
+        if(o.left != nil && o.right != nil)
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::PostgreSQL::COMMA
           collector = isit o.right, collector
         end
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Power(o, collector)
-        collector << 'POWER('
+      def visit_ArelExtensions_Nodes_Power o, collector
+        collector << "POWER("
         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_Log10(o, collector)
-        collector << 'LOG('
+      def visit_ArelExtensions_Nodes_Log10 o, collector
+        collector << "LOG("
         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
 
+
       remove_method(:visit_Arel_Nodes_Regexp) rescue nil
-      def visit_Arel_Nodes_Regexp(o, collector)
+      def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
-        collector << ' ~ '
-        visit o.right, collector
+        collector << " ~ "
+        collector = visit o.right, collector
+        collector
       end
 
       remove_method(:visit_Arel_Nodes_NotRegexp) rescue nil
-      def visit_Arel_Nodes_NotRegexp(o, collector)
+      def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
-        collector << ' !~ '
-        visit o.right, collector
+        collector << " !~ "
+        collector = visit o.right, collector
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_Concat(o, collector)
+      def visit_ArelExtensions_Nodes_Concat o, collector
         collector << '('
         o.expressions.each_with_index { |arg, i|
           collector = visit arg, collector
           collector << ' || ' unless i == o.expressions.length - 1
         }
-        collector << ')'
+        collector << ")"
         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
@@ -98,130 +77,84 @@ 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_Aggregate_For_AggregateFunction(o, collector)
-        if !o.order.blank? || !o.group.blank?
-          collector << ' OVER ('
-          if !o.group.blank?
-            collector << ' PARTITION BY '
-            o.group.each_with_index do |group, i|
-              collector << COMMA if i != 0
-              visit group, collector
-            end
-          end
-          if !o.order.blank?
-            collector << ' ORDER BY '
-            o.order.each_with_index do |order, i|
-              collector << COMMA if i != 0
-              visit order, collector
-            end
-          end
-          collector << ')'
-        end
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
-        collector << 'array_to_string(array_agg('
+      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+        collector << "array_to_string(array_agg("
         collector = visit o.left, collector
-        if o.order && !o.order.blank?
-          collector << ' ORDER BY'
-          o.order.each_with_index do |order, i|
-            collector << COMMA if i != 0
-            collector << ' '
-            visit order, collector
+        if !o.orders.blank?
+          collector << ' ORDER BY '
+          o.orders.each_with_index do |order,i|
+            collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+            collector = visit order, collector
           end
         end
-        collector << ')'
-        o.order = nil
-        visit_Aggregate_For_AggregateFunction o, collector
-        collector << COMMA
-        sep = o.separator.is_a?(Arel::Nodes::Quoted) ? o.separator.expr : o.separator
-        collector =
-          if 'NULL' == sep
-            visit Arel.quoted(','), collector
-          else
-            visit o.separator, collector
-          end
-        collector << ')'
+        collector << ")"
+        collector << Arel::Visitors::PostgreSQL::COMMA
+        if o.right  && o.right != 'NULL'
+          collector = visit o.right, collector
+        else
+          collector = visit Arel::Nodes.build_quoted(','), collector
+        end
+        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_Format(o, collector)
-        visit_ArelExtensions_Nodes_FormattedDate o, collector
-      end
-
-      def visit_ArelExtensions_Nodes_FormattedDate(o, collector)
-        fmt = ArelExtensions::Visitors.strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
-        collector << 'TO_CHAR('
-        collector << '(' if o.time_zone
+      def visit_ArelExtensions_Nodes_Format o, collector
+        collector << "TO_CHAR("
         collector = visit o.left, collector
-        case o.time_zone
-        when Hash
-          src_tz, dst_tz = o.time_zone.first
-          collector << ') AT TIME ZONE '
-          collector = visit Arel.quoted(src_tz), collector
-          collector << ' AT TIME ZONE '
-          collector = visit Arel.quoted(dst_tz), collector
-        when String
-          collector << ") AT TIME ZONE 'UTC' AT TIME ZONE "
-          collector = visit Arel.quoted(o.time_zone), collector
-        end
-        collector << COMMA
-        collector = visit Arel.quoted(fmt), collector
-        collector << ')'
+        collector << Arel::Visitors::PostgreSQL::COMMA
+
+        f = o.iso_format.dup
+        Arel::Visitors::PostgreSQL::DATE_FORMAT_DIRECTIVES.each { |d, r| f.gsub!(d, r) }
+        collector = visit Arel::Nodes.build_quoted(f), 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_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
@@ -233,7 +166,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_AiIMatches(o, collector)
+      def visit_ArelExtensions_Nodes_AiIMatches o, collector
         collector = visit o.left.ai_collate, collector
         collector << ' ILIKE '
         collector = visit o.right.ai_collate, collector
@@ -245,7 +178,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_SMatches(o, collector)
+      def visit_ArelExtensions_Nodes_SMatches o, collector
         collector = visit o.left, collector
         collector << ' LIKE '
         collector = visit o.right, collector
@@ -257,11 +190,11 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_Collate(o, collector)
+      def visit_ArelExtensions_Nodes_Collate o, collector
         if o.ai
-          collector << 'unaccent('
+          collector << "unaccent("
           collector = visit o.expressions.first, collector
-          collector << ')'
+          collector << ")"
         elsif o.ci
           collector = visit o.expressions.first, collector
         else
@@ -270,25 +203,26 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateAdd(o, collector)
+      def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector = visit o.left, collector
-        collector << ' + ' # (o.right.value >= 0 ? ' + ' : ' - ')
-        visit o.postgresql_value(o.right), collector
+        collector << ' + ' #(o.right.value >= 0 ? ' + ' : ' - ')
+        collector = visit o.postgresql_value(o.right), collector
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
-        if %i[ruby_date ruby_time date datetime time].include?(o.right_node_type)
-          collector << if %i[ruby_time datetime time].include?(o.left_node_type)
-                         "DATEDIFF('second', "
-                       else
-                         "DATEDIFF('day', "
-                       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
+                          "DATEDIFF('second', "
+                      else
+                          "DATEDIFF('day', "
+                      end
           collector = visit o.right, collector
           collector << (o.right_node_type == :date ? '::date' : '::timestamp')
-          collector << COMMA
+          collector << Arel::Visitors::PostgreSQL::COMMA
           collector = visit o.left, collector
           collector << (o.left_node_type == :date ? '::date' : '::timestamp')
-          collector << ')'
+          collector << ")"
         else
           collector << '('
           collector = visit o.left, collector
@@ -302,178 +236,146 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration(o, collector)
+      def visit_ArelExtensions_Nodes_Duration o, collector
         if o.with_interval
-          interval =
-            case o.left
-            when 'd', 'm', 'y'
+          interval = case o.left
+            when  'd','m','y'
               'DAY'
-            when 'h', 'mn', 's'
+            when 'h','mn','s'
               'SECOND'
             when /i\z/
-              collector << '('
+              collector << "("
               collector = visit o.right, collector
-              collector << ')'
-              collector << " * (INTERVAL '1' #{DATE_MAPPING[o.left[0..-2]]})"
+              collector << ")"
+              collector << " * (INTERVAL '1' #{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left[0..-2]]})"
               return collector
             end
         end
-        collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM CAST("
+        collector << "EXTRACT(#{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left]} FROM "
         collector = visit o.right, collector
-        collector << ' AS TIMESTAMP WITH TIME ZONE))'
+        collector << ")"
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Locate(o, collector)
-        collector << 'POSITION('
+      def visit_ArelExtensions_Nodes_Locate o, collector
+        collector << "POSITION("
         collector = visit o.right, collector
-        collector << ' IN '
+        collector << " IN "
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Substring(o, collector)
-        return visit(o.range_substring_node, collector) if o.range?
-
-        collector << 'SUBSTR('
+      def visit_ArelExtensions_Nodes_Substring o, collector
+        collector << "SUBSTR("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_RegexpReplace(o, collector)
-        collector << 'REGEXP_REPLACE('
-        visit o.left, collector
-        collector << COMMA
-        tab = o.pattern.inspect + 'g' # Make it always global
-        pattern = tab.split('/')[1..-2].join('/')
-        flags = tab.split('/')[-1]
-        visit Arel.quoted(pattern), collector
-        collector << COMMA
-        visit o.substitute, collector
-        collector << COMMA
-        visit Arel.quoted(flags + 'g'), collector
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_IsNull(o, collector)
+      def visit_ArelExtensions_Nodes_IsNull o, collector
         collector = visit o.expr, collector
         collector << ' IS NULL'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNotNull(o, collector)
-        collector = visit o.expr, collector
-        collector << ' IS NOT NULL'
-        collector
+      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+          collector = visit o.expr, collector
+          collector << ' IS NOT NULL'
+          collector
       end
 
-      def visit_ArelExtensions_Nodes_Sum(o, collector)
-        collector << 'sum('
+      def visit_ArelExtensions_Nodes_Sum o, collector
+        collector << "sum("
         collector = visit o.expr, collector
-        collector << ')'
-        visit_Aggregate_For_AggregateFunction o, collector
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Wday(o, collector)
-        collector << 'EXRTACT(DOW, '
+      def visit_ArelExtensions_Nodes_Wday o, collector
+        collector << "EXRTACT(DOW, "
         collector = visit o.date, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Cast(o, collector)
-        as_attr =
-          case o.as_attr
-          when :string
-            'varchar'
-          when :text, :ntext
-            'text'
-          when :time
-            'time'
-          when :int
-            collector << 'CAST(CAST('
-            collector = visit o.left, collector
-            collector << ' AS numeric) AS int)'
-            return collector
-          when :number, :decimal, :float
-            'numeric'
-          when :datetime
-            'timestamp without time zone'
-          when :date
-            'date'
-          when :binary
-            'binary'
-          when :jsonb
-            'jsonb'
-          else
-            o.as_attr.to_s
-          end
-
-        collector << 'CAST('
+      def visit_ArelExtensions_Nodes_Cast o, collector
+        as_attr = case o.as_attr
+        when :string
+          Arel::Nodes::SqlLiteral.new('varchar')
+        when :time
+          Arel::Nodes::SqlLiteral.new('time')
+        when :int
+          collector << "CAST(CAST("
+          collector = visit o.left, collector
+          collector << " AS numeric) AS int)"
+          return collector
+        when :number, :decimal, :float
+          Arel::Nodes::SqlLiteral.new('numeric')
+        when :datetime
+          Arel::Nodes::SqlLiteral.new('timestamp')
+        when :date
+          Arel::Nodes::SqlLiteral.new('date')
+        when :binary
+          Arel::Nodes::SqlLiteral.new('binary')
+        else
+          Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
+        end
+        collector << "CAST("
         collector = visit o.left, collector
-        collector << ' AS '
-        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), collector
-        collector << ')'
+        collector << " AS "
+        collector = visit as_attr, collector
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber(o, collector)
+      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        comma = o.precision == 0 ? '' : (NUMBER_COMMA_MAPPING[o.locale][0] || '.')
-        thousand_separator = NUMBER_COMMA_MAPPING[o.locale][1] || (NUMBER_COMMA_MAPPING[o.locale] ? '' : 'G')
-        nines_after = (1..o.precision).map { '9' }.join('')
-        nines_before = ("999#{thousand_separator}" * 4 + '990')
+        comma = o.precision == 0 ? '' : (Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale][0] || '.')
+        thousand_separator = Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale][1] || (Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale] ? '' : 'G')
+        nines_after = (1..o.precision).map{'9'}.join('')
+        nines_before = ("999#{thousand_separator}"*4+"990")
 
-        sign = Arel.when(col < 0).
+        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('TRIM', [
-                  Arel::Nodes::NamedFunction.new('TO_CHAR', [
-                    Arel.when(col.not_eq 0).then(col.abs / Arel.quoted(10).pow(col.abs.log10.floor)).else(1),
-                    Arel.quoted("FM#{nines_before}\"#{comma}\"V#{nines_after}")
-                  ])]),
-                o.type,
-                Arel::Nodes::NamedFunction.new('TRIM', [
-                  Arel::Nodes::NamedFunction.new('TO_CHAR', [
-                    Arel.when(col.not_eq 0).then(col.abs.log10.floor).else(0),
-                    Arel.quoted("FM#{nines_before}")
-                  ])])
-              ])
-          else
-            Arel::Nodes::NamedFunction.new('TRIM', [
-              Arel::Nodes::NamedFunction.new('TO_CHAR', [
-                Arel.quoted(col.abs),
-                Arel.quoted("FM#{nines_before}\"#{comma}\"V#{nines_after}")
-              ])])
-          end
+        if o.scientific_notation
+          number = ArelExtensions::Nodes::Concat.new([
+                  Arel::Nodes::NamedFunction.new('TRIM',[
+                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                      col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor),
+                      Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+                    ])]),
+                  o.type,
+                  Arel::Nodes::NamedFunction.new('TRIM',[
+                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                      col.abs.log10.floor,
+                      Arel::Nodes.build_quoted('FM'+nines_before)
+                    ])])
+                ])
+        else
+          number = Arel::Nodes::NamedFunction.new('TRIM',[
+                Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                  Arel::Nodes.build_quoted(col.abs),
+                  Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+                ])])
+        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,
@@ -482,29 +384,31 @@ 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
 
-      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_TableAlias visit_Arel_Nodes_TableAlias rescue nil
-      def visit_Arel_Nodes_TableAlias(o, collector)
+      alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias
+      def visit_Arel_Nodes_TableAlias o, collector
         if o.name.length > 63
           o = Arel::Table.new(o.table_name).alias(Arel.shorten(o.name))
         end
-        old_visit_Arel_Nodes_TableAlias(o, collector)
+        old_visit_Arel_Nodes_TableAlias(o,collector)
       end
 
-      alias old_visit_Arel_Attributes_Attribute visit_Arel_Attributes_Attribute rescue nil
-      def visit_Arel_Attributes_Attribute(o, collector)
+      alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute
+      def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
         if join_name.length > 63
           join_name = Arel.shorten(join_name)
@@ -512,73 +416,58 @@ module ArelExtensions
         collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
       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
 
-      def visit_ArelExtensions_Nodes_Json(o, collector)
+      def visit_ArelExtensions_Nodes_Json o,collector
         case o.dict
         when Array
-          if o.dict.empty?
-            # `to_jsonb(array[])` would raise "cannot determine type of empty array";
-            # an empty array is simply the `[]` JSON literal.
-            collector << %('[]'::jsonb)
-          else
-            collector << 'to_jsonb(array['
-            o.dict.each.with_index do |v, i|
-              if i != 0
-                collector << COMMA
-              end
-              collector = visit v, collector
+          collector << 'to_jsonb(array['
+          o.dict.each.with_index do |v,i|
+            if i != 0
+              collector << Arel::Visitors::MySQL::COMMA
             end
-            collector << '])'
+            collector  = visit v, collector
           end
+          collector << '])'
         when Hash
           collector << 'jsonb_build_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 << Arel::Visitors::MySQL::COMMA
             collector = visit v, collector
           end
           collector << ')'
-        when String, Numeric, TrueClass, FalseClass
-          collector = visit Arel.quoted("#{o.dict}"), collector
+        when String,Numeric,TrueClass,FalseClass
+          collector = visit Arel::Nodes.build_quoted("#{o.dict}"), collector
           collector << '::jsonb'
         when NilClass
-          collector << %('null'::jsonb)
+          collector  << %Q['null'::jsonb]
+        when Arel::Attributes::Attribute
+          collector = visit o.dict.cast(:jsonb), collector
         else
-          if o.dict.is_a?(Arel::Nodes::Quoted) && o.dict.expr.nil?
-            # `Arel.null` must mean the JSON null member, not SQL NULL:
-            # `to_jsonb(NULL)` would raise a polymorphic-type error.
-            collector << %('null'::jsonb)
-          else
-            # `to_jsonb` rather than `::jsonb` so a non-JSON value (e.g. a text column) is
-            # encoded as a JSON string instead of rejected by the server.
-            collector << 'to_jsonb('
-            collector = visit o.dict, collector
-            collector << ')'
-          end
+          collector = visit o.dict, collector
+          collector << '::jsonb'
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonMerge(o, collector)
-        o.expressions.each.with_index do |v, i|
+      def visit_ArelExtensions_Nodes_JsonMerge o,collector
+        o.expressions.each.with_index do |v,i|
           if i != 0
             collector << ' || '
           end
@@ -587,29 +476,28 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGet(o, collector)
+      def visit_ArelExtensions_Nodes_JsonGet o,collector
         collector = visit o.dict, collector
-        collector << ' ->> '
-        visit o.key, collector
+        collector << ' -> '
+        collector = visit o.key, collector
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonSet(o, collector)
+      def visit_ArelExtensions_Nodes_JsonSet o,collector
         collector << 'jsonb_set('
         collector = visit o.dict, collector
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         collector << 'array['
         collector = visit o.key, collector
         collector << ']'
-        collector << COMMA
-        collector << 'COALESCE('
+        collector << Arel::Visitors::MySQL::COMMA
         collector = visit o.value, collector
-        collector << ", 'null'::jsonb)"
-        collector << COMMA
+        collector << Arel::Visitors::MySQL::COMMA
         collector << 'true)'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGroup(o, collector)
+      def visit_ArelExtensions_Nodes_JsonGroup o, collector
         if o.as_array
           collector << 'jsonb_agg('
           collector = visit o.dict, collector
@@ -617,13 +505,13 @@ module ArelExtensions
         else
           case o.dict
           when Hash
-            o.dict.each.with_index do |(k, v), i|
+            o.dict.each.with_index do |(k,v),i|
               if i != 0
                 collector << ' || '
               end
               collector << 'jsonb_object_agg('
               collector = visit k, collector
-              collector << COMMA
+              collector << Arel::Visitors::MySQL::COMMA
               collector = visit v, collector
               collector << ')'
             end
@@ -635,6 +523,7 @@ module ArelExtensions
         end
         collector
       end
+
     end
   end
 end