db2_query 0.1.0 → 0.3.0

data/lib/db2_query/config.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Config
+    extend ActiveSupport::Concern
+    DEFAULT_ENV = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence }
+
+    included do
+      @@configurations = nil
+    end
+
+    class_methods do
+      def configurations
+        @@configurations
+      end
+      alias config configurations
+
+      def load_database_configurations(path = nil)
+        file_path = path || "#{Rails.root}/config/db2query.yml"
+        if File.exist?(file_path)
+          config_file = IO.read(file_path)
+          @@configurations = YAML.load(config_file)[DEFAULT_ENV.call].transform_keys(&:to_sym)
+        else
+          raise Db2Query::Error, "Could not load db2query database configuration. No such file - #{file_path}"
+        end
+      end
+    end
+  end
+end

data/lib/db2_query/connection.rb

@@ -1,50 +1,128 @@
 # frozen_string_literal: true
 
+require_relative "error"
+require "connection_pool"
+
 module Db2Query
-  class Connection
-    include DatabaseStatements
+  class Bind < Struct.new(:name, :value, :index)
+  end
+
+  class Connection < ConnectionPool
+    attr_reader :config
+
+    include Logger
 
-    attr_reader :connector, :db_name, :odbc_conn
+    def initialize(config, &block)
+      @config = config
+      super(pool_config, &block)
+      @instrumenter = ActiveSupport::Notifications.instrumenter
+      @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+    end
+
+    alias pool with
+
+    def pool_config
+      { size: config[:pool], timeout: config[:timeout] }
+    end
 
-    def initialize(connector, db_name)
-      @connector = connector
-      @db_name = db_name.to_sym
-      connect
+    def query(sql)
+      pool do |odbc_conn|
+        stmt = odbc_conn.run(sql)
+        stmt.to_a
+      ensure
+        stmt.drop unless stmt.nil?
+      end
     end
 
-    def connect
-      @odbc_conn = connector.connect
-      @odbc_conn.use_time = true
+    def query_rows(sql)
+      query(sql)
     end
 
-    def active?
-      @odbc_conn.connected?
+    def query_value(sql)
+      single_value_from_rows(query(sql))
     end
 
-    def disconnect!
-      @odbc_conn.drop_all
-      @odbc_conn.disconnect if active?
+    def query_values(sql)
+      query(sql).map(&:first)
     end
 
-    def reconnect!
-      disconnect!
-      connect
+    def execute(sql, args = [])
+      pool do |odbc_conn|
+        odbc_conn.do(sql, *args)
+      end
     end
-    alias reset! reconnect!
 
-    def execute(sql, *args)
-      reset! unless active?
-      @odbc_conn.do(sql, *args)
+    def exec_query(formatters, sql, args = [])
+      binds, args = extract_binds_from_sql(sql, args)
+      sql = db2_spec_sql(sql)
+      log(sql, "SQL", binds, args) do
+        run_query(formatters, sql, args, binds)
+      end
     end
 
-    def exec_query(sql, *args)
-      reset! unless active?
-      statement = @odbc_conn.run(sql, *args)
-      columns = statement.columns.values
-      rows = statement.to_a
-      [columns, rows]
-    ensure
-      statement.drop if statement
+    def run_query(formatters, sql, args = [], binds)
+      pool do |odbc_conn|
+        begin
+          if args.empty?
+            stmt = odbc_conn.run(sql)
+          else
+            stmt = odbc_conn.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 iud_sql?(sql)
+        sql.match?(/insert into|update|delete/i)
+      end
+
+      def iud_ref_table(sql)
+        sql.match?(/delete/i) ? "OLD TABLE" : "NEW TABLE"
+      end
+
+      def db2_spec_sql(sql)
+        if iud_sql?(sql)
+          "SELECT * FROM #{iud_ref_table(sql)} (#{sql})"
+        else
+          sql
+        end.tr("$", "")
+      end
+
+      def extract_binds_from_sql(sql, args)
+        keys = sql.scan(/\$\S+/).map { |key| key.gsub!(/[$=]/, "") }
+        sql = sql.tr("$", "")
+        args = args[0].is_a?(Hash) ? args[0] : args
+        given, expected = args.length, sql.scan(/\?/i).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|
+            if args[key.to_sym].nil?
+              raise Db2Query::Error, "Column name: `#{key}` not found inside sql statement."
+            end
+            Db2Query::Bind.new(key.to_s, value, nil)
+          end
+        else
+          binds = keys.map.with_index do |key, index|
+            Db2Query::Bind.new(key, args[index], nil)
+          end
+        end
+
+        [binds.map { |bind| [bind, bind.value] }, binds.map { |bind| bind.value }]
+      end
   end
 end

