db2_query 0.3.2 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a863b9451d52ea28e71b1477cfd7275bb76b34c91a1302208f4052674dc7b901
-  data.tar.gz: 555eafaa282e3cab7a0d4231592a6d2a6d3087d0c194f98040dff1724f5da0f2
+  metadata.gz: 3e06666a1eee58811d081a1d8da67e2d3e814d91ef15a0c12bb5b306ee130aed
+  data.tar.gz: fa7ebb35a4e9019f9619416ed4c97fa410e663d3eb58b9320314002e759c501e
 SHA512:
-  metadata.gz: 917d8a2a7a1eefbb85185d021642f42115e7fd51969b302752f1284e274799fca9d7b24c3f6a7fdc764fa9a79cfd6cac7245e4500b0005d5e498f1e718e63a5b
-  data.tar.gz: 353f50ef752eaaee361c939c21f6552e4fa5c8b5bc81a0face640aae420d889fcb1fb148bd0d7b74e8fec3b1867ffa31df9996cacb05465302e512ec0a5d2147
+  metadata.gz: b538e762bf70e00782cc09eb56151c0db034dd13e7b757e8261c27e0e2caafbcd7da70b21a310d8881fe2072e3fd9d56fa072c3499fcd14ab7db97dbac24a2ce
+  data.tar.gz: c507ee06457bd6d84e6232ee5bb900cad7dc26249281fab2bb80e04382ea1f5aafd03a6fe182c056ac997176e33b8236bf587207638c1901ddaef694b53bc7a7

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2021 yohanes oktavianus lumentut
+Copyright Yohanes 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,11 +2,13 @@
 
 [![Gem Version](https://badge.fury.io/rb/db2_query.svg)](https://badge.fury.io/rb/db2_query)
 
-A Rails 5 & Rails 6 plugin for handling Db2 SQL database `SIUD` statement (`SELECT`, `INSERT`, `UPDATE`, `DELETE`) by using ODBC connection.
+A Rails 7 (Ruby v3.1.0) plugin for connecting Db2 with Rails appplication by using ODBC connection.
+Db2Query execute plain SQL instead of using query builder
 
-Note: Tested at Rails 5.2.6 and Rails 6.1.4
+Note: Tested at Rails 7.1.2 on Ruby v3.1.0
 
 ## 1. Installation
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -14,16 +16,23 @@ gem 'db2_query'
 ```
 
 And then execute:
+
 ```bash
 $ bundle
+  ...
 ```
 
 Or install it yourself as:
+
 ```bash
 $ gem install db2_query
+  ...
 ```
+
 ## 2. Initialization
+
 Execute **db2query:init** task at the app root to create database configurations and initializer file.
+
 ```bash
 $ rake db2query:init
       create  config/db2query.yml
@@ -33,20 +42,22 @@ $ rake db2query:init
 Complete the configurations by editing the files according to your application requirement.
 
 ### Database Configuration
+
 File **config/db2query.yml** consist of DSN/database name and connection pool config:
+
 ```yml
   development:
-     dsn: ARUNIT
+     dsn: LIBDEV
      idle: 5
      pool: 5
      timeout: 5
   test:
-     dsn: ARUNIT
+     dsn: LIBTEST
      idle: 5
      pool: 5
      timeout: 5
   production:
-     dsn: ARUNIT
+     dsn: LIBPROD
      idle: 5
      pool: 5
      timeout: 5
@@ -57,7 +68,9 @@ Key **idle** is a **client** idle maximum limit value (in minutes) to avoid the
 [**Ensure**](https://github.com/yohaneslumentut/db2_query/wiki/DB2-ODBC-Connection#verify-odbc-connection) that **unixodbc** has been installed and test your connection first by using **isql** commands.
 
 ### Initializer File
+
 This file is used by **Db2Query::Base** to load **field types** configurations and establish a **connection** instance.
+
 ```ruby
 # app_root/config/initializers/db2query.rb
 
@@ -70,7 +83,10 @@ end
 ```
 
 ### Custom Field Type
-**FieldTypes** are classes that used by **Db2Query** to format the data before sending it to the database by using `serialize` method and converting the **query result** before consumed by your **Rails application** by using `deserialize` method. Both `serialize` and `deserialize` operations are only applied when you provide **QueryDefinitions** on your query. By default, there are ten field types that can be used in your [query definitions](#32-querydefinitions) :
+
+**FieldTypes** are classes that are used by **Db2Query** to format the data before sending it to the database by using `serialize` method and `deserialize` the returned query result data by converting the **query result** before consumed by your **Rails application**. Both `serialize` and `deserialize` operations are only applied when you provide **QueryDefinitions** on your query.
+
+By default, there are ten field types that can be used in your [query definitions](#32-querydefinitions) :
 
 ```ruby
   DEFAULT_FIELD_TYPES = {
@@ -86,7 +102,9 @@ end
     timestamp: Db2Query::Type::Timestamp
   }
 ```
+
 You can use your own Field type class by extending **Db2Query::Type::Value** class. For example:
+
 ```ruby
   class CustomTypeClass < Db2Query::Type::Value
     # Method to convert data from ruby type value into data that is understood by Db2
@@ -100,7 +118,9 @@ You can use your own Field type class by extending **Db2Query::Type::Value** cla
     end
  end
 ```
-Then map the classes into a variable and load it into the **Db2Query::Base** by using **set_field_types** method in the initializer file.
+
+Then put the classes into a field types hash constant and load it into the **Db2Query::Base** by using **set_field_types** method in the initializer file.
+
 ```ruby
 # app_root/config/initializers/db2query.rb
 
@@ -122,28 +142,26 @@ end
 
 ## 3. Usage
 
-Once you completely do [**Installation**](#1-installation) & [**Initialization**](#2-initialization), basically you has been ready to use **Db2Query::Base** with three additional conventions: **SQL Convention**, **Field Type Convention**, **Argument Key Convention**.
+Once you completely do the [**Installation**](#1-installation) & [**Initialization**](#2-initialization) steps, basically you has been ready to use **Db2Query::Base**. There are three additional rules that help **Db2Query** run properly: **SQL Convention**, **Field Type Convention**, and **Argument Key Convention**.
 
 **SQL Convention**:
-> **"** Dollar symbol **$** is used as the prefix of all column names **in the WHERE clause** of provided **Parameterized Query** SQL string. It is used as a pointer in the binding process of key and value of query arguments. We have to provide it manually in the SQL string of each **Parameterized Query**. Here, **Parameterized Query** is used to minimize SQL injection risks.**"**
-
-**Field Type Convention**:
-> **"** **field_name** written in **query_definition** block must be in downcased format.**"**
-
-**Argument Key Convention**:
-> **"** **Argument Key** passed into query have to follow its parameter written in the SQL. It is case-sensitive. If the parameter in your SQL is written in downcase format, then your argument key has to be in downcase format too.**"**
-
+> A colon **:** is used as the prefix of all column names of provided **Parameterized Query** SQL string. It is used in determining query arguments key and value binding process. We have to provide it manually in the SQL string of each **Parameterized Query**. Here, **Parameterized Query** is used to minimize SQL injection risks.
 
 ```ruby
 # SQL Convention Examples
 # Example of Parameterized Query SQL usage
 
-Db2Query::Base.query("SELECT * FROM USERS WHERE $email = ?", "my_account@email.com")
+Db2Query::Base.query("SELECT * FROM USERS WHERE email = :email", "my_account@email.com")
 
 # Example of Normal SQL usage
 
 Db2Query::Base.query("SELECT * FROM USERS WHERE email = 'my_account@email.com'")
+```
 
+**Field Type Convention**:
+> Query definition's **field_name** written in **query_definition** block must be in downcased format.
+
+```ruby
 # Field Type Convention Example
 
 module Definitions
@@ -158,60 +176,85 @@ module Definitions
     end
   end
 end
+```
+
+**Argument Key Convention**:
+> The letter case of a **Named Argument** key that passed into a query, has to follow its parameter letter case format that is written in the SQL. The argument key is case-sensitive. If the parameter in your SQL is written in downcase format, then your argument key has to be in downcase format too, and vice versa.
 
+```ruby
 # Argument Key Convention Example
 
+class MyQuery < Db2Query::Base
+  ...
+  query :find_by, <<-SQL
+    SELECT * FROM USERS WHERE id = :id
+  SQL
+  ...
+end
+
 MyQuery.find_user_by_id id: 10000
 
 ```
 
-
 ### 3.1 Basic Usage
 
 #### Base Class Query Methods
 
 ##### #query(sql, args)
+
 A raw query to perform a `connection.run(sql, args)` operation and returns an array of hashes representing each row record being executed.
+
 ```ruby
-Db2Query::Base.query("SELECT * FROM USERS WHERE $id < ?", 10003)
+Db2Query::Base.query("SELECT * FROM USERS WHERE id < :id", 10003)
 => [{:id=>10000, :first_name=>"Taisha", :last_name=>"Kutch", :email=>"willie.lesch@toy.org"}, {:id=>10001, :first_name=>"Setsuko", :last_name=>"Kutch", :email=>"thelma@purdy.co"}, {:id=>10002, :first_name=>"Trina", :last_name=>"Mayer", :email=>"dorsey_upton@flatley-gulgowski.name"}]
 ```
 
 ##### #query_rows(sql)
+
 Execute the `SELECT Statement SQL` and returns collections of arrays consisting of row values.
+
 ```ruby
 Db2Query::Base.query_rows("SELECT * FROM USERS WHERE id < 10003")
 => [[10000, "Taisha", "Kutch", "willie.lesch@toy.org"], [10001, "Setsuko", "Kutch", "thelma@purdy.co"], [10002, "Trina", "Mayer", "dorsey_upton@flatley-gulgowski.name"]]
 ```
 
 ##### #query_value(sql)
+
 Execute the `SELECT Statement SQL` and returns the first value of the query results first row.
+
 ```ruby
 Db2Query::Base.query_value("SELECT * FROM USERS WHERE id < 10003")
 => 10000
 ```
 
 ##### #query_values(sql)
+
 Execute the `SELECT Statement SQL` and returns a collection of the first value of each query result rows.
+
 ```ruby
 Db2Query::Base.query_values("SELECT * FROM USERS WHERE id < 10003")
 => [10000, 10001, 10002]
 ```
 
 ##### #execute(sql, args)
+
 A method to execute `DUI Statement SQL` by using `connection.do(sql, args)`
+
 ```ruby
-Db2Query::Base.execute("DELETE FROM users WHERE $id = ?", 10000)
+Db2Query::Base.execute("DELETE FROM users WHERE id = :id", 10000)
 => -1
 ```
 
 ### 3.2 QueryDefinitions
 
+#### 3.2.1 Query Field Definitions
+
 QueryDefinitions is helpful when you need formatter methods that **serialize** the data before it being sent to the database and **deserialize** database output data before being consumed by **Rails application**. The real examples are **Binary** and **Boolean** field types.
 At **Db2Query::Type::Binary**, the data `unpacked` by `serialize` method before sending to the database and do `deserialize` operation to `pack` the database returned data.
 QueryDefinition can be used as **Query Schema** where the **field types** of a query are outlined. The field-type written in QueryDefinition has to follow the **Field Type Convention**.
 
-A QueryDefinitions reside in `app_root/app/queries/definitions` directory. It is automatically created when you create your query by using run `rails g query query_name` [**generator**](#33-generator) command. The QueryDefinitions class can be defined as follow:
+A QueryDefinitions reside in `app_root/app/queries/definitions` directory. It is automatically created when you create your query by running `rails g query query_name` [**generator**](#33-generator) command. The QueryDefinitions class can be defined as follow:
+
 ```ruby
 # app_root/app/queries/definitions/your_query_definitions.rb
 module Definitions
@@ -230,6 +273,7 @@ module Definitions
   end
 end
 ```
+
 For Example:
 
 ```ruby
@@ -257,6 +301,21 @@ end
 
 ```
 
+#### 3.2.2 Query Argument Types
+
+Sometimes, the `query arguments` do not exist in query definitions fields. In such a case, a `Db2Query::QueryArgumentError` will be raised. So, we have to provide `query argument types` at the Query class.
+
+```ruby
+module NameSpace
+  class QueryName < Db2Query::Base
+    query_arguments :user_by_email, { email: :string, trim: true }
+
+    def user_by_email_sql
+      "SELECT id, first_name, last_name FROM USERS WHERE email = :email"
+    end
+  end
+end
+```
 
 ### 3.3 Generator
 
@@ -265,9 +324,10 @@ Create query class by using `rails g query NAME` commands. For example:
 ```bash
 $ rails g query NameSpace::Name --defines=first_query --queries=next_query  --lambdas=last_query
     create app/queries/name_space/name_query.rb
-    create  app/queries/definitions/movies_query_definitions.rb
+    create app/queries/definitions/name_space/name_query_definitions.rb
     create test/queries/name_space/name_query_test.rb
 ```
+
 This will create `app/queries/name_space/name_query.rb` file in `app/queries` directory.
 
 ```ruby
@@ -339,9 +399,11 @@ end
 ```
 
 #### 3.4.1 Plain Query (--defines)
+
 Query implementation that uses the plain method. The method name must have a `_sql` suffix and return SQL statement string.
 
 Example:
+
 ```ruby
 class MyQuery < Db2Query::Base
   def all_users_sql
@@ -349,15 +411,17 @@ class MyQuery < Db2Query::Base
   end
 
   def find_user_by_id_sql
-    "SELECT * FROM USERS WHERE $id = ?"
+    "SELECT * FROM USERS WHERE id = :id"
   end
 end
 ```
 
 #### 3.4.2 String Query (--queries)
+
 Query implementation that uses the built-in `query` method. The input arguments consist of `query_name` symbol and SQL statement
 
 Example:
+
 ```ruby
 class MyQuery < Db2Query::Base
   query :all_users, <<-SQL
@@ -365,15 +429,17 @@ class MyQuery < Db2Query::Base
   SQL
 
   query :find_user_by_id, <<-SQL
-    SELECT * FROM USERS WHERE $id = ?
-  end
+    SELECT * FROM USERS WHERE id = :id
+  SQL
 end
 ```
 
 #### 3.4.3 Lambda Query (--lambdas)
+
 Query implementation that uses the built-in `query` method. The input arguments consist of the `query_name` symbol and a lambda function. We have to pass `args` as the arguments of a lambda function. Do not change the `args` with let's say `-> id, email { ... }`. Just leave it written as `args`. The `args` is used by `Db2Query::Base` to store `query_name` and the other `arg` inputs.
 
 Example:
+
 ```ruby
 class MyQuery < Db2Query::Base
   query :all_users, -> args {
@@ -381,7 +447,7 @@ class MyQuery < Db2Query::Base
   }
 
   query :find_user_by_id, -> args {
-    fetch("SELECT * FROM USERS WHERE $id = ?", args)
+    fetch("SELECT * FROM USERS WHERE id = :id", args)
   }
 end
 ```
@@ -397,6 +463,7 @@ irb(main):001:0> MyQuery.find_user_by_id 10000
   SQL (3.0ms)  SELECT * FROM USERS WHERE id = ?  [["id", 10000]]
 => #<Db2Query::Result [#<Record id: 10004, first_name: Yohanes, ...]>
 ```
+
 If you pass a key-value argument into query, the key has to follow **Argument Key Convention**
 
 ```bash
@@ -407,6 +474,7 @@ irb(main):001:0> MyQuery.find_user_by_id(id: 10000)
 ```
 
 And use it at your application
+
 ```ruby
 users = MyQuery.all
 user_records = users.records
@@ -425,24 +493,28 @@ user.last_name  # => "Lumentut"
 user.email      # => "yohanes@github.com"
 ```
 
-### 3.5 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.
+### 3.5 SQL extension (`@extension`)
+
+For the sake of reusable SQL string, we can reuse the most commonly used SQL part by implementing `sql_with_extension` methods with an SQL string argument contain `@extension` pointer at SQL statement.
+
 ```ruby
 class MyQuery < Db2Query::Base
   # reusable SQL
-  _SQL = -> extention {
-    sql_with_extention("SELECT * FROM USERS WHERE @extention", extention)
+  _SQL = -> extension {
+    sql_with_extension("SELECT * FROM USERS WHERE @extension", extension)
   }
   
   # implementation
-  query :user_by_email, _SQL.("$email = ?")
+  query :user_by_email, _SQL.("email = :email")
 end
 ```
+
 ```bash
-irb(main):001:0> MyQuery.user_by_email
+irb(main):001:0> MyQuery.user_by_email email: "yohanes@github.com"
   SQL (2.7ms)  SELECT * FROM USERS email = ?  [["email", "yohanes@github.com"]]
 => #<Db2Query::Result [#<Record id: 10000, first_name: Yohanes, ...]>
 ```
+
 ```ruby
 user = MyQuery.user_by_email "yohanes@github.com"
 user.id         # => 10000
@@ -450,7 +522,9 @@ user.first_name # => "Yohanes"
 user.last_name  # => "Lumentut"
 user.email      # => "yohanes@github.com"
 ```
+
 ### 3.6 List input (`@list`)
+
 For an array consist list of inputs, we can use `fetch_list` method and `@list` pointer at the SQL statement.
 
 ```ruby
@@ -460,12 +534,14 @@ class MyQuery < Db2Query::Base
   }
 end
 ```
+
 ```bash
 irb(main):007:0> MyQuery.user_by_ids [10000,10001,10002]
   SQL (2.8ms)  SELECT * FROM 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">]>
 
 ```
+
 ```ruby
 users = MyQuery.user_by_ids [10000,10001,10002]
 user = users.first
@@ -478,12 +554,15 @@ user.email      # => "captain.marvel@marvel.universe.com"
 ```
 
 ### 3.7 Formatter
+
 For the latest version of **Db2Query**, there is no more **Db2Query::Formatter** class. We can implement our formater into **deserialize** method of our [**QueryDefinitions**](#32-querydefinitions).
 
 If you upgrade from the previous version, you have to run **`rake db2query:init`** again to override the initializer. Please create a backup of your Formatter classes before you do this operation. Then you can implement your Formatter methods into your **QueryDefinitions**.
 
 ## 4. Available Result Object methods
+
 `Db2Query::Result` inherit all `ActiveRecord::Result` methods with additional custom methods:
+
   1. `records` to convert query result into an array of Result query's Record objects.
   2. `record` to get the first Record Object of Result query.
   3. `to_h` to convert query result into an array of hashes with symbolized keys.
@@ -503,10 +582,11 @@ end
 ```
 
 Utilize the goodness of rails model `scope`
+
 ```ruby
 class User < Db2Record
   scope :by_name, -> *args {
-    query("SELECT * FROM USERS WHERE $first_name = ? AND $last_name = ?", args)
+    query("SELECT * FROM USERS WHERE first_name = :first_name AND last_name = :last_name", args)
   }
 end
 ```
@@ -518,6 +598,7 @@ SQL Load (3.28ms)  SELECT * FROM USERS WHERE first_name = ? AND last_name = ? [[
 ```
 
 Another example:
+
 ```ruby
 class User < Db2Record
   scope :age_gt, -> *args {
@@ -535,6 +616,18 @@ SQL Load (3.28ms)  SELECT * FROM USERS WHERE age > 500
 ## 6. Examples
 
 For complete examples please see the basic examples [here](https://github.com/yohaneslumentut/db2_query/blob/master/test/dummy/app/queries/user_query.rb).
+Please see [**Db2Session**](https://github.com/yohaneslumentut/db2_session) for **REST** and **GraphQL** implementation of multi-user on the remote server.
+
+## 7. Test
+
+To run a development test:
+
+```bash
+$ bin/test test
+    Db2 Version     : DB2 v11.5.8.0
+    ...
+```
+
+## 8. License
 
-## 7. License
 The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

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

data/lib/db2_query/base.rb

@@ -4,7 +4,6 @@ module Db2Query
   class Base
     include Config
     include Helper
-    include Quoting
     include DbConnection
     include FieldType
     include Core

data/lib/db2_query/core.rb

@@ -25,27 +25,44 @@ module Db2Query
       end
 
       def query(*query_args)
-        if query_args[1].respond_to?(:call)
+        if query_args.first.is_a?(Symbol)
           query_name, body = query_args
-          singleton_class.define_method(query_name) do |*args|
-            body.call(args << { query_name: query_name })
+
+          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
-        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)
+            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::QueryMethodError.new
+          raise Db2Query::Error, "Wrong query implementation"
         end
       end
       alias define query
 
+      def query_arguments_map
+        @query_arguments_map ||= {}
+      end
+
+      def query_arguments(query_name, argument_types)
+        query_arguments_map[query_name] = argument_types
+      end
+
       def fetch(sql, args = [])
         query = definitions.lookup_query(args, sql)
         query.validate_select_query
@@ -60,7 +77,10 @@ module Db2Query
       private
         def new_definitions
           definition_class = "Definitions::#{name}Definitions"
-          Object.const_get(definition_class).new(field_types_map)
+          Object.const_get(definition_class).new(
+            query_arguments_map,
+            field_types_map
+          )
         rescue Exception => e
           raise Db2Query::Error, e.message
         end
@@ -71,13 +91,6 @@ module Db2Query
           end
         end
 
-        def raw_query(sql, args)
-          Query.new.tap do |query|
-            query.define_sql(sql)
-            query.define_args(args)
-          end
-        end
-
         def define_sql_query(method_name)
           sql_query_name = sql_query_symbol(method_name)
           sql_statement = allocate.method(sql_query_name).call

data/lib/db2_query/db_connection.rb

@@ -35,11 +35,10 @@ module Db2Query
       end
     end
 
-    attr_reader :config, :connection_pool, :instrumenter, :lock
+    attr_reader :config, :connection_pool, :instrumenter, :mutex
 
     delegate :with, :current_state, :disconnect!, :reload, to: :connection_pool
     delegate :instrument, to: :instrumenter
-    delegate :synchronize, to: :lock
 
     include Logger
     include DbStatements
@@ -47,7 +46,8 @@ module Db2Query
     def initialize(config)
       @config = config
       @instrumenter = ActiveSupport::Notifications.instrumenter
-      @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+      @mutex = Mutex.new
+      @connection_pool = nil
       create_connection_pool
     end
 
@@ -58,7 +58,7 @@ module Db2Query
     end
 
     def create_connection_pool
-      synchronize do
+      mutex.synchronize do
         return @connection_pool if @connection_pool
         @connection_pool = Pool.new(pool_config) { DbClient.new(config) }
       end

data/lib/db2_query/definitions.rb

@@ -3,9 +3,11 @@
 module Db2Query
   class Definitions
     attr_accessor :types, :types_map
+    attr_reader :arguments_map
 
-    def initialize(types_map)
-      @types_map = types_map
+    def initialize(query_arguments_map, field_types_map)
+      @arguments_map = query_arguments_map
+      @types_map = field_types_map
       describe
       initialize_types
     end
@@ -26,14 +28,24 @@ module Db2Query
 
     def lookup(query_name)
       queries.fetch(query_name)
-    rescue
-      raise Db2Query::QueryDefinitionError.new(name, query_name)
+    rescue Exception => e
+      if defined?(name)
+        raise Db2Query::QueryDefinitionError.new(name, query_name)
+      else
+        raise Db2Query::Error, e.message
+      end
     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))
+        rescue
+          raise Db2Query::QueryArgumentError.new(query_name, key)
+        end
       end
     end
 
@@ -75,5 +87,13 @@ module Db2Query
         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