arel_extensions 2.3.3 → 2.5.0

data/lib/arel_extensions/visitors/oracle.rb

@@ -13,27 +13,41 @@ module ArelExtensions
       }
       NUMBER_COMMA_MAPPING = {'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '}
 
-      def visit_ArelExtensions_Nodes_Log10 o, collector
+      def visit_ArelExtensions_Nodes_ByteSize(o, collector)
+        collector << 'LENGTHB('
+        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_Log10(o, collector)
         collector << 'LOG('
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ',10)'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Power o, collector
+      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 << COMMA if i != 0
           collector = visit arg, collector
         }
         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 o.convert_to_string_node(arg), collector
@@ -43,7 +57,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IMatches o, collector
+      def visit_ArelExtensions_Nodes_IMatches(o, collector)
         collector << 'LOWER('
         collector = visit o.left, collector
         collector << ') LIKE LOWER('
@@ -57,7 +71,7 @@ module ArelExtensions
         end
       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
@@ -69,7 +83,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 << ' LIKE '
         collector = visit o.right.ai_collate, collector
@@ -81,7 +95,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
@@ -93,7 +107,7 @@ module ArelExtensions
         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('
@@ -107,7 +121,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_Collate o, collector
+      def visit_ArelExtensions_Nodes_Collate(o, collector)
         if o.ai
           collector << 'NLSSORT('
           collector = visit o.expressions.first, collector
@@ -123,39 +137,39 @@ module ArelExtensions
         else
           collector = visit o.expressions.first, collector
         end
-      collector
+        collector
       end
 
       def visit_Arel_Nodes_RollUp(o, collector)
-        collector << "ROLLUP"
+        collector << 'ROLLUP'
         grouping_array_or_grouping_element o, collector
       end
 
-      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
         collector << '(LISTAGG('
         collector = visit o.left, collector
         collector << COMMA
         sep = o.separator.is_a?(Arel::Nodes::Quoted) ? o.separator.expr : o.separator
         collector =
-          if 'NULL' != sep
-            visit o.separator, collector
-          else
+          if 'NULL' == sep
             visit Arel.quoted(','), collector
+          else
+            visit o.separator, collector
           end
         collector << ') WITHIN GROUP (ORDER BY '
-        if !o.order.blank?
+        if o.order.blank?
+          collector = visit o.left, collector
+        else
           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
       end
 
-      def visit_ArelExtensions_Nodes_Coalesce o, collector
+      def visit_ArelExtensions_Nodes_Coalesce(o, collector)
         collector << 'COALESCE('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -175,7 +189,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_MD5 o, collector
+      def visit_ArelExtensions_Nodes_MD5(o, collector)
         collector << 'LOWER (RAWTOHEX (DBMS_OBFUSCATION_TOOLKIT.md5(input => UTL_I18N.STRING_TO_RAW('
         collector = visit o.left, collector
         collector << ", 'AL32UTF8'))))"
@@ -183,9 +197,9 @@ module ArelExtensions
       end
 
       # :date is not possible in Oracle since this type does not really exist
-      def visit_ArelExtensions_Nodes_DateDiff o, collector
-        lc = o.left_node_type == :ruby_date || o.left_node_type == :ruby_time
-        rc = o.right_node_type == :ruby_date || o.right_node_type == :ruby_time
+      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
+        lc = %i[ruby_date ruby_time].include?(o.left_node_type)
+        rc = %i[ruby_date ruby_time].include?(o.right_node_type)
         if rc || o.right_node_type == :date || o.right_node_type == :datetime || o.right_node_type == :time
           collector << '('
           collector << 'TO_DATE(' if lc
@@ -196,7 +210,7 @@ module ArelExtensions
           collector = visit o.right, collector
           collector << ')' if rc
           collector << ')'
-          if (o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time)
+          if %i[ruby_time datetime time].include?(o.left_node_type)
             collector << ' * (CASE WHEN (TRUNC('
             collector << 'TO_DATE(' if lc
             collector = visit o.left, collector
@@ -222,7 +236,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration o, collector
+      def visit_ArelExtensions_Nodes_Duration(o, collector)
         case o.left
         when 'wd', 'w'
           collector << 'TO_CHAR('
@@ -230,23 +244,24 @@ module ArelExtensions
           collector << COMMA
           collector = visit Arel.quoted(DATE_MAPPING[o.left]), collector
         else
-          right = case o.left
-          when  'd', 'm', 'y'
-            interval = 'DAY'
-            o.right.cast(:date)
-          when 'h', 'mn', 's'
-            interval = 'SECOND'
-            o.right.cast(:datetime)
-          when /i\z/
-            interval = DATE_MAPPING[o.left[0..-2]]
-            collector << '('
-            collector = visit o.right, collector
-            collector << ") * (INTERVAL '1' #{interval})"
-            return collector
-          else
-            interval = nil
-            o.right
-          end
+          right =
+            case o.left
+            when 'd', 'm', 'y'
+              interval = 'DAY'
+              o.right.cast(:date)
+            when 'h', 'mn', 's'
+              interval = 'SECOND'
+              o.right.cast(:datetime)
+            when /i\z/
+              interval = DATE_MAPPING[o.left[0..-2]]
+              collector << '('
+              collector = visit o.right, collector
+              collector << ") * (INTERVAL '1' #{interval})"
+              return collector
+            else
+              interval = nil
+              o.right
+            end
           collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
           collector = visit right, collector
         end
@@ -255,7 +270,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Cast o, collector
+      def visit_ArelExtensions_Nodes_Cast(o, collector)
         case o.as_attr
         when :string
           collector << 'TO_CHAR('
@@ -314,26 +329,26 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Length o, collector
-        collector << "LENGTH#{o.bytewise ? 'B' : ''}("
+      def visit_ArelExtensions_Nodes_Length(o, collector)
+        collector << "LENGTH#{'B' if o.bytewise}("
         collector = visit o.expr, 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
+      def visit_ArelExtensions_Nodes_IsNotNull(o, collector)
         collector = visit o.expr, collector
         collector << ' IS NOT NULL'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Rand o, collector
+      def visit_ArelExtensions_Nodes_Rand(o, collector)
         collector << 'DBMS_RANDOM.VALUE('
         if o.left && o.right
           collector = visit o.left, collector
@@ -344,7 +359,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_Arel_Nodes_Regexp o, collector
+      def visit_Arel_Nodes_Regexp(o, collector)
         collector << ' REGEXP_LIKE('
         collector = visit o.left, collector
         collector << COMMA
@@ -353,7 +368,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_Arel_Nodes_NotRegexp o, collector
+      def visit_Arel_Nodes_NotRegexp(o, collector)
         collector << ' NOT REGEXP_LIKE('
         collector = visit o.left, collector
         collector << COMMA
@@ -362,7 +377,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Locate o, collector
+      def visit_ArelExtensions_Nodes_Locate(o, collector)
         collector << 'INSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -372,7 +387,9 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Substring o, collector
+      def visit_ArelExtensions_Nodes_Substring(o, collector)
+        return visit(o.range_substring_node, collector) if o.range?
+
         collector << 'SUBSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -382,7 +399,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim o, collector
+      def visit_ArelExtensions_Nodes_Trim(o, collector)
         collector << 'TRIM(' # BOTH
         if o.right.expr && SPECIAL_CHARS[o.right.expr]
           collector << SPECIAL_CHARS[o.right.expr]
@@ -408,7 +425,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Ltrim o, collector
+      def visit_ArelExtensions_Nodes_Ltrim(o, collector)
         collector << 'TRIM(LEADING '
         if o.right.expr && SPECIAL_CHARS[o.right.expr]
           collector << SPECIAL_CHARS[o.right.expr]
@@ -421,7 +438,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Rtrim o, collector
+      def visit_ArelExtensions_Nodes_Rtrim(o, collector)
         collector << 'TRIM(TRAILING '
         if o.right.expr && SPECIAL_CHARS[o.right.expr]
           collector << SPECIAL_CHARS[o.right.expr]
@@ -434,15 +451,15 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Blank o, collector
+      def visit_ArelExtensions_Nodes_Blank(o, collector)
         visit o.expr.trim.length.coalesce(0).eq(0), collector
       end
 
-      def visit_ArelExtensions_Nodes_NotBlank o, collector
+      def visit_ArelExtensions_Nodes_NotBlank(o, collector)
         visit o.expr.trim.length.coalesce(0).gt(0), collector
       end
 
-      def visit_ArelExtensions_Nodes_DateAdd o, collector
+      def visit_ArelExtensions_Nodes_DateAdd(o, collector)
         collector << '('
         collector = visit o.left, collector
         collector << ' + ' # (o.right.value >= 0 ? ' + ' : ' - ')
@@ -451,12 +468,12 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Format o, collector
+      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)
+      def visit_ArelExtensions_Nodes_FormattedDate(o, collector)
+        fmt = ArelExtensions::Visitors.strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
         collector << 'TO_CHAR('
         collector << 'CAST(' if o.time_zone
         collector = visit o.left, collector
