arel_extensions 1.2.3 → 1.2.14

data/lib/arel_extensions/visitors/oracle.rb

@@ -1,7 +1,7 @@
 #require 'oracle_visitor'
 module ArelExtensions
   module Visitors
-    Arel::Visitors::Oracle.class_eval do
+    class Arel::Visitors::Oracle
 
       SPECIAL_CHARS = {"\t" => 'CHR(9)', "\n" => 'CHR(10)', "\r" => 'CHR(13)'}
       Arel::Visitors::Oracle::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
@@ -131,14 +131,15 @@ module ArelExtensions
         collector << "(LISTAGG("
         collector = visit o.left, collector
         collector << Arel::Visitors::Oracle::COMMA
-        if o.right  && o.right != 'NULL'
-          collector = visit o.right, collector
-        else
-          collector = visit Arel::Nodes.build_quoted(','), collector
-        end
+        collector =
+          if o.separator && o.separator != 'NULL'
+            visit o.separator, collector
+          else
+            visit Arel::Nodes.build_quoted(','), collector
+          end
         collector << ") WITHIN GROUP (ORDER BY "
-        if !o.orders.blank?
-          o.orders.each_with_index do |order,i|
+        if !o.order.blank?
+          o.order.each_with_index do |order,i|
             collector << Arel::Visitors::Oracle::COMMA unless i == 0
             collector = visit order, collector
           end
@@ -154,7 +155,7 @@ module ArelExtensions
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::Oracle::COMMA unless i == 0
           if i > 0 && o.left_node_type == :text
-            if arg == ''  || (arg.is_a?(Arel::Nodes::Quoted) && (arg.expr == ''))
+            if arg == '' || (arg.is_a?(Arel::Nodes::Quoted) && (arg.expr == ''))
               collector << "NULL"
             else
               collector << 'TO_CLOB('
@@ -466,14 +467,12 @@ module ArelExtensions
           o.left.each_with_index do |row, idx| # values
           collector << " UNION ALL " if idx != 0
             collector << "(SELECT "
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.each_with_index { |value, i|
+            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
-                  attr = v.columns[i]
                   collector << quote(value, attr && column_for(attr)).to_s
                 end
                 collector << Arel::Visitors::Oracle::COMMA unless i == len
@@ -489,12 +488,13 @@ module ArelExtensions
           o.left.each_with_index do |row, idx|
             collector << " UNION ALL " if idx != 0
             collector << "(SELECT "
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            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

data/lib/arel_extensions/visitors/oracle12.rb

@@ -68,7 +68,7 @@ module ArelExtensions
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
-            collector  = visit v, collector
+            collector = visit v, collector
           end
           collector << ')'
         when Hash

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::PostgreSQL.class_eval do
+    class Arel::Visitors::PostgreSQL
       Arel::Visitors::PostgreSQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
       Arel::Visitors::PostgreSQL::DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'IYYY', '%C' => 'CC', '%y' => 'YY', '%m' => 'MM', '%B' => 'Month', '%^B' => 'MONTH', '%b' => 'Mon', '%^b' => 'MON',
@@ -83,23 +83,49 @@ module ArelExtensions
         collector
       end
 
+      def visit_Aggregate_For_AggregateFunction o, collector
+        if !o.order.blank? || !o.group.blank?
+          collector << " OVER ("
+          if !o.group.blank?
+            collector << " PARTITION BY "
+            o.group.each_with_index do |group, i|
+              collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              visit group, collector
+            end
+          end
+          if !o.order.blank?
+            collector << " ORDER BY "
+            o.order.each_with_index do |order, i|
+              collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              visit order, collector
+            end
+          end
+          collector << ")"
+        end
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "array_to_string(array_agg("
         collector = visit o.left, collector
-        if !o.orders.blank?
-          collector << ' ORDER BY '
-          o.orders.each_with_index do |order,i|
+        if o.order && !o.order.blank?
+          collector << " ORDER BY"
+          o.order.each_with_index do |order, i|
             collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
-            collector = visit order, collector
+            collector << " "
+            visit order, collector
           end
         end
         collector << ")"
+        o.order = nil
+        visit_Aggregate_For_AggregateFunction o, collector
         collector << Arel::Visitors::PostgreSQL::COMMA
-        if o.right  && o.right != 'NULL'
-          collector = visit o.right, collector
-        else
-          collector = visit Arel::Nodes.build_quoted(','), collector
-        end
+        collector =
+          if o.separator && o.separator != 'NULL'
+            visit o.separator, collector
+          else
+            visit Arel::Nodes.build_quoted(','), collector
+          end
         collector << ")"
         collector
       end
@@ -277,6 +303,22 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        collector << "REGEXP_REPLACE("
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        tab = o.pattern.inspect+ 'g' # Make it always global
+        pattern = tab.split('/')[1..-2].join('/') 
+        flags = tab.split('/')[-1]
+        visit Arel::Nodes.build_quoted(pattern), collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit Arel::Nodes.build_quoted(flags+"g"), collector
+        collector << ")"
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_IsNull o, collector
         collector = visit o.expr, collector
         collector << ' IS NULL'
@@ -293,6 +335,7 @@ module ArelExtensions
         collector << "sum("
         collector = visit o.expr, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -345,27 +388,28 @@ module ArelExtensions
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
 
-        if o.scientific_notation
-          number = ArelExtensions::Nodes::Concat.new([
-                  Arel::Nodes::NamedFunction.new('TRIM',[
-                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                      col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor),
-                      Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
-                    ])]),
-                  o.type,
-                  Arel::Nodes::NamedFunction.new('TRIM',[
-                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                      col.abs.log10.floor,
-                      Arel::Nodes.build_quoted('FM'+nines_before)
-                    ])])
-                ])
-        else
-          number = Arel::Nodes::NamedFunction.new('TRIM',[
-                Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                  Arel::Nodes.build_quoted(col.abs),
-                  Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
-                ])])
-        end
+        number =
+          if o.scientific_notation
+            ArelExtensions::Nodes::Concat.new([
+                Arel::Nodes::NamedFunction.new('TRIM',[
+                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                    col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor),
+                    Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+                  ])]),
+                o.type,
+                Arel::Nodes::NamedFunction.new('TRIM',[
+                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                    col.abs.log10.floor,
+                    Arel::Nodes.build_quoted('FM'+nines_before)
+                  ])])
+              ])
+          else
+            Arel::Nodes::NamedFunction.new('TRIM',[
+              Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                Arel::Nodes.build_quoted(col.abs),
+                Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+              ])])
+          end
 
         repeated_char = (o.width == 0) ? Arel::Nodes.build_quoted('') : ArelExtensions::Nodes::Case.new().
           when(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length)>0).
