arel_extensions 2.1.3 → 2.1.4

data/lib/arel_extensions/visitors/mssql.rb

@@ -13,10 +13,10 @@ module ArelExtensions
       }.freeze
 
       LOADED_VISITOR::DATE_FORMAT_DIRECTIVES = {
-        '%Y' => 'YYYY', '%C' => '', '%y' => 'YY', '%m' => 'MM', '%B' =>   '', '%b' => '', '%^b' => '', # year, month
-        '%V' => 'iso_week', '%G' => '',                                                                # ISO week number and year of week
-        '%d' => 'DD', '%e' => '', '%j' =>   '', '%w' => 'dw', '%A' => '',                              # day, weekday
-        '%H' => 'hh', '%k' => '', '%I' =>   '', '%l' =>   '', '%P' => '', '%p' => '',                  # hours
+        '%Y' => 'YYYY', '%C' => '', '%y' => 'YY', '%m' => 'MM', '%B' => 'month', '%^B' => '', '%b' => '', '%^b' => '', # year, month
+        '%V' => 'iso_week', '%G' => '',                                                                                # ISO week number and year of week
+        '%d' => 'DD', '%e' => ''  , '%j' => ''  , '%w' => 'dw', %'a' => '', '%A' => 'weekday',                         # day, weekday
+        '%H' => 'hh', '%k' => ''  , '%I' => ''  , '%l' => ''  , '%P' => '', '%p' => '',                                # hours
         '%M' => 'mi', '%S' => 'ss', '%L' => 'ms', '%N' => 'ns', '%z' => 'tz'
       }.freeze
 
@@ -24,6 +24,10 @@ module ArelExtensions
         'YY' => '0#', 'MM' => '0#', 'DD' => '0#', 'hh' => '0#', 'mi' => '0#', 'ss' => '0#', 'iso_week' => '0#'
       }
 
