em-pg-client 0.3.0 → 0.3.1

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,31 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+env:
+  - PGVERSION=9.3 PGBUILD=9.3.2-1-linux-x64
+  - PGVERSION=9.0 PGBUILD=9.0.15-1-linux-x64
+  - PGVERSION=8.4 PGBUILD=8.4.19-1-linux-x64
+before_install:
+  - sudo /etc/init.d/postgresql stop
+  - export PGPREFIX=/opt/PostgreSQL/$PGVERSION
+  - export PGDATA=$PGPREFIX/data
+  - export PATH="$PGPREFIX/bin:$PATH"
+  - wget http://get.enterprisedb.com/postgresql/postgresql-$PGBUILD.run
+  - chmod +x postgresql-$PGBUILD.run
+  - sudo ./postgresql-$PGBUILD.run --mode unattended --unattendedmodeui minimal --prefix
+    $PGPREFIX --datadir $PGDATA;
+  - sudo sed s/md5\$/trust/g $PGDATA/pg_hba.conf >/tmp/pg_hba.conf.$$
+  - sudo mv /tmp/pg_hba.conf.$$ $PGDATA/pg_hba.conf
+  - sudo -i -u postgres $PGPREFIX/bin/pg_ctl -D $PGDATA reload
+  - PGHOST_UNIX=`netstat -l --protocol=unix|grep PGSQL|awk '{print $NF}'`
+  - export PGHOST_UNIX="`dirname $PGHOST_UNIX`"
+  - test -n "$PGHOST_UNIX"
+  - export PG_CTL_STOP_CMD="sudo -i -u postgres $PGPREFIX/bin/pg_ctl -D $PGDATA stop
+    -s -m fast"
+  - export PG_CTL_START_CMD="sudo -i -u postgres $PGPREFIX/bin/pg_ctl -D $PGDATA start
+    -l $PGDATA/postgresql.log -s -w"
+  - export PGUSER=postgres
+  - psql -c 'create database test;' -h "$PGHOST_UNIX"
+script: COVERAGE=1 bundle exec rake test_with_coveralls

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org/"
+
+gem 'rake' # Travis-CI complains about it not being here
+
+gemspec

data/HISTORY.md

@@ -1,3 +1,13 @@
+0.3.1
+
+- support for asynchronous data streaming in single row mode -
+  asynchronous versions of get_result, get_last_result and
+  their deferrable variants
+- watcher improvements allowing to reset pending commands
+- minor DRY improvements in code and specs
+- single_row_mode? helper
+- spec: Travis CI and Coverage
+
 0.3.0
 
 - dedicated asynchronous connection pool

data/README.md

@@ -1,16 +1,20 @@
-em-pg-client
-============
+#em-pg-client
 
