arel_extensions 2.3.3 → 2.5.0

data/lib/arel_extensions/visitors/postgresql.rb

@@ -20,9 +20,23 @@ module ArelExtensions
         'en_US' => '.,', 'fr_FR' => ',', 'sv_SE' => ', '
       }.freeze
 
-      def visit_ArelExtensions_Nodes_Rand o, collector
+      def visit_ArelExtensions_Nodes_ByteSize(o, collector)
+        collector << 'octet_length('
+        collector = visit o.expr.coalesce(''), collector
+        collector << ')'
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_CharLength(o, collector)
+        collector << 'length('
+        collector = visit o.expr.coalesce(''), collector
+        collector << ')'
+        collector
+      end
+
+      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 = isit o.right, collector
@@ -31,44 +45,41 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Power o, collector
+      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 << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Log10 o, collector
+      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 << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ')'
         collector
       end
 
-
       remove_method(:visit_Arel_Nodes_Regexp) rescue nil
-      def visit_Arel_Nodes_Regexp o, collector
+      def visit_Arel_Nodes_Regexp(o, collector)
         collector = visit o.left, collector
         collector << ' ~ '
-        collector = visit o.right, collector
-        collector
+        visit o.right, collector
       end
 
       remove_method(:visit_Arel_Nodes_NotRegexp) rescue nil
-      def visit_Arel_Nodes_NotRegexp o, collector
+      def visit_Arel_Nodes_NotRegexp(o, collector)
         collector = visit o.left, collector
         collector << ' !~ '
-        collector = visit o.right, collector
-        collector
+        visit o.right, collector
       end
 
