arel_extensions 2.1.0 → 2.1.1

data/lib/arel_extensions/math.rb

@@ -1,3 +1,5 @@
+require 'arel_extensions/helpers'
+
 require 'arel_extensions/nodes'
 require 'arel_extensions/nodes/function'
 require 'arel_extensions/nodes/concat'
@@ -38,21 +40,17 @@ module ArelExtensions
       when Arel::Nodes::Function
         Arel.grouping(Arel::Nodes::Addition.new self, other)
       else
-        begin
-          col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
-        rescue Exception
-          col = nil
-        end
+        col = self.respond_to?(:relation)? ArelExtensions::column_of(self.relation.table_name, self.name.to_s) : nil
         if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Addition.new(self, other))
+          Arel.grouping(Arel::Nodes::Addition.new(self, Arel::Nodes.build_quoted(other)))
         else
           arg = col.type
           if arg == :integer || (!arg)
             other = other.to_i if other.is_a?(String)
-            Arel.grouping(Arel::Nodes::Addition.new self, other)
+            Arel.grouping(Arel::Nodes::Addition.new self, Arel::Nodes.build_quoted(other))
           elsif arg == :decimal || arg == :float
             other = Arel.sql(other) if other.is_a?(String) # Arel should accept Float & BigDecimal!
-            Arel.grouping(Arel::Nodes::Addition.new self, other)
+            Arel.grouping(Arel::Nodes::Addition.new self, Arel::Nodes.build_quoted(other))
           elsif arg == :datetime || arg == :date
             ArelExtensions::Nodes::DateAdd.new [self, other]
           elsif arg == :string || arg == :text
@@ -68,41 +66,33 @@ module ArelExtensions
       case self
       when Arel::Nodes::Grouping
         if self.expr.left.is_a?(Date) || self.expr.left.is_a?(DateTime)
-          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, other])
+          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, Arel::Nodes.build_quoted(other)])
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
         end
       when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
         case self.return_type
         when :string, :text # ???
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, other)) # ??
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other))) # ??
         when :integer, :decimal, :float, :number
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
         when :date, :datetime
-          ArelExtensions::Nodes::DateSub.new [self, other]
+          ArelExtensions::Nodes::DateSub.new [self, Arel::Nodes.build_quoted(other)]
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
         end
       when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
       else
-        begin
-          col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
-        rescue Exception
-          col = nil
-        end
+        col = ArelExtensions::column_of(self.relation.table_name, self.name.to_s)
         if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
         else
           arg = col.type
           if (arg == :date || arg == :datetime)
             case other
             when Arel::Attributes::Attribute
-              begin
-                col2 = Arel::Table.engine.connection.schema_cache.columns_hash(other.relation.table_name)[other.name.to_s]
-              rescue Exception
-                col2 = nil
-              end
+              col2 = ArelExtensions::column_of(other.relation.table_name, other.name.to_s)
               if (!col2) # if the column doesn't exist in the database
                 ArelExtensions::Nodes::DateSub.new [self, other]
               else
@@ -127,7 +117,7 @@ module ArelExtensions
             when String
               Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
             else
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, other))
+              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
             end
           end
         end

data/lib/arel_extensions/nodes/case.rb

@@ -1,3 +1,5 @@
+require 'arel_extensions/helpers'
+
 module ArelExtensions
   module Nodes
     if Gem::Version.new(Arel::VERSION) < Gem::Version.new("7.1.0")
@@ -57,11 +59,7 @@ module ArelExtensions
           when Date, DateTime,Time
             :datetime
           when Arel::Attributes::Attribute
-            begin
-              Arel::Table.engine.connection.schema_cache.columns_hash(obj.relation.table_name)[obj.name.to_s].type
-            rescue Exception
-              :string
-            end
+            ArelExtensions::column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
           else
             :string
           end

data/lib/arel_extensions/nodes/date_diff.rb

@@ -117,7 +117,16 @@ module ArelExtensions
           if @date_type == :date
             v.to_i / (24*3600)
           elsif @date_type == :datetime
-            v.to_i
+            if v.parts.size == 1
+              #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
+              #       |     the value
+              #       |     |
+              #       |     |
+              #       v     v
+              v.parts.first.second
+            else
+              v.to_i
+            end
           end
         else
           v
@@ -130,7 +139,17 @@ module ArelExtensions
           if @date_type == :date
             Arel.sql('day')
           elsif @date_type == :datetime
