db2_query 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42c29fbb4c23d3cc0198ea49b0cbb9e980150a610dde50b19e422c8dd9519c99
-  data.tar.gz: 7ff6974cb986bc5df133229f275d4be9bac9a647e7936c35e1f3103967848b95
+  metadata.gz: '09ecde3a8404d9aa56b416cbd3aa89efb21519166dea225cf8e3d7a54a2b4ed1'
+  data.tar.gz: c72fe3cc5e681d99d3dd5a6ec85863cb15b4b95e72b92e42dcb9d20fac910fbc
 SHA512:
-  metadata.gz: 79661005fa24b32c0b03e119549377f5fea9dde025aa91dc5809ad52ad4f212f9b20a278736ea6a077aefb411d4bbc0513bb0e3acb629675d9735202206ebfd4
-  data.tar.gz: 6f58ef2ceb59765e54310d2ea7c1cf1132da62f6102e7187121691b8018670b6a9abe194d41d86cfd9042f35cb5e5746444dcf10c9adced05b85e2335c37f5e6
+  metadata.gz: 20370e437967f91a7b273b21339c22ad4f868310812be5ff40676eb0ae28044def876276044aa1a0f237fec1b47e3acf6b7591e2bf1d76d53b7876ca688528ae
+  data.tar.gz: aa62b2ff0df74fb300963ab83c36f066b6e032d26de149ade42ed7cd79daac5579aedeae1bafd264747466a0719520b76ef8cef49e7e1e4c64a9cc84eb9f46db

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2020 yohanes_l
+Copyright 2021 yohanes oktavianus lumentut
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,7 +2,9 @@
 
 [![Gem Version](https://badge.fury.io/rb/db2_query.svg)](https://badge.fury.io/rb/db2_query)
 
-A Rails 6+ query plugin to fetch data from Db2 database by using ODBC connection
+A Rails 5 & Rails 6 plugin for handling Db2 SQL database `SIUD` statement (`SELECT`, `INPUT`, `UPDATE`, `DELETE`) by using ODBC connection.
+
+Note: Tested at Rails 5.2.6 and Rails 6.1.4
 
 ## Installation
 Add this line to your application's Gemfile:
@@ -26,39 +28,27 @@ Execute init task at the app root
 ```bash
 $ rake db2query:init
 ```
-DB2Query will generate two required files:
-- `config/db2query_database.yml`
+Db2Query will generate two required files:
+- `config/db2query.yml`
 - `config/initializers/db2query.rb`
 
-Edit these files according to the requirement.
-
-Note: 
-
-To upgrade from the previous version to v.0.2.1, please delete all the files generated by init task and do init task again (don't forget to backup your db2query_database.yml).
-
-In v.0.2.0, we have to `require 'db2_query'` at initializer manually.
+Edit those files according to the requirement.
 
 ### Database Configuration
-At `db2query_database.yml` we can use two type of connection:
-1. DSN connection config
-2. Connection String config
+At version 0.3.0, `db2query.yml` only use DSN connection config:
 ```yml
-development:
-  primary:                          # Connection String Example
-    conn_string:
-      driver: DB2
-      database: SAMPLE
-      dbalias: SAMPLE
-      hostname: LOCALHOST
-      currentschema: LIBTEST
-      port: "0"
-      protocol: IPC
-      uid: <%= ENV["DB2EC_UID"] %>
-      pwd: <%= ENV["DB2EC_PWD"] %>
-  secondary:             # DSN Example
-    dsn: iseries
-    uid: <%= ENV["ISERIES_UID"] %>
-    pwd: <%= ENV["ISERIES_PWD"] %>
+  development:
+     dsn: ARUNIT
+     pool: 5
+     timeout: 5
+  test:
+     dsn: ARUNIT
+     pool: 5
+     timeout: 5
+  production:
+     dsn: ARUNIT
+     pool: 5
+     timeout: 5
 ```
 
 Ensure that `unixodbc` have been installed and test your connection first by using `isql` commands.
@@ -67,7 +57,7 @@ Example:
 
 Secondary database connection test
 ```bash
-$ isql -v iseries
+$ isql -v ARUNIT
 +---------------------------------------+
 | Connected!                            |
 |                                       |
@@ -80,71 +70,134 @@ SQL>
 ```
 
 ## Usage
-Note: Version 0.1.0 use `Db2Query` namespace. Please use `DB2Query` in versions greater than it.
+Note: Version 0.1.0 use `Db2Query` namespace. Version 0.2 use `DB2Query`. At version 0.3.0 we use `Db2Query`  , revert back to the previous namespace.
 
 ### 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. 
+
+Note: `$`symbol is used as column name prefix.
+
+### 1. `query` method
+The `query` method must have 2 inputs:
+1. Method name
+2. Body (can be an SQL statement or lamda).
+
+The lambda is used to facilitate us in using `built-in methods` as shown at two query methods below:
+Example 1.
 ```ruby
-class User < DB2Query::Base
+class User < Db2Query::Base
   query :find_by, <<-SQL
-    SELECT * FROM LIBTEST.USERS WHERE id = ?
+    SELECT * FROM LIBTEST.USERS WHERE $id = ?
   SQL
 end
-
-class User < DB2query::Base
+```
+```bash
+irb(main):004:0> User.find_by 10000
+  SQL (3.2ms)  SELECT * FROM LIBTEST.USERS WHERE id = ?  [["id", 10000]]
+=> #<Db2Query::Result [#<Record id: 10000, first_name: "Wilma", last_name: "Lindgren", email: "cleveland_kilback@breitenberg.com">]>
+```
+Example 2.
+```ruby
+class User < Db2query::Base
   query :id_greater_than, -> id {
-    exec_query({}, "SELECT * FROM LIBTEST.USERS WHERE id > ?", [id])
-  }
-
-  query :insert_record, -> *args {
-    execute(
-      "INSERT INTO users (id, first_name, last_name, email) VALUES (?, ?, ?, ?)", args
-    )
+    exec_query({}, "SELECT * FROM LIBTEST.USERS WHERE $id > ?", [id])
   }
 end
 ```
+```bash
+irb(main):003:0> User.id_greater_than 10000
+  SQL (3.2ms)  SELECT * FROM LIBTEST.USERS WHERE id > ?  [["id", 1000]]
+=> #<Db2Query::Result [#<Record id: 10000, first_name: "Wilma", last_name: "Lindgren", email: "cleveland_kilback@breitenberg.com">...">]>
+```
+Example 3.
+```ruby
+class User < Db2query::Base
+  query :insert_record, -> args {
+    exec_query({},
+      "INSERT INTO users ($id, $first_name, $last_name, $email) VALUES (?, ?, ?, ?)", args
+  )
+}
+end
+```
+```bash
+```
 
-The query method must have 2 inputs:
-1. Method name
-2. Body (can be an SQL statement or lamda).
-
-The lambda is used to facilitate us in using `built-in methods` as shown at two query methods above.
-
-Or use a normal sql method (don't forget the `_sql` suffix)
+### 2. Plain/normal method
+At a plain/normal sql method we add `_sql` suffix. For example `find_by_sql`
 ```ruby
-class User < DB2Query::Base 
+class User < Db2Query::Base 
   def find_by_sql
-    "SELECT * FROM LIBTEST.USERS WHERE id = ?"
+    "SELECT * FROM LIBTEST.USERS WHERE $id = ?"
   end
 end
 ```
-Check it at rails console
+Then we can call it by using `find_by` class method.
 ```bash
-User.find_by 10000
+irb(main):001:0> User.find_by 10000
 SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE id = ? [[nil, 10000]]
 => #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
-Or using keywords argument if the sql use `=` operator, e.g `first_name = ?`
+Or with hash arguments input
+```ruby
+class User < Db2Query::Base
+  def by_name_and_email_sql
+    "SELECT * FROM LIBTEST.USERS WHERE $first_name = ? AND $email = ?"
+  end
+end
+```
 ```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]]
+irb(main):001:0> User.by_name_and_email first_name: "Strange", email: "strange@marvel.universe.com"
+SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ? [["first_name", Strange], ["email", strange@marvel.universe.com]]
 => #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
+```
+###  SQL extention (`@extention`)
+For a reusable sql, we can extend it by using a combination of `extention` and `sql_with_extention` methods,  with an `@extention` pointer at SQL statement.
+```ruby
+class User < Db2Query::Base
+    # reusable SQL
+	_SQL = -> extention {
+    sql_with_extention("SELECT * FROM LIBTEST.USERS WHERE @extention", extention)
+  }
+    # implementation
+  query :by_email, _SQL.("$email = ?")
+end
+```
+```bash
+irb(main):004:0> User.by_email "strange@marvel.universe.com"
+  SQL (3.2ms)  SELECT * FROM LIBTEST.USERS WHERE email = ?  [["email", "strange@marvel.universe.com"]]
+=> #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]> 
+```
+### List input (`@list`)
+For an array consist list of inputs, we can use `fetch_list` method and `@list` pointer at the SQL statement.
+
+```ruby
+class User < Db2Query
+  query :by_ids, -> ids {
+    fetch_list("SELECT * FROM LIBTEST.USERS WHERE ID IN (@list)", ids)
+  }
+end
+```
+```bash
+irb(main):007:0> User.by_ids [10000,10001,10002]
+  SQL (2.8ms)  SELECT * FROM LIBTEST.USERS WHERE ID IN ('10000', '10001', '10002')
+=> #<Db2Query::Result [#<Record id: 10000, name: "Carol", last_name: "Danvers", email: "captain.marvel@marvel.universe.com">, #<Record id: 10001, first_name: "Natasha", last_name: "Romanova", email: "black.widow@marvel.universe">, #<Record id: 10002, first_name: "Wanda", last_name: "Maximoff", email: "scarlet.witch@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 adding a formatter class that inherits `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)
     "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
 ```
@@ -161,13 +214,15 @@ SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE id = ? [["id", 10000]]
 => #<DB2Query::Result @records=[#<Record id: 10000, first_name: "Dr.Strange", last_name: "Stephen", email: "strange@marvel.universe.com">]>
 ```
 
-### Available Result Ogject methods
-`DB2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom methods:
+For complete examples please see the basic examples [here](https://github.com/yohaneslumentut/db2_query/blob/master/test/dummy/app/queries/test_query.rb).
+
+### Available Result Object methods
+`Db2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom methods:
   1. `records` to convert query result into array of Record objects.
   2. `to_h` to convert query result into hash with symbolized keys.
 
 ### Built-in methods
-These built-in methods are delegated to `DB2Query::Connection` methods
+These built-in methods are delegated to `Db2Query::Connection` methods
   1. `query_rows(sql)`
   2. `query_value(sql)`
   3. `query_values(sql)`
@@ -182,8 +237,8 @@ Create an abstract class that inherit from `ActiveRecord::Base`
 class Db2Record < ActiveRecord::Base
   self.abstract_class = true
 
-  def self.query(sql, formatter = {}, args = [])
-    DB2Query::Base.connection.exec_query(sql, formatter, args).to_a.map(&:deep_symbolize_keys)
+  def self.query(formatter, sql, args = [])
+    Db2Query::Base.connection.exec_query(formatter, sql, args).to_a.map(&:deep_symbolize_keys)
   end
 end
 ```
@@ -193,7 +248,7 @@ Utilize the goodness of rails model `scope`
 class User < Db2Record
   scope :by_name, -> *args {
     query(
-      "SELECT * FROM LIBTEST.USERS WHERE first_name = ? AND last_name = ?", {}, args
+      {}, "SELECT * FROM LIBTEST.USERS WHERE $first_name = ? AND $last_name = ?", args
     )
   }
 end
@@ -220,4 +275,4 @@ SQL Load (3.28ms)  SELECT * FROM LIBTEST.USERS WHERE age > 500
 ```
 
 ## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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,25 +1,22 @@
-# 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/error"
-require "db2_query/connection_handling"
+require "active_support/concurrency/load_interlock_aware_monitor"
+require "connection_pool"
+require "odbc_utf8"
 
-module DB2Query
+module Db2Query
   extend ActiveSupport::Autoload
 
   autoload :Version
-  autoload :Base
-  autoload :Bind
-  autoload :Core
-  autoload :DatabaseStatements
+  autoload :Config
   autoload :Connection
-  autoload :ODBCConnector
-  autoload :Formatter
+  autoload :Core
   autoload :Result
+  autoload :Logger
+  autoload :Base
+  autoload :Error
 
   require "db2_query/railtie" if defined?(Rails)
 end

data/lib/db2_query/base.rb

@@ -1,10 +1,8 @@
 # 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 Core
   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
+    extend ActiveSupport::Concern
+    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
+    included do
+      @@configurations = nil
     end
 
-    def config_file
-      Pathname.new(config_path)
-    end
+    class_methods do
+      def configurations
+        @@configurations
+      end
+      alias config configurations
 
-    def read_config
-      erb = ERB.new(config_file.read)
-      YAML.parse(erb.result(binding)).transform.transform_keys(&:to_sym)
+      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
+      end
     end
   end
 end

data/lib/db2_query/connection.rb

@@ -1,164 +1,128 @@
-# frozen_String_literal: true
+# frozen_string_literal: true
 
-module DB2Query
-  class Connection
-    ADAPTER_NAME = "DB2Query"
+require_relative "error"
+require "connection_pool"
 
-    include DB2Query::DatabaseStatements
-    include ActiveSupport::Callbacks
-
-    define_callbacks :checkout, :checkin
+module Db2Query
+  class Bind < Struct.new(:name, :value, :index)
+  end
 
-    set_callback :checkin, :after, :enable_lazy_transactions!
+  class Connection < ConnectionPool
+    attr_reader :config
 
-    attr_accessor :pool
-    attr_reader :owner, :connector, :lock
-    alias :in_use? :owner
+    include Logger
 
-    def initialize(type, config)
-      @connector = DB2Query::ODBCConnector.new(type, config)
-      @instrumenter  = ActiveSupport::Notifications.instrumenter
+    def initialize(config, &block)
       @config = config
-      @pool = ActiveRecord::ConnectionAdapters::NullPool.new
+      super(pool_config, &block)
+      @instrumenter = ActiveSupport::Notifications.instrumenter
       @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
-      connect
     end
 
-    def adapter_name
-      self.class::ADAPTER_NAME
-    end
-
-    def current_transaction
-    end
-
-    def begin_transaction(options = {})
-    end
-
-    def transaction_open?
-    end
+    alias pool with
 
-    def requires_reloading?
-      false
+    def pool_config
+      { size: config[:pool], timeout: config[:timeout] }
     end
 
-    def close
-      pool.checkin self
+    def query(sql)
+      pool do |odbc_conn|
+        stmt = odbc_conn.run(sql)
+        stmt.to_a
+      ensure
+        stmt.drop unless stmt.nil?
+      end
     end
 
-    def connect
-      @connection = connector.connect
+    def query_rows(sql)
+      query(sql)
     end
 
-    def active?
-      @connection.connected?
+    def query_value(sql)
+      single_value_from_rows(query(sql))
     end
 
-    def reconnect!
-      disconnect!
-      connect
+    def query_values(sql)
+      query(sql).map(&:first)
     end
-    alias reset! reconnect!
 
-    def disconnect!
-      if @connection.connected?
-        @connection.commit
-        @connection.disconnect
+    def execute(sql, args = [])
+      pool do |odbc_conn|
+        odbc_conn.do(sql, *args)
       end
     end
 
-    def check_version
-    end
-
-    def enable_lazy_transactions!
-      @lazy_transactions_enabled = true
+    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, args, binds)
+      end
     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}."
