arel_extensions 2.0.21 → 2.2.2

data/lib/arel_extensions/visitors/oracle.rb

@@ -6,30 +6,31 @@ module ArelExtensions
       DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
       DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'YYYY', '%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
+        '%V' => 'IW', '%G' => 'IYYY',                                                                       # ISO week number and year of week
+        '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%a' => 'Dy', '%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
       }
-      NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
+      NUMBER_COMMA_MAPPING = {'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '}
 
       def visit_ArelExtensions_Nodes_Log10 o, collector
-          collector << "LOG("
-          o.expressions.each_with_index { |arg, i|
-            collector << Arel::Visitors::ToSql::COMMA if i != 0
-            collector = visit arg, collector
-          }
-          collector << ",10)"
-          collector
+        collector << 'LOG('
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector = visit arg, collector
+        }
+        collector << ',10)'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Power o, collector
-            collector << "POWER("
-            o.expressions.each_with_index { |arg, i|
-              collector << Arel::Visitors::ToSql::COMMA if i != 0
-              collector = visit arg, collector
-            }
-            collector << ")"
-            collector
+        collector << 'POWER('
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector = visit arg, collector
+        }
+        collector << ')'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Concat o, collector
@@ -107,54 +108,59 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Collate o, collector
-      if o.ai
-        collector << "NLSSORT("
-        collector = visit o.expressions.first, collector
-        collector << COMMA
-        collector << "'NLS_SORT = BINARY_AI NLS_COMP = LINGUISTIC'"
-        collector << ")"
-      elsif o.ci
-        collector << "NLSSORT("
-        collector = visit o.expressions.first, collector
-        collector << COMMA
-        collector << "'NLS_SORT = BINARY_CI NLS_COMP = LINGUISTIC'"
-        collector << ")"
-      else
-        collector = visit o.expressions.first, collector
-      end
+        if o.ai
+          collector << 'NLSSORT('
+          collector = visit o.expressions.first, collector
+          collector << COMMA
+          collector << "'NLS_SORT = BINARY_AI NLS_COMP = LINGUISTIC'"
+          collector << ')'
+        elsif o.ci
+          collector << 'NLSSORT('
+          collector = visit o.expressions.first, collector
+          collector << COMMA
+          collector << "'NLS_SORT = BINARY_CI NLS_COMP = LINGUISTIC'"
+          collector << ')'
+        else
+          collector = visit o.expressions.first, collector
+        end
       collector
       end
 
+      def visit_Arel_Nodes_RollUp(o, collector)
+        collector << "ROLLUP"
+        grouping_array_or_grouping_element o, collector
+      end
+
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "(LISTAGG("
+        collector << '(LISTAGG('
         collector = visit o.left, collector
         collector << COMMA
         collector =
           if o.separator && o.separator != 'NULL'
             visit o.separator, collector
           else
-            visit Arel::Nodes.build_quoted(','), collector
+            visit Arel.quoted(','), collector
           end
-        collector << ") WITHIN GROUP (ORDER BY "
+        collector << ') WITHIN GROUP (ORDER BY '
         if !o.order.blank?
-          o.order.each_with_index do |order,i|
+          o.order.each_with_index do |order, i|
             collector << COMMA if i != 0
             collector = visit order, collector
           end
         else
           collector = visit o.left, collector
         end
-        collector << "))"
+        collector << '))'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Coalesce o, collector
-        collector << "COALESCE("
+        collector << 'COALESCE('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           if i > 0 && o.left_node_type == :text
             if arg == '' || (arg.is_a?(Arel::Nodes::Quoted) && (arg.expr == ''))
-              collector << "NULL"
+              collector << 'NULL'
             else
               collector << 'TO_CLOB('
               collector = visit arg, collector
@@ -164,12 +170,12 @@ module ArelExtensions
             collector = visit arg, collector
           end
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_MD5 o, collector
-        collector << "LOWER (RAWTOHEX (DBMS_OBFUSCATION_TOOLKIT.md5(input => UTL_I18N.STRING_TO_RAW("
+        collector << 'LOWER (RAWTOHEX (DBMS_OBFUSCATION_TOOLKIT.md5(input => UTL_I18N.STRING_TO_RAW('
         collector = visit o.left, collector
         collector << ", 'AL32UTF8'))))"
         collector
@@ -184,7 +190,7 @@ module ArelExtensions
           collector << 'TO_DATE(' if lc
           collector = visit o.left, collector
           collector << ')' if lc
