activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/lib/arjdbc/mssql/column.rb

@@ -0,0 +1,182 @@
+module ArJdbc
+  module MSSQL
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /sqlserver|tds|Microsoft SQL/i, lambda { |config, column| column.extend(Column) } ]
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      def self.included(base)
+        # NOTE: assumes a standalone MSSQLColumn class
+        class << base; include Cast; end
+      end
+
+      include LockMethods
+
+      attr_accessor :identity, :special
+      # @deprecated
+      alias_method :is_special, :special
+
+      # @override
+      def simplified_type(field_type)
+        case field_type
+        when /int|bigint|smallint|tinyint/i           then :integer
+        when /numeric/i                               then (@scale.nil? || @scale == 0) ? :integer : :decimal
+        when /float|double|money|real|smallmoney/i    then :decimal
+        when /datetime|smalldatetime/i                then :datetime
+        when /timestamp/i                             then :timestamp
+        when /time/i                                  then :time
+        when /date/i                                  then :date
+        when /text|ntext|xml/i                        then :text
+        when /binary|image|varbinary/i                then :binary
+        when /char|nchar|nvarchar|string|varchar/i    then (@limit == 1073741823 ? (@limit = nil; :text) : :string)
+        when /bit/i                                   then :boolean
+        when /uniqueidentifier/i                      then :string
+        else
+          super
+        end
+      end
+
+      # @override
+      def default_value(value)
+        return $1 if value =~ /^\(N?'(.*)'\)$/
+        value
+      end
+
+      # @override
+      def type_cast(value)
+        return nil if value.nil?
+        case type
+        when :integer then value.delete('()').to_i rescue unquote(value).to_i rescue value ? 1 : 0
+        when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
+        when :decimal   then self.class.value_to_decimal(unquote(value))
+        when :date      then self.class.string_to_date(value)
+        when :datetime  then self.class.string_to_time(value)
+        when :timestamp then self.class.string_to_time(value)
+        when :time      then self.class.string_to_dummy_time(value)
+        when :boolean   then value == true || (value =~ /^t(rue)?$/i) == 0 || unquote(value) == '1'
+        when :binary    then unquote value
+        else value
+        end
+      end
+
+      # @override
+      def extract_limit(sql_type)
+        case sql_type
+        when /^smallint/i
+          2
+        when /^int/i
+          4
+        when /^bigint/i
+          8
+        when /\(max\)/, /decimal/, /numeric/
+          nil
+        when /text|ntext|xml|binary|image|varbinary|bit/
+          nil
+        else
+          super
+        end
+      end
+
+      private
+
+      def is_utf8?
+        !!( sql_type =~ /nvarchar|ntext|nchar/i )
+      end
+
+      def unquote(value)
+        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
+      end
+
+      # @deprecated no longer used
+      def cast_to_time(value)
+        return value if value.is_a?(Time)
+        DateTime.parse(value).to_time rescue nil
+      end
+
+      # @deprecated no longer used
+      def cast_to_date(value)
+        return value if value.is_a?(Date)
+        return Date.parse(value) rescue nil
+      end
+
+      # @deprecated no longer used
+      def cast_to_datetime(value)
+        if value.is_a?(Time)
+          if value.year != 0 and value.month != 0 and value.day != 0
+            return value
+          else
+            return Time.mktime(2000, 1, 1, value.hour, value.min, value.sec) rescue nil
+          end
+        end
+        if value.is_a?(DateTime)
+          begin
+            # Attempt to convert back to a Time, but it could fail for dates significantly in the past/future.
+            return Time.mktime(value.year, value.mon, value.day, value.hour, value.min, value.sec)
+          rescue ArgumentError
+            return value
+          end
+        end
+
+        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
+
+        return value.is_a?(Date) ? value : nil
+      end
+
+      module Cast
+
+        def string_to_date(value)
+          return value unless value.is_a?(String)
+          return nil if value.empty?
+
+          date = fast_string_to_date(value)
+          date ? date : Date.parse(value) rescue nil
+        end
+
+        def string_to_time(value)
+          return value unless value.is_a?(String)
+          return nil if value.empty?
+
+          fast_string_to_time(value) ||
+            begin
+              DateTime.parse(value).to_time
+            rescue nil
+            end
+        end
+
+        ISO_TIME = /\A(\d\d)\:(\d\d)\:(\d\d)(\.\d+)?\z/
+
+        def string_to_dummy_time(value)
+          return value unless value.is_a?(String)
+          return nil if value.empty?
+
+          if value =~ ISO_TIME # "12:34:56.1234560"
+            microsec = ($4.to_f * 1_000_000).round.to_i
+            new_time 2000, 1, 1, $1.to_i, $2.to_i, $3.to_i, microsec
+          else
+            super(value)
+          end
+        end
+
+        # @private
+        def string_to_binary(value)
+          # this will only allow the adapter to insert binary data with a length
+          # of 7K or less because of a SQL Server statement length policy ...
+          '' # "0x#{value.unpack("H*")[0]}"
+        end
+
+        def binary_to_string(value)
+          if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
+            value = value.force_encoding(Encoding::ASCII_8BIT)
+          end
+          value =~ /[^[:xdigit:]]/ ? value : [value].pack('H*')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/mssql/connection_methods.rb

