arel_extensions 1.2.15 → 1.2.23

data/lib/arel_extensions/visitors/oracle.rb

@@ -1,22 +1,21 @@
-#require 'oracle_visitor'
+# require 'oracle_visitor'
 module ArelExtensions
   module Visitors
     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'}
-      Arel::Visitors::Oracle::DATE_FORMAT_DIRECTIVES = {
+      DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
+      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
       }
-      Arel::Visitors::Oracle::NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
+      NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
 
       def visit_ArelExtensions_Nodes_Log10 o, collector
           collector << "LOG("
           o.expressions.each_with_index { |arg, i|
-            collector << Arel::Visitors::ToSql::COMMA unless i == 0
+            collector << Arel::Visitors::ToSql::COMMA if i != 0
             collector = visit arg, collector
           }
           collector << ",10)"
@@ -26,7 +25,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Power o, collector
             collector << "POWER("
             o.expressions.each_with_index { |arg, i|
-              collector << Arel::Visitors::ToSql::COMMA unless i == 0
+              collector << Arel::Visitors::ToSql::COMMA if i != 0
               collector = visit arg, collector
             }
             collector << ")"
@@ -93,7 +92,6 @@ module ArelExtensions
         end
       end
 
-
       def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
         collector << 'LOWER('
         collector = visit o.left, collector
@@ -112,25 +110,25 @@ module ArelExtensions
       if o.ai
         collector << "NLSSORT("
         collector = visit o.expressions.first, collector
-        collector << Arel::Visitors::Oracle::COMMA
+        collector << COMMA
         collector << "'NLS_SORT = BINARY_AI NLS_COMP = LINGUISTIC'"
         collector << ")"
       elsif o.ci
         collector << "NLSSORT("
         collector = visit o.expressions.first, collector
-        collector << Arel::Visitors::Oracle::COMMA
+        collector << COMMA
         collector << "'NLS_SORT = BINARY_CI NLS_COMP = LINGUISTIC'"
         collector << ")"
       else
         collector = visit o.expressions.first, collector
       end
-        collector
+      collector
       end
 
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "(LISTAGG("
         collector = visit o.left, collector
-        collector << Arel::Visitors::Oracle::COMMA
+        collector << COMMA
         collector =
           if o.separator && o.separator != 'NULL'
             visit o.separator, collector
@@ -140,7 +138,7 @@ module ArelExtensions
         collector << ") WITHIN GROUP (ORDER BY "
         if !o.order.blank?
           o.order.each_with_index do |order,i|
-            collector << Arel::Visitors::Oracle::COMMA unless i == 0
+            collector << COMMA if i != 0
             collector = visit order, collector
           end
         else
@@ -153,7 +151,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Coalesce o, collector
         collector << "COALESCE("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector << COMMA if i != 0
           if i > 0 && o.left_node_type == :text
             if arg == '' || (arg.is_a?(Arel::Nodes::Quoted) && (arg.expr == ''))
               collector << "NULL"
@@ -196,7 +194,7 @@ module ArelExtensions
             collector << 'TO_DATE(' if lc
             collector = visit o.left, collector
             collector << ')' if lc
-            collector << Arel::Visitors::Oracle::COMMA
+            collector << COMMA
             collector << "'DDD') = "
             collector << 'TO_DATE(' if lc
             collector = visit o.left, collector
@@ -222,8 +220,8 @@ module ArelExtensions
         when 'wd', 'w'
           collector << "TO_CHAR("
           collector = visit o.right, collector
-          collector << Arel::Visitors::Oracle::COMMA
-          collector = visit Arel::Nodes.build_quoted(Arel::Visitors::Oracle::DATE_MAPPING[o.left]), collector
+          collector << COMMA
+          collector = visit Arel::Nodes.build_quoted(DATE_MAPPING[o.left]), collector
         else
           right = case o.left
           when  'd','m','y'
@@ -233,7 +231,7 @@ module ArelExtensions
             interval = 'SECOND'
             o.right.cast(:datetime)
           when /i\z/
-            interval = Arel::Visitors::Oracle::DATE_MAPPING[o.left[0..-2]]
+            interval = DATE_MAPPING[o.left[0..-2]]
             collector << '('
             collector = visit o.right, collector
             collector << ") * (INTERVAL '1' #{interval})"
