db2_odbc_adapter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f204595e9630c40fcf1fc1d520f29eae633a06739d1c9b40f6eca716ddff3d9c
+  data.tar.gz: b58bfc5ad2d8b1b910ad19d320f5926f615e6e9ed3ae309ac30482148997105b
+SHA512:
+  metadata.gz: f7fb09975d463f81d0c144278ad1397ad2665546b68e7c6ebb70a57839fa62f477375669deb79ef73cf80c00b9ec6f8aa1864d29efed6600f38bf1d064375638
+  data.tar.gz: e592c5c2f236534f37626b1dc4ba87a9747eb029aa5c763d2e96f33cc2f27e1b4c74582097f9b05c5bc8cab9e1f6f009c3a13966ee1f958489e423ed03ecf37d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'activerecord', '6.0.2.2'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 Localytics http://www.localytics.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# DB2 ODBCAdapter
+
+An ActiveRecord DB2 ODBC adapter. 
+It is a fork of [ActiveRecord odbc_adapter](https://github.com/localytics/odbc_adapter) with a minor heck so that it can work only with DB2 Connection at Rails 6+.
+
+## Installation
+
+Ensure you have the ODBC driver installed on your machine. And have a DB2 server to connect.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'db2_odbc_adapter'
+```
+
+And then execute:
+```
+  $ bundle
+```
+
+Or install it yourself as:
+```
+  $ gem install db2_odbc_adapter
+```
+
+## Usage
+
+Configure your `database.yml` by either using the `dsn` option to point to a DSN that corresponds to a valid entry in your `~/etc/odbc.ini` file:
+
+```
+db2_connection:             // connection name (as you wish)
+  adapter:  odbc            // compulsori
+  dsn: YourDatabaseDSN      // as in the odbc.ini file
+```
+
+and use it at your model as follow.
+
+Single table connection
+
+```ruby
+  class MyTable < ActiveRecord::Base
+    establish_connection :db2_connection
+    self.table_name  = "TableName"       #table name at DB2 server
+    self.primary_key = 'column_name'    #colum that have unique content since db2 have RRN instead of id 
+  end
+
+```
+
+Raw SQL connection
+
+```ruby
+  class MyCustomModel < ActiveRecord::Base
+    establish_connection :db2_connection
+    scope :method_name, -> arg {
+      connection.exec_query("SELECT * FROM .........WHERE ..'#{arg}...")
+    }
+  end
+```
+
+ActiveRecord models that use this connection will now be connecting to the configured database using the ODBC driver.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/db2_odbc_adapter.gemspec

@@ -0,0 +1,21 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'odbc_adapter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'db2_odbc_adapter'
+  spec.version       = ODBCAdapter::VERSION
+  spec.authors       = ['Yohanes']
+  spec.email         = ['yohanes.lumentut@gmail.com']
+
+  spec.summary       = 'An ActiveRecord DB2 ODBC adapter'
+  spec.homepage      = 'https://github.com/yohaneslumentut/db2_odbc_adapter'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ruby-odbc', '~> 0.99999'
+end

data/lib/active_record/connection_adapters/odbc_adapter.rb

@@ -0,0 +1,218 @@
+require 'active_record'
+require 'arel/visitors'
+require 'odbc'
+require 'odbc_utf8'
+
+require 'odbc_adapter/database_limits'
+require 'odbc_adapter/database_statements'
+require 'odbc_adapter/error'
+require 'odbc_adapter/quoting'
+require 'odbc_adapter/schema_statements'
+require 'odbc_adapter/column'
+require 'odbc_adapter/column_metadata'
+require 'odbc_adapter/database_metadata'
+require 'odbc_adapter/version'
+
+module ActiveRecord
+  class Base
+    class << self
+      # Build a new ODBC connection with the given configuration.
+      def odbc_connection(config)
+        config = config.symbolize_keys
+
+        connection, config =
+          if config.key?(:dsn)
+            odbc_dsn_connection(config)
+          elsif config.key?(:conn_str)
+            odbc_conn_str_connection(config)
+          else
+            raise ArgumentError, 'No data source name (:dsn) or connection string (:conn_str) specified.'
+          end
+
+        database_metadata = ::ODBCAdapter::DatabaseMetadata.new(connection, config[:encoding_bug])
+        ::ODBCAdapter::Db2Adapter.new(connection, logger, config, database_metadata)
+      end
+
+      private
+
+      # Connect using a predefined DSN.
+      def odbc_dsn_connection(config)
+        username   = config[:username] ? config[:username].to_s : nil
+        password   = config[:password] ? config[:password].to_s : nil
+        odbc_module = config[:encoding] == 'utf8' ? ODBC_UTF8 : ODBC
+        connection = odbc_module.connect(config[:dsn], username, password)
+
+        # encoding_bug indicates that the driver is using non ASCII and has the issue referenced here https://github.com/larskanis/ruby-odbc/issues/2
+        [connection, config.merge(username: username, password: password, encoding_bug: config[:encoding] == 'utf8')]
+      end
+
+      # Connect using ODBC connection string
+      # Supports DSN-based or DSN-less connections
+      # e.g. "DSN=virt5;UID=rails;PWD=rails"
+      #      "DRIVER={OpenLink Virtuoso};HOST=carlmbp;UID=rails;PWD=rails"
+      def odbc_conn_str_connection(config)
+        attrs = config[:conn_str].split(';').map { |option| option.split('=', 2) }.to_h
+        odbc_module = attrs['ENCODING'] == 'utf8' ? ODBC_UTF8 : ODBC
+        driver = odbc_module::Driver.new
+        driver.name = 'odbc'
+        driver.attrs = attrs
+
+        connection = odbc_module::Database.new.drvconnect(driver)
+        # encoding_bug indicates that the driver is using non ASCII and has the issue referenced here https://github.com/larskanis/ruby-odbc/issues/2
+        [connection, config.merge(driver: driver, encoding: attrs['ENCODING'], encoding_bug: attrs['ENCODING'] == 'utf8')]
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class ODBCAdapter < AbstractAdapter
+      include ::ODBCAdapter::DatabaseLimits
+      include ::ODBCAdapter::DatabaseStatements
+      include ::ODBCAdapter::Quoting
+      include ::ODBCAdapter::SchemaStatements
+
+      ADAPTER_NAME = 'ODBC'.freeze
+      BOOLEAN_TYPE = 'BOOLEAN'.freeze
+
+      ERR_DUPLICATE_KEY_VALUE                     = 23_505
+      ERR_QUERY_TIMED_OUT                         = 57_014
+      ERR_QUERY_TIMED_OUT_MESSAGE                 = /Query has timed out/
+      ERR_CONNECTION_FAILED_REGEX                 = '^08[0S]0[12347]'.freeze
+      ERR_CONNECTION_FAILED_MESSAGE               = /Client connection failed/
+
+      # The object that stores the information that is fetched from the DBMS
+      # when a connection is first established.
+      attr_reader :database_metadata
+
+      def initialize(connection, logger, config, database_metadata)
+        configure_time_options(connection)
+        super(connection, logger, config)
+        @database_metadata = database_metadata
+      end
+
+      # Returns the human-readable name of the adapter.
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      # Does this adapter support migrations? Backend specific, as the abstract
+      # adapter always returns +false+.
+      def supports_migrations?
+        true
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      # Checks whether the connection to the database is still active. This
+      # includes checking whether the database is actually capable of
+      # responding, i.e. whether the connection isn't stale.
+      def active?
+        @connection.connected?
+      end
+
+      # Disconnects from the database if already connected, and establishes a
+      # new connection with the database.
+      def reconnect!
+        disconnect!
+        odbc_module = @config[:encoding] == 'utf8' ? ODBC_UTF8 : ODBC
+        @connection =
+          if @config.key?(:dsn)
+            odbc_module.connect(@config[:dsn], @config[:username], @config[:password])
+          else
+            odbc_module::Database.new.drvconnect(@config[:driver])
+          end
+        configure_time_options(@connection)
+        super
+      end
+      alias reset! reconnect!
+
+      # Disconnects from the database if already connected. Otherwise, this
+      # method does nothing.
+      def disconnect!
+        @connection.disconnect if @connection.connected?
+      end
+
+      # Build a new column object from the given options. Effectively the same
+      # as super except that it also passes in the native type.
+      # rubocop:disable Metrics/ParameterLists
+      def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil, native_type = nil)
+        ::ODBCAdapter::Column.new(name, default, sql_type_metadata, null, table_name, default_function, collation, native_type)
+      end
+
+      protected
+
+      # Build the type map for ActiveRecord
+      # Here, ODBC and ODBC_UTF8 constants are interchangeable
+      def initialize_type_map(map)
+        map.register_type 'boolean',              Type::Boolean.new
+        map.register_type ODBC::SQL_CHAR,         Type::String.new
+        map.register_type ODBC::SQL_LONGVARCHAR,  Type::Text.new
+        map.register_type ODBC::SQL_TINYINT,      Type::Integer.new(limit: 4)
+        map.register_type ODBC::SQL_SMALLINT,     Type::Integer.new(limit: 8)
+        map.register_type ODBC::SQL_INTEGER,      Type::Integer.new(limit: 16)
+        map.register_type ODBC::SQL_BIGINT,       Type::BigInteger.new(limit: 32)
+        map.register_type ODBC::SQL_REAL,         Type::Float.new(limit: 24)
+        map.register_type ODBC::SQL_FLOAT,        Type::Float.new
+        map.register_type ODBC::SQL_DOUBLE,       Type::Float.new(limit: 53)
+        map.register_type ODBC::SQL_DECIMAL,      Type::Float.new
+        map.register_type ODBC::SQL_NUMERIC,      Type::Integer.new
+        map.register_type ODBC::SQL_BINARY,       Type::Binary.new
+        map.register_type ODBC::SQL_DATE,         Type::Date.new
+        map.register_type ODBC::SQL_DATETIME,     Type::DateTime.new
+        map.register_type ODBC::SQL_TIME,         Type::Time.new
+        map.register_type ODBC::SQL_TIMESTAMP,    Type::DateTime.new
+        map.register_type ODBC::SQL_GUID,         Type::String.new
+
+        alias_type map, ODBC::SQL_BIT,            'boolean'
+        alias_type map, ODBC::SQL_VARCHAR,        ODBC::SQL_CHAR
+        alias_type map, ODBC::SQL_WCHAR,          ODBC::SQL_CHAR
+        alias_type map, ODBC::SQL_WVARCHAR,       ODBC::SQL_CHAR
+        alias_type map, ODBC::SQL_WLONGVARCHAR,   ODBC::SQL_LONGVARCHAR
+        alias_type map, ODBC::SQL_VARBINARY,      ODBC::SQL_BINARY
+        alias_type map, ODBC::SQL_LONGVARBINARY,  ODBC::SQL_BINARY
+        alias_type map, ODBC::SQL_TYPE_DATE,      ODBC::SQL_DATE
+        alias_type map, ODBC::SQL_TYPE_TIME,      ODBC::SQL_TIME
+        alias_type map, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP
+      end
+
+      # Translate an exception from the native DBMS to something usable by
+      # ActiveRecord.
+      def translate_exception(exception, message)
+        error_number = exception.message[/^\d+/].to_i
+
+        if error_number == ERR_DUPLICATE_KEY_VALUE
+          ActiveRecord::RecordNotUnique.new(message, exception)
+        elsif error_number == ERR_QUERY_TIMED_OUT || exception.message =~ ERR_QUERY_TIMED_OUT_MESSAGE
+          ::ODBCAdapter::QueryTimeoutError.new(message, exception)
+        elsif exception.message.match(ERR_CONNECTION_FAILED_REGEX) || exception.message =~ ERR_CONNECTION_FAILED_MESSAGE
+          begin
+            reconnect!
+            ::ODBCAdapter::ConnectionFailedError.new(message, exception)
+          rescue => e
+            puts "unable to reconnect #{e}"
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      # Can't use the built-in ActiveRecord map#alias_type because it doesn't
+      # work with non-string keys, and in our case the keys are (almost) all
+      # numeric
+      def alias_type(map, new_type, old_type)
+        map.register_type(new_type) do |_, *args|
+          map.lookup(old_type, *args)
+        end
+      end
+
+      # Ensure ODBC is mapping time-based fields to native ruby objects
+      def configure_time_options(connection)
+        connection.use_time = true
+      end
+    end
+  end
+end
+
+require "odbc_adapter/db2_adapter"

data/lib/odbc_adapter.rb

@@ -0,0 +1,2 @@
+# Requiring with this pattern to mirror ActiveRecord
+require 'active_record/connection_adapters/odbc_adapter'

data/lib/odbc_adapter/column.rb

@@ -0,0 +1,13 @@
+module ODBCAdapter
+  class Column < ActiveRecord::ConnectionAdapters::Column
+    attr_reader :native_type
+
+    # Add the native_type accessor to allow the native DBMS to report back what
+    # it uses to represent the column internally.
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, native_type = nil, default_function = nil, collation = nil)
+      super(name, default, sql_type_metadata, null, table_name)
+      @native_type = native_type
+    end
+  end
+end

data/lib/odbc_adapter/column_metadata.rb

@@ -0,0 +1,76 @@
+module ODBCAdapter
+  class ColumnMetadata
+    GENERICS = {
+      primary_key: [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+      string:      [ODBC::SQL_VARCHAR],
+      text:        [ODBC::SQL_LONGVARCHAR, ODBC::SQL_VARCHAR],
+      integer:     [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+      decimal:     [ODBC::SQL_NUMERIC, ODBC::SQL_DECIMAL],
+      float:       [ODBC::SQL_DOUBLE, ODBC::SQL_REAL],
+      datetime:    [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      timestamp:   [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      time:        [ODBC::SQL_TYPE_TIME, ODBC::SQL_TIME, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      date:        [ODBC::SQL_TYPE_DATE, ODBC::SQL_DATE, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      binary:      [ODBC::SQL_LONGVARBINARY, ODBC::SQL_VARBINARY],
+      boolean:     [ODBC::SQL_BIT, ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT, ODBC::SQL_INTEGER]
+    }.freeze
+
+    attr_reader :adapter
+
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def native_database_types
+      grouped = reported_types.group_by { |row| row[1] }
+
+      GENERICS.each_with_object({}) do |(abstract, candidates), mapped|
+        candidates.detect do |candidate|
+          next unless grouped[candidate]
+          mapped[abstract] = native_type_mapping(abstract, grouped[candidate])
+        end
+      end
+    end
+
+    private
+
+    # Creates a Hash describing a mapping from an abstract type to a
+    # DBMS native type for use by #native_database_types
+    def native_type_mapping(abstract, rows)
+      # The appropriate SQL for :primary_key is hard to derive as
+      # ODBC doesn't provide any info on a DBMS's native syntax for
+      # autoincrement columns. So we use a lookup instead.
+      return adapter.class::PRIMARY_KEY if abstract == :primary_key
+      selected_row = rows[0]
+
+      # If more than one native type corresponds to the SQL type we're
+      # handling, the type in the first descriptor should be the
+      # best match, because the ODBC specification states that
+      # SQLGetTypeInfo returns the results ordered by SQL type and then by
+      # how closely the native type maps to that SQL type.
+      # But, for :text and :binary, select the native type with the
+      # largest capacity. (Compare SQLGetTypeInfo:COLUMN_SIZE values)
+      selected_row = rows.max_by { |row| row[2] } if %i[text binary].include?(abstract)
+      result = { name: selected_row[0] } # SQLGetTypeInfo: TYPE_NAME
+
+      create_params = selected_row[5]
+      # Depending on the column type, the CREATE_PARAMS keywords can
+      # include length, precision or scale.
+      if create_params && !create_params.strip.empty? && abstract != :decimal
+        result[:limit] = selected_row[2] # SQLGetTypeInfo: COL_SIZE
+      end
+
+      result
+    end
+
+    def reported_types
+      @reported_types ||=
+        begin
+          stmt = adapter.raw_connection.types
+          stmt.fetch_all
+        ensure
+          stmt.drop unless stmt.nil?
+        end
+    end
+  end
+end

data/lib/odbc_adapter/database_limits.rb

@@ -0,0 +1,10 @@
+module ODBCAdapter
+  module DatabaseLimits
+    # Returns the maximum length of a table name.
+    def table_alias_length
+      max_identifier_length = database_metadata.max_identifier_len
+      max_table_name_length = database_metadata.max_table_name_len
+      [max_identifier_length, max_table_name_length].max
+    end
+  end
+end

data/lib/odbc_adapter/database_metadata.rb

@@ -0,0 +1,46 @@
+module ODBCAdapter
+  # Caches SQLGetInfo output
+  class DatabaseMetadata
+    FIELDS = %i[
+      SQL_DBMS_NAME
+      SQL_DBMS_VER
+      SQL_IDENTIFIER_CASE
+      SQL_QUOTED_IDENTIFIER_CASE
+      SQL_IDENTIFIER_QUOTE_CHAR
+      SQL_MAX_IDENTIFIER_LEN
+      SQL_MAX_TABLE_NAME_LEN
+      SQL_USER_NAME
+      SQL_DATABASE_NAME
+    ].freeze
+
+    attr_reader :values
+
+    # has_encoding_bug refers to https://github.com/larskanis/ruby-odbc/issues/2 where ruby-odbc in UTF8 mode
+    # returns incorrectly encoded responses to getInfo
+    def initialize(connection, has_encoding_bug = false)
+      @values = Hash[FIELDS.map do |field|
+        info = connection.get_info(ODBC.const_get(field))
+        info = info.encode(Encoding.default_external, 'UTF-16LE') if info.is_a?(String) && has_encoding_bug
+        [field, info]
+      end]
+    end
+
+    def upcase_identifiers?
+      @upcase_identifiers ||= (identifier_case == ODBC::SQL_IC_UPPER)
+    end
+
+    # A little bit of metaprogramming magic here to create accessors for each of
+    # the fields reported on by the DBMS.
+    FIELDS.each do |field|
+      define_method(field.to_s.downcase.gsub('sql_', '')) do
+        value_for(field)
+      end
+    end
+
+    private
+
+    def value_for(field)
+      values[field]
+    end
+  end
+end

data/lib/odbc_adapter/database_statements.rb

@@ -0,0 +1,134 @@
+module ODBCAdapter
+  module DatabaseStatements
+    # ODBC constants missing from Christian Werner's Ruby ODBC driver
+    SQL_NO_NULLS = 0
+    SQL_NULLABLE = 1
+    SQL_NULLABLE_UNKNOWN = 2
+
+    # Executes the SQL statement in the context of this connection.
+    # Returns the number of rows affected.
+    def execute(sql, name = nil, binds = [])
+      log(sql, name) do
+        if prepared_statements
+          @connection.do(sql, *prepared_binds(binds))
+        else
+          @connection.do(sql)
+        end
+      end
+    end
+
+    # Executes +sql+ statement in the context of this connection using
+    # +binds+ as the bind substitutes. +name+ is logged along with
+    # the executed +sql+ statement.
+    def exec_query(sql, name = 'SQL', binds = [], prepare: false) # rubocop:disable Lint/UnusedMethodArgument
+      log(sql, name) do
+        stmt =
+          if prepared_statements
+            @connection.run(sql, *prepared_binds(binds))
+          else
+            @connection.run(sql)
+          end
+
+        columns = stmt.columns
+        values  = stmt.to_a
+        stmt.drop
+
+        values = dbms_type_cast(columns.values, values)
+        column_names = columns.keys.map { |key| format_case(key) }
+        ActiveRecord::Result.new(column_names, values)
+      end
+    end
+
+    # Executes delete +sql+ statement in the context of this connection using
+    # +binds+ as the bind substitutes. +name+ is logged along with
+    # the executed +sql+ statement.
+    def exec_delete(sql, name, binds)
+      execute(sql, name, binds)
+    end
+    alias exec_update exec_delete
+
+    # Begins the transaction (and turns off auto-committing).
+    def begin_db_transaction
+      @connection.autocommit = false
+    end
+
+    # Commits the transaction (and turns on auto-committing).
+    def commit_db_transaction
+      @connection.commit
+      @connection.autocommit = true
+    end
+
+    # Rolls back the transaction (and turns on auto-committing). Must be
+    # done if the transaction block raises an exception or returns false.
+    def exec_rollback_db_transaction
+      @connection.rollback
+      @connection.autocommit = true
+    end
+
+    # Returns the default sequence name for a table.
+    # Used for databases which don't support an autoincrementing column
+    # type, but do support sequences.
+    def default_sequence_name(table, _column)
+      "#{table}_seq"
+    end
+
+    private
+
+    # A custom hook to allow end users to overwrite the type casting before it
+    # is returned to ActiveRecord. Useful before a full adapter has made its way
+    # back into this repository.
+    def dbms_type_cast(_columns, values)
+      values
+    end
+
+    # Assume received identifier is in DBMS's data dictionary case.
+    def format_case(identifier)
+      if database_metadata.upcase_identifiers?
+        identifier =~ /[a-z]/ ? identifier : identifier.downcase
+      else
+        identifier
+      end
+    end
+
+    # In general, ActiveRecord uses lowercase attribute names. This may
+    # conflict with the database's data dictionary case.
+    #
+    # The ODBCAdapter uses the following conventions for databases
+    # which report SQL_IDENTIFIER_CASE = SQL_IC_UPPER:
+    # * if a name is returned from the DBMS in all uppercase, convert it
+    #   to lowercase before returning it to ActiveRecord.
+    # * if a name is returned from the DBMS in lowercase or mixed case,
+    #   assume the underlying schema object's name was quoted when
+    #   the schema object was created. Leave the name untouched before
+    #   returning it to ActiveRecord.
+    # * before making an ODBC catalog call, if a supplied identifier is all
+    #   lowercase, convert it to uppercase. Leave mixed case or all
+    #   uppercase identifiers unchanged.
+    # * columns created with quoted lowercase names are not supported.
+    #
+    # Converts an identifier to the case conventions used by the DBMS.
+    # Assume received identifier is in ActiveRecord case.
+    def native_case(identifier)
+      if database_metadata.upcase_identifiers?
+        identifier =~ /[A-Z]/ ? identifier : identifier.upcase
+      else
+        identifier
+      end
+    end
+
+    # Assume column is nullable if nullable == SQL_NULLABLE_UNKNOWN
+    def nullability(col_name, is_nullable, nullable)
+      not_nullable = (!is_nullable || !nullable.to_s.match('NO').nil?)
+      result = !(not_nullable || nullable == SQL_NO_NULLS)
+
+      # HACK!
+      # MySQL native ODBC driver doesn't report nullability accurately.
+      # So force nullability of 'id' columns
+      col_name == 'id' ? false : result
+    end
+
+    def prepared_binds(binds)
+      prepare_binds_for_database(binds).map { |bind| _type_cast(bind) }
+    end
+  end
+end

data/lib/odbc_adapter/db2_adapter.rb

@@ -0,0 +1,16 @@
+module ODBCAdapter
+  class Db2Adapter < ActiveRecord::ConnectionAdapters::ODBCAdapter
+
+    def arel_visitor
+      Arel::Visitors::IBM_DB.new(self)
+    end
+
+    def prepared_statements
+      false
+    end
+
+    def supports_migrations?
+      false
+    end
+  end
+end

data/lib/odbc_adapter/error.rb

@@ -0,0 +1,6 @@
+module ODBCAdapter
+  class QueryTimeoutError < ActiveRecord::StatementInvalid
+  end
+  class ConnectionFailedError < ActiveRecord::StatementInvalid
+  end
+end

data/lib/odbc_adapter/quoting.rb

@@ -0,0 +1,42 @@
+module ODBCAdapter
+  module Quoting
+    # Quotes a string, escaping any ' (single quote) characters.
+    def quote_string(string)
+      string.gsub(/\'/, "''")
+    end
+
+    # Returns a quoted form of the column name.
+    def quote_column_name(name)
+      name = name.to_s
+      quote_char = database_metadata.identifier_quote_char.to_s.strip
+
+      return name if quote_char.length.zero?
+      quote_char = quote_char[0]
+
+      # Avoid quoting any already quoted name
+      return name if name[0] == quote_char && name[-1] == quote_char
+
+      # If upcase identifiers, only quote mixed case names.
+      if database_metadata.upcase_identifiers?
+        return name unless name =~ /([A-Z]+[a-z])|([a-z]+[A-Z])/
+      end
+
+      "#{quote_char.chr}#{name}#{quote_char.chr}"
+    end
+
+    # Ideally, we'd return an ODBC date or timestamp literal escape
+    # sequence, but not all ODBC drivers support them.
+    def quoted_date(value)
+      if value.acts_like?(:time)
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.respond_to?(zone_conversion_method)
+          value = value.send(zone_conversion_method)
+        end
+        value.strftime('%Y-%m-%d %H:%M:%S') # Time, DateTime
+      else
+        value.strftime('%Y-%m-%d') # Date
+      end
+    end
+  end
+end

data/lib/odbc_adapter/schema_statements.rb

@@ -0,0 +1,131 @@
+module ODBCAdapter
+  module SchemaStatements
+    # Returns a Hash of mappings from the abstract data types to the native
+    # database types. See TableDefinition#column for details on the recognized
+    # abstract data types.
+    def native_database_types
+      @native_database_types ||= ColumnMetadata.new(self).native_database_types
+    end
+
+    # Returns an array of table names, for database tables visible on the
+    # current connection.
+    def tables(_name = nil)
+      stmt   = @connection.tables
+      result = stmt.fetch_all || []
+      stmt.drop
+
+      result.each_with_object([]) do |row, table_names|
+        schema_name, table_name, table_type = row[1..3]
+        next if respond_to?(:table_filtered?) && table_filtered?(schema_name, table_type)
+        table_names << format_case(table_name)
+      end
+    end
+
+    # Returns an array of view names defined in the database.
+    def views
+      []
+    end
+
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, _name = nil)
+      stmt   = @connection.indexes(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+
+      index_cols = []
+      index_name = nil
+      unique     = nil
+
+      result.each_with_object([]).with_index do |(row, indices), row_idx|
+        # Skip table statistics
+        next if row[6].zero? # SQLStatistics: TYPE
+
+        if row[7] == 1 # SQLStatistics: ORDINAL_POSITION
+          # Start of column descriptor block for next index
+          index_cols = []
+          unique     = row[3].zero? # SQLStatistics: NON_UNIQUE
+          index_name = String.new(row[5]) # SQLStatistics: INDEX_NAME
+        end
+
+        index_cols << format_case(row[8]) # SQLStatistics: COLUMN_NAME
+        next_row = result[row_idx + 1]
+
+        if (row_idx == result.length - 1) || (next_row[6].zero? || next_row[7] == 1)
+          indices << ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, format_case(index_name), unique, index_cols)
+        end
+      end
+    end
+
+    # Returns an array of Column objects for the table specified by
+    # +table_name+.
+    def columns(table_name, _name = nil)
+      stmt   = @connection.columns(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop
+
+      result.each_with_object([]) do |col, cols|
+        col_name        = col[3]  # SQLColumns: COLUMN_NAME
+        col_default     = col[12] # SQLColumns: COLUMN_DEF
+        col_sql_type    = col[4]  # SQLColumns: DATA_TYPE
+        col_native_type = col[5]  # SQLColumns: TYPE_NAME
+        col_limit       = col[6]  # SQLColumns: COLUMN_SIZE
+        col_scale       = col[8]  # SQLColumns: DECIMAL_DIGITS
+
+        # SQLColumns: IS_NULLABLE, SQLColumns: NULLABLE
+        col_nullable = nullability(col_name, col[17], col[10])
+
+        args = { sql_type: col_sql_type, type: col_sql_type, limit: col_limit }
+        args[:sql_type] = 'boolean' if col_native_type == self.class::BOOLEAN_TYPE
+
+        if [ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC].include?(col_sql_type)
+          args[:scale]     = col_scale || 0
+          args[:precision] = col_limit
+        end
+        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(**args)
+
+        cols << new_column(format_case(col_name), col_default, sql_type_metadata, col_nullable, table_name, col_native_type)
+      end
+    end
+
+    # Returns just a table's primary key
+    def primary_key(table_name)
+      stmt   = @connection.primary_keys(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+      result[0] && result[0][3]
+    end
+
+    def foreign_keys(table_name)
+      stmt   = @connection.foreign_keys(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+
+      result.map do |key|
+        fk_from_table      = key[2]  # PKTABLE_NAME
+        fk_to_table        = key[6]  # FKTABLE_NAME
+
+        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
+          fk_from_table,
+          fk_to_table,
+          name:        key[11], # FK_NAME
+          column:      key[3],  # PKCOLUMN_NAME
+          primary_key: key[7],  # FKCOLUMN_NAME
+          on_delete:   key[10], # DELETE_RULE
+          on_update:   key[9]   # UPDATE_RULE
+        )
+      end
+    end
+
+    # Ensure it's shorter than the maximum identifier length for the current
+    # dbms
+    def index_name(table_name, options)
+      maximum = database_metadata.max_identifier_len || 255
+      super(table_name, options)[0...maximum]
+    end
+
+    def current_database
+      byebug
+      database_metadata.database_name.strip
+    end
+  end
+end

data/lib/odbc_adapter/version.rb

@@ -0,0 +1,3 @@
+module ODBCAdapter
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: db2_odbc_adapter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yohanes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-odbc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99999'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99999'
+description: 
+email:
+- yohanes.lumentut@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- db2_odbc_adapter.gemspec
+- lib/active_record/connection_adapters/odbc_adapter.rb
+- lib/odbc_adapter.rb
+- lib/odbc_adapter/column.rb
+- lib/odbc_adapter/column_metadata.rb
+- lib/odbc_adapter/database_limits.rb
+- lib/odbc_adapter/database_metadata.rb
+- lib/odbc_adapter/database_statements.rb
+- lib/odbc_adapter/db2_adapter.rb
+- lib/odbc_adapter/error.rb
+- lib/odbc_adapter/quoting.rb
+- lib/odbc_adapter/schema_statements.rb
+- lib/odbc_adapter/version.rb
+homepage: https://github.com/yohaneslumentut/db2_odbc_adapter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord DB2 ODBC adapter
+test_files: []