pg_helper 0.3.1 → 0.4.0

data/lib/pg_helper/query_helper.rb

@@ -1,179 +1,168 @@
-#Main module of PgHelper gem/plugin
+# Main module of PgHelper gem/plugin
 module PgHelper
-
-#Indicates that query returned unexpected columnt count
-class PgHelperErrorInvalidColumnCount < PGError; end
-
-#Indicates that query returned too much rows
-class PgHelperErrorInvalidRowCount < PGError; end
-
-# Indicates that transaction was called while inside transaction
-class PgHelperErrorNestedTransactionNotAllowed  < PGError; end
-
-#For use inside transaction to cause rollback.
-class PgHelperErrorRollback < PGError; end
-
-#Indicates that call is invalid outside transaction
-class PgHelperErrorInvalidOutsideTransaction < PGError; end
-
-#Invalid argument
-class PgHelperErrorParamsMustBeArrayOfStrings < PGError; end
-
-#Main api class
-class QueryHelper
-
-  # @return [Hash]  connection params
-  attr_accessor :connection_params
-
-  # Active database connection
-  # @return [PGconn]  connection see {http://rubygems.org/gems/pg Pg gem on rubygems} for details
-  attr_accessor :pg_connection
-
-
-  # Creates a new instance of  the QueryHelper
-  def initialize(params)
-    if params.kind_of? PGconn
-      @pg_connection = params
-      @connection_params = nil
-    else
-      @connection_params = params
-      reconnect
+  # Main api class
+  class QueryHelper
+    # @return [Hash]  connection params
+    attr_accessor :connection_params
+
+    # Active database connection
+    # @return [PGconn]  connection see {http://rubygems.org/gems/pg gem}
+    attr_accessor :pg_connection
+
+    # Creates a new instance of  the QueryHelper
+    def self.using_pool(pool, &_block)
+      helper = nil
+      pool.with_connection do |conn|
+        helper = new(conn)
+        yield helper
+      end
+    ensure
+      helper = nil
     end
-  end
 
-  # @param [String]  query SQL select that should return one cell, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [String]
-  def value(query, params = [])
-    exec(query, params) do |pg_result|
-      verify_single_cell!(pg_result)
-      pg_result.getvalue(0,0)
+    def initialize(params)
+      if params.is_a? PGconn
+        @pg_connection = params
+        @connection_params = nil
+      else
+        @connection_params = params
+        reconnect
+      end
     end
-  end
 
-  # @param [String]  query SQL select that should return one column, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [Array<String>]  Values of selected column
-  def get_column(query, params = [])
-    exec(query, params) do |pg_result|
-      require_single_column!(pg_result)
-      pg_result.column_values(0)
+    # @param [String]  query SQL select that should return one cell,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [String]
+    def value(query, params = [])
+      exec(query, params) do |pg_result|
+        ValidationHelper.verify_single_cell!(pg_result)
+        pg_result.getvalue(0, 0)
+      end
     end
-  end
 
-  # @param [String]  query SQL select that should return one row, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [Hash]  Hash of column_name => row_value for resulting row
-  def get_hash(query, params = [])
-    exec(query, params) do |pg_result|
-      require_single_row!(pg_result)
-      pg_result.res[0]
+    # @param [String]  query SQL select that should return one column,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [Array<String>]  Values of selected column
+    def get_column(query, params = [])
+      exec(query, params) do |pg_result|
+        ValidationHelper.require_single_column!(pg_result)
+        pg_result.column_values(0)
+      end
     end
-  end
 
-  # @param [String]  query SQL select, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [Array<Array>]  Array containing Array of values for each row
-  def get_all(query, params = [])
-    exec(query, params) do |pg_result|
-      pg_result.values
+    # @param [String]  query SQL select that should return one row,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [Hash]  Hash of column_name => row_value for resulting row
+    def get_hash(query, params = [])
+      exec(query, params) do |pg_result|
+        ValidationHelper.require_single_row!(pg_result)
+        pg_result[0]
+      end
     end
-  end
 
-  # @param [String]  query SQL select, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [Array<Hash>]  Array containing hash of column_name => row_value for each row
-  def get_all_hashes(query, params = [])
-    exec(query, params) do |pg_result|
-      pg_result.to_a
+    # @param [String]  query SQL select,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [Array<Array>]  Array containing Array of values for each row
+    def get_all(query, params = [])
+      exec(query, params) do |pg_result|
+        pg_result.values
+      end
     end
