db2_query 0.2.3 → 0.3.0

data/lib/db2_query/bind.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module DB2Query
-  class Bind < Struct.new(:name, :value, :index)
-  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
-    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)
-      handler_key = DB2Query::Base.reading_role
-      connection_handlers[handler_key] ||= DB2Query::ConnectionHandler.new
-    end
-
-    def resolve_config_for_connection(config_or_env)
-      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)
-        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,89 +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)
-      single_value_from_rows(query(sql))
-    end
-
-    def query_values(sql)
-      query(sql).map(&:first)
-    end
-
-    def execute(sql, args = [])
-      @connection.do(sql, *args)
-    end
-
-    def exec_query(formatters, sql, args = [])
-      binds, args = extract_binds_from_sql(sql, args)
-      log(sql, "SQL", 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, formatters)
-      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
-        given, expected = args.length, question_mark_positions.length
-
-        if given != expected
-          raise DB2Query::Error, "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 DB2Query::Error, "Column name: `#{key}` not found inside sql statement."
-            elsif position.length > 1
-              raise DB2Query::Error, "Can't handle such this kind of sql. Please refactor your sql."
-            else
-              index = position[0]
-            end
-
-            DB2Query::Bind.new(key.to_s, value, 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 = DB2Query::Bind.new(column.gsub(/[)(]/, ""), args, 0)
-          [[[bind, bind.value]], bind.value]
-        else
-          [args.map { |arg| [nil, arg] }, args]
-        end
-      end
-  end
-end

data/lib/db2_query/odbc_connector.rb

@@ -1,44 +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
-
-    def connect
-      raise "abstract method #connect must be defined"
-    end
-  end
-
-  class DsnConnector < AbstractConnector
-    def connect
-      ::ODBC.connect(config[:dsn], config[:uid], config[:pwd])
-    rescue ::ODBC::Error => e
-      raise DB2Query::Error, "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 DB2Query::Error, "Unable to activate ODBC Conn String connection #{e}"
-    end
-  end
-end