db2_query 0.2.0 → 0.3.1

data/lib/db2_query/connection_handling.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module DB2Query
-  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 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)
-
-      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 == Base ? "primary" : superclass.connection_specification_name
-      end
-      @connection_specification_name
-    end
-
-    def primary_class?
-      self == Base || defined?(ApplicationRecord) && self == ApplicationRecord
-    end
-  end
-end

data/lib/db2_query/database_statements.rb

@@ -1,88 +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 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/odbc_connector.rb

@@ -1,38 +0,0 @@
-# frozen_String_literal: true
-
-module DB2Query
-  CONNECTION_TYPES = %i[dsn conn_string].freeze
-
-  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
-    end
-
-    def connect
-      connector.connect(conn_config)
-    end
-  end
-
-  class DsnConnector
-    def connect(config)
-      ::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)
-      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