em-pg-client-12 0.3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93743ff68b0f04bdcff75b78165fbcbeafc20b96
+  data.tar.gz: a05e6cb106bcc02666bc57b9ee98c301d70839c0
+SHA512:
+  metadata.gz: 73384a9e88c54ffbc721b00aadded48d82697c128d23bb24679b5196da71a4b29e6432ab19242706dc0ab42d5cc53147ffaf08fe58189181e0d31e3a0166b636
+  data.tar.gz: 47a95833438b11d1e142956125b5bed1c22446f7ecb307d9d82ad8231466c96bb30f06326b227ac2a2484cfbc04faaeb627cd6773dd9b92a2641febdb1b558e6

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,32 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+env:
+  - PGVERSION=9.3 PGBUILD=9.3.4-1-linux-x64
+  - PGVERSION=9.0 PGBUILD=9.0.17-1-linux-x64
+  - PGVERSION=8.4 PGBUILD=8.4.21-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/.yardopts

@@ -0,0 +1 @@
+lib/pg/em/client/*.rb  lib/pg/em/*.rb lib/pg/*.rb - benchmarks/*.rb BENCHMARKS.md LICENSE HISTORY.md

data/BENCHMARKS.md

@@ -0,0 +1,91 @@
+Benchmarking
+============
+
+Environment
+-----------
+
+The machine running tests is Linux CentOS 2.6.18-194.32.1.el5xen #1 SMP with
+Quad Core Xeon X3360 @ 2.83GHz, 4GB RAM.
+
+Postgres server version: 9.0.3
+Postgres pqlib version: 9.3
+
+Fully Asynchronous vs. poor man's async
+---------------------------------------
+
+The following {file:benchmarks/em_pg.rb benchmark} compares fully
+asynchronous implementation (`em-pg-client`) versus blocking em-pg drivers.
+
+The goal of the test is to retrieve (~80000) rows from the same table with
+a lot of text data, in chunks, using parallel connections.
+
+The parallel method uses synchrony for simplicity.
+
+* `single` is (eventmachine-less) job for retrieving a whole data table in
+  one simple query "select * from resources"
+* `parallel` chunk_row_count / concurrency] uses em-pg-client for retrieving
+  result in chunks by `chunk_row_count` rows and using `concurrency` parallel
+  connections
+* `blocking` chunk_row_count / concurrency is similiar to `parallel` except
+  that it uses special patched version of library that uses blocking
+  PGConnection methods
+
+
+```
+    >> benchmark 1000
+                              user     system      total        real
+    single:              80.970000   0.350000  81.320000 (205.592592)
+
+    parallel 90000/1:    87.380000   0.710000  88.090000 (208.171564)
+    parallel 5000/5:     84.250000   3.760000  88.010000 (141.031289)
+    parallel 2000/10:    90.190000   4.970000  95.160000 (152.844950)
+    parallel 1000/20:    97.070000   5.390000 102.460000 (212.358631)
+
+    blocking 90000/1:    93.590000   0.610000  94.200000 (230.190776)
+    blocking 5000/5:     79.930000   1.810000  81.740000 (223.342432)
+    blocking 2000/10:    76.990000   2.820000  79.810000 (225.347169)
+    blocking 1000/20:    78.790000   3.230000  82.020000 (225.949107)
+```
+
+As we can see the gain from using asynchronous em-pg-client while
+using `parallel` queries is noticeable (up to ~30%).
+
+The `blocking` client however doesn't gain much from parallel execution.
+This was expected because it freezes eventmachine until the whole
+dataset is consumed by the client.
+
+
+Threads vs. Fibers Streaming Benchmark
+--------------------------------------
+
+The following {file:benchmarks/single_row_mode.rb benchmark} compares
+performance of parallel running threads using vanilla PG::Connection driver
+versus EventMachine driven parallel Fibers using PG::EM::Client v0.3.2.
+
+Each thread/fiber retrieves first 5000 rows from the same table with
+a lot of text data in a `single_row_mode`. After 5000 rows is retrieved
+the connection is being reset. The process is repeated after all parallel
+running threads/fibers finish their task.
+
+Both Thread and Fiber versions use the same chunk of code to retrieve rows.
+
+```
+    >> benchmark 400
+                               user     system      total        real
+    threads 400x1:        24.970000   1.090000  26.060000 ( 30.683818)
+    threads 80x5:         24.730000   7.020000  31.750000 ( 51.402710)
+    threads 40x10:        22.880000   7.460000  30.340000 ( 52.548910)
+    threads 20x20:        22.220000   7.130000  29.350000 ( 53.911111)
+    threads 10x40:        22.570000   7.620000  30.190000 ( 54.111841)
+
+    fibers  400x1:        26.040000   1.060000  27.100000 ( 31.619598)
+    fibers  80x5:         28.690000   1.140000  29.830000 ( 33.025573)
+    fibers  40x10:        28.790000   1.280000  30.070000 ( 33.498418)
+    fibers  20x20:        29.100000   1.210000  30.310000 ( 33.289344)
+    fibers  10x40:        29.220000   1.340000  30.560000 ( 33.691188)
+```
+
+```
+    AxB - repeat A times running B parallel threads/fibers.
+```
+

data/Gemfile

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

data/HISTORY.md

@@ -0,0 +1,107 @@
+0.3.4
+
+- spec: fix em_client_on_connect and em_connection_pool tests
+- asynchronous wait_for_notify and wait_for_notify_defer with specs
+
+0.3.3
+
+- rake: console for debugging
+- added on_connect callback
+- given block to ConnectionPool.new set as on_connect option fallback
+- spec: connection pool database tests
+- spec: on_connect tests
+- spec: on_connect + on_autoreconnect auto re-connect tests
+- spec: added travis rvm 2.1.0 and updated postgres server versions
+- sugar: on_connect and on_autoreconnect block setters
+
+0.3.2
+
+- fix: asynchronous get_result performance
+- fix+specs: query_timeout timer is canceled on connection breakdown
+- comply with pg+specs: asynchronous get_result and get_last_result return nil
+  when connection status is not ok
+
+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
+- works on windows (with ruby 2.0+): uses PGConn#socket_io object instead of
+  #socket file descriptor
+- socket watch handler is not being detached between command calls
+- no more separate em and em-synchrony client
+- api changes: async_exec and async_query command are now fiber-synchronized
+- api changes: other async_* methods are removed or deprecated
+- api changes: asynchronous methods renamed to *_defer
+- transaction() helper method that can be called recursively
+- requirements updated: eventmachine >~ 1.0.0, pg >= 0.17.0, ruby >= 1.9.2
+- spec: more auto re-connect test cases
+- spec: more tests for connection establishing
+- comply with pg: do not close the client on connection failure
+- comply with pg: asynchronous connect_timeout fallbacks to environment variable
+- fix: auto re-connect raises an error if the failed connection had unfinished
+  transaction state
+- yardoc docs
+
+0.2.1
+
+- support for pg >= 0.14 native PG::Result#check
+- support for pg >= 0.14 native PG::Connection#set_default_encoding
+- fix: connection option Hash argument was modified by Client.new and Client.async_connect
+
+0.2.0
+
+- disabled async_autoreconnect by default unless on_autoreconnect is set
+- async_connect sets #internal_encoding to Encoding.default_internal
+- fix: finish connection on async connect_timeout
+- nice errors generated on missing dependencies
+- blocking #reset() should clear async_command_aborted flag
+- less calls to #is_busy in Watcher#notify_readable
+- async_describe_portal() + specs
+- async_describe_prepared() + specs
+
+0.2.0.pre.3
+
+- status() returns CONNECTION_BAD for connections with expired query
+- spec: query timeout expiration
+- non-blocking result processing for multiple data query statements sent at once
+- refine code in em-synchrony/pg
+- spec: more detailed tests
+- spec: async_connect
+- spec: autoreconnect
+
+0.2.0.pre.2
+
+- errors from consume_input fails deferrable
+- query_timeout now measures only network response timeout,
+  so it's not fired for large datasets
+
+0.2.0.pre.1
+
+- added query_timeout feature for async query commands
+- added connect_timeout property for async connect/reset
+- fix: async_autoreconnect for tcp/ip connections
+- fix: async_* does not raise errors; errors handled by deferrable
+- rework async_autoreconnect in fully async manner
+- added async_connect() and async_reset()
+- API change: on_reconnect -> on_autoreconnect
+
+0.1.1
+
+- added on_reconnect callback
+- docs updated
+- added development dependency for eventmachine >= 1.0.0.beta.1
+- added separate client specs for eventmachine = 0.12.10
+- added error checking to eventmachine specs
+
+0.1.0
+
+- first release

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Rafal Michalski (rafal at yeondir dot com)
+
+MIT License
+
+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

@@ -0,0 +1,456 @@
+em-pg-client
+============
+
+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__ 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
+with PG::Connection.
+
+The real difference begins when you turn the EventMachine reactor on.
+
+```ruby
+  require 'pg/em'
+  
+  pg = PG::EM::Client.new dbname: 'test'
+
+  # no async
+  pg.query('select * from foo') do |result|
+    puts Array(result).inspect
+  end
+
+  # asynchronous
+  EM.run do
+    Fiber.new do
+      pg.query('select * from foo') do |result|
+        puts Array(result).inspect
+      end
+      EM.stop
+    end.resume
+  end
+
+  # asynchronous + deferrable
+  EM.run do
+    df = pg.query_defer('select * from foo')
+    df.callback { |result|
+      puts Array(result).inspect
+      EM.stop
+    }
+    df.errback {|ex|
+      raise ex
+    }
+    puts "sent"
+  end
+```
+
+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.
+* 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.
+* Configurable timeouts (connect or execute) of asynchronous processing.
+* 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][Issue 7]).
+* Supports asynchronous query data processing in single row mode
+  ([issue #12][Issue 12]). See {file:BENCHMARKS.md BENCHMARKING}.
+* __New__ - asynchronous implementation of wait_for_notify
+
+Requirements
+------------
+
+* ruby >= 1.9.2 (tested: 2.1.0, 2.0.0-p353, 1.9.3-p374, 1.9.2-p320)
+* https://bitbucket.org/ged/ruby-pg >= 0.17.0
+* [PostgreSQL](http://www.postgresql.org/ftp/source/) RDBMS >= 8.4
+* http://rubyeventmachine.com >= 1.0.0
+*  [EM-Synchrony](https://github.com/igrigorik/em-synchrony)
+  (optional - not needed for any of the client functionality,
+  just wrap your code in a fiber)
+
+Install
+-------
+
+```sh
+  $ [sudo] gem install em-pg-client
+```
+
+#### Gemfile
+
+```ruby
+  gem "em-pg-client", "~> 0.3.4"
+```
+
+#### Github
+
+```
+  git clone git://github.com/royaltm/ruby-em-pg-client.git
+```
+
+Usage
+-----
+
+### PG::Connection commands adapted to the EventMachine
+
+#### Asynchronous, the EventMachine style:
+
+* `Client.connect_defer` (singleton method)
+* `reset_defer`
+* `exec_defer` (alias: `query_defer`)
+* `prepare_defer`
+* `exec_prepared_defer`
+* `describe_prepared_defer`
+* `describe_portal_defer`
+
+For arguments of these methods consult their original (without the `_defer`
+suffix) counterparts in the
+[PG::Connection](http://deveiate.org/code/pg/PG/Connection.html) manual.
+
+Use `callback` with a block on the returned deferrable object to receive the
+result. In case of `connect_defer` and `reset_defer` the result is an instance
+of the {PG::EM::Client}. The received client is in connected state and ready
+for the queries. Otherwise an instance of the
+[PG::Result](http://deveiate.org/code/pg/PG/Result.html) is received. You may
+`clear` the obtained result object or leave it to `gc`.
+
+To detect an error in the executed command call `errback` on the deferrable
+with a block. You should expect an instance of the raised `Exception`
+(usually PG::Error) as the block argument.
+
+#### Reactor sensing methods, EM-Synchrony style:
+
+* `Client.new` (singleton, alias: `connect`, `open`, `setdb`, `setdblogin`)
+* `reset`
+* `exec` (alias: `query`, `async_exec`, `async_query`)
+* `prepare`
+* `exec_prepared`
+* `describe_prepared`
+* `describe_portal`
+
+The above methods call `*_defer` counterparts of themselves and `yield`
+from the current fiber awaiting for the result. The PG::Result instance
+(or PG::EM::Client for `new`) is then returned to the caller.
+If a code block is given, it will be passed the result as an argument.
+In that case the value of the block is returned instead and the result is
+being cleared (or in case of `new` - client is being closed) after block
+terminates.
+
+These methods check if EventMachine's reactor is running and the current fiber
+is not a root fiber. Otherwise the parent (thread-blocking) PG::Connection
+methods are being called.
+
+You can call asynchronous, fiber aware and blocking methods without finishing
+the connection. You only need to start/stop EventMachine in between the
+asynchronous calls.
+
+Although the [em-synchrony](https://github.com/igrigorik/em-synchrony/)
+provides very nice set of tools for the untangled EventMachine, you don't
+really require it to fully benefit from the PG::EM::Client. Just wrap your
+asynchronous code in a fiber:
+
+    Fiber.new { ... }.resume
+
+#### Special options
+
+There are four special connection options and one of them is a standard `pg`
+option used by the async methods. You may pass them as one of the __hash__
+options to {PG::EM::Client.new} or {PG::EM::Client.connect_defer} or simply
+use the accessor methods to change them on the fly.
+
+The options are:
+
+* `connect_timeout`
+* `query_timeout`
+* `async_autoreconnect`
+* `on_autoreconnect`
+* `on_connect`
+
+Only `connect_timeout` is a standard `libpq` option, although changing it with
+the accessor method affects asynchronous functions only.
+See {PG::EM::Client} for more details.
+
+#### Handling errors
+
+Exactly like in `pg`:
+
+```ruby
+  EM.synchrony do
+    begin
+      pg.query('smellect 1')
+    rescue => e
+      puts "error: #{e.inspect}"
+    end
+    EM.stop
+  end
+```
+
+with *_defer methods:
+
+```ruby
+  EM.run do
+    pg.query_defer('smellect 1') do |ret|
+      if ret.is_a?(Exception)
+        puts "PSQL error: #{ret.inspect}"
+      end
+    end
+  end
+```
+
+or
+
+```ruby
+  EM.run do
+    pg.query_defer('smellect 1').callback do |ret|
+      puts "do something with #{ret}"
+    end.errback do |err|
+      puts "PSQL error: #{err.inspect}"
+    end
+  end
+```
+
+### Auto re-connecting in asynchronous mode
+
+Connection reset is done in a non-blocking manner using `reset_defer` internally.
+
+```ruby
+  EM.run do
+    Fiber.new do
+      pg = PG::EM::Client.new async_autoreconnect: true
+
+      try_query = lambda do
+        pg.query('select * from foo') do |result|
+          puts Array(result).inspect
+        end
+      end
+
+      try_query.call
+      system 'pg_ctl stop -m fast'
+      system 'pg_ctl start -w'
+      try_query.call
+
+      EM.stop
+    end.resume
+  end
+```
+
+to enable this feature call:
+
+```ruby
+  pg.async_autoreconnect = true
+```
+
+Additionally the `on_autoreconnect` callback may be set on the connection.
+It's being invoked after successfull connection restart, just before the
+pending command is sent again to the server.
+
+### Server-sent notifications - async style
+
+Not surprisingly, there are two possible ways to wait for notifications,
+one with a deferrable:
+
+```ruby
+  pg = PG::EM::Client.new
+  EM.run do
+    pg.wait_for_notify_defer(7).callback do |notify|
+      if notify
+        puts "Someone spoke to us on channel: #{notify[:relname]} from #{notify[:be_pid]}"
+      else
+        puts "Too late, 7 seconds passed"
+      end
+    end.errback do |ex|
+      puts "Connection to deep space lost..."
+    end
+    pg.query_defer("LISTEN deep_space") do
+      pg.query_defer("NOTIFY deep_space") do
+        puts "Reaching out... to the other worlds"
+      end
+    end
+  end
+```
+
+and the other, using fibers:
+
+```ruby
+  EM.synchrony do
+    pg = PG::EM::Client.new
+    EM::Synchrony.next_tick do
+      pg.query('LISTEN "some channel"')
+      pg.query('SELECT pg_notify($1::text,$2::text)', ['some channel', 'with some message'])
+    end
+    pg.wait_for_notify(10) do |channel, pid, payload|
+      puts "I've got notification on #{channel} #{payload}."
+    end.tap do |name|
+      puts "Whatever, I've been waiting too long already" if name.nil?
+    end
+  end
+```
+
+As you might have noticed, one does not simply wait for notifications,
+but one can also run some queries on the same connection at the same time,
+if one wishes so.
+
+### Connection Pool
+
+Forever alone? Not anymore! There is a dedicated {PG::EM::ConnectionPool}
+class with dynamic pool for both types of asynchronous commands (deferral
+and fiber-synchronized).
+
+It also provides a #transaction method which locks the in-transaction
+connection to the calling fiber and allows to execute commands
+on the same connection within a transaction block. The transactions may
+be nested. See also docs for the {PG::EM::Client#transaction} method.
+
+#### Parallel async queries
+
+```ruby
+  require 'pg/em/connection_pool'
+  require 'em-synchrony'
+
+  EM.synchrony do
+    pg = PG::EM::ConnectionPool.new(size: 2, dbname: 'test')
+
+    multi = EM::Synchrony::Multi.new
+    multi.add :foo, pg.query_defer('select pg_sleep(1)')
+    multi.add :bar, pg.query_defer('select pg_sleep(1)')
+
+    start = Time.now
+    res = multi.perform
+    # around 1 sec.
+    puts Time.now - start
+
+    EM.stop
+  end
+```
+
+#### Fiber Concurrency
+
+```ruby
+  require 'pg/em/connection_pool'
+  require 'em-synchrony'
+  require "em-synchrony/fiber_iterator"
+
+  EM.synchrony do
+    concurrency = 5
+    queries = (1..10).map {|i| "select pg_sleep(1); select #{i}" }
+
+    pg = PG::EM::ConnectionPool.new(size: concurrency, dbname: 'test')
+
+    start = Time.now
+    EM::Synchrony::FiberIterator.new(queries, concurrency).each do |query|
+      pg.query(query) do |result|
+        puts "recv: #{result.getvalue(0,0)}"
+      end
+    end
+    # around 2 secs.
+    puts Time.now - start
+
+    EM.stop
+  end
+```
+
+API Changes
+-----------
+
+### 0.2.x -> 0.3.x
+
+There is a substantial difference in the API between this and the previous
+releases. The idea behind it was to make this implementation as much
+compatible as possible with the threaded `pg` interface.
+E.g. the `#async_exec` is now an alias to `#exec`.
+
+The other reason was to get rid of the ugly em / em-synchrony duality.
+
+* There is no separate em-synchrony client version anymore.
+* The methods returning Deferrable have now the `*_defer` suffix.
+* The `#async_exec` and `#async_query` (in <= 0.2 they were deferrable methods)
+  are now aliases to `#exec`.
+* The command methods `#exec`, `#query`, `#exec_*`, `#describe_*` are now
+  em-synchrony style methods (fiber-synchronized).
+* The following methods were removed:
+
+    - `#async_prepare`,
+    - `#async_exec_prepared`,
+    - `#async_describe_prepared`,
+    - `#async_describe_portal`
+
+  as their names were confusing due to the unfortunate `#async_exec`.
+
+* The `async_connect` and `#async_reset` are renamed to `connect_defer` and `#reset_defer`
+  respectively.
+
+### 0.1.x -> 0.2.x
+
+* `on_reconnect` renamed to more accurate `on_autoreconnect`
+  (well, it's not used by PG::EM::Client#reset call).
+* `async_autoreconnect` is `false` by default if `on_autoreconnect`
+  is __not__ specified as initialization option.
+
+Bugs/Limitations
+----------------
+
+* no async support for COPY commands (`get_copy_data`,  `put_copy_data`)
+* actually no ActiveRecord support (you are welcome to contribute).
+
+TODO:
+-----
+
+* more convenient streaming API
+* implement EM adapted version of `get_copy_data`, `put_copy_data`
+* ORM (ActiveRecord and maybe Datamapper) support as separate projects
+
+More Info
+---------
+
+This implementation makes use of non-blocking:
+[PGConn#is_busy](http://deveiate.org/code/pg/PG/Connection.html#method-i-is_busy) and
+[PGConn#consume_input](http://deveiate.org/code/pg/PG/Connection.html#method-i-consume_input) methods.
+Depending on the size of queried results and the concurrency level, the gain
+in overall speed and responsiveness of your application might be actually quite huge.
+See {file:BENCHMARKS.md BENCHMARKING}.
+
+Thanks
+------
+
+The greetz go to:
+
+* [Authors](https://bitbucket.org/ged/ruby-pg/wiki/Home#!copying) of __pg__
+  driver (especially for its async-api)
+* Francis Cianfrocca for great reactor framework
+  [EventMachine](https://github.com/eventmachine/eventmachine)
+* Ilya Grigorik [igrigorik](https://github.com/igrigorik) for
+  [untangling EM with Fibers](http://www.igvita.com/2010/03/22/untangling-evented-code-with-ruby-fibers/)
+* Peter Yanovich [fl00r](https://github.com/fl00r) for the
+  [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).
+
+[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
+[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