querier 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9288e68d9c81a85ddd04dbac7bda54ed629dc5bcbf3862828234b416646b31e1
-  data.tar.gz: 9776a4f2a9d025f4b30c1c41c91e04213d767f696879b1507d27b34210e87617
+  metadata.gz: 7a9d661e9272bd71551c319bb3bbb2937a0b385c9ded9cc01cff1f78a6fe1dd5
+  data.tar.gz: f9df13887085ef293df3f8630386e817542278615b867e84396653dbf986962b
 SHA512:
-  metadata.gz: 105265c744ee14f48a2f410839f4c6d075ec1a38a739c83275a86caf34ff24a17cb1270f1e0f01c6cf601cab741a75abfdb64976179ac2e8fb379f5b85703a28
-  data.tar.gz: 9d33bef69465070fc629b524004664fca7e256cc7dcc1a6c975a2349aaf8e9d192748fd596015e08714957feda9f8dbc61225186f8d3b35cab513d405d7f7689
+  metadata.gz: 22de9fbcea5a9a08186a6f3743aeff6dc4da8e97ed4bcf392e7f7c54bb1cbb82782b05c6f1b67d21fcbff2dd2d7fc74ae18e6c99641eabce34bdbbaf283d6035
+  data.tar.gz: a2619f2ee3d5ab6a651208b93778c72298079575cd51bfebe60ced41fe708158498806ac8c16409bae4415e71773f65bde956bcd135e5ba1139e158a45f8b46b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gedean Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/README.md

@@ -1,85 +1,153 @@
-# Querier Class for ActiveRecord Custom SQL Queries
+# Querier: Execução Parametrizada de SQL com ActiveRecord
 
-This README explains the functionality and use of the `Querier` class, designed to facilitate the construction and execution of custom SQL queries in a Ruby on Rails environment using ActiveRecord.
+Gem Ruby para executar consultas SQL customizadas de forma segura e elegante usando ActiveRecord, com suporte para templates parametrizados, DSL fluente e formatos práticos de resultado.
 
-## Module: `QuerierDatasetExtensions`
+## Instalação
 
-The `QuerierDatasetExtensions` module extends the results returned by SQL queries with utility methods for easy data transformation:
-
-- `as_hash`: Converts each record into a hash with symbolized keys, making it easier to work with the data.
-- `as_struct`: Converts each record into an `OpenStruct` instance, allowing attribute access using dot notation.
+```ruby
+gem 'querier'
+```
 
-## Class: `Querier`
+## Recursos Principais
 
-The `Querier` class is designed to simplify the execution of custom SQL queries on a specific ActiveRecord model. Below are the detailed explanations of its components:
+- ✅ Substituição segura de parâmetros contra SQL injection
+- ✅ DSL fluente para construção de queries
+- ✅ Validação automática de parâmetros obrigatórios
+- ✅ Métodos de conveniência para diferentes formatos de resultado
+- ✅ Tratamento de erros aprimorado
+- ✅ Suporte para EXPLAIN e COUNT
+- ✅ Extensões úteis para resultados (as_hash, as_struct, pluck)
 
-### 1. Class Variable and Singleton Attribute
+## Uso Básico
 
-The class uses a singleton attribute (`@active_record_class`) to maintain a reference to the ActiveRecord class that will be used to execute queries.
+### Criando uma Query Simples
 
-Instead of using class variables (`@@`), which are generally discouraged due to inheritance and concurrency issues, the implementation uses the recommended approach of using singleton class attributes with `attr_accessor` defined within the `class << self` context.
+```ruby
+class UserQuerier < Querier
+  def initialize(name:, active:)
+    @query_template = 'SELECT * FROM users WHERE name = ${name} AND active = ${active}'
+    super
+  end
+end
 
-### 2. Attributes and Initialization
+query = UserQuerier.new(name: 'João', active: true)
+users = query.select_all.as_hash
+```
 
-- **`@query_params`**: Stores the parameters that will be used to fill in the query template.
-- **`@active_record_class`**: Initialized with the ActiveRecord class defined by the class or superclass. This allows the `Querier` class to be reused for different ActiveRecord models.
+### Usando DSL Fluente
 
-### 3. Public Execution Methods
+```ruby
+class ProductQuerier < Querier
+  query_template 'SELECT * FROM products WHERE price BETWEEN ${min} AND ${max}'
+  param :min, :max
+end
 
-The `Querier` class provides several methods to execute SQL queries, wrapping the ActiveRecord connection methods:
+products = ProductQuerier.new
+  .min(10.0)
+  .max(100.0)
+  .select_all
+  .as_struct
+```
 
