arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/visitors/to_sql.rb

@@ -1,385 +1,324 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::ToSql
-      COMMA = ', ' unless defined?(COMMA)
-
-      # Escape properly the string expression expr.
-      # Take care of escaping.
-      def make_json_string(expr)
-        Arel.quoted('"') \
-        + expr
-            .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
+  Arel::Visitors::ToSql.class_eval do
+      Arel::Visitors::ToSql::COMMA = ", "
 
       # Math Functions
-      def visit_ArelExtensions_Nodes_Abs(o, collector)
-        collector << 'ABS('
+      def visit_ArelExtensions_Nodes_Abs o, collector
+        collector << "ABS("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Ceil(o, collector)
-        collector << 'CEIL('
+      def visit_ArelExtensions_Nodes_Ceil o, collector
+        collector << "CEIL("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Floor(o, collector)
-        collector << 'FLOOR('
+      def visit_ArelExtensions_Nodes_Floor o, collector
+        collector << "FLOOR("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Rand(o, collector)
-        collector << 'RAND('
+      def visit_ArelExtensions_Nodes_Rand o, collector
+        collector << "RAND("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Round(o, collector)
-        collector << 'ROUND('
+      def visit_ArelExtensions_Nodes_Round o, collector
+        collector << "ROUND("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_Log10(o, collector)
-        collector << 'LOG10('
+  
+      def visit_ArelExtensions_Nodes_Log10 o, collector
+        collector << "LOG10("
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_Power(o, collector)
-        collector << 'POW('
+  
+      def visit_ArelExtensions_Nodes_Power o, collector
+        collector << "POW("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Sum(o, collector)
-        collector << 'SUM('
-        collector = visit o.expr, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
       # String functions
-      def visit_ArelExtensions_Nodes_Concat(o, collector)
-        collector << 'CONCAT('
-        o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+      def visit_ArelExtensions_Nodes_Concat o, collector
+        collector << "CONCAT("
+      o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
-        collector << 'GROUP_CONCAT('
+      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+        collector << "GROUP_CONCAT("
         collector = visit o.left, collector
-        sep = o.separator.is_a?(Arel::Nodes::Quoted) ? o.separator.expr : o.separator
-        if 'NULL' != sep
-          collector << COMMA
-          collector = visit o.separator, collector
+        if o.right && o.right != 'NULL'
+          collector << Arel::Visitors::ToSql::COMMA
+          collector = visit o.right, collector
         end
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_MD5(o, collector)
-        collector << 'MD5('
+      def visit_ArelExtensions_Nodes_MD5 o, collector
+        collector << "MD5("
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
       def visit_ArelExtensions_Nodes_Length o, collector
-        collector << "#{o.bytewise ? '' : 'CHAR_'}LENGTH("
+        collector << "LENGTH("
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Locate(o, collector)
-        collector << 'LOCATE('
+      def visit_ArelExtensions_Nodes_Locate o, collector
+        collector << "LOCATE("
         collector = visit o.right, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Substring(o, collector)
-        return visit(o.range_substring_node, collector) if o.range?
-
-        collector << 'SUBSTRING('
+      def visit_ArelExtensions_Nodes_Substring o, collector
+        collector << "SUBSTRING("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Replace(o, collector)
-        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('
-        visit o.left, collector
-        collector << COMMA
-        visit Arel.quoted(o.pattern.to_s), collector
-        collector << COMMA
-        visit o.substitute, collector
-        collector << ')'
+      def visit_ArelExtensions_Nodes_Replace o, collector
+        collector << "REPLACE("
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
+          collector = visit arg, collector
+        }
+        collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_Repeat(o, collector)
-        collector << 'REPEAT('
+  
+      def visit_ArelExtensions_Nodes_Repeat o, collector
+        collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FindInSet(o, collector)
-        collector << 'FIND_IN_SET('
+      def visit_ArelExtensions_Nodes_FindInSet o, collector
+        collector << "FIND_IN_SET("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Soundex(o, collector)
-        collector << 'SOUNDEX('
+      def visit_ArelExtensions_Nodes_Soundex o, collector
+        collector << "SOUNDEX("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Downcase(o, collector)
-        collector << 'LOWER('
+      def visit_ArelExtensions_Nodes_Downcase o, collector
+        collector << "LOWER("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Upcase(o, collector)
-        collector << 'UPPER('
+      def visit_ArelExtensions_Nodes_Upcase o, collector
+        collector << "UPPER("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim(o, collector)
-        collector << 'TRIM('
+      def visit_ArelExtensions_Nodes_Trim o, collector
+        collector << "TRIM("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Ltrim(o, collector)
-        collector << 'LTRIM('
+      def visit_ArelExtensions_Nodes_Ltrim o, collector
+        collector << "LTRIM("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Rtrim(o, collector)
-        collector << 'RTRIM('
+      def visit_ArelExtensions_Nodes_Rtrim o, collector
+        collector << "RTRIM("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Blank(o, collector)
-        # visit o.left.coalesce('').trim.length.eq(0), collector
+      def visit_ArelExtensions_Nodes_Blank o, collector
+    #visit o.left.coalesce('').trim.length.eq(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
-        collector << COMMA
-        collector = visit Arel.quoted(''), collector
-        collector << '))) = 0'
+        collector << Arel::Visitors::ToSql::COMMA
+        collector = visit Arel::Nodes.build_quoted(''), collector
+        collector << "))) = 0"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_NotBlank(o, collector)
-        # visit o.left.coalesce('').trim.length.gt(0), collector
+
+      def visit_ArelExtensions_Nodes_NotBlank o, collector
+    #visit o.left.coalesce('').trim.length.gt(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
-        collector << COMMA
-        collector = visit Arel.quoted(''), collector
-        collector << '))) > 0'
+        collector << Arel::Visitors::ToSql::COMMA
+        collector = visit Arel::Nodes.build_quoted(''), collector
+        collector << "))) > 0"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Format(o, collector)
+      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 << Arel::Visitors::ToSql::COMMA
           collector = visit o.left, collector
