db2_query 0.3.1 → 0.3.2

data/lib/db2_query.rb

@@ -3,20 +3,47 @@
 require "active_record"
 require "active_support"
 require "active_support/concurrency/load_interlock_aware_monitor"
+require "active_model/type"
 require "connection_pool"
 require "odbc_utf8"
+require "db2_query/error"
 
 module Db2Query
-  extend ActiveSupport::Autoload
+  autoload :Version, "db2_query/version"
+  autoload :Error, "db2_query/error"
+  autoload :Config, "db2_query/config"
+  autoload :Logger, "db2_query/logger"
+  autoload :DbClient, "db2_query/db_client"
+  autoload :DbStatements, "db2_query/db_statements"
+  autoload :Validations, "db2_query/validations"
+  autoload :Helper, "db2_query/helper"
+  autoload :Quoting, "db2_query/quoting"
+  autoload :FieldType, "db2_query/field_type"
 
-  autoload :Version
-  autoload :Config
-  autoload :Connection
-  autoload :Core
-  autoload :Result
-  autoload :Logger
-  autoload :Error
-  autoload :Base
+  module Type
+    autoload :Value, "db2_query/type/value"
+    autoload :Binary, "db2_query/type/binary"
+    autoload :Boolean, "db2_query/type/boolean"
+    autoload :Decimal, "db2_query/type/decimal"
+    autoload :String, "db2_query/type/string"
+    autoload :Text, "db2_query/type/text"
+    autoload :Integer, "db2_query/type/integer"
+    autoload :Time, "db2_query/type/time"
+    autoload :Timestamp, "db2_query/type/timestamp"
+    autoload :Date, "db2_query/type/date"
+  end
+
+  autoload :SqlStatement, "db2_query/sql_statement"
+  autoload :Query, "db2_query/query"
+  autoload :Definitions, "db2_query/definitions"
+  autoload :DbConnection, "db2_query/db_connection"
+  autoload :Result, "db2_query/result"
+  autoload :Core, "db2_query/core"
+  autoload :Base, "db2_query/base"
+
+  def self.root
+    __dir__
+  end
 
   require "db2_query/railtie" if defined?(Rails)
 end

data/lib/db2_query/base.rb

@@ -3,6 +3,19 @@
 module Db2Query
   class Base
     include Config
+    include Helper
+    include Quoting
+    include DbConnection
+    include FieldType
     include Core
+
+    def self.inherited(subclass)
+      subclass.define_query_definitions
+    end
+
+    def self.establish_connection
+      load_database_configurations
+      new_database_connection
+    end
   end
 end

data/lib/db2_query/config.rb

@@ -2,27 +2,27 @@
 
 module Db2Query
   module Config
-    extend ActiveSupport::Concern
     DEFAULT_ENV = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence }
 
-    included do
-      @@configurations = nil
+    def self.included(base)
+      base.send(:extend, ClassMethods)
     end
 
-    class_methods do
-      def configurations
-        @@configurations
-      end
+    module ClassMethods
+      mattr_accessor :configurations
+      @@configurations = nil
+
       alias config configurations
 
+      def default_path
+        "#{Rails.root}/config/db2query.yml"
+      end
+
       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
+        config_file = IO.read(path || default_path)
+        @@configurations = YAML.load(config_file)[DEFAULT_ENV.call].transform_keys(&:to_sym)
+      rescue Exception => e
+        raise Db2Query::Error, e.message
       end
     end
   end

data/lib/db2_query/core.rb

@@ -1,160 +1,101 @@
 # frozen_string_literal: true
 
 module Db2Query
-  class DbClient
-    attr_reader :dsn
-
-    delegate :run, :do, to: :client
-
-    def initialize(config)
-      @dsn = config[:dsn]
-      @idle_time_limit = config[:idle] || 5
-      @client = new_db_client
-      @last_active = Time.now
-    end
-
-    def expire?
-      Time.now - @last_active > 60 * @idle_time_limit
-    end
-
-    def active?
-      @client.connected?
-    end
-
-    def connected_and_persist?
-      active? && !expire?
-    end
-
-    def disconnect!
-      @client.drop_all
-      @client.disconnect if active?
-      @client = nil
+  module Core
+    def self.included(base)
+      base.send(:extend, ClassMethods)
     end
 
-    def new_db_client
-      ODBC.connect(dsn)
-    end
+    module ClassMethods
+      attr_reader :definitions
 
-    def client
-      return @client if connected_and_persist?
-      disconnect!
-      @last_active = Time.now
-      @client = new_db_client
-    end
-  end
+      delegate :query_rows, :query_value, :query_values, :execute, to: :connection
 
-  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)
+      def define_query_definitions
+        @definitions = new_definitions
       end
 
-      def connection
-        @@connection || create_connection
+      def exec_query_result(query, args)
+        reset_id_when_required(query)
+        connection.exec_query(query, args)
       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 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)
+      def query(*query_args)
+        if query_args[1].respond_to?(:call)
+          query_name, body = query_args
+          singleton_class.define_method(query_name) do |*args|
+            body.call(args << { query_name: query_name })
           end
