db2_query 0.2.0 → 0.3.1

data/lib/db2_query/connection.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Bind < Struct.new(:name, :value, :index)
+  end
+
+  class Connection < ConnectionPool
+    attr_reader :config
+
+    include Logger
+
+    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 query(sql)
+      pool do |odbc_conn|
+        stmt = odbc_conn.run(sql)
+        stmt.to_a
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+    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 = [])
+      pool do |odbc_conn|
+        odbc_conn.do(sql, *args)
+      end
+    end
+
+    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, binds, args)
+      end
+    end
+
+    def run_query(formatters, sql,  binds, args = [])
+      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

@@ -1,59 +1,118 @@
 # frozen_string_literal: true
 
-module DB2Query
-  module Core
-    extend ActiveSupport::Concern
+module Db2Query
+  class DbClient
+    attr_reader :dsn
 
-    included do |base|
-      def self.configurations=(config)
-        @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
-      end
-      self.configurations = {}
-
-      def self.configurations
-        @@configurations
-      end
+    delegate :run, :do, to: :client
 
-      class_attribute :default_connection_handler
+    def initialize(config)
+      @dsn = config[:dsn]
+      @idle_time_limit = config[:idle] || 5
+      @client = new_db_client
+      @last_active = Time.now
+    end
 
-      mattr_accessor :connection_handlers, instance_accessor: false, default: {}
+    def expire?
+      Time.now - @last_active > 60 * @idle_time_limit
+    end
 
-      mattr_accessor :writing_role, instance_accessor: false, default: :writing
+    def active?
+      @client.connected?
+    end
 
-      mattr_accessor :reading_role, instance_accessor: false, default: :reading
+    def connected_and_persist?
+      active? && !expire?
+    end
 
-      def self.connection_handler
-        Thread.current.thread_variable_get("ar_connection_handler") || default_connection_handler
-      end
+    def disconnect!
+      @client.drop_all
+      @client.disconnect if active?
+      @client = nil
+    end
 
-      def self.connection_handler=(handler)
-        Thread.current.thread_variable_set("ar_connection_handler", handler)
-      end
+    def new_db_client
+      ODBC.connect(dsn)
+    end
 
-      self.default_connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    def client
+      return @client if connected_and_persist?
+      disconnect!
+      @last_active = Time.now
+      @client = new_db_client
+    end
+  end
 
-      base.extend ClassMethods
+  module Core
+    extend ActiveSupport::Concern
+    included do
+      @@connection = nil
+      @@mutex = Mutex.new
     end
 
-    module ClassMethods
+    class_methods do
+      def initiation
+        yield(self) if block_given?
+      end
+
       def attributes(attr_name, format)
         formatters.store(attr_name, format)
       end
 
-      def query(name, sql_statement)
+      def connection
+        @@connection || create_connection
+      end
+
+      def create_connection
+        @@mutex.synchronize do
+          return @@connection if @@connection
+          @@connection = Connection.new(config) { DbClient.new(config) }
+        end
+      end
+
+      def establish_connection
+        load_database_configurations
+        create_connection
+      end
+
+      def query(name, body)
         if defined_method_name?(name)
-          raise ArgumentError, "You tried to define a scope named \"#{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
 
-        unless sql_statement.strip.match?(/^select/i)
-          raise NotImplementedError
+        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
 
-        self.class.define_method(name) do |*args|
-          connection.exec_query(sql_statement, formatters, args)
-        end
+      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
@@ -73,16 +132,29 @@ module DB2Query
             sql_statement = allocate.method(sql_method).call
 
             unless sql_statement.is_a? String
-              raise ArgumentError, "Query methods must return a SQL statement 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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Db2Query
+  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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module DB2Query
+module Db2Query
   module Formatter
     def self.register(name, klass)
       self.format_registry.store(name.to_sym, klass.new)
@@ -21,7 +21,7 @@ module DB2Query
 
   class AbstractFormatter
     def format(value)
-      raise NotImplementedError, "Implement format method in your subclass."
+      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 = [], args = [], &block)
+      @instrumenter.instrument(
+        "sql.active_record",
+        sql:               sql,
+        name:              name,
+        binds:             binds,
+        type_casted_binds: args,
+        statement_name:    nil,
+        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,20 +1,15 @@
 # frozen_string_literal: true
 
-require 'db2_query'
-require 'rails'
+require "db2_query"
+require "rails"
 
-module DB2Query
-  class Railtie < Rails::Railtie
+module Db2Query
+  class Railtie < ::Rails::Railtie
     railtie_name :db2_query
 
     rake_tasks do
       path = File.expand_path(__dir__)
       Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
     end
-
-    initializer "db2_query.database_initialization" do
-      DB2Query::Base.configurations = DB2Query.config
-      DB2Query::Base.establish_connection :primary
-    end
   end
 end

data/lib/db2_query/result.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module DB2Query
+module Db2Query
   class Result < ActiveRecord::Result
     attr_reader :formatters
 
@@ -9,23 +9,37 @@ module DB2Query
       super(columns, rows, column_types)
     end
 
+    def includes_column?(name)
+      @columns.include? name
+    end
+
+    def record
+      @record ||= Record.new(rows[0], columns, formatters)
+    end
+
     def records
       @records ||= rows.map do |row|
         Record.new(row, columns, formatters)
       end
     end
 
+    def to_h
+      rows.map do |row|
+        columns.zip(row).each_with_object({}) { |cr, h| h[cr[0].to_sym] = cr[1] }
+      end
+    end
+
     def inspect
       entries = records.take(11).map!(&:inspect)
 
       entries[10] = "..." if entries.size == 11
 
-      "#<#{self.class.name} @records=[#{entries.join(', ')}]>"
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
     end
 
     class Record
       attr_reader :formatters
-    
+
       def initialize(row, columns, formatters)
         @formatters = formatters
         columns.zip(row) do |col, val|
@@ -53,7 +67,7 @@ module DB2Query
           column = col.downcase
           format_name = formatters[column.to_sym]
           unless format_name.nil?
-            formatter = DB2Query::Formatter.lookup(format_name)
+            formatter = Db2Query::Formatter.lookup(format_name)
             val = formatter.format(val)
           end
           [column, val]