arel_extensions 2.1.3 → 2.1.4

data/lib/arel_extensions/visitors/postgresql.rb

@@ -8,11 +8,11 @@ module ArelExtensions
 
       DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'YYYY', '%C' => 'CC', '%y' => 'YY',
-        '%m' => 'MM', '%B' => 'Month', '%^B' => 'MONTH', '%b' => 'Mon', '%^b' => 'MON',
-        '%V' => 'IW', '%G' => 'IYYY',                                                     # ISO week number and year of week
-        '%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
+        '%m' => 'MM', '%B' => 'TMMonth', '%^B' => 'TMMONTH', '%b' => 'TMMon', '%^b' => 'TMMON',
+        '%V' => 'IW', '%G' => 'IYYY',                                                              # ISO week number and year of week
+        '%d' => 'DD', '%e' => 'FMDD', '%j' => 'DDD', '%w' => '', '%a' => 'TMDy', '%A' => 'TMDay',  # 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
 
@@ -21,33 +21,33 @@ module ArelExtensions
       }.freeze
 
       def visit_ArelExtensions_Nodes_Rand o, collector
-        collector << "RANDOM("
+        collector << 'RANDOM('
         if (o.left != nil && o.right != nil)
           collector = visit o.left, collector
           collector << COMMA
           collector = isit o.right, collector
         end
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Power o, collector
-        collector << "POWER("
+        collector << 'POWER('
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Log10 o, collector
-        collector << "LOG("
+        collector << 'LOG('
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -55,7 +55,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_Regexp) rescue nil
       def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
-        collector << " ~ "
+        collector << ' ~ '
         collector = visit o.right, collector
         collector
       end
@@ -63,7 +63,7 @@ module ArelExtensions
       remove_method(:visit_Arel_Nodes_NotRegexp) rescue nil
       def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
-        collector << " !~ "
+        collector << ' !~ '
         collector = visit o.right, collector
         collector
       end
@@ -74,7 +74,7 @@ module ArelExtensions
           collector = visit arg, collector
           collector << ' || ' unless i == o.expressions.length - 1
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -87,7 +87,7 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        collector << " AS "
+        collector << ' AS '
 
         # sometimes these values are already quoted, if they are, don't double quote it
         quote = o.right.is_a?(Arel::Nodes::SqlLiteral) && o.right[0] != '"' && o.right[-1] != '"'
@@ -101,38 +101,38 @@ module ArelExtensions
 
       def visit_Aggregate_For_AggregateFunction o, collector
         if !o.order.blank? || !o.group.blank?
-          collector << " OVER ("
+          collector << ' OVER ('
           if !o.group.blank?
-            collector << " PARTITION BY "
+            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 "
+            collector << ' ORDER BY '
             o.order.each_with_index do |order, i|
               collector << COMMA if i != 0
               visit order, collector
             end
           end
-          collector << ")"
+          collector << ')'
         end
         collector
       end
 
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "array_to_string(array_agg("
+        collector << 'array_to_string(array_agg('
         collector = visit o.left, collector
         if o.order && !o.order.blank?
-          collector << " ORDER BY"
+          collector << ' ORDER BY'
           o.order.each_with_index do |order, i|
             collector << COMMA if i != 0
-            collector << " "
+            collector << ' '
             visit order, collector
           end
         end
-        collector << ")"
+        collector << ')'
         o.order = nil
         visit_Aggregate_For_AggregateFunction o, collector
         collector << COMMA
@@ -140,68 +140,68 @@ module ArelExtensions
           if o.separator && o.separator != 'NULL'
             visit o.separator, collector
           else
-            visit Arel::Nodes.build_quoted(','), collector
+            visit Arel.quoted(','), collector
           end
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Trim o, collector
-          collector << 'TRIM(BOTH '
-          collector = visit o.right, collector
-          collector << " FROM "
-          collector = visit o.left, collector
-          collector << ")"
-          collector
+        collector << 'TRIM(BOTH '
+        collector = visit o.right, collector
+        collector << ' FROM '
+        collector = visit o.left, collector
+        collector << ')'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Ltrim o, collector
-          collector << 'TRIM(LEADING '
-          collector = visit o.right, collector
-          collector << " FROM "
-          collector = visit o.left, collector
-          collector << ")"
-          collector
+        collector << 'TRIM(LEADING '
+        collector = visit o.right, collector
+        collector << ' FROM '
+        collector = visit o.left, collector
+        collector << ')'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Rtrim o, collector
         collector << 'TRIM(TRAILING '
         collector = visit o.right, collector
