tgbyte-activerecord-jdbc-adapter 1.2.2.2

data/lib/arjdbc/jdbc/missing_functionality_helper.rb

@@ -0,0 +1,88 @@
+module ArJdbc
+  module MissingFunctionalityHelper
+    #Taken from SQLite adapter
+
+    def alter_table(table_name, options = {}) #:nodoc:
+      table_name = table_name.to_s.downcase
+      altered_table_name = "altered_#{table_name}"
+      caller = lambda {|definition| yield definition if block_given?}
+
+      transaction do
+        # A temporary table might improve performance here, but
+        # it doesn't seem to maintain indices across the whole move.
+        move_table(table_name, altered_table_name,
+          options)
+        move_table(altered_table_name, table_name, &caller)
+      end
+    end
+
+    def move_table(from, to, options = {}, &block) #:nodoc:
+      copy_table(from, to, options, &block)
+      drop_table(from)
+    end
+
+    def copy_table(from, to, options = {}) #:nodoc:
+      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+      create_table(to, options) do |definition|
+        @definition = definition
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+            (options[:rename][column.name] ||
+             options[:rename][column.name.to_sym] ||
+             column.name) : column.name
+
+          @definition.column(column_name, column.type,
+            :limit => column.limit, :default => column.default,
+            :precision => column.precision, :scale => column.scale,
+            :null => column.null)
+        end
+        @definition.primary_key(primary_key(from)) if primary_key(from)
+        yield @definition if block_given?
+      end
+
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+        @definition.columns.map {|column| column.name},
+        options[:rename] || {})
+    end
+
+    def copy_table_indexes(from, to, rename = {}) #:nodoc:
+      indexes(from).each do |index|
+        name = index.name.downcase
+        if to == "altered_#{from}"
+          name = "temp_#{name}"
+        elsif from == "altered_#{to}"
+          name = name[5..-1]
+        end
+
+        to_column_names = columns(to).map(&:name)
+        columns = index.columns.map {|c| rename[c] || c }.select do |column|
+          to_column_names.include?(column)
+        end
+
+        unless columns.empty?
+          # index name can't be the same
+          opts = { :name => name.gsub(/(_?)(#{from})_/, "\\1#{to}_") }
+          opts[:unique] = true if index.unique
+          add_index(to, columns, opts)
+        end
+      end
+    end
+
+    def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
+      column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
+      rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
+      from_columns = columns(from).collect {|col| col.name}
+      columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
+      quoted_columns = columns.map { |col| quote_column_name(col) } * ','
+
+      quoted_to = quote_table_name(to)
+      execute("SELECT * FROM #{quote_table_name(from)}").each do |row|
+        sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
+        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+        sql << ')'
+        execute sql
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -0,0 +1,28 @@
+module ArJdbc
+  module QuotedPrimaryKeyExtension
+    def self.extended(base)
+      #       Rails 3 method           Rails 2 method
+      meth = [:arel_attributes_values, :attributes_with_quotes].detect do |m|
+        base.private_instance_methods.include?(m.to_s)
+      end
+      pk_hash_key = "self.class.primary_key"
+      pk_hash_value = '"?"'
+      if meth == :arel_attributes_values
+        pk_hash_key = "self.class.arel_table[#{pk_hash_key}]"
+        pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
+      end
+      if meth
+        base.module_eval <<-PK, __FILE__, __LINE__
+          alias :#{meth}_pre_pk :#{meth}
+          def #{meth}(include_primary_key = true, *args) #:nodoc:
+            aq = #{meth}_pre_pk(include_primary_key, *args)
+            if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
+              aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?
+            end
+            aq
+          end
+        PK
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails/railtie'
+
+module ::ArJdbc
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../rake_tasks.rb', __FILE__)
+    end
+  end
+end

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -0,0 +1,10 @@
+if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
+  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
+  if Rake.application.lookup("db:create")
+    # rails tasks already defined; load the override tasks now
+    load jdbc_rakefile
+  else
+    # rails tasks not loaded yet; load as an import
+    Rake.application.add_import(jdbc_rakefile)
+  end
+end

data/lib/arjdbc/jdbc/require_driver.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # load a JDBC driver library/gem, failing silently. If failed, trust
+  # that the driver jar is already present through some other means
+  def jdbc_require_driver(path, gem_name = nil)
+    gem_name ||= path.sub('/', '-')
+    2.times do
+      begin
+        require path
+        break
+      rescue LoadError
+        require 'rubygems'
+        begin; gem gem_name; rescue LoadError; end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -0,0 +1,126 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # I want to use JDBC's DatabaseMetaData#getTypeInfo to choose the best native types to
+    # use for ActiveRecord's Adapter#native_database_types in a database-independent way,
+    # but apparently a database driver can return multiple types for a given
+    # java.sql.Types constant.  So this type converter uses some heuristics to try to pick
+    # the best (most common) type to use.  It's not great, it would be better to just
+    # delegate to each database's existin AR adapter's native_database_types method, but I
+    # wanted to try to do this in a way that didn't pull in all the other adapters as
+    # dependencies.  Suggestions appreciated.
+    class JdbcTypeConverter
+      # The basic ActiveRecord types, mapped to an array of procs that are used to #select
+      # the best type.  The procs are used as selectors in order until there is only one
+      # type left.  If all the selectors are applied and there is still more than one
+      # type, an exception will be raised.
+      AR_TO_JDBC_TYPES = {
+        :string      => [ lambda {|r| Jdbc::Types::VARCHAR == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^varchar/i},
+                          lambda {|r| r['type_name'] =~ /^varchar$/i},
+                          lambda {|r| r['type_name'] =~ /varying/i}],
+        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
+                          lambda {|r| r['type_name'] =~ /sub_type 1$/i}, # For FireBird
+                          lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
+                          lambda {|r| r['type_name'] =~ /^character large object$/i},
+                          lambda {|r| r['sql_data_type'] == 2005}],
+        :integer     => [ lambda {|r| Jdbc::Types::INTEGER == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i},
+                          lambda {|r| r['type_name'] =~ /^int4$/i},
+                          lambda {|r| r['type_name'] =~ /^int$/i}],
+        :decimal     => [ lambda {|r| Jdbc::Types::DECIMAL == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^numeric$/i},
+                          lambda {|r| r['type_name'] =~ /^number$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '38'},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::DECIMAL}],
+        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE, Jdbc::Types::REAL].include?(r['data_type'].to_i)},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::REAL}, #Prefer REAL to DOUBLE for Postgresql
+                          lambda {|r| r['type_name'] =~ /^float/i},
+                          lambda {|r| r['type_name'] =~ /^double$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '15'}],
+        :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^time$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},  # For Informix
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^date$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver3
+        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^blob/i},
+                          lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
+                          lambda {|r| r['type_name'] =~ /^varbinary$/i}, # We want this sucker for Mimer
+                          lambda {|r| r['type_name'] =~ /^binary$/i}, ],
+        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^bool/i},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::BIT},
+                          lambda {|r| r['type_name'] =~ /^tinyint$/i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i}]
+      }
+
+      def initialize(types)
+        @types = types
+        @types.each {|t| t['type_name'] ||= t['local_type_name']} # Sybase driver seems to want 'local_type_name'
+      end
+
+      def choose_best_types
+        type_map = {}
+        @types.each do |row|
+          name = row['type_name'].downcase
+          k = name.to_sym
+          type_map[k] = { :name => name }
+          set_limit_to_nonzero_precision(type_map[k], row)
+        end
+
+        AR_TO_JDBC_TYPES.keys.each do |k|
+          typerow = choose_type(k)
+          type_map[k] = { :name => typerow['type_name'].downcase }
+          case k
+          when :integer, :string, :decimal
+            set_limit_to_nonzero_precision(type_map[k], typerow)
+          when :boolean
+            type_map[k][:limit] = 1
+          end
+        end
+        type_map
+      end
+
+      def choose_type(ar_type)
+        procs = AR_TO_JDBC_TYPES[ar_type]
+        types = @types
+        procs.each do |p|
+          new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
+          new_types = new_types.select(&p)
+          new_types = new_types.inject([]) do |typs,t|
+            typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
+            typs
+          end
+          return new_types.first if new_types.length == 1
+          types = new_types if new_types.length > 0
+        end
+        raise "unable to choose type for #{ar_type} from:\n#{types.collect{|t| t['type_name']}.inspect}"
+      end
+
+      def set_limit_to_nonzero_precision(map, row)
+        if row['precision'] && row['precision'].to_i > 0
+          map[:limit] = row['precision'].to_i
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/mimer.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/mimer/adapter'

