arel_extensions 2.3.3 → 2.5.0

data/lib/arel_extensions/visitors/mysql.rb

@@ -25,7 +25,7 @@ module ArelExtensions
       end
 
       if private_method_defined?(:visit_Arel_Nodes_SelectCore) || method_defined?(:visit_Arel_Nodes_SelectCore)
-        alias_method(:old_visit_Arel_Nodes_SelectCore, :visit_Arel_Nodes_SelectCore)
+        alias old_visit_Arel_Nodes_SelectCore visit_Arel_Nodes_SelectCore
       end
       # The whole purpose of this override is to fix the behavior of RollUp.
       # All other databases treat RollUp sanely, execpt MySQL which requires
@@ -33,7 +33,7 @@ module ArelExtensions
       def visit_Arel_Nodes_SelectCore(o, collector)
         collector << 'SELECT'
 
-        collector = collect_optimizer_hints(o, collector) if self.respond_to?(:collect_optimizer_hinsts)
+        collector = collect_optimizer_hints(o, collector) if respond_to?(:collect_optimizer_hints, true)
         collector = maybe_visit o.set_quantifier, collector
 
         collect_nodes_for o.projections, collector, ' '
@@ -65,20 +65,20 @@ module ArelExtensions
       end
 
       # Math functions
-      def visit_ArelExtensions_Nodes_Log10 o, collector
+      def visit_ArelExtensions_Nodes_Log10(o, collector)
         collector << 'LOG10('
         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_Power o, collector
+      def visit_ArelExtensions_Nodes_Power(o, collector)
         collector << 'POW('
         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 << ')'
@@ -86,7 +86,21 @@ module ArelExtensions
       end
 
       # String functions
-      def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
+      def visit_ArelExtensions_Nodes_ByteSize(o, collector)
+        collector << 'LENGTH('
+        collector = visit o.expr.coalesce(''), collector
+        collector << ')'
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_CharLength(o, collector)
+        collector << 'CHAR_LENGTH('
+        collector = visit o.expr.coalesce(''), collector
+        collector << ')'
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_IMatches(o, collector) # insensitive on ASCII
         collector << 'LOWER('
         collector = visit o.left, collector
         collector << ') LIKE LOWER('
@@ -99,7 +113,7 @@ module ArelExtensions
         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
@@ -110,7 +124,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_AiIMatches o, collector
+      def visit_ArelExtensions_Nodes_AiIMatches(o, collector)
         collector = visit o.left.ai_collate, collector
         collector << ' LIKE '
         collector = visit o.right.ai_collate, collector
@@ -121,7 +135,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_SMatches o, collector
+      def visit_ArelExtensions_Nodes_SMatches(o, collector)
         collector = visit o.left.collate, collector
         collector << ' LIKE '
         collector = visit o.right.collate, collector
@@ -132,7 +146,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
+      def visit_ArelExtensions_Nodes_IDoesNotMatch(o, collector)
         collector << 'LOWER('
         collector = visit o.left, collector
         collector << ') NOT LIKE LOWER('
@@ -145,7 +159,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Collate o, collector
+      def visit_ArelExtensions_Nodes_Collate(o, collector)
         charset =
           case o.expressions.first
           when Arel::Attributes::Attribute
@@ -156,7 +170,7 @@ module ArelExtensions
               Arel::Table.engine.connection.charset || 'utf8'
             end
           else
-            (o.option == 'latin1') ? 'latin1' : 'utf8'
+            o.option == 'latin1' ? 'latin1' : 'utf8'
           end
         collector = visit o.expressions.first, collector
         collector <<
@@ -171,7 +185,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Concat o, collector
+      def visit_ArelExtensions_Nodes_Concat(o, collector)
         collector << 'CONCAT('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -189,16 +203,16 @@ module ArelExtensions
 
       def visit_Arel_Nodes_RollUp(o, collector)
         visit o.expr, collector
-        collector << " WITH ROLLUP"
+        collector << ' WITH ROLLUP'
       end
 
-      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+      def visit_ArelExtensions_Nodes_GroupConcat(o, collector)
         collector << 'GROUP_CONCAT('
         collector = visit o.left, collector
         if !o.order.blank?
           collector << ' ORDER BY '
           o.order.each_with_index do |order, i|
