db2_query 0.3.3 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dd6ee9200ac62f38f2a81e202c0df39eb374778398b31ee41021749957d20bf
-  data.tar.gz: 71a6155efe5dded92661e02435c60f7f9b5f47c85353fd662836988ec3a217db
+  metadata.gz: 3e06666a1eee58811d081a1d8da67e2d3e814d91ef15a0c12bb5b306ee130aed
+  data.tar.gz: fa7ebb35a4e9019f9619416ed4c97fa410e663d3eb58b9320314002e759c501e
 SHA512:
-  metadata.gz: c70095fb9df32696b8b30bd9a589767af759f2ea341724e3e9891d4850c5379c22de27082186d14b131da1c5dc96a48d7d4552a4c0382c66427bcaec64080f28
-  data.tar.gz: c5237f837262f80453f6dbf426769e50ae72cb9907306d70f6fc915ae4e281a15d0f0de94d3a116beadf98ce2a1ce98bc892801b28bd05dd2497acbc16cdadad
+  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,7 +42,9 @@ $ 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: LIBDEV
@@ -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,8 @@ end
 ```
 
 ### Custom Field Type
-**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. 
+
+**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) :
 
@@ -88,7 +102,9 @@ By default, there are ten field types that can be used in your [query definition
     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
@@ -102,7 +118,9 @@ You can use your own Field type class by extending **Db2Query::Type::Value** cla
     end
  end
 ```
+
 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
 
@@ -127,13 +145,13 @@ end
 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 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.
+> 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
 
@@ -169,7 +187,7 @@ end
 class MyQuery < Db2Query::Base
   ...
   query :find_by, <<-SQL
-    SELECT * FROM USERS WHERE $id = ?
+    SELECT * FROM USERS WHERE id = :id
   SQL
   ...
 end
@@ -178,43 +196,52 @@ 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
 ```
 
@@ -227,6 +254,7 @@ At **Db2Query::Type::Binary**, the data `unpacked` by `serialize` method before
 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 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
@@ -245,6 +273,7 @@ module Definitions
   end
 end
 ```
+
 For Example:
 
 ```ruby
@@ -271,17 +300,18 @@ 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.
+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
-    arguments :user_by_email, { email: :string, trim: true }
+    query_arguments :user_by_email, { email: :string, trim: true }
 
     def user_by_email_sql
-      "SELECT id, first_name, last_name FROM USERS WHERE $email = ?"
+      "SELECT id, first_name, last_name FROM USERS WHERE email = :email"
     end
   end
 end
@@ -297,6 +327,7 @@ $ rails g query NameSpace::Name --defines=first_query --queries=next_query  --la
     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
@@ -368,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
@@ -378,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
@@ -394,15 +429,17 @@ class MyQuery < Db2Query::Base
   SQL
 
   query :find_user_by_id, <<-SQL
-    SELECT * FROM USERS WHERE $id = ?
+    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 {
@@ -410,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
 ```
@@ -426,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
@@ -436,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
@@ -455,6 +494,7 @@ user.email      # => "yohanes@github.com"
 ```
 
 ### 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
@@ -465,14 +505,16 @@ class MyQuery < Db2Query::Base
   }
   
   # implementation
-  query :user_by_email, _SQL.("$email = ?")
+  query :user_by_email, _SQL.("email = :email")
 end
 ```
+
 ```bash
 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
@@ -480,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
@@ -490,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
@@ -508,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.
@@ -533,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
 ```
@@ -548,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 {
@@ -567,5 +618,16 @@ SQL Load (3.28ms)  SELECT * FROM USERS WHERE age > 500
 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
+## 7. Test
+
+To run a development test:
+
+```bash
+$ bin/test test
+    Db2 Version     : DB2 v11.5.8.0
+    ...
+```
+
+## 8. 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/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,7 @@ 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
@@ -59,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

@@ -28,8 +28,12 @@ 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)
@@ -39,6 +43,8 @@ module Db2Query
         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

data/lib/db2_query/error.rb

@@ -78,4 +78,16 @@ module Db2Query
       "The query body needs to be callable or is a SQL statement string"
     end
   end
+
+  class QueryArgumentError < StandardError
+    def initialize(query_name, arg_key)
+      @query_name = query_name
+      @arg_key = arg_key
+      super(message)
+    end
+
+    def message
+      "Data type of `#{@arg_key}` not found at `:#{@query_name}` query definitions"
+    end
+  end
 end

data/lib/db2_query/logger.rb

@@ -22,7 +22,7 @@ module Db2Query
         statement_name:    nil,
         connection_id:     object_id,
         connection:        self) do
-        synchronize do
+        mutex.synchronize do
           yield
         end
       rescue => e

data/lib/db2_query/query.rb

