anchor.diff:  ```
   Tuples are defined from `Tuple2` to `Tuple7` and for above that to `TupleN`.
   
  -Automap
  ---------------
  += Automap
  +
   To map the result set values to an interface, first declare an interface:
   
   ```java
  
positive.code: ```
  While you are processing reactively you should avoid blocking calls but domain boundaries sometimes force this to happen (e.g. accumulate the results and return them as xml over the network from a web service call). Bear in mind also that if you are worried about the complexities of debugging RxJava programs then you might wish to make brief limited forays into reactive code. That's completely fine too. What you lose in efficiency you may gain in simplicity.
  
  Asynchrony
  ------------
  The query flowables returned by the `Database` all run asynchronously. This is required because of the use of non-blocking connection pools. When a connection is returned to the pool and then checked-out by another query that checkout must occur on a different thread so that stack overflow does not occur. See the [Non-blocking connection pools](README.md=non-blocking-connection-pools) section for more details.
  
  
  Nulls
  ---------
  RxJava2 does not support streams of nulls. If you want to represent nulls in your stream then use `java.util.Optional`.
  
  In the special case where a single nullable column is being returned and mapped to a class via `getAs` you should instead use `getAsOptional`:
  
negative.code: 
  Each time you call `Database.test(maxPoolSize)` you will have a fresh new database to play with that is loaded with data as described above.
  
  = A query example
  
  Let's use a `Database` instance to perform a select query on the `Person` table and write the names to the console:
  
  ```java
  