-      def visit_ArelExtensions_Nodes_Concat o, collector
+      def visit_ArelExtensions_Nodes_Concat(o, collector)
         collector << '('
         o.expressions.each_with_index { |arg, i|
           collector = visit arg, collector
@@ -78,8 +89,8 @@ module ArelExtensions
         collector
       end
 
-      alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
-      def visit_Arel_Nodes_As o, collector
+      alias 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 << '('
           collector = visit o.left, collector
@@ -99,7 +110,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_Aggregate_For_AggregateFunction o, collector
+      def visit_Aggregate_For_AggregateFunction(o, collector)
         if !o.order.blank? || !o.group.blank?
           collector << ' OVER ('
           if !o.group.blank?
@@ -121,7 +132,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
         collector << 'array_to_string(array_agg('
         collector = visit o.left, collector
         if o.order && !o.order.blank?
@@ -138,16 +149,16 @@ module ArelExtensions
         collector << COMMA
         sep = o.separator.is_a?(Arel::Nodes::Quoted) ? o.separator.expr : o.separator
         collector =
-          if 'NULL' != sep
-            visit o.separator, collector
-          else
+          if 'NULL' == sep
             visit Arel.quoted(','), collector
+          else
+            visit o.separator, collector
           end
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim o, collector
+      def visit_ArelExtensions_Nodes_Trim(o, collector)
         collector << 'TRIM(BOTH '
         collector = visit o.right, collector
         collector << ' FROM '
@@ -156,7 +167,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Ltrim o, collector
+      def visit_ArelExtensions_Nodes_Ltrim(o, collector)
         collector << 'TRIM(LEADING '
         collector = visit o.right, collector
         collector << ' FROM '
@@ -165,7 +176,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Rtrim o, collector
+      def visit_ArelExtensions_Nodes_Rtrim(o, collector)
         collector << 'TRIM(TRAILING '
         collector = visit o.right, collector
         collector << ' FROM '
@@ -174,12 +185,12 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Format o, collector
+      def visit_ArelExtensions_Nodes_Format(o, collector)
         visit_ArelExtensions_Nodes_FormattedDate o, collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedDate o, collector
-        fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
+      def visit_ArelExtensions_Nodes_FormattedDate(o, collector)
+        fmt = ArelExtensions::Visitors.strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
         collector << 'TO_CHAR('
         collector << '(' if o.time_zone
         collector = visit o.left, collector
@@ -200,17 +211,17 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Repeat o, collector
+      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 << COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_AiMatches o, collector
+      def visit_ArelExtensions_Nodes_AiMatches(o, collector)
         collector = visit o.left.ai_collate, collector
         collector << ' LIKE '
         collector = visit o.right.ai_collate, collector
@@ -222,7 +233,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_AiIMatches o, collector
+      def visit_ArelExtensions_Nodes_AiIMatches(o, collector)
         collector = visit o.left.ai_collate, collector
         collector << ' ILIKE '
         collector = visit o.right.ai_collate, collector
@@ -234,7 +245,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_SMatches o, collector
+      def visit_ArelExtensions_Nodes_SMatches(o, collector)
         collector = visit o.left, collector
         collector << ' LIKE '
         collector = visit o.right, collector
@@ -246,7 +257,7 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_Collate o, collector
+      def visit_ArelExtensions_Nodes_Collate(o, collector)
         if o.ai
           collector << 'unaccent('
           collector = visit o.expressions.first, collector
@@ -259,20 +270,19 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateAdd o, collector
+      def visit_ArelExtensions_Nodes_DateAdd(o, collector)
         collector = visit o.left, collector
         collector << ' + ' # (o.right.value >= 0 ? ' + ' : ' - ')
-        collector = visit o.postgresql_value(o.right), collector
-        collector
+        visit o.postgresql_value(o.right), collector
       end
 
-      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
+      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
+        if %i[ruby_date ruby_time date datetime time].include?(o.right_node_type)
+          collector << if %i[ruby_time datetime time].include?(o.left_node_type)
                          "DATEDIFF('second', "
-                      else
-                        "DATEDIFF('day', "
-                      end
+                       else
+                         "DATEDIFF('day', "
+                       end
           collector = visit o.right, collector
           collector << (o.right_node_type == :date ? '::date' : '::timestamp')
           collector << COMMA
@@ -292,10 +302,11 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration o, collector
+      def visit_ArelExtensions_Nodes_Duration(o, collector)
         if o.with_interval
-          interval = case o.left
-            when  'd', 'm', 'y'
+          interval =
+            case o.left
+            when 'd', 'm', 'y'
               'DAY'
             when 'h', 'mn', 's'
               'SECOND'
@@ -314,7 +325,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Locate o, collector
+      def visit_ArelExtensions_Nodes_Locate(o, collector)
         collector << 'POSITION('
         collector = visit o.right, collector
         collector << ' IN '
@@ -323,7 +334,9 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Substring o, collector
+      def visit_ArelExtensions_Nodes_Substring(o, collector)
+        return visit(o.range_substring_node, collector) if o.range?
+
         collector << 'SUBSTR('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -333,35 +346,35 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+      def visit_ArelExtensions_Nodes_RegexpReplace(o, collector)
         collector << 'REGEXP_REPLACE('
         visit o.left, collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         tab = o.pattern.inspect + 'g' # Make it always global
         pattern = tab.split('/')[1..-2].join('/')
         flags = tab.split('/')[-1]
         visit Arel.quoted(pattern), collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         visit o.substitute, collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << COMMA
         visit Arel.quoted(flags + 'g'), collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNull o, collector
+      def visit_ArelExtensions_Nodes_IsNull(o, collector)
         collector = visit o.expr, collector
         collector << ' IS NULL'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+      def visit_ArelExtensions_Nodes_IsNotNull(o, collector)
         collector = visit o.expr, collector
-          collector << ' IS NOT NULL'
-          collector
+        collector << ' IS NOT NULL'
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_Sum o, collector
+      def visit_ArelExtensions_Nodes_Sum(o, collector)
         collector << 'sum('
         collector = visit o.expr, collector
         collector << ')'
@@ -369,14 +382,14 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Wday o, collector
+      def visit_ArelExtensions_Nodes_Wday(o, collector)
         collector << 'EXRTACT(DOW, '
         collector = visit o.date, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Cast o, collector
+      def visit_ArelExtensions_Nodes_Cast(o, collector)
         as_attr =
           case o.as_attr
           when :string
@@ -412,11 +425,11 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
+      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')
-        nines_after = (1..o.precision).map{'9'}.join('')
+        nines_after = (1..o.precision).map { '9' }.join('')
         nines_before = ("999#{thousand_separator}" * 4 + '990')
 
         sign = Arel.when(col < 0).
@@ -473,10 +486,8 @@ module ArelExtensions
         collector
       end
 
-
-      alias_method(:old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement) rescue nil
-      def visit_Arel_Nodes_SelectStatement o, collector
-
+      alias 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
           o.orders = []
@@ -484,16 +495,16 @@ module ArelExtensions
         old_visit_Arel_Nodes_SelectStatement(o, collector)
       end
 
-      alias_method(:old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias) rescue nil
-      def visit_Arel_Nodes_TableAlias o, collector
+      alias 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))
         end
         old_visit_Arel_Nodes_TableAlias(o, collector)
       end
 
