db2_query 0.2.3 → 0.3.3

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/base.rb

@@ -1,10 +1,20 @@
 # 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 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,91 +1,110 @@
 # frozen_string_literal: true
 
-require "active_record/database_configurations"
-
-module DB2Query
+module Db2Query
   module Core
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      attr_reader :definitions
+
+      delegate :query_rows, :query_value, :query_values, :execute, to: :connection
 
-    included do
-      def self.configurations=(config)
-        @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
+      def initiation
+        yield(self) if block_given?
       end
-      self.configurations = {}
 
-      def self.configurations
-        @@configurations
+      def define_query_definitions
+        @definitions = new_definitions
       end
 
-      mattr_accessor :connection_handlers, instance_accessor: false, default: {}
+      def exec_query_result(query, args)
+        reset_id_when_required(query)
+        connection.exec_query(query, args)
+      end
 
-      class_attribute :default_connection_handler
+      def query(*query_args)
+        if query_args.first.is_a?(Symbol)
+          query_name, body = query_args
 
-      def self.connection_handler
-        Thread.current.thread_variable_get("db2q_connection_handler") || default_connection_handler
+          body_lambda = if body.is_a?(Proc)
+            -> args { body.call(args << { query_name: query_name }) }
+          elsif body.is_a?(String)
+            definition = definitions.lookup_query(query_name, body.strip)
+            -> args { exec_query_result(definition, args) }
+          else
+            raise Db2Query::QueryMethodError.new
+          end
+
+          singleton_class.define_method(query_name) do |*args|
+            body_lambda.call(args)
+          end
+        elsif query_args.first.is_a?(String)
+          sql, args = [query_args.first.strip, query_args.drop(1)]
+
+          definition = Query.new.tap do |d|
+            d.define_sql(sql)
+            d.define_args(args)
+          end
+
+          connection.raw_query(definition.db2_spec_sql, definition.args)
+        else
+          raise Db2Query::Error, "Wrong query implementation"
+        end
       end
+      alias define query
 
-      def self.connection_handler=(handler)
-        Thread.current.thread_variable_set("db2q_connection_handler", handler)
+      def query_arguments_map
+        @query_arguments_map ||= {}
       end
 
-      self.default_connection_handler = DB2Query::ConnectionHandler.new
-    end
+      def query_arguments(query_name, argument_types)
+        query_arguments_map[query_name] = argument_types
+      end
 
-    module ClassMethods
-      def initiation
-        yield(self) if block_given?
+      def fetch(sql, args = [])
+        query = definitions.lookup_query(args, sql)
+        query.validate_select_query
+        connection.exec_query(query, args)
       end
 
-      def attributes(attr_name, format)
-        formatters.store(attr_name, format)
+      def fetch_list(sql, args)
+        list = args.first
+        fetch(sql_with_list(sql, list), args.drop(1))
       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."
+      private
+        def new_definitions
+          definition_class = "Definitions::#{name}Definitions"
+          Object.const_get(definition_class).new(
+            query_arguments_map,
+            field_types_map
+          )
+        rescue Exception => e
+          raise Db2Query::Error, e.message
         end
 
-        if body.respond_to?(:call)
-          singleton_class.define_method(name) do |*args|
-            body.call(*args)
+        def reset_id_when_required(query)
+          if query.insert_sql? && !query.column_id.nil?
+            connection.reset_id_sequence!(query.table_name)
           end
-        elsif body.is_a?(String)
-          sql = body
-          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
-
-      private
-        def formatters
-          @formatters ||= Hash.new
         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 DB2Query::Error, "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 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

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,68 @@
+# 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
+      @connection_pool = nil
+      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

