arel_extensions 1.2.23 → 2.0.0.rc3

data/lib/arel_extensions/visitors/sqlite.rb

@@ -1,23 +1,16 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::SQLite
-      DATE_MAPPING = {
-        'd' => '%d', 'm' => '%m', 'w' => '%W', 'y' => '%Y', 'wd' => '%w', 'M' => '%M',
-        'h' => '%H', 'mn' => '%M', 's' => '%S'
-      }.freeze
-
-      DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
+    Arel::Visitors::SQLite.class_eval do
+      Arel::Visitors::SQLite::DATE_MAPPING = {'d' => '%d', 'm' => '%m', 'w' => '%W', 'y' => '%Y', 'wd' => '%w', 'M' => '%M', 'h' => '%H', 'mn' => '%M', 's' => '%S'}
+      Arel::Visitors::SQLite::DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
         '%Y' => '%Y', '%C' =>   '', '%y' => '%y', '%m' => '%m', '%B' => '%M', '%b' => '%b', '%^b' => '%b', # year, month
         '%d' => '%d', '%e' => '%e', '%j' => '%j', '%w' => '%w', '%A' => '%W', # day, weekday
         '%H' => '%H', '%k' => '%k', '%I' => '%I', '%l' => '%l', '%P' => '%p', '%p' => '%p', # hours
         '%M' => '%M', '%S' => '%S', '%L' =>   '', '%N' => '%f', '%z' => '' # seconds, subseconds
-      }.freeze
-
-      NUMBER_COMMA_MAPPING = {
-        'fr_FR' => {',' => ' ', '.' =>','}
-      }.freeze
+      }
+      Arel::Visitors::SQLite::NUMBER_COMMA_MAPPING = { 'fr_FR' => {',' => ' ','.' =>','} }
 
-      # String functions
+      #String functions
       def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
         collector = visit o.left.ci_collate, collector
         collector << ' LIKE '
@@ -80,6 +73,7 @@ module ArelExtensions
         collector
       end
 
+
       def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
         collector = visit o.left.lower, collector
         collector << ' NOT LIKE '
@@ -96,15 +90,14 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector << "date("
         collector = visit o.expressions.first, collector
-        collector << COMMA
+        collector << Arel::Visitors::SQLite::COMMA
         collector = visit o.sqlite_value, collector
         collector << ")"
         collector
       end
 
       def visit_ArelExtensions_Nodes_DateDiff o, collector
-        case o.left_node_type
-        when :ruby_time, :datetime, :time
+        if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
           collector << "strftime('%s', "
           collector = visit o.left, collector
           collector << ") - strftime('%s', "
@@ -120,16 +113,17 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Duration o, collector
-        collector << "strftime('#{DATE_MAPPING[o.left]}'#{COMMA}"
+        collector << "strftime('#{Arel::Visitors::SQLite::DATE_MAPPING[o.left]}'#{Arel::Visitors::SQLite::COMMA}"
         collector = visit o.right, collector
         collector << ")"
         collector
       end
 
+
       def visit_ArelExtensions_Nodes_Locate o, collector
         collector << "instr("
         collector = visit o.expr, collector
-        collector << COMMA
+        collector << Arel::Visitors::SQLite::COMMA
         collector = visit o.right, collector
         collector << ")"
         collector
@@ -148,7 +142,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Substring o, collector
         collector << "SUBSTR("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::SQLite::COMMA unless i == 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -171,7 +165,7 @@ module ArelExtensions
         collector << "RANDOM("
         if o.left != nil && o.right != nil
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::SQLite::COMMA
           collector = visit o.right, collector
         end
         collector << ")"
@@ -199,28 +193,18 @@ module ArelExtensions
         collector
       end
 
-      # CAST(
-      #   CASE
-      #     WHEN 3.42 >= 0 THEN CAST(3.42 AS INT)
-      #     WHEN CAST(3.42 AS INT) = 3.42 THEN CAST(3.42 AS INT)
-      #     ELSE CAST((3.42 - 1.0) AS INT)
-      #   END
-      #   AS FLOAT
-      # )
+      # CASE WHEN ROUND(3.42,1) > round(3.42) THEN round(3.42) ELSE round(3.42)-1 END
+      # OR CAST(3.14 AS INTEGER)
       def visit_ArelExtensions_Nodes_Floor o, collector
