arel_extensions 1.2.25 → 2.0.0.rc3

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,29 +1,20 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::PostgreSQL
-      DATE_MAPPING = {
-        'd' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW',
-        'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'
-      }.freeze
-
-      DATE_FORMAT_DIRECTIVES = {
-        '%Y' => 'YYYY', '%C' => 'CC', '%y' => 'YY',
-        '%m' => 'MM', '%B' => 'Month', '%^B' => 'MONTH', '%b' => 'Mon', '%^b' => 'MON',
+    Arel::Visitors::PostgreSQL.class_eval do
+      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',
         '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%A' => 'Day', # day, weekday
         '%H' => 'HH24', '%k' => '', '%I' => 'HH', '%l' => '', '%P' => 'am', '%p' => 'AM', # hours
-        '%M' => 'MI', '%S' => 'SS', '%L' => 'MS', '%N' => 'US', '%z' => 'tz', # seconds, subseconds
-        '%%' => '%',
-      }.freeze
-
-      NUMBER_COMMA_MAPPING = {
-        'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '
-      }.freeze
+        '%M' => 'MI', '%S' => 'SS', '%L' => 'MS', '%N' => 'US', '%z' => 'tz' # seconds, subseconds
+      }
+      Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
 
       def visit_ArelExtensions_Nodes_Rand o, collector
         collector << "RANDOM("
-        if (o.left != nil && o.right != nil)
+        if(o.left != nil && o.right != nil)
           collector = visit o.left, collector
-          collector << COMMA
+          collector << Arel::Visitors::PostgreSQL::COMMA
           collector = isit o.right, collector
         end
         collector << ")"
@@ -33,7 +24,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Power o, collector
         collector << "POWER("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -43,7 +34,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Log10 o, collector
         collector << "LOG("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -77,7 +68,7 @@ module ArelExtensions
         collector
       end
 
-      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
+      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 << '('
@@ -92,49 +83,23 @@ 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 << COMMA if i != 0
-              visit group, collector
-            end
-          end
-          if !o.order.blank?
-            collector << " ORDER BY "
-            o.order.each_with_index do |order, i|
-              collector << COMMA if 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.order && !o.order.blank?
-          collector << " ORDER BY"
-          o.order.each_with_index do |order, i|
-            collector << COMMA if i != 0
-            collector << " "
-            visit order, collector
+        if !o.orders.blank?
+          collector << ' ORDER BY '
+          o.orders.each_with_index do |order,i|
+            collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+            collector = visit order, collector
           end
         end
         collector << ")"
-        o.order = nil
-        visit_Aggregate_For_AggregateFunction o, collector
-        collector << COMMA
-        collector =
-          if o.separator && o.separator != 'NULL'
-            visit o.separator, collector
-          else
-            visit Arel::Nodes.build_quoted(','), collector
-          end
+        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 << ")"
         collector
       end
@@ -167,11 +132,14 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Format o, collector
-        fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
         collector << "TO_CHAR("
         collector = visit o.left, collector
-        collector << COMMA
-        collector = visit Arel::Nodes.build_quoted(fmt), collector
+        collector << Arel::Visitors::PostgreSQL::COMMA
+
+        f = o.iso_format.dup
+        Arel::Visitors::PostgreSQL::DATE_FORMAT_DIRECTIVES.each { |d, r| f.gsub!(d, r) }
+        collector = visit Arel::Nodes.build_quoted(f), collector
+
         collector << ")"
         collector
       end
@@ -179,7 +147,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -237,7 +205,7 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector = visit o.left, collector
-        collector << ' + ' # (o.right.value >= 0 ? ' + ' : ' - ')
+        collector << ' + ' #(o.right.value >= 0 ? ' + ' : ' - ')
         collector = visit o.postgresql_value(o.right), collector
         collector
       end
@@ -251,7 +219,7 @@ module ArelExtensions
                       end
           collector = visit o.right, collector
           collector << (o.right_node_type == :date ? '::date' : '::timestamp')
-          collector << COMMA
+          collector << Arel::Visitors::PostgreSQL::COMMA
           collector = visit o.left, collector
           collector << (o.left_node_type == :date ? '::date' : '::timestamp')
           collector << ")"
@@ -279,11 +247,11 @@ module ArelExtensions
               collector << "("
               collector = visit o.right, collector
               collector << ")"
-              collector << " * (INTERVAL '1' #{DATE_MAPPING[o.left[0..-2]]})"
+              collector << " * (INTERVAL '1' #{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left[0..-2]]})"
               return collector
             end
         end
-        collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
+        collector << "EXTRACT(#{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left]} FROM "
         collector = visit o.right, collector
         collector << ")"
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
@@ -302,29 +270,13 @@ 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::PostgreSQL::COMMA unless i == 0
           collector = visit arg, collector
         }
         collector << ")"
         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'
@@ -341,7 +293,6 @@ module ArelExtensions
         collector << "sum("
         collector = visit o.expr, collector
         collector << ")"
-        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -356,8 +307,6 @@ module ArelExtensions
         as_attr = case o.as_attr
         when :string
           Arel::Nodes::SqlLiteral.new('varchar')
-        when :text, :ntext
-          Arel::Nodes::SqlLiteral.new('text')
         when :time
           Arel::Nodes::SqlLiteral.new('time')
         when :int
@@ -386,8 +335,8 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        comma = o.precision == 0 ? '' : (NUMBER_COMMA_MAPPING[o.locale][0] || '.')
-        thousand_separator = NUMBER_COMMA_MAPPING[o.locale][1] || (NUMBER_COMMA_MAPPING[o.locale] ? '' : 'G')
+        comma = o.precision == 0 ? '' : (Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale][0] || '.')
+        thousand_separator = Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale][1] || (Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale] ? '' : 'G')
         nines_after = (1..o.precision).map{'9'}.join('')
         nines_before = ("999#{thousand_separator}"*4+"990")
 
@@ -396,28 +345,27 @@ module ArelExtensions
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
 
-        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
+        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
 
         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).
@@ -441,7 +389,7 @@ module ArelExtensions
       end
 
 
-      alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
+      alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
       def visit_Arel_Nodes_SelectStatement o, collector
 
         if !(collector.value.blank? || (collector.value.is_a?(Array) && collector.value[0].blank?)) && o.limit.blank? && o.offset.blank?
@@ -451,7 +399,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_SelectStatement(o,collector)
       end
 
-      alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
+      alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias
       def visit_Arel_Nodes_TableAlias o, collector
         if o.name.length > 63
           o = Arel::Table.new(o.table_name).alias(Arel.shorten(o.name))
@@ -459,7 +407,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_TableAlias(o,collector)
       end
 
-      alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
+      alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
         if join_name.length > 63
@@ -472,7 +420,6 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
         visit o.left, collector
         collector << ")"
-        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -480,7 +427,6 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
         visit o.left, collector
         collector << ")"
-        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -492,7 +438,7 @@ module ArelExtensions
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
-            collector = visit v, collector
+            collector  = visit v, collector
           end
           collector << '])'
         when Hash
@@ -577,6 +523,7 @@ module ArelExtensions
         end
         collector
       end
+
     end
   end
 end

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