db2_query 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a863b9451d52ea28e71b1477cfd7275bb76b34c91a1302208f4052674dc7b901
-  data.tar.gz: 555eafaa282e3cab7a0d4231592a6d2a6d3087d0c194f98040dff1724f5da0f2
+  metadata.gz: 3dd6ee9200ac62f38f2a81e202c0df39eb374778398b31ee41021749957d20bf
+  data.tar.gz: 71a6155efe5dded92661e02435c60f7f9b5f47c85353fd662836988ec3a217db
 SHA512:
-  metadata.gz: 917d8a2a7a1eefbb85185d021642f42115e7fd51969b302752f1284e274799fca9d7b24c3f6a7fdc764fa9a79cfd6cac7245e4500b0005d5e498f1e718e63a5b
-  data.tar.gz: 353f50ef752eaaee361c939c21f6552e4fa5c8b5bc81a0face640aae420d889fcb1fb148bd0d7b74e8fec3b1867ffa31df9996cacb05465302e512ec0a5d2147
+  metadata.gz: c70095fb9df32696b8b30bd9a589767af759f2ea341724e3e9891d4850c5379c22de27082186d14b131da1c5dc96a48d7d4552a4c0382c66427bcaec64080f28
+  data.tar.gz: c5237f837262f80453f6dbf426769e50ae72cb9907306d70f6fc915ae4e281a15d0f0de94d3a116beadf98ce2a1ce98bc892801b28bd05dd2497acbc16cdadad

data/README.md

@@ -36,17 +36,17 @@ Complete the configurations by editing the files according to your application r
 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
