anchor.diff:  
   include::./attributes.adoc[]
   
  -Many projects that use data require connections to a database.
  -The main way of obtaining connections to a database is to use a datasource.
  -
  -In Quarkus, the out of the box datasource and connection pooling implementation is https://agroal.github.io/[Agroal].
  +Many projects that use data require connections to a relational database.
  +
  +The main way of obtaining connections to a database is to use a datasource and configure a JDBC driver.
  +
  +In Quarkus, the preferred datasource and connection pooling implementation is https://agroal.github.io/[Agroal].
  +
  +Agroal is a modern, light weight connection pool implementation designed for very high performance and scalability,
  +and features first class integration with the other components in Quarkus, such as security, transaction management components, health metrics.
   
   This guide will explain how to:
   
   * configure a datasource, or multiple datasources
   * how to obtain a reference to those datasources in code
  +* which pool tuning configuration properties are available
   
   == Prerequisites
   
  -To complete this guide, you need:
  +To complete this guide, you will need:
   
   * less than 10 minutes
   * an IDE
  
positive.code:     -Dpath="/hello"
  ----
  
  It generates:
  
  * the Maven structure
  * a landing page accessible on `http://localhost:8080`
  * example `Dockerfile` files for both `native` and `jvm` modes
  * the application configuration file
  * an `org.acme.datasource.GreetingResource` resource
  * an associated test
  
  == Adding maven dependencies
  
  
negative.code: 
  This behavior can be disabled via the property `quarkus.datasource.health.enabled`.
  
  == Narayana Transaction Manager integration
  
  If the Narayana JTA extension is also available, integration is automatic.
  
  You can override this by setting the `transactions` configuration property - see the <<configuration-reference, Configuration Reference>> below.
  
  
  [[in-memory-databases]]
  == Testing with in-memory databases
  
  Some databases like H2 and Derby are commonly used in "embedded mode" as a facility to run quick integration tests.
  
  Our suggestion is to use the real database you intend to use in production; container technologies made this simple enough so you no longer have an excuse. Still, there are sometimes
  good reasons to also want the ability to run quick integration tests using the JVM powered databases,
  so this is possible as well.
  
  It is important to remember that when configuring H2 (or Derby) to use the embedded engine,
  this will work as usual in JVM mode but such an application will not compile into a native image, as the Quarkus extensions only cover for making the JDBC client code compatible with the native compilation step: embedding the whole database engine into a native image is currently not implemented.
  
  If you plan to run such integration tests in the JVM exclusively, it will of course work as usual.
  
  If you want the ability to run such integration test in both JVM and/or native images, we have some cool helpers for you: just add either `@QuarkusTestResource(H2DatabaseTestResource.class)` or `@QuarkusTestResource(DerbyDatabaseTestResource.class)` on any class in your integration tests, this will make sure the testsuite starts (and stops) the embedded database into a separate process as necessary to run your tests.
  
  These additional helpers are provided by the artifacts having Maven coordinates `io.quarkus:quarkus-test-h2:{quarkus-version}` and `io.quarkus:quarkus-test-derby:{quarkus-version}`, respectively for H2 and Derby.
  
  Follows an example for H2:
  
  [source,java]
  ----
  package my.app.integrationtests.db;
  
  import io.quarkus.test.common.QuarkusTestResource;
  import io.quarkus.test.h2.H2DatabaseTestResource;
  
  @QuarkusTestResource(H2DatabaseTestResource.class)
  public class TestResources {
  }
  ----
  
  This will allow you to test your application even when it's compiled into a native image,
  while the database will run in the JVM as usual.
  
  Connect to it using:
  
  [source]
  ----
  quarkus.datasource.url=jdbc:h2:tcp://localhost/mem:test
  quarkus.datasource.driver=org.h2.Driver
  ----
  
  [[configuration-reference]]
  == Agroal Configuration Reference
  