db2_query 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d2946448234d56484778d59e3051573c81c2789631776f0ed543a79fdc510fa
-  data.tar.gz: a257fabf1a7de500f7d325c70dd11f494a08163dbf78460f61b3bf51cb626b77
+  metadata.gz: fde277f004b8ff05460621968ce473c7f15f047a5903e77c6bf7da997640d8dc
+  data.tar.gz: 72fc3599f00909fabc2125964ce5a3f79de9e2343577937206c04c88d7b97cc1
 SHA512:
-  metadata.gz: ca8c1b52138ec97d9f4e9cbbca0d8bb148e95f4ac181a929e3e5715b597ed59b70e25b779156ba45a7fe9f119203e4162a2a932c63d11c94acdc2a1eaeb56db8
-  data.tar.gz: 67f0d7228274d4a7a6e38771cc0743b83da27621d3ce310e0d5d7d323e937316f700ec3b278734312ff27cdc88796321cb09f02d7c2bf48b8c5607a7331a7f27
+  metadata.gz: 477d63287ce0a745ba5dfd91c82f8984632976dec003c305f5a888ba54bccec8b5b8a065c12462bb2294dc14f74537d135ed012df9a0a541cb773109c22a6ff9
+  data.tar.gz: ab481810cc3cb1ed79bb97594d3af8480e518e7527d770d73606523b5ae35504a4bb6b0ef128ee32f579216604a6b1e43e6230e6e0b0e4fc222a005e086cc513

data/README.md