@@ -242,7 +240,7 @@ module ArelExtensions
             interval = nil
             o.right
           end
-          collector << "EXTRACT(#{Arel::Visitors::Oracle::DATE_MAPPING[o.left]} FROM "
+          collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
           collector = visit right, collector
         end
         collector << ")"
@@ -257,6 +255,16 @@ module ArelExtensions
           collector = visit o.left, collector
           collector << ")"
           return collector
+        when :text
+          collector << "TO_CLOB("
+          collector = visit o.left, collector
+          collector << ")"
+          return collector
+        when :ntext
+          collector << "TO_NCLOB("
+          collector = visit o.left, collector
+          collector << ")"
+          return collector
         when :time
           if (o.left.respond_to?(:return_type) && o.left.return_type == :string) || o.left.is_a?(Arel::Nodes::Quoted)
             collector << "TO_DATE("
@@ -322,7 +330,7 @@ module ArelExtensions
         collector << "DBMS_RANDOM.VALUE("
         if o.left && o.right
           collector = visit o.left, collector
-          collector << Arel::Visitors::Oracle::COMMA
+          collector << COMMA
           collector = visit o.right, collector
         end
         collector << ")"
@@ -332,7 +340,7 @@ module ArelExtensions
       def visit_Arel_Nodes_Regexp o, collector
         collector << " REGEXP_LIKE("
         collector = visit o.left, collector
-        collector << Arel::Visitors::Oracle::COMMA
+        collector << COMMA
         collector = visit o.right, collector
         collector << ')'
         collector
@@ -341,7 +349,7 @@ module ArelExtensions
       def visit_Arel_Nodes_NotRegexp o, collector
         collector << " NOT REGEXP_LIKE("
         collector = visit o.left, collector
-        collector << Arel::Visitors::Oracle::COMMA
+        collector << COMMA
         collector = visit o.right, collector
         collector << ')'
         collector
@@ -350,7 +358,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Locate o, collector
         collector << "INSTR("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -360,7 +368,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Substring o, collector
         collector << "SUBSTR("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -379,11 +387,11 @@ module ArelExtensions
         if o.type_of_attribute(o.left) == :text
           collector << 'dbms_lob.SUBSTR('
           collector = visit o.left, collector
-          collector << Arel::Visitors::Oracle::COMMA
+          collector << COMMA
           collector << 'COALESCE(dbms_lob.GETLENGTH('
           collector = visit o.left, collector
           collector << "), 0)"
-          collector << Arel::Visitors::Oracle::COMMA
+          collector << COMMA
           collector << '1)'
         else
           collector = visit o.left, collector
@@ -430,28 +438,25 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector << '('
         collector = visit o.left, collector
-        collector << ' + '# (o.right.value >= 0 ? ' + ' : ' - ')
+        collector << ' + ' # (o.right.value >= 0 ? ' + ' : ' - ')
         collector = visit o.oracle_value(o.right), collector
         collector << ')'
         collector
       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 << Arel::Visitors::Oracle::COMMA
-
-        f = o.iso_format.gsub(/\ (\w+)/, ' "\1"')
-        Arel::Visitors::Oracle::DATE_FORMAT_DIRECTIVES.each { |d, r| f.gsub!(d, r) }
-        collector = visit Arel::Nodes.build_quoted(f), collector
-
+        collector << COMMA
+        collector = visit Arel::Nodes.build_quoted(fmt), collector
         collector << ")"
         collector
       end
 
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "LPAD("
-        collector = visit o.expressions[0], collector #can't put empty string, otherwise it wouldn't work
+        collector = visit o.expressions[0], collector # can't put empty string, otherwise it wouldn't work
         collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.expressions[1], collector
         collector << Arel::Visitors::ToSql::COMMA
@@ -460,24 +465,24 @@ module ArelExtensions
         collector
       end
 
-        # add primary_key if not present, avoid zip
+      # add primary_key if not present, avoid zip
       if Arel::VERSION.to_i < 7
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           collector << "("
           o.left.each_with_index do |row, idx| # values
           collector << " UNION ALL " if idx != 0