@@ -465,7 +482,7 @@ module ArelExtensions
           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 << ' at time zone '
           collector = visit Arel.quoted(dst_tz), collector
         when String
           collector << ' as timestamp) at time zone '
@@ -477,20 +494,20 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Repeat o, collector
+      def visit_ArelExtensions_Nodes_Repeat(o, collector)
         collector << 'LPAD('
         collector = visit o.expressions[0], collector # can't put empty string, otherwise it wouldn't work
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         collector = visit o.expressions[1], collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         collector = visit o.expressions[0], 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
+      if AREL_VERSION < V7
+        def visit_ArelExtensions_InsertManager_BulkValues(o, collector)
           collector << '('
           o.left.each_with_index do |row, idx| # values
             collector << ' UNION ALL ' if idx != 0
@@ -511,7 +528,7 @@ module ArelExtensions
           collector
         end
       else
-        def visit_ArelExtensions_InsertManager_BulkValues o, collector
+        def visit_ArelExtensions_InsertManager_BulkValues(o, collector)
           collector << '('
           o.left.each_with_index do |row, idx|
             collector << ' UNION ALL ' if idx != 0
@@ -535,8 +552,7 @@ module ArelExtensions
         end
       end
 
-
-      def get_time_converted element
+      def get_time_converted(element)
         if element.is_a?(Time)
           ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
         elsif element.is_a?(Arel::Attributes::Attribute)