-        collector << " FROM "
+        collector << ' FROM '
         collector = visit o.left, collector
-        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 << 'TO_CHAR('
         collector << '(' if o.time_zone
         collector = visit o.left, collector
         case o.time_zone
         when Hash
           src_tz, dst_tz = o.time_zone.first
           collector << ') AT TIME ZONE '
-          collector = visit Arel::Nodes.build_quoted(src_tz), collector
+          collector = visit Arel.quoted(src_tz), collector
           collector << ' AT TIME ZONE '
-          collector = visit Arel::Nodes.build_quoted(dst_tz), collector
+          collector = visit Arel.quoted(dst_tz), collector
         when String
           collector << ') AT TIME ZONE '
-          collector = visit Arel::Nodes.build_quoted(o.time_zone), collector
+          collector = visit Arel.quoted(o.time_zone), collector
         end
         collector << COMMA
-        collector = visit Arel::Nodes.build_quoted(fmt), collector
-        collector << ")"
+        collector = visit Arel.quoted(fmt), collector
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Repeat o, collector
-        collector << "REPEAT("
+        collector << 'REPEAT('
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -243,9 +243,9 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_Collate o, collector
         if o.ai
-          collector << "unaccent("
+          collector << 'unaccent('
           collector = visit o.expressions.first, collector
-          collector << ")"
+          collector << ')'
         elsif o.ci
           collector = visit o.expressions.first, collector
         else
@@ -264,16 +264,16 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_DateDiff o, collector
         if o.right_node_type == :ruby_date || o.right_node_type == :ruby_time || o.right_node_type == :date || o.right_node_type == :datetime || o.right_node_type == :time
           collector << if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
-                          "DATEDIFF('second', "
+                         "DATEDIFF('second', "
                       else
-                          "DATEDIFF('day', "
+                        "DATEDIFF('day', "
                       end
           collector = visit o.right, collector
           collector << (o.right_node_type == :date ? '::date' : '::timestamp')
           collector << COMMA
           collector = visit o.left, collector
           collector << (o.left_node_type == :date ? '::date' : '::timestamp')
-          collector << ")"
+          collector << ')'
         else
           collector << '('
           collector = visit o.left, collector
@@ -290,57 +290,57 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Duration o, collector
         if o.with_interval
           interval = case o.left
-            when  'd','m','y'
+            when  'd', 'm', 'y'
               'DAY'
-            when 'h','mn','s'
+            when 'h', 'mn', 's'
               'SECOND'
             when /i\z/
-              collector << "("
+              collector << '('
               collector = visit o.right, collector
