activerecord-jdbc-adapter 0.6

data/lib/jdbc_adapter/jdbc_firebird.rb

@@ -0,0 +1,109 @@
+module ::JdbcSpec
+  module FireBird
+    def self.adapter_selector
+      [/firebird/i, lambda{|cfg,adapt| adapt.extend(::JdbcSpec::FireBird)}]
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
+      tp[:string][:limit] = 252
+      tp[:integer][:limit] = nil
+      tp
+    end
+    
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) # :nodoc:
+      execute(sql, name)
+      id_value
+    end
+
+    def add_limit_offset!(sql, options) # :nodoc:
+      if options[:limit]
+        limit_string = "FIRST #{options[:limit]}"
+        limit_string << " SKIP #{options[:offset]}" if options[:offset]
+        sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
+      end
+    end
+
+    def prefetch_primary_key?(table_name = nil)
+      true
+    end
+
+    def default_sequence_name(table_name, primary_key) # :nodoc:
+      "#{table_name}_seq"
+    end
+    
+    def next_sequence_value(sequence_name)
+      select_one("SELECT GEN_ID(#{sequence_name}, 1 ) FROM RDB$DATABASE;")["gen_id"]
+    end
+    
+    def create_table(name, options = {}) #:nodoc:
+      super(name, options)
+      execute "CREATE GENERATOR #{name}_seq"
+    end
+
+    def rename_table(name, new_name) #:nodoc:
+      execute "RENAME #{name} TO #{new_name}"
+      execute "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name}_seq' WHERE RDB$GENERATOR_NAME='#{name}_seq'" rescue nil
+    end  
+
+    def drop_table(name, options = {}) #:nodoc:
+      super(name)
+      execute "DROP GENERATOR #{name}_seq" rescue nil
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
+    end
+
+    def rename_column(table_name, column_name, new_column_name)
+      execute "ALTER TABLE #{table_name} ALTER  #{column_name} TO #{new_column_name}"
+    end
+
+    def remove_index(table_name, options) #:nodoc:
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end
+    
+    def quote(value, column = nil) # :nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+      
+      if [Time, DateTime].include?(value.class)
+        "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
+      else
+        if column && column.type == :primary_key
+          return value.to_s
+        end
+        super
+      end
+    end
+
+    def quote_string(string) # :nodoc:
+      string.gsub(/'/, "''")
+    end
+    
+    def quote_column_name(column_name) # :nodoc:
+      %Q("#{ar_to_fb_case(column_name)}")
+    end
+    
+    def quoted_true # :nodoc:
+      quote(1)
+    end
+    
+    def quoted_false # :nodoc:
+      quote(0)
+    end
+
+    private
+    
+    # Maps uppercase Firebird column names to lowercase for ActiveRecord;
+    # mixed-case columns retain their original case.
+    def fb_to_ar_case(column_name)
+      column_name =~ /[[:lower:]]/ ? column_name : column_name.to_s.downcase
+    end
+    
+    # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
+    # mixed-case columns retain their original case.
+    def ar_to_fb_case(column_name)
+      column_name =~ /[[:upper:]]/ ? column_name : column_name.to_s.upcase
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_hsqldb.rb

@@ -0,0 +1,168 @@
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def hsqldb_connection(config)
+      config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+      config[:driver] ||= "org.hsqldb.jdbcDriver"
+      embedded_driver(config)
+    end
+      
+    def h2_connection(config)
+      config[:url] ||= "jdbc:h2:#{config[:database]}"
+      config[:driver] ||= "org.h2.Driver"
+      embedded_driver(config)
+    end
+  end
+  
+  module HSQLDB
+    def self.column_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::JdbcSpec::HSQLDB::Column)}]
+    end
+
+    def self.adapter_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::HSQLDB)}]
+    end
+    
+    module Column
+      def type_cast(value)
+        return nil if value.nil? || value =~ /^\s*null\s*$/i
+        case type
+        when :string    then value
+        when :integer   then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+        when :float     then value.to_f
+        when :datetime  then cast_to_date_or_time(value)
+        when :timestamp then cast_to_time(value)
+        when :binary    then value.scan(/[0-9A-Fa-f]{2}/).collect {|v| v.to_i(16)}.pack("C*")
+        when :time      then cast_to_time(value)
+        else value
+        end
+      end
+      def cast_to_date_or_time(value)
+        return value if value.is_a? Date
+        return nil if value.blank?
+        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
+      end
+
+      def cast_to_time(value)
+        return value if value.is_a? Time
+        time_array = ParseDate.parsedate value
+        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
+        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
+      end
+
+      def guess_date_or_time(value)
+        (value.hour == 0 and value.min == 0 and value.sec == 0) ?
+        Date.new(value.year, value.month, value.day) : value
+      end
+
+
+      private
+      def simplified_type(field_type)
+        case field_type
+        when /longvarchar/i
+          :text
+        else
+          super(field_type)
+        end
+      end
+
+      # Override of ActiveRecord::ConnectionAdapters::Column
+      def extract_limit(sql_type)
+        # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns, which
+        # for AR purposes should be interpreted as "no limit"
+        return nil if sql_type =~ /\(0\)/
+        super
+      end
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "INTEGER GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
+      tp[:integer][:limit] = nil
+      tp[:boolean][:limit] = nil
+      # set text and float limits so we don't see odd scales tacked on
+      # in migrations
+      tp[:text][:limit] = nil
+      tp[:float][:limit] = 17
+      tp[:string][:limit] = 255
+      tp[:datetime] = { :name => "DATETIME" }
+      tp[:timestamp] = { :name => "DATETIME" }
+      tp[:time] = { :name => "DATETIME" }
+      tp[:date] = { :name => "DATETIME" }
+      tp
+    end
+
+    def quote(value, column = nil) # :nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+      
+      case value
+      when String
+        if column && column.type == :binary
+          "'#{quote_string(value).unpack("C*").collect {|v| v.to_s(16)}.join}'"
+        else
+          "'#{quote_string(value)}'"
+        end
+      else super
+      end
+    end
+
+    def quote_string(str)
+      str.gsub(/'/, "''")
+    end
+
+    def quoted_true
+      '1'
+    end
+
+    def quoted_false
+      '0'
+    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 rename_column(table_name, column_name, new_column_name) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} RENAME TO #{new_column_name}"
+    end
+
+    def rename_table(name, new_name)
+      execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+      log_no_bench(sql,name) do
+        @connection.execute_update(sql)
+      end
+      table = sql.split(" ", 4)[2]
+      id_value || last_insert_id(table, nil)
+    end
+
+    def last_insert_id(table, sequence_name)
+      Integer(select_value("SELECT IDENTITY() FROM #{table}"))
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      offset = options[:offset] || 0
+      bef = sql[7..-1]
+      if limit = options[:limit]
+        sql.replace "select limit #{offset} #{limit} #{bef}"
+      elsif offset > 0
+        sql.replace "select limit #{offset} 0 #{bef}"
+      end
+    end
+
+    # override to filter out system tables that otherwise end
+    # up in db/schema.rb during migrations.  JdbcConnection#tables
+    # now takes an optional block filter so we can screen out
+    # rows corresponding to system tables.  HSQLDB names its
+    # system tables SYSTEM.*, but H2 seems to name them without
+    # any kind of convention
+    def tables
+      @connection.tables.select {|row| row.to_s !~ /^system_/i }
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_mimer.rb