-  end
 
-  # @param [String]  query SQL select, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return String csv representation of query result with csv header
-  def csv(query)
-    csv_query = "COPY (#{query}) TO STDOUT with CSV HEADER"
-    exec(csv_query, params = []) do
-      csv_data = ""
-      csv_data += buf while buf = @pg_connection.get_copy_data(true)
-      csv_data
+    # @param [String]  query SQL select,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [Array<Hash>]  Array of row hashes column_name => row_value
+    def get_all_hashes(query, params = [])
+      exec(query, params) do |pg_result|
+        pg_result.to_a
+      end
     end
-  end
 
-  # @param [String]  query SQL update, may include $1, $2 etc to be replaced by arguments
-  # @param [Array<String>]  params query arguments to be passed on to PostgreSql
-  # @return [Integer]  Number of rows changed
-  def modify(query, params = [])
-    exec(query, params) do |pg_result|
-      pg_result.cmd_tuples
+    # @param [String]  query SQL select
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return String csv representation of query result with csv header
+    def csv(query, params = [])
+      csv_query = "COPY (#{query}) TO STDOUT with CSV HEADER"
+      exec(csv_query, params) do
+        csv_data = ''
+        buf = @pg_connection.get_copy_data(true)
+        while buf
+          csv_data += buf
+          buf = @pg_connection.get_copy_data(true)
+        end
+        csv_data
+      end
     end
-  end
 
-  # Executes content of given block inside database transaction
-  #@yield [QueryHelper] 
-  def transaction(&block)
-    verify_transaction_possible!(&block)
-    perform_transaction(&block)
-  end
+    # @param [String]  query SQL update,
+    # may include $1, $2 etc to be replaced by query arguments
+    # @param [Array<String>]  params query arguments
+    # @return [Integer]  Number of rows changed
+    def modify(query, params = [])
+      exec(query, params) do |pg_result|
+        pg_result.cmd_tuples
+      end
+    end
 
-  # Aborts current transaction, or raises exception if invoked outside transaction.
-  #@return [void]
-  def rollback!
-    raise PgHelperErrorInvalidOutsideTransaction if connection_idle?
-    raise PgHelperErrorRollback.new
-  end
+    # Executes content of given block inside database transaction
+    # @yield [QueryHelper]
+    def transaction(&block)
+      verify_transaction_possible!(&block)
+      perform_transaction(&block)
+    end
 
-  protected
+    # Aborts current transaction, or raises exception if invoked
+    # outside transaction.
+    # @return [void]
+    def rollback!
+      fail PgHelperErrorInvalidOutsideTransaction if connection_idle?
+      fail PgHelperErrorRollback
+    end
 
-  def connection_idle?
-    PGconn::PQTRANS_IDLE == @pg_connection.transaction_status
-  end
+    protected
 
-  def require_single_row!(pg_result)
-    raise PgHelperErrorInvalidRowCount.new if pg_result.ntuples != 1
-  end
+    def connection_idle?
+      PGconn::PQTRANS_IDLE == @pg_connection.transaction_status
+    end
 
-  def require_single_column!(pg_result)
-    raise PgHelperErrorInvalidColumnCount.new if pg_result.nfields != 1
-  end
+    def exec(query, params = [], &block)
+      check_query_params(params)
+      pg_result = nil
+      begin
+        pg_result = @pg_connection.exec(query, params)
+        block.call(pg_result)
+      ensure
+        pg_result && pg_result.clear
+      end
+    end
 
-  def exec(query, params=[], &block)
-    check_query_params(params)
-    pg_result = nil
-    begin
-      pg_result = @pg_connection.exec(query, params)
-      block.call(pg_result)
-    ensure
-      pg_result && pg_result.clear
+    def check_query_params(params)
+      params.is_a?(Array) || fail(PgHelperErrorParamsMustBeArrayOfStrings)
     end
-  end
 
-  def check_query_params(params)
-    raise PgHelperErrorParamsMustBeArrayOfStrings.new unless params.is_a?(Array)
-  end
-  def reconnect
-    @pg_connection = PGconn.open(@connection_params)
-  end
+    def reconnect
+      @pg_connection = PGconn.open(@connection_params)  if @connection_params
+    end
 