data/lib/arjdbc/mimer/adapter.rb

@@ -0,0 +1,142 @@
+module ArJdbc
+  module Mimer
+    def self.extended(mod)
+      require 'arjdbc/jdbc/quoted_primary_key'
+      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "INTEGER NOT NULL PRIMARY KEY"
+      tp[:boolean][:limit] = nil
+      tp[:string][:limit] = 255
+      tp[:binary] = {:name => "BINARY VARYING", :limit => 4096}
+      tp[:text] = {:name => "VARCHAR", :limit => 4096}
+      tp[:datetime] = { :name => "TIMESTAMP" }
+      tp[:timestamp] = { :name => "TIMESTAMP" }
+      tp[:time] = { :name => "TIMESTAMP" }
+      tp[:date] = { :name => "TIMESTAMP" }
+      tp
+    end
+
+    def default_sequence_name(table, column) #:nodoc:
+      "#{table}_seq"
+    end
+
+    def create_table(name, options = {}) #:nodoc:
+      super(name, options)
+      execute "CREATE SEQUENCE #{name}_seq" unless options[:id] == false
+    end
+
+    def drop_table(name, options = {}) #:nodoc:
+      super(name) rescue nil
+      execute "DROP SEQUENCE #{name}_seq" rescue nil
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
+    end
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{quote(default)}"
+    end
+
+    def remove_index(table_name, options = {}) #:nodoc:
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) #:nodoc:
+      if pk.nil? # Who called us? What does the sql look like? No idea!
+        execute sql, name, binds
+      elsif id_value # Pre-assigned id
+        log(sql, name) { @connection.execute_insert sql,pk }
+      else # Assume the sql contains a bind-variable for the id
+        id_value = select_one("SELECT NEXT_VALUE OF #{sequence_name} AS val FROM MIMER.ONEROW")['val']
+        log(sql, name) {
+          execute_prepared_insert(sql,id_value)
+        }
+      end
+      id_value
+    end
+
+    def execute_prepared_insert(sql, id)
+      @stmts ||= {}
+      @stmts[sql] ||= @connection.ps(sql)
+      stmt = @stmts[sql]
+      stmt.setLong(1,id)
+      stmt.executeUpdate
+      id
+    end
+
+    def quote(value, column = nil) #:nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      if String === value && column && column.type == :binary
+        return "X'#{quote_string(value.unpack("C*").collect {|v| v.to_s(16)}.join)}'"
+      end
+      case value
+      when String
+        %Q{'#{quote_string(value)}'}
+      when NilClass
+        'NULL'
+      when TrueClass
+        '1'
+      when FalseClass
+        '0'
+      when Numeric
+        value.to_s
+      when Date, Time
+        %Q{TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
+      else
+        %Q{'#{quote_string(value.to_yaml)}'}
+      end
+    end
+
+    def quoted_true
+      '1'
+    end
+
+    def quoted_false
+      '0'
+    end
+
+    def add_limit_offset!(sql, options) # :nodoc:
+      @limit = options[:limit]
+      @offset = options[:offset]
+    end
+
+    def select_all(sql, name = nil, binds = [])
+      @offset ||= 0
+      if !@limit || @limit == -1
+        range = @offset..-1
+      else
+        range = @offset...(@offset+@limit)
+      end
+      select(sql, name, binds)[range]
+    ensure
+      @limit = @offset = nil
+    end
+
+    def select_one(sql, name = nil)
+      @offset ||= 0
+      select(sql, name)[@offset]
+    ensure
+      @limit = @offset = nil
+    end
+
+    def _execute(sql, name = nil)
+        if sql =~ /^select/i
+          @offset ||= 0
+          if !@limit || @limit == -1
+            range = @offset..-1
+          else
+            range = @offset...(@offset+@limit)
+          end
+          @connection.execute_query(sql)[range]
+        else
+          @connection.execute_update(sql)
+        end
+    ensure
+      @limit = @offset = nil
+    end
+  end
+end

data/lib/arjdbc/mssql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/jtds', 'jdbc-mssql'
+require 'arjdbc/mssql/connection_methods'
+require 'arjdbc/mssql/adapter'

data/lib/arjdbc/mssql/adapter.rb

@@ -0,0 +1,477 @@
+require 'arjdbc/mssql/tsql_helper'
+require 'arjdbc/mssql/limit_helpers'
+require 'arjdbc/mssql/lock_helpers'
+require 'strscan'
+
+module ::ArJdbc
+  module MsSQL
+    include TSqlMethods
+    include LimitHelpers
+
+    def self.extended(mod)
+      unless defined?(@lob_callback_added)
+        ActiveRecord::Base.class_eval do
+          def after_save_with_mssql_lob
+            self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |c|
+              value = self[c.name]
+              if coder = self.class.serialized_attributes[c.name]
+                if coder.respond_to?(:dump)
+                  value = coder.dump(value)
+                else
+                  value = value.to_yaml
+                end
+              end
+              next if value.nil?  || (value == '')
+
+              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            end
+          end
+        end
+
+        ActiveRecord::Base.after_save :after_save_with_mssql_lob
+        @lob_callback_added = true
+      end
+      mod.add_version_specific_add_limit_offset
+    end
+
+    def self.column_selector
+      [/sqlserver|tds|Microsoft SQL/i, lambda {|cfg,col| col.extend(::ArJdbc::MsSQL::Column)}]
+    end
+
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::MssqlJdbcConnection
+    end
+
+    def self.arel2_visitors(config)
+      require 'arel/visitors/sql_server'
+      visitor_class = config[:sqlserver_version] == "2000" ? ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
+      {}.tap {|v| %w(mssql sqlserver jdbcmssql).each {|x| v[x] = visitor_class } }
+    end
+
+    def sqlserver_version
+      @sqlserver_version ||= select_value("select @@version")[/Microsoft SQL Server\s+(\d{4})/, 1]
+    end
+
+    def add_version_specific_add_limit_offset
+      config[:sqlserver_version] = version = sqlserver_version
+      if version == "2000"
+        extend LimitHelpers::SqlServer2000AddLimitOffset
+      else
+        extend LimitHelpers::SqlServerAddLimitOffset
+      end
+    end
+
+    def modify_types(tp) #:nodoc:
+      super(tp)
+      tp[:string] = {:name => "NVARCHAR", :limit => 255}
+      if sqlserver_version == "2000"
+        tp[:text] = {:name => "NTEXT"}
+      else
+        tp[:text] = {:name => "NVARCHAR(MAX)"}
+      end
+      tp
+    end
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+      # MSSQL's NVARCHAR(n | max) column supports either a number between 1 and
+      # 4000, or the word "MAX", which corresponds to 2**30-1 UCS-2 characters.
+      #
+      # It does not accept NVARCHAR(1073741823) here, so we have to change it
+      # to NVARCHAR(MAX), even though they are logically equivalent.
+      #
+      # MSSQL Server 2000 is skipped here because I don't know how it will behave.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/ms186939.aspx
+      if type.to_s == 'string' and limit == 1073741823 and sqlserver_version != "2000"
+        'NVARCHAR(MAX)'
+      elsif %w( boolean date datetime ).include?(type.to_s)
+        super(type)   # cannot specify limit/precision/scale with these types
+      else
+        super
+      end
+    end
+
+    module Column
+      include LockHelpers::SqlServerAddLock
+
+      attr_accessor :identity, :is_special
+
+      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
+
+      def default_value(value)
+        return $1 if value =~ /^\(N?'(.*)'\)$/
+        value
+      end
+
+      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 :datetime  then cast_to_datetime(value)
+        when :timestamp then cast_to_time(value)
+        when :time      then cast_to_time(value)
+        when :date      then cast_to_date(value)
+        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or unquote(value)=="1"
+        when :binary    then unquote value
+        else value
+        end
+      end
+
+      def extract_limit(sql_type)
+        case sql_type
+        when /text|ntext|xml|binary|image|varbinary|bit/
+          nil
+        else
+          super
+        end
+      end
+
+      def is_utf8?
+        sql_type =~ /nvarchar|ntext|nchar/i
+      end
+
+      def unquote(value)
+        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
+      end
+
+      def cast_to_time(value)
+        return value if value.is_a?(Time)
+        DateTime.parse(value).to_time rescue nil
+      end
+
+      def cast_to_date(value)
+        return value if value.is_a?(Date)
+        return Date.parse(value) rescue nil
+      end
+
+      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
+
+      # These methods will only allow the adapter to insert binary data with a length of 7K or less
+      # because of a SQL Server statement length policy.
+      def self.string_to_binary(value)
+        ''
+      end
+
+    end
+
+    def quote(value, column = nil)
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      case value
+      # SQL Server 2000 doesn't let you insert an integer into a NVARCHAR
+      # column, so we include Integer here.
+      when String, ActiveSupport::Multibyte::Chars, Integer
+        value = value.to_s
+        if column && column.type == :binary
+          "'#{quote_string(ArJdbc::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
+        elsif column && [:integer, :float].include?(column.type)
+          value = column.type == :integer ? value.to_i : value.to_f
+          value.to_s
+        elsif !column.respond_to?(:is_utf8?) || column.is_utf8?
+          "N'#{quote_string(value)}'" # ' (for ruby-mode)
+        else
+          super
+        end
+      when TrueClass             then '1'
+      when FalseClass            then '0'
+      else                       super
+      end
+    end
+
+    def quote_string(string)
+      string.gsub(/\'/, "''")
+    end
+
+    def quote_table_name(name)
+      quote_column_name(name)
+    end
+
+    def quote_column_name(name)
+      "[#{name}]"
+    end
+
+    def quoted_true
+      quote true
+    end
+
+    def quoted_false
+      quote false
+    end
+
+    def adapter_name #:nodoc:
+      'MsSQL'
+    end
+
+    def change_order_direction(order)
+      order.split(",").collect do |fragment|
+        case fragment
+        when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
+        when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
+        else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
+        end
+      end.join(",")
+    end
+
+    def supports_ddl_transactions?
+      true
+    end
+
+    def recreate_database(name)
+      drop_database(name)
+      create_database(name)
+    end
+
+    def drop_database(name)
+      execute "USE master"
+      execute "DROP DATABASE #{name}"
+    end
+
+    def create_database(name)
+      execute "CREATE DATABASE #{name}"
+      execute "USE #{name}"
+    end
+
+    def rename_table(name, new_name)
+      clear_cached_table(name)
+      execute "EXEC sp_rename '#{name}', '#{new_name}'"
+    end
+
+    # Adds a new column to the named table.
+    # See TableDefinition#column for details of the options you can use.
+    def add_column(table_name, column_name, type, options = {})
+      clear_cached_table(table_name)
+      add_column_sql = "ALTER TABLE #{table_name} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_options!(add_column_sql, options)
+      # TODO: Add support to mimic date columns, using constraints to mark them as such in the database
+      # add_column_sql << " CONSTRAINT ck__#{table_name}__#{column_name}__date_only CHECK ( CONVERT(CHAR(12), #{quote_column_name(column_name)}, 14)='00:00:00:000' )" if type == :date
+      execute(add_column_sql)
+    end
+
+    def rename_column(table, column, new_column_name)
+      clear_cached_table(table)
+      execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      clear_cached_table(table_name)
+      change_column_type(table_name, column_name, type, options)
+      change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+    end
+
+    def change_column_type(table_name, column_name, type, options = {}) #:nodoc:
+      clear_cached_table(table_name)
+      sql = "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      if options.has_key?(:null)
+        sql += (options[:null] ? " NULL" : " NOT NULL")
+      end
+      execute(sql)
+    end
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      clear_cached_table(table_name)
+      remove_default_constraint(table_name, column_name)
+      unless default.nil?
+        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
+      end
+    end
+
+    def remove_column(table_name, column_name)
+      clear_cached_table(table_name)
+      remove_check_constraints(table_name, column_name)
+      remove_default_constraint(table_name, column_name)
+      execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+    end
+
+    def remove_default_constraint(table_name, column_name)
+      clear_cached_table(table_name)
+      defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
+      defaults.each {|constraint|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
+      }
+    end
+
+    def remove_check_constraints(table_name, column_name)
+      clear_cached_table(table_name)
+      # TODO remove all constraints in single method
+      constraints = select "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{table_name}' and COLUMN_NAME = '#{column_name}'"
+      constraints.each do |constraint|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["CONSTRAINT_NAME"]}"
+      end
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    end
+
+    def columns(table_name, name = nil)
+      # It's possible for table_name to be an empty string, or nil, if something attempts to issue SQL
+      # which doesn't involve a table.  IE. "SELECT 1" or "SELECT * from someFunction()".
+      return [] if table_name.blank?
+      table_name = table_name.to_s if table_name.is_a?(Symbol)
+
+      # Remove []'s from around the table name, valid in a select statement, but not when matching metadata.
+      table_name = table_name.gsub(/[\[\]]/, '')
+
+      return [] if table_name =~ /^information_schema\./i
+      @table_columns ||= {}
+      unless @table_columns[table_name]
+        @table_columns[table_name] = super
+        @table_columns[table_name].each do |col|
+          col.identity = true if col.sql_type =~ /identity/i
+          col.is_special = true if col.sql_type =~ /text|ntext|image|xml/i
+        end
+      end
+      @table_columns[table_name]
+    end
+
+    def _execute(sql, name = nil)
+      # Match the start of the sql to determine appropriate behaviour.  Be aware of
+      # multi-line sql which might begin with 'create stored_proc' and contain 'insert into ...' lines.
+      # Possible improvements include ignoring comment blocks prior to the first statement.
+      if sql.lstrip =~ /\Ainsert/i
+        if query_requires_identity_insert?(sql)
+          table_name = get_table_name(sql)
+          with_identity_insert_enabled(table_name) do
+            id = @connection.execute_insert(sql)
+          end
+        else
+          @connection.execute_insert(sql)
+        end
+      elsif sql.lstrip =~ /\A(create|exec)/i
+        @connection.execute_update(sql)
+      elsif sql.lstrip =~ /\A\(?\s*(select|show)/i
+        repair_special_columns(sql)
+        @connection.execute_query(sql)
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
+    def select(sql, name = nil, binds = [])
+      sql = substitute_binds(sql, binds)
+      log(sql, name) do
+        @connection.execute_query(sql)
+      end
+    end
+
+    # Turns IDENTITY_INSERT ON for table during execution of the block
+    # N.B. This sets the state of IDENTITY_INSERT to OFF after the
+    # block has been executed without regard to its previous state
+    def with_identity_insert_enabled(table_name, &block)
+      set_identity_insert(table_name, true)
+      yield
+    ensure
+      set_identity_insert(table_name, false)
+    end
+
+    def set_identity_insert(table_name, enable = true)
+      execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+    rescue Exception => e
+      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+    end
+
+    def identity_column(table_name)
+      columns(table_name).each do |col|
+        return col.name if col.identity
+      end
+      return nil
+    end
+
+    def query_requires_identity_insert?(sql)
+      table_name = get_table_name(sql)
+      id_column = identity_column(table_name)
+      if sql.strip =~ /insert into [^ ]+ ?\((.+?)\)/i
+        insert_columns = $1.split(/, */).map(&method(:unquote_column_name))
+        return table_name if insert_columns.include?(id_column)
+      end
+    end
+
+    def unquote_column_name(name)
+      if name =~ /^\[.*\]$/
+        name[1..-2]
+      else
+        name
+      end
+    end
+
+    def get_special_columns(table_name)
+      special = []
+      columns(table_name).each do |col|
+        special << col.name if col.is_special
+      end
+      special
+    end
+
+    def repair_special_columns(sql)
+      special_cols = get_special_columns(get_table_name(sql))
+      for col in special_cols.to_a
+        sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
+        sql.gsub!(/ORDER BY #{col.to_s}/i, '')
+      end
+      sql
+    end
+
+    def determine_order_clause(sql)
+      return $1 if sql =~ /ORDER BY (.*)$/
+      table_name = get_table_name(sql)
+      "#{table_name}.#{determine_primary_key(table_name)}"
+    end
+
+    def determine_primary_key(table_name)
+      primary_key = columns(table_name).detect { |column| column.primary || column.identity }
+      return primary_key.name if primary_key
+      # Look for an id column.  Return it, without changing case, to cover dbs with a case-sensitive collation.
+      columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
+      # Give up and provide something which is going to crash almost certainly
+      columns(table_name)[0].name
+    end
+
+    def clear_cached_table(name)
+      (@table_columns ||= {}).delete(name.to_s)
+    end
+
+    def reset_column_information
+      @table_columns = nil
+    end
+  end
+end
+