em-pg-client 0.1.1 → 0.2.0.pre.1

data/benchmarks/em_pg.rb

@@ -1,93 +1,93 @@
-$:.unshift('./lib')
-require 'eventmachine'
-require 'em-synchrony'
-require 'em-synchrony/pg'
-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) }
-    puts
-    b.report('parallel 90000/1:')  { parallel(repeat, 90000, 1) }
-    b.report('parallel 5000/5:')  { parallel(repeat, 5000, 5) }
-    b.report('parallel 2000/10:') { parallel(repeat, 2000, 10) }
-    b.report('parallel 1000/20:') { parallel(repeat, 1000, 20) }
-    puts
-    patch_blocking
-    b.report('blocking 90000/1:')  { parallel(repeat, 90000, 1) }
-    b.report('blocking 5000/5:')  { parallel(repeat, 5000, 5) }
-    b.report('blocking 2000/10:') { parallel(repeat, 2000, 10) }
-    b.report('blocking 1000/20:') { parallel(repeat, 1000, 20) }
-    patch_remove_blocking
-  end
-end
-
-def patch_remove_blocking
-  PG::EM::Client::Watcher.module_eval <<-EOE
-    alias_method :notify_readable, :original_notify_readable
-    undef :original_notify_readable
-  EOE
-end
-
-def patch_blocking
-  PG::EM::Client::Watcher.module_eval <<-EOE
-    alias_method :original_notify_readable, :notify_readable
-    def notify_readable
-      detach
-      begin
-        result = @client.get_last_result
-      rescue Exception => e
-        @deferrable.fail(e)
-      else
-        @deferrable.succeed(result)
-      end
-    end
-  EOE
-end
-
-# retrieve resources using single select query
-def single(repeat=1)
-  rowcount = 0
-  p = PGconn.new :dbname => $dbname
-  p.query('select count(*) from resources') do |result|
-    rowcount = result.getvalue(0,0).to_i
-  end
-  repeat.times do
-    p.query('select * from resources order by cdate') do |result|
-      $resources = result.values
-    end
-  end
-  # raise "invalid count #{$resources.length} != #{rowcount}" if $resources.length != rowcount
-end
-
-# retrieve resources using parallel queries
-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.query('select count(*) from resources') do |result|
-      rowcount = result.getvalue(0,0).to_i
-    end
-    offsets = (rowcount / chunk_size.to_f).ceil.times.map {|n| n*chunk_size }
-    repeat.times do
-      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
-    EM.stop
-  end
-  # raise "invalid count #{resources.length} != #{rowcount}" if resources.length != rowcount
-  # raise "resources != $resources" if resources != $resources
-  resources
-end
-
-if $0 == __FILE__
-  benchmark (ARGV.first || 10).to_i
-end
+$:.unshift('./lib')
+require 'eventmachine'
+require 'em-synchrony'
+require 'em-synchrony/pg'
+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) }
+    puts
+    b.report('parallel 90000/1:')  { parallel(repeat, 90000, 1) }
+    b.report('parallel 5000/5:')  { parallel(repeat, 5000, 5) }
+    b.report('parallel 2000/10:') { parallel(repeat, 2000, 10) }
+    b.report('parallel 1000/20:') { parallel(repeat, 1000, 20) }
+    puts
+    patch_blocking
+    b.report('blocking 90000/1:')  { parallel(repeat, 90000, 1) }
+    b.report('blocking 5000/5:')  { parallel(repeat, 5000, 5) }
+    b.report('blocking 2000/10:') { parallel(repeat, 2000, 10) }
+    b.report('blocking 1000/20:') { parallel(repeat, 1000, 20) }
+    patch_remove_blocking
+  end
+end
+
+def patch_remove_blocking
+  PG::EM::Client::Watcher.module_eval <<-EOE
+    alias_method :notify_readable, :original_notify_readable
+    undef :original_notify_readable
+  EOE
+end
+
+def patch_blocking
+  PG::EM::Client::Watcher.module_eval <<-EOE
+    alias_method :original_notify_readable, :notify_readable
+    def notify_readable
+      detach
+      begin
+        result = @client.get_last_result
+      rescue Exception => e
+        @deferrable.fail(e)
+      else
+        @deferrable.succeed(result)
+      end
+    end
+  EOE
+end
+
+# retrieve resources using single select query
+def single(repeat=1)
+  rowcount = 0
+  p = PGconn.new :dbname => $dbname, :host => 'localhost'
+  p.query('select count(*) from resources') do |result|
+    rowcount = result.getvalue(0,0).to_i
+  end
+  repeat.times do
+    p.query('select * from resources order by cdate') do |result|
+      $resources = result.values
+    end
+  end
+  # raise "invalid count #{$resources.length} != #{rowcount}" if $resources.length != rowcount
+end
+
+# retrieve resources using parallel queries
+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.query('select count(*) from resources') do |result|
+      rowcount = result.getvalue(0,0).to_i
+    end
+    offsets = (rowcount / chunk_size.to_f).ceil.times.map {|n| n*chunk_size }
+    repeat.times do
+      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
+    EM.stop
+  end
+  # raise "invalid count #{resources.length} != #{rowcount}" if resources.length != rowcount
+  # raise "resources != $resources" if resources != $resources
+  resources
+end
+
+if $0 == __FILE__
+  benchmark (ARGV.first || 10).to_i
+end