@@ -1,4 +1,7 @@
-# Db2Query
+# DB2Query
+
+[![Gem Version](https://badge.fury.io/rb/db2_query.svg)](https://badge.fury.io/rb/db2_query)
+
 A Rails query plugin to fetch data from Db2 database by using ODBC connection.
 
 ## Installation
@@ -15,7 +18,7 @@ $ bundle
 
 Or install it yourself as:
 ```bash
-$ gem install db2-query
+$ gem install db2_query
 ```
 
 ## Initialization
@@ -23,7 +26,7 @@ Execute init task at the app root
 ```bash
 $ rake db2query:init
 ```
-Db2Query will generate two required files:
+DB2Query will generate two required files:
 - `config/db2query_database.yml`
 - `config/initializers/db2query`
 
@@ -35,7 +38,8 @@ At `db2query_database.yml` we can use two type of connection:
 2. Connection String config
 ```yml
 development:
-  primary:                         # Connection String Example
+  primary:                          # Connection String Example
+    adapter: db2_query
     conn_string:
       driver: DB2
       database: SAMPLE
@@ -46,79 +50,76 @@ development:
       protocol: IPC
       uid: <%= ENV["DB2EC_UID"] %>
       pwd: <%= ENV["DB2EC_PWD"] %>
-  secondary:                       # DSN Example
-    dsn: SAMPLE
-    uid: <%= ENV["DB2EC_UID"] %>
-    pwd: <%= ENV["DB2EC_PWD"] %>
+  secondary:
+    adapter: db2_query             # DSN Example
+    dsn: iseries
+    uid: <%= ENV["ISERIES_UID"] %>
+    pwd: <%= ENV["ISERIES_PWD"] %>
 ```
 
 ## Usage
 ### Basic Usage
-Create query class that inherit from `Db2Query::Base` in `app/queries` folder
+Create query class that inherit from `DB2Query::Base` in `app/queries` folder
 ```ruby
-class Users < Db2Query::Base
+class User < DB2Query::Base
   query :find_by, <<-SQL
-    SELECT * FROM LIBTEST.USERS WHERE user_id = ?
+    SELECT * FROM LIBTEST.USERS WHERE id = ?
   SQL
 end
 ```
 Or use a normal sql method (don't forget the `_sql` suffix)
 ```ruby
-class Users < Db2Query::Base 
+class User < DB2Query::Base 
   def find_by_sql
-    "SELECT * FROM LIBTEST.USERS WHERE user_id = ?"
+    "SELECT * FROM LIBTEST.USERS WHERE id = ?"
   end
 end
 ```
 Check it at rails console
 ```bash
-Users.find_by 10000
-Users Load (330.28ms)  SELECT * FROM LIBTEST.USERS WHERE user_id = ? [[10000]]
-=> #<Db2Query::Result [#<Users::FindBy user_id: 10000, first_name: "Alex", last_name: "Jacobi", email: "lula_durgan@dooley.com">]>
+User.find_by 10000
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE user_id = ? [[nil, 10000]]
+=> #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
+Or using keywords argument
+```bash
+User.by_name first_name: "Strange", last_name: "Stephen"
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ? [["first_name", Strange], ["last_name", Stephen]]
+=> #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
+```
+
 ### Formatter
-In order to get different result column format, a query result can be reformatted by add a formatter class that inherit `Db2Query::AbstractFormatter` then register at `config\initializers\db2query.rb`
+In order to get different result column format, a query result can be reformatted by add a formatter class that inherit `DB2Query::AbstractFormatter` then register at `config\initializers\db2query.rb`
 ```ruby
 require "db2_query/formatter"
 
 # create a formatter class
-class FirstNameFormatter < Db2Query::AbstractFormatter
+class FirstNameFormatter < DB2Query::AbstractFormatter
   def format(value)
-    "Mr/Mrs. " + value
+    "Dr." + value
   end
 end
 
 # register the formatter class
-Db2Query::Formatter.registration do |format|
+DB2Query::Formatter.registration do |format|
   format.register(:first_name_formatter, FirstNameFormatter)
 end
 ```
 Use it at query class
 ```ruby
-class Users < Db2Query::Base
+class Doctor < User
   attributes :first_name, :first_name_formatter
-
-  query :find_by, <<-SQL
-    SELECT * FROM LIBTEST.USERS WHERE user_id = ?
-  SQL
 end
 ```
 Check it at rails console
 ```bash
-Users.find_by 10000
-Users Load (330.28ms)  SELECT * FROM LIBTEST.USERS WHERE user_id = ? [[10000]]
-=> #<Db2Query::Result [#<Users::FindBy user_id: 10000, first_name: "Mr/Mrs. Alex", last_name: "Jacobi", email: "lula_durgan@dooley.com">]>
+Doctor.find_by id: 10000
+SQL Load (30.28ms)  SELECT * FROM LIBTEST.USERS WHERE user_id = ? [["id", 10000]]
+=> #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Dr.Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
-### Available methods
-Db2Query::Result has public methods as follows:
-- to_a
-- to_hash
-- pluck
-- first
-- last
-- size
-- each
 
+### Available methods
+`DB2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom `records` method.
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,29 +1,12 @@
 # frozen_string_literal: true
 
-begin
-  require "bundler/setup"
-rescue LoadError
-  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
-end
-
-require "rdoc/task"
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title    = "Db2Query"
-  rdoc.options << "--line-numbers"
-  rdoc.rdoc_files.include("README.md")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-end
-
 require "bundler/gem_tasks"
-
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = false
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
 task default: :test

data/lib/active_record/connection_adapters/db2_query_adapter.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "odbc_utf8"
+require "db2_query/odbc_connector"
+require "db2_query/database_statements"
+
+module ActiveRecord
+  module ConnectionHandling
+    def db2_query_connection(config)
+      conn_type = (config.keys & DB2Query::CONNECTION_TYPES).first
+      if conn_type.nil?
+        raise ArgumentError, "No data source name (:dsn) or connection string (:conn_str) provided."
+      end
+      connector = DB2Query::ODBCConnector.new(conn_type, config)
+      ConnectionAdapters::DB2QueryConnection.new(connector, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class DB2QueryConnection
+      include DB2Query::DatabaseStatements
+      include ActiveSupport::Callbacks
+      define_callbacks :checkout, :checkin
+
+      set_callback :checkin, :after, :enable_lazy_transactions!
+
+      attr_accessor :pool
+      attr_reader :owner, :connector, :lock
+      alias :in_use? :owner
+
+      def initialize(connector, config)
+        @connector = connector
+        @instrumenter  = ActiveSupport::Notifications.instrumenter
+        @config = config
+        @pool = ActiveRecord::ConnectionAdapters::NullPool.new
+        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+        connect
+      end
+
+      def connect
+        @connection = connector.connect
+        @connection.use_time = true
+      end
+
+      def active?
+        @connection.connected?
+      end
+
+      def reconnect!
+        disconnect!
+        connect
+      end
+      alias reset! reconnect!
+
+      def disconnect!
+        if @connection.connected?
+          @connection.commit
+          @connection.disconnect
+        end
+      end
+
+      def check_version
+      end
+
+      def enable_lazy_transactions!
+        @lazy_transactions_enabled = true
+      end
+
+      def lease
+        if in_use?
+          msg = +"Cannot lease connection, "
+          if @owner == Thread.current
+            msg << "it is already leased by the current thread."
+          else
+            msg << "it is already in use by a different thread: #{@owner}. " \
+                   "Current thread: #{Thread.current}."
+          end
+          raise ActiveRecordError, msg
+        end
+
+        @owner = Thread.current
+      end
+
+      def verify!
+        reconnect! unless active?
+      end
+
+      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
+          ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+        end
+      end
+
+      def expire
+        if in_use?
+          if @owner != Thread.current
+            raise ActiveRecordError, "Cannot expire connection, " \
+              "it is owned by a different thread: #{@owner}. " \
+              "Current thread: #{Thread.current}."
+          end
+
+          @idle_since = Concurrent.monotonic_time
+          @owner = nil
+        else
+          raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
+        end
+      end
+
+      def steal!
+        if in_use?
+          if @owner != Thread.current
+            pool.send :remove_connection_from_thread_cache, self, @owner
+
+            @owner = Thread.current
+          end
+        else
+          raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
+        end
+      end
+
+      def seconds_idle # :nodoc:
+        return 0 if in_use?
+        Concurrent.monotonic_time - @idle_since
+      end
+
+      private
+        def type_map
+          @type_map ||= Type::TypeMap.new.tap do |mapping|
+            initialize_type_map(mapping)
+          end
+        end
+
+        def alias_type(map, new_type, old_type)
+          map.register_type(new_type) do |_, *args|
+            map.lookup(old_type, *args)
+          end
+        end
+
+        def initialize_type_map(map)
+          map.register_type "boolean",              Type::Boolean.new
+          map.register_type ODBC::SQL_CHAR,         Type::String.new
+          map.register_type ODBC::SQL_LONGVARCHAR,  Type::Text.new
+          map.register_type ODBC::SQL_TINYINT,      Type::Integer.new(limit: 4)
+          map.register_type ODBC::SQL_SMALLINT,     Type::Integer.new(limit: 8)
+          map.register_type ODBC::SQL_INTEGER,      Type::Integer.new(limit: 16)
+          map.register_type ODBC::SQL_BIGINT,       Type::BigInteger.new(limit: 32)
+          map.register_type ODBC::SQL_REAL,         Type::Float.new(limit: 24)
+          map.register_type ODBC::SQL_FLOAT,        Type::Float.new
+          map.register_type ODBC::SQL_DOUBLE,       Type::Float.new(limit: 53)
+          map.register_type ODBC::SQL_DECIMAL,      Type::Float.new
+          map.register_type ODBC::SQL_NUMERIC,      Type::Integer.new
+          map.register_type ODBC::SQL_BINARY,       Type::Binary.new
+          map.register_type ODBC::SQL_DATE,         Type::Date.new
+          map.register_type ODBC::SQL_DATETIME,     Type::DateTime.new
+          map.register_type ODBC::SQL_TIME,         Type::Time.new
+          map.register_type ODBC::SQL_TIMESTAMP,    Type::DateTime.new
+          map.register_type ODBC::SQL_GUID,         Type::String.new
+
+          alias_type map, ODBC::SQL_BIT,            "boolean"
+          alias_type map, ODBC::SQL_VARCHAR,        ODBC::SQL_CHAR
+          alias_type map, ODBC::SQL_WCHAR,          ODBC::SQL_CHAR
+          alias_type map, ODBC::SQL_WVARCHAR,       ODBC::SQL_CHAR
+          alias_type map, ODBC::SQL_WLONGVARCHAR,   ODBC::SQL_LONGVARCHAR
+          alias_type map, ODBC::SQL_VARBINARY,      ODBC::SQL_BINARY
+          alias_type map, ODBC::SQL_LONGVARBINARY,  ODBC::SQL_BINARY
+          alias_type map, ODBC::SQL_TYPE_DATE,      ODBC::SQL_DATE
+          alias_type map, ODBC::SQL_TYPE_TIME,      ODBC::SQL_TIME
+          alias_type map, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP
+        end
+    end
+  end
+end

data/lib/db2_query.rb

@@ -1,29 +1,23 @@
 # frozen_string_literal:true
 
-require "odbc"
 require "yaml"
 require "erb"
 require "active_record"
 require "active_support"
+require "active_record/database_configurations"
+require "db2_query/config"
 
-module Db2Query
+module DB2Query
   extend ActiveSupport::Autoload
 
   autoload :Version
-  autoload :Error
-  autoload :Path
-  autoload :Schema
-  autoload :DatabaseConfigurations
-  autoload :ODBCConnector
-  autoload :Connection
+  autoload :Base
+  autoload :Core
   autoload :ConnectionHandling
   autoload :DatabaseStatements
-  autoload :SQLValidator
-  autoload :LogSubscriber
+  autoload :ODBCConnector
   autoload :Formatter
-  autoload :Column
   autoload :Result
-  autoload :Base
-end
 
-require "db2_query/railtie"
+  require "db2_query/railtie" if defined?(Rails)
+end

data/lib/db2_query/base.rb

@@ -1,84 +1,11 @@
 # frozen_string_literal: true
 
-module Db2Query
+module DB2Query
   class Base
-    include DatabaseConfigurations
-    include ConnectionHandling
-
-    class << self
-      include SQLValidator
-
-      def attributes(attr_name, format)
-        attr_format.store(attr_name, format)
-      end
-
-      def query(method_name, sql_statement)
-        unless is_query?(sql_statement)
-          raise Error, "Query only for SQL query commands."
-        end
-
-        if self.class.respond_to?(method_name)
-          raise Error, "Query :#{method_name} has been defined before"
-        end
-
-        self.class.define_method(method_name) do |*args|
-          log(sql_statement, args) do
-            columns, rows = connection.exec_query(sql_statement, *args)
-            Result.new(self, method_name, columns, rows, attr_format)
-          end
-        end
-      end
-
-      private
-        def attr_format
-          @attr_format ||= Hash.new
-        end
-
-        def define_query_method(method_name, sql_statement)
-          if is_query?(sql_statement)
-            query(method_name, sql_statement)
-          else
-            raise NotImplementedError
-          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
-
-            raise Error, "Query methods must return a SQL statement string!" unless sql_statement.is_a? String
-
-            expected_args = sql_statement.count "?"
-            given_args = args.size
-
-            if expected_args == given_args
-              define_query_method(method_name, sql_statement)
-            else
-              raise ArgumentError, "wrong number of arguments (given #{given_args}, expected #{expected_args})"
-            end
-
-            method(method_name).call(*args)
-          else
-            super
-          end
-        end
-
-        def instrumenter
-          @instrumenter ||= ActiveSupport::Notifications.instrumenter
-        end
-
-        def log(sql_statement, args)
-          instrumenter.instrument(
-            "sql.db2_query",
-            sql:   sql_statement,
-            name:  self,
-            binds: args) do
-            yield
-          end
-        end
-    end
+    include DB2Query::Core
+    include ActiveRecord::Inheritance
+    extend ActiveSupport::Concern
+    extend ActiveRecord::ConnectionHandling
+    extend DB2Query::ConnectionHandling
   end
 end