-      alias_method(:old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute) rescue nil
-      def visit_Arel_Attributes_Attribute o, collector
+      alias 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
           join_name = Arel.shorten(join_name)
@@ -501,7 +512,7 @@ module ArelExtensions
         collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
 
-      def visit_ArelExtensions_Nodes_Std o, collector
+      def visit_ArelExtensions_Nodes_Std(o, collector)
         collector << (o.unbiased_estimator ? 'STDDEV_SAMP(' : 'STDDEV_POP(')
         visit o.left, collector
         collector << ')'
@@ -509,7 +520,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Variance o, collector
+      def visit_ArelExtensions_Nodes_Variance(o, collector)
         collector << (o.unbiased_estimator ? 'VAR_SAMP(' : 'VAR_POP(')
         visit o.left, collector
         collector << ')'
@@ -517,25 +528,31 @@ module ArelExtensions
         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|
-            if i != 0
-              collector << Arel::Visitors::MySQL::COMMA
+          if o.dict.empty?
+            # `to_jsonb(array[])` would raise "cannot determine type of empty array";
+            # an empty array is simply the `[]` JSON literal.
+            collector << %('[]'::jsonb)
+          else
+            collector << 'to_jsonb(array['
+            o.dict.each.with_index do |v, i|
+              if i != 0
+                collector << COMMA
+              end
+              collector = visit v, collector
             end
-            collector = visit v, collector
+            collector << '])'
           end
-          collector << '])'
         when Hash
           collector << 'jsonb_build_object('
           o.dict.each.with_index do |(k, v), i|
             if i != 0
-              collector << Arel::Visitors::MySQL::COMMA
+              collector << COMMA
             end
             collector = visit k, collector
-            collector << Arel::Visitors::MySQL::COMMA
+            collector << COMMA
             collector = visit v, collector
           end
           collector << ')'
@@ -543,15 +560,24 @@ module ArelExtensions
           collector = visit Arel.quoted("#{o.dict}"), collector
           collector << '::jsonb'
         when NilClass
-          collector << %Q['null'::jsonb]
+          collector << %('null'::jsonb)
         else
-          collector = visit o.dict, collector
-          collector << '::jsonb'
+          if o.dict.is_a?(Arel::Nodes::Quoted) && o.dict.expr.nil?
+            # `Arel.null` must mean the JSON null member, not SQL NULL:
+            # `to_jsonb(NULL)` would raise a polymorphic-type error.
+            collector << %('null'::jsonb)
+          else
+            # `to_jsonb` rather than `::jsonb` so a non-JSON value (e.g. a text column) is
+            # encoded as a JSON string instead of rejected by the server.
+            collector << 'to_jsonb('
+            collector = visit o.dict, collector
+            collector << ')'
+          end
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonMerge o, collector
+      def visit_ArelExtensions_Nodes_JsonMerge(o, collector)
         o.expressions.each.with_index do |v, i|
           if i != 0
             collector << ' || '
@@ -561,28 +587,29 @@ 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
+        visit o.key, 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
+        collector << COMMA
         collector << 'array['
         collector = visit o.key, collector
         collector << ']'
-        collector << Arel::Visitors::MySQL::COMMA
+        collector << COMMA
+        collector << 'COALESCE('
         collector = visit o.value, collector
-        collector << Arel::Visitors::MySQL::COMMA
+        collector << ", 'null'::jsonb)"
+        collector << COMMA
         collector << 'true)'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGroup o, collector
+      def visit_ArelExtensions_Nodes_JsonGroup(o, collector)
         if o.as_array
           collector << 'jsonb_agg('
           collector = visit o.dict, collector
@@ -596,7 +623,7 @@ module ArelExtensions
               end
               collector << 'jsonb_object_agg('
               collector = visit k, collector
-              collector << Arel::Visitors::MySQL::COMMA
+              collector << COMMA
               collector = visit v, collector
               collector << ')'
             end