arel_extensions 2.0.21 → 2.2.2

data/lib/arel_extensions/visitors/to_sql.rb

@@ -6,241 +6,252 @@ module ArelExtensions
       # Escape properly the string expression expr.
       # Take care of escaping.
       def make_json_string expr
-        Arel::Nodes.build_quoted('"') \
+        Arel.quoted('"') \
         + expr
-            .replace('\\','\\\\').replace('"','\"').replace("\n", '\n') \
+            .coalesce('')
+            .replace('\\', '\\\\')
+            .replace('"', '\"')
+            .replace("\b", '\b')
+            .replace("\f", '\f')
+            .replace("\n", '\n')
+            .replace("\r", '\r')
+            .replace("\t", '\t') \
         + '"'
       end
 
+      def make_json_null
+        Arel.quoted('null')
+      end
+
       # Math Functions
       def visit_ArelExtensions_Nodes_Abs o, collector
-        collector << "ABS("
+        collector << 'ABS('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Ceil o, collector
-        collector << "CEIL("
+        collector << 'CEIL('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Floor o, collector
-        collector << "FLOOR("
+        collector << 'FLOOR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Rand o, collector
-        collector << "RAND("
+        collector << 'RAND('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Round o, collector
-        collector << "ROUND("
+        collector << 'ROUND('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Log10 o, collector
-        collector << "LOG10("
+        collector << 'LOG10('
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Power o, collector
-        collector << "POW("
+        collector << 'POW('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Sum o, collector
-        collector << "SUM("
+        collector << 'SUM('
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
-        collector << "CONCAT("
+        collector << 'CONCAT('
         o.expressions.each_with_index { |arg, i|
-            collector << COMMA if i != 0
-            collector = visit arg, collector
+          collector << COMMA if i != 0
+          collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "GROUP_CONCAT("
+        collector << 'GROUP_CONCAT('
         collector = visit o.left, collector
         if o.separator && o.separator != 'NULL'
           collector << COMMA
           collector = visit o.separator, collector
         end
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_MD5 o, collector
-        collector << "MD5("
+        collector << 'MD5('
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Length o, collector
-        collector << "LENGTH("
+        collector << "#{o.bytewise ? '' : 'CHAR_'}LENGTH("
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Locate o, collector
-        collector << "LOCATE("
+        collector << 'LOCATE('
         collector = visit o.right, collector
         collector << COMMA
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Substring o, collector
-        collector << "SUBSTRING("
+        collector << 'SUBSTRING('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Replace o, collector
-        collector << "REPLACE("
+        collector << 'REPLACE('
         visit o.left, collector
         collector << COMMA
         visit o.pattern, collector
         collector << COMMA
         visit o.substitute, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_RegexpReplace o, collector
-        collector << "REGEXP_REPLACE("
+        collector << 'REGEXP_REPLACE('
         visit o.left, collector
         collector << COMMA
-        visit Arel::Nodes.build_quoted(o.pattern.to_s), collector
+        visit Arel.quoted(o.pattern.to_s), collector
         collector << COMMA
         visit o.substitute, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Repeat o, collector
-        collector << "REPEAT("
+        collector << 'REPEAT('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_FindInSet o, collector
-        collector << "FIND_IN_SET("
+        collector << 'FIND_IN_SET('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Soundex o, collector
-        collector << "SOUNDEX("
+        collector << 'SOUNDEX('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Downcase o, collector
-        collector << "LOWER("
+        collector << 'LOWER('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Upcase o, collector
-        collector << "UPPER("
+        collector << 'UPPER('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Trim o, collector
-        collector << "TRIM("
+        collector << 'TRIM('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Ltrim o, collector
-        collector << "LTRIM("
+        collector << 'LTRIM('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Rtrim o, collector
-        collector << "RTRIM("
+        collector << 'RTRIM('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -249,8 +260,8 @@ module ArelExtensions
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
         collector << COMMA
-        collector = visit Arel::Nodes.build_quoted(''), collector
-        collector << "))) = 0"
+        collector = visit Arel.quoted(''), collector
+        collector << '))) = 0'
         collector
       end
 
@@ -259,25 +270,45 @@ module ArelExtensions
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
         collector << COMMA
-        collector = visit Arel::Nodes.build_quoted(''), collector
-        collector << "))) > 0"
+        collector = visit Arel.quoted(''), collector
+        collector << '))) > 0'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Format o, collector
         case o.col_type
         when :date, :datetime, :time
-          collector << "STRFTIME("
+          collector << 'STRFTIME('
           collector = visit o.right, collector
           collector << COMMA
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
         when :integer, :float, :decimal
-          collector << "FORMAT("
+          collector << 'FORMAT('
           collector = visit o.left, collector
           collector << COMMA
           collector = visit o.right, collector
-          collector << ")"
+          collector << ')'
+        else
+          collector = visit o.left, collector
+        end
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_FormattedDate o, collector
+        case o.col_type
+        when :date, :datetime, :time
+          collector << 'STRFTIME('
+          collector = visit o.right, collector
+          collector << COMMA
+          collector = visit o.left, collector
+          collector << ')'
+        when :integer, :float, :decimal
+          collector << 'FORMAT('
+          collector = visit o.left, collector
+          collector << COMMA
+          collector = visit o.right, collector
+          collector << ')'
         else
           collector = visit o.left, collector
         end
@@ -287,61 +318,56 @@ module ArelExtensions
       # comparators
 
       def visit_ArelExtensions_Nodes_Cast o, collector
-        collector << "CAST("
+        as_attr =
+          case o.as_attr
+          when :binary                   then 'binary'
+          when :datetime                 then 'datetime'
+          when :decimal, :float, :number then 'float'
+          when :int                      then 'int'
+          when :string                   then 'char'
+          when :text, :ntext             then 'text'
+          when :time                     then 'time'
+          else                           o.as_attr.to_s
+          end
+
+        collector << 'CAST('
         collector = visit o.left, collector
-        collector << " AS "
-        case o.as_attr
-        when :string
-          as_attr = Arel::Nodes::SqlLiteral.new('char')
-        when :int
-          as_attr = Arel::Nodes::SqlLiteral.new('int')
-        when :decimal, :float, :number
-          as_attr = Arel::Nodes::SqlLiteral.new('float')
-        when :datetime
-          as_attr = Arel::Nodes::SqlLiteral.new('datetime')
-        when :time
-          as_attr = Arel::Nodes::SqlLiteral.new('time')
-        when :binary
-          as_attr = Arel::Nodes::SqlLiteral.new('binary')
-        when :text, :ntext
-          as_attr = Arel::Nodes::SqlLiteral.new('text')
-        else
-          as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
-        end
-        collector = visit as_attr, collector
-        collector << ")"
+        collector << ' AS '
+        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), 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
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_DateDiff o, collector
-        collector << if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
-                      'TIMEDIFF('
-                    else
-                      'DATEDIFF('
-                    end
+        collector <<
+          if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
+            'TIMEDIFF('
+          else
+            'DATEDIFF('
+          end
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.right, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_DateSub o, collector
-        collector << "DATE_SUB("
+        collector << 'DATE_SUB('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.right, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -358,7 +384,7 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        collector << " AS "
+        collector << ' AS '
         collector = visit o.right, collector
         collector
       end