data/em-pg-client.gemspec

@@ -2,7 +2,7 @@ $:.unshift "lib"
 
 Gem::Specification.new do |s|
   s.name = "em-pg-client"
-  s.version = "0.1.1"
+  s.version = "0.2.0.pre.1"
   s.required_ruby_version = ">= 1.9.1"
   s.date = "#{Time.now.strftime("%Y-%m-%d")}"
   s.summary = "EventMachine PostgreSQL client"

data/lib/em-synchrony/pg.rb

@@ -1,45 +1,81 @@
-require 'pg/em'
-module PG
-  module EM
-    class Client
-      # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
-      # Licence:: MIT License
-      #
-      # =PostgreSQL Client for EM-Synchrony
-      #
-
-      # conform to *standard*
-      alias_method :aquery, :async_query
-
-      # fiber untangled version of theese methods:
-      # - exec (aliased as query)
-      # - exec_prepared
-      # - prepare
-      %w(exec exec_prepared prepare).each do |name|
-        class_eval <<-EOD
-          def #{name}(*args, &blk)
-            if ::EM.reactor_running?
-              df = async_#{name}(*args)
-              f = Fiber.current
-              df.callback { |res| f.resume(res) }
-              df.errback  { |err| f.resume(err) }
-
-              result = Fiber.yield
-              raise result if result.is_a?(::Exception)
-              if block_given?
-                yield result 
-              else
-                result
-              end
-            else
-              super(*args, &blk)
-            end
-          end
-        EOD
-
-      end
-
-      alias_method :query, :exec
-    end
-  end
-end
+require 'pg/em'
+module PG
+  module EM
+    class Client
+      # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
+      # Licence:: MIT License
+      #
+      # =PostgreSQL Client for EM-Synchrony
+      #
+
+      # conform to *standard*
+      alias_method :aquery, :async_query
+
+      # fiber untangled version of theese methods:
+      # - exec (aliased as query)
+      # - exec_prepared
+      # - prepare
+      %w(exec exec_prepared prepare reset self.connect).each do |name|
+        async_name = "async_#{name.split('.').last}"
+        class_eval <<-EOD
+          def #{name}(*args, &blk)
+            if ::EM.reactor_running?
+              df = #{async_name}(*args)
+              f = Fiber.current
+              df.callback { |res| f.resume(res) }
+              df.errback  { |err| f.resume(err) }
+
+              result = Fiber.yield
+              raise result if result.is_a?(::Exception)
+              if block_given?
+                yield result 
+              else
+                result
+              end
+            else
+              super(*args, &blk)
+            end
+          end
+        EOD
+      end
+
+      class << self
+        alias_method :new, :connect
+        alias_method :open, :connect
+        alias_method :setdb, :connect
+        alias_method :setdblogin, :connect
+      end
+
+      alias_method :query, :exec
+
+      def async_autoreconnect!(deferrable, error, &send_proc)
+         if async_autoreconnect && (@async_command_aborted || self.status != PG::CONNECTION_OK)
+          reset_df = async_reset
+          reset_df.errback { |ex| deferrable.fail(ex) }
+          reset_df.callback do
+            Fiber.new do
+              if on_autoreconnect
+                returned_df = on_autoreconnect.call(self, error)
+                if returned_df == false
+                  ::EM.next_tick { deferrable.fail(error) }
+                elsif returned_df.respond_to?(:callback) && returned_df.respond_to?(:errback)
+                  returned_df.callback { deferrable.protect(&send_proc) }
+                  returned_df.errback { |ex| deferrable.fail(ex) }
+                elsif returned_df.is_a?(Exception)
+                  ::EM.next_tick { deferrable.fail(returned_df) }
+                else
+                  deferrable.protect(&send_proc)
+                end
+              else
+                deferrable.protect(&send_proc)
+              end
+            end.resume
+          end
+        else
+          ::EM.next_tick { deferrable.fail(error) }
+        end
+      end
+
+    end
+  end
+end