-          collector << " - "
+          collector << ' - '
           collector << 'TO_DATE(' if rc
           collector = visit o.right, collector
           collector << ')' if rc
@@ -218,16 +224,16 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Duration o, collector
         case o.left
         when 'wd', 'w'
-          collector << "TO_CHAR("
+          collector << 'TO_CHAR('
           collector = visit o.right, collector
           collector << COMMA
-          collector = visit Arel::Nodes.build_quoted(DATE_MAPPING[o.left]), collector
+          collector = visit Arel.quoted(DATE_MAPPING[o.left]), collector
         else
           right = case o.left
-          when  'd','m','y'
+          when  'd', 'm', 'y'
             interval = 'DAY'
             o.right.cast(:date)
-          when 'h','mn','s'
+          when 'h', 'mn', 's'
             interval = 'SECOND'
             o.right.cast(:datetime)
           when /i\z/
@@ -243,7 +249,7 @@ module ArelExtensions
           collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
           collector = visit right, collector
         end
-        collector << ")"
+        collector << ')'
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
         collector
       end
@@ -251,45 +257,45 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Cast o, collector
         case o.as_attr
         when :string
-          collector << "TO_CHAR("
+          collector << 'TO_CHAR('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
           return collector
         when :text
-          collector << "TO_CLOB("
+          collector << 'TO_CLOB('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
           return collector
         when :ntext
-          collector << "TO_NCLOB("
+          collector << 'TO_NCLOB('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
           return collector
         when :time
           if (o.left.respond_to?(:return_type) && o.left.return_type == :string) || o.left.is_a?(Arel::Nodes::Quoted)
-            collector << "TO_DATE("
+            collector << 'TO_DATE('
             collector = visit o.left, collector
             collector << ",'HH24:MI:SS')"
           else
-            collector << "TO_DATE(TO_CHAR("
+            collector << 'TO_DATE(TO_CHAR('
             collector = visit o.left, collector
             collector << ",'HH24:MI:SS'),'HH24:MI:SS')"
           end
           return collector
         when :number, :decimal
-          collector << "TO_NUMBER("
+          collector << 'TO_NUMBER('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
           return collector
         when :datetime
           as_attr = Arel::Nodes::SqlLiteral.new('timestamp')
         when :date
           if (o.left.respond_to?(:return_type) && o.left.return_type == :string) || o.left.is_a?(Arel::Nodes::Quoted)
-            collector << "TO_DATE("
+            collector << 'TO_DATE('
             collector = visit o.left, collector
             collector << ",'YYYY-MM-DD')"
           else
-            collector << "TO_DATE(TO_CHAR("
+            collector << 'TO_DATE(TO_CHAR('
             collector = visit o.left, collector
             collector << ",'YYYY-MM-DD'),'YYYY-MM-DD')"
           end
@@ -299,18 +305,18 @@ module ArelExtensions
         else
           as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
         end
-        collector << "CAST("
+        collector << 'CAST('
         collector = visit o.left, collector
-        collector << " AS "
+        collector << ' AS '
         collector = visit as_attr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Length o, collector
-        collector << "LENGTH("
+        collector << "LENGTH#{o.bytewise ? 'B' : ''}("
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -327,18 +333,18 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Rand o, collector
-        collector << "DBMS_RANDOM.VALUE("
+        collector << 'DBMS_RANDOM.VALUE('
         if o.left && o.right
           collector = visit o.left, collector
           collector << COMMA
           collector = visit o.right, collector
         end
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_Arel_Nodes_Regexp o, collector
-        collector << " REGEXP_LIKE("
+        collector << ' REGEXP_LIKE('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.right, collector
@@ -347,7 +353,7 @@ module ArelExtensions
       end
 
       def visit_Arel_Nodes_NotRegexp o, collector
-        collector << " NOT REGEXP_LIKE("
+        collector << ' NOT REGEXP_LIKE('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.right, collector
@@ -356,22 +362,22 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Locate o, collector
-        collector << "INSTR("
+        collector << 'INSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Substring o, collector
-        collector << "SUBSTR("
+        collector << 'SUBSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -390,14 +396,14 @@ module ArelExtensions
           collector << COMMA
           collector << 'COALESCE(dbms_lob.GETLENGTH('
           collector = visit o.left, collector
-          collector << "), 0)"
+          collector << '), 0)'
           collector << COMMA
           collector << '1)'
         else
           collector = visit o.left, collector
         end
         collector << ')' if o.left.is_a? ArelExtensions::Nodes::Trim
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -410,7 +416,7 @@ module ArelExtensions
         end
         collector << ' FROM '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -423,7 +429,7 @@ module ArelExtensions
         end
         collector << ' FROM '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -445,35 +451,51 @@ module ArelExtensions
       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 << 'TO_CHAR('