@@ -70,7 +70,9 @@ 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 = {
@@ -100,7 +102,7 @@ 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,17 +124,10 @@ 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.**"**
-
+> 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 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
@@ -143,7 +138,12 @@ Db2Query::Base.query("SELECT * FROM USERS WHERE $email = ?", "my_account@email.c
 # 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,9 +158,22 @@ 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 = ?
+  SQL
+  ...
+end
+
 MyQuery.find_user_by_id id: 10000
 
 ```
@@ -207,11 +220,13 @@ Db2Query::Base.execute("DELETE FROM users WHERE $id = ?", 10000)
 
 ### 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
@@ -256,7 +271,21 @@ module Definitions
 end
 
 ```
+#### 3.2.2 Query Argument Types
 
+Sometimes, the `query arguments` do not exist in query definitions fields. In such a case, we have to provide `query argument types` at the Query class.
+
+```ruby
+module NameSpace
+  class QueryName < Db2Query::Base
+    arguments :user_by_email, { email: :string, trim: true }
+
+    def user_by_email_sql
+      "SELECT id, first_name, last_name FROM USERS WHERE $email = ?"
+    end
+  end
+end
+```
 
 ### 3.3 Generator
 
@@ -265,7 +294,7 @@ 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.
@@ -366,7 +395,7 @@ class MyQuery < Db2Query::Base
 
   query :find_user_by_id, <<-SQL
     SELECT * FROM USERS WHERE $id = ?
-  end
+  SQL
 end
 ```
 
@@ -425,13 +454,14 @@ 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
@@ -439,7 +469,7 @@ class MyQuery < Db2Query::Base
 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, ...]>
 ```
@@ -535,6 +565,7 @@ 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. License
 The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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

@@ -48,6 +48,7 @@ module Db2Query
       @config = config
       @instrumenter = ActiveSupport::Notifications.instrumenter
       @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+      @connection_pool = nil
       create_connection_pool
     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
@@ -34,6 +36,10 @@ module Db2Query
       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
 
@@ -75,5 +81,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

data/lib/db2_query/error.rb

@@ -39,7 +39,7 @@ module Db2Query
     end
   end
 
-  class ExtentionError < StandardError
+  class ExtensionError < StandardError
   end
 
   class ImplementationError < StandardError

data/lib/db2_query/helper.rb

@@ -16,12 +16,13 @@ module Db2Query
         sql.gsub("@list", "'#{list.join("', '")}'")
       end
 
-      def sql_with_extention(sql, extention)
-        if sql.scan(/\@extention+/).length == 0
-          raise Db2Query::ExtentionError, "Missing @extention pointer at SQL"
+      def sql_with_extension(sql, extension)
+        if sql.scan(/\@extension+/).length == 0
+          raise Db2Query::ExtensionError, "Missing @extension pointer at SQL"
         end
-        sql.gsub("@extention", extention.strip)
+        sql.gsub("@extension", extension.strip)
       end
+      alias sql_with_extention sql_with_extension
 
       private
         def sql_query_methods
@@ -42,7 +43,7 @@ module Db2Query
         end
 
         def fetch_error_message
-          "`fetch`, `fetch_list` and `fetch_extention` methods applied for SQL `select` statement only."
+          "`fetch`, `fetch_list` and `fetch_extension` methods applied for SQL `select` statement only."
         end
     end
   end

data/lib/db2_query/query.rb

@@ -2,7 +2,7 @@
 
 module Db2Query
   class Query
-    attr_reader :columns, :keys, :query_name, :sql, :types
+    attr_reader :query_name, :sql, :columns, :keys, :types, :argument_types
 
     include SqlStatement
 
@@ -10,11 +10,12 @@ module Db2Query
       @columns = {}
       @query_name = query_name
       @sql_statement = nil
+      @argument_types = {}
       @types = {}
     end
 
     def define_sql(sql)
-      @keys ||= new_keys(sql)
+      @keys ||= sql_arguments(sql)
       @sql ||= sql.tr("$", "")
     end
 
@@ -33,6 +34,19 @@ module Db2Query
       raise Db2Query::Error, "No column #{column} found at query: #{query_name} definitions"
     end
 
+    def argument_type(key)
+      argument_types.fetch(key) || data_type(key)
+    rescue
+      raise Db2Query::Error, "No argument #{key} type found at query: #{query_name}"
+    end
+
+    def argument_keys
+      keys.map do |key|
+        arg_key = "#{key}".split(".").last
+        arg_key.to_sym unless arg_key.nil?  
+      end
+    end
+
     def length
       columns.length
     end
@@ -52,7 +66,7 @@ module Db2Query
     end
 
     def sorted_args(args)
-      keys.map.with_index do |key, index|
+      argument_keys.map.with_index do |key, index|
         serialized_arg(args.is_a?(Hash) ? args[key] : args[index], key)
       end
     end
@@ -82,12 +96,12 @@ module Db2Query
     end
 
     private
-      def new_keys(raw_sql)
-        raw_sql.scan(/\$\S+/).map { |key| key.gsub!(/[$=,)]/, "").to_sym }
+      def sql_arguments(raw_sql)
+        raw_sql.scan(/\$\S+/).map { |arg| arg.gsub!(/[$=,)]/, "").to_sym }
       end
 
       def serialized_arg(arg, key)
-        query_name.nil? ? arg : data_type(key).serialize(arg)
+        query_name.nil? ? arg : argument_type(key).serialize(arg)
       end
 
       def column_from_key(key)
@@ -104,14 +118,11 @@ module Db2Query
         end
       end
 
-      def validate_arguments(given, expected)
-        raise Db2Query::ArgumentError.new(given, expected) unless given == expected
-      end
-
       def validated_args(args)
-        args = args.first.is_a?(Hash) ? args.first : args
-        validate_arguments(args.length, keys.length)
-        sorted_args(args)
+        arguments = args.first.is_a?(Hash) ? args.first : args
+        given, expected = [arguments.length, keys.length]
+        raise Db2Query::ArgumentError.new(given, expected) unless given == expected
+        sorted_args(arguments)
       end
   end
 end

data/lib/db2_query/railtie.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "db2_query"
-require "rails"
-
 module Db2Query
   class Railtie < ::Rails::Railtie
     railtie_name :db2_query

data/lib/db2_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Db2Query
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

