neo-activerecord-jdbc-adapter 5.0.pre2

data/lib/arjdbc/jdbc/extension.rb

@@ -0,0 +1,59 @@
+module ArJdbc
+
+  # Defines an AR-JDBC extension. An extension consists of a declaration using
+  # this method and an ArJdbc::XYZ module that contains implementation and
+  # overrides for methods in ActiveRecord::ConnectionAdapters::AbstractAdapter.
+  # When you declare your extension, you provide a block that detects when a
+  # database configured to use the extension is present and loads the necessary
+  # code for it. AR-JDBC will patch the code into the base JdbcAdapter by
+  # extending an instance of it with your extension module.
+  #
+  # +name+ the name of a module to be defined under the +ArJdbc+ module.
+  #
+  # +block+ should be a one- or two-arity block that receives the dialect name
+  # or driver class name as the first argument, and optionally the whole
+  # database configuration hash as a second argument
+  #
+  # Example:
+  #
+  #   ArJdbc.extension :FRoB do |name|
+  #     if name =~ /frob/i
+  #       require 'arjdbc/frob' # contains ArJdbc::FRoB
+  #       true
+  #     end
+  #   end
+  #
+  def self.extension(name, &block)
+    if const_defined?(name)
+      mod = const_get(name)
+    else
+      mod = const_set(name, Module.new)
+    end
+    (class << mod; self; end).instance_eval do
+      define_method :adapter_matcher do |_name, config|
+        if block.arity == 1
+          block.call(_name) ? mod : false
+        else
+          block.call(_name, config) ? mod : false
+        end
+      end
+    end unless mod.respond_to?(:adapter_matcher)
+  end
+
+  private
+  def self.discover_extensions
+    if defined?(Gem) && Gem.respond_to?(:find_files)
+      files = Gem.find_files('arjdbc/discover')
+    else
+      files = $LOAD_PATH.map do |path|
+        discover = File.join(path, 'arjdbc', 'discover.rb')
+        File.exist?(discover) ? discover : nil
+      end.compact
+    end
+    files.each do |file|
+      puts "Loading AR-JDBC extension #{file}" if $DEBUG
+      require file
+    end
+  end
+
+end

data/lib/arjdbc/jdbc/java.rb

@@ -0,0 +1,15 @@
+require 'java'
+require 'arjdbc/jdbc/adapter_java'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Jdbc
+      # @private
+      DriverManager = ::Java::JavaSql::DriverManager
+      # @private
+      Types = ::Java::JavaSql::Types
+    end
+    # @private JdbcConnectionFactory
+    java_import "arjdbc.jdbc.JdbcConnectionFactory"
+  end
+end

data/lib/arjdbc/jdbc/jdbc.rake

@@ -0,0 +1,4 @@
+load 'arjdbc/tasks.rb'
+
+require 'arjdbc'
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"

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__ + 1
+          alias :#{meth}_pre_pk :#{meth}
+          def #{meth}(include_primary_key = true, *args)
+            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,2 @@
+require 'arjdbc/railtie'
+ArJdbc.deprecate "require 'arjdbc/railtie' instead of 'arjdbc/jdbc/railtie'"

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -0,0 +1,3 @@
+load 'arjdbc/tasks.rb'
+
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' instead of 'arjdbc/jdbc/rake_tasks.rb'"

data/lib/arjdbc/jdbc/serialized_attributes_helper.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/util/serialized_attributes'
+
+ArJdbc.deprecate "require 'arjdbc/util/serialized_attributes' instead of 'arjdbc/jdbc/serialized_attributes_helper'"

data/lib/arjdbc/jdbc/type_cast.rb