-            Arel.sql('second')
+            res = if v.parts.size == 1
+                    #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
+                    #       |     the key
+                    #       |     |     convert symbol to string
+                    #       |     |     |   remove the plural suffix `s`
+                    #       v     v     v   v
+                    v.parts.first.first.to_s[0..-2]
+                  else
+                    'second'
+                  end
+            Arel.sql(res)
           end
         else
           if ArelExtensions::Nodes::Duration === v
@@ -141,9 +160,9 @@ module ArelExtensions
             when 'h','mn','s'
               Arel.sql('second')
             when /i\z/
-              Arel.sql(Arel::Visitors::MSSQL::DATE_MAPPING[v.left[0..-2]])
+              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
             else
-              Arel.sql(Arel::Visitors::MSSQL::DATE_MAPPING[v.left])
+              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left])
             end
           end
         end

data/lib/arel_extensions/nodes/format.rb

@@ -5,11 +5,12 @@ module ArelExtensions
     class Format < Function
       RETURN_TYPE = :string
 
-      attr_accessor :col_type, :iso_format
+      attr_accessor :col_type, :iso_format, :time_zone
 
       def initialize expr
-        col = expr.first
+        col = expr[0]
         @iso_format = convert_format(expr[1])
+        @time_zone  = Arel::Nodes.build_quoted(expr[2]) if expr[2]
         @col_type = type_of_attribute(col)
         super [col, convert_to_string_node(@iso_format)]
       end

data/lib/arel_extensions/nodes/function.rb

@@ -51,13 +51,7 @@ module ArelExtensions
       def type_of_attribute(att)
         case att
         when Arel::Attributes::Attribute
-          begin
-            if Arel::Table.engine.connection.tables.include? att.relation.table_name 
-              Arel::Table.engine.connection.schema_cache.columns_hash(att.relation.table_name)[att.name.to_s].type
-            end
-          rescue
-            att
-          end
+          ArelExtensions::column_of(att.relation.table_name, att.name.to_s)&.type || att
         when ArelExtensions::Nodes::Function
           att.return_type
           #        else

data/lib/arel_extensions/version.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = "2.1.0".freeze
+  VERSION = "2.1.1".freeze
 end

data/lib/arel_extensions/visitors/mssql.rb

@@ -2,27 +2,37 @@ module ArelExtensions
   module Visitors
     module MSSQL
 