-          collector << ')'
+          collector << ")"
         when :integer, :float, :decimal
-          collector << 'FORMAT('
+          collector << "FORMAT("
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::ToSql::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
-        collector
-      end
-
-      # comparators
-
-      def visit_ArelExtensions_Nodes_Cast(o, collector)
-        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
+      #comparators
 
-        collector << 'CAST('
+      def visit_ArelExtensions_Nodes_Cast o, collector
+        collector << "CAST("
         collector = visit o.left, collector
-        collector << ' AS '
-        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), collector
-        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')  
+        else
+          as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
+        end
+        collector = visit as_attr, collector
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Coalesce(o, collector)
-        collector << 'COALESCE('
+      def visit_ArelExtensions_Nodes_Coalesce o, collector
+        collector << "COALESCE("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
-        collector <<
-          if %i[ruby_time datetime time].include?(o.left_node_type)
-            'TIMEDIFF('
-          else
-            'DATEDIFF('
-          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 = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
-        collector << ')'
+        collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_DateSub(o, collector)
-        collector << 'DATE_SUB('
+  
+      def visit_ArelExtensions_Nodes_DateSub o, collector
+        collector << "DATE_SUB("
         collector = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      # override
+        # override
       remove_method(:visit_Arel_Nodes_As) rescue nil # if Arel::Visitors::ToSql.method_defined?(:visit_Arel_Nodes_As)
-      def visit_Arel_Nodes_As(o, collector)
-        if o.left.respond_to?(:alias)
-          o.left.alias = nil
-        end
+      def visit_Arel_Nodes_As o, collector
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
           collector = visit o.left, collector
@@ -387,25 +326,28 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        collector << ' AS '
-        visit o.right, collector
+        collector << " AS "
+        collector = visit o.right, collector
+        collector
       end
 
       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)
+      def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
-        collector << ' REGEXP '
-        visit o.right, collector
+        collector << " REGEXP "
+        collector = visit o.right, collector
+        collector
       end
 
       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)
+      def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
-        collector << ' NOT REGEXP '
-        visit o.right, collector
+        collector << " NOT REGEXP "
+        collector = visit o.right, collector
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_IMatches(o, collector)
+      def visit_ArelExtensions_Nodes_IMatches o, collector
         collector = infix_value o, collector, ' ILIKE '
         if o.escape
           collector << ' ESCAPE '
@@ -415,7 +357,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_IDoesNotMatch(o, collector)
+      def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
         collector = infix_value o, collector, ' NOT ILIKE '
         if o.escape
           collector << ' ESCAPE '
@@ -424,169 +366,169 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNull(o, collector)
-        collector << 'ISNULL('
+      def visit_ArelExtensions_Nodes_IsNull o, collector
+        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
+      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+          collector << "NOT ISNULL("
+          collector = visit o.expr, collector
+          collector << ")"
+          collector
       end
 
-      def visit_ArelExtensions_Nodes_Then(o, collector)
-        collector << 'CASE WHEN ('
+      def visit_ArelExtensions_Nodes_Then o, collector
+        collector << "CASE WHEN ("
         collector = visit o.left, collector
-        collector << ') THEN '
+        collector << ") THEN "
         collector = visit o.right, collector
