arel_extensions 2.1.1 → 2.1.4

data/lib/arel_extensions/visitors/mysql.rb

@@ -8,7 +8,8 @@ module ArelExtensions
 
       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
+        '%V' => '%v', '%G' => '%x',                                                                         # ISO week number and year of week
+        '%d' => '%d', '%e' => '%e', '%j' => '%j', '%w' => '%w', '%a' => '%a', '%A' => '%W',                 # day, weekday
         '%H' => '%H', '%k' => '%k', '%I' => '%I', '%l' => '%l', '%P' => '%p', '%p' => '%p',                 # hours
         '%M' => '%i', '%S' => '%S', '%L' =>   '', '%N' => '%f', '%z' => ''
       }.freeze
@@ -16,22 +17,22 @@ module ArelExtensions
 
       # Math functions
       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 = visit arg, collector
-          }
-          collector << ")"
-          collector
+        collector << 'LOG10('
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::ToSql::COMMA if i != 0
+          collector = visit arg, collector
+        }
+        collector << ')'
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Power o, collector
-        collector << "POW("
+        collector << 'POW('
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -44,10 +45,9 @@ module ArelExtensions
         collector << ')'
         if o.escape
           collector << ' ESCAPE '
-          visit o.escape, collector
-        else
-          collector
+          collector = visit o.escape, collector
         end
+        collector
       end
 
       def visit_ArelExtensions_Nodes_AiMatches o, collector
@@ -56,10 +56,9 @@ module ArelExtensions
         collector = visit o.right.ai_collate, collector
         if o.escape
           collector << ' ESCAPE '
-          visit o.escape, collector
-        else
-          collector
+          collector = visit o.escape, collector
         end
+        collector
       end
 
       def visit_ArelExtensions_Nodes_AiIMatches o, collector
@@ -68,22 +67,20 @@ module ArelExtensions
         collector = visit o.right.ai_collate, collector
         if o.escape
           collector << ' ESCAPE '
-          visit o.escape, collector
-        else
-          collector
+          collector = visit o.escape, collector
         end
+        collector
       end
 
       def visit_ArelExtensions_Nodes_SMatches o, collector
-          collector = visit o.left.collate, collector
-          collector << ' LIKE '
-          collector = visit o.right.collate, collector
-          if o.escape
-            collector << ' ESCAPE '
-            visit o.escape, collector
-          else
-            collector
-          end
+        collector = visit o.left.collate, collector
+        collector << ' LIKE '
+        collector = visit o.right.collate, collector
+        if o.escape
+          collector << ' ESCAPE '
+          collector = visit o.escape, collector
+        end
+        collector
       end
 
       def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
@@ -94,10 +91,9 @@ module ArelExtensions
         collector << ')'
         if o.escape
           collector << ' ESCAPE '
-          visit o.escape, collector
-        else
-          collector
+          collector = visit o.escape, collector
         end
+        collector
       end
 
       def visit_ArelExtensions_Nodes_Collate o, collector
@@ -105,7 +101,7 @@ module ArelExtensions
           case o.expressions.first
           when Arel::Attributes::Attribute
             case o.option
-            when 'latin1','utf8'
+            when 'latin1', 'utf8'
               o.option
             else
               Arel::Table.engine.connection.charset || 'utf8'
@@ -127,27 +123,27 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Concat o, collector
-        collector << "CONCAT("
+        collector << 'CONCAT('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
           if (arg.is_a?(Numeric)) || (arg.is_a?(Arel::Attributes::Attribute))
-            collector << "CAST("
+            collector << 'CAST('
             collector = visit arg, collector
-            collector << " AS char)"
+            collector << ' AS char)'
           else
             collector = visit arg, collector
           end
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "GROUP_CONCAT("
+        collector << 'GROUP_CONCAT('
         collector = visit o.left, collector
         if !o.order.blank?
           collector << ' ORDER BY '
-          o.order.each_with_index do |order,i|
+          o.order.each_with_index do |order, i|
             collector << Arel::Visitors::ToSql::COMMA if i != 0
             collector = visit order, collector
           end
@@ -156,77 +152,85 @@ module ArelExtensions
           collector << ' SEPARATOR '
           collector = visit o.separator, 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_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
 
       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")
+          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(o, collector)
       end
 
       def visit_ArelExtensions_Nodes_Format o, collector
         case o.col_type
         when :date, :datetime, :time
           fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