+        collector << 'CAST(' if o.time_zone
         collector = visit o.left, collector
+        case o.time_zone
+        when Hash
+          src_tz, dst_tz = o.time_zone.first
+          collector << ' as timestamp) at time zone '
+          collector = visit Arel.quoted(src_tz), collector
+          collector < ' at time zone '
+          collector = visit Arel.quoted(dst_tz), collector
+        when String
+          collector << ' as timestamp) at time zone '
+          collector = visit Arel.quoted(o.time_zone), collector
+        end
         collector << COMMA
-        collector = visit Arel::Nodes.build_quoted(fmt), collector
-        collector << ")"
+        collector = visit Arel.quoted(fmt), collector
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Repeat o, collector
-        collector << "LPAD("
+        collector << 'LPAD('
         collector = visit o.expressions[0], collector # can't put empty string, otherwise it wouldn't work
         collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.expressions[1], collector
         collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.expressions[0], collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       # add primary_key if not present, avoid zip
       if Arel::VERSION.to_i < 7
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
-          collector << "("
+          collector << '('
           o.left.each_with_index do |row, idx| # values
-          collector << " UNION ALL " if idx != 0
-          collector << "(SELECT "
-          len = row.length - 1
-          row.zip(o.cols).each_with_index { |(value, attr), i|
+            collector << ' UNION ALL ' if idx != 0
+            collector << '(SELECT '
+            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
@@ -481,18 +503,18 @@ module ArelExtensions
                 collector << quote(value, attr && column_for(attr)).to_s
               end
               collector << COMMA unless i == len
-          }
-          collector << ' FROM DUAL)'
+            }
+            collector << ' FROM DUAL)'
           end
-          collector << ")"
+          collector << ')'
           collector
         end
       else
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
-          collector << "("
+          collector << '('
           o.left.each_with_index do |row, idx|
-            collector << " UNION ALL " if idx != 0
-            collector << "(SELECT "
+            collector << ' UNION ALL ' if idx != 0
+            collector << '(SELECT '
             len = row.length - 1
             row.zip(o.cols).each_with_index { |(value, attr), i|
               case value
@@ -507,7 +529,7 @@ module ArelExtensions
             }
             collector << ' FROM DUAL)'
           end
-          collector << ")"
+          collector << ')'
           collector
         end
       end
@@ -517,7 +539,7 @@ module ArelExtensions
         if element.is_a?(Time)
           ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
         elsif element.is_a?(Arel::Attributes::Attribute)
-          col = Arel::Table.engine.connection.schema_cache.columns_hash(element.relation.table_name)[element.name.to_s]
+          col = Arel.column_of(element.relation.table_name, element.name.to_s)
           if col && (col.type == :time)
             ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
           else
@@ -532,7 +554,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_GreaterThanOrEqual) rescue nil
       def visit_Arel_Nodes_GreaterThanOrEqual o, collector
         collector = visit get_time_converted(o.left), collector
-        collector << " >= "
+        collector << ' >= '
         collector = visit get_time_converted(o.right), collector
         collector
       end
@@ -540,7 +562,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_GreaterThan) rescue nil
       def visit_Arel_Nodes_GreaterThan o, collector
         collector = visit get_time_converted(o.left), collector
-        collector << " > "
+        collector << ' > '
         collector = visit get_time_converted(o.right), collector
         collector
       end
@@ -548,7 +570,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_LessThanOrEqual) rescue nil
       def visit_Arel_Nodes_LessThanOrEqual o, collector
         collector = visit get_time_converted(o.left), collector
-        collector << " <= "
+        collector << ' <= '
         collector = visit get_time_converted(o.right), collector
         collector
       end
@@ -556,7 +578,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_LessThan) rescue nil
       def visit_Arel_Nodes_LessThan o, collector
         collector = visit get_time_converted(o.left), collector
-        collector << " < "
+        collector << ' < '
         collector = visit get_time_converted(o.right), collector
         collector
       end
@@ -568,15 +590,15 @@ module ArelExtensions
           o = o.dup
           o.orders = []
         end
-        old_visit_Arel_Nodes_SelectStatement(o,collector)
+        old_visit_Arel_Nodes_SelectStatement(o, collector)
       end
 
       alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
       def visit_Arel_Nodes_TableAlias o, collector
         if o.name.length > 30