+      LOADED_VISITOR::DATE_NAME = [
+        '%B', '%A'
+      ]
+
       LOADED_VISITOR::DATE_FORMAT_REGEX =
         Regexp.new(
           LOADED_VISITOR::DATE_FORMAT_DIRECTIVES
@@ -35,7 +39,7 @@ module ArelExtensions
       # TODO; all others... http://www.sql-server-helper.com/tips/date-formats.aspx
       LOADED_VISITOR::DATE_CONVERT_FORMATS = {
         'YYYY-MM-DD' => 120,
-        'YY-MM-DD'  => 120,
+        'YY-MM-DD' => 120,
         'MM/DD/YYYY' => 101,
         'MM-DD-YYYY' => 110,
         'YYYY/MM/DD' => 111,
@@ -47,63 +51,63 @@ module ArelExtensions
 
       # Math Functions
       def visit_ArelExtensions_Nodes_Ceil o, collector
-        collector << "CEILING("
+        collector << 'CEILING('
         collector = visit o.expr, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Log10 o, collector
-          collector << "LOG10("
+        collector << 'LOG10('
           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_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_IsNull o, collector
-        collector << "("
+        collector << '('
         collector = visit o.expr, collector
-        collector << " IS NULL)"
+        collector << ' IS NULL)'
         collector
       end
 
       def visit_ArelExtensions_Nodes_IsNotNull o, collector
-          collector << "("
+        collector << '('
           collector = visit o.expr, collector
-          collector << " IS NOT NULL)"
+          collector << ' IS NOT NULL)'
           collector
       end
 
       def visit_ArelExtensions_Nodes_Concat o, collector
-        collector << "CONCAT("
+        collector << 'CONCAT('
         o.expressions.each_with_index { |arg, i|
           collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Repeat o, collector
-        collector << "REPLICATE("
+        collector << 'REPLICATE('
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -123,28 +127,28 @@ module ArelExtensions
           collector << ')'
         else
           da = ArelExtensions::Nodes::DateAdd.new([])
-          collector << "DATEADD("
+          collector << 'DATEADD('
           collector = visit da.mssql_datepart(o.right), collector
           collector << LOADED_VISITOR::COMMA
-          collector << "-("
+          collector << '-('
           collector = visit da.mssql_value(o.right), collector
-          collector << ")"
+          collector << ')'
           collector << LOADED_VISITOR::COMMA
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
           collector
         end
         collector
       end
 
       def visit_ArelExtensions_Nodes_DateAdd o, collector
-        collector << "DATEADD("
+        collector << 'DATEADD('
         collector = visit o.mssql_datepart(o.right), collector
         collector << LOADED_VISITOR::COMMA
         collector = visit o.mssql_value(o.right), collector
         collector << LOADED_VISITOR::COMMA
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -160,47 +164,47 @@ module ArelExtensions
           collector << 'CONVERT(datetime,' if conv
           collector = visit o.right, collector
           collector << ')' if conv
-          collector << ")"
+          collector << ')'
         end
         collector
       end
 
       def visit_ArelExtensions_Nodes_Length o, collector
         if o.bytewise
-          collector << "(DATALENGTH("
+          collector << '(DATALENGTH('
           collector = visit o.expr, collector
-          collector << ") / ISNULL(NULLIF(DATALENGTH(LEFT(COALESCE("
+          collector << ') / ISNULL(NULLIF(DATALENGTH(LEFT(COALESCE('
           collector = visit o.expr, collector
           collector << ", '#' ), 1 )), 0), 1))"
           collector
         else
-          collector << "LEN("
+          collector << 'LEN('
           collector = visit o.expr, collector
-          collector << ")"
+          collector << ')'
           collector
         end
       end
 
       def visit_ArelExtensions_Nodes_Round o, collector
-        collector << "ROUND("
+        collector << 'ROUND('
         o.expressions.each_with_index { |arg, i|
           collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
         if o.expressions.length == 1
           collector << LOADED_VISITOR::COMMA
-          collector << "0"
+          collector << '0'
         end
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Locate o, collector
-        collector << "CHARINDEX("
+        collector << 'CHARINDEX('
         collector = visit o.right, collector
         collector << LOADED_VISITOR::COMMA
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -218,15 +222,15 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Trim o, collector
         collector << 'TRIM( '
         collector = visit o.right, collector
-        collector << " FROM "
+        collector << ' FROM '
         collector = visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Ltrim o, collector
         if o.right
-          collector << "REPLACE(REPLACE(LTRIM(REPLACE(REPLACE("
+          collector << 'REPLACE(REPLACE(LTRIM(REPLACE(REPLACE('
           collector = visit o.left, collector
           collector << ", ' ', '~'), "
           collector = visit o.right, collector
@@ -234,16 +238,16 @@ module ArelExtensions
           collector = visit o.right, collector
           collector << "), '~', ' ')"
         else
-          collector << "LTRIM("
+          collector << 'LTRIM('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
         end
         collector
       end
 
       def visit_ArelExtensions_Nodes_Rtrim o, collector
         if o.right
-          collector << "REPLACE(REPLACE(RTRIM(REPLACE(REPLACE("
+          collector << 'REPLACE(REPLACE(RTRIM(REPLACE(REPLACE('
           collector = visit o.left, collector
           collector << ", ' ', '~'), "
           collector = visit o.right, collector
@@ -251,9 +255,9 @@ module ArelExtensions
           collector = visit o.right, collector
           collector << "), '~', ' ')"
         else
-          collector << "RTRIM("
+          collector << 'RTRIM('
           collector = visit o.left, collector
-          collector << ")"
+          collector << ')'
         end
         collector
       end
@@ -281,12 +285,12 @@ module ArelExtensions
           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 << LOADED_VISITOR::COMMA
           collector << fmt.to_s
@@ -294,7 +298,7 @@ module ArelExtensions
           collector
         else
           s = StringScanner.new o.iso_format
-          collector << "("
+          collector << '('
           sep = ''
           while !s.eos?
             collector << sep
@@ -303,10 +307,11 @@ module ArelExtensions
             when s.scan(LOADED_VISITOR::DATE_FORMAT_REGEX)
               dir = LOADED_VISITOR::DATE_FORMAT_DIRECTIVES[s.matched]
               fmt = LOADED_VISITOR::DATE_FORMAT_FORMAT[dir]
+              date_name = LOADED_VISITOR::DATE_NAME.include?(s.matched)
               collector << 'TRIM('
               collector << 'FORMAT(' if fmt
-              collector << 'STR('    if !fmt
-              collector << 'DATEPART('
+              collector << 'STR('    if !fmt && !date_name
+              collector << (date_name ? 'DATENAME(' : 'DATEPART(')
               collector << dir
               collector << LOADED_VISITOR::COMMA
               if o.time_zone
@@ -318,22 +323,22 @@ module ArelExtensions
               case o.time_zone
               when Hash
                 src_tz, dst_tz = o.time_zone.first.first, o.time_zone.first.second
-                collector << ") AT TIME ZONE "
-                collector = visit Arel::Nodes.build_quoted(src_tz), collector
-                collector << " AT TIME ZONE "
-                collector = visit Arel::Nodes.build_quoted(dst_tz), collector
+                collector << ') AT TIME ZONE '
+                collector = visit Arel.quoted(src_tz), collector
+                collector << ' AT TIME ZONE '
+                collector = visit Arel.quoted(dst_tz), collector
               when String
-                collector << ") AT TIME ZONE "
-                collector = visit Arel::Nodes.build_quoted(o.time_zone), collector
+                collector << ') AT TIME ZONE '
+                collector = visit Arel.quoted(o.time_zone), collector
               end
               collector << ')'
-              collector << ')'                                  if !fmt
+              collector << ')'                                  if !fmt && !date_name
               collector << LOADED_VISITOR::COMMA << "'#{fmt}')" if fmt
               collector << ')'
             when s.scan(/^%%/)
-              collector = visit Arel::Nodes.build_quoted('%'), collector
+              collector = visit Arel.quoted('%'), collector
             when s.scan(/[^%]+|./)
-              collector = visit Arel::Nodes.build_quoted(s.matched), collector
+              collector = visit Arel.quoted(s.matched), collector
             end
           end
           collector << ')'
@@ -342,22 +347,22 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Replace o, collector
-        collector << "REPLACE("
+        collector << 'REPLACE('
         o.expressions.each_with_index { |arg, i|
           collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_FindInSet o, collector
-        collector << "dbo.FIND_IN_SET("
+        collector << 'dbo.FIND_IN_SET('
         o.expressions.each_with_index { |arg, i|
           collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
-        collector << ")"
+        collector << ')'
         collector
       end
 
@@ -400,9 +405,9 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_AiIMatches o, collector
-        collector = visit o.left.collate(true,true), collector
+        collector = visit o.left.collate(true, true), collector
         collector << ' LIKE '
-        collector = visit o.right.collate(true,true), collector
+        collector = visit o.right.collate(true, true), collector
         if o.escape
           collector << ' ESCAPE '
           visit o.escape, collector
@@ -449,7 +454,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] != '"'
@@ -476,108 +481,109 @@ module ArelExtensions
 
       # TODO;
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "(STRING_AGG("
+        collector << '(STRING_AGG('
         collector = visit o.left, collector
         collector << Arel::Visitors::Oracle::COMMA
         collector =
           if o.separator && o.separator != 'NULL'
             visit o.separator, collector
           else
-            visit Arel::Nodes.build_quoted(','), collector
+            visit Arel.quoted(','), collector
           end
-        collector << ") WITHIN GROUP (ORDER BY "
+        collector << ') WITHIN GROUP (ORDER BY '
         if o.order.present?
-          o.order.each_with_index do |order,i|
+          o.order.each_with_index do |order, i|
             collector << Arel::Visitors::Oracle::COMMA if i != 0
             collector = visit order, collector
           end
         else
           collector = visit o.left, collector
         end
-        collector << "))"
+        collector << '))'
         collector
       end
 
       def visit_ArelExtensions_Nodes_MD5 o, collector
         collector << "LOWER(CONVERT(NVARCHAR(32),HashBytes('MD5',CONVERT(VARCHAR,"
         collector = visit o.left, collector
-        collector << ")),2))"
+        collector << ')),2))'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Cast o, collector
-        case o.as_attr
-        when :string
-          as_attr = Arel::Nodes::SqlLiteral.new('varchar')
-        when :time
-          as_attr = Arel::Nodes::SqlLiteral.new('time')
-        when :date
-          as_attr = Arel::Nodes::SqlLiteral.new('date')
-        when :datetime
-          as_attr = Arel::Nodes::SqlLiteral.new('datetime')
-        when :number,:decimal, :float
-          as_attr = Arel::Nodes::SqlLiteral.new('decimal(10,6)')
-        when :int
-          collector << "CAST(CAST("
-          collector = visit o.left, collector
-          collector << " AS decimal(10,0)) AS int)"
-          return collector
-        when :binary
-          as_attr = Arel::Nodes::SqlLiteral.new('binary')
-        else
-          as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
-        end
-        collector << "CAST("
+        as_attr =
+          case o.as_attr
+          when :string
+            'varchar'
+          when :time
+            'time'
+          when :date
+            'date'
+          when :datetime
+            'datetime'
+          when :number, :decimal, :float
+            'decimal(10,6)'
+          when :int
+            collector << 'CAST(CAST('
+            collector = visit o.left, collector
+            collector << ' AS decimal(10,0)) AS int)'
+            return collector
+          when :binary
+            'binary'
+          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
 
       def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         col = o.left.coalesce(0)
-        locale = Arel::Nodes.build_quoted(o.locale.tr('_','-'))
-        param = Arel::Nodes.build_quoted("N#{o.precision}")
-        sign = ArelExtensions::Nodes::Case.new.when(col<0).
+        locale = Arel.quoted(o.locale.tr('_', '-'))
+        param = Arel.quoted("N#{o.precision}")
+        sign = Arel.when(col < 0).
                   then('-').
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = o.flags.include?('+') || o.flags.include?(' ') ?
-              Arel::Nodes.build_quoted(1) :
-              ArelExtensions::Nodes::Case.new.when(col<0).then(1).else(0)
+              Arel.quoted(1) :
+              Arel.when(col < 0).then(1).else(0)
 
         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),
+                  Arel::Nodes::NamedFunction.new('FORMAT', [
+                    col.abs / Arel.quoted(10).pow(col.abs.log10.floor),
                     param,
                     locale
                   ]),
                   o.type,
-                  Arel::Nodes::NamedFunction.new('FORMAT',[
+                  Arel::Nodes::NamedFunction.new('FORMAT', [
                     col.abs.log10.floor,
-                    Arel::Nodes.build_quoted('N0'),
+                    Arel.quoted('N0'),
                     locale
                   ])
                 ])
           else
-            Arel::Nodes::NamedFunction.new('FORMAT',[
-                Arel::Nodes.build_quoted(col.abs),
+            Arel::Nodes::NamedFunction.new('FORMAT', [
+                Arel.quoted(col.abs),
                 param,
                 locale
               ])
           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([
@@ -587,27 +593,27 @@ 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_ArelExtensions_Nodes_Std o, collector
-        collector << (o.unbiased_estimator ? "STDEV(" : "STDEVP(")
+        collector << (o.unbiased_estimator ? 'STDEV(' : 'STDEVP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Variance o, collector
-        collector << (o.unbiased_estimator ? "VAR(" : "VARP(")
+        collector << (o.unbiased_estimator ? 'VAR(' : 'VARP(')
         visit o.left, collector
-        collector << ")"
+        collector << ')'
         collector
       end
 
 
       def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
-        collector << "dbo.LEVENSHTEIN_DISTANCE("
+        collector << 'dbo.LEVENSHTEIN_DISTANCE('
         collector = visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
         collector = visit o.right, collector
@@ -616,14 +622,14 @@ module ArelExtensions
       end
 
 
-      def visit_ArelExtensions_Nodes_JsonGet o,collector
+      def visit_ArelExtensions_Nodes_JsonGet o, collector
         collector << 'JSON_VALUE('
         collector = visit o.dict, collector
         collector << Arel::Visitors::MySQL::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