-- `execute`: Executes the query without returning structured records.
-- `exec_query`: Executes the query and returns results as an `ActiveRecord::Result`, extended with the `QuerierDatasetExtensions` module.
-- `select_all`, `select_one`, `select_rows`, `select_values`, `select_value`: These methods provide different formats for returning the query results, such as all records, a single record, rows, values, or a specific value.
+## Métodos de Execução
 
-### 4. Filling Query Parameters (`fill_query_params`)
+- `execute` - Executa a query (sem retorno estruturado)
+- `exec_query` - Retorna `ActiveRecord::Result` com métodos extras
+- `select_all` - Retorna array de hashes
+- `select_one` - Retorna um único hash
+- `select_rows` - Retorna array de arrays
+- `select_values` - Retorna array de valores de uma coluna
+- `select_value` - Retorna um único valor
+- `to_sql` - Retorna a query SQL gerada
+- `explain` - Retorna o plano de execução
+- `count` - Retorna contagem de registros
 
-The private `fill_query_params` method is responsible for parameter interpolation within the `@query_template`.
+## Extensões de Dataset
 
-- There are two types of placeholders for parameters in the query:
-  - `${param_name}`: This placeholder is replaced by the parameter value, escaped using the ActiveRecord connection's `quote` method to prevent SQL injection.
-  - `${param_name/no_quote}`: This placeholder substitutes the value directly without escaping, which is useful when the value is not susceptible to SQL injection (e.g., column names).
+```ruby
+result = query.select_all
 
-### Security Considerations
+# Converte para hash com chaves simbólicas
+result.as_hash
 
-- The use of `${param_name/no_quote}` should be done cautiously, as it may introduce vulnerabilities if used with unvalidated inputs. It is recommended to restrict its use to validated column names only.
+# Converte para OpenStruct
+result.as_struct
 
-### Error Handling
+# Extrai valores de colunas específicas
+result.pluck(:name)           # ['João', 'Maria']
+result.pluck(:name, :email)   # [['João', 'j@email.com'], ['Maria', 'm@email.com']]
 
-Currently, there is no error handling. Adding a `begin-rescue` block in the execution methods could improve robustness, handling issues such as connection failures or SQL syntax errors gracefully.
+# Primeiro valor do primeiro registro
+result.first_value  # 'João'
+```
 
-### Query Template Separation
+## Parâmetros Seguros vs Não-Quotados
 
-The `@query_template` is not explicitly defined in the provided code. It is recommended to use subclasses or clearly pass a query template, following good design practices to reuse query templates effectively.
+```ruby
+# ${param} - Sempre quotado (seguro para valores do usuário)
+@query_template = 'SELECT * FROM users WHERE email = ${email}'
 
-### Interface Improvement
+# ${param/no_quote} - Não quotado (apenas para valores validados)
+@query_template = 'SELECT * FROM ${table/no_quote} WHERE id IN (${ids/no_quote})'
+```
 
-Adding methods that accept queries directly as arguments could make the class more flexible and easier to use in scenarios where a dynamic query is needed.
+## Exemplo Avançado
 
-## Example Usage
+```ruby
+class ReportQuerier < Querier
+  query_template <<~SQL
+    SELECT 
+      DATE(created_at) as date,
+      COUNT(*) as total,
+      SUM(amount) as revenue
+    FROM orders
+    WHERE created_at BETWEEN ${start_date} AND ${end_date}
+      AND status = ${status}
+    GROUP BY DATE(created_at)
+    ORDER BY date DESC
+  SQL
+  
+  param :start_date, :end_date, :status
+  
+  def last_30_days
+    start_date(30.days.ago.to_date.to_s)
+    end_date(Date.today.to_s)
+    self
+  end
+end
 
-Below is an example of how to use the `Querier` class:
+# Uso
+report = ReportQuerier.new
+  .last_30_days
+  .status('completed')
 
-```ruby
-class MyCustomQuery < Querier
-  QUERY_TEMPLATE = <<-END_TEMPLATE
-  SELECT * FROM users WHERE id = ${user_id}
-  END_TEMPLATE
+# Visualizar SQL
+puts report.to_sql
 