@@ -1,5 +1,14 @@
 ArJdbc::ConnectionMethods.module_eval do
+
+  # Default connection method for MS-SQL adapter (`adapter: mssql`),
+  # uses the (open-source) jTDS driver.
+  # If you'd like to use the "official" MS's SQL-JDBC driver, it's preferable
+  # to use the {#sqlserver_connection} method (set `adapter: sqlserver`).
   def mssql_connection(config)
+    if config[:driver] =~ /SQLServerDriver$/ || config[:url] =~ /^jdbc:sqlserver:/
+      return sqlserver_connection(config)
+    end
+
     begin
       require 'jdbc/jtds'
       # NOTE: the adapter has only support for working with the
@@ -9,7 +18,7 @@ ArJdbc::ConnectionMethods.module_eval do
       raise e unless e.message.to_s.index('no such file to load')
     end
 
-    config[:host] ||= "localhost"
+    config[:host] ||= 'localhost'
     config[:port] ||= 1433
     config[:driver] ||= defined?(::Jdbc::JTDS.driver_name) ? ::Jdbc::JTDS.driver_name : 'net.sourceforge.jtds.jdbc.Driver'
     config[:adapter_spec] ||= ::ArJdbc::MSSQL
@@ -29,10 +38,34 @@ ArJdbc::ConnectionMethods.module_eval do
     end
 
     unless config[:domain]
-      config[:username] ||= "sa"
-      config[:password] ||= ""
+      config[:username] ||= 'sa'
+      config[:password] ||= ''
     end
     jdbc_connection(config)
   end
   alias_method :jdbcmssql_connection, :mssql_connection
-end
+
+  # @note Assumes SQLServer SQL-JDBC driver on the class-path.
+  def sqlserver_connection(config)
+    config[:host] ||= 'localhost'
+    config[:driver] ||= 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
+    config[:adapter_spec] ||= ::ArJdbc::MSSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
+    config[:connection_alive_sql] ||= 'SELECT 1'
+
+    config[:url] ||= begin
+      url = "jdbc:sqlserver://#{config[:host]}"
+      url << ( config[:port] ? ":#{config[:port]};" : ';' )
+      url << "databaseName=#{config[:database]};" if config[:database]
+      url << "instanceName=#{config[:instance]};" if config[:instance]
+      app = config[:appname] || config[:application]
+      url << "applicationName=#{app};" if app
+      isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
+      url << "integratedSecurity=#{isc};" unless isc.nil?
+      url
+    end
+    jdbc_connection(config)
+  end
+  alias_method :jdbcsqlserver_connection, :sqlserver_connection
+
+end

data/lib/arjdbc/mssql/explain_support.rb

@@ -3,24 +3,15 @@ require 'active_support/core_ext/string'
 module ArJdbc
   module MSSQL
     module ExplainSupport
-      
+
       DISABLED = Java::JavaLang::Boolean.getBoolean('arjdbc.mssql.explain_support.disabled')