-              collector << ")"
+              collector << ')'
               collector << " * (INTERVAL '1' #{DATE_MAPPING[o.left[0..-2]]})"
               return collector
             end
         end
         collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM CAST("
         collector = visit o.right, collector
-        collector << " AS TIMESTAMP WITH TIME ZONE))"
+        collector << ' AS TIMESTAMP WITH TIME ZONE))'
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
         collector
       end
 
       def visit_ArelExtensions_Nodes_Locate o, collector
-        collector << "POSITION("
+        collector << 'POSITION('
         collector = visit o.right, collector
-        collector << " IN "
+        collector << ' IN '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Substring o, collector
-        collector << "SUBSTR("
+        collector << 'SUBSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_RegexpReplace o, collector
-        collector << "REGEXP_REPLACE("
+        collector << 'REGEXP_REPLACE('
         visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
-        tab = o.pattern.inspect+ 'g' # Make it always global
+        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
+        visit Arel.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 << ")"
+        visit Arel.quoted(flags + 'g'), collector
+        collector << ')'
         collector
       end
 
@@ -351,57 +351,59 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_IsNotNull o, collector
-          collector = visit o.expr, collector
+        collector = visit o.expr, collector
           collector << ' IS NOT NULL'
           collector
       end
 
       def visit_ArelExtensions_Nodes_Sum o, collector
-        collector << "sum("
+        collector << 'sum('
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_Wday o, collector
-        collector << "EXRTACT(DOW, "
+        collector << 'EXRTACT(DOW, '
         collector = visit o.date, collector
         collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Cast o, collector
-        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
-          collector << "CAST(CAST("
-          collector = visit o.left, collector
-          collector << " AS numeric) AS int)"
-          return collector
-        when :number, :decimal, :float
-          Arel::Nodes::SqlLiteral.new('numeric')
-        when :datetime
-          Arel::Nodes::SqlLiteral.new('timestamp with time zone')
-        when :date
-          Arel::Nodes::SqlLiteral.new('date')
-        when :binary
-          Arel::Nodes::SqlLiteral.new('binary')
-        when :jsonb
-          Arel::Nodes::SqlLiteral.new('jsonb')
-        else
-          Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
-        end
-        collector << "CAST("
+        as_attr =
+          case o.as_attr
+          when :string
+            'varchar'
+          when :text, :ntext
+            'text'
+          when :time
+            'time'
+          when :int
+            collector << 'CAST(CAST('
+            collector = visit o.left, collector
+            collector << ' AS numeric) AS int)'
+            return collector
+          when :number, :decimal, :float
+            'numeric'
+          when :datetime
+            'timestamp with time zone'
+          when :date
+            'date'
+          when :binary
+            'binary'
+          when :jsonb
+            'jsonb'
+          else
+            o.as_attr.to_s
+          end
+
+        collector << 'CAST('
         collector = visit o.left, collector
-        collector << " AS "
-        collector = visit as_attr, collector
-        collector << ")"
+        collector << ' AS '
+        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), collector
+        collector << ')'
         collector
       end
 
@@ -410,9 +412,9 @@ module ArelExtensions
         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")
+        nines_before = ("999#{thousand_separator}" * 4 + '990')
 
