db2_query 0.1.0 → 0.2.0

data/lib/db2_query/config.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DB2Query
+  class << self
+    def config
+      @config ||= read_config
+    end
+
+    def config_path
+      if defined?(Rails)
+        "#{Rails.root}/config/db2query_database.yml"
+      else
+        ENV["DQ_CONFIG_PATH"]
+      end
+    end
+
+    def config_file
+      Pathname.new(config_path)
+    end
+
+    def read_config
+      erb = ERB.new(config_file.read)
+      YAML.parse(erb.result(binding)).transform
+    end
+
+    def connection_env
+      ENV["RAILS_ENV"].to_sym
+    end
+  end
+end

data/lib/db2_query/connection_handling.rb

@@ -1,56 +1,33 @@
 # frozen_string_literal: true
 
-module Db2Query
+module DB2Query
   module ConnectionHandling
-    extend ActiveSupport::Concern
+    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
+    DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
-    DEFAULT_DB = "primary"
+    def resolve_config_for_connection(config_or_env) # :nodoc:
+      raise "Anonymous class is not allowed." unless name
 
-    included do |base|
-      def base.inherited(child)
-        child.connection = @connection
-      end
-
-      base.extend ClassMethods
-      base.connection = nil
-    end
-
-    module ClassMethods
-      attr_reader :connection
-
-      def connection=(connection)
-        @connection = connection
-        update_descendants_connection unless self.descendants.empty?
-      end
-
-      def update_descendants_connection
-        self.descendants.each { |child| child.connection = @connection }
-      end
+      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)
 
-      def establish_connection(db_name = nil)
-        clear_connection unless self.connection.nil?
-        db_name = db_name.nil? ? DEFAULT_DB : db_name.to_s
+      config_hash = resolver.resolve(config_or_env, pool_name).symbolize_keys
+      config_hash[:name] = pool_name
 
-        self.load_database_configurations if self.configurations.nil?
-
-        if self.configurations[db_name].nil?
-          raise Error, "Database (:#{db_name}) not found at database configurations."
-        end
-
-        conn_type, conn_config = extract_configuration(db_name)
-
-        connector = ODBCConnector.new(conn_type, conn_config)
-        self.connection = Connection.new(connector, db_name)
-      end
+      config_hash
+    end
 
-      def current_database
-        @connection.db_name
+    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 clear_connection
-        @connection.disconnect!
-        @connection = nil
-      end
+    def primary_class?
+      self == Base || defined?(ApplicationRecord) && self == ApplicationRecord
     end
   end
 end

data/lib/db2_query/core.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module DB2Query
+  module Core
+    extend ActiveSupport::Concern
+
+    included do |base|
+      def self.configurations=(config)
+        @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
+      end
+      self.configurations = {}
+
+      def self.configurations
+        @@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
+
+      def self.connection_handler
+        Thread.current.thread_variable_get("ar_connection_handler") || default_connection_handler
+      end
+
+      def self.connection_handler=(handler)
+        Thread.current.thread_variable_set("ar_connection_handler", handler)
+      end
+
+      self.default_connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def attributes(attr_name, format)
+        formatters.store(attr_name, format)
+      end
+
+      def query(name, sql_statement)
+        if defined_method_name?(name)
+          raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+            "on the model \"#{self.name}\", but DB2Query already defined " \
+            "a class method with the same name."
+        end
+
+        unless sql_statement.strip.match?(/^select/i)
+          raise NotImplementedError
+        end
+
+        self.class.define_method(name) do |*args|
+          connection.exec_query(sql_statement, formatters, args)
+        end
+      end
+
+      private
+        def formatters
+          @formatters ||= Hash.new
+        end
+
+        def defined_method_name?(name)
+          self.class.method_defined?(name) || self.class.private_method_defined?(name)
+        end
+
+        def method_missing(method_name, *args, &block)
+          sql_methods = self.instance_methods.grep(/_sql/)
+          sql_method = "#{method_name}_sql".to_sym
+
+          if sql_methods.include?(sql_method)
+            sql_statement = allocate.method(sql_method).call
+
+            unless sql_statement.is_a? String
+              raise ArgumentError, "Query methods must return a SQL statement string!"
+            end
+
+            query(method_name, sql_statement)
+
+            method(method_name).call(*args)
+          else
+            super
+          end
+        end
+    end
+  end
+end