@@ -0,0 +1,134 @@
+module JdbcSpec
+  module Mimer
+    def self.adapter_selector
+      [/mimer/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::Mimer)}]
+    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) #:nodoc:
+      if pk.nil? # Who called us? What does the sql look like? No idea!
+        execute sql, name
+      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)
+      @offset ||= 0
+      if !@limit || @limit == -1
+        range = @offset..-1
+      else
+        range = @offset...(@offset+@limit)
+      end
+      select(sql, name)[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/jdbc_adapter/jdbc_mssql.rb

@@ -0,0 +1,356 @@
+module ::ActiveRecord
+  class Base
+    # After setting large objects to empty, write data back with a helper method
+    after_save :write_lobs
+    def write_lobs() #:nodoc:
+      if connection.is_a?(JdbcSpec::MsSQL)
+        self.class.columns.select { |c| c.sql_type =~ /image/i }.each { |c|
+          value = self[c.name]
+          value = value.to_yaml if unserializable_attribute?(c.name, c)
+          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
+    private :write_lobs
+  end
+end
+
+module JdbcSpec
+  module MsSQL
+    def self.column_selector
+      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::JdbcSpec::MsSQL::Column)}]
+    end
+
+    def self.adapter_selector
+      [/sqlserver|tds/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::MsSQL)}]
+    end
+    
+    module Column
+      attr_accessor :identity, :is_special
+      
+      def simplified_type(field_type)
+        case field_type
+          when /int|bigint|smallint|tinyint/i                        then :integer
+          when /float|double|decimal|money|numeric|real|smallmoney/i then @scale == 0 ? :integer : :decimal
+          when /datetime|smalldatetime/i                             then :datetime
+          when /timestamp/i                                          then :timestamp
+          when /time/i                                               then :time
+          when /text|ntext/i                                         then :text
+          when /binary|image|varbinary/i                             then :binary
+          when /char|nchar|nvarchar|string|varchar/i                 then :string
+          when /bit/i                                                then :boolean
+          when /uniqueidentifier/i                                   then :string
+        end
+      end
+
+      def type_cast(value)
+        return nil if value.nil? || value == "(NULL)"
+        case type
+        when :string then unquote value
+        when :integer then 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_datetime(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 unquote(value)
+        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
+      end
+      
+      def cast_to_time(value)
+        return value if value.is_a?(Time)
+        time_array = ParseDate.parsedate(value)
+        time_array[0] ||= 2000
+        time_array[1] ||= 1
+        time_array[2] ||= 1
+        Time.send(ActiveRecord::Base.default_timezone, *time_array) 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
+        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
+        value
+      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 modify_types(tp)
+      tp[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
+      tp[:integer][:limit] = nil
+      tp[:boolean] = {:name => "bit"}
+      tp[:binary] = { :name => "image"}
+      tp
+    end
+    
+    def quote(value, column = nil)
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      case value
+      when String, ActiveSupport::Multibyte::Chars
+        value = value.to_s
+        if column && column.type == :binary
+          "'#{quote_string(JdbcSpec::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
+        else
+          "'#{quote_string(value)}'" # ' (for ruby-mode)
+        end
+        when TrueClass             then '1'
+        when FalseClass            then '0'
+        when Time, DateTime        then "'#{value.strftime("%Y%m%d %H:%M:%S")}'"
+        when Date                  then "'#{value.strftime("%Y%m%d")}'"
+        else                       super
+      end
+    end
+
+      def quote_string(string)
+        string.gsub(/\'/, "''")
+      end
+
+      def quote_column_name(name)
+        "[#{name}]"
+      end
+      
+        def add_limit_offset!(sql, options)
+          if options[:limit] and options[:offset]
+            total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT\\1 TOP 1000000000")}) tally")[0]["TotalRows"].to_i
+            if (options[:limit] + options[:offset]) >= total_rows
+              options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
+            end
+            sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT\\1 TOP #{options[:limit] + options[:offset]} ")
+            sql << ") AS tmp1"
+            if options[:order]
+              options[:order] = options[:order].split(',').map do |field|
+                parts = field.split(" ")
+                tc = parts[0]
+                if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+                  tc.gsub!(/\./, '\\.\\[')
+                  tc << '\\]'
+                end
+                if sql =~ /#{tc} AS (t\d_r\d\d?)/
+                  parts[0] = $1
+                elsif parts[0] =~ /\w+\.(\w+)/
+                  parts[0] = $1
+                end
+                parts.join(' ')
+              end.join(', ')
+              sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+            else
+              sql << " ) AS tmp2"
+            end
+          elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+            sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
+              "SELECT#{$1} TOP #{options[:limit]}"
+            end unless options[:limit].nil?
+          end
+        end
+    
+      
+      def change_order_direction(order)
+        order.split(",").collect {|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
+        }.join(",")
+      end
+      
+    def recreate_database(name)
+      drop_database(name)
+      create_database(name)
+    end
+    
+    def drop_database(name)
+      execute "DROP DATABASE #{name}"
+    end
+
+    def create_database(name)
+      execute "CREATE DATABASE #{name}"
+    end
+
+      def rename_table(name, new_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 = {})
+        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)
+        execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+      end
+       
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+          return super unless type.to_s == 'integer'
+          
+        if limit.nil? || limit == 4
+          'int'
+        elsif limit == 2
+          'smallint'
+        elsif limit ==1
+          'tinyint'
+        else
+          'bigint'
+        end
+       end
+        
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        sql_commands = ["ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"]
+        if options_include_default?(options)
+          remove_default_constraint(table_name, column_name)
+          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(options[:default], options[:column])} FOR #{column_name}"
+        end
+        sql_commands.each {|c|
+          execute(c)
+        }
+      end
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default, column_name)} FOR #{column_name}"
+      end
+      def remove_column(table_name, column_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)
+        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)
+        # 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)
+        cc = super
+        cc.each do |col|
+          col.identity = true if col.sql_type =~ /identity/i
+          col.is_special = true if col.sql_type =~ /text|ntext|image/i
+        end
+        cc
+      end
+      
+      def _execute(sql, name = nil)
+        if sql.lstrip =~ /^insert/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 =~ /^\(?\s*(select|show)/i
+          repair_special_columns(sql)
+          @connection.execute_query(sql)
+        else
+          @connection.execute_update(sql)
+        end
+      end
+      
+      
+      private
+      # 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 ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"  
+      end
+
+      def get_table_name(sql)
+        if sql =~ /^\s*insert\s+into\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+          $1
+        elsif sql =~ /from\s+([^\(\s]+)\s*/i
+          $1
+        else
+          nil
+        end
+      end
+
+      def identity_column(table_name)
+        @table_columns = {} unless @table_columns
+        @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
+        @table_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)
+        sql =~ /\[#{id_column}\]/ ? table_name : nil
+      end
+      
+      def get_special_columns(table_name)
+        special = []
+        @table_columns ||= {}
+        @table_columns[table_name] ||= columns(table_name)
+        @table_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
+    end
+  end
+