-        if o.expressions[2]
-          collector << ' ELSE '
+        if o.expressions[2]  
+          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('
+      def visit_ArelExtensions_Nodes_DateAdd o, collector
+        collector << "DATE_ADD("
         collector = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.sqlite_value(o.right), collector
         collector << ')'
         collector
       end
 
-      if AREL_VERSION < V7
-        def visit_ArelExtensions_InsertManager_BulkValues(o, collector)
+      if Arel::VERSION.to_i < 7
+        def visit_ArelExtensions_InsertManager_BulkValues o, collector
           collector << 'VALUES '
           row_nb = o.left.length
           o.left.each_with_index do |row, idx|
             collector << '('
-            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
-              else
-                collector << quote(value, attr && column_for(attr)).to_s
-              end
-              collector << COMMA unless i == len
+            v = Arel::Nodes::Values.new(row, o.cols)
+            len = v.expressions.length - 1
+            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+                case value
+                when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                  collector = visit value, collector
+                else
+                  collector << quote(value, attr && column_for(attr)).to_s
+                end
+                collector << Arel::Visitors::ToSql::COMMA unless i == len
             }
-            collector << (idx == row_nb - 1 ? ')' : '), ')
+            collector << (idx == row_nb-1 ? ')' : '), ')
           end
           collector
         end
       else
-        def visit_ArelExtensions_InsertManager_BulkValues(o, collector)
+        def visit_ArelExtensions_InsertManager_BulkValues o, collector
           collector << 'VALUES '
           row_nb = o.left.length
           o.left.each_with_index do |row, idx|
             collector << '('
             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
-              when Integer
-                collector << value.to_s
-              else
-                collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
-              end
-              collector << COMMA unless i == len
+            row.each_with_index { |value, i|
+              attr = o.cols[i]
+                case value
+                when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                  collector = visit value, collector
+                else
+                  collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
+                end
+                collector << Arel::Visitors::ToSql::COMMA unless i == len
             }
-            collector << (idx == row_nb - 1 ? ')' : '), ')
+            collector << (idx == row_nb-1 ? ')' : '), ')
           end
           collector
         end
       end
 
-      def visit_ArelExtensions_Nodes_Union(o, collector)
+      def visit_ArelExtensions_Nodes_Union o, collector
         collector = visit o.left, collector
-        collector << ' UNION '
-        visit o.right, collector
+        collector << " UNION "
+        collector = visit o.right, collector
+        collector
       end
-
-      def visit_ArelExtensions_Nodes_UnionAll(o, collector)
+  
+      def visit_ArelExtensions_Nodes_UnionAll o, collector
         collector = visit o.left, collector
-        collector << ' UNION ALL '
-        visit o.right, collector
+        collector << " UNION ALL "
+        collector = visit o.right, collector
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_Case(o, collector)
-        collector << 'CASE '
+      def visit_ArelExtensions_Nodes_Case o, collector
+        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.quoted(o.left), collector
-        collector << ' THEN '
-        visit Arel.quoted(o.right), collector
+      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
       end
 
-      def visit_ArelExtensions_Nodes_Case_Else(o, collector)
-        collector << 'ELSE '
-        visit Arel.quoted(o.expr), collector
+      def visit_ArelExtensions_Nodes_Case_Else o, collector
+        collector << "ELSE "
+        visit Arel::Nodes.build_quoted(o.expr), collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber(o, collector)
+      def visit_ArelExtensions_Nodes_FormattedNumber o, collector  
         visit o.left, collector
       end
-
-      remove_method(:visit_Arel_Nodes_LessThan) rescue nil
-      def visit_Arel_Nodes_LessThan(o, collector)
+  
+      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('
+  
+      def visit_ArelExtensions_Nodes_Std o, collector  
+        collector << "STD("
         visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_Variance(o, collector)
-        collector << 'VARIANCE('
+  
+      def visit_ArelExtensions_Nodes_Variance o, collector  
+        collector << "VARIANCE("
         visit o.left, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_LevenshteinDistance(o, collector)
-        collector << 'LEVENSHTEIN_DISTANCE('
+      def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
+        collector << "LEVENSHTEIN_DISTANCE("
         collector = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
         collector << ')'
         collector
       end
 
-      # Boolean logic.
-
-      alias old_visit_Arel_Nodes_And visit_Arel_Nodes_And rescue nil
-      def visit_Arel_Nodes_And(o, collector)
+      alias_method :old_visit_Arel_Nodes_And, :visit_Arel_Nodes_And
+      def visit_Arel_Nodes_And o, collector
         case o.children.length
         when 0
-          collector << '1 = 1' # but this should not happen
+          collector << '1=1' # but this should not happen
         when 1
           collector = visit o.children[0], collector
         else
@@ -602,111 +544,97 @@ module ArelExtensions
         collector
       end
 
-      alias old_visit_Arel_Nodes_Or visit_Arel_Nodes_Or rescue nil
-      def visit_Arel_Nodes_Or(o, collector)
+      def visit_ArelExtensions_Nodes_Or o, collector
         case o.children.length
         when 0
-          collector << '1 = 0' # but this should not happen
+          collector << '0=1' # but this should not happen
         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)
