db2_query 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d96a31dfec03b3e0b1fbecff08c2fe16bc85460bb168081fde94c431d45f3c6
-  data.tar.gz: cbeb3d3342a33a28c222a45fa50bb5ebeec4271195d864b74b7cffe0298519a5
+  metadata.gz: a54ab3ca53e8078aee466400a89ec9b18c5c5ed65450d6d35cdf7a8552e0e21c
+  data.tar.gz: 72ad54eb98b13a471ba8e022e57cb686a31cf7a2e1d833a4d54d833f3d900105
 SHA512:
-  metadata.gz: 7f18c6256a2186145f91380f2d828aa4eaacce7731a2f7f89ad56da22563506e7088ca5a909c3edd9723fd49b4cbec0f0301f9c486a8af0979c3c770077da980
-  data.tar.gz: 23e3ce4cedcae00e4570edc47bd6316dac424c5b264ef67daebda977d84f16e2d89aede6d6d27663ba13465ec300f7a4a16d50d36144e070ea56fdb1b141d552
+  metadata.gz: a037c568900f33c3eefdc2692fd0d8d470dc4167ff87f3b1c0fa11902204fb38523b4bc257cf6cac069590a9706f1c94f506fc13fd35aa7388495fc9e28ea84a
+  data.tar.gz: 9f1815d05567d1f972ff1f7d0ff5324a2d11781ae0000b13b552c1c21b4da260de7e7e0d8a633fb48a5ce5636ceea7f90e1fe0a509352a7ff99779788ef0b7d7

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/db2_query.svg)](https://badge.fury.io/rb/db2_query)
 
-A Rails query plugin to fetch data from Db2 database by using ODBC connection.
+A Rails 6+ query plugin to fetch data from Db2 database by using ODBC connection
 
 ## Installation
 Add this line to your application's Gemfile:
@@ -20,8 +20,6 @@ Or install it yourself as:
 ```bash
 $ gem install db2_query
 ```
-## Note
-Start v.0.2.0, this module use `DB2Query` instead of `Db2Query`
 
 ## Initialization
 Execute init task at the app root
@@ -30,10 +28,16 @@ $ rake db2query:init
 ```
 DB2Query will generate two required files:
 - `config/db2query_database.yml`
-- `config/initializers/db2query`
+- `config/initializers/db2query.rb`
 
 Edit these files according to the requirement.
 
+Note: 
+
+To upgrade from the previous version to v.0.2.1, please delete all the files generated by init task and do init task again (don't forget to backup your db2query_database.yml).
+
+In v.0.2.0, we have to `require 'db2_query'` at initializer manually.
+
 ### Database Configuration
 At `db2query_database.yml` we can use two type of connection:
 1. DSN connection config
@@ -59,7 +63,27 @@ development:
     pwd: <%= ENV["ISERIES_PWD"] %>
 ```
 
+Ensure that `unixodbc` have been installed and test your connection first by using `isql` commands.
+
+Example:
+
+Secondary database connection test
+```bash
+$ isql -v iseries
++---------------------------------------+
+| Connected!                            |
+|                                       |
+| sql-statement                         |
+| help [tablename]                      |
+| quit                                  |
+|                                       |
++---------------------------------------+
+SQL> 
+```
+
 ## Usage
+Note: Version 0.1.0 use `Db2Query` namespace. Please use `DB2Query` in versions greater than it.
+
 ### Basic Usage
 Create query class that inherit from `DB2Query::Base` in `app/queries` folder
 ```ruby
@@ -83,7 +107,7 @@ User.find_by 10000
 SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE id = ? [[nil, 10000]]
 => #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
-Or using keywords argument
+Or using keywords argument if the sql use `=` operator, e.g `first_name = ?`
 ```bash
 User.by_name first_name: "Strange", last_name: "Stephen"
 SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ? [["first_name", Strange], ["last_name", Stephen]]
@@ -116,12 +140,58 @@ end
 Check it at rails console
 ```bash
 Doctor.find_by id: 10000
-SQL Load (30.28ms)  SELECT * FROM LIBTEST.USERS WHERE id = ? [["id", 10000]]
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE id = ? [["id", 10000]]
 => #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Dr.Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
 
 ### Available methods
-`DB2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom `records` method.
+`DB2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom methods:
+  1. `records` to convert query result into array of Record objects.
+  2. `to_h` to convert query result into hash with symbolized keys.
+
+### ActiveRecord Combination
+
+Create an abstract class that inherit from `ActiveRecord::Base`
+```ruby
+class Db2Record < ActiveRecord::Base
+  self.abstract_class = true
+
+  def self.query(sql, formatter = {}, args = [])
+    DB2Query::Base.connection.exec_query(sql, formatter, args).to_a.map(&:deep_symbolize_keys)
+  end
+end
+```
+
+Utilize the goodness of rails model `scope`
+```ruby
+class User < Db2Record
+  scope :by_name, -> *args {
+    query(
+      "SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ?", {}, args
+    )
+  }
+end
+```
+```bash
+User.by_name first_name: "Strange", last_name: "Stephen"
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ? [["first_name", Strange], ["last_name", Stephen]]
+=> [{:id=> 10000, :first_name=> "Strange", :last_name=> "Stephen", :email=> "strange@marvel.universe.com"}]
+```
+
+Another example:
+```ruby
+class User < Db2Record
+  scope :age_gt, -> age {
+    query("SELECT * FROM LIBTEST.USERS WHERE age > #{age}")
+  }
+end
+```
+
+```bash
+User.age_gt 500
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE age > 500
+=> [{:id=> 99999, :first_name=> "Ancient", :last_name=> "One", :email=> "ancientone@marvel.universe.com"}]
+```
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/db2_query.rb

@@ -4,8 +4,8 @@ require "yaml"
 require "erb"
 require "active_record"
 require "active_support"
-require "active_record/database_configurations"
 require "db2_query/config"
+require "db2_query/connection_handling"
 
 module DB2Query
   extend ActiveSupport::Autoload
@@ -13,8 +13,8 @@ module DB2Query
   autoload :Version
   autoload :Base
   autoload :Core
-  autoload :ConnectionHandling
   autoload :DatabaseStatements
+  autoload :Connection
   autoload :ODBCConnector
   autoload :Formatter
   autoload :Result

data/lib/db2_query/base.rb

@@ -2,9 +2,8 @@
 
 module DB2Query
   class Base
-    include DB2Query::Core
     include ActiveRecord::Inheritance
-    extend ActiveSupport::Concern
+    include DB2Query::Core
     extend ActiveRecord::ConnectionHandling
     extend DB2Query::ConnectionHandling
   end

data/lib/db2_query/config.rb

@@ -20,11 +20,7 @@ module DB2Query
 
     def read_config
       erb = ERB.new(config_file.read)
-      YAML.parse(erb.result(binding)).transform
-    end
-
-    def connection_env
-      ENV["RAILS_ENV"].to_sym
+      YAML.parse(erb.result(binding)).transform.transform_keys(&:to_sym)
     end
   end
 end

data/lib/db2_query/connection.rb

@@ -0,0 +1,163 @@
+# frozen_String_literal: true
+
+module DB2Query
+  class Connection
+    ADAPTER_NAME = "DB2Query"
+
+    include DB2Query::DatabaseStatements
+    include ActiveSupport::Callbacks
+    define_callbacks :checkout, :checkin
+
+    set_callback :checkin, :after, :enable_lazy_transactions!
+
+    attr_accessor :pool
+    attr_reader :owner, :connector, :lock
+    alias :in_use? :owner
+
+    def initialize(type, config)
+      @connector = DB2Query::ODBCConnector.new(type, config)
+      @instrumenter  = ActiveSupport::Notifications.instrumenter
+      @config = config
+      @pool = ActiveRecord::ConnectionAdapters::NullPool.new
+      @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+      connect
+    end
+
+    def adapter_name
+      self.class::ADAPTER_NAME
+    end
+
+    def current_transaction
+    end
+
+    def begin_transaction(options = {})
+    end
+
+    def transaction_open?
+    end
+
+    def requires_reloading?
+      false
+    end
+
+    def close
+      pool.checkin self
+    end
+
+    def connect
+      @connection = connector.connect
+    end
+
+    def active?
+      @connection.connected?
+    end
+
+    def reconnect!
+      disconnect!
+      connect
+    end
+    alias reset! reconnect!
+
+    def disconnect!
+      if @connection.connected?
+        @connection.commit
+        @connection.disconnect
+      end
+    end
+
+    def check_version
+    end
+
+    def enable_lazy_transactions!
+      @lazy_transactions_enabled = true
+    end
+
+    def lease
+      if in_use?
+        msg = +"Cannot lease connection, "
+        if @owner == Thread.current
+          msg << "it is already leased by the current thread."
+        else
+          msg << "it is already in use by a different thread: #{@owner}. " \
+                  "Current thread: #{Thread.current}."
+        end
+        raise ActiveRecordError, msg
+      end
+
+      @owner = Thread.current
+    end
+
+    def verify!
+      reconnect! unless active?
+    end
+
+    def translate_exception_class(e, sql, binds)
+      message = "#{e.class.name}: #{e.message}"
+
+      exception = translate_exception(
+        e, message: message, sql: sql, binds: binds
+      )
+      exception.set_backtrace e.backtrace
+      exception
+    end
+
+    def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+      @instrumenter.instrument(
+        "sql.active_record",
+        sql:               sql,
+        name:              name,
+        binds:             binds,
+        type_casted_binds: type_casted_binds,
+        statement_name:    statement_name,
+        connection_id:     object_id,
+        connection:        self) do
+        @lock.synchronize do
+          yield
+        end
+      rescue => e
+        raise translate_exception_class(e, sql, binds)
+      end
+    end
+
+    def translate_exception(exception, message:, sql:, binds:)
+      case exception
+      when RuntimeError
+        exception
+      else
+        ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+      end
+    end
+
+    def expire
+      if in_use?
+        if @owner != Thread.current
+          raise ActiveRecordError, "Cannot expire connection, " \
+            "it is owned by a different thread: #{@owner}. " \
+            "Current thread: #{Thread.current}."
+        end
+
+        @idle_since = Concurrent.monotonic_time
+        @owner = nil
+      else
+        raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
+      end
+    end
+
+    def steal!
+      if in_use?
+        if @owner != Thread.current
+          pool.send :remove_connection_from_thread_cache, self, @owner
+
+          @owner = Thread.current
+        end
+      else
+        raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
+      end
+    end
+
+    def seconds_idle # :nodoc:
+      return 0 if in_use?
+      Concurrent.monotonic_time - @idle_since
+    end
+  end
+end

data/lib/db2_query/connection_handling.rb

@@ -1,17 +1,87 @@
 # frozen_string_literal: true
 
 module DB2Query
+  CONNECTION_TYPES = %i[dsn conn_string].freeze
+
+  class ConnectionPool < ActiveRecord::ConnectionAdapters::ConnectionPool
+    attr_reader :conn_type
+
+    def initialize(spec)
+      @conn_type = (spec.config.keys & DB2Query::CONNECTION_TYPES).first
+      super(spec)
+    end
+
+    private
+      def new_connection
+        DB2Query::Connection.new(conn_type, spec.config)
+      end
+  end
+
+  class ConnectionSpecification #:nodoc:
+    attr_reader :name, :config
+
+    def initialize(name, config)
+      @name, @config = name, config
+    end
+
+    def initialize_dup(original)
+      @config = original.config.dup
+    end
+
+    def to_hash
+      @config.merge(name: @name)
+    end
+
+    class Resolver < ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
+      def spec(config)
+        pool_name = config if config.is_a?(Symbol)
+        spec = resolve(config, pool_name).symbolize_keys
+        ConnectionSpecification.new(spec.delete(:name) || "primary", spec)
+      end
+    end
+  end
+
+  class ConnectionHandler < ActiveRecord::ConnectionAdapters::ConnectionHandler
+    def establish_connection(config)
+      resolver = ConnectionSpecification::Resolver.new(DB2Query::Base.configurations)
+
+      spec = resolver.spec(config)
+
+      remove_connection(spec.name)
+
+      message_bus = ActiveSupport::Notifications.instrumenter
+      payload = {
+        connection_id: object_id
+      }
+      if spec
+        payload[:spec_name] = spec.name
+        payload[:config] = spec.config
+      end
+
+      message_bus.instrument("!connection.active_record", payload) do
+        owner_to_pool[spec.name] = DB2Query::ConnectionPool.new(spec)
+      end
+
+      owner_to_pool[spec.name]
+    end
+  end
+
   module ConnectionHandling
     RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
+    def lookup_connection_handler(handler_key) # :nodoc:
+      handler_key = DB2Query::Base.reading_role
+      connection_handlers[handler_key] ||= DB2Query::ConnectionHandler.new
+    end
+
     def resolve_config_for_connection(config_or_env) # :nodoc:
       raise "Anonymous class is not allowed." unless name
 
       config_or_env ||= DEFAULT_ENV.call.to_sym
       pool_name = primary_class? ? "primary" : name
       self.connection_specification_name = pool_name
-      resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(Base.configurations)
+      resolver = DB2Query::ConnectionSpecification::Resolver.new(DB2Query::Base.configurations)
 
       config_hash = resolver.resolve(config_or_env, pool_name).symbolize_keys
       config_hash[:name] = pool_name
@@ -21,13 +91,22 @@ module DB2Query
 
     def connection_specification_name
       if !defined?(@connection_specification_name) || @connection_specification_name.nil?
-        return self == Base ? "primary" : superclass.connection_specification_name
+        return self == DB2Query::Base ? "primary" : superclass.connection_specification_name
       end
       @connection_specification_name
     end
 
     def primary_class?
-      self == Base || defined?(ApplicationRecord) && self == ApplicationRecord
+      self == DB2Query::Base || defined?(Db2Record) && self == Db2Record
     end
+
+    private
+      def swap_connection_handler(handler, &blk) # :nodoc:
+        old_handler, DB2Query::Base.connection_handler = DB2Query::Base.connection_handler, handler
+        return_value = yield
+        return_value
+      ensure
+        DB2Query::Base.connection_handler = old_handler
+      end
   end
 end

data/lib/db2_query/core.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "active_record/database_configurations"
+
 module DB2Query
   module Core
     extend ActiveSupport::Concern
 
-    included do |base|
+    included do
       def self.configurations=(config)
         @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
       end
@@ -14,28 +16,26 @@ module DB2Query
         @@configurations
       end
 
-      class_attribute :default_connection_handler
-
       mattr_accessor :connection_handlers, instance_accessor: false, default: {}
 
-      mattr_accessor :writing_role, instance_accessor: false, default: :writing
-
-      mattr_accessor :reading_role, instance_accessor: false, default: :reading
+      class_attribute :default_connection_handler
 
       def self.connection_handler
-        Thread.current.thread_variable_get("ar_connection_handler") || default_connection_handler
+        Thread.current.thread_variable_get("db2q_connection_handler") || default_connection_handler
       end
 
       def self.connection_handler=(handler)
-        Thread.current.thread_variable_set("ar_connection_handler", handler)
+        Thread.current.thread_variable_set("db2q_connection_handler", handler)
       end
 
-      self.default_connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-
-      base.extend ClassMethods
+      self.default_connection_handler = DB2Query::ConnectionHandler.new
     end
 
     module ClassMethods
+      def initiation
+        yield(self) if block_given?
+      end
+
       def attributes(attr_name, format)
         formatters.store(attr_name, format)
       end

data/lib/db2_query/database_statements.rb

@@ -48,6 +48,11 @@ module DB2Query
     end
 
     private
+      def single_value_from_rows(rows)
+        row = rows.first
+        row && row.first
+      end
+
       def key_finder_regex(k)
         /#{k} =\\? | #{k}=\\? | #{k}= \\? /i
       end

data/lib/db2_query/odbc_connector.rb

@@ -1,31 +1,33 @@
 # frozen_String_literal: true
 
-module DB2Query
-  CONNECTION_TYPES = %i[dsn conn_string].freeze
+require "odbc_utf8"
 
+module DB2Query
   class ODBCConnector
-    attr_reader :connector, :conn_type, :conn_config
-
-    def initialize(type, config)
-      @conn_type, @conn_config = type, config.transform_keys(&:to_sym)
-      @connector = DB2Query.const_get("#{conn_type.to_s.camelize}Connector").new
+    def self.new(type, config)
+      conn_type, conn_config = type, config.transform_keys(&:to_sym)
+      DB2Query.const_get("#{conn_type.to_s.camelize}Connector").new(conn_config)
     end
+  end
 
-    def connect
-      connector.connect(conn_config)
+  class AbstractConnector
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
     end
   end
 
-  class DsnConnector
-    def connect(config)
+  class DsnConnector < AbstractConnector
+    def connect
       ::ODBC.connect(config[:dsn], config[:uid], config[:pwd])
     rescue ::ODBC::Error => e
       raise ArgumentError, "Unable to activate ODBC DSN connection #{e}"
     end
   end
 
-  class ConnStringConnector
-    def connect(config)
+  class ConnStringConnector < AbstractConnector
+    def connect
       driver = ::ODBC::Driver.new.tap do |d|
         d.attrs = config[:conn_string].transform_keys(&:to_s)
         d.name = "odbc"

data/lib/db2_query/railtie.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'db2_query'
-require 'rails'
+require "db2_query"
+require "rails"
 
 module DB2Query
   class Railtie < Rails::Railtie

data/lib/db2_query/result.rb

@@ -15,6 +15,12 @@ module DB2Query
       end
     end
 
+    def to_h
+      rows.map do |row|
+        columns.zip(row).each_with_object({}) { |cr, h| h[cr[0].to_sym] = cr[1] }
+      end
+    end
+
     def inspect
       entries = records.take(11).map!(&:inspect)
 
@@ -25,7 +31,7 @@ module DB2Query
 
     class Record
       attr_reader :formatters
-    
+
       def initialize(row, columns, formatters)
         @formatters = formatters
         columns.zip(row) do |col, val|

data/lib/db2_query/tasks/init.rake

@@ -6,4 +6,4 @@ namespace :db2query do
     Rake::Task["db2query:initializer"].invoke
     Rake::Task["db2query:database"].invoke
   end
-end
+end

data/lib/db2_query/tasks/initializer.rake

@@ -6,6 +6,11 @@ DB2_QUERY_INITIALIZER_TEMPLATE ||= <<-EOF
 require "db2_query"
 require "db2_query/formatter"
 
+DB2Query::Base.initiation do |base|
+  base.configurations = base.parent.config
+  base.establish_connection ENV['RAILS_ENV'].to_sym
+end
+
 # Example
 
 class FirstNameFormatter < DB2Query::AbstractFormatter
@@ -34,4 +39,4 @@ namespace :db2query do
       puts "  File '#{initializer_path}' created."
     end
   end
-end
+end

data/lib/db2_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DB2Query
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db2_query
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - yohanes_l
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-odbc
@@ -31,9 +31,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 6.0.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,9 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 6.0.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.0.3.1
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -51,9 +45,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 6.0.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -61,9 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 6.0.3
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.0.3.1
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -172,10 +160,10 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- lib/active_record/connection_adapters/db2_query_adapter.rb
 - lib/db2_query.rb
 - lib/db2_query/base.rb
 - lib/db2_query/config.rb
+- lib/db2_query/connection.rb
 - lib/db2_query/connection_handling.rb
 - lib/db2_query/core.rb
 - lib/db2_query/database_statements.rb
@@ -207,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: DB2Query

data/lib/active_record/connection_adapters/db2_query_adapter.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require "odbc_utf8"
-require "db2_query/odbc_connector"
-require "db2_query/database_statements"
-
-module ActiveRecord
-  module ConnectionHandling
-    def db2_query_connection(config)
-      conn_type = (config.keys & DB2Query::CONNECTION_TYPES).first
-      if conn_type.nil?
-        raise ArgumentError, "No data source name (:dsn) or connection string (:conn_str) provided."
-      end
-      connector = DB2Query::ODBCConnector.new(conn_type, config)
-      ConnectionAdapters::DB2QueryConnection.new(connector, config)
-    end
-  end
-
-  module ConnectionAdapters
-    class DB2QueryConnection
-      include DB2Query::DatabaseStatements
-      include ActiveSupport::Callbacks
-      define_callbacks :checkout, :checkin
-
-      set_callback :checkin, :after, :enable_lazy_transactions!
-
-      attr_accessor :pool
-      attr_reader :owner, :connector, :lock
-      alias :in_use? :owner
-
-      def initialize(connector, config)
-        @connector = connector
-        @instrumenter  = ActiveSupport::Notifications.instrumenter
-        @config = config
-        @pool = ActiveRecord::ConnectionAdapters::NullPool.new
-        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
-        connect
-      end
-
-      def connect
-        @connection = connector.connect
-        @connection.use_time = true
-      end
-
-      def active?
-        @connection.connected?
-      end
-
-      def reconnect!
-        disconnect!
-        connect
-      end
-      alias reset! reconnect!
-
-      def disconnect!
-        if @connection.connected?
-          @connection.commit
-          @connection.disconnect
-        end
-      end
-
-      def check_version
-      end
-
-      def enable_lazy_transactions!
-        @lazy_transactions_enabled = true
-      end
-
-      def lease
-        if in_use?
-          msg = +"Cannot lease connection, "
-          if @owner == Thread.current
-            msg << "it is already leased by the current thread."
-          else
-            msg << "it is already in use by a different thread: #{@owner}. " \
-                   "Current thread: #{Thread.current}."
-          end
-          raise ActiveRecordError, msg
-        end
-
-        @owner = Thread.current
-      end
-
-      def verify!
-        reconnect! unless active?
-      end
-
-      def translate_exception_class(e, sql, binds)
-        message = "#{e.class.name}: #{e.message}"
-
-        exception = translate_exception(
-          e, message: message, sql: sql, binds: binds
-        )
-        exception.set_backtrace e.backtrace
-        exception
-      end
-
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
-        @instrumenter.instrument(
-          "sql.active_record",
-          sql:               sql,
-          name:              name,
-          binds:             binds,
-          type_casted_binds: type_casted_binds,
-          statement_name:    statement_name,
-          connection_id:     object_id,
-          connection:        self) do
-          @lock.synchronize do
-            yield
-          end
-        rescue => e
-          raise translate_exception_class(e, sql, binds)
-        end
-      end
-
-      def translate_exception(exception, message:, sql:, binds:)
-        case exception
-        when RuntimeError
-          exception
-        else
-          ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
-        end
-      end
-
-      def expire
-        if in_use?
-          if @owner != Thread.current
-            raise ActiveRecordError, "Cannot expire connection, " \
-              "it is owned by a different thread: #{@owner}. " \
-              "Current thread: #{Thread.current}."
-          end
-
-          @idle_since = Concurrent.monotonic_time
-          @owner = nil
-        else
-          raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
-        end
-      end
-
-      def steal!
-        if in_use?
-          if @owner != Thread.current
-            pool.send :remove_connection_from_thread_cache, self, @owner
-
-            @owner = Thread.current
-          end
-        else
-          raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
-        end
-      end
-
-      def seconds_idle # :nodoc:
-        return 0 if in_use?
-        Concurrent.monotonic_time - @idle_since
-      end
-
-      private
-        def type_map
-          @type_map ||= Type::TypeMap.new.tap do |mapping|
-            initialize_type_map(mapping)
-          end
-        end
-
-        def alias_type(map, new_type, old_type)
-          map.register_type(new_type) do |_, *args|
-            map.lookup(old_type, *args)
-          end
-        end
-
-        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
-    end
-  end
-end