anchor.diff:    void update(Fruit fruit);
   
     @Select
  -  PagingIterable<Fruit> findById(String id);
  -}
  -----
  -
  -This class exposes operations that will be used in the REST service.
  -
  -Finally, the Mapper itself:
  +  PagingIterable<Fruit> findAll();
  +}
  +----
  +
  +This interface exposes operations that will be used in our REST service. Again, the annotation
  +`@Dao` comes from the DataStax Object Mapper, which will also automatically generate an
  +implementation of this interface for you.
  +
  +Note also the special return type of the `findAll` method,
  +link:https://docs.datastax.com/en/drivers/java/latest/com/datastax/oss/driver/api/core/PagingIterable.html[`PagingIterable`]:
  +it's the base type of result sets returned by the driver.
  +
  +Finally, let's create the a Mapper interface:
   
   [source,java]
   ----
  
positive.code: quarkus.cassandra.auth.password=s3cr3t
  ----
  
  === Connecting to a cloud DataStax Astra database
  
  When connecting to Astra, instead of providing a contact point and a datacenter, you should provide
  `secure-connect-bundle`, which should point to a valid path to an Astra secure connect bundle, as
  well as `username` and`password`, since authentication is always required on Astra clusters.
  
  A sample configuration for DataStax Astra should look like this:
  
  
negative.code: quarkus.cassandra.keyspace=k1
  ----
  
  === Advanced Driver Configuration
  
  You can configure other Java driver settings using `application.conf` or `application.json` files.
  They need to be located in the classpath of your application. All settings will be passed
  automatically to the underlying driver configuration mechanism. Settings defined in
  `application.properties` with the `quarkus.cassandra` prefix will have priority over settings
  defined in `application.conf` or `application.json`.
  
  To see the full list of settings, please refer to the
  link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[driver
  settings reference].
  
  == Running a Local Cassandra Database
  
  By default, the Cassandra client is configured to access a local Cassandra database on port 9042
  (the default Cassandra port).
  
  IMPORTANT: Make sure that the setting `quarkus.cassandra.local-datacenter` matches the datacenter of
  your Cassandra cluster.
  
  TIP: If you don't know the name of your local datacenter, this value can be found by running the
  following CQL query: `SELECT data_center FROM system.local`.
  
  If you want to use Docker to run a Cassandra database, you can use the following command to launch
  one in the background:
  
  [source,shell]
  ----
  docker run --name local-cassandra-instance -p 9042:9042 -d cassandra
  ----
  
  Next you need to create the keyspace and table that will be used by your application. If you are
  using Docker, run the following commands:
  
  [source,shell]
  ----
  docker exec -it local-cassandra-instance cqlsh -e "CREATE KEYSPACE IF NOT EXISTS k1 WITH replication = {'class':'SimpleStrategy', 'replication_factor':1}"
  docker exec -it local-cassandra-instance cqlsh -e "CREATE TABLE IF NOT EXISTS k1.fruit(name text PRIMARY KEY, description text)"
  ----
  
  You can also use the CQLSH utility to interactively interrogate your database:
  
  [source,shell]
  ----
  docker exec -it local-cassandra-instance cqlsh
  ----
  
  == Testing the REST API
  
  In the project root directory:
  
  - Run `mvn clean package` and then `java -jar ./target/cassandra-quarkus-quickstart-*-runner.jar` to start the application;
  - Or better yet, run the application in dev mode: `mvn clean quarkus:dev`.
  
  Now you can use curl commands to interact with the underlying REST API.
  
  To create a fruit:
  
  [source,shell]
  ----
  curl --header "Content-Type: application/json" \
    --request POST \
    --data '{"name":"apple","description":"red and tasty"}' \
    http://localhost:8080/fruits
  ----
  
  To retrieve fruits:
  
  [source,shell]
  ----
  curl -X GET http://localhost:8080/fruits
  ----
  
  == Creating a Frontend
  
  Now let's add a simple web page to interact with our `FruitResource`.
  
  Quarkus automatically serves static resources located under the `META-INF/resources` directory. In
  the `src/main/resources/META-INF/resources` directory, add a `fruits.html` file with the contents
  from link:src/main/resources/META-INF/resources/fruits.html[this file] in it.
  
  You can now interact with your REST service:
  
  * If you haven't done yet, start your application with `mvn clean quarkus:dev`;
  * Point your browser to `http://localhost:8080/fruits.html`;
  * Add new fruits to the list via the form.
  
  [[reactive]]
  == Reactive Programming with the Cassandra Client
  
  The
  link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[`QuarkusCqlSession`
  interface] gives you access to a series of reactive methods that integrate seamlessly with Quarkus
  and its reactive framework, Mutiny.
  
  TIP:  If you're not familiar with Mutiny, read the
  link:https://quarkus.io/guides/getting-started-reactive[Getting Started with Reactive guide] first.
  
  Let's rewrite our application using reactive programming with Mutiny.
  
  First, let's to declare another DAO interface that works in a reactive way:
  
  [source,java]
  ----
  @Dao
  public interface ReactiveFruitDao {
  
    @Update
    Uni<Void> updateAsync(Fruit fruit);
  
    @Select
    MutinyMappedReactiveResultSet<Fruit> findAll();
  }
  
  ----
  
  Note the usage of `MutinyMappedReactiveResultSet` - it is a specialized `Mutiny` type converted from
  the original `Publisher` returned by the driver, which also exposes a few extra methods, e.g. to
  obtain the query execution info. If you don't need anything in that interface, you can also simply
  declare your method to return `Multi`: `Multi<Fruit> findAll()`,
  
  Similarly, the method `updateAsync` returns a `Uni` - it is automatically converted from the
  original result set returned by the driver.
  