@@ -14,9 +14,12 @@ module Db2Query
       @types = {}
     end
 
-    def define_sql(sql)
-      @keys ||= sql_arguments(sql)
-      @sql ||= sql.tr("$", "")
+    def define_sql(raw_sql)
+      @keys = []
+      @sql = raw_sql.gsub(/:\w+/) do |match|
+        @keys << match[1..]
+        '?'
+      end
     end
 
     def map_column(name, args)
@@ -96,9 +99,9 @@ module Db2Query
     end
 
     private
-      def sql_arguments(raw_sql)
-        raw_sql.scan(/\$\S+/).map { |arg| arg.gsub!(/[$=,)]/, "").to_sym }
-      end
+      # 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 : argument_type(key).serialize(arg)

data/lib/db2_query/railtie.rb

@@ -1,15 +1,4 @@
-# frozen_string_literal: true
-
 module Db2Query
   class Railtie < ::Rails::Railtie
-    railtie_name :db2_query
-
-    rake_tasks do
-      Dir.glob("#{Db2Query.root}/db2_query/tasks/*.rake").each { |f| load f }
-    end
-
-    config.app_generators do
-      require "#{Db2Query.root}/rails/generators/query/query_generator.rb"
-    end
   end
 end

data/lib/db2_query/version.rb

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

data/lib/db2_query.rb

@@ -1,14 +1,11 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/concurrency/load_interlock_aware_monitor"
-require "active_record"
-require "active_model/type"
+require "db2_query/version"
+require "db2_query/railtie"
 require "connection_pool"
 require "odbc_utf8"
 require "db2_query/error"
 
 module Db2Query
+  # Your code goes here...
   autoload :Version, "db2_query/version"
   autoload :Error, "db2_query/error"
   autoload :Config, "db2_query/config"
@@ -45,5 +42,3 @@ module Db2Query
     __dir__
   end
 end
-
-require "db2_query/railtie" if defined?(Rails)

data/lib/tasks/db2_query_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :db2_query do
+#   # Task goes here
+# end

metadata

@@ -1,125 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: db2_query
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.6
 platform: ruby
 authors:
-- yohanes_l
+- Yohanes Lumentut
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-07 00:00:00.000000000 Z
+date: 2024-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: tty-progressbar
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+        version: '7.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 7.1.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+        version: '7.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 7.1.2
 - !ruby/object:Gem::Dependency
-  name: rubocop-rails
+  name: tty-progressbar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.18'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.5
 - !ruby/object:Gem::Dependency
@@ -136,8 +86,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A Rails 5 & Rails 6 plugin for handling Db2 SQL SIUD statement (SELECT,
-  INSERT, UPDATE, DELETE) by using ODBC connection.
+description: A Rails 7 (Ruby v3.1.0) plugin for connecting Db2 with Rails appplication
+  by using ODBC connection.
 email:
 - yohanes.lumentut@gmail.com
 executables: []
@@ -164,11 +114,6 @@ files:
 - lib/db2_query/result.rb
 - lib/db2_query/sql_statement.rb
 - lib/db2_query/tasks.rb
-- lib/db2_query/tasks/database.rake
-- lib/db2_query/tasks/init.rake
-- lib/db2_query/tasks/initializer.rake
-- lib/db2_query/tasks/templates/database.rb.tt
-- lib/db2_query/tasks/templates/initializer.rb.tt
 - lib/db2_query/type/binary.rb
 - lib/db2_query/type/boolean.rb
 - lib/db2_query/type/date.rb
@@ -180,11 +125,7 @@ files:
 - lib/db2_query/type/timestamp.rb
 - lib/db2_query/type/value.rb
 - lib/db2_query/version.rb
-- lib/rails/generators/query/USAGE
-- lib/rails/generators/query/query_generator.rb
-- lib/rails/generators/query/templates/query.rb.tt
-- lib/rails/generators/query/templates/query_definitions.rb.tt
-- lib/rails/generators/query/templates/unit_test.rb.tt
+- lib/tasks/db2_query_tasks.rake
 homepage: https://github.com/yohaneslumentut/db2_query
 licenses:
 - MIT
@@ -207,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Rails Db2 ODBC plugin

data/lib/db2_query/tasks/database.rake

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "db2_query/tasks"
-
-namespace :db2query do
-  desc "Create Database configuration file"
-  task :database do
-    Db2Query::DatabaseTask.generate_file
-  end
-end

data/lib/db2_query/tasks/init.rake

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-namespace :db2query do
-  desc "Create Initializer and Database configuration file"
-  task :init do
-    Rake::Task["db2query:database"].invoke
-    Rake::Task["db2query:initializer"].invoke
-  end
-end