-        collector << "CAST(CASE WHEN "
-        collector = visit o.left, collector
-        collector << " >= 0 THEN CAST("
-        collector = visit o.left, collector
-        collector << " AS INT) WHEN CAST("
+        collector << "CASE WHEN ROUND("
         collector = visit o.left, collector
-        collector << " AS INT) = "
+        collector << ", 1) > ROUND("
         collector = visit o.left, collector
-        collector << " THEN CAST("
+        collector << ") THEN ROUND("
         collector = visit o.left, collector
-        collector << " AS INT) ELSE CAST(("
+        collector << ") ELSE ROUND("
         collector = visit o.left, collector
-        collector << " - 1.0) AS INT) END AS FLOAT)"
+        collector << ") - 1 END"
         collector
       end
 
@@ -241,8 +225,9 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            len = row.length - 1
-            row.zip(o.cols).each_with_index { |(value, attr), i|
+            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.as(attr.name), collector
@@ -253,7 +238,7 @@ module ArelExtensions
                     collector << quote(attr.name)
                   end
                 end
-                collector << COMMA unless i == len
+                collector << Arel::Visitors::SQLite::COMMA unless i == len
             }
             collector << ' UNION ALL ' unless idx == o.left.length - 1
           end
@@ -264,24 +249,19 @@ module ArelExtensions
           o.left.each_with_index do |row, idx|
             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.as(attr.name), collector
-                when Integer
-                  collector <<  value.to_s
-                  if idx == 0
-                    collector << " AS "
-                    collector << quote(attr.name)
-                  end
-                else
-                  collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
-                  if idx == 0
-                    collector << " AS "
-                    collector << quote(attr.name)
-                  end
+            row.each_with_index { |value, i|
+              attr = o.cols[i]
+              case value
+              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                collector = visit value.as(attr.name), collector
+              else
+                collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
+                if idx == 0
+                  collector << " AS "
+                  collector << quote(attr.name)
                 end
-                collector << COMMA unless i == len
+              end
+              collector << Arel::Visitors::SQLite::COMMA unless i == len
             }
             collector << ' UNION ALL ' unless idx == o.left.length - 1
           end
@@ -290,36 +270,32 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Union o, collector
-        collector =
-          if o.left.is_a?(Arel::SelectManager)
-            visit o.left.ast, collector
-          else
-            visit o.left, collector
-          end
+        if o.left.is_a?(Arel::SelectManager)
+          collector = visit o.left.ast, collector
+        else
+          collector = visit o.left, collector
+        end
         collector << " UNION "
-        collector =
-          if o.right.is_a?(Arel::SelectManager)
-            visit o.right.ast, collector
-          else
-            visit o.right, collector
-          end
+        if o.right.is_a?(Arel::SelectManager)
+          collector = visit o.right.ast, collector
+        else
+          collector = visit o.right, collector
+        end
         collector
       end
 
       def visit_ArelExtensions_Nodes_UnionAll o, collector
-        collector =
-          if o.left.is_a?(Arel::SelectManager)
-            visit o.left.ast, collector
-          else
-            visit o.left, collector
-          end
+        if o.left.is_a?(Arel::SelectManager)
+          collector = visit o.left.ast, collector
+        else
+          collector = visit o.left, collector
+        end
         collector << " UNION ALL "
-        collector =
-          if o.right.is_a?(Arel::SelectManager)
-            visit o.right.ast, collector
-          else
-            visit o.right, collector
-          end
+        if o.right.is_a?(Arel::SelectManager)
+          collector = visit o.right.ast, collector
+        else
+          collector = visit o.right, collector
+        end
         collector
       end
 
@@ -370,7 +346,17 @@ module ArelExtensions
         collector
       end
 