-          o = Arel::Table.new(o.table_name).alias(Base64.urlsafe_encode64(Digest::MD5.new.digest(o.name)).tr('=', '').tr('-', '_'))
+          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_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
@@ -588,7 +610,7 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        quote = o.right.to_s =~ /(\A["].*["]\z)|\A[a-zA-Z_]*\z/ ? '' : '"'
+        quote = /(\A".*"\z)|\A[a-zA-Z_]*\z/.match?(o.right.to_s) ? '' : '"'
         collector << " AS #{quote}"
         collector = visit o.right, collector
         collector << "#{quote}"
@@ -612,47 +634,52 @@ module ArelExtensions
         col = o.left.coalesce(0)
         comma = NUMBER_COMMA_MAPPING[o.locale] || '.,'
         comma_in_format = o.precision == 0 ? '' : 'D'
-        nines_after = (1..o.precision-1).map{'9'}.join('')+'0'
+        nines_after = (1..o.precision - 1).map{'9'}.join('') + '0'
         if comma.length == 1
-          options = Arel::Nodes.build_quoted("NLS_NUMERIC_CHARACTERS = '"+comma+" '")
-          nines_before = ("999"*4+"990")
+          options = Arel.quoted("NLS_NUMERIC_CHARACTERS = '#{comma} '")
+          nines_before = ('999' * 4 + '990')
         else
-          options = Arel::Nodes.build_quoted("NLS_NUMERIC_CHARACTERS = '"+comma+"'")
-          nines_before = ("999G"*4+"990")
+          options = Arel.quoted("NLS_NUMERIC_CHARACTERS = '#{comma}'")
+          nines_before = ('999G' * 4 + '990')
         end
-        sign = ArelExtensions::Nodes::Case.new.when(col<0).
+        sign = Arel.when(col < 0).
                   then('-').
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = o.flags.include?('+') || o.flags.include?(' ') ?
-                Arel::Nodes.build_quoted(1) :
-                ArelExtensions::Nodes::Case.new.when(col<0).then(1).else(0)
+                Arel.quoted(1) :
+                Arel.when(col < 0).then(1).else(0)
 
         if o.scientific_notation
-          number = Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                Arel::Nodes.build_quoted(col.abs),
-                Arel::Nodes.build_quoted('FM'+nines_before+comma_in_format+nines_after+'EEEE'),
+          number = Arel::Nodes::NamedFunction.new('TO_CHAR', [
+                Arel.quoted(col.abs),
+                Arel.quoted("FM#{nines_before}#{comma_in_format}#{nines_after}EEEE"),
                 options
               ])
           if o.type == 'e'
-            number = number.replace('E','e')
+            number = number.replace('E', 'e')
           end
         else
-          number = Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                Arel::Nodes.build_quoted(col.abs),
-                Arel::Nodes.build_quoted('FM'+nines_before+comma_in_format+nines_after),
+          number = Arel::Nodes::NamedFunction.new('TO_CHAR', [
+                Arel.quoted(col.abs),
+                Arel.quoted("FM#{nines_before}#{comma_in_format}#{nines_after}"),
                 options
               ])
         end
 
-        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 : ''
+        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 : ''
         after  = o.flags.include?('-') ? repeated_char : ''
         full_number = ArelExtensions::Nodes::Concat.new([
             before,
@@ -661,32 +688,44 @@ module ArelExtensions
             number,
             after
           ])
-        collector = visit ArelExtensions::Nodes::Concat.new([Arel::Nodes.build_quoted(o.prefix),full_number,Arel::Nodes.build_quoted(o.suffix)]), collector
+        collector = visit ArelExtensions::Nodes::Concat.new([Arel.quoted(o.prefix), full_number, Arel.quoted(o.suffix)]), collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_Std o, collector
-        collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
+        collector << (o.unbiased_estimator ? 'STDDEV_SAMP(' : 'STDDEV_POP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Variance o, collector
-        collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
+        collector << (o.unbiased_estimator ? 'VAR_SAMP(' : 'VAR_POP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
-        collector << "UTL_MATCH.edit_distance("
+        collector << 'UTL_MATCH.edit_distance('
         collector = visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
         collector << ')'
         collector
       end
+
+      # Utilized by GroupingSet, Cube & RollUp visitors to
+      # handle grouping aggregation semantics
+      def grouping_array_or_grouping_element(o, collector)
+        if o.expr.is_a? Array
+          collector << "( "
+          visit o.expr, collector
+          collector << " )"
+        else
+          visit o.expr, collector
+        end
+      end
     end
   end
 end