-        case o.type_of_node(v)
-        when :numeric
-          # A bare numeric literal (e.g. `{ col => 1 }`) is never NULL, so it is
-          # emitted as-is rather than run through `is_null`/`coalesce`.
-          Arel.quoted(v)
-        when :boolean
-          # A literal boolean is never NULL: emit the JSON token directly.
-          # A boolean column is null-checked and rendered as true/false. `eq(true)` rather than the
-          # bare column, because T-SQL (mssql) requires a proper boolean predicate in WHEN.
-          if o.boolean_literal?(v)
-            Arel.quoted((v.is_a?(Arel::Nodes::Quoted) ? v.expr : v).to_s)
-          else
-            Arel.when(v.is_null).then(make_json_null).else(Arel.when(v.eq(true)).then('true').else('false'))
-          end
-        when :string
-          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(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(make_json_null).else(make_json_string(s))
-        when :time
-          s = v.format('%H:%M:%S')
-          Arel.when(s.is_null).then(make_json_null).else(make_json_string(s))
-        when :nil
-          make_json_null
-        else
-          ArelExtensions::Nodes::Cast.new([v, :string]).coalesce(make_json_null)
-        end
+      alias_method :old_visit_Arel_Nodes_Or, :visit_Arel_Nodes_Or
+      def visit_Arel_Nodes_Or o, collector
+        collector << '('
+        collector = visit o.left, collector
+        collector << ') OR ('
+        collector = visit o.right, collector
+        collector << ')'
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_Json(o, collector)
+      def visit_ArelExtensions_Nodes_Json o,collector
         case o.dict
         when Array
-          res = Arel.quoted('[')
-          o.dict.each.with_index do |v, i|
+          res = Arel::Nodes.build_quoted('[')
+          o.dict.each.with_index do |v,i|
             if i != 0
               res += ', '
             end
-            res += json_value(o, v)
+            if (v.is_a?(Arel::Attributes::Attribute) && o.type_of_attribute(v) == :string) || (v.return_type == :string)
+              res = res + '"' + v + '"'
+            else
+              res += v
+            end
           end
           res += ']'
           collector = visit res, collector
         when Hash
-          res = Arel.quoted('{')
-          o.dict.each.with_index do |(k, v), i|
+          res = Arel::Nodes.build_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])) + ': '
-            res += json_value(o, v)
+            res += Arel::Nodes.build_quoted('"')+k + '": '
+            if (v.is_a?(Arel::Attributes::Attribute) && o.type_of_attribute(v) == :string) || (v.respond_to?(:return_type) && v.return_type == :string)
+              res = res + '"' + v + '"'
+            else
+              res += v
+            end
           end
           res += '}'
           collector = visit res, collector
         else
-          collector = visit(o.boolean_literal?(o.dict) ? Arel.quoted(o.dict.expr.to_s) : o.dict, collector)
+          collector = visit o.dict, collector
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGroup(o, collector)
+      def visit_ArelExtensions_Nodes_JsonGroup o, collector
         if o.as_array
-          res =
-            Arel.quoted('[') \
-            + (o.orders ? o.dict.group_concat(', ', order: Array(o.orders)) : o.dict.group_concat(', ')).coalesce('') \
-            + ']'
+          res = Arel::Nodes.build_quoted('[') + (o.orders ? o.dict.group_concat(', ',o.orders) : o.dict.group_concat(', ')) + ']'
           collector = visit res, collector
         else
-          res = Arel.quoted('{')
+          res = Arel::Nodes.build_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 = res + ', '
+            end
+            kv = Arel::Nodes.build_quoted('"')+k + '": '
+            if (v.is_a?(Arel::Attributes::Attribute) && o.type_of_attribute(v) == :string) || (v.respond_to?(:return_type) && v.return_type == :string)
+              kv = kv + '"' + v + '"'
+            else
+              kv += v
             end
-            kv = make_json_string(ArelExtensions::Nodes::Cast.new([k, :string])) + ': '
-            kv += json_value(o, v)
-            res += kv.group_concat(', ', order: Array(orders)).coalesce('')
+            res = res + kv.group_concat(', ',orders)
           end
-          res += '}'
+          res = res + '}'
           collector = visit res, collector
         end
         collector
       end
+
     end
   end
 end