-            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, collector
-                else
-                  collector << quote(value, attr && column_for(attr)).to_s
-                end
-                collector << Arel::Visitors::Oracle::COMMA unless i == len
-            }
-            collector << ' FROM DUAL)'
+          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, collector
+              else
+                collector << quote(value, attr && column_for(attr)).to_s
+              end
+              collector << COMMA unless i == len
+          }
+          collector << ' FROM DUAL)'
           end
           collector << ")"
           collector
@@ -498,7 +503,7 @@ module ArelExtensions
               else
                 collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
               end
-              collector << Arel::Visitors::Oracle::COMMA unless i == len
+              collector << COMMA unless i == len
             }
             collector << ' FROM DUAL)'
           end
@@ -557,7 +562,7 @@ module ArelExtensions
       end
 
 
-      alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+      alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
       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?
           o = o.dup
@@ -566,7 +571,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_SelectStatement(o,collector)
       end
 
-      alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias
+      alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
       def visit_Arel_Nodes_TableAlias o, collector
         if o.name.length > 30
           o = Arel::Table.new(o.table_name).alias(Base64.urlsafe_encode64(Digest::MD5.new.digest(o.name)).tr('=', '').tr('-', '_'))
@@ -574,7 +579,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_TableAlias(o,collector)
       end
 
-      alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
       def visit_Arel_Nodes_As o, collector
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
@@ -594,7 +599,7 @@ module ArelExtensions
         visit_Arel_Nodes_As o, collector
       end
 
-      alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute
+      alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
         if join_name.length > 30
@@ -603,10 +608,9 @@ module ArelExtensions
         collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
 
-
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        comma = Arel::Visitors::Oracle::NUMBER_COMMA_MAPPING[o.locale] || '.,'
+        comma = NUMBER_COMMA_MAPPING[o.locale] || '.,'
         comma_in_format = o.precision == 0 ? '' : 'D'
         nines_after = (1..o.precision-1).map{'9'}.join('')+'0'
         if comma.length == 1
@@ -683,7 +687,6 @@ module ArelExtensions
         collector << ')'
         collector
       end
-
     end
   end
 end

data/lib/arel_extensions/visitors/oracle12.rb

@@ -1,19 +1,7 @@
 module ArelExtensions
   module Visitors
-
     Arel::Visitors.send(:remove_const,'Oracle12') if Arel::Visitors.const_defined?('Oracle12')
     Arel::Visitors.const_set('Oracle12',Class.new(Arel::Visitors::Oracle)).class_eval do
