db2_query 0.2.2 → 0.3.2

data/Rakefile

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
 require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
 end
 
 task default: :test

data/lib/db2_query.rb

@@ -1,23 +1,49 @@
-# frozen_string_literal:true
+# frozen_string_literal: true
 
-require "yaml"
-require "erb"
 require "active_record"
 require "active_support"
-require "db2_query/config"
-require "db2_query/connection_handling"
+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
+module Db2Query
+  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 :Base
-  autoload :Core
-  autoload :DatabaseStatements
-  autoload :Connection
-  autoload :ODBCConnector
-  autoload :Formatter
-  autoload :Result
+  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

@@ -1,10 +1,21 @@
 # frozen_string_literal: true
 
-module DB2Query
+module Db2Query
   class Base
-    include ActiveRecord::Inheritance
-    include DB2Query::Core
-    extend ActiveRecord::ConnectionHandling
-    extend DB2Query::ConnectionHandling
+    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

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
-module DB2Query
-  class << self
-    def config
-      @config ||= read_config
-    end
+module Db2Query
+  module Config
+    DEFAULT_ENV = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence }
 
-    def config_path
-      if defined?(Rails)
-        "#{Rails.root}/config/db2query_database.yml"
-      else
-        ENV["DQ_CONFIG_PATH"]
-      end
+    def self.included(base)
+      base.send(:extend, ClassMethods)
     end
 
-    def config_file
-      Pathname.new(config_path)
-    end
+    module ClassMethods
+      mattr_accessor :configurations
+      @@configurations = nil
+
+      alias config configurations
 
-    def read_config
-      erb = ERB.new(config_file.read)
-      YAML.parse(erb.result(binding)).transform.transform_keys(&:to_sym)
+      def default_path
+        "#{Rails.root}/config/db2query.yml"
+      end
+
+      def load_database_configurations(path = nil)
+        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
 end

data/lib/db2_query/core.rb

@@ -1,84 +1,97 @@
 # frozen_string_literal: true
 
-require "active_record/database_configurations"
-
-module DB2Query
+module Db2Query
   module Core
-    extend ActiveSupport::Concern
-
-    included do
-      def self.configurations=(config)
-        @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
-      end
-      self.configurations = {}
-
-      def self.configurations
-        @@configurations
-      end
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
 
-      mattr_accessor :connection_handlers, instance_accessor: false, default: {}
+    module ClassMethods
+      attr_reader :definitions
 
-      class_attribute :default_connection_handler
+      delegate :query_rows, :query_value, :query_values, :execute, to: :connection
 
-      def self.connection_handler
-        Thread.current.thread_variable_get("db2q_connection_handler") || default_connection_handler
+      def initiation
+        yield(self) if block_given?
       end
 
-      def self.connection_handler=(handler)
-        Thread.current.thread_variable_set("db2q_connection_handler", handler)
+      def define_query_definitions
+        @definitions = new_definitions
       end
 
-      self.default_connection_handler = DB2Query::ConnectionHandler.new
-    end
+      def exec_query_result(query, args)
+        reset_id_when_required(query)
+        connection.exec_query(query, args)
+      end
 
-    module ClassMethods
-      def initiation
-        yield(self) if block_given?
+      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 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::QueryMethodError.new
+        end
       end
+      alias define query
 
-      def attributes(attr_name, format)
-        formatters.store(attr_name, format)
+      def fetch(sql, args = [])
+        query = definitions.lookup_query(args, sql)
+        query.validate_select_query
+        connection.exec_query(query, args)
       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
+      def fetch_list(sql, args)
+        list = args.first
+        fetch(sql_with_list(sql, list), args.drop(1))
+      end
 
-        unless sql_statement.strip.match?(/^select/i)
-          raise NotImplementedError
+      private
+        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
 
-        self.class.define_method(name) do |*args|
-          connection.exec_query(sql_statement, formatters, args)
+        def reset_id_when_required(query)
+          if query.insert_sql? && !query.column_id.nil?
+            connection.reset_id_sequence!(query.table_name)
+          end
         end
-      end
 
-      private
-        def formatters
-          @formatters ||= Hash.new
+        def raw_query(sql, args)
+          Query.new.tap do |query|
+            query.define_sql(sql)
+            query.define_args(args)
+          end
         end
 
-        def defined_method_name?(name)
-          self.class.method_defined?(name) || self.class.private_method_defined?(name)
+        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)
-          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)
-
+          if sql_query_method?(method_name)
+            define_sql_query(method_name)
             method(method_name).call(*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

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

data/lib/db2_query/db_statements.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module DbStatements
+    def query(sql)
+      pool do |client|
+        stmt = client.run(sql)
+        stmt.to_a
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+    end
+
+    def query_rows(sql)
+      query(sql)
+    end
+
+    def query_value(sql)
+      rows = query(sql)
+      row = rows.first
+      row && row.first
+    end
+
+    def query_values(sql)
+      query(sql).map(&:first)
+    end
+
+    def execute(sql, args = [])
+      pool do |client|
+        client.do(sql, *args)
+      end
+    end
+
+    def raw_query(sql, args = [])
+      pool do |client|
+        stmt = client.run(sql, *args)
+        raw_result(stmt)
+      end
+    end
+
+    def exec_query(query, args = [])
+      sql, binds, args = query.exec_query_arguments(args)
+      log(sql, binds, args) do
+        pool do |client|
+          stmt = client.run(sql, *args)
+          columns = stmt.columns.values.map { |col| col.name.downcase }
+          rows = stmt.to_a
+          Db2Query::Result.new(columns, rows, query)
+        ensure
+          stmt.drop unless stmt.nil?
+        end
+      end
+    end
+
+    def reset_id_sequence!(table_name)
+      next_val = max_id(table_name) + 1
+      execute <<-SQL
+        ALTER TABLE #{table_name}
+        ALTER COLUMN ID
+        RESTART WITH #{next_val}
+        SET INCREMENT BY 1
+        SET NO CYCLE
+        SET CACHE 500
+        SET NO ORDER;
+      SQL
+    end
+
+    private
+      def max_id(table_name)
+        query_value("SELECT COALESCE(MAX (ID),0) FROM #{table_name}")
+      end
+
+      def raw_result(stmt)
+        columns = stmt.columns.values.map { |col| col.name.downcase }
+        stmt.to_a.map do |row|
+          index, hash = [0, {}]
+          while index < columns.length
+            hash[columns[index].to_sym] = row[index]
+            index += 1
+          end
+          hash
+        end
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+  end
+end