-  def initialize(user_id)
-    @query_template = QUERY_TEMPLATE
-    super
-  end
+# Executar e formatar
+results = report.select_all.as_struct
+results.each do |day|
+  puts "#{day.date}: #{day.total} pedidos, R$ #{day.revenue}"
 end
+```
+
+## Tratamento de Erros
 
-query = MyCustomQuery.new(1)
-result = query.select_one
-puts result # => Returns the user record with id 1
+```ruby
+begin
+  query.select_all
+rescue Querier::QueryError => e
+  puts "Erro na query: #{e.message}"
+end
 ```
 
-This example demonstrates how the `Querier` class can be used to create specific queries for different purposes, making it easier to organize and reuse SQL queries.
+## Segurança
+
+- Use `${param}` para todos os valores dinâmicos vindos do usuário
+- Use `${param/no_quote}` apenas para valores pré-validados (nomes de colunas, listas processadas)
+- A gem valida automaticamente se todos os parâmetros necessários foram fornecidos
 
-## Summary
+## Licença
 
-The `Querier` class provides a convenient way to build and execute custom SQL queries while keeping the process organized. It also enables centralized control for constructing and executing SQL within the context of ActiveRecord. The addition of the `QuerierDatasetExtensions` module further enhances the ease of transforming and using query results.
+MIT
 

data/lib/querier.rb

@@ -1,16 +1,39 @@
 require 'active_record'
+require 'ostruct'
 
 module QuerierDatasetExtensions
   def as_hash = map(&:symbolize_keys)
-  def as_struct = map { |record| OpenStruct.new(record) }
+  def as_struct = map { OpenStruct.new(it) }
+  def pluck(*columns) = map { |row| columns.one? ? row[columns.first.to_s] : columns.map { row[it.to_s] } }
+  def first_value = first&.values&.first
 end
 
 class Querier
+  class QueryError < StandardError; end
+  
   @active_record_class = ActiveRecord::Base
-  # based on rubocop's tips at: https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style/ClassVars
-  # solution here: https://www.ruby-lang.org/en/documentation/faq/8/
+  
   class << self
     attr_accessor :active_record_class
+    
+    def query_template(template = nil)
+      @query_template = template if template
+      @query_template
+    end
+    
+    def param(*names)
+      @param_names = names
+      names.each do |name|
+        define_method(name) do |value|
+          @query_params[name] = value
+          self
+        end
+      end
+    end
+    
+    def param_names
+      @param_names || []
+    end
   end
 
   attr_reader :query, :query_template, :query_params
@@ -18,30 +41,74 @@ class Querier
   def initialize(template_query_params = {})
     @active_record_class = self.class.active_record_class || self.class.superclass.active_record_class
     @query_params = template_query_params
-    @query = fill_query_params
+    @query_template ||= self.class.query_template
+    validate_template!
   end
 
-  def execute = @active_record_class.connection.execute(@query)
-  def exec_query = @active_record_class.connection.exec_query(@query).extend(QuerierDatasetExtensions)
-  def select_all = @active_record_class.connection.select_all(@query).extend(QuerierDatasetExtensions)
-  def select_one = @active_record_class.connection.select_one(@query)
-  def select_rows = @active_record_class.connection.select_rows(@query)
-  def select_values = @active_record_class.connection.select_values(@query)
-  def select_value = @active_record_class.connection.select_value(@query)
+  def execute = wrap_errors { build_and_execute { connection.execute(@query) } }
+  def exec_query = wrap_errors { build_and_execute { connection.exec_query(@query).extend(QuerierDatasetExtensions) } }
+  def select_all = wrap_errors { build_and_execute { connection.select_all(@query).extend(QuerierDatasetExtensions) } }
+  def select_one = wrap_errors { build_and_execute { connection.select_one(@query) } }
+  def select_rows = wrap_errors { build_and_execute { connection.select_rows(@query) } }
+  def select_values = wrap_errors { build_and_execute { connection.select_values(@query) } }
+  def select_value = wrap_errors { build_and_execute { connection.select_value(@query) } }
+  
+  def to_sql
+    build_query
+    @query
+  end
+  
+  def explain
+    build_query
+    explained_query = "EXPLAIN #{@query}"
+    connection.select_all(explained_query).map { it['QUERY PLAN'] }.join("\n")
+  end
+  
+  def count
+    build_query
+    count_query = "SELECT COUNT(*) FROM (#{@query}) AS count_query"
+    connection.select_value(count_query).to_i
+  end
 
   private
 
-  def fill_query_params
-    query = @query_template.dup
+  def connection = @active_record_class.connection
 
-    @query_params.each do |param_name, param_value|
-      placeholder = "${#{param_name}}"
-      placeholder_no_quote = "${#{param_name}/no_quote}"
+  def validate_template!
+    raise ArgumentError, "Query template não pode ser vazio" if @query_template.nil? || @query_template.strip.empty?
+  end
+  
+  def build_and_execute
+    build_query
+    yield
+  end
   
-      query.gsub!(placeholder, @active_record_class.connection.quote(param_value.to_s))
-      query.gsub!(placeholder_no_quote, param_value.to_s)
+  def build_query
+    return if @query
+    
+    required_params = extract_params
+    provided_params = @query_params.keys.map(&:to_s)
+    missing_params = required_params - provided_params
+    
+    if missing_params.any? && self.class.param_names.empty?
+      raise ArgumentError, "Parâmetros faltando: #{missing_params.join(', ')}"
     end
+    
+    @query = @query_params.reduce(@query_template.dup) do |q, (param_name, param_value)|
+      quoted_value = connection.quote(param_value.to_s)
+      q.gsub!("${#{param_name}}", quoted_value)
+      q.gsub!("${#{param_name}/no_quote}", param_value.to_s)
+      q
+    end
+  end
+  
+  def extract_params
+    @query_template.scan(/\$\{(\w+)(?:\/no_quote)?\}/).map(&:first).uniq
+  end
   
-    query
+  def wrap_errors
+    yield
+  rescue ActiveRecord::StatementInvalid => e
+    raise QueryError, "Erro ao executar query: #{e.message}\nQuery: #{@query}"
   end
 end

metadata

@@ -1,30 +1,91 @@
 --- !ruby/object:Gem::Specification
 name: querier
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Gedean Dias
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-04 00:00:00.000000000 Z
-dependencies: []
-description: Active Record queries with variable number of params
+date: 2025-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Gem que simplifica a execução de consultas SQL customizadas usando ActiveRecord,
+  com suporte para templates parametrizados e formatos práticos de resultado. Permite
+  substituição segura de parâmetros e retorno de dados como hash ou struct.
 email: gedean.dias@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - lib/querier.rb
-- lib/querier_bkp.rb
-- lib/querier_bkp2.rb
 homepage: https://github.com/gedean/querier
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/gedean/querier/issues
+  changelog_uri: https://github.com/gedean/querier/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/gedean/querier#readme
+  homepage_uri: https://github.com/gedean/querier
+  source_code_uri: https://github.com/gedean/querier
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -32,15 +93,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Active Record Querier
+summary: Execução segura de queries SQL parametrizadas com ActiveRecord
 test_files: []

data/lib/querier_bkp.rb

@@ -1,93 +0,0 @@
-require 'active_record'
-
-class Querier
-  PARAM_NAME_INDEX = 0
-  PARAM_VALUE_INDEX = 1
-
-  @active_record_class = ActiveRecord::Base
-  # based on rubocop's tips at: https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style/ClassVars
-  # solution here: https://www.ruby-lang.org/en/documentation/faq/8/
-  class << self
-    attr_accessor :active_record_class
-  end
-
-  attr_reader :query_execution_count, :query_template, :query_params
-
-  def initialize(template_query_params = {})
-    @active_record_class = self.class.active_record_class || self.class.superclass.active_record_class
-    @query_execution_count = 0
-    @query_params = template_query_params
-  end
-
-  def execute
-    @query_execution_count += 1
-    @execution_cached_result = @active_record_class.connection.select_all(fill_query_params(query_template: @query_template,
-                                                                                         query_params: @query_params)).map(&:symbolize_keys!)
-  end
-
-  def cached_result(format: :hash)
-    raise 'query not executed yet' if @query_execution_count.eql?(0)
-
-    case format
-    when :hash
-      @execution_cached_result
-    when :open_struct
-      hash_to_open_struct(dataset: @execution_cached_result)
-    else
-      raise 'invalid value type'
-    end
-  end
-
-  def structured_results
-    hash_to_open_struct(dataset: execute)
-  end
-
-  def to_sql
-    fill_query_params(query_template: @query_template, query_params: @query_params)
-  end
-
-  def to_file
-    file_name = "querier #{Time.now.strftime '[%d-%m-%Y]-[%Hh %Mm %Ss]'}.sql"
-    File.write "tmp/#{file_name}", to_sql
-  end
-
-  def field_group_and_count(field_name:, sort_element_index: nil, reverse_sort: true)
-    count_result = cached_result(format: :open_struct).group_by(&field_name).map { |k, v| [k, v.count] }
-
-    unless sort_element_index.nil?
-      count_result = count_result.sort_by { |el| el[sort_element_index] }
-      count_result.reverse! if reverse_sort.eql? true
-    end
-
-    count_result
-  end
-
-  private
-
-  def hash_to_open_struct(dataset:)
-    dataset.map { |record| OpenStruct.new(record.symbolize_keys!) }
-  end
-
-  def get_param_value(raw_query_param:, quotefy_param: true)
-    # where's String#quote when we need it?
-    raw_query_param.instance_of?(String) && quotefy_param ? "'#{raw_query_param.to_s}'" : raw_query_param.to_s
-  end
-
-  def fill_query_params(query_template:, query_params:)
-    query = query_template
-
-    query_params.each_pair do |query_param|
-      query_param_name = query_param[PARAM_NAME_INDEX].to_s
-
-      query.gsub!(/\${#{query_param_name}}/,
-                  get_param_value(raw_query_param: query_param[PARAM_VALUE_INDEX], 
-                                  quotefy_param: true))
-
-      query.gsub!(/\${#{query_param_name}\/no_quote}/,
-                  get_param_value(raw_query_param: query_param[PARAM_VALUE_INDEX],
-                                  quotefy_param: false))
-    end
-
-    query
-  end
-end

data/lib/querier_bkp2.rb

@@ -1,105 +0,0 @@
-require 'active_record'
-
-class Querier
-  PARAM_NAME_INDEX = 0
-  PARAM_VALUE_INDEX = 1
-
-  @active_record_class = ActiveRecord::Base
-  # based on rubocop's tips at: https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style/ClassVars
-  # solution here: https://www.ruby-lang.org/en/documentation/faq/8/
-  class << self
-    attr_accessor :active_record_class
-  end
-
-  attr_reader :query, :query_template, :query_params
-
-  def initialize(template_query_params = {})
-    @active_record_class = self.class.active_record_class || self.class.superclass.active_record_class
-    @query_params = template_query_params
-    @query = fill_query_params
-  end
-
-  def execute
-    @active_record_class.connection.execute(@query)
-  end
-
-  def exec_query
-    decorate_dataset_format(@active_record_class.connection.exec_query(@query))
-  end
-
-  def select_all
-    decorate_dataset_format(@active_record_class.connection.select_all(@query))
-  end
-
-  def select_one
-    @active_record_class.connection.select_one(@query)
-  end
-
-  def select_sole
-    @active_record_class.connection.select_sole(@query)
-  end
-
-  def select_values
-    @active_record_class.connection.select_values(@query)
-  end
-
-  def select_rows
-    @active_record_class.connection.select_rows(@query)
-  end
-
-  def select_value
-    @active_record_class.connection.select_value(@query)
-  end
-
-  private
-
-  def decorate_dataset_format(dataset)
-    def dataset.as_hash
-      map(&:symbolize_keys)
-    end
-
-    def dataset.as_struct
-      map { |record| OpenStruct.new(record) }
-    end
-
-    dataset
-  end
-
-  def get_param_value(raw_query_param:, quotefy_param: true)
-    if raw_query_param.instance_of?(String) && quotefy_param
-      @active_record_class.connection.quote(raw_query_param.to_s)
-    else
-      raw_query_param.to_s
-    end
-  end
-
-  def fill_query_params
-    query = @query_template.dup
-
-    @query_params.each_pair do |query_param|
-      query_param_name = query_param[PARAM_NAME_INDEX].to_s
-
-      query.gsub!(/\${#{query_param_name}}/,
-                  get_param_value(raw_query_param: query_param[PARAM_VALUE_INDEX], 
-                                  quotefy_param: true))
-
-      query.gsub!(/\${#{query_param_name}\/no_quote}/,
-                  get_param_value(raw_query_param: query_param[PARAM_VALUE_INDEX],
-                                  quotefy_param: false))
-    end
-
-    query
-  end
-end
-
-
-# def fill_query_params
-#   query = @query_template.dup
-
-#   @query_params.each do |param_name, param_value|
-#     placeholder = "${#{param_name}}"
-#     query.gsub!(placeholder, param_value.to_s)
-#   end
-
-#   query
-# end