data/lib/db2_query/tasks/initializer.rake

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "db2_query/tasks"
-
-namespace :db2query do
-  desc "Create Initializer file"
-  task :initializer do
-    Db2Query::InitializerTask.generate_file
-  end
-end

data/lib/db2_query/tasks/templates/database.rb.tt

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-development:
-  dsn: TODO
-  idle: 5
-  pool: 5
-  timeout: 5
-
-test:
-  dsn: TODO
-  idle: 5
-  pool: 5
-  timeout: 5
-
-production:
-  dsn: TODO
-  idle: 5
-  pool: 5
-  timeout: 5

data/lib/db2_query/tasks/templates/initializer.rb.tt

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "db2_query"
-
-Db2Query::Base.initiation do |base|
-  base.set_field_types
-  base.establish_connection
-end

data/lib/rails/generators/query/USAGE

@@ -1,15 +0,0 @@
-Description:
-  Stubs out a new query. Pass the query name, either
-    CamelCased or under_scored, and an optional list of its methods as arguments.
-
-    To create a query within a module, just use namespace pattern as the other rails generators do.
-
-    To create query class methods, you can use 3 options:
-      1. Plain SQL methods --defines
-      2. Query Methods with SQL string, --queries
-      3. Query Methods with lambda, --lambdas
-
-Example:
-  $ rails g query NameSpace::Name --queries query_1 --defines query_2 --lambdas query_3
-      create app/queries/name_space/name_query.rb
-      create test/queries/name_space/name_query_test.rb

data/lib/rails/generators/query/query_generator.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "fileutils"
-
-module Rails
-  module Generators
-    class QueryGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path("../templates", __FILE__)
-
-      class_option :skip_unit_test, type: :boolean, default: false, desc: "Skip unit test file creation"
-      class_option :defines, type: :array, default: [], desc: "Plain query method options"
-      class_option :queries, type: :array, default: [], desc: "Query method SQL options"
-      class_option :lambdas, type: :array, default: [], desc: "Query method with callable args"
-
-      def create_query_file
-        template "query.rb", File.join("app/queries", class_path, "#{file_name}_query.rb")
-      end
-
-      def create_query_definitions_file
-        template "query_definitions.rb", File.join("app/queries/definitions", class_path, "#{file_name}_query_definitions.rb")
-      end
-
-      def create_query_test_file
-        unless options[:skip_unit_test]
-          template "unit_test.rb", File.join("test/queries", class_path, "#{file_name}_query_test.rb")
-        end
-      end
-
-      private
-        def assign_names!(name)
-          super(name)
-          @method_options = options.slice("defines", "queries", "lambdas")
-          @query_methods = @method_options.map { |key, val| val }.flatten
-        end
-
-        def query_class_name
-          "#{file_name.camelize}Query"
-        end
-
-        def namespaced_query?
-          !class_path.empty?
-        end
-
-        def namespaced_names
-          class_path
-        end
-
-        def namespaced_content(content)
-          namespaced_names.reverse_each do |namespace_name|
-            content = "module #{namespace_name.camelize}\n#{indent(content)}\nend"
-          end
-          content
-        end
-
-        def module_namespacing(&block)
-          content = capture(&block)
-          content = namespaced_content(content) if namespaced_query?
-          concat(content)
-        end
-
-        def module_definitions_namespacing(&block)
-          content = capture(&block)
-          content = namespaced_content(content) if namespaced_query?
-          definitions_namespace_content = "module Definitions\n#{indent(content)}\nend"
-          concat(definitions_namespace_content)
-        end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-<% module_namespacing do -%>
-class <%= query_class_name %> < <%= "Db2Query::Base" -%>
-<% if @query_methods.empty? %>
-<%= indent("query :to_do, <<-SQL\n") %>
-<%= indent("SQL\n") %>
-<%= indent("def to_do_sql\n") %>
-<%= indent("end") %>
-<% end -%>
-<% @method_options.each do |key, val| -%>
-<% val.each_with_index do |option, index| -%>
-<% case key when 'defines' -%> 
-<%= indent("def #{option}_sql\n") %>
-<%= indent("end") %>
-<% when 'queries' %>
-<%= indent("query :#{option}, <<-SQL\n") %>
-<%= indent("SQL") %>
-<% when 'lambdas' %>
-<%= indent("query :#{option}, -> args {\n") %>
-<%= indent("}") %>
-<% end -%>
-<% end -%>
-<% end -%>
-<%= 'end' -%>
-<% end %>

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-<% 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 %>

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

@@ -1,9 +0,0 @@
-require "test_helper"
-
-<% module_namespacing do -%>
-class <%= query_class_name %>Test < ActiveSupport::TestCase
-  # test "the truth" do
-  #   assert true
-  # end
-<%= 'end' -%>
-<% end %>