anchor.diff:      .mapTo(LocalDate.class)
       .findOnly();
   ----
  -
  -==== LIKE clauses
  -
  -Due to a built-in safety mechanism, `LIKE` clauses and argument binding
  -don't work together intuitively and must be written a particular way. The following
  -is what users would intuitively try to do:
  -
  -[source,java]
  -----
  -handle.createQuery("select name from things
  -where name like '%:search%'")
  -    .bind("search", "foo")
  -    .mapTo(String.class)
  -    .list()
  -----
  -
  -Firstly, this query would try to select `where name like '%:search%'`
  -_literally_, without binding any arguments. This is because proper `SqlParser`
  -implementations do not bind arguments _inside string literals_.
  -
  -Secondly, Jdbi has your back. This query will throw an exception,
  -because we don't allow unused bindings by default. Of course, if you use
  -the parameter somewhere else in the query and the `SqlParser` binds it,
  -then this check won't save you.
  -
  -The solution is to use SQL string concatenation:
  -
  -[source,java]
  -----
  -handle.createQuery("select name from things
  -where name like '%' || :search || '%'")
  -    .bind("search", "foo")
  -    .mapTo(String.class)
  -    .list()
  -----
  -
  -[NOTE]
  -Check the string concatenation syntax of your database before doing this.
   
   === Templating
   
  
positive.code: [NOTE]
  _Binding_ is a term specifically related to _Arguments_ only. _Attributes_ are involved in _rendering_ a query _template_ using a _TemplateEngine_ to perform String-wise manipulations on a query before it is interpreted as SQL.
  
  ==== Positional Arguments
  
  When a SQL statement uses `?` tokens, Jdbi can bind a values to parameters
  
negative.code:   `TupleMappers` must be configured properly i.e. all non row-mapped
    tuple indices must be provided with a column configuration!
  
  == Cookbook
  
  This section includes examples of various things you might like to do with `Jdbi`.
  
  === LIKE clauses with Parameters
  
  Since JDBC (and therefore `Jdbi`) does not allow binding parameters into the middle of string literals,
  you cannot interpolate bindings into `LIKE` clauses (`LIKE '%:param%'`).
  
  Incorrect usage:
  
  [source,java]
  ----
  handle.createQuery("select name from things
  where name like '%:search%'")
      .bind("search", "foo")
      .mapTo(String.class)
      .list()
  ----
  
  This query would try to select `where name like '%:search%'` _literally_, without binding any arguments.
  This is because JDBC drivers will not bind arguments _inside string literals_.
  
  It never gets that far, though -- this query will throw an exception,
  because we don't allow unused argument bindings by default.
  
  The solution is to use SQL string concatenation:
  
  [source,java]
  ----
  handle.createQuery("select name from things
  where name like '%' || :search || '%'")
      .bind("search", "foo")
      .mapTo(String.class)
      .list()
  ----
  
  Now, `search` can be properly bound as a parameter to the statement, and it all works as desired.
  
  [NOTE]
  Check the string concatenation syntax of your database before doing this.
  
  == Advanced Topics
  
  === Compiling with Parameter Names
  