db2_query 0.2.2 → 0.3.2

data/lib/db2_query/connection.rb

@@ -1,163 +0,0 @@
-# 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,112 +0,0 @@
-# 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 = DB2Query::ConnectionSpecification::Resolver.new(DB2Query::Base.configurations)
-
-      config_hash = resolver.resolve(config_or_env, pool_name).symbolize_keys
-      config_hash[:name] = pool_name
-
-      config_hash
-    end
-
-    def connection_specification_name
-      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
-        return self == DB2Query::Base ? "primary" : superclass.connection_specification_name
-      end
-      @connection_specification_name
-    end
-
-    def primary_class?
-      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/database_statements.rb

@@ -1,93 +0,0 @@
-# frozen_String_literal: true
-
-module DB2Query
-  module DatabaseStatements
-    def query(sql)
-      stmt = @connection.run(sql)
-      stmt.to_a
-    ensure
-      stmt.drop unless stmt.nil?
-    end
-
-    def query_rows(sql)
-      query(sql)
-    end
-
-    def query_value(sql, name = nil)
-      single_value_from_rows(query(sql))
-    end
-
-    def query_values(sql, name = nil)
-      query(sql).map(&:first)
-    end
-
-    def execute(sql, args = [])
-      if args.empty?
-        @connection.do(sql)
-      else
-        @connection.do(sql, *args)
-      end
-    end
-
-    def exec_query(sql, formatter = {}, args = [], name = "SQL")
-      binds, args = extract_binds_from_sql(sql, args)
-      log(sql, name, binds, args) do
-        begin
-          if args.empty?
-            stmt = @connection.run(sql)
-          else
-            stmt = @connection.run(sql, *args)
-          end
-          columns = stmt.columns.values.map { |col| col.name.downcase }
-          rows = stmt.to_a
-        ensure
-          stmt.drop unless stmt.nil?
-        end
-        DB2Query::Result.new(columns, rows, formatter)
-      end
-    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
-
-      def extract_binds_from_sql(sql, args)
-        question_mark_positions = sql.enum_for(:scan, /\?/i).map { Regexp.last_match.begin(0) }
-        args = args.first.is_a?(Hash) ? args.first : args.is_a?(Array) ? args : [args]
-        given, expected = args.length, question_mark_positions.length
-
-        if given != expected
-          raise ArgumentError, "wrong number of arguments (given #{given}, expected #{expected})"
-        end
-
-        if args.is_a?(Hash)
-          binds = args.map do |key, value|
-            position = sql.enum_for(:scan, key_finder_regex(key)).map { Regexp.last_match.begin(0) }
-            if position.empty?
-              raise ArgumentError, "Column name: `#{key}` not found inside sql statement."
-            elsif position.length > 1
-              raise ArgumentError, "Can't handle such this kind of sql. Please refactor your sql."
-            else
-              index = position[0]
-            end
-
-            OpenStruct.new({ name: key.to_s, value: value, index: index })
-          end
-          binds = binds.sort_by { |bind| bind.index }
-          [binds.map { |bind| [bind, bind.value] }, binds.map { |bind| bind.value }]
-        elsif question_mark_positions.length == 1 && args.length == 1
-          column = sql[/(.*?) = \?|(.*?) =\?|(.*?)= \?|(.*?)=\?/m, 1].split.last.downcase
-          bind = OpenStruct.new({ name: column, value: args })
-          [[[bind, bind.value]], bind.value]
-        else
-          [args.map { |arg| [nil, arg] }, args]
-        end
-      end
-  end
-end

data/lib/db2_query/formatter.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module DB2Query
-  module Formatter
-    def self.register(name, klass)
-      self.format_registry.store(name.to_sym, klass.new)
-    end
-
-    def self.format_registry
-      @@format_registry ||= Hash.new
-    end
-
-    def self.lookup(name)
-      @@format_registry.fetch(name)
-    end
-
-    def self.registration(&block)
-      yield self if block_given?
-    end
-  end
-
-  class AbstractFormatter
-    def format(value)
-      raise NotImplementedError, "Implement format method in your subclass."
-    end
-  end
-end

data/lib/db2_query/odbc_connector.rb

@@ -1,40 +0,0 @@
-# frozen_String_literal: true
-
-require "odbc_utf8"
-
-module DB2Query
-  class ODBCConnector
-    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
-
-  class AbstractConnector
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-  end
-
-  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 < AbstractConnector
-    def connect
-      driver = ::ODBC::Driver.new.tap do |d|
-        d.attrs = config[:conn_string].transform_keys(&:to_s)
-        d.name = "odbc"
-      end
-      ::ODBC::Database.new.drvconnect(driver)
-    rescue ::ODBC::Error => e
-      raise ArgumentError, "Unable to activate ODBC Conn String connection #{e}"
-    end
-  end
-end