data/lib/db2_query/database_statements.rb

@@ -1,32 +1,88 @@
-# frozen_string_literal: true
+# frozen_String_literal: true
 
-module Db2Query
+module DB2Query
   module DatabaseStatements
-    def query_value(sql) # :nodoc:
-      single_value_from_rows(query(sql))
+    def query(sql)
+      stmt = @connection.run(sql)
+      stmt.to_a
+    ensure
+      stmt.drop unless stmt.nil?
     end
 
-    def query(sql)
-      exec_query(sql).last
+    def query_rows(sql)
+      query(sql)
     end
 
-    def query_values(sql)
+    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 current_database
-      db_name.to_s
+    def execute(sql, args = [])
+      if args.empty?
+        @connection.do(sql)
+      else
+        @connection.do(sql, *args)
+      end
     end
 
-    def current_schema
-      query_value("select current_schema from sysibm.sysdummy1").strip
+    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
-    alias library current_schema
 
     private
-      def single_value_from_rows(rows)
-        row = rows.first
-        row && row.first
+      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,17 +1,17 @@
 # frozen_string_literal: true
 
-module Db2Query
+module DB2Query
   module Formatter
     def self.register(name, klass)
-      self.registry.store(name, klass.new)
+      self.format_registry.store(name.to_sym, klass.new)
     end
 
-    def self.registry
-      @@registry ||= Hash.new
+    def self.format_registry
+      @@format_registry ||= Hash.new
     end
 
     def self.lookup(name)
-      @@registry.fetch(name.to_sym)
+      @@format_registry.fetch(name)
     end
 
     def self.registration(&block)
@@ -24,22 +24,4 @@ module Db2Query
       raise NotImplementedError, "Implement format method in your subclass."
     end
   end
-
-  class BareFormatter < AbstractFormatter
-    def format(value)
-      value
-    end
-  end
-
-  class FloatFormatter < AbstractFormatter
-    def format(value)
-      value.to_f
-    end
-  end
-
-  class IntegerFormatter < AbstractFormatter
-    def format(value)
-      value.to_i
-    end
-  end
 end

data/lib/db2_query/odbc_connector.rb

@@ -1,14 +1,14 @@
-# frozen_string_literal: true
+# frozen_String_literal: true
+
+module DB2Query
+  CONNECTION_TYPES = %i[dsn conn_string].freeze
 
-module Db2Query
   class ODBCConnector
     attr_reader :connector, :conn_type, :conn_config
 
-    CONNECTION_TYPES = %i[dsn conn_string].freeze
-
     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
+      @connector = DB2Query.const_get("#{conn_type.to_s.camelize}Connector").new
     end
 
     def connect
@@ -20,7 +20,7 @@ module Db2Query
     def connect(config)
       ::ODBC.connect(config[:dsn], config[:uid], config[:pwd])
     rescue ::ODBC::Error => e
-      raise Error, "Unable to activate ODBC DSN connection #{e}"
+      raise ArgumentError, "Unable to activate ODBC DSN connection #{e}"
     end
   end
 
@@ -32,7 +32,7 @@ module Db2Query
       end
       ::ODBC::Database.new.drvconnect(driver)
     rescue ::ODBC::Error => e
-      raise Error, "Unable to activate ODBC Conn String connection #{e}"
+      raise ArgumentError, "Unable to activate ODBC Conn String connection #{e}"
     end
   end
 end

data/lib/db2_query/railtie.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-module Db2Query
-  class Railtie < ::Rails::Railtie
+require 'db2_query'
+require 'rails'
+
+module DB2Query
+  class Railtie < Rails::Railtie
     railtie_name :db2_query
 
     rake_tasks do
-      tasks_path = "#{File.expand_path("..", __dir__)}/tasks"
-      Dir.glob("#{tasks_path}/*.rake").each { |file| load file }
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
     end
 
     initializer "db2_query.database_initialization" do