@@ -420,6 +464,7 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
         visit o.left, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -427,6 +472,7 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
         visit o.left, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -438,7 +484,7 @@ module ArelExtensions
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
-            collector  = visit v, collector
+            collector = visit v, collector
           end
           collector << '])'
         when Hash

data/lib/arel_extensions/visitors/sqlite.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::SQLite.class_eval do
+    class Arel::Visitors::SQLite
       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
@@ -193,18 +193,28 @@ module ArelExtensions
         collector
       end
 
-      # 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)
+      # 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
+      # )
       def visit_ArelExtensions_Nodes_Floor o, collector
-        collector << "CASE WHEN ROUND("
+        collector << "CAST(CASE WHEN "
         collector = visit o.left, collector
-        collector << ", 1) > ROUND("
+        collector << " >= 0 THEN CAST("
         collector = visit o.left, collector
-        collector << ") THEN ROUND("
+        collector << " AS INT) WHEN CAST("
+        collector = visit o.left, collector
+        collector << " AS INT) = "
+        collector = visit o.left, collector
+        collector << " THEN CAST("
         collector = visit o.left, collector
-        collector << ") ELSE ROUND("
+        collector << " AS INT) ELSE CAST(("
         collector = visit o.left, collector
-        collector << ") - 1 END"
+        collector << " - 1.0) AS INT) END AS FLOAT)"
         collector
       end
 
@@ -225,9 +235,8 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            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
@@ -248,12 +257,17 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            v = Arel::Nodes::Values.new(row, o.cols)
-            len = v.expressions.length - 1
-            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+            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
@@ -270,32 +284,36 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Union o, collector
-        if o.left.is_a?(Arel::SelectManager)
-          collector = visit o.left.ast, collector
-        else
-          collector = visit o.left, collector
-        end
+        collector =
+          if o.left.is_a?(Arel::SelectManager)
+            visit o.left.ast, collector
+          else
+            visit o.left, collector
+          end
         collector << " UNION "