-      
-      def supports_explain?
-        ! DISABLED
-      end
+
+      def supports_explain?; ! DISABLED; end
 
       def explain(arel, binds = [])
         return if DISABLED
         sql = to_sql(arel)
-        result = with_showplan_on do 
-          # exec_query(sql, 'EXPLAIN', binds)
-          raw_result = execute(sql, 'EXPLAIN', binds)
-          # TODO we should refactor to exec_query once it returns Result :
-          keys = raw_result[0] ? raw_result[0].keys : {}
-          rows = raw_result.map { |hash| hash.values }
-          ActiveRecord::Result.new(keys, rows)
-        end
+        result = with_showplan_on { exec_query(sql, 'EXPLAIN', binds) }
         PrinterTable.new(result).pp
       end
 
@@ -37,12 +28,13 @@ module ArJdbc
         option = 'SHOWPLAN_TEXT'
         execute "SET #{option} #{enable ? 'ON' : 'OFF'}"
       rescue Exception => e
-        raise ActiveRecord::ActiveRecordError, "#{option} could not be turned" + 
+        raise ActiveRecord::ActiveRecordError, "#{option} could not be turned" +
               " #{enable ? 'ON' : 'OFF'} (check SHOWPLAN permissions) due : #{e.inspect}"
       end
-      
-      class PrinterTable # :nodoc:
-        
+
+      # @private
+      class PrinterTable
+
         cattr_accessor :max_column_width, :cell_padding
         self.max_column_width = 50
         self.cell_padding = 1
@@ -64,7 +56,7 @@ module ArJdbc
             pp << build_cells(row)
           end
           pp << @separator
-          pp.join("\n") + "\n"
+          pp.join("\n") << "\n"
         end
 
         private
@@ -81,7 +73,7 @@ module ArJdbc
         end
 
         def build_separator
-          '+' + @widths.map {|w| '-' * (w + (cell_padding * 2))}.join('+') + '+'
+          '+' << @widths.map {|w| '-' * (w + (cell_padding * 2))}.join('+') << '+'
         end
 
         def build_cells(items)
@@ -99,9 +91,9 @@ module ArJdbc
           else item.to_s.truncate(max_column_width)
           end
         end
-        
+
       end
-      
+
     end
   end
 end

data/lib/arjdbc/mssql/limit_helpers.rb

@@ -1,70 +1,71 @@
 module ArJdbc
   module MSSQL
     module LimitHelpers
-      
-      FIND_SELECT = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im # :nodoc:
-      
+
+      # @private
+      FIND_SELECT = /\b(SELECT(\s+DISTINCT)?)\b(.*)/mi
+
       module SqlServerReplaceLimitOffset
-        
+
         module_function
-        
+
         def replace_limit_offset!(sql, limit, offset, order)
           if limit
             offset ||= 0
-            start_row = offset + 1
-            end_row = offset + limit.to_i
-            _, select, rest_of_query = FIND_SELECT.match(sql).to_a
-            rest_of_query.strip!
-            if rest_of_query[0...1] == "1" && rest_of_query !~ /1 AS/i
-              rest_of_query[0] = "*"
+            start_row, end_row = offset + 1, offset + limit.to_i
+
+            if match = FIND_SELECT.match(sql)
+              select, distinct, rest_of_query = match[1], match[2], match[3]
+              rest_of_query.strip!
             end
-            if rest_of_query[0...1] == "*"
+            rest_of_query[0] = '*' if rest_of_query[0...1] == '1' && rest_of_query !~ /1 AS/i
+            if rest_of_query[0...1] == '*'
               from_table = Utils.get_table_name(rest_of_query, true)
-              rest_of_query = from_table + '.' + rest_of_query
+              rest_of_query = "#{from_table}.#{rest_of_query}"
             end
-            new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, #{rest_of_query}"
-            new_sql << ") AS t WHERE t._row_num BETWEEN #{start_row} AND #{end_row}"
+
+            if distinct # select =~ /DISTINCT/i
+              order = order.gsub(/([a-z0-9_])+\./, 't.')
+              new_sql = "SELECT t.* FROM "
+              new_sql << "( SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, t.* FROM (#{select} #{rest_of_query}) AS t ) AS t"
+              new_sql << " WHERE t._row_num BETWEEN #{start_row} AND #{end_row}"
+            else
+              new_sql = "#{select} t.* FROM "
+              new_sql << "( SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, #{rest_of_query} ) AS t"
+              new_sql << " WHERE t._row_num BETWEEN #{start_row} AND #{end_row}"
+            end
+
             sql.replace(new_sql)
           end
           sql
         end