data/lib/db2_query/core.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class DbClient
+    attr_reader :dsn
+
+    delegate :run, :do, to: :client
+
+    def initialize(dsn)
+      @dsn = dsn
+      @client = retrieve_db_client
+    end
+
+    def retrieve_db_client
+      ODBC.connect(dsn)
+    end
+
+    def client
+      unless @client.connected?
+        @client = retrieve_db_client
+      end
+      @client
+    end
+  end
+
+  module Core
+    extend ActiveSupport::Concern
+    included do
+      @@connection = nil
+      @@mutex = Mutex.new
+    end
+
+    class_methods do
+      def initiation
+        yield(self) if block_given?
+      end
+
+      def attributes(attr_name, format)
+        formatters.store(attr_name, format)
+      end
+
+      def connection
+        @@connection || create_connection
+      end
+
+      def create_connection
+        @@mutex.synchronize do
+          return @@connection if @@connection
+          @@connection = Connection.new(config) { DbClient.new(config[:dsn]) }
+        end
+      end
+
+      def establish_connection
+        load_database_configurations
+        create_connection
+      end
+
+      def query(name, body)
+        if defined_method_name?(name)
+          raise Db2Query::Error, "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
+
+        if body.respond_to?(:call)
+          singleton_class.define_method(name) do |*args|
+            body.call(*args)
+          end
+        elsif body.is_a?(String)
+          sql = body.strip
+          singleton_class.define_method(name) do |*args|
+            connection.exec_query(formatters, sql, args)
+          end
+        else
+          raise Db2Query::Error, "The query body needs to be callable or is a sql string"
+        end
+      end
+      alias define query
+
+      def fetch(sql, args)
+        validate_sql(sql)
+        connection.exec_query({}, sql, args)
+      end
+
+      def fetch_list(sql, args)
+        validate_sql(sql)
+        raise Db2Query::Error, "Missing @list pointer at SQL" if sql.scan(/\@list+/).length == 0
+        raise Db2Query::Error, "The arguments should be an array of list" unless args.is_a?(Array)
+        connection.exec_query({}, sql.gsub("@list", "'#{args.join("', '")}'"), [])
+      end
+
+      def sql_with_extention(sql, extention)
+        validate_sql(sql)
+        raise Db2Query::Error, "Missing @extention pointer at SQL" if sql.scan(/\@extention+/).length == 0
+        sql.gsub("@extention", extention.strip)
+      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 Db2Query::Error, "Query methods must return a SQL statement string!"
+            end
+
+            query(method_name, sql_statement)
+
+            if args[0].is_a?(Hash)
+              keys = sql_statement.scan(/\$\S+/).map { |key| key.gsub!(/[$=]/, "") }
+              rearrange_args = {}
+              keys.each { |key| rearrange_args[key.to_sym] = args[0][key.to_sym] }
+              args[0] = rearrange_args
+            end
+
+            method(method_name).call(*args)
+          elsif connection.respond_to?(method_name)
+            connection.send(method_name, *args)
+          else
+            super
+          end
+        end
+
+        def validate_sql(sql)
+          raise Db2Query::Error, "SQL have to be in string format" unless sql.is_a?(String)
+        end
+    end
+  end
+end

data/lib/db2_query/error.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
 module Db2Query
-  class Error < ArgumentError; end
+  class Error < StandardError
+  end
+
+  class StatementInvalid < ActiveRecord::ActiveRecordError
+    def initialize(message = nil, sql: nil, binds: nil)
+      super(message || $!.try(:message))
+      @sql = sql
+      @binds = binds
+    end
+
+    attr_reader :sql, :binds
+  end
 end

data/lib/db2_query/formatter.rb

@@ -3,15 +3,15 @@
 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)
@@ -21,25 +21,7 @@ module Db2Query
 
   class AbstractFormatter
     def format(value)
-      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
+      raise Db2Query::Error, "Implement format method in your subclass."
     end
   end
 end

data/lib/db2_query/logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Logger
+    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
+        StatementInvalid.new(message, sql: sql, binds: binds)
+      end
+    end
+  end
+end

data/lib/db2_query/railtie.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
+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 }
-    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
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
     end
   end
 end