@@ -366,7 +392,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_Regexp) rescue nil # if Arel::Visitors::ToSql.method_defined?(:visit_Arel_Nodes_Regexp)
       def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
-        collector << " REGEXP "
+        collector << ' REGEXP '
         collector = visit o.right, collector
         collector
       end
@@ -374,7 +400,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_NotRegexp) rescue nil # if Arel::Visitors::ToSql.method_defined?(:visit_Arel_Nodes_NotRegexp)
       def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
-        collector << " NOT REGEXP "
+        collector << ' NOT REGEXP '
         collector = visit o.right, collector
         collector
       end
@@ -399,35 +425,35 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_IsNull o, collector
-        collector << "ISNULL("
+        collector << 'ISNULL('
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_IsNotNull o, collector
-          collector << "NOT ISNULL("
-          collector = visit o.expr, collector
-          collector << ")"
-          collector
+        collector << 'NOT ISNULL('
+        collector = visit o.expr, collector
+        collector << ')'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Then o, collector
-        collector << "CASE WHEN ("
+        collector << 'CASE WHEN ('
         collector = visit o.left, collector
-        collector << ") THEN "
+        collector << ') THEN '
         collector = visit o.right, collector
         if o.expressions[2]
-          collector << " ELSE "
+          collector << ' ELSE '
           collector = visit o.expressions[2], collector
         end