-        
-      end
 
-      module SqlServerAddLimitOffset
-        
-        def add_limit_offset!(sql, options)
-          if options[:limit]
-            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
-            sql.sub!(/ ORDER BY.*$/i, '')
-            SqlServerReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
-          end
-        end
-        
       end
-      
+
       module SqlServer2000ReplaceLimitOffset
-        
+
         module_function
-        
+
         def replace_limit_offset!(sql, limit, offset, order)
           if limit
             offset ||= 0
             start_row = offset + 1
             end_row = offset + limit.to_i
-            _, select, rest_of_query = FIND_SELECT.match(sql).to_a
-			
+            
+            if match = FIND_SELECT.match(sql)
+              select, distinct, rest_of_query = match[1], match[2], match[3]
+            end
             #need the table name for avoiding amiguity
             table_name  = Utils.get_table_name(sql, true)
             primary_key = get_primary_key(order, table_name)
-			
+
             #I am not sure this will cover all bases.  but all the tests pass
             if order[/ORDER/].nil?
               new_order = "ORDER BY #{order}, [#{table_name}].[#{primary_key}]" if order.index("#{table_name}.#{primary_key}").nil?
             else
               new_order ||= order
             end
-			
+
             if (start_row == 1) && (end_row ==1)
               new_sql = "#{select} TOP 1 #{rest_of_query} #{new_order}"
               sql.replace(new_sql)
@@ -94,7 +95,7 @@ module ArJdbc
 
         # Split the rest_of_query into chunks based on regexs (applied from end of string to the beginning)
         # The result is an array of regexs.size+1 elements (the last one being the remaining once everything was chopped away)
-        def split_sql rest_of_query, *regexs
+        def split_sql(rest_of_query, *regexs)
           results = Array.new
 
           regexs.each do |regex|
@@ -112,7 +113,7 @@ module ArJdbc
 
           results
         end
-        
+
         def get_primary_key(order, table_name) # table_name might be quoted
           if order =~ /(\w*id\w*)/i
             $1
@@ -124,17 +125,53 @@ module ArJdbc
         end
 
         private
-        
+
         if ActiveRecord::VERSION::MAJOR >= 3
           def descendants; ::ActiveRecord::Base.descendants; end
         else
           def descendants; ::ActiveRecord::Base.send(:subclasses) end
         end
-        
+
+      end
+
+      private
+
+      if ::ActiveRecord::VERSION::MAJOR < 3
+
+        def setup_limit_offset!(version = nil)
+          if version.to_s == '2000' || sqlserver_2000?
+            extend SqlServer2000AddLimitOffset
+          else
+            extend SqlServerAddLimitOffset
+          end
+        end
+
+      else
+
+        def setup_limit_offset!(version = nil); end
+
       end
 
+      # @private
+      module SqlServerAddLimitOffset
+
+        # @note Only needed with (non-AREL) ActiveRecord **2.3**.
+        # @see Arel::Visitors::SQLServer
+        def add_limit_offset!(sql, options)
+          if options[:limit]
+            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
+            sql.sub!(/ ORDER BY.*$/i, '')
+            SqlServerReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
+          end
+        end
+
+      end if ::ActiveRecord::VERSION::MAJOR < 3
+
+      # @private
       module SqlServer2000AddLimitOffset
-        
+
+        # @note Only needed with (non-AREL) ActiveRecord **2.3**.
+        # @see Arel::Visitors::SQLServer
         def add_limit_offset!(sql, options)
           if options[:limit]
             order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
@@ -142,9 +179,9 @@ module ArJdbc
             SqlServer2000ReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
           end
         end
-        
-      end
-      
+
+      end if ::ActiveRecord::VERSION::MAJOR < 3
+
     end
   end
 end