-          collector << "DATE_FORMAT("
-          collector << "CONVERT_TZ(" if o.time_zone
+          collector << 'DATE_FORMAT('
+          collector << 'CONVERT_TZ(' if o.time_zone
           collector = visit o.left, collector
-          if o.time_zone
+          case o.time_zone
+          when Hash
+            src_tz, dst_tz = o.time_zone.first
+            collector << COMMA
+            collector = visit Arel.quoted(src_tz), collector
+            collector << COMMA
+            collector = visit Arel.quoted(dst_tz), collector
+            collector << ')'
+          when String
             collector << COMMA << "'UTC'" << COMMA
-            collector = visit o.time_zone, collector
+            collector = visit Arel.quoted(o.time_zone), collector
             collector << ')'
           end
           collector << COMMA
-          collector = visit Arel::Nodes.build_quoted(fmt), collector
-          collector << ")"
+          collector = visit Arel.quoted(fmt), collector
+          collector << ')'
         when :integer, :float, :decimal
-          collector << "FORMAT("
+          collector << 'FORMAT('
           collector = visit o.left, collector
           collector << Arel::Visitors::ToSql::COMMA
           collector << '2'
           collector << Arel::Visitors::ToSql::COMMA
           collector = visit o.right, collector
-          collector << ")"
+          collector << ')'
         else
           collector = visit o.left, collector
         end
@@ -244,7 +248,7 @@ module ArelExtensions
           collector = visit o.right, collector
           collector << COMMA
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
         else
           collector << '('
           collector = visit o.left, collector
@@ -264,81 +268,79 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_DateAdd o, collector
-        collector << "DATE_ADD("
+        collector << 'DATE_ADD('
         collector = visit o.left, collector
         collector << COMMA
         collector = visit o.mysql_value(o.right), collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Duration o, collector
         if o.left == 'wd'
-          collector << "(WEEKDAY("
+          collector << '(WEEKDAY('
           collector = visit o.right, collector
-          collector << ") + 1) % 7"
+          collector << ') + 1) % 7'
         else
           if o.with_interval
-            case o.left
-            when 'd','m','y'
-              interval = 'DAY'
-            when 'h','mn','s'
-              interval = 'SECOND'
-            when /i\z/
-              interval = DATE_MAPPING[o.left[0..-2]]
-            else
-              interval = nil
-            end
+            interval =
+              case o.left
+              when 'd', 'm', 'y'
+                'DAY'
+              when 'h', 'mn', 's'
+                'SECOND'
+              when /i\z/
+                DATE_MAPPING[o.left[0..-2]]
+              end
           end
-          collector << " INTERVAL " if o.with_interval && interval
+          collector << ' INTERVAL ' if o.with_interval && interval
           collector << "#{DATE_MAPPING[o.left]}("
           collector = visit o.right, collector
-          collector << ")"
+          collector << ')'
           collector << " #{interval} " if o.with_interval && interval
         end
         collector
       end
 
       def visit_ArelExtensions_Nodes_IsNull o, collector
-        collector << "ISNULL("
+        collector << 'ISNULL('
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_IsNotNull o, collector
-          collector << "NOT ISNULL("
+        collector << 'NOT ISNULL('
           collector = visit o.expr, collector
-          collector << ")"
+          collector << ')'
           collector
       end
 
       def visit_ArelExtensions_Nodes_Wday o, collector
-        collector << "(WEEKDAY("
+        collector << '(WEEKDAY('
         collector = visit o.date, collector
-        collector << ") + 1) % 7"
+        collector << ') + 1) % 7'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Cast o, collector
-        collector << "CAST("
-        collector = visit o.left, collector
-        collector << " AS "
         as_attr =
-          Arel::Nodes::SqlLiteral.new(
-            case o.as_attr
-            when :string           then 'char'
-            when :time             then 'time'
-            when :int              then 'signed'
-            when :number, :decimal then 'decimal(20,6)'
-            when :datetime         then 'datetime'
-            when :date             then 'date'
-            when :binary           then 'binary'
-            else                        o.as_attr.to_s
-            end
-          )
-        collector = visit as_attr, collector
-        collector << ")"
+          case o.as_attr
+          when :binary           then 'binary'
+          when :date             then 'date'
+          when :datetime         then 'datetime'
+          when :int              then 'signed'
+          when :number, :decimal then 'decimal(20,6)'
+          when :string           then 'char'
+          when :time             then 'time'
+          else                        o.as_attr.to_s
+          end
+
+        collector << 'CAST('
+        collector = visit o.left, collector
+        collector << ' AS '
+        collector = visit Arel::Nodes::SqlLiteral.new(as_attr), collector
+        collector << ')'
         collector
       end
 