-        elsif body.is_a?(String)
-          sql = body.strip
-          singleton_class.define_method(name) do |*args|
-            connection.exec_query(formatters, sql, args)
+        elsif query_args[0].is_a?(String)
+          sql, query_args = [query_args.first.strip, query_args.drop(1)]
+          query = raw_query(sql, query_args)
+          connection.raw_query(query.db2_spec_sql, query.args)
+        elsif query_args[1].is_a?(String) && query_args[1].strip.length > 0
+          query_name, sql = query_args
+          query = definitions.lookup_query(query_name, sql.strip)
+          singleton_class.define_method(query_name) do |*args|
+            exec_query_result(query, args)
           end
         else
-          raise Db2Query::Error, "The query body needs to be callable or is a sql string"
+          raise Db2Query::QueryMethodError.new
         end
       end
       alias define query
 
-      def fetch(sql, args)
-        validate_sql(sql)
-        connection.exec_query({}, sql, args)
+      def fetch(sql, args = [])
+        query = definitions.lookup_query(args, sql)
+        query.validate_select_query
+        connection.exec_query(query, 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)
+        list = args.first
+        fetch(sql_with_list(sql, list), args.drop(1))
       end
 
       private
-        def formatters
-          @formatters ||= Hash.new
+        def new_definitions
+          definition_class = "Definitions::#{name}Definitions"
+          Object.const_get(definition_class).new(field_types_map)
+        rescue Exception => e
+          raise Db2Query::Error, e.message
         end
 
-        def defined_method_name?(name)
-          self.class.method_defined?(name) || self.class.private_method_defined?(name)
+        def reset_id_when_required(query)
+          if query.insert_sql? && !query.column_id.nil?
+            connection.reset_id_sequence!(query.table_name)
+          end
         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)
+        def raw_query(sql, args)
+          Query.new.tap do |query|
+            query.define_sql(sql)
+            query.define_args(args)
+          end
+        end
 
-            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
+        def define_sql_query(method_name)
+          sql_query_name = sql_query_symbol(method_name)
+          sql_statement = allocate.method(sql_query_name).call
+          define(method_name, sql_statement)
+        end
 
+        def method_missing(method_name, *args, &block)
+          if sql_query_method?(method_name)
+            define_sql_query(method_name)
             method(method_name).call(*args)
-          elsif connection.respond_to?(method_name)
-            connection.send(method_name, *args)
+          elsif method_name == :exec_query
+            sql, args = [args.shift, args.first]
+            query = definitions.lookup_query(args, sql)
+            exec_query_result(query, 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/db_client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class DbClient
+    attr_reader :dsn
+
+    include ActiveModel::Type::Helpers::Timezone
+
+    delegate :run, :do, to: :client
+
+    def initialize(config)
+      @dsn = config[:dsn]
+      @idle_time_limit = config[:idle] || 5
+      @client = new_client
+      @last_transaction = Time.now
+    end
+
+    def expire?
+      Time.now - @last_transaction > 60 * @idle_time_limit
+    end
+
+    def active?
+      @client.connected?
+    end
+
+    def connected_and_persist?
+      active? && !expire?
+    end
+
+    def disconnect!
+      @client.drop_all
+      @client.disconnect if active?
+      @client = nil
+    end
+
+    def new_client
+      ODBC.connect(dsn).tap do |odbc_conn|
+        odbc_conn.use_time = true
+        odbc_conn.use_utc = is_utc?
+      end
+    rescue ::ODBC::Error => e
+      raise Db2Query::ConnectionError.new(e.message)
+    end
+
+    def reconnect!
+      disconnect!
+      @client = new_client
+    end
+
+    def client
+      reconnect! unless connected_and_persist?
+      @last_transaction = Time.now
+      @client
+    end
+  end
+end

data/lib/db2_query/db_connection.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module DbConnection
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      mattr_reader :connection
+      @@connection = nil
+
+      def new_database_connection
+        @@connection = Connection.new(config)
+      end
+    end
+  end
+
+  class Connection
+    class Pool < ConnectionPool
+      def initialize(config, &block)
+        super(config, &block)
+      end
+
+      def current_state
+        { size: self.size, available: self.available }
+      end
+
+      def disconnect!
+        shutdown { |client| client.disconnect! }
+      end
+
+      def reload
+        super { |client| client.disconnect! }
+      end
+    end
+
+    attr_reader :config, :connection_pool, :instrumenter, :lock
+
+    delegate :with, :current_state, :disconnect!, :reload, to: :connection_pool
+    delegate :instrument, to: :instrumenter
+    delegate :synchronize, to: :lock
+
+    include Logger
+    include DbStatements
+
+    def initialize(config)
+      @config = config
+      @instrumenter = ActiveSupport::Notifications.instrumenter
+      @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+      create_connection_pool
+    end
+
+    alias pool with
+
+    def pool_config
+      { size: config[:pool], timeout: config[:timeout] }
+    end
+
+    def create_connection_pool
+      synchronize do
+        return @connection_pool if @connection_pool
+        @connection_pool = Pool.new(pool_config) { DbClient.new(config) }
+      end
+    end
+  end
+end