-  def perform_transaction(&block)
-    @pg_connection.transaction do
-      begin
-      block.call(self)
-      rescue PgHelperErrorRollback
-        true
+    def perform_transaction(&block)
+      @pg_connection.transaction do
+        begin
+          block.call(self)
+          rescue PgHelperErrorRollback
+            true
+        end
       end
     end
-  end
 
-  def verify_transaction_possible!(&block)
-    raise PgHelperErrorNestedTransactionNotAllowed.new unless connection_idle?
-    raise ArgumentError.new('missing block') unless block_given?
-  end
-
-  def verify_single_cell!(pg_result)
-    require_single_row!(pg_result)
-    require_single_column!(pg_result)
+    def verify_transaction_possible!(&_block)
+      fail PgHelperErrorNestedTransactionNotAllowed unless connection_idle?
+      fail ArgumentError, 'missing block' unless block_given?
+    end
   end
 end
-end

data/lib/pg_helper/support_classes.rb

@@ -0,0 +1,44 @@
+# Main module of PgHelper gem/plugin
+module PgHelper
+  # Indicates that query returned unexpected columnt count
+  class PgHelperErrorInvalidColumnCount < PGError; end
+
+  # Indicates that query returned too much rows
+  class PgHelperErrorInvalidRowCount < PGError; end
+
+  # Indicates that transaction was called while inside transaction
+  class PgHelperErrorNestedTransactionNotAllowed  < PGError; end
+
+  # For use inside transaction to cause rollback.
+  class PgHelperErrorRollback < PGError; end
+
+  # Indicates that call is invalid outside transaction
+  class PgHelperErrorInvalidOutsideTransaction < PGError; end
+
+  # Invalid argument
+  class PgHelperErrorParamsMustBeArrayOfStrings < PGError; end
+
+  # data validation
+  class ValidationHelper
+    class << self
+      def require_single_row!(pg_result)
+        fail(
+          PgHelperErrorInvalidRowCount,
+          "expected 1 row, got #{pg_result.ntuples}"
+        ) if pg_result.ntuples != 1
+      end
+
+      def require_single_column!(pg_result)
+        fail(
+          PgHelperErrorInvalidColumnCount,
+          "expected 1 column, got #{pg_result.nfields}"
+        ) if pg_result.nfields != 1
+      end
+
+      def verify_single_cell!(pg_result)
+        require_single_row!(pg_result)
+        require_single_column!(pg_result)
+      end
+    end
+  end
+end

data/lib/pg_helper/version.rb

@@ -1,5 +1,5 @@
-#Main module of PgHelper gem/plugin
+# Main module of PgHelper gem/plugin
 module PgHelper
   # @return [String]  gem version
-  VERSION = "0.3.1"
+  VERSION = '0.4.0'
 end

data/pg_helper.gemspec

@@ -19,11 +19,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'pg'
+  s.add_runtime_dependency 'pg', '~> 0.18.0'
+  s.add_runtime_dependency 'thread_safe'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'wirble'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'bluecloth' #yard hidden dependency
-end
+  s.add_development_dependency 'rubocop' #yard hidden dependency
+end

data/spec/lib/connection_pool_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'pg_helper/connection_pool'
+
+RSpec.describe PgHelper::ConnectionPool do
+  describe '.new'
+  # OPTIONS: :pool_size, :checkout_timeout,
+  # # REST is passed directly to pg_connection.new
+  describe '#checkout'
+  describe '#checkin(connection)'
+  describe '#'
+
+  def connection_options
+    { dbname: 'postgres', user: 'postgres', host: 'localhost' }
+  end
+
+  subject { described_class.new(connection_options) }
+
+  describe '#auto_connect' do
+    it 'is true by default' do
+      expect(subject.auto_connect).to be true
+    end
+
+    context 'when is true' do
+      before { subject.auto_connect = true }
+
+      it 'provides active connection' do
+        expect(subject.connection).not_to be_finished
+      end
+
+      it 'yields active connection' do
+        subject.with_connection { |c| expect(c).not_to be_finished }
+      end
+    end
+
+    context 'when is false' do
+      before { subject.auto_connect = false }
+      it 'raises error instead of active connection' do
+        expect do
+          subject.connection
+        end.to raise_exception
+      end
+
+      it 'raises error instead of yielding active connection' do
+        expect do
+          subject.connection
+        end.to raise_exception
+      end
+    end
+  end
+end

data/spec/lib/connection_pool_test.rb