data/lib/pg/em.rb

@@ -1,175 +1,348 @@
-require 'pg'
-module PG
-  module EM
-    # == PostgreSQL EventMachine client
-    #
-    # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
-    # Licence:: MIT License
-    #
-    #
-    # PG::EM::Client is a wrapper for PG::Connection which (re)defines methods:
-    #
-    # - +async_exec+ (alias: +async_query+)
-    # - +async_prepare+
-    # - +async_exec_prepared+
-    #
-    # and following:
-    #
-    # - +exec+ (alias: +query+)
-    # - +exec_prepared+
-    # - +prepare+
-    #
-    # which autodetects if EventMachine is running and uses appropriate
-    # (async or sync) method version.
-    #
-    # Async methods might try to reset connection on connection error,
-    # you won't even notice that (except for warning message from PG).
-    #
-    # To disable such behavior set:
-    #   client.async_autoreconnect = false
-    #
-    # or pass as new() hash argument:
-    #   PG::EM::Client.new database: 'bar', async_autoreconnect: false
-    #
-    # Otherwise nothing changes in PG::Connect API.
-    # See PG::Connect docs for arguments to above methods.
-    #
-    # *Warning:*
-    #
-    # +async_exec_prepared+ after +async_prepare+ should only be invoked on
-    # the *same* connection.
-    # If you are using connection pool, make sure to acquire single connection first.
-    #
-    class Client < PG::Connection
-
-      attr_accessor :async_autoreconnect
-      
-      # +on_reconnect+ is a user defined Proc that is called after a connection
-      # with the server has been re-established.
-      # It's invoked with +connection+ as first argument and original
-      # +exception+ that caused the reconnecting process as second argument.
-      #
-      # Certain rules should apply to on_reconnect proc:
-      #
-      # - +async_autoreconnect+ is switched off (do not try to change it from
-      #   inside on_reconnect proc).
-      # - If proc returns +false+ (explicitly, +nil+ is ignored)
-      #   the original +exception+ is raised and the send query command is
-      #   not invoked at all.
-      # - If return value responds to +callback+ and +errback+ methods
-      #   (like +Deferrable+), the send query command will be bound to this
-      #   deferrable's success callback. Otherwise the send query command is called
-      #   immediately after on_reconnect proc is executed.
-      # - Other return values are ignored.
-      #
-      # You may pass this proc as +:on_reconnect+ option to PG::EM::Client.new.
-      #
-      # Example:
-      #   pg.on_reconnect = proc do |conn, ex|
-      #     conn.prepare("birds_by_name", "select id, name from animals order by name where species=$1", ['birds'])
-      #   end
-      #
-      attr_accessor :on_reconnect
-
-      module Watcher
-        def initialize(client, deferrable)
-          @client = client
-          @deferrable = deferrable
-        end
-
-        def notify_readable
-          @client.consume_input
-          return if @client.is_busy
-          detach
-          begin
-            result = @client.get_last_result
-          rescue Exception => e
-            @deferrable.fail(e)
-          else
-            @deferrable.succeed(result)
-          end
-        end
-      end
-
-      def initialize(*args)
-        @async_autoreconnect = true
-        @on_reconnect = nil
-        if args.last.is_a? Hash
-          args.last.reject! do |key, value|
-            case key.to_s
-            when 'async_autoreconnect'
-              @async_autoreconnect = !!value
-              true
-            when 'on_reconnect'
-              @on_reconnect = value if value.respond_to? :call
-              true
-            end
-          end
-        end
-        super(*args)
-      end
-
-      %w(
-        exec          send_query
-        prepare       send_prepare
-        exec_prepared send_query_prepared
-          ).each_slice(2) do |name, send_name|
-
-        class_eval <<-EOD
-        def async_#{name}(*args, &blk)
-          df = ::EM::DefaultDeferrable.new
-          if block_given?
-            df.callback(&blk)
-            df.errback(&blk)
-          end
-          begin
-            #{send_name}(*args)
-          rescue PG::Error => e
-            if self.status != PG::CONNECTION_OK && async_autoreconnect
-              reset
-              if on_reconnect
-                begin
-                  self.async_autoreconnect = false
-                  returned_df = on_reconnect.call(self, e)
-                  raise e if returned_df == false
-                  if returned_df.respond_to?(:callback) && returned_df.respond_to?(:errback)
-                    returned_df.callback do
-                      #{send_name}(*args)
-                      ::EM.watch(self.socket, Watcher, self, df).notify_readable = true
-                    end
-                    returned_df.errback do |ex|
-                      df.fail(ex)
-                    end
-                    return df
-                  end
-                ensure
-                  self.async_autoreconnect = true
-                end
-              end
-              #{send_name}(*args) 
-            else
-              raise e
-            end
-          end
-          ::EM.watch(self.socket, Watcher, self, df).notify_readable = true
-          df
-        end
-        EOD
-
-        class_eval <<-EOD
-        def #{name}(*args, &blk)
-          if ::EM.reactor_running?
-            async_#{name}(*args, &blk)
-          else
-            super(*args, &blk)
-          end
-        end
-        EOD
-
-      end
-
-      alias_method :query, :exec
-      alias_method :async_query, :async_exec
-    end
-  end
-end
+require 'pg'
+module PG
+  module EM
+    class FeaturedDeferrable < ::EM::DefaultDeferrable
+      def initialize(&blk)
+        if block_given?
+          callback(&blk)
+          errback(&blk)
+        end
+      end
+      
+      def protect(fail_value = nil)
+        yield
+      rescue Exception => e
+        ::EM.next_tick { fail(e) }
+        fail_value
+      end
+      
+      def protect_and_succeed(fail_value = nil)
+        ret = yield
+      rescue Exception => e
+        ::EM.next_tick { fail(e) }
+        fail_value
+      else
+        ::EM.next_tick { succeed(ret) }
+        ret
+      end
+    end
+    # == PostgreSQL EventMachine client
+    #
+    # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
+    # Licence:: MIT License
+    #
+    #
+    # PG::EM::Client is a wrapper for PG::Connection which (re)defines methods:
+    #
+    # - +async_exec+ (alias: +async_query+)
+    # - +async_prepare+
+    # - +async_exec_prepared+
+    #
+    # and following:
+    #
+    # - +exec+ (alias: +query+)
+    # - +exec_prepared+
+    # - +prepare+
+    #
+    # which autodetects if EventMachine is running and uses appropriate
+    # (async or sync) method version.
+    #
+    # Additionally to the above, there are asynchronous methods defined for
+    # establishing connection and reseting it:
+    #
+    # - +Client.async_connect+
+    # - +async_reset+
+    #
+    # They are async equivalents of +Client.connect+ (which is also aliased
+    # by PG::Connection as +new+, +open+, +setdb+, +setdblogin+) and +reset+.
+    #
+    # Async methods might try to reset connection on connection error.
+    # You won't even notice that (except for warning message from PG).
+    # If you want to detect such event use +on_autoreconnect+ property.
+    #
+    # To disable such behavior set:
+    #   client.async_autoreconnect = false
+    #
+    # or pass as new() hash argument:
+    #   PG::EM::Client.new database: 'bar', async_autoreconnect: false
+    #
+    # Otherwise nothing changes in PG::Connect API.
+    # See PG::Connect docs for arguments to above methods.
+    #
+    # *Warning:*
+    #
+    # +async_exec_prepared+ after +async_prepare+ should only be invoked on
+    # the *same* connection.
+    # If you are using connection pool, make sure to acquire single connection first.
+    #
+    class Client < PG::Connection
+
+
+      # Connection timeout. Changing this property only affects
+      # +Client.async_connect+ and +async_reset+.
+      # However if passed as initialization option also affects blocking
+      # +Client.connect+ and +reset+.
+      attr_accessor :connect_timeout
+
+      # (EXPERIMENTAL)
+      # Aborts async command processing if waiting for response from server
+      # exceedes +query_timeout+ seconds. This does not apply to
+      # +Client.async_connect+ and +async_reset+. For those two use
+      # +connect_timeout+ instead.
+      #
+      # To enable it set to seconds (> 0). To disable: set to 0.
+      # You can also specify this as initialization option.
+      attr_accessor :query_timeout
+
+      # Enable/disable auto-reconnect feature (+true+/+false+).
+      # Default is +true+.
+      attr_accessor :async_autoreconnect
+
+      # +on_autoreconnect+ is a user defined Proc that is called after a connection
+      # with the server has been re-established.
+      # It's invoked with +connection+ as first argument and original
+      # +exception+ that caused the reconnecting process as second argument.
+      #
+      # Certain rules should apply to on_autoreconnect proc:
+      #
+      # - If proc returns +false+ (explicitly, +nil+ is ignored)
+      #   the original +exception+ is passed to +Defferable#fail+ and the send
+      #   query command is not invoked at all.
+      # - If return value is an instance of exception it is passed to
+      #   +Defferable#fail+ and the send query command is not invoked at all.
+      # - If return value responds to +callback+ and +errback+ methods
+      #   (like +Deferrable+), the send query command will be bound to this
+      #   deferrable's success callback. Otherwise the send query command is
+      #   called immediately after on_autoreconnect proc is executed.
+      # - Other return values are ignored and the send query command is called
+      #   immediately after on_autoreconnect proc is executed.
+      #
+      # You may pass this proc as +:on_autoreconnect+ option to PG::EM::Client.new.
+      #
+      # Example:
+      #   pg.on_autoreconnect = proc do |conn, ex|
+      #     conn.prepare("birds_by_name", "select id, name from animals order by name where species=$1", ['birds'])
+      #   end
+      #
+      attr_accessor :on_autoreconnect
+
+      # Used internally for marking connection as aborted on query timeout.
+      attr_accessor :async_command_aborted
+
+      module Watcher
+        def initialize(client, deferrable, send_proc)
+          @client = client
+          @deferrable = deferrable
+          @send_proc = send_proc
+          if (timeout = client.query_timeout) > 0
+            @timer = ::EM::Timer.new(timeout) do
+              detach
+              @client.async_command_aborted = true
+              IO.for_fd(@client.socket).close # break connection now (hack)
+              @deferrable.protect do
+                raise PG::Error, "query timeout expired (async)"
+              end
+            end
+          end
+        end
+
+        def notify_readable
+          @client.consume_input
+          return if @client.is_busy
+          @timer.cancel if @timer
+          detach
+          begin
+            result = @client.get_last_result
+          rescue PG::Error => e
+            @client.async_autoreconnect!(@deferrable, e, &@send_proc)
+          rescue Exception => e
+            @deferrable.fail(e)
+          else
+            @deferrable.succeed(result)
+          end
+        end
+      end
+
+      module ConnectWatcher
+        def initialize(client, deferrable, poll_method)
+          @client = client
+          @deferrable = deferrable
+          @poll_method = :"#{poll_method}_poll"
+          if (timeout = client.connect_timeout) > 0
+            @timer = ::EM::Timer.new(timeout) do
+              detach
+              @deferrable.protect do
+                raise PG::Error, "timeout expired (async)"
+              end
+            end
+          end
+        end
+
+        def notify_writable
+          poll_connection_and_check
+        end
+
+        def notify_readable
+          poll_connection_and_check
+        end
+
+        def poll_connection_and_check
+          case @client.__send__(@poll_method)
+          when PG::PGRES_POLLING_READING
+            self.notify_readable = true
+            self.notify_writable = false
+          when PG::PGRES_POLLING_WRITING
+            self.notify_writable = true
+            self.notify_readable = false
+          when PG::PGRES_POLLING_OK, PG::PGRES_POLLING_FAILED
+            @timer.cancel if @timer
+            detach
+            success = @deferrable.protect_and_succeed do
+              unless @client.status == PG::CONNECTION_OK
+                raise PG::Error, @client.error_message
+              end
+              @client
+            end
+          end
+        end
+      end
+
+      def self.parse_async_args(*args)
+        async_args = {
+          :@async_autoreconnect => true,
+          :@connect_timeout => 0,
+          :@query_timeout => 0,
+          :@on_autoreconnect => nil,
+          :@async_command_aborted => false,
+        }
+        if args.last.is_a? Hash
+          args.last.reject! do |key, value|
+            case key.to_s
+            when 'async_autoreconnect'
+              async_args[:@async_autoreconnect] = !!value
+              true
+            when 'on_reconnect'
+              raise ArgumentError.new("on_reconnect is no longer supported, use on_autoreconnect")
+            when 'on_autoreconnect'
+              async_args[:@on_autoreconnect] = value if value.respond_to? :call
+              true
+            when 'connect_timeout'
+              async_args[:@connect_timeout] = value.to_f
+              false
+            when 'query_timeout'
+              async_args[:@query_timeout] = value.to_f
+              true
+            end
+          end
+        end
+        async_args
+      end
+
+      # Attempt connection asynchronously.
+      # Pass the same arguments as to +Client.new+.
+      #
+      # Returns +deferrable+. Use it's +callback+ to obtain newly created and
+      # already connected +Client+ object.
+      # If block is provided it's bound to +callback+ and +errback+ of returned
+      # +deferrable+.
+      def self.async_connect(*args, &blk)
+        df = PG::EM::FeaturedDeferrable.new(&blk)
+        async_args = parse_async_args(*args)
+        conn = df.protect { connect_start(*args) }
+        if conn
+          async_args.each {|k, v| conn.instance_variable_set(k, v) }
+          ::EM.watch(conn.socket, ConnectWatcher, conn, df, :connect).poll_connection_and_check
+        end
+        df
+      end
+
+      # Attempt connection reset asynchronously.
+      # There are no arguments.
+      #
+      # Returns +deferrable+. Use it's +callback+ to handle success.
+      # If block is provided it's bound to +callback+ and +errback+ of returned
+      # +deferrable+.
+      def async_reset(&blk)
+        @async_command_aborted = false
+        df = PG::EM::FeaturedDeferrable.new(&blk)
+        ret = df.protect(:fail) { reset_start }
+        unless ret == :fail
+          ::EM.watch(self.socket, ConnectWatcher, self, df, :reset).poll_connection_and_check
+        end
+        df
+      end
+
+      def initialize(*args)
+        Client.parse_async_args(*args).each {|k, v| self.instance_variable_set(k, v) }
+        super(*args)
+      end
+
+      # Perform autoreconnect. Used internally.
+      def async_autoreconnect!(deferrable, error, &send_proc)
+        if async_autoreconnect && (@async_command_aborted || self.status != PG::CONNECTION_OK)
+          reset_df = async_reset
+          reset_df.errback { |ex| deferrable.fail(ex) }
+          reset_df.callback do
+            if on_autoreconnect
+              returned_df = on_autoreconnect.call(self, error)
+              if returned_df == false
+                ::EM.next_tick { deferrable.fail(error) }
+              elsif returned_df.respond_to?(:callback) && returned_df.respond_to?(:errback)
+                returned_df.callback { deferrable.protect(&send_proc) }
+                returned_df.errback { |ex| deferrable.fail(ex) }
+              elsif returned_df.is_a?(Exception)
+                ::EM.next_tick { deferrable.fail(returned_df) }
+              else
+                deferrable.protect(&send_proc)
+              end
+            else
+              deferrable.protect(&send_proc)
+            end
+          end
+        else
+          ::EM.next_tick { deferrable.fail(error) }
+        end
+      end
+
+      %w(
+        exec          send_query
+        prepare       send_prepare
+        exec_prepared send_query_prepared
+          ).each_slice(2) do |name, send_name|
+
+        class_eval <<-EOD
+        def async_#{name}(*args, &blk)
+          df = PG::EM::FeaturedDeferrable.new(&blk)
+          send_proc = proc do
+            #{send_name}(*args)
+            ::EM.watch(self.socket, Watcher, self, df, send_proc).notify_readable = true
+          end
+          begin
+            raise PG::Error, "previous query expired, need connection reset" if @async_command_aborted
+            send_proc.call
+          rescue PG::Error => e
+            async_autoreconnect!(df, e, &send_proc)
+          rescue Exception => e
+            ::EM.next_tick { df.fail(e) }
+          end
+          df
+        end
+        EOD
+
+        class_eval <<-EOD
+        def #{name}(*args, &blk)
+          if ::EM.reactor_running?
+            async_#{name}(*args, &blk)
+          else
+            super(*args, &blk)
+          end
+        end
+        EOD
+
+      end
+
+      alias_method :query, :exec
+      alias_method :async_query, :async_exec
+    end
+  end
+end