-        sign = ArelExtensions::Nodes::Case.new.when(col<0).
+        sign = Arel.when(col < 0).
                   then('-').
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
@@ -420,35 +422,35 @@ module ArelExtensions
         number =
           if o.scientific_notation
             ArelExtensions::Nodes::Concat.new([
-                Arel::Nodes::NamedFunction.new('TRIM',[
-                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                    Arel.when(col.not_eq 0).then(col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor)).else(1),
-                    Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+                Arel::Nodes::NamedFunction.new('TRIM', [
+                  Arel::Nodes::NamedFunction.new('TO_CHAR', [
+                    Arel.when(col.not_eq 0).then(col.abs / Arel.quoted(10).pow(col.abs.log10.floor)).else(1),
+                    Arel.quoted('FM' + nines_before + '"' + comma + '"V' + nines_after)
                   ])]),
                 o.type,
-                Arel::Nodes::NamedFunction.new('TRIM',[
-                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                Arel::Nodes::NamedFunction.new('TRIM', [
+                  Arel::Nodes::NamedFunction.new('TO_CHAR', [
                     Arel.when(col.not_eq 0).then(col.abs.log10.floor).else(0),
-                    Arel::Nodes.build_quoted('FM'+nines_before)
+                    Arel.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)
+            Arel::Nodes::NamedFunction.new('TRIM', [
+              Arel::Nodes::NamedFunction.new('TO_CHAR', [
+                Arel.quoted(col.abs),
+                Arel.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).
-          then(Arel::Nodes.build_quoted(
+        repeated_char = (o.width == 0) ? Arel.quoted('') : ArelExtensions::Nodes::Case.new.
+          when(Arel.quoted(o.width).abs - (number.length + sign_length) > 0).
+          then(Arel.quoted(
               o.flags.include?('-') ? ' ' : (o.flags.include?('0') ? '0' : ' ')
-            ).repeat(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length))
+            ).repeat(Arel.quoted(o.width).abs - (number.length + sign_length))
           ).
           else('')
-        before = (!o.flags.include?('0'))&&(!o.flags.include?('-')) ? repeated_char : ''
-        middle = (o.flags.include?('0'))&&(!o.flags.include?('-'))  ? repeated_char : ''
+        before = (!o.flags.include?('0')) && (!o.flags.include?('-')) ? repeated_char : ''
+        middle = (o.flags.include?('0')) && (!o.flags.include?('-'))  ? repeated_char : ''
         after  = o.flags.include?('-') ? repeated_char : ''
         full_number = ArelExtensions::Nodes::Concat.new([
             before,
@@ -457,7 +459,7 @@ module ArelExtensions
             number,
             after
           ])
-        collector = visit ArelExtensions::Nodes::Concat.new([Arel::Nodes.build_quoted(o.prefix),full_number,Arel::Nodes.build_quoted(o.suffix)]), collector
+        collector = visit ArelExtensions::Nodes::Concat.new([Arel.quoted(o.prefix), full_number, Arel.quoted(o.suffix)]), collector
         collector
       end
 
@@ -469,7 +471,7 @@ module ArelExtensions
           o = o.dup
           o.orders = []
         end
-        old_visit_Arel_Nodes_SelectStatement(o,collector)
+        old_visit_Arel_Nodes_SelectStatement(o, collector)
       end
 
       alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
@@ -477,7 +479,7 @@ module ArelExtensions
         if o.name.length > 63
           o = Arel::Table.new(o.table_name).alias(Arel.shorten(o.name))
         end
-        old_visit_Arel_Nodes_TableAlias(o,collector)
+        old_visit_Arel_Nodes_TableAlias(o, collector)
       end
 
       alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
@@ -490,26 +492,26 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Std o, collector
-        collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
+        collector << (o.unbiased_estimator ? 'STDDEV_SAMP(' : 'STDDEV_POP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_Variance o, collector
-        collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
+        collector << (o.unbiased_estimator ? 'VAR_SAMP(' : 'VAR_POP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Json o,collector
+      def visit_ArelExtensions_Nodes_Json o, collector
         case o.dict
         when Array
           collector << 'to_jsonb(array['
-          o.dict.each.with_index do |v,i|
+          o.dict.each.with_index do |v, i|
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
@@ -518,7 +520,7 @@ module ArelExtensions
           collector << '])'
         when Hash
           collector << 'jsonb_build_object('
-          o.dict.each.with_index do |(k,v),i|
+          o.dict.each.with_index do |(k, v), i|
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
@@ -527,11 +529,11 @@ module ArelExtensions
             collector = visit v, collector
           end
           collector << ')'
-        when String,Numeric,TrueClass,FalseClass
-          collector = visit Arel::Nodes.build_quoted("#{o.dict}"), collector
+        when String, Numeric, TrueClass, FalseClass
+          collector = visit Arel.quoted("#{o.dict}"), collector
           collector << '::jsonb'
         when NilClass
-          collector  << %Q['null'::jsonb]
+          collector << %Q['null'::jsonb]
         else
           collector = visit o.dict, collector
           collector << '::jsonb'
@@ -539,8 +541,8 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonMerge o,collector
-        o.expressions.each.with_index do |v,i|
+      def visit_ArelExtensions_Nodes_JsonMerge o, collector
+        o.expressions.each.with_index do |v, i|
           if i != 0
             collector << ' || '
           end
@@ -549,14 +551,14 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGet o,collector
+      def visit_ArelExtensions_Nodes_JsonGet o, collector
         collector = visit o.dict, collector
         collector << ' ->> '
         collector = visit o.key, collector
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonSet o,collector
+      def visit_ArelExtensions_Nodes_JsonSet o, collector
         collector << 'jsonb_set('
         collector = visit o.dict, collector
         collector << Arel::Visitors::MySQL::COMMA
@@ -578,7 +580,7 @@ module ArelExtensions
         else
           case o.dict
           when Hash
-            o.dict.each.with_index do |(k,v),i|
+            o.dict.each.with_index do |(k, v), i|
               if i != 0
                 collector << ' || '
               end