-        if o.right.is_a?(Arel::SelectManager)
-          collector = visit o.right.ast, collector
-        else
-          collector = visit o.right, collector
-        end
+        collector =
+          if o.right.is_a?(Arel::SelectManager)
+            visit o.right.ast, collector
+          else
+            visit o.right, collector
+          end
         collector
       end
 
       def visit_ArelExtensions_Nodes_UnionAll o, collector
-        if o.left.is_a?(Arel::SelectManager)
-          collector = visit o.left.ast, collector
-        else
-          collector = visit o.left, collector
-        end
+        collector =
+          if o.left.is_a?(Arel::SelectManager)
+            visit o.left.ast, collector
+          else
+            visit o.left, collector
+          end
         collector << " UNION ALL "
-        if o.right.is_a?(Arel::SelectManager)
-          collector = visit o.right.ast, collector
-        else
-          collector = visit o.right, collector
-        end
+        collector =
+          if o.right.is_a?(Arel::SelectManager)
+            visit o.right.ast, collector
+          else
+            visit o.right, collector
+          end
         collector
       end
 
@@ -346,16 +364,6 @@ module ArelExtensions
         collector
       end
 
-
-      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)

data/lib/arel_extensions/visitors/to_sql.rb

@@ -1,6 +1,7 @@
 module ArelExtensions
   module Visitors
-  Arel::Visitors::ToSql.class_eval do
+    class Arel::Visitors::ToSql
+      Arel::Visitors::ToSql::COMMA = ', ' unless defined?(Arel::Visitors::ToSql::COMMA)
 
       # Math Functions
       def visit_ArelExtensions_Nodes_Abs o, collector
@@ -52,14 +53,14 @@ module ArelExtensions
         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|
@@ -70,6 +71,13 @@ module ArelExtensions
         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("
@@ -84,9 +92,9 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "GROUP_CONCAT("
         collector = visit o.left, collector
-        if o.right && o.right != 'NULL'
+        if o.separator && o.separator != 'NULL'
           collector << Arel::Visitors::ToSql::COMMA
-          collector = visit o.right, collector
+          collector = visit o.separator, collector
         end
         collector << ")"
         collector
@@ -127,14 +135,26 @@ module ArelExtensions
 
       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
-        }
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.pattern, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
         collector << ")"
         collector
       end
-  
+
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        collector << "REGEXP_REPLACE("
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit Arel::Nodes.build_quoted(o.pattern.to_s), collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
+        collector << ")"
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
@@ -269,12 +289,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 :binary
+          as_attr = Arel::Nodes::SqlLiteral.new('binary')
         else
           as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
         end
@@ -305,7 +325,7 @@ module ArelExtensions
         collector << ")"
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_DateSub o, collector
         collector << "DATE_SUB("
         collector = visit o.left, collector
@@ -384,7 +404,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
@@ -408,16 +428,15 @@ module ArelExtensions
           row_nb = o.left.length
           o.left.each_with_index do |row, idx|
             collector << '('
-            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
+            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 << Arel::Visitors::ToSql::COMMA unless i == len
             }
             collector << (idx == row_nb-1 ? ')' : '), ')
           end
@@ -429,16 +448,17 @@ module ArelExtensions
           row_nb = o.left.length
           o.left.each_with_index do |row, idx|
             collector << '('
-            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 << (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
+            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 << Arel::Visitors::ToSql::COMMA unless i == len
             }
             collector << (idx == row_nb-1 ? ')' : '), ')
           end
@@ -452,7 +472,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 "
@@ -489,25 +509,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 << ")"
@@ -523,11 +543,13 @@ module ArelExtensions
         collector
       end
 
+      # Boolean logic.
+
       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
@@ -543,10 +565,11 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Or o, collector
+      alias_method :old_visit_Arel_Nodes_Or, :visit_Arel_Nodes_Or
+      def visit_Arel_Nodes_Or o, collector
         case o.children.length
         when 0
-          collector << '0=1' # but this should not happen
+          collector << '1 = 0' # but this should not happen
         when 1
           collector = visit o.children[0], collector
         else
@@ -562,16 +585,6 @@ module ArelExtensions
         collector
       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
         case o.dict
         when Array
@@ -611,7 +624,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(', ',o.orders) : o.dict.group_concat(', ')) + ']'
+          res = Arel::Nodes.build_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('{')
@@ -626,7 +639,7 @@ module ArelExtensions
             else
               kv += v
             end
-            res = res + kv.group_concat(', ',orders)
+            res = res + kv.group_concat(', ', order: Array(orders)).coalesce('')
           end
           res = res + '}'
           collector = visit res, collector