-            collector << Arel::Visitors::ToSql::COMMA if i != 0
+            collector << COMMA if i != 0
             collector = visit order, collector
           end
         end
@@ -211,7 +225,7 @@ module ArelExtensions
         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 '
@@ -220,7 +234,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 '
@@ -229,7 +243,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 '
@@ -238,24 +252,24 @@ 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_RegexpReplace o, collector
+      def visit_ArelExtensions_Nodes_RegexpReplace(o, collector)
         if !regexp_replace_supported?
           warn('Warning: ArelExtensions: REGEXP_REPLACE does not seem to be available in the current version of the DBMS, it might crash')
         end
-        super(o, collector)
+        super
       end
 
-      def visit_ArelExtensions_Nodes_Format o, collector
+      def visit_ArelExtensions_Nodes_Format(o, collector)
         # One use case we met is
         # `case…when…then(valid_date).else(Arel.null).format(…)`.
         #
@@ -264,10 +278,12 @@ module ArelExtensions
         # infer the proper type.
         first = o.expressions[0]
         type =
-          o.col_type.nil? \
-            && (first.respond_to?(:return_type) && !first&.return_type.nil?) \
-          ? first&.return_type \
-          : o.col_type
+          if o.col_type.nil? \
+            && first.respond_to?(:return_type) && !first&.return_type.nil?
+            first&.return_type
+          else
+            o.col_type
+          end
 
         case type
         when :date, :datetime, :time
@@ -275,9 +291,9 @@ module ArelExtensions
         when :integer, :float, :decimal
           collector << 'FORMAT('
           collector = visit o.left, collector
-          collector << Arel::Visitors::ToSql::COMMA
+          collector << COMMA
           collector << '2'
-          collector << Arel::Visitors::ToSql::COMMA
+          collector << COMMA
           collector = visit o.right, collector
           collector << ')'
         else
@@ -286,8 +302,8 @@ module ArelExtensions
         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 << 'DATE_FORMAT('
         collector << 'CONVERT_TZ(' if o.time_zone
         collector = visit o.left, collector
@@ -309,7 +325,7 @@ module ArelExtensions
         collector << ')'
       end
 
-      def visit_ArelExtensions_Nodes_DateDiff o, collector
+      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
         case o.right_node_type
         when :ruby_date, :ruby_time, :date, :datetime, :time
           collector <<
@@ -339,7 +355,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateAdd o, collector
+      def visit_ArelExtensions_Nodes_DateAdd(o, collector)
         collector << 'DATE_ADD('
         collector = visit o.left, collector
         collector << COMMA
@@ -348,7 +364,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration o, collector
+      def visit_ArelExtensions_Nodes_Duration(o, collector)
         if o.left == 'wd'
           collector << '(WEEKDAY('
           collector = visit o.right, collector
@@ -374,28 +390,28 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNull o, collector
+      def visit_ArelExtensions_Nodes_IsNull(o, collector)
         collector << 'ISNULL('
         collector = visit o.expr, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+      def visit_ArelExtensions_Nodes_IsNotNull(o, collector)
         collector << 'NOT ISNULL('
-          collector = visit o.expr, collector
-          collector << ')'
-          collector
+        collector = visit o.expr, collector
+        collector << ')'
+        collector
       end
 
-      def visit_ArelExtensions_Nodes_Wday o, collector
+      def visit_ArelExtensions_Nodes_Wday(o, collector)
         collector << '(WEEKDAY('
         collector = visit o.date, collector
         collector << ') + 1) % 7'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Cast o, collector
+      def visit_ArelExtensions_Nodes_Cast(o, collector)
         as_attr =
           case o.as_attr
           when :binary           then 'binary'
