arel_extensions 2.1.3 → 2.1.4

data/lib/arel_extensions/visitors/oracle.rb

@@ -7,30 +7,30 @@ module ArelExtensions
       DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'YYYY', '%C' => 'CC', '%y' => 'YY', '%m' => 'MM', '%B' => 'Month', '%^B' => 'MONTH', '%b' => 'Mon', '%^b' => 'MON',
         '%V' => 'IW', '%G' => 'IYYY',                                                                       # ISO week number and year of week
-        '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%A' => 'Day',                             # day, weekday
+        '%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' => ', ' }
 
       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
@@ -108,54 +108,54 @@ 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_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
@@ -165,12 +165,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
@@ -185,7 +185,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
@@ -219,16 +219,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/
@@ -244,7 +244,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
@@ -252,45 +252,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
@@ -300,18 +300,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#{o.bytewise ? 'B' : ''}("
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -328,18 +328,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
@@ -348,7 +348,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
@@ -357,22 +357,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
 
@@ -391,14 +391,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
 
@@ -411,7 +411,7 @@ module ArelExtensions
         end
         collector << ' FROM '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -424,7 +424,7 @@ module ArelExtensions
         end
         collector << ' FROM '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -447,46 +447,46 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_Format o, collector
         fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
-        collector << "TO_CHAR("
-        collector << "CAST(" if o.time_zone
+        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::Nodes.build_quoted(src_tz), collector
+          collector = visit Arel.quoted(src_tz), collector
           collecto < ' at time zone '
-          collector = visit Arel::Nodes.build_quoted(dst_tz), collector
+          collector = visit Arel.quoted(dst_tz), collector
         when String
           collector << ' as timestamp) at time zone '
-          collector = visit Arel::Nodes.build_quoted(o.time_zone), collector
+          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
@@ -494,18 +494,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
@@ -520,7 +520,7 @@ module ArelExtensions
             }
             collector << ' FROM DUAL)'
           end
-          collector << ")"
+          collector << ')'
           collector
         end
       end
@@ -530,7 +530,7 @@ module ArelExtensions
         if element.is_a?(Time)
           ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
         elsif element.is_a?(Arel::Attributes::Attribute)
-          col = ArelExtensions::column_of(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
@@ -545,7 +545,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
@@ -553,7 +553,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
@@ -561,7 +561,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
@@ -569,7 +569,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
@@ -581,7 +581,7 @@ 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
@@ -589,7 +589,7 @@ module ArelExtensions
         if o.name.length > 30
           o = Arel::Table.new(o.table_name).alias(Base64.urlsafe_encode64(Digest::MD5.new.digest(o.name)).tr('=', '').tr('-', '_'))
         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
@@ -625,47 +625,47 @@ 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(
+        repeated_char = (o.width == 0) ? Arel.quoted('') : ArelExtensions::Nodes::Case.new.
+          when(Arel.quoted(o.width).abs - (number.length + sign_length) > 0).
+          then(Arel.quoted(
               o.flags.include?('-') ? ' ' : (o.flags.include?('0') ? '0' : ' ')
-            ).repeat(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length))
+            ).repeat(Arel.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 : ''
+        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,
@@ -674,26 +674,26 @@ 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