@@ -0,0 +1,166 @@
+require 'active_record/connection_adapters/column'
+
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # Type casting methods taken from AR 4.1's Column class.
+    # @private Simply to quickly "hack-in" 4.2 compatibility.
+    module TypeCast
+      TRUE_VALUES = Column::TRUE_VALUES if Column.const_defined?(:TRUE_VALUES)
+      FALSE_VALUES = if defined?(ActiveModel::Type::Boolean::FALSE_VALUES)
+        ActiveModel::Type::Boolean::FALSE_VALUES
+      else
+        Column::FALSE_VALUES
+      end
+
+      #module Format
+      ISO_DATE = if defined?(ActiveModel::Type::Date::ISO_DATE)
+        ActiveModel::Type::Date::ISO_DATE
+      else
+        Column::Format::ISO_DATE
+      end
+
+      ISO_DATETIME = if defined?(ActiveModel::Type::Helpers::TimeValue::ISO_DATETIME)
+        ActiveModel::Type::Helpers::TimeValue::ISO_DATETIME
+      else
+        Column::Format::ISO_DATETIME
+      end
+      #end
+
+      # Used to convert from BLOBs to Strings
+      def binary_to_string(value)
+        value
+      end
+
+      def value_to_date(value)
+        if value.is_a?(String)
+          return nil if value.empty?
+          fast_string_to_date(value) || fallback_string_to_date(value)
+        elsif value.respond_to?(:to_date)
+          value.to_date
+        else
+          value
+        end
+      end
+
+      def string_to_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+        return string if string =~ /^-?infinity$/.freeze
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      def string_to_dummy_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+
+        dummy_time_string = "2000-01-01 #{string}"
+
+        fast_string_to_time(dummy_time_string) || begin
+          time_hash = Date._parse(dummy_time_string)
+          return nil if time_hash[:hour].nil?
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+        end
+      end
+
+      # convert something to a boolean
+      def value_to_boolean(value)
+        if value.is_a?(String) && value.empty?
+          nil
+        else
+          TRUE_VALUES.include?(value)
+        end
+      end if const_defined?(:TRUE_VALUES) # removed on AR 5.0
+
+      # convert something to a boolean
+      def value_to_boolean(value)
+        if value.is_a?(String) && value.empty?
+          nil
+        else
+          ! FALSE_VALUES.include?(value)
+        end
+      end unless const_defined?(:TRUE_VALUES)
+
+      # Used to convert values to integer.
+      # handle the case when an integer column is used to store boolean values
+      def value_to_integer(value)
+        case value
+        when TrueClass, FalseClass
+          value ? 1 : 0
+        else
+          value.to_i rescue nil
+        end
+      end
+
+      # convert something to a BigDecimal
+      def value_to_decimal(value)
+        # Using .class is faster than .is_a? and
+        # subclasses of BigDecimal will be handled
+        # in the else clause
+        if value.class == BigDecimal
+          value
+        elsif value.respond_to?(:to_d)
+          value.to_d
+        else
+          value.to_s.to_d
+        end
+      end
+
+      protected
+        # '0.123456' -> 123456
+        # '1.123456' -> 123456
+        def microseconds(time)
+          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+        end
+
+        def new_date(year, mon, mday)
+          if year && year != 0
+            Date.new(year, mon, mday) rescue nil
+          end
+        end
+
+        def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+          # Treat 0000-00-00 00:00:00 as nil.
+          return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+          if offset
+            time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+            return nil unless time
+
+            time -= offset
+            ActiveRecord::Base.default_timezone == :utc ? time : time.getlocal
+          else
+            timezone = ActiveRecord::Base.default_timezone
+            Time.public_send(timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+        end
+
+        def fast_string_to_date(string)
+          if string =~ ISO_DATE
+            new_date $1.to_i, $2.to_i, $3.to_i
+          end
+        end
+
+        # Doesn't handle time zones.
+        def fast_string_to_time(string)
+          if string =~ ISO_DATETIME
+            microsec = ($7.to_r * 1_000_000).to_i
+            new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          end
+        end
+
+        def fallback_string_to_date(string)
+          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+        end
+
+        def fallback_string_to_time(string)
+          time_hash = Date._parse(string)
+          time_hash[:sec_fraction] = microseconds(time_hash)
+          time_hash[:year] *= -1 if time_hash[:zone] == 'BC'
+
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+        end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -0,0 +1,142 @@
+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 existing 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. Improvements appreciated.
+    class JdbcTypeConverter
+
+      # @private
+      TEXT_TYPES = [ Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB ]
+      private_constant :TEXT_TYPES if respond_to? :private_constant
+
+      # @private
+      FLOAT_TYPES = [ Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE, Jdbc::Types::REAL ]
+      private_constant :FLOAT_TYPES if respond_to? :private_constant
+
+      # @private
+      BINARY_TYPES = [ Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB ]
+      private_constant :BINARY_TYPES if respond_to? :private_constant
+
+      # 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| TEXT_TYPES.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| FLOAT_TYPES.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'] =~ /^datetime.+/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'] =~ /^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},
+                          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| BINARY_TYPES.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::BIT == r['data_type'].to_i && r['precision'].to_i == 1},
+                          lambda {|r| Jdbc::Types::TINYINT == 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 |ar_type|
+          typerow = choose_type(ar_type)
+          type_map[ar_type] = { :name => typerow['type_name'].downcase }
+          case ar_type
+          when :integer, :string, :decimal
+            set_limit_to_nonzero_precision(type_map[ar_type], typerow)
+          when :boolean
+            type_map[ar_type][:limit] = 1
+          end
+        end
+        type_map
+      end
+
+      def choose_type(ar_type)
+        types = @types
+        AR_TO_JDBC_TYPES[ar_type].each do |proc|
+          new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
+          new_types = new_types.select(&proc)
+          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,3 @@
+require 'arjdbc'
+require 'arjdbc/mimer/adapter'
+ArJdbc.warn_unsupported_adapter 'mimer', [4, 2] # warns on AR >= 4.2

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