@@ -0,0 +1,310 @@
+# module ActiveRecord
+#   module ConnectionAdapters
+#     class ConnectionPoolTest < ActiveRecord::TestCase
+#       attr_reader :pool
+#
+#       def setup
+#         super
+#
+#         # Keep a duplicate pool so we do not bother others
+#         @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+#
+#         if in_memory_db?
+#           # Separate connections to an in-memory database
+#           # create an entirely new database,
+#           # with an empty schema etc, so we just stub out this
+#           # schema on the fly.
+#           @pool.with_connection do |connection|
+#             connection.create_table :posts do |t|
+#               t.integer :cololumn
+#             end
+#           end
+#         end
+#       end
+#
+#       def teardown
+#         super
+#         @pool.disconnect!
+#       end
+#
+#       def active_connections(pool)
+#         pool.connections.find_all(&:in_use?)
+#       end
+#
+#       def test_checkout_after_close
+#         connection = pool.connection
+#         assert connection.in_use?
+#
+#         connection.close
+#         assert !connection.in_use?
+#
+#         assert pool.connection.in_use?
+#       end
+#
+#       def test_released_connection_moves_between_threads
+#         thread_conn = nil
+#
+#         Thread.new {
+#           pool.with_connection do |conn|
+#             thread_conn = conn
+#           end
+#         }.join
+#
+#         assert thread_conn
+#
+#         Thread.new {
+#           pool.with_connection do |conn|
+#             assert_equal thread_conn, conn
+#           end
+#         }.join
+#       end
+#
+#       def test_with_connection
+#         assert_equal 0, active_connections(pool).size
+#
+#         main_thread = pool.connection
+#         assert_equal 1, active_connections(pool).size
+#
+#         Thread.new {
+#           pool.with_connection do |conn|
+#             assert conn
+#             assert_equal 2, active_connections(pool).size
+#           end
+#           assert_equal 1, active_connections(pool).size
+#         }.join
+#
+#         main_thread.close
+#         assert_equal 0, active_connections(pool).size
+#       end
+#
+#       def test_active_connection_in_use
+#         assert !pool.active_connection?
+#         main_thread = pool.connection
+#
+#         assert pool.active_connection?
+#
+#         main_thread.close
+#
+#         assert !pool.active_connection?
+#       end
+#
+#       def test_full_pool_exception
+#         assert_raises(CouldNotObtainConnection) do
+#           (@pool.size + 1).times do
+#             @pool.checkout
+#           end
+#         end
+#       end
+#
+#       def test_full_pool_blocks
+#         cs = @pool.size.times.map { @pool.checkout }
+#         t = Thread.new { @pool.checkout }
+#
+#         # make sure our thread is in the timeout section
+#         Thread.pass until t.status == "sleep"
+#
+#         connection = cs.first
+#         connection.close
+#         assert_equal connection, t.join.value
+#       end
+#
+#       def test_removing_releases_latch
+#         cs = @pool.size.times.map { @pool.checkout }
+#         t = Thread.new { @pool.checkout }
+#
+#         # make sure our thread is in the timeout section
+#         Thread.pass until t.status == "sleep"
+#
+#         connection = cs.first
+#         @pool.remove connection
+#         assert_respond_to t.join.value, :execute
+#       end
+#
+#       def test_reap_and_active
+#         @pool.checkout
+#         @pool.checkout
+#         @pool.checkout
+#         @pool.dead_connection_timeout = 0
+#
+#         connections = @pool.connections.dup
+#
+#         @pool.reap
+#
+#         assert_equal connections.length, @pool.connections.length
+#       end
+#
+#       def test_reap_inactive
+#         @pool.checkout
+#         @pool.checkout
+#         @pool.checkout
+#         @pool.dead_connection_timeout = 0
+#
+#         connections = @pool.connections.dup
+#         connections.each do |conn|
+#           conn.extend(Module.new { def active?; false; end; })
+#         end
+#
+#         @pool.reap
+#
+#         assert_equal 0, @pool.connections.length
+#       ensure
+#         connections.each(&:close)
+#       end
+#
+#       def test_remove_connection
+#         conn = @pool.checkout
+#         assert conn.in_use?
+#
+#         length = @pool.connections.length
+#         @pool.remove conn
+#         assert conn.in_use?
+#         assert_equal(length - 1, @pool.connections.length)
+#       ensure
+#         conn.close
+#       end
+#
+#       def test_remove_connection_for_thread
+#         conn = @pool.connection
+#         @pool.remove conn
+#         assert_not_equal(conn, @pool.connection)
+#       ensure
+#         conn.close if conn
+#       end
+#
+#       def test_active_connection?
+#         assert !@pool.active_connection?
+#         assert @pool.connection
+#         assert @pool.active_connection?
+#         @pool.release_connection
+#         assert !@pool.active_connection?
+#       end
+#
+#       def test_checkout_behaviour
+#         pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+#         connection = pool.connection
+#         assert_not_nil connection
+#         threads = []
+#         4.times do |i|
+#           threads << Thread.new(i) do
+#             connection = pool.connection
+#             assert_not_nil connection
+#             connection.close
+#           end
+#         end
+#
+#         threads.each(&:join)
+#
+#         Thread.new do
+#           assert pool.connection
+#           pool.connection.close
+#         end.join
+#       end
+#
+#       # The connection pool is "fair" if threads waiting for
+#       # connections receive them the order in which they began
+#       # waiting.  This ensures that we don't timeout one HTTP request
+#       # even while well under capacity in a multi-threaded environment
+#       # such as a Java servlet container.
+#       #
+#       # We don't need strict fairness: if two connections become
+#       # available at the same time, it's fine of two threads that were
+#       # waiting acquire the connections out of order.
+#       #
+#       # Thus this test prepares waiting threads and then trickles in
+#       # available connections slowly, ensuring the wakeup order is
+#       # correct in this case.
+#       def test_checkout_fairness
+#         @pool.instance_variable_set(:@size, 10)
+#         expected = (1..@pool.size).to_a.freeze
+#         # check out all connections so our threads start out waiting
+#         conns = expected.map { @pool.checkout }
+#         mutex = Mutex.new
+#         order = []
+#         errors = []
+#
+#         threads = expected.map do |i|
+#           t = Thread.new {
+#             begin
+#               @pool.checkout # never checked back in
+#               mutex.synchronize { order << i }
+#             rescue => e
+#               mutex.synchronize { errors << e }
+#             end
+#           }
+#           Thread.pass until t.status == "sleep"
+#           t
+#         end
+#
+#         # this should wake up the waiting threads one by one in order
+#         conns.each { |conn| @pool.checkin(conn); sleep 0.1 }
+#
+#         threads.each(&:join)
+#
+#         raise errors.first if errors.any?
+#
+#         assert_equal(expected, order)
+#       end
+#
+#       # As mentioned in #test_checkout_fairness, we don't care about
+#       # strict fairness.  This test creates two groups of threads:
+#       # group1 whose members all start waiting before any thread in
+#       # group2.  Enough connections are checked in to wakeup all
+#       # group1 threads, and the fact that only group1 and no group2
+#       # threads acquired a connection is enforced.
+#       def test_checkout_fairness_by_group
+#         @pool.instance_variable_set(:@size, 10)
+#         # take all the connections
+#         conns = (1..10).map { @pool.checkout }
+#         mutex = Mutex.new
+#         successes = []    # threads that successfully got a connection
+#         errors = []
+#
+#         make_thread = proc do |i|
+#           t = Thread.new {
+#             begin
+#               @pool.checkout # never checked back in
+#               mutex.synchronize { successes << i }
+#             rescue => e
+#               mutex.synchronize { errors << e }
+#             end
+#           }
+#           Thread.pass until t.status == "sleep"
+#           t
+#         end
+#
+#         # all group1 threads start waiting before any in group2
+#         group1 = (1..5).map(&make_thread)
+#         group2 = (6..10).map(&make_thread)
+#
+#         # checkin n connections back to the pool
+#         checkin = proc do |n|
+#           n.times do
+#             c = conns.pop
+#             @pool.checkin(c)
+#           end
+#         end
+#
+#         checkin.call(group1.size)         # should wake up all group1
+#
+#         loop do
+#           sleep 0.1
+#           break if mutex.synchronize {
+#             (successes.size + errors.size) == group1.size }
+#         end
+#
+#         winners = mutex.synchronize { successes.dup }
+#         checkin.call(group2.size) # should wake up everyone remaining
+#
+#         group1.each(&:join)
+#         group2.each(&:join)
+#
+#         assert_equal((1..group1.size).to_a, winners.sort)
+#
+#         if errors.any?
+#           raise errors.first
+#         end
+#       end
+#     end
+#   end
+# end
+# =