-      def visit_Arel_Nodes_SelectStatement(o, collector)
-        # Oracle does not allow LIMIT clause with select for update
-        if o.limit && o.lock
-          raise ArgumentError, <<-MSG
-          'Combination of limit and lock is not supported.
-          because generated SQL statements
-          `SELECT FOR UPDATE and FETCH FIRST n ROWS` generates ORA-02014.`
-          MSG
-        end
-        super
-      end
 
       def visit_Arel_Nodes_SelectOptions(o, collector)
         collector = maybe_visit o.offset, collector
@@ -84,7 +72,7 @@ module ArelExtensions
             collector << 'FORMAT JSON'
           end
           collector << ')'
-        when String,Numeric,TrueClass,FalseClass
+        when String, Numeric, TrueClass, FalseClass
           collector = visit Arel::Nodes.build_quoted("#{o.dict}"), collector
           collector << ' FORMAT JSON'
         when NilClass
@@ -97,7 +85,6 @@ module ArelExtensions
         end
         collector
       end
-
     end
   end
 end

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,20 +1,29 @@
 module ArelExtensions
   module Visitors
     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',
+      DATE_MAPPING = {
+        'd' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW',
+        'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'
+      }.freeze
+
+      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
-      }
-      Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING = { 'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', ' }
+        '%M' => 'MI', '%S' => 'SS', '%L' => 'MS', '%N' => 'US', '%z' => 'tz', # seconds, subseconds
+        '%%' => '%',
+      }.freeze
+
+      NUMBER_COMMA_MAPPING = {
+        'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '
+      }.freeze
 
       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 << Arel::Visitors::PostgreSQL::COMMA
+          collector << COMMA
           collector = isit o.right, collector
         end
         collector << ")"
@@ -24,7 +33,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Power o, collector
         collector << "POWER("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA unless i == 0
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -34,7 +43,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Log10 o, collector
         collector << "LOG("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA unless i == 0
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -68,7 +77,7 @@ module ArelExtensions
         collector
       end
 
-      alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
       def visit_Arel_Nodes_As o, collector
         if o.left.is_a?(Arel::Nodes::Binary)
           collector << '('
@@ -89,14 +98,14 @@ module ArelExtensions
           if !o.group.blank?
             collector << " PARTITION BY "
             o.group.each_with_index do |group, i|
-              collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              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 << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              collector << COMMA if i != 0
               visit order, collector
             end
           end
@@ -111,7 +120,7 @@ module ArelExtensions
         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 << COMMA if i != 0
             collector << " "
             visit order, collector
           end
@@ -119,7 +128,7 @@ module ArelExtensions
         collector << ")"
         o.order = nil
         visit_Aggregate_For_AggregateFunction o, collector
-        collector << Arel::Visitors::PostgreSQL::COMMA
+        collector << COMMA
         collector =
           if o.separator && o.separator != 'NULL'
             visit o.separator, collector
@@ -158,14 +167,11 @@ 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 << 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 << COMMA
+        collector = visit Arel::Nodes.build_quoted(fmt), collector
         collector << ")"
         collector
       end
@@ -173,7 +179,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::ToSql::COMMA unless i == 0
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -231,7 +237,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
@@ -245,7 +251,7 @@ module ArelExtensions
                       end
           collector = visit o.right, collector
           collector << (o.right_node_type == :date ? '::date' : '::timestamp')
-          collector << Arel::Visitors::PostgreSQL::COMMA
+          collector << COMMA
           collector = visit o.left, collector
           collector << (o.left_node_type == :date ? '::date' : '::timestamp')
           collector << ")"
@@ -273,11 +279,11 @@ module ArelExtensions
               collector << "("
               collector = visit o.right, collector
               collector << ")"
-              collector << " * (INTERVAL '1' #{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left[0..-2]]})"
+              collector << " * (INTERVAL '1' #{DATE_MAPPING[o.left[0..-2]]})"
               return collector
             end
         end
-        collector << "EXTRACT(#{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left]} FROM "
+        collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
         collector = visit o.right, collector
         collector << ")"
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
@@ -296,7 +302,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Substring o, collector
         collector << "SUBSTR("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+          collector << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -308,7 +314,7 @@ module ArelExtensions
         visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
         tab = o.pattern.inspect+ 'g' # Make it always global
-        pattern = tab.split('/')[1..-2].join('/') 
+        pattern = tab.split('/')[1..-2].join('/')
         flags = tab.split('/')[-1]
         visit Arel::Nodes.build_quoted(pattern), collector
         collector << Arel::Visitors::ToSql::COMMA
@@ -350,6 +356,8 @@ 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
@@ -378,8 +386,8 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        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')
+        comma = o.precision == 0 ? '' : (NUMBER_COMMA_MAPPING[o.locale][0] || '.')
+        thousand_separator = NUMBER_COMMA_MAPPING[o.locale][1] || (NUMBER_COMMA_MAPPING[o.locale] ? '' : 'G')
         nines_after = (1..o.precision).map{'9'}.join('')
         nines_before = ("999#{thousand_separator}"*4+"990")
 
@@ -433,7 +441,7 @@ module ArelExtensions
       end
 
 
-      alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+      alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
       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?
@@ -443,7 +451,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_SelectStatement(o,collector)
       end
 
-      alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias
+      alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
       def visit_Arel_Nodes_TableAlias o, collector
         if o.name.length > 63
           o = Arel::Table.new(o.table_name).alias(Arel.shorten(o.name))
@@ -451,7 +459,7 @@ module ArelExtensions
         old_visit_Arel_Nodes_TableAlias(o,collector)
       end
 
-      alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute
+      alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
         if join_name.length > 63
@@ -569,7 +577,6 @@ module ArelExtensions
         end
         collector
       end
-
     end
   end
 end