data/lib/db2_query/definitions.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Definitions
+    attr_accessor :types, :types_map
+    attr_reader :arguments_map
+
+    def initialize(query_arguments_map, field_types_map)
+      @arguments_map = query_arguments_map
+      @types_map = field_types_map
+      describe
+      initialize_types
+    end
+
+    def describe
+      raise Db2Query::Error, "Please describe query definitions at #{self.class.name}"
+    end
+
+    def queries
+      @queries ||= {}
+    end
+
+    def query_definition(query_name, &block)
+      definition = Query.new(query_name)
+      yield definition
+      queries[query_name] = definition
+    end
+
+    def lookup(query_name)
+      queries.fetch(query_name)
+    rescue
+      raise Db2Query::QueryDefinitionError.new(name, query_name)
+    end
+
+    def lookup_query(*args)
+      query_name, sql = query_definitions(args)
+      lookup(query_name).tap do |query|
+        query.define_sql(sql)
+        query.argument_keys.each do |key|
+          key, key_def = query_arg_key(query, key)
+          query.argument_types.store(key, data_type_instance(key_def))
+        end
+      end
+    end
+
+    private
+      def initialize_types
+        queries.each do |query_name, definition|
+          definition.columns.each do |column, col_def|
+            definition.types.store(column, data_type_instance(col_def))
+          end
+        end
+      end
+
+      def new_data_type(klass, options)
+        options.nil? ? klass.new : klass.new(**options)
+      rescue Exception => e
+        raise Db2Query::Error, e.message
+      end
+
+      def data_type_instance(column_definition)
+        data_type, options = column_definition
+        klass = @types_map.fetch(data_type)
+        new_data_type(klass, options)
+      rescue
+        raise Db2Query::Error, "Not supported `#{data_type}` data type"
+      end
+
+      def fetch_query_name(args)
+        placeholder = args.pop
+        placeholder.fetch(:query_name)
+      rescue
+        raise Db2Query::ImplementationError.new
+      end
+
+      def query_definitions(args)
+        case args.first
+        when Array
+          query_name = fetch_query_name(args.first)
+          [query_name, args.last]
+        else args
+        end
+      end
+
+      def query_arg_key(query, key)
+        [key, unless arguments_map[query.query_name].nil?
+          arguments_map[query.query_name][key]
+        else
+          query.columns[key]
+        end]
+      end
+  end
+end

data/lib/db2_query/error.rb

@@ -1,16 +1,81 @@
 # frozen_string_literal: true
 
-module DB2Query
+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
+  class ArgumentError < StandardError
+    def initialize(given, expected)
+      @given = given
+      @expected = expected
+      super(message)
     end
 
-    attr_reader :sql, :binds
+    def message
+      "Wrong number of arguments (given #{@given}, expected #{@expected})"
+    end
+  end
+
+  class ColumnError < StandardError
+    def initialize(def_cols, res_cols)
+      @def_cols = def_cols
+      @res_cols = res_cols
+      super(message)
+    end
+
+    def message
+      "Wrong number of columns (query definitions #{@def_cols}, query result #{@res_cols})"
+    end
+  end
+
+  class ConnectionError < StandardError
+    def initialize(odbc_message)
+      @odbc_message = odbc_message
+      super(message)
+    end
+
+    def message
+      "Unable to activate ODBC DSN connection #{@odbc_message}"
+    end
+  end
+
+  class ExtensionError < StandardError
+  end
+
+  class ImplementationError < StandardError
+    def message
+      "Method `fetch`, `fetch_list`, and `exec_query` can only be implemented inside a lambda query"
+    end
+  end
+
+  class ListTypeError < StandardError
+  end
+
+  class MissingListError < StandardError
+  end
+
+  class QueryDefinitionError < StandardError
+    def initialize(klass, query_name = nil, column = nil)
+      @klass = klass
+      @query_name = query_name
+      @column = column
+      super(message)
+    end
+
+    def message
+      if @query_name.nil?
+        "Definitions::#{@klass}Definitions file not found."
+      elsif @column.nil?
+        "No query definition found for #{@klass}:#{@query_name}"
+      else
+        "Column `#{@column}` not found at `#{@klass} query:#{@query_name}` Query Definitions."
+      end
+    end
+  end
+
+  class QueryMethodError < StandardError
+    def message
+      "The query body needs to be callable or is a SQL statement string"
+    end
   end
 end

data/lib/db2_query/field_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module FieldType
+    DEFAULT_FIELD_TYPES = {
+      binary: Db2Query::Type::Binary,
+      boolean:  Db2Query::Type::Boolean,
+      string: Db2Query::Type::String,
+      varchar: Db2Query::Type::String,
+      longvarchar: Db2Query::Type::String,
+      decimal: Db2Query::Type::Decimal,
+      integer: Db2Query::Type::Integer,
+      date: Db2Query::Type::Date,
+      time: Db2Query::Type::Time,
+      timestamp: Db2Query::Type::Timestamp
+    }
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      mattr_reader :field_types_map
+      @@field_types_map = nil
+
+      def set_field_types(types = DEFAULT_FIELD_TYPES)
+        @@field_types_map = types
+      end
+    end
+  end
+end