-        collector << " END"
+        collector << ' END'
         collector
       end
 
       # Date operations
       def visit_ArelExtensions_Nodes_DateAdd o, collector
-        collector << "DATE_ADD("
+        collector << 'DATE_ADD('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.sqlite_value(o.right), collector
@@ -451,7 +477,7 @@ module ArelExtensions
               end
               collector << COMMA unless i == len
             }
-            collector << (idx == row_nb-1 ? ')' : '), ')
+            collector << (idx == row_nb - 1 ? ')' : '), ')
           end
           collector
         end
@@ -473,7 +499,7 @@ module ArelExtensions
               end
               collector << COMMA unless i == len
             }
-            collector << (idx == row_nb-1 ? ')' : '), ')
+            collector << (idx == row_nb - 1 ? ')' : '), ')
           end
           collector
         end
@@ -481,45 +507,45 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_Union o, collector
         collector = visit o.left, collector
-        collector << " UNION "
+        collector << ' UNION '
         collector = visit o.right, collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_UnionAll o, collector
         collector = visit o.left, collector
-        collector << " UNION ALL "
+        collector << ' UNION ALL '
         collector = visit o.right, collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_Case o, collector
-        collector << "CASE "
+        collector << 'CASE '
         if o.case
           visit o.case, collector
-          collector << " "
+          collector << ' '
         end
         o.conditions.each do |condition|
           visit condition, collector
-          collector << " "
+          collector << ' '
         end
         if o.default
           visit o.default, collector
-          collector << " "
+          collector << ' '
         end
-        collector << "END"
+        collector << 'END'
       end
 
       def visit_ArelExtensions_Nodes_Case_When o, collector
-        collector << "WHEN "
-        visit Arel::Nodes.build_quoted(o.left), collector
-        collector << " THEN "
-        visit Arel::Nodes.build_quoted(o.right), collector
+        collector << 'WHEN '
+        visit Arel.quoted(o.left), collector
+        collector << ' THEN '
+        visit Arel.quoted(o.right), collector
       end
 
       def visit_ArelExtensions_Nodes_Case_Else o, collector
-        collector << "ELSE "
-        visit Arel::Nodes.build_quoted(o.expr), collector
+        collector << 'ELSE '
+        visit Arel.quoted(o.expr), collector
       end
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
@@ -529,26 +555,26 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_LessThan) rescue nil
       def visit_Arel_Nodes_LessThan o, collector
         collector = visit o.left, collector
-        collector << " < "
+        collector << ' < '
         visit o.right, collector
       end
 
       def visit_ArelExtensions_Nodes_Std o, collector
-        collector << "STD("
+        collector << 'STD('
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Variance o, collector
-        collector << "VARIANCE("
+        collector << 'VARIANCE('
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
-        collector << "LEVENSHTEIN_DISTANCE("
+        collector << 'LEVENSHTEIN_DISTANCE('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.right, collector
@@ -586,58 +612,58 @@ module ArelExtensions
         when 1
           collector = visit o.children[0], collector
         else
-            collector << '('
-            o.children.each_with_index { |arg, i|
-              if i != 0
-                collector << ') OR ('
-              end
-              collector = visit arg, collector
-            }
-            collector << ')'
+          collector << '('
+          o.children.each_with_index { |arg, i|
+            if i != 0
+              collector << ') OR ('
+            end
+            collector = visit arg, collector
+          }
+          collector << ')'
         end
         collector
       end
 