@@ -416,8 +432,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 = []
@@ -425,8 +441,8 @@ module ArelExtensions
         old_visit_Arel_Nodes_SelectStatement(o, 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
@@ -446,7 +462,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
+      def visit_ArelExtensions_Nodes_FormattedNumber(o, collector)
         col = o.left.coalesce(0)
         params = o.locale ? [o.precision, Arel.quoted(o.locale)] : [o.precision]
         sign = Arel.when(col < 0).
@@ -496,7 +512,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_Aggregate_For_AggregateFunction o, collector
+      def visit_Aggregate_For_AggregateFunction(o, collector)
         if !window_supported?
           warn('Warning: ArelExtensions: Window Functions are not available in the current version of the DBMS.')
           return collector
@@ -519,7 +535,7 @@ module ArelExtensions
         collector
       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 << ')'
@@ -527,7 +543,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 << ')'
@@ -550,19 +566,19 @@ module ArelExtensions
 
       def version_supported?(mariadb_v = '10.2.3', mysql_v = '5.7.0')
         conn = Arel::Table.engine.connection
-        conn.send(:mariadb?) && \
-          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v || \
-          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v || \
-          conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mariadb_v) || \
-          !conn.send(:mariadb?) && \
-            (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v || \
-            conn.respond_to?(:version) && conn.send(:version) >= mysql_v || \
-            conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mysql_v)
+        conn.send(:mariadb?) &&
+          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v ||
+          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v ||
+          conn.instance_variable_get(:@version) && conn.instance_variable_get(:@version) >= mariadb_v) ||
+          !conn.send(:mariadb?) &&
+            (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v ||
+            conn.respond_to?(:version) && conn.send(:version) >= mysql_v ||
+            conn.instance_variable_get(:@version) && conn.instance_variable_get(:@version) >= mysql_v)
         # ideally we should parse the instance_variable @full_version because @version contains only the supposedly
         # corresponding mysql version of the current mariadb version (which is not very helpful most of the time)
       end
 
-      def visit_ArelExtensions_Nodes_Json o, collector
+      def visit_ArelExtensions_Nodes_Json(o, collector)
         return super if !json_supported?
 
         case o.dict
@@ -572,7 +588,7 @@ module ArelExtensions
             if i != 0
               collector << COMMA
             end
-            collector = visit v, collector
+            collector = visit_json_value(o, v, collector)
           end
           collector << ')'
         when Hash
@@ -583,16 +599,34 @@ module ArelExtensions
             end
             collector = visit k, collector
             collector << COMMA
-            collector = visit v, collector
+            collector = visit_json_value(o, v, collector)
           end
           collector << ')'
         else
-          collector = visit o.dict, collector
+          collector = visit_json_value(o, o.dict, collector)
+        end
+        collector
+      end
+
+      # A JSON Boolean must render as `true`/`false`, not the integer `1`/`0` that MySQL
+      # collapses `TRUE`/`FALSE` into inside JSON functions (MariaDB keeps them boolean).
+      def visit_json_value(o, v, collector)
+        if o.boolean_literal?(v)
+          value = v.is_a?(Arel::Nodes::Quoted) ? v.expr : v
+          collector << "JSON_EXTRACT('#{value}', '$')"
+        elsif o.type_of_node(v) == :boolean
+          collector << 'JSON_EXTRACT(CASE WHEN '
+          collector = visit v, collector
+          collector << " IS NULL THEN NULL WHEN "
+          collector = visit v, collector
+          collector << " THEN 'true' ELSE 'false' END, '$')"
+        else
+          collector = visit v, collector
         end
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonMerge o, collector
+      def visit_ArelExtensions_Nodes_JsonMerge(o, collector)
         collector << 'JSON_MERGE_PATCH('
         o.expressions.each.with_index do |v, i|
           if i != 0
@@ -604,7 +638,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGet o, collector
+      def visit_ArelExtensions_Nodes_JsonGet(o, collector)
         collector << 'JSON_EXTRACT('
         collector = visit o.dict, collector
         collector << COMMA
@@ -617,7 +651,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonSet o, collector
+      def visit_ArelExtensions_Nodes_JsonSet(o, collector)
         collector << 'JSON_SET('
         collector = visit o.dict, collector
         collector << COMMA
@@ -632,7 +666,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_JsonGroup o, collector
+      def visit_ArelExtensions_Nodes_JsonGroup(o, collector)
         return super if !json_supported?
 
         if o.as_array