-      Path.database_config_file = "#{Rails.root}/config/db2query_database.yml"
-      Base.load_database_configurations
-      Base.establish_connection
-    end
-
-    initializer "db2_query.attach_log_subscription" do
-      LogSubscriber.attach_to :db2_query
+      DB2Query::Base.configurations = DB2Query.config
+      DB2Query::Base.establish_connection :primary
     end
   end
 end

data/lib/db2_query/result.rb

@@ -1,95 +1,63 @@
 # frozen_string_literal: true
 
-module Db2Query
-  class Result
-    attr_reader :core, :klass, :rows, :columns, :column_metadatas, :attr_format
+module DB2Query
+  class Result < ActiveRecord::Result
+    attr_reader :formatters
 
-    def initialize(core, klass, columns, rows, attr_format = {})
-      @core = core
-      @klass = klass.to_s.camelize
-      @rows  = rows
-      @attr_format = attr_format
-      @columns = []
-      @column_metadatas = extract_metadatas(columns)
+    def initialize(columns, rows, formatters = {}, column_types = {})
+      @formatters = formatters
+      super(columns, rows, column_types)
     end
 
-    def to_a
-      core.const_set(klass, row_class) unless core.const_defined?(klass)
-
-      rows.map do |row|
-        (core.const_get klass).new(row, column_metadatas)
-      end
-    end
-
-    def to_hash
-      rows.map do |row|
-        Hash[columns.zip(row)]
-      end
-    end
-
-    def pluck(*column_names)
-      records.map do |record|
-        column_names.map { |column_name| record.send(column_name) }
+    def records
+      @records ||= rows.map do |row|
+        Record.new(row, columns, formatters)
       end
     end
 
-    def first
-      records.first
-    end
-
-    def last
-      records.last
-    end
-
-    def size
-      records.size
-    end
-    alias length size
-
-    def each(&block)
-      records.each(&block)
-    end
-
     def inspect
       entries = records.take(11).map!(&:inspect)
+
       entries[10] = "..." if entries.size == 11
-      "#<#{self.class} [#{entries.join(', ')}]>"
-    end
 
-    private
-      def records
-        @records ||= to_a
-      end
+      "#<#{self.class.name} @records=[#{entries.join(', ')}]>"
+    end
 
-      def extract_metadatas(columns)
-        columns.map do |col|
-          @columns << column_name = col.name.downcase
-          Column.new(column_name, col.type, attr_format[column_name.to_sym])
+    class Record
+      attr_reader :formatters
+    
+      def initialize(row, columns, formatters)
+        @formatters = formatters
+        columns.zip(row) do |col, val|
+          column, value = format(col, val)
+          singleton_class.class_eval { attr_accessor "#{column}" }
+          send("#{column}=", value)
         end
       end
 
-      def row_class
-        Class.new do
-          def initialize(row, columns_metadata)
-            columns_metadata.zip(row) do |column, val|
-              self.class.send(:attr_accessor, column.name.to_sym)
-              instance_variable_set("@#{column.name}", column.format(val))
-            end
-          end
+      def inspect
+        inspection = if defined?(instance_variables) && instance_variables
+          instance_variables.reject { |var| var == :@formatters }.map do |attr|
+            value = instance_variable_get(attr)
+            "#{attr[1..-1]}: #{(value.kind_of? String) ? %Q{"#{value}"} : value}"
+          end.compact.join(", ")
+        else
+          "not initialized"
+        end
 
-          def inspect
-            inspection = if defined?(instance_variables) && instance_variables
-              instance_variables.collect do |attr|
-                value = instance_variable_get(attr)
-                "#{attr[1..-1]}: #{(value.kind_of? String) ? %Q{"#{value}"} : value}"
-              end.compact.join(", ")
-            else
-              "not initialized"
-            end
+        "#<Record #{inspection}>"
+      end
 
-            "#<#{self.class} #{inspection}>"
+      private
+        def format(col, val)
+          column = col.downcase
+          format_name = formatters[column.to_sym]
+          unless format_name.nil?
+            formatter = DB2Query::Formatter.lookup(format_name)
+            val = formatter.format(val)
           end
+          [column, val]
         end
-      end
+    end
   end
 end