activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/lib/active_record/connection_adapters/cachedb_adapter.rb

@@ -1 +0,0 @@
-require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/jdbc_adapter_spec.rb

@@ -1,26 +0,0 @@
-module JdbcSpec
-  module ActiveRecordExtensions
-    def self.add_method_to_remove_from_ar_base(meth)
-      @methods ||= []
-      @methods << meth
-    end
-
-    def self.extended(klass)
-      (@methods || []).each {|m| (class << klass; self; end).instance_eval { remove_method(m) rescue nil } }
-    end
-  end
-end
-
-require 'jdbc_adapter/jdbc_mimer'
-require 'jdbc_adapter/jdbc_hsqldb'
-require 'jdbc_adapter/jdbc_oracle'
-require 'jdbc_adapter/jdbc_postgre'
-require 'jdbc_adapter/jdbc_mysql'
-require 'jdbc_adapter/jdbc_derby'
-require 'jdbc_adapter/jdbc_firebird'
-require 'jdbc_adapter/jdbc_db2'
-require 'jdbc_adapter/jdbc_mssql'
-require 'jdbc_adapter/jdbc_cachedb'
-require 'jdbc_adapter/jdbc_sqlite3'
-require 'jdbc_adapter/jdbc_sybase'
-require 'jdbc_adapter/jdbc_informix'

data/lib/jdbc_adapter/jdbc_cachedb.rb

@@ -1,33 +0,0 @@
-require 'jdbc_adapter/tsql_helper'
-
-module ::JdbcSpec
-  module ActiveRecordExtensions
-    def cachedb_connection( config )
-      config[:port] ||= 1972
-      config[:url] ||= "jdbc:Cache://#{config[:host]}:#{config[:port]}/#{ config[:database]}"
-      config[:driver] ||= "com.intersys.jdbc.CacheDriver"
-      jdbc_connection( config )
-    end
-  end
-
-  module CacheDB
-    include TSqlMethods
-
-    def self.adapter_matcher(name, *)
-     name =~ /cache/i ? self : false
-    end
-
-    def self.column_selector
-      [ /cache/i, lambda {  | cfg, col | col.extend( ::JdbcSpec::CacheDB::Column ) } ]
-    end
-
-    module Column
-    end
-    
-    def create_table(name, options = { })
-      super(name, options)
-      primary_key = options[:primary_key] || "id"
-      execute "ALTER TABLE #{name} ADD CONSTRAINT #{name}_PK PRIMARY KEY(#{primary_key})" unless options[:id] == false
-    end
-  end
-end

data/lib/jdbc_adapter/jdbc_db2.rb