@@ -348,7 +350,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_As, :visit_Arel_Nodes_As) rescue nil
@@ -360,7 +362,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] != '`'
@@ -370,13 +372,12 @@ module ArelExtensions
         collector << '`' if quote
 
         collector
-        collector
       end
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        params = o.locale ? [o.precision,Arel::Nodes.build_quoted(o.locale)] : [o.precision]
-        sign = ArelExtensions::Nodes::Case.new.when(col<0).
+        params = o.locale ? [o.precision, Arel.quoted(o.locale)] : [o.precision]
+        sign = Arel.when(col < 0).
                   then('-').
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
@@ -384,28 +385,28 @@ module ArelExtensions
         number =
           if o.scientific_notation
             ArelExtensions::Nodes::Concat.new([
-                    Arel::Nodes::NamedFunction.new('FORMAT',[
-                      col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor)
-                    ]+params),
+                    Arel::Nodes::NamedFunction.new('FORMAT', [
+                      col.abs / Arel.quoted(10).pow(col.abs.log10.floor)
+                    ] + params),
                     o.type,
-                    Arel::Nodes::NamedFunction.new('FORMAT',[
+                    Arel::Nodes::NamedFunction.new('FORMAT', [
                       col.abs.log10.floor,
                       0
                     ])
                   ])
           else
-            Arel::Nodes::NamedFunction.new('FORMAT',[col.abs]+params)
+            Arel::Nodes::NamedFunction.new('FORMAT', [col.abs] + params)
           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,
@@ -414,45 +415,45 @@ 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
 
       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
+          warn('Warning: ArelExtensions: Window Functions are not available in the current version of the DBMS.')
+          return collector
         end
 
         if !o.order.empty? || !o.group.empty?
-          collector << " OVER ("
+          collector << ' OVER ('
           if !o.group.empty?
-            collector << " PARTITION BY ("
+            collector << ' PARTITION BY ('
             visit o.group, collector
-            collector << ")"
+            collector << ')'
           end
           if !o.order.empty?
-            collector << " ORDER BY ("
+            collector << ' ORDER BY ('
             visit o.order, collector
-            collector << ")"
+            collector << ')'
           end
-          collector << ")"
+          collector << ')'
         end
         collector
       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
@@ -484,13 +485,13 @@ module ArelExtensions
         # 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
         when Array
           collector << 'JSON_ARRAY('
-          o.dict.each.with_index do |v,i|
+          o.dict.each.with_index do |v, i|
             if i != 0
               collector << COMMA
             end
@@ -499,7 +500,7 @@ module ArelExtensions
           collector << ')'
         when Hash
           collector << 'JSON_OBJECT('
-          o.dict.each.with_index do |(k,v),i|
+          o.dict.each.with_index do |(k, v), i|
             if i != 0
               collector << COMMA
             end
@@ -514,9 +515,9 @@ module ArelExtensions
         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|
+        o.expressions.each.with_index do |v, i|
           if i != 0
             collector << COMMA
           end
@@ -526,27 +527,27 @@ 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
         if o.key.is_a?(Integer)
           collector << "\"$[#{o.key}]\""
         else
-          collector = visit Arel::Nodes.build_quoted('$.')+o.key, collector
+          collector = visit Arel.quoted('$.') + o.key, collector
         end
         collector << ')'
         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
         if o.key.is_a?(Integer)
           collector << "\"$[#{o.key}]\""
         else
-          collector = visit Arel::Nodes.build_quoted('$.')+o.key, collector
+          collector = visit Arel.quoted('$.') + o.key, collector
         end
         collector << COMMA
         collector = visit o.value, collector
@@ -565,7 +566,7 @@ module ArelExtensions
           case o.dict
           when Hash
             collector << 'JSON_MERGE_PATCH(' if o.dict.length > 1
-            o.dict.each.with_index do |(k,v),i|
+            o.dict.each.with_index do |(k, v), i|
               if i != 0
                 collector << COMMA
               end