-      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
+
+      alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+      def visit_Arel_Nodes_SelectStatement o, collector
+        if !collector.value.blank? && o.limit.blank?
+          o = o.dup
+          o.orders = []
+        end
+        old_visit_Arel_Nodes_SelectStatement(o,collector)
+      end
+
+      alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
       def visit_Arel_Nodes_As o, collector
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
@@ -387,13 +373,14 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         format = Arel::Nodes::NamedFunction.new('printf',[Arel::Nodes.build_quoted(o.original_string),o.left])
-        locale_map = NUMBER_COMMA_MAPPING[o.locale]
+        locale_map = Arel::Visitors::SQLite::NUMBER_COMMA_MAPPING[o.locale]
         if locale_map
           format = format.replace(',',locale_map[',']).replace('.',locale_map['.'])
         end
         visit format, collector
         collector
       end
+
     end
   end
 end

data/lib/arel_extensions/visitors/to_sql.rb

@@ -1,22 +1,13 @@
 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::Nodes.build_quoted('"') \
-        + expr
-            .replace('\\','\\\\').replace('"','\"').replace("\n", '\n') \
-        + '"'
-      end
+  Arel::Visitors::ToSql.class_eval do
+      Arel::Visitors::ToSql::COMMA = ", "
 
       # Math Functions
       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 << ")"
@@ -26,7 +17,7 @@ module ArelExtensions
       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 << ")"
@@ -36,7 +27,7 @@ module ArelExtensions
       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 << ")"
@@ -46,7 +37,7 @@ module ArelExtensions
       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 << ")"
@@ -56,43 +47,36 @@ module ArelExtensions
       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
       end
-
+  
       def visit_ArelExtensions_Nodes_Log10 o, collector
         collector << "LOG10("
         collector = visit o.left, collector
         collector << ")"
         collector
       end
-
+  
       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
-      end
-
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
         collector << "CONCAT("
-        o.expressions.each_with_index { |arg, i|
-            collector << COMMA if i != 0
-            collector = visit arg, collector
+      o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
+          collector = visit arg, collector
         }
         collector << ")"
         collector
@@ -101,9 +85,9 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "GROUP_CONCAT("
         collector = visit o.left, collector
-        if o.separator && o.separator != 'NULL'
-          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
@@ -126,7 +110,7 @@ module ArelExtensions
       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
@@ -135,7 +119,7 @@ module ArelExtensions
       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 << ")"
@@ -144,30 +128,18 @@ module ArelExtensions
 
       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
-      end
-
-      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
-        collector << "REGEXP_REPLACE("
-        visit o.left, collector
-        collector << COMMA
-        visit Arel::Nodes.build_quoted(o.pattern.to_s), collector
-        collector << COMMA
-        visit o.substitute, collector
+        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("
         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 << ")"
@@ -177,7 +149,7 @@ module ArelExtensions
       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 << ")"
@@ -187,7 +159,7 @@ module ArelExtensions
       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 << ")"
@@ -197,7 +169,7 @@ module ArelExtensions
       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 << ")"
@@ -207,7 +179,7 @@ module ArelExtensions
       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 << ")"
@@ -217,7 +189,7 @@ module ArelExtensions
       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 << ")"
@@ -227,7 +199,7 @@ module ArelExtensions
       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 << ")"
@@ -237,7 +209,7 @@ module ArelExtensions
       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 << ")"
@@ -245,20 +217,21 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Blank o, collector
-        # visit o.left.coalesce('').trim.length.eq(0), collector
+    #visit o.left.coalesce('').trim.length.eq(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
-        collector << COMMA
+        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
+    #visit o.left.coalesce('').trim.length.gt(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.expr, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit Arel::Nodes.build_quoted(''), collector
         collector << "))) > 0"
         collector
@@ -269,13 +242,13 @@ module ArelExtensions
         when :date, :datetime, :time
           collector << "STRFTIME("
           collector = visit o.right, collector
-          collector << COMMA
+          collector << Arel::Visitors::ToSql::COMMA
           collector = visit o.left, collector
           collector << ")"
         when :integer, :float, :decimal
           collector << "FORMAT("
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::ToSql::COMMA
           collector = visit o.right, collector
           collector << ")"
         else
@@ -284,7 +257,7 @@ module ArelExtensions
         collector
       end
 
-      # comparators
+      #comparators
 
       def visit_ArelExtensions_Nodes_Cast o, collector
         collector << "CAST("
@@ -297,14 +270,12 @@ module ArelExtensions
           as_attr = Arel::Nodes::SqlLiteral.new('int')
         when :decimal, :float, :number
           as_attr = Arel::Nodes::SqlLiteral.new('float')
-        when :datetime
+        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')
+        when :binary  
+          as_attr = Arel::Nodes::SqlLiteral.new('binary')  
         else
           as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
         end
@@ -316,7 +287,7 @@ module ArelExtensions
       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 << ")"
@@ -330,27 +301,24 @@ module ArelExtensions
                       'DATEDIFF('
                     end
         collector = visit o.left, collector
-        collector << COMMA
+        collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
         collector << ")"
         collector
       end
-
+  
       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
       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
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
           collector = visit o.left, collector
@@ -417,7 +385,7 @@ module ArelExtensions
         collector = visit o.left, collector
         collector << ") THEN "
         collector = visit o.right, collector
-        if o.expressions[2]
+        if o.expressions[2]  
           collector << " ELSE "
           collector = visit o.expressions[2], collector
         end
@@ -429,7 +397,7 @@ module ArelExtensions
       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
@@ -441,15 +409,16 @@ module ArelExtensions
           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 ? ')' : '), ')
           end