@@ -1,191 +0,0 @@
-module JdbcSpec
-  module DB2
-    def self.adapter_matcher(name, config)
-      if name =~ /db2/i
-         return config[:url] =~ /^jdbc:derby:net:/ ? ::JdbcSpec::Derby : self
-      end
-      false
-    end
-
-    def self.adapter_selector
-      [/db2/i, lambda {|cfg,adapt|
-         if cfg[:url] =~ /^jdbc:derby:net:/
-           adapt.extend(::JdbcSpec::Derby)
-         else
-           adapt.extend(::JdbcSpec::DB2)
-         end }]
-    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 :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
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = 'int not null generated by default as identity (start with 1) primary key'
-      tp[:string][:limit] = 255
-      tp[:integer][:limit] = nil
-      tp[:boolean][:limit] = nil
-      tp
-    end
-
-    def add_limit_offset!(sql, options)
-      if limit = options[:limit]
-        offset = options[:offset] || 0
-        sql.gsub!(/SELECT/i, 'SELECT B.* FROM (SELECT A.*, row_number() over () AS internal$rownum FROM (SELECT')
-        sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset}"
-      end
-    end
-
-    def quote_column_name(column_name)
-      column_name
-    end
-
-    def quote(value, column = nil) # :nodoc:
-      if column && column.type == :primary_key
-        return value.to_s
-      end
-      if column && (column.type == :decimal || column.type == :integer) && value
-        return value.to_s
-      end
-      case value
-      when String
-        if column && column.type == :binary
-          "BLOB('#{quote_string(value)}')"
-        else
-          "'#{quote_string(value)}'"
-        end
-      else super
-      end
-    end
-
-    def quote_string(string)
-      string.gsub(/'/, "''") # ' (for ruby-mode)
-    end
-
-    def quoted_true
-      '1'
-    end
-
-    def quoted_false
-      '0'
-    end
-
-    def recreate_database(name)
-      do_not_drop = ["stmg_dbsize_info","hmon_atm_info","hmon_collection","policy"]
-      tables.each do |table|
-        unless do_not_drop.include?(table)
-          drop_table(table)
-        end
-      end
-    end
-
-    def remove_index(table_name, options = { })
-      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
-    end
-
-    # This method makes tests pass without understanding why.
-    # Don't use this in production.
-    def columns(table_name, name = nil)
-      super.select do |col|
-        # strip out "magic" columns from DB2 (?)
-        !/rolename|roleid|create_time|auditpolicyname|auditpolicyid|remarks/.match(col.name)
-      end
-    end
-
-    def add_quotes(name)
-      return name unless name
-      %Q{"#{name}"}
-    end
-
-    def strip_quotes(str)
-      return str unless str
-      return str unless /^(["']).*\1$/ =~ str
-      str[1..-2]
-    end
-
-    def expand_double_quotes(name)
-      return name unless name && name['"']
-      name.gsub(/"/,'""')
-    end
-
-
-    def structure_dump #:nodoc:
-      definition=""
-      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
-      while rs.next
-        tname = rs.getString(3)
-        definition << "CREATE TABLE #{tname} (\n"
-        rs2 = @connection.connection.meta_data.getColumns(nil,nil,tname,nil)
-        first_col = true
-        while rs2.next
-          col_name = add_quotes(rs2.getString(4));
-          default = ""
-          d1 = rs2.getString(13)
-          default = d1 ? " DEFAULT #{d1}" : ""
-
-          type = rs2.getString(6)
-          col_size = rs2.getString(7)
-          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
-          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
-            " " +
-            type +
-            "" +
-            nulling +
-            default
-          if !first_col
-            create_col_string = ",\n #{create_col_string}"
-          else
-            create_col_string = " #{create_col_string}"
-          end
-
-          definition << create_col_string
-
-          first_col = false
-        end
-        definition << ");\n\n"
-      end
-      definition
-    end
-
-    def dump_schema_information
-      begin
-        if (current_schema = ActiveRecord::Migrator.current_version) > 0
-          #TODO: Find a way to get the DB2 instace name to properly form the statement
-          return "INSERT INTO DB2INST2.SCHEMA_INFO (version) VALUES (#{current_schema})"
-        end
-      rescue ActiveRecord::StatementInvalid
-        # No Schema Info
-      end
-    end
-
-  end
-end

data/lib/jdbc_adapter/jdbc_mssql.rb

@@ -1,333 +0,0 @@
-require 'jdbc_adapter/tsql_helper'
-
-module ::JdbcSpec
-  module MsSQL
-    include TSqlMethods
-
-    def self.extended(mod)
-      unless @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]
-            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
-        end
-
-        ActiveRecord::Base.after_save :after_save_with_mssql_lob
-        @lob_callback_added = true
-      end
-    end
-
-    def self.adapter_matcher(name, *)
-      name =~ /sqlserver|tds/i ? self : false
-    end
-
-    def self.column_selector
-      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::JdbcSpec::MsSQL::Column)}]
-    end
-
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::MssqlJdbcConnection
-    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 /numeric/i                                            then (@scale.nil? || @scale == 0) ? :integer : :decimal
-          when /float|double|decimal|money|real|smallmoney/i         then :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)" || value == "(NULL)"
-        case type
-        when :string then unquote_string 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
-
-      # JRUBY-2011: Match balanced quotes and parenthesis - 'text',('text') or (text)
-      def unquote_string(value)
-        value.to_s.sub(/^\((.*)\)$/,'\1').sub(/^'(.*)'$/,'\1')
-      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 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
-          "N'#{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_table_name(name)
-      name
-    end
-
-    def quote_column_name(name)
-      "[#{name}]"
-    end
-
-    def quoted_true
-      quote true
-    end
-
-    def quoted_false
-      quote false
-    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 "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)
-        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 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:
-        remove_default_constraint(table_name, column_name)
-        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)
-        return [] if table_name =~ /^information_schema\./i
-        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
-
-      #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
-      def add_lock!(sql, options)
-        sql
-      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 ActiveRecord::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
-