-      Arel::Visitors::MSSQL::DATE_MAPPING = {
+      mssql_class = Arel::Visitors.constants.select { |c|
+        Arel::Visitors.const_get(c).is_a?(Class) && %i[MSSQL SQLServer].include?(c)
+      }.first
+
+      LOADED_VISITOR = Arel::Visitors.const_get(mssql_class) || Arel::Visitors.const_get('MSSQL')
+
+      LOADED_VISITOR::DATE_MAPPING = {
         'd' => 'day', 'm' => 'month', 'y' => 'year', 'wd' => 'weekday', 'w' => 'week', 'h' => 'hour', 'mn' => 'minute', 's' => 'second'
       }.freeze
 
-      Arel::Visitors::MSSQL::DATE_FORMAT_DIRECTIVES = {
+      LOADED_VISITOR::DATE_FORMAT_DIRECTIVES = {
         '%Y' => 'YYYY', '%C' => '', '%y' => 'YY', '%m' => 'MM', '%B' =>   '', '%b' => '', '%^b' => '', # year, month
         '%d' => 'DD', '%e' => '', '%j' =>   '', '%w' => 'dw', '%A' => '', # day, weekday
         '%H' => 'hh', '%k' => '', '%I' =>   '', '%l' =>   '', '%P' => '', '%p' => '', # hours
         '%M' => 'mi', '%S' => 'ss', '%L' => 'ms', '%N' => 'ns', '%z' => 'tz'
       }.freeze
 
-      Arel::Visitors::MSSQL::DATE_FORMAT_REGEX =
+      LOADED_VISITOR::DATE_FORMAT_FORMAT = {
+        'YY' => '0#', 'MM' => '0#', 'DD' => '0#', 'hh' => '0#', 'mi' => '0#', 'ss' => '0#'
+      }
+
+      LOADED_VISITOR::DATE_FORMAT_REGEX =
         Regexp.new(
-          Arel::Visitors::MSSQL::DATE_FORMAT_DIRECTIVES
+          LOADED_VISITOR::DATE_FORMAT_DIRECTIVES
             .keys
             .map{|k| Regexp.escape(k)}
             .join('|')
         ).freeze
 
       # TODO; all others... http://www.sql-server-helper.com/tips/date-formats.aspx
-      Arel::Visitors::MSSQL::DATE_CONVERT_FORMATS = {
+      LOADED_VISITOR::DATE_CONVERT_FORMATS = {
         'YYYY-MM-DD' => 120,
         'YY-MM-DD'  => 120,
         'MM/DD/YYYY' => 101,
@@ -79,7 +89,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Concat o, collector
         collector << "CONCAT("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::MSSQL::COMMA if i != 0
+          collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -102,23 +112,23 @@ module ArelExtensions
         case o.right_node_type
         when :ruby_date, :ruby_time, :date, :datetime, :time
           collector << case o.left_node_type
-                       when :ruby_time, :datetime, :time then 'DATEDIFF(second'
-                       else                                   'DATEDIFF(day'
-                       end
-          collector << Arel::Visitors::MSSQL::COMMA
+                      when :ruby_time, :datetime, :time then 'DATEDIFF(second'
+                      else                                   'DATEDIFF(day'
+                      end
+          collector << LOADED_VISITOR::COMMA
           collector = visit o.right, collector
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::COMMA
           collector = visit o.left, collector
           collector << ')'
         else
           da = ArelExtensions::Nodes::DateAdd.new([])
           collector << "DATEADD("
           collector = visit da.mssql_datepart(o.right), collector
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::COMMA
           collector << "-("
           collector = visit da.mssql_value(o.right), collector
           collector << ")"
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::COMMA
           collector = visit o.left, collector
           collector << ")"
           collector
@@ -129,9 +139,9 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector << "DATEADD("
         collector = visit o.mssql_datepart(o.right), collector
-        collector << Arel::Visitors::MSSQL::COMMA
+        collector << LOADED_VISITOR::COMMA
         collector = visit o.mssql_value(o.right), collector
-        collector << Arel::Visitors::MSSQL::COMMA
+        collector << LOADED_VISITOR::COMMA
         collector = visit o.left, collector
         collector << ")"
         collector
@@ -144,8 +154,8 @@ module ArelExtensions
           left = o.left.end_with?('i') ? o.left[0..-2] : o.left
           conv = ['h', 'mn', 's'].include?(o.left)
           collector << 'DATEPART('
-          collector << Arel::Visitors::MSSQL::DATE_MAPPING[left]
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::DATE_MAPPING[left]
+          collector << LOADED_VISITOR::COMMA
           collector << 'CONVERT(datetime,' if conv
           collector = visit o.right, collector
           collector << ')' if conv
@@ -155,20 +165,29 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Length o, collector
-        collector << "#{o.bytewise ? 'DATALENGTH' : 'LEN'}("
-        collector = visit o.expr, collector
-        collector << ")"
-        collector
+        if o.bytewise
+          collector << "(DATALENGTH("
+          collector = visit o.expr, collector
+          collector << ") / ISNULL(NULLIF(DATALENGTH(LEFT(COALESCE("
+          collector = visit o.expr, collector
+          collector << ", '#' ), 1 )), 0), 1))"
+          collector
+        else
+          collector << "LEN("
+          collector = visit o.expr, collector
+          collector << ")"
+          collector
+        end
       end
 
       def visit_ArelExtensions_Nodes_Round o, collector
         collector << "ROUND("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::MSSQL::COMMA if i != 0
+          collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
         if o.expressions.length == 1
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::COMMA
           collector << "0"
         end
         collector << ")"
@@ -178,7 +197,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Locate o, collector
         collector << "CHARINDEX("
         collector = visit o.right, collector
-        collector << Arel::Visitors::MSSQL::COMMA
+        collector << LOADED_VISITOR::COMMA
         collector = visit o.left, collector
         collector << ")"
         collector
@@ -187,28 +206,20 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Substring o, collector
         collector << 'SUBSTRING('
         collector = visit o.expressions[0], collector
-        collector << Arel::Visitors::MSSQL::COMMA
+        collector << LOADED_VISITOR::COMMA
         collector = visit o.expressions[1], collector
-        collector << Arel::Visitors::MSSQL::COMMA
+        collector << LOADED_VISITOR::COMMA
         collector = o.expressions[2] ? visit(o.expressions[2], collector) : visit(o.expressions[0].length, collector)
         collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Trim o, collector
-        if o.right
-          collector << "REPLACE(REPLACE(LTRIM(RTRIM(REPLACE(REPLACE("
-          collector = visit o.left, collector
-          collector << ", ' ', '~'), "
-          collector = visit o.right, collector
-          collector << ", ' '))), ' ', "
-          collector = visit o.right, collector
-          collector << "), '~', ' ')"
-        else
-          collector << "LTRIM(RTRIM("
-          collector = visit o.left, collector
-          collector << "))"
-        end
+        collector << 'TRIM( '
+        collector = visit o.right, collector
+        collector << " FROM "
+        collector = visit o.left, collector
+        collector << ")"
         collector
       end
 
@@ -255,12 +266,21 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Format o, collector
-        f = ArelExtensions::Visitors::strftime_to_format(o.iso_format, Arel::Visitors::MSSQL::DATE_FORMAT_DIRECTIVES)
-        if fmt = Arel::Visitors::MSSQL::DATE_CONVERT_FORMATS[f]
+        f = ArelExtensions::Visitors::strftime_to_format(o.iso_format, LOADED_VISITOR::DATE_FORMAT_DIRECTIVES)
+        if fmt = LOADED_VISITOR::DATE_CONVERT_FORMATS[f]
           collector << "CONVERT(VARCHAR(#{f.length})"
-          collector << Arel::Visitors::MSSQL::COMMA
+          collector << LOADED_VISITOR::COMMA
+          if o.time_zone
+            collector << 'CONVERT(datetime'
+            collector << LOADED_VISITOR::COMMA
+            collector << ' '
+          end
           collector = visit o.left, collector
-          collector << Arel::Visitors::MSSQL::COMMA
+          if o.time_zone
+            collector << ") AT TIME ZONE 'UTC' AT TIME ZONE "
+            collector = visit o.time_zone, collector
+          end
+          collector << LOADED_VISITOR::COMMA
           collector << fmt.to_s
           collector << ')'
           collector
@@ -272,13 +292,31 @@ module ArelExtensions
             collector << sep
             sep = ' + '
             case
-            when s.scan(Arel::Visitors::MSSQL::DATE_FORMAT_REGEX)
-              dir = Arel::Visitors::MSSQL::DATE_FORMAT_DIRECTIVES[s.matched]
-              collector << 'LTRIM(STR(DATEPART('
+            when s.scan(LOADED_VISITOR::DATE_FORMAT_REGEX)
+              dir = LOADED_VISITOR::DATE_FORMAT_DIRECTIVES[s.matched]
+              fmt = LOADED_VISITOR::DATE_FORMAT_FORMAT[dir]
+              collector << 'TRIM('
+              collector << 'FORMAT(' if fmt
+              collector << 'STR('    if !fmt
+              collector << 'DATEPART('
               collector << dir
-              collector << Arel::Visitors::MSSQL::COMMA
+              collector << LOADED_VISITOR::COMMA
+              if o.time_zone
+                collector << 'CONVERT(datetime'
+                collector << LOADED_VISITOR::COMMA
+                collector << ' '
+              end
               collector = visit o.left, collector
-              collector << ')))'
+              if o.time_zone
+                collector << ") AT TIME ZONE 'UTC' AT TIME ZONE "
+                collector = visit o.time_zone, collector
+              end
+              collector << ')'
+              collector << ')'                                  if !fmt
+              collector << LOADED_VISITOR::COMMA << "'#{fmt}')" if fmt
+              collector << ')'
+            when s.scan(/^%%/)
+              collector = visit Arel::Nodes.build_quoted('%'), collector
             when s.scan(/[^%]+|./)
               collector = visit Arel::Nodes.build_quoted(s.matched), collector
             end
@@ -291,7 +329,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Replace o, collector
         collector << "REPLACE("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::MSSQL::COMMA if i != 0
+          collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -301,7 +339,7 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_FindInSet o, collector
         collector << "dbo.FIND_IN_SET("
         o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::MSSQL::COMMA if i != 0
+          collector << LOADED_VISITOR::COMMA if i != 0
           collector = visit arg, collector
         }
         collector << ")"
@@ -387,6 +425,27 @@ module ArelExtensions
         collector
       end
 
+      alias_method(: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
+          collector << ')'
+        else
+          collector = visit o.left, collector
+        end
+        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] != '"'
+
+        collector << '"' if quote
+        collector = visit o.right, collector
+        collector << '"' if quote
+
+        collector
+      end
+
       # SQL Server does not know about REGEXP
       def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
@@ -554,7 +613,6 @@ module ArelExtensions
         collector << ')'
         collector
       end
-
     end
   end
 end

data/lib/arel_extensions/visitors/mysql.rb

@@ -209,7 +209,13 @@ module ArelExtensions
         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 = visit o.left, collector
+          if o.time_zone
+            collector << COMMA << "'UTC'" << COMMA
+            collector = visit o.time_zone, collector
+            collector << ')'
+          end
           collector << COMMA
           collector = visit Arel::Nodes.build_quoted(fmt), collector
           collector << ")"

data/lib/arel_extensions/visitors/oracle.rb

@@ -447,7 +447,12 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Format o, collector
         fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
         collector << "TO_CHAR("
+        collector << "CAST(" if o.time_zone
         collector = visit o.left, collector
+        if o.time_zone
+          collector << " as timestamp) at time zone "
+          collector = visit o.time_zone, collector
+        end
         collector << COMMA
         collector = visit Arel::Nodes.build_quoted(fmt), collector
         collector << ")"
@@ -517,7 +522,7 @@ module ArelExtensions
         if element.is_a?(Time)
           ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
         elsif element.is_a?(Arel::Attributes::Attribute)
-          col = Arel::Table.engine.connection.schema_cache.columns_hash(element.relation.table_name)[element.name.to_s]
+          col = ArelExtensions::column_of(element.relation.table_name, element.name.to_s)
           if col && (col.type == :time)
             ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
           else

data/lib/arel_extensions/visitors/postgresql.rb

@@ -90,11 +90,11 @@ module ArelExtensions
 
         # 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] != '"'
-        
+
         collector << '"' if quote
         collector = visit o.right, collector
         collector << '"' if quote
-        
+
         collector
       end
 
@@ -176,6 +176,10 @@ module ArelExtensions
         fmt = ArelExtensions::Visitors::strftime_to_format(o.iso_format, DATE_FORMAT_DIRECTIVES)
         collector << "TO_CHAR("
         collector = visit o.left, collector
+        if o.time_zone
+          collector << " AT TIME ZONE "
+          collector = visit o.time_zone, collector
+        end
         collector << COMMA
         collector = visit Arel::Nodes.build_quoted(fmt), collector
         collector << ")"
@@ -289,9 +293,9 @@ module ArelExtensions
               return collector
             end
         end
-        collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM "
+        collector << "EXTRACT(#{DATE_MAPPING[o.left]} FROM CAST("
         collector = visit o.right, collector
-        collector << ")"
+        collector << " AS TIMESTAMP WITH TIME ZONE))"
         collector << " * (INTERVAL '1' #{interval})" if interval && o.with_interval
         collector
       end
@@ -374,7 +378,7 @@ module ArelExtensions
         when :number, :decimal, :float
           Arel::Nodes::SqlLiteral.new('numeric')
         when :datetime
-          Arel::Nodes::SqlLiteral.new('timestamp')
+          Arel::Nodes::SqlLiteral.new('timestamp with time zone')
         when :date
           Arel::Nodes::SqlLiteral.new('date')
         when :binary

data/lib/arel_extensions/visitors/sqlite.rb

@@ -1,3 +1,5 @@
+require 'arel_extensions/helpers'
+
 module ArelExtensions
   module Visitors
     class Arel::Visitors::SQLite
@@ -327,7 +329,7 @@ module ArelExtensions
         if element.is_a?(Time)
           return Arel::Nodes::NamedFunction.new('STRFTIME',[element, '%H:%M:%S'])
         elsif element.is_a?(Arel::Attributes::Attribute)
-          col = Arel::Table.engine.connection.schema_cache.columns_hash(element.relation.table_name)[element.name.to_s]
+          col = ArelExtensions::column_of(element.relation.table_name, element.name.to_s)
           if col && (col.type == :time)
             return Arel::Nodes::NamedFunction.new('STRFTIME',[element, '%H:%M:%S'])
           else
@@ -379,9 +381,10 @@ module ArelExtensions
         else
           collector = visit o.left, collector
         end
-        collector << " AS \""
+        sep = o.right.size > 1 && o.right[0] == '"' && o.right[-1] == '"' ? '' : '"'
+        collector << " AS #{sep}"
         collector = visit o.right, collector
-        collector << "\""
+        collector << "#{sep}"
         collector
       end
 

data/lib/arel_extensions.rb

@@ -77,7 +77,17 @@ require 'arel_extensions/nodes/soundex'
 require 'arel_extensions/nodes/cast'
 require 'arel_extensions/nodes/json'
 
-
+# It seems like the code in lib/arel_extensions/visitors.rb that is supposed
+# to inject ArelExtension is not enough. Different versions of the sqlserver
+# adapter behave differently. It doesn't always proc, so we added this for
+# coverage.
+if defined?(Arel::Visitors::SQLServer)
+  Arel::Visitors.const_set('MSSQL', Arel::Visitors::SQLServer)
+  require 'arel_extensions/visitors/mssql'
+  class Arel::Visitors::SQLServer
+    include ArelExtensions::Visitors::MSSQL
+  end
+end
 
 module Arel
   def self.rand