+    def run_query(formatters, sql, args = [], binds)
+      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
-        raise DB2Query::Error, msg
+        Db2Query::Result.new(columns, rows, formatters)
       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)
+    private
+      def single_value_from_rows(rows)
+        row = rows.first
+        row && row.first
       end
-    end
 
-    def translate_exception(exception, message:, sql:, binds:)
-      case exception
-      when RuntimeError
-        exception
-      else
-        DB2Query::StatementInvalid.new(message, sql: sql, binds: binds)
+      def iud_sql?(sql)
+        sql.match?(/insert into|update|delete/i)
       end
-    end
 
-    def expire
-      if in_use?
-        if @owner != Thread.current
-          raise DB2Query::Error, "Cannot expire connection, " \
-            "it is owned by a different thread: #{@owner}. " \
-            "Current thread: #{Thread.current}."
-        end
+      def iud_ref_table(sql)
+        sql.match?(/delete/i) ? "OLD TABLE" : "NEW TABLE"
+      end
 
-        @idle_since = Concurrent.monotonic_time
-        @owner = nil
-      else
-        raise DB2Query::Error, "Cannot expire connection, it is not currently leased."
+      def db2_spec_sql(sql)
+        if iud_sql?(sql)
+          "SELECT * FROM #{iud_ref_table(sql)} (#{sql})"
+        else
+          sql
+        end.tr("$", "")
       end
-    end
 
-    def steal!
-      if in_use?
-        if @owner != Thread.current
-          pool.send :remove_connection_from_thread_cache, self, @owner
+      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
 
-          @owner = Thread.current
+        if given != expected
+          raise Db2Query::Error, "wrong number of arguments (given #{given}, expected #{expected})"
         end
-      else
-        raise DB2Query::Error, "Cannot steal connection, it is not currently leased."
-      end
-    end
 
-    def seconds_idle
-      return 0 if in_use?
-      Concurrent.monotonic_time - @idle_since
-    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