data/lib/db2_query.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "active_record"
 require "active_support"
 require "active_support/concurrency/load_interlock_aware_monitor"
+require "active_record"
 require "active_model/type"
 require "connection_pool"
 require "odbc_utf8"
@@ -44,6 +44,6 @@ module Db2Query
   def self.root
     __dir__
   end
-
-  require "db2_query/railtie" if defined?(Rails)
 end
+
+require "db2_query/railtie" if defined?(Rails)

data/lib/rails/generators/query/templates/query_definitions.rb.tt

@@ -2,11 +2,17 @@
 
 <% module_definitions_namespacing do -%>
 class <%= query_class_name %>Definitions < <%= "Db2Query::Definitions" %>
+<% if @query_methods.empty? %>
+<%= indent("def describe\n") -%>
+<%= indent("") %>
+<%= indent("end") %>
+<% else %>
 <%= indent("def describe") -%>
 <% @query_methods.each do |method| %>
   <%= indent("query_definition :#{method} do |c|\n") %>
   <%= indent("end") %>
 <% end -%>
 <%= indent("end") %>
+<% end %>
 <%= 'end' -%>
 <% end %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db2_query
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - yohanes_l
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-01 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tty-progressbar
@@ -160,7 +160,6 @@ files:
 - lib/db2_query/helper.rb
 - lib/db2_query/logger.rb
 - lib/db2_query/query.rb
-- lib/db2_query/quoting.rb
 - lib/db2_query/railtie.rb
 - lib/db2_query/result.rb
 - lib/db2_query/sql_statement.rb
@@ -208,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Rails Db2 ODBC plugin

data/lib/db2_query/quoting.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Db2Query
-  module Quoting
-    def self.included(base)
-      base.send(:extend, ClassMethods)
-    end
-
-    module ClassMethods
-      def quoted_true
-        "TRUE"
-      end
-
-      def unquoted_true
-        1
-      end
-
-      def quoted_false
-        "FALSE"
-      end
-
-      def unquoted_false
-        0
-      end
-
-      def quoted_binary(value)
-        "x'#{value.hex}'"
-      end
-
-      def quoted_time(value)
-        value = value.change(year: 2000, month: 1, day: 1)
-        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
-      end
-
-      def quoted_date(value)
-        if value.acts_like?(:time)
-          if ActiveRecord::Base.default_timezone == :utc
-            value = value.getutc if !value.utc?
-          else
-            value = value.getlocal
-          end
-        end
-
-        result = value.to_s(:db)
-        if value.respond_to?(:usec) && value.usec > 0
-          result << "." << sprintf("%06d", value.usec)
-        else
-          result
-        end
-      end
-
-      private
-        def _quote(value)
-          case value
-          when String, Symbol, ActiveSupport::Multibyte::Chars
-            "'#{quote_string(value.to_s)}'"
-          when true
-            quoted_true
-          when false
-            quoted_false
-          when nil
-            "NULL"
-          when BigDecimal
-            value.to_s("F")
-          when Numeric, ActiveSupport::Duration
-            value.to_s
-          when Db2Query::Type::Binary::Data
-            quoted_binary(value)
-          when ActiveRecord::Type::Time::Value
-            "'#{quoted_time(value)}'"
-          when Date, Time
-            "'#{quoted_date(value)}'"
-          when Class
-            "'#{value}'"
-          else raise TypeError, "can't quote #{value.class.name}"
-          end
-        end
-
-        def _type_cast(value)
-          case value
-          when Symbol, ActiveSupport::Multibyte::Chars
-            value.to_s
-          when Db2Query::Type::Binary::Data
-            value.hex
-          when true
-            unquoted_true
-          when false
-            unquoted_false
-          when BigDecimal
-            value.to_s("F")
-          when nil, Numeric, String
-            value
-          when ActiveRecord::Type::Time::Value
-            quoted_time(value)
-          when Date, Time
-            quoted_date(value)
-          else raise TypeError, "can't cast #{value.class.name}"
-          end
-        end
-    end
-  end
-end