-      def json_value(o,v)
+      def json_value(o, v)
         case o.type_of_node(v)
         when :string
-          Arel.when(v.is_null).then(Arel::Nodes.build_quoted("null")).else(make_json_string(v))
+          Arel.when(v.is_null).then(make_json_null).else(make_json_string(v))
         when :date
           s = v.format('%Y-%m-%d')
-          Arel.when(s.is_null).then(Arel::Nodes.build_quoted("null")).else(Arel::Nodes.build_quoted('"') + s + '"')
+          Arel.when(s.is_null).then(make_json_null).else(make_json_string(s))
         when :datetime
           s = v.format('%Y-%m-%dT%H:%M:%S')
-          Arel.when(s.is_null).then(Arel::Nodes.build_quoted("null")).else(Arel::Nodes.build_quoted('"') + s + '"')
+          Arel.when(s.is_null).then(make_json_null).else(make_json_string(s))
         when :time
           s = v.format('%H:%M:%S')
-          Arel.when(s.is_null).then(Arel::Nodes.build_quoted("null")).else(Arel::Nodes.build_quoted('"') + s + '"')
+          Arel.when(s.is_null).then(make_json_null).else(make_json_string(s))
         when :nil
-          Arel::Nodes.build_quoted("null")
+          make_json_null
         else
-          ArelExtensions::Nodes::Cast.new([v, :string]).coalesce("null")
+          ArelExtensions::Nodes::Cast.new([v, :string]).coalesce(make_json_null)
         end
       end
 
-      def visit_ArelExtensions_Nodes_Json o,collector
+      def visit_ArelExtensions_Nodes_Json o, collector
         case o.dict
         when Array
-          res = Arel::Nodes.build_quoted('[')
-          o.dict.each.with_index do |v,i|
+          res = Arel.quoted('[')
+          o.dict.each.with_index do |v, i|
             if i != 0
               res += ', '
             end
-            res += json_value(o,v)
+            res += json_value(o, v)
           end
           res += ']'
           collector = visit res, collector
         when Hash
-          res = Arel::Nodes.build_quoted('{')
-          o.dict.each.with_index do |(k,v),i|
+          res = Arel.quoted('{')
+          o.dict.each.with_index do |(k, v), i|
             if i != 0
               res += ', '
             end
-            res += make_json_string(ArelExtensions::Nodes::Cast.new([k, :string]).coalesce("")) + ': '
-            res += json_value(o,v)
+            res += make_json_string(ArelExtensions::Nodes::Cast.new([k, :string])) + ': '
+            res += json_value(o, v)
           end
           res += '}'
           collector = visit res, collector
@@ -649,17 +675,20 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_JsonGroup o, collector
         if o.as_array
-          res = Arel::Nodes.build_quoted('[') + (o.orders ? o.dict.group_concat(', ', order: Array(o.orders)) : o.dict.group_concat(', ')).coalesce('') + ']'
+          res =
+            Arel.quoted('[') \
+            + (o.orders ? o.dict.group_concat(', ', order: Array(o.orders)) : o.dict.group_concat(', ')).coalesce('') \
+            + ']'
           collector = visit res, collector
         else
-          res = Arel::Nodes.build_quoted('{')
+          res = Arel.quoted('{')
           orders = o.orders || o.dict.keys
-          o.dict.each.with_index do |(k,v),i|
+          o.dict.each.with_index do |(k, v), i|
             if i != 0
               res = res + ', '
             end
-            kv = make_json_string(ArelExtensions::Nodes::Cast.new([k, :string]).coalesce("")) + ': '
-            kv += json_value(o,v)
+            kv = make_json_string(ArelExtensions::Nodes::Cast.new([k, :string])) + ': '
+            kv += json_value(o, v)
             res = res + kv.group_concat(', ', order: Array(orders)).coalesce('')
           end
           res = res + '}'