-Author: Rafał Michalski  (rafal at yeondir dot com)
+The Ruby EventMachine driver interface to the PostgreSQL RDBMS. It is based on
+[ruby-pg](https://bitbucket.org/ged/ruby-pg).
+
+[![Gem Version][GV img]][Gem Version]
+[![Dependency Status][DS img]][Dependency Status]
+[![Coverage Status][CS img]][Coverage Status]
+[![Build Status][BS img]][Build Status]
+
+Author: Rafał Michalski (rafal at yeondir dot com)
 
 * http://github.com/royaltm/ruby-em-pg-client
 
 Description
 -----------
 
-__em-pg-client__ is the Ruby EventMachine driver interface to the
-PostgreSQL RDBMS. It is based on [ruby-pg](https://bitbucket.org/ged/ruby-pg).
-
 __em-pg-client__ provides {PG::EM::Client} class which inherits
 [PG::Connection](http://deveiate.org/code/pg/PG/Connection.html).
 You can work with {PG::EM::Client} almost the same way you would work
@@ -58,7 +62,7 @@ Features
 * Non-blocking / fully asynchronous processing with EventMachine.
 * Event reactor auto-detecting, asynchronous fiber-synchronized command methods
   (the same code can be used regardless of the EventMachine reactor state)
-* Asynchronous EM-style (deferrable returning) command methods.
+* Asynchronous EM-style (Deferrable returning) command methods.
 * Fully asynchronous automatic re-connects on connection failures
   (e.g.: RDBMS restarts, network failures).
 * Minimal changes to [PG::Connection](http://deveiate.org/code/pg/PG/Connection.html) API.
@@ -66,7 +70,9 @@ Features
 * Dedicated connection pool with dynamic size, supporting asynchronous
   processing and transactions.
 * [Sequel Adapter](https://github.com/fl00r/em-pg-sequel) by Peter Yanovich.
-* Works on windows (requires ruby 2.0) (issue #7).
+* Works on windows (requires ruby 2.0) ([issue #7][Issue 7]).
+* __New__ - supports asynchronous query data processing in single row mode
+  ([issue #12][Issue 12]).
 
 Requirements
 ------------
@@ -82,14 +88,14 @@ Requirements
 Install
 -------
 
-```
+```sh
   $ [sudo] gem install em-pg-client
 ```
 
 #### Gemfile
 
 ```ruby
-  gem "em-pg-client", "~> 0.3.0"
+  gem "em-pg-client", "~> 0.3.1"
 ```
 
 #### Github
@@ -390,3 +396,18 @@ The greetz go to:
   [em-pg-sequel](https://github.com/fl00r/em-pg-sequel)
 * Andrew Rudenko [prepor](https://github.com/prepor) for the implicit idea
   of the re-usable watcher from his [em-pg](https://github.com/prepor/em-pg).
+
+[![Bitdeli Badge][BB img]][Bitdeli Badge]
+
+[Gem Version]: https://rubygems.org/gems/em-pg-client
+[Dependency Status]: https://gemnasium.com/royaltm/ruby-em-pg-client
+[Coverage Status]: https://coveralls.io/r/royaltm/ruby-em-pg-client
+[Build Status]: https://travis-ci.org/royaltm/ruby-em-pg-client
+[Bitdeli Badge]: https://bitdeli.com/free
+[Issue 7]: https://github.com/royaltm/ruby-em-pg-client/issues/7
+[Issue 12]: https://github.com/royaltm/ruby-em-pg-client/issues/12
+[GV img]: https://badge.fury.io/rb/em-pg-client.png
+[DS img]: https://gemnasium.com/royaltm/ruby-em-pg-client.png
+[CS img]: https://coveralls.io/repos/royaltm/ruby-em-pg-client/badge.png
+[BS img]: https://travis-ci.org/royaltm/ruby-em-pg-client.png
+[BB img]: https://d2weczhvl823v0.cloudfront.net/royaltm/ruby-em-pg-client/trend.png

data/Rakefile

@@ -1,3 +1,7 @@
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+task :test_with_coveralls => ['test:all', 'coveralls:push']
+
 $:.unshift "lib"
 
 task :default => [:test]
@@ -13,43 +17,76 @@ task :test => :'test:safe'
 
 namespace :test do
   env_common = {'PGDATABASE' => 'test'}
-  env_unix_socket = env_common.merge('PGHOST' => '/tmp')
-  env_tcpip = env_common.merge('PGHOST' => 'localhost')
+  env_unix = env_common.merge('PGHOST' => ENV['PGHOST_UNIX'] || '/tmp')
+  env_inet = env_common.merge('PGHOST' => ENV['PGHOST_INET'] || 'localhost')
 
   task :warn do
-    puts "WARNING: The test needs to be run with an available local PostgreSQL server"
+    puts "WARNING: The tests needs to be run with an available local PostgreSQL server"
   end
 
   desc "Run specs only"
-  task :spec do
-    sh "rspec spec/pg_em_featured_deferrable.rb"
-    sh "rspec spec/pg_em_client_options.rb"
-    sh "rspec spec/pg_em_client_connect_finish.rb"
-    sh "rspec spec/pg_em_client_connect_timeout.rb"
-    sh "rspec spec/pg_em_connection_pool.rb"
+  task :spec => [:spec_defer, :spec_pool, :spec_client]
+
+  task :spec_client do
+    sh({'COVNAME'=>'spec:client'},     "rspec spec/pg_em_client_*.rb")
+  end
+
+  task :spec_pool do
+    sh({'COVNAME'=>'spec:pool'},       "rspec spec/pg_em_connection_pool.rb")
+  end
+
+  task :spec_defer do
+    sh({'COVNAME'=>'spec:deferrable'}, "rspec spec/pg_em_featured_deferrable.rb")
   end
 
   desc "Run safe tests only"
-  task :safe => [:warn, :spec] do
-    %w[
-      spec/em_client.rb
-      spec/em_synchrony_client.rb
-    ].each do |spec|
-      sh env_unix_socket, "rspec #{spec}" unless windows_os?
-      sh env_tcpip, "rspec #{spec}"
+  task :safe  => [:warn, :spec, :async, :fiber]
+  task :async => [:async_inet, :async_unix]
+  task :fiber => [:fiber_inet, :fiber_unix]
+
+  task :async_inet do
+    sh env_inet.merge('COVNAME'=>'async:inet'), "rspec spec/em_client.rb"
+  end
+
+  task :async_unix do
+    sh env_unix.merge('COVNAME'=>'async:unix'), "rspec spec/em_client.rb" unless windows_os?
+  end
+
+  task :fiber_inet do
+    sh env_inet.merge('COVNAME'=>'fiber:inet'), "rspec spec/em_synchrony_client.rb"
+  end
+
+  task :fiber_unix do
+    sh env_unix.merge('COVNAME'=>'fiber:unix'), "rspec spec/em_synchrony_client.rb" unless windows_os?
+  end
+
+  task :pgdata_check do
+    unless ENV['PGDATA'] || (ENV['PG_CTL_STOP_CMD'] && ENV['PG_CTL_START_CMD'])
+      raise "Set PGDATA environment variable before running the autoreconnect tests."
     end
   end
 
   desc "Run unsafe tests only"
-  task :unsafe => :warn do
-    raise "Set PGDATA environment variable before running the autoreconnect tests." unless ENV['PGDATA']
-    %w[
-      spec/em_client_autoreconnect.rb
-      spec/em_synchrony_client_autoreconnect.rb
-    ].each do |spec|
-      sh env_unix_socket, "rspec #{spec}" unless windows_os?
-      sh env_tcpip, "rspec #{spec}"
-    end
+  task :unsafe => [:warn, :pgdata_check,
+    :async_autoreconnect_inet,
+    :async_autoreconnect_unix,
+    :fiber_autoreconnect_inet,
+    :fiber_autoreconnect_unix]
+
+  task :async_autoreconnect_inet do
+    sh env_inet.merge('COVNAME'=>'async:autoreconnect:inet'), "rspec spec/em_client_autoreconnect.rb"
+  end
+
+  task :async_autoreconnect_unix do
+    sh env_unix.merge('COVNAME'=>'async:autoreconnect:unix'), "rspec spec/em_client_autoreconnect.rb"
+  end
+
+  task :fiber_autoreconnect_inet do
+    sh env_inet.merge('COVNAME'=>'fiber:autoreconnect:inet'), "rspec spec/em_synchrony_client_autoreconnect.rb"
+  end
+
+  task :fiber_autoreconnect_unix do
+    sh env_unix.merge('COVNAME'=>'fiber:autoreconnect:unix'), "rspec spec/em_synchrony_client_autoreconnect.rb"
   end
 
   desc "Run safe and unsafe tests"

data/benchmarks/em_pg.rb

@@ -1,13 +1,11 @@
 $:.unshift('./lib')
 require 'eventmachine'
 require 'em-synchrony'
-require 'em-synchrony/pg'
+require 'pg/em/connection_pool'
 require "em-synchrony/fiber_iterator"
 require 'pp'
 require 'benchmark'
 
-$dbname = 'alpha'
-
 def benchmark(repeat=100)
   Benchmark.bm(20) do |b|
     b.report('single:')         { single(repeat) }
@@ -28,31 +26,36 @@ end
 
 def patch_remove_blocking
   PG::EM::Client::Watcher.module_eval <<-EOE
-    alias_method :notify_readable, :original_notify_readable
-    undef :original_notify_readable
+    alias_method :fetch_results, :original_fetch_results
+    alias_method :notify_readable, :fetch_results
+    undef :original_fetch_results
   EOE
 end
 
 def patch_blocking
+  PG::Connection.class_eval <<-EOE
+    alias_method :blocking_get_last_result, :get_last_result
+  EOE
   PG::EM::Client::Watcher.module_eval <<-EOE
-    alias_method :original_notify_readable, :notify_readable
-    def notify_readable
-      detach
+    alias_method :original_fetch_results, :fetch_results
+    def fetch_results
+      self.notify_readable = false
       begin
-        result = @client.get_last_result
+        result = @client.blocking_get_last_result
       rescue Exception => e
         @deferrable.fail(e)
       else
         @deferrable.succeed(result)
       end
     end
+    alias_method :notify_readable, :fetch_results
   EOE
 end
 
 # retrieve resources using single select query
 def single(repeat=1)
   rowcount = 0
-  p = PGconn.new :dbname => $dbname, :host => 'localhost'
+  p = PGconn.new
   p.query('select count(*) from resources') do |result|
     rowcount = result.getvalue(0,0).to_i
   end
@@ -69,7 +72,7 @@ def parallel(repeat=1, chunk_size=2000, concurrency=10)
   resources = []
   rowcount = 0
   EM.synchrony do
-    p = EM::Synchrony::ConnectionPool.new(size: concurrency) { PG::EM::Client.new :dbname => $dbname }
+    p = PG::EM::ConnectionPool.new size: concurrency
     p.query('select count(*) from resources') do |result|
       rowcount = result.getvalue(0,0).to_i
     end
@@ -78,7 +81,7 @@ def parallel(repeat=1, chunk_size=2000, concurrency=10)
       EM::Synchrony::FiberIterator.new(offsets, concurrency).each do |offset|
         p.query('select * from resources order by cdate limit $1 offset $2', [chunk_size, offset]) do |result|
           resources[offset, chunk_size] = result.values
-        end    
+        end
       end
     end
     EM.stop

data/em-pg-client.gemspec

@@ -22,6 +22,8 @@ Gem::Specification.new do |s|
   s.requirements << "PostgreSQL server"
   s.add_runtime_dependency "pg", ">= 0.17.0"
   s.add_runtime_dependency "eventmachine", "~> 1.0.0"
-  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "rspec", "~> 2.14"
   s.add_development_dependency "em-synchrony", "~> 1.0.0"
+  s.add_development_dependency "coveralls", ">= 0.7.0"
+  s.add_development_dependency "simplecov", ">= 0.8.2"
 end

data/examples/single_row_mode.rb

@@ -0,0 +1,67 @@
+# Demonstation of fully asynchronous query data streaming.
+#
+# This is a low-level method which has its:
+#
+# upside:   it's the same way you would work with PG::Connection
+# downside: it's a little verbose and doesn't support automatic re-connects
+gem 'em-pg-client', '>= 0.3.1'
+require 'pg/em/connection_pool'
+require 'em-synchrony'
+require 'em-synchrony/fiber_iterator'
+
+TABLE_NAME = 'resources'
+
+unless PG::EM::Client.single_row_mode?
+  raise 'compile pg against pqlib >= 9.2 to support single row mode'
+end
+
+def tick_sleep
+  f = Fiber.current
+  EM.next_tick { f.resume }
+  Fiber.yield
+end
+
+EM.synchrony do
+  EM.add_periodic_timer(0.01) { print ' ' }
+
+  db = PG::EM::ConnectionPool.new size: 3
+
+  10.times do
+
+    EM::Synchrony::FiberIterator.new(%w[@ * #], 3).each do |mark|
+
+      db.hold do |pg|
+        pg.send_query("select * from #{TABLE_NAME}")
+        pg.set_single_row_mode
+        rows = 0
+        while result = pg.get_result
+          begin
+            result.check
+            result.each do |tuple|
+              rows += 1
+              # process tuple
+              print mark
+              if (rows % 10).zero?
+                # let reactor do some work if data is coming too fast
+                tick_sleep
+              end
+              # break stream cleanly
+              pg.reset if rows > 1000
+            end
+          rescue PG::Error => e
+            # cleanup connection
+            pg.get_last_result
+            raise e
+          ensure
+            result.clear
+          end
+        end
+      end
+
+    end
+
+    puts
+    puts '='*80
+  end
+  EM.stop
+end

data/lib/pg/em-version.rb

@@ -1,5 +1,5 @@
 module PG
   module EM
-    VERSION = '0.3.0'
+    VERSION = '0.3.1'
   end
 end

data/lib/pg/em.rb

@@ -175,6 +175,21 @@ module PG
       # Used internally for marking connection as aborted on query timeout.
       attr_accessor :async_command_aborted
 
+      # Returns +true+ if +pg+ supports single row mode or +false+ otherwise.
+      # Single row mode is available since +libpq+ 9.2.
+      # @return [Boolean]
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-set_single_row_mode PG::Connection#set_single_row_mode
+      def self.single_row_mode?
+        method_defined? :set_single_row_mode
+      end
+
+      # Returns +true+ if +pg+ supports single row mode or +false+ otherwise.
+      # @return [Boolean]
+      # @see single_row_mode?
+      def single_row_mode?
+        self.class.single_row_mode?
+      end
+
       # environment variable name for connect_timeout fallback value
       @@connect_timeout_envvar = conndefaults.find{|d| d[:keyword] == "connect_timeout" }[:envvar]
 
@@ -267,9 +282,10 @@ module PG
       # after successfull reset.
       # If the block is provided it's bound to +callback+ and +errback+ hooks
       # of the returned deferrable.
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-reset PG::Connection#reset
       def reset_defer(&blk)
         @async_command_aborted = false
-        df = PG::EM::FeaturedDeferrable.new(&blk)
+        df = FeaturedDeferrable.new(&blk)
         # there can be only one watch handler over the socket
         # apparently eventmachine has hard time dealing with more than one
         # for blocking reset this is not needed
@@ -302,10 +318,9 @@ module PG
       # Otherwise performs a thread-blocking call to the parent method.
       #
       # @raise [PG::Error]
-      #
+      # @see #reset_defer
       # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-reset PG::Connection#reset
       def reset
-        @async_command_aborted = false
         if ::EM.reactor_running? && !(f = Fiber.current).equal?(ROOT_FIBER)
           reset_defer {|r| f.resume(r) }
 
@@ -313,6 +328,11 @@ module PG
           raise conn if conn.is_a?(::Exception)
           conn
         else
+          @async_command_aborted = false
+          if @watcher
+            @watcher.detach if @watcher.watching?
+            @watcher = nil
+          end
           super
         end
       end
@@ -394,7 +414,7 @@ module PG
       # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-status PG::Connection#status
       def status
         if @async_command_aborted
-          PG::CONNECTION_BAD
+          CONNECTION_BAD
         else
           super
         end
@@ -404,10 +424,10 @@ module PG
       # Perform auto re-connect. Used internally.
       def async_autoreconnect!(deferrable, error, &send_proc)
         # reconnect only if connection is bad and flag is set
-        if self.status != PG::CONNECTION_OK && async_autoreconnect
+        if self.status == CONNECTION_BAD && async_autoreconnect
           # check if transaction was active
           was_in_transaction = case @last_transaction_status
-          when PG::PQTRANS_IDLE, PG::PQTRANS_UNKNOWN
+          when PQTRANS_IDLE, PQTRANS_UNKNOWN
             false
           else
             true
@@ -431,7 +451,7 @@ module PG
                 if returned_df.respond_to?(:callback) && returned_df.respond_to?(:errback)
                   # the handler returned a deferrable
                   returned_df.callback do
-                    if was_in_transaction
+                    if was_in_transaction || !send_proc
                       # there was a transaction in progress, fail anyway
                       deferrable.fail error
                     else
@@ -444,7 +464,7 @@ module PG
                 elsif returned_df.is_a?(Exception)
                   # tha handler returned an exception object, so fail with it
                   deferrable.fail returned_df
-                elsif returned_df == false || (was_in_transaction && returned_df != true)
+                elsif returned_df == false || !send_proc || (was_in_transaction && returned_df != true)
                   # tha handler returned false or raised an exception
                   # or there was an active transaction and handler didn't return true
                   deferrable.fail error
@@ -453,7 +473,7 @@ module PG
                   deferrable.protect(&send_proc)
                 end
               end.resume
-            elsif was_in_transaction
+            elsif was_in_transaction || !send_proc
               # there was a transaction in progress, fail anyway
               deferrable.fail error
             else
@@ -469,11 +489,14 @@ module PG
       end
 
       # @!macro deferrable_api
-      #   @yieldparam result [PG::Result|Error] command result on success or a PG::Error instance on error.
       #   @return [FeaturedDeferrable]
-      #   Use the returned deferrable's +callback+ and +errback+ method to get the result.
-      #   If the block is provided it's bound to both the +callback+ and +errback+ hooks
-      #   of the returned deferrable.
+      #   Use the returned Deferrable's +callback+ and +errback+ methods to
+      #   get the result. If the block is provided it's bound to both the
+      #   +callback+ and +errback+ hooks of the returned deferrable.
+
+      # @!macro deferrable_query_api
+      #   @yieldparam result [PG::Result|Error] command result on success or a PG::Error instance on error.
+      #   @macro deferrable_api
 
       # @!group Deferrable command methods
 
@@ -481,41 +504,41 @@ module PG
       #   Sends SQL query request specified by +sql+ to PostgreSQL for asynchronous processing,
       #   and immediately returns with +deferrable+.
       #
-      #   @macro deferrable_api
+      #   @macro deferrable_query_api
       #
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-exec PG::Connection#exec
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-exec_params PG::Connection#exec_params
       #
       # @!method prepare_defer(stmt_name, sql, param_types=nil, &blk)
       #   Prepares statement +sql+ with name +stmt_name+ to be executed later asynchronously,
-      #   and immediately returns with deferrable.
+      #   and immediately returns with a Deferrable.
       #
-      #   @macro deferrable_api
+      #   @macro deferrable_query_api
       #
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-prepare PG::Connection#prepare
       #
       # @!method exec_prepared_defer(statement_name, params=nil, result_format=nil, &blk)
       #   Execute prepared named statement specified by +statement_name+ asynchronously,
-      #   and immediately returns with deferrable.
+      #   and immediately returns with a Deferrable.
       #
-      #   @macro deferrable_api
+      #   @macro deferrable_query_api
       #
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-send_query_prepared PG::Connection#send_query_prepared
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared PG::Connection#send_exec_prepared
       #
       # @!method describe_prepared_defer(statement_name, &blk)
       #   Asynchronously sends command to retrieve information about the prepared statement +statement_name+,
-      #   and immediately returns with deferrable.
+      #   and immediately returns with a Deferrable.
       #
-      #   @macro deferrable_api
+      #   @macro deferrable_query_api
       #
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-describe_prepared PG::Connection#describe_prepared
       #
       # @!method describe_portal_defer(portal_name, &blk)
       #   Asynchronously sends command to retrieve information about the portal +portal_name+,
-      #   and immediately returns with deferrable.
+      #   and immediately returns with a Deferrable.
       #
-      #   @macro deferrable_api
+      #   @macro deferrable_query_api
       #
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-describe_portal PG::Connection#describe_portal
       #
@@ -529,25 +552,16 @@ module PG
 
         class_eval <<-EOD, __FILE__, __LINE__
         def #{defer_name}(*args, &blk)
-          df = PG::EM::FeaturedDeferrable.new(&blk)
+          df = FeaturedDeferrable.new(&blk)
           send_proc = proc do
             #{send_name}(*args)
-            if @watcher && @watcher.watching?
-              @watcher.watch_query(df, send_proc)
-            else
-              @watcher = ::EM.watch(self.socket_io, Watcher, self).
-                            watch_query(df, send_proc)
-            end
+            setup_emio_watcher.watch_results(df, send_proc)
           end
           begin
-            if @async_command_aborted
-              error = ConnectionBad.new("previous query expired, need connection reset")
-              error.instance_variable_set(:@connection, self)
-              raise error
-            end
+            check_async_command_aborted!
             @last_transaction_status = transaction_status
             send_proc.call
-          rescue PG::Error => e
+          rescue Error => e
             ::EM.next_tick { async_autoreconnect!(df, e, &send_proc) }
           rescue Exception => e
             ::EM.next_tick { df.fail(e) }
@@ -565,18 +579,106 @@ module PG
 
       # @!endgroup
 
-      # @!macro auto_synchrony_api
-      #   Performs command asynchronously yielding current fiber
-      #   if EventMachine reactor is running and the current fiber isn't the
-      #   root fiber. Other fibers can process while waiting for the server
+      # Asynchronously retrieves the next result from a call to
+      # #send_query (or another asynchronous command) and immediately
+      # returns with a Deferrable.
+      # It then receives the result object on :succeed, or +nil+
+      # if no results are available.
+      #
+      # @macro deferrable_api
+      # @yieldparam result [PG::Result|Error|nil] command result on success or a PG::Error instance on error
+      #                                             or +nil+ if no results are available.
+      #
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-send_query PG::Connection#send_query
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-get_result PG::Connection#get_result
+      #
+      def get_result_defer(&blk)
+        begin
+          df = FeaturedDeferrable.new(&blk)
+          check_async_command_aborted!
+          setup_emio_watcher.watch_results(df, nil, true)
+        rescue Error => e
+          ::EM.next_tick { async_autoreconnect!(df, e) }
+        rescue Exception => e
+          ::EM.next_tick { df.fail(e) }
+        end
+        df
+      end
+
+      alias_method :blocking_get_result, :get_result
+
+      # Asynchronously retrieves all available results on the current
+      # connection (from previously issued asynchronous commands like
+      # +send_query()+) and immediately returns with a Deferrable.
+      # It then receives the last non-NULL result on :succeed, or +nil+
+      # if no results are available.
+      #
+      # @macro deferrable_api
+      # @yieldparam result [PG::Result|Error|nil] command result on success or a PG::Error instance on error
+      #                                             or +nil+ if no results are available.
+      #
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-send_query PG::Connection#send_query
+      # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-get_last_result PG::Connection#get_last_result
+      #
+      def get_last_result_defer(&blk)
+        begin
+          df = FeaturedDeferrable.new(&blk)
+          check_async_command_aborted!
+          setup_emio_watcher.watch_results(df)
+        rescue Error => e
+          ::EM.next_tick { async_autoreconnect!(df, e) }
+        rescue Exception => e
+          ::EM.next_tick { df.fail(e) }
+        end
+        df
+      end
+
+      def raise_error(klass=Error, message=error_message)
+        error = klass.new(message)
+        error.instance_variable_set(:@connection, self)
+        raise error
+      end
+
+      private
+
+      def check_async_command_aborted!
+        if @async_command_aborted
+          raise_error ConnectionBad, "previous query expired, need connection reset"
+        end
+      end
+
+      def setup_emio_watcher
+        case status
+        when CONNECTION_BAD
+          raise_error ConnectionBad
+        when CONNECTION_OK
+          if @watcher && @watcher.watching?
+            @watcher
+          else
+            @watcher = ::EM.watch(self.socket_io, Watcher, self)
+          end
+        else
+          raise_error ConnectionBad, "connection reset pending"
+        end
+      end
+
+      public
+
+      # @!macro auto_synchrony_api_intro
+      #   If EventMachine reactor is running and the current fiber isn't the
+      #   root fiber this method performs command asynchronously yielding
+      #   current fiber. Other fibers can process while waiting for the server
       #   to complete the request.
       #
-      #   Otherwise performs a blocking call to parent method.
+      #   Otherwise performs a blocking call to a parent method.
       #
       #   @yieldparam result [PG::Result] command result on success
+      #   @raise [PG::Error]
+
+      # @!macro auto_synchrony_api
+      #   @macro auto_synchrony_api_intro
       #   @return [PG::Result] if block wasn't given
       #   @return [Object] result of the given block
-      #   @raise [PG::Error]
 
       # @!group Auto-sensing thread or fiber blocking command methods
 
@@ -605,7 +707,7 @@ module PG
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-prepare PG::Connection#prepare
       #
       # @!method exec_prepared(statement_name, params=nil, result_format=nil, &blk)
-      #   Execute prepared named statement specified by +statement_name+.
+      #   Executes prepared named statement specified by +statement_name+.
       #
       #   @macro auto_synchrony_api
       #
@@ -613,7 +715,7 @@ module PG
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared PG::Connection#exec_prepared
       #
       # @!method describe_prepared(statement_name, &blk)
-      #   Retrieve information about the prepared statement +statement_name+,
+      #   Retrieves information about the prepared statement +statement_name+,
       #
       #   @macro auto_synchrony_api
       #
@@ -621,13 +723,35 @@ module PG
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-describe_prepared PG::Connection#describe_prepared
       #
       # @!method describe_portal(portal_name, &blk)
-      #   Retrieve information about the portal +portal_name+,
+      #   Retrieves information about the portal +portal_name+,
       #
       #   @macro auto_synchrony_api
       #
       #   @see PG::EM::Client#describe_portal_defer
       #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-describe_portal PG::Connection#describe_portal
       #
+      # @!method get_result(&blk)
+      #   Retrieves the next result from a call to #send_query (or another
+      #   asynchronous command). If no more results are available returns
+      #   +nil+ and the block (if given) is never called.
+      #
+      #   @macro auto_synchrony_api
+      #   @return [nil] if no more results
+      #
+      #   @see #get_result_defer
+      #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-get_result PG::Connection#get_result
+      #
+      # @!method get_last_result
+      #   Retrieves all available results on the current connection
+      #   (from previously issued asynchronous commands like +send_query()+)
+      #   and returns the last non-NULL result, or +nil+ if no results are
+      #   available.
+      #
+      #   @macro auto_synchrony_api
+      #   @return [nil] if no more results
+      #
+      #   @see #get_last_result_defer
+      #   @see http://deveiate.org/code/pg/PG/Connection.html#method-i-get_last_result PG::Connection#get_last_result
       %w(
         exec              exec_defer
         exec_params       exec_defer
@@ -635,18 +759,25 @@ module PG
         prepare           prepare_defer
         describe_prepared describe_prepared_defer
         describe_portal   describe_portal_defer
+        get_result        get_result_defer
+        get_last_result   get_last_result_defer
         ).each_slice(2) do |name, defer_name|
 
         class_eval <<-EOD, __FILE__, __LINE__
           def #{name}(*args, &blk)
             if ::EM.reactor_running? && !(f = Fiber.current).equal?(ROOT_FIBER)
+              result = fiber = nil
               #{defer_name}(*args) do |res|
-                f.resume(res)
+                f = nil
+                if fiber
+                  fiber.resume(res)
+                else
+                  result = res
+                end
               end
-
-              result = Fiber.yield
+              result = Fiber.yield if (fiber = f)
               raise result if result.is_a?(::Exception)
-              if block_given?
+              if block_given? && result
                 begin
                   yield result
                 ensure
@@ -668,9 +799,11 @@ module PG
 
       # @!endgroup
 
+
       TRAN_BEGIN_QUERY = 'BEGIN'
       TRAN_ROLLBACK_QUERY = 'ROLLBACK'
       TRAN_COMMIT_QUERY = 'COMMIT'
+
       # Executes a BEGIN at the start of the block and a COMMIT at the end
       # of the block or ROLLBACK if any exception occurs.
       #
@@ -727,12 +860,12 @@ module PG
         tcount = @client_tran_count.to_i
 
         case transaction_status
-        when PG::PQTRANS_IDLE
+        when PQTRANS_IDLE
           # there is no transaction yet, so let's begin
           exec(TRAN_BEGIN_QUERY)
           # reset transaction count in case user code rolled it back before
           tcount = 0 if tcount != 0
-        when PG::PQTRANS_INTRANS
+        when PQTRANS_INTRANS
           # transaction in progress, leave it be
         else
           # transaction failed, is in unknown state or command is active
@@ -748,7 +881,7 @@ module PG
         rescue
           # error was raised
           case transaction_status
-          when PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR
+          when PQTRANS_INTRANS, PQTRANS_INERROR
             # do not rollback if transaction was rolled back before
             # or is in unknown state, which means connection reset is needed
             # and rollback only from the outermost transaction block
@@ -759,15 +892,15 @@ module PG
         else
           # we are good (but not out of woods yet)
           case transaction_status
-          when PG::PQTRANS_INTRANS
+          when PQTRANS_INTRANS
             # commit only from the outermost transaction block
             exec(TRAN_COMMIT_QUERY) if tcount.zero?
-          when PG::PQTRANS_INERROR
+          when PQTRANS_INERROR
             # no ruby error was raised (or an error was rescued in code block)
             # but there was an sql error anyway
             # so rollback after the outermost block
             exec(TRAN_ROLLBACK_QUERY) if tcount.zero?
-          when PG::PQTRANS_IDLE
+          when PQTRANS_IDLE
             # the code block has terminated the transaction on its own
             # so just reset the counter
             tcount = 0