@@ -462,16 +431,15 @@ module ArelExtensions
           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 ? ')' : '), ')
           end
@@ -485,7 +453,7 @@ module ArelExtensions
         collector = visit o.right, collector
         collector
       end
-
+  
       def visit_ArelExtensions_Nodes_UnionAll o, collector
         collector = visit o.left, collector
         collector << " UNION ALL "
@@ -522,25 +490,25 @@ module ArelExtensions
         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
+  
+      remove_method(:visit_Arel_Nodes_LessThan) rescue nil  
       def visit_Arel_Nodes_LessThan o, collector
         collector = visit o.left, collector
         collector << " < "
         visit o.right, collector
       end
-
-      def visit_ArelExtensions_Nodes_Std o, collector
+  
+      def visit_ArelExtensions_Nodes_Std o, collector  
         collector << "STD("
         visit o.left, collector
         collector << ")"
         collector
       end
-
-      def visit_ArelExtensions_Nodes_Variance o, collector
+  
+      def visit_ArelExtensions_Nodes_Variance o, collector  
         collector << "VARIANCE("
         visit o.left, collector
         collector << ")"
@@ -550,19 +518,17 @@ module ArelExtensions
       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_method(:old_visit_Arel_Nodes_And, :visit_Arel_Nodes_And) rescue nil
+      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
@@ -578,11 +544,10 @@ module ArelExtensions
         collector
       end
 
-      alias_method(: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
@@ -598,24 +563,14 @@ module ArelExtensions
         collector
       end
 
-      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))
-        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 + '"')
-        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 + '"')
-        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 + '"')
-        when :nil
-          Arel::Nodes.build_quoted("null")
-        else
-          ArelExtensions::Nodes::Cast.new([v, :string]).coalesce("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
@@ -626,7 +581,11 @@ module ArelExtensions
             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
@@ -636,8 +595,12 @@ module ArelExtensions
             if i != 0
               res += ', '
             end
-            res += make_json_string(ArelExtensions::Nodes::Cast.new([k, :string]).coalesce("")) + ': '
-            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
@@ -649,7 +612,7 @@ 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::Nodes.build_quoted('[') + (o.orders ? o.dict.group_concat(', ',o.orders) : o.dict.group_concat(', ')) + ']'
           collector = visit res, collector
         else
           res = Arel::Nodes.build_quoted('{')
@@ -658,15 +621,20 @@ module ArelExtensions
             if i != 0
               res = res + ', '
             end
-            kv = make_json_string(ArelExtensions::Nodes::Cast.new([k, :string]).coalesce("")) + ': '
-            kv += json_value(o,v)
-            res = res + kv.group_concat(', ', order: Array(orders)).coalesce('')
+            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
+            res = res + kv.group_concat(', ',orders)
           end
           res = res + '}'
           collector = visit res, collector
         end
         collector
       end
+
     end
   end
 end