@@ -551,42 +567,36 @@ module ArelExtensions
         end
       end
 
-
       remove_method(:visit_Arel_Nodes_GreaterThanOrEqual) rescue nil
-      def visit_Arel_Nodes_GreaterThanOrEqual o, collector
+      def visit_Arel_Nodes_GreaterThanOrEqual(o, collector)
         collector = visit get_time_converted(o.left), collector
         collector << ' >= '
-        collector = visit get_time_converted(o.right), collector
-        collector
+        visit get_time_converted(o.right), collector
       end
 
       remove_method(:visit_Arel_Nodes_GreaterThan) rescue nil
-      def visit_Arel_Nodes_GreaterThan o, collector
+      def visit_Arel_Nodes_GreaterThan(o, collector)
         collector = visit get_time_converted(o.left), collector
         collector << ' > '
-        collector = visit get_time_converted(o.right), collector
-        collector
+        visit get_time_converted(o.right), collector
       end
 
       remove_method(:visit_Arel_Nodes_LessThanOrEqual) rescue nil
-      def visit_Arel_Nodes_LessThanOrEqual o, collector
+      def visit_Arel_Nodes_LessThanOrEqual(o, collector)
         collector = visit get_time_converted(o.left), collector
         collector << ' <= '
-        collector = visit get_time_converted(o.right), collector
-        collector
+        visit get_time_converted(o.right), collector
       end
 
       remove_method(:visit_Arel_Nodes_LessThan) rescue nil
-      def visit_Arel_Nodes_LessThan o, collector
+      def visit_Arel_Nodes_LessThan(o, collector)
         collector = visit get_time_converted(o.left), collector
         collector << ' < '
-        collector = visit get_time_converted(o.right), collector
-        collector
+        visit get_time_converted(o.right), collector
       end
 
-
-      alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
-      def visit_Arel_Nodes_SelectStatement o, collector
+      alias old_visit_Arel_Nodes_SelectStatement visit_Arel_Nodes_SelectStatement rescue nil
+      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 = []
@@ -594,16 +604,16 @@ module ArelExtensions
         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
+      alias 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(Arel.shorten(o.name))
         end
         old_visit_Arel_Nodes_TableAlias(o, collector)
       end
 
-      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
-      def visit_Arel_Nodes_As o, collector
+      alias old_visit_Arel_Nodes_As visit_Arel_Nodes_As rescue nil
+      def visit_Arel_Nodes_As(o, collector)
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
           collector = visit o.left, collector
@@ -618,12 +628,12 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_As o, collector
+      def visit_ArelExtensions_Nodes_As(o, collector)
         visit_Arel_Nodes_As o, collector
       end
 
-      alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
-      def visit_Arel_Attributes_Attribute o, collector
+      alias old_visit_Arel_Attributes_Attribute visit_Arel_Attributes_Attribute rescue nil
+      def visit_Arel_Attributes_Attribute(o, collector)
         join_name = o.relation.table_alias || o.relation.name
         if join_name.length > 30
           join_name = Arel.shorten(join_name)
@@ -631,11 +641,11 @@ module ArelExtensions
         collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
+      def visit_ArelExtensions_Nodes_FormattedNumber(o, collector)
         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.quoted("NLS_NUMERIC_CHARACTERS = '#{comma} '")
           nines_before = ('999' * 4 + '990')
@@ -693,24 +703,24 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Std o, collector
+      def visit_ArelExtensions_Nodes_Std(o, collector)
         collector << (o.unbiased_estimator ? 'STDDEV_SAMP(' : 'STDDEV_POP(')
         visit o.left, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Variance o, collector
+      def visit_ArelExtensions_Nodes_Variance(o, collector)
         collector << (o.unbiased_estimator ? 'VAR_SAMP(' : 'VAR_POP(')
         visit o.left, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
+      def visit_ArelExtensions_Nodes_LevenshteinDistance(o, collector)
         collector << 'UTL_MATCH.edit_distance('
         collector = visit o.left, collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         collector = visit o.right, collector
         collector << ')'
         collector
@@ -720,9 +730,9 @@ module ArelExtensions
       # handle grouping aggregation semantics
       def grouping_array_or_grouping_element(o, collector)
         if o.expr.is_a? Array
-          collector << "( "
+          collector << '( '
           visit o.expr, collector
-          collector << " )"
+          collector << ' )'
         else
           visit o.expr, collector
         end

data/lib/arel_extensions/visitors/oracle12.rb

@@ -1,8 +1,7 @@
 module ArelExtensions
   module Visitors
     Arel::Visitors.send(:remove_const, 'Oracle12') if Arel::Visitors.const_defined?('Oracle12')
-    Arel::Visitors.const_set('Oracle12', Class.new(Arel::Visitors::Oracle)).class_eval do
-
+    Arel::Visitors.const_set(:Oracle12, Class.new(Arel::Visitors::Oracle)).class_eval do
       def visit_Arel_Nodes_SelectOptions(o, collector)
         collector = maybe_visit o.offset, collector
         collector = maybe_visit o.limit, collector
@@ -48,13 +47,13 @@ module ArelExtensions
         collector << ')'
       end
 
-      def visit_ArelExtensions_Nodes_Json o, collector
+      def visit_ArelExtensions_Nodes_Json(o, collector)
         case o.dict
         when Array
           collector << 'json_array('
           o.dict.each.with_index do |v, i|
             if i != 0
-              collector << Arel::Visitors::MySQL::COMMA
+              collector << COMMA
             end
             collector = visit v, collector
           end
@@ -63,7 +62,7 @@ module ArelExtensions
           collector << 'json__object('
           o.dict.each.with_index do |(k, v), i|
             if i != 0
-              collector << Arel::Visitors::MySQL::COMMA
+              collector << COMMA
             end
             collector << 'KEY '
             collector = visit k, collector
@@ -76,7 +75,7 @@ module ArelExtensions
           collector = visit Arel.quoted("#{o.dict}"), collector
           collector << ' FORMAT JSON'
         when NilClass
-          collector << %Q['null' FORMAT JSON]
+          collector << %('null' FORMAT JSON)
         when Arel::Attributes::Attribute
           collector = visit o.dict.cast('JSON'), collector
         else