Add Ahead of Time Repository support

[mp911de]

We now provide AOT support to generate repository implementations during build-time for JDBC repository query methods.

Supported Features

• Derived query methods, @Query and named query methods
• @Modifying methods returning void, int, and long
• Pagination, Slice, Stream, and Optional return types
• DTO and Interface Projections
• Value Expressions

Limitations

• Methods accepting ScrollPosition (e.g. Keyset pagination) are not yet supported

Excluded methods

• CrudRepository, Querydsl, Query by Example, and other base interface methods as their implementation is provided by the base class respective fragments
• Methods whose implementation would be overly complex
  ** Methods accepting ScrollPosition (e.g. Keyset pagination)

Example repository:

interface UserRepository extends CrudRepository<User, Integer> {

	User findByFirstname(String name);

	Stream<User> streamByAgeGreaterThan(int age);

	@Query("SELECT * FROM MY_USER WHERE firstname = :name")
	User findByFirstnameAnnotated(String name);

	@Modifying
	@Query("delete from MY_USER where firstname = :firstname")
	void deleteWithoutResult(String firstname);

}

Generated fragment:

/**
 * AOT generated JDBC repository implementation for {@link UserRepository}.
 */
public class UserRepositoryImpl__AotRepository extends AotRepositoryFragmentSupport {
  private final RepositoryFactoryBeanSupport.FragmentCreationContext context;

  private final RowMapperFactory rowMapperFactory;

  private final JdbcAggregateOperations operations;

  public UserRepositoryImpl__AotRepository(RowMapperFactory rowMapperFactory,
      JdbcAggregateOperations operations,
      RepositoryFactoryBeanSupport.FragmentCreationContext context) {
    super(rowMapperFactory, operations, context);
    this.rowMapperFactory = rowMapperFactory;
    this.operations = operations;
    this.context = context;
  }

  public User findByFirstname(String name) {
    Criteria criteria = Criteria.where("firstname").is(name);
    StatementFactory.Selection selection = getStatementFactory().select(User.class);
    selection.filter(criteria);
    MapSqlParameterSource rawParameterSource = new MapSqlParameterSource();
    String query = selection.build(rawParameterSource);
    SqlParameterSource parameterSource = escapingParameterSource(rawParameterSource);

    RowMapper rowMapper = rowMapperFactory.create(User.class);
    Object result = queryForObject(query, parameterSource, rowMapper);
    return (User) convertOne(result, User.class);
  }

  public Stream<User> streamByAgeGreaterThan(int age) {
    Criteria criteria = Criteria.where("age").greaterThan(age);
    StatementFactory.Selection selection = getStatementFactory().select(User.class);
    selection.filter(criteria);
    MapSqlParameterSource rawParameterSource = new MapSqlParameterSource();
    String query = selection.build(rawParameterSource);
    SqlParameterSource parameterSource = escapingParameterSource(rawParameterSource);

    RowMapper rowMapper = rowMapperFactory.create(User.class);
    Stream result = getJdbcOperations().queryForStream(query, parameterSource, rowMapper);
    return (Stream<User>) convertMany(result, User.class);
  }

  public User findByFirstnameAnnotated(String name) {
    class ExpressionMarker{};
    String query = "SELECT * FROM MY_USER WHERE firstname = :name";
    MapSqlParameterSource parameterSource = new MapSqlParameterSource();
    getBindableValue(ExpressionMarker.class.getEnclosingMethod(), name, 0).bind("name", parameterSource);

    RowMapper rowMapper = rowMapperFactory.create(User.class);
    Object result = queryForObject(query, parameterSource, rowMapper);
    return (User) convertOne(result, User.class);
  }

  public void deleteWithoutResult(String firstname) {
    class ExpressionMarker{};
    String query = "delete from MY_USER where firstname = :firstname";
    MapSqlParameterSource parameterSource = new MapSqlParameterSource();
    getBindableValue(ExpressionMarker.class.getEnclosingMethod(), firstname, 0).bind("firstname", parameterSource);

    getJdbcOperations().update(query, parameterSource);
  }
}

Metadata (truncated):

{
  "name": "org.springframework.data.jdbc.repository.aot.UserRepository",
  "module": "JDBC",
  "type": "IMPERATIVE",
  "methods": [
    {
      "name": "findByFirstname",
      "signature": "public abstract org.springframework.data.jdbc.repository.aot.User org.springframework.data.jdbc.repository.aot.UserRepository.findByFirstname(java.lang.String)",
      "query": {
        "query": "SELECT \"MY_USER\".\"ID\" AS \"ID\", \"MY_USER\".\"AGE\" AS \"AGE\", \"MY_USER\".\"FIRSTNAME\" AS \"FIRSTNAME\" FROM \"MY_USER\" WHERE \"MY_USER\".\"FIRSTNAME\" = :firstname"
      }
    },
    {
      "name": "deleteWithoutResult",
      "signature": "public abstract void org.springframework.data.jdbc.repository.aot.UserRepository.deleteWithoutResult(java.lang.String)",
      "query": {
        "query": "delete from MY_USER where firstname = :firstname"
      }
    },
    {
      "name": "saveAll",
      "signature": "public abstract <S extends T> java.lang.Iterable<S> org.springframework.data.repository.CrudRepository.saveAll(java.lang.Iterable<S>)",
      "fragment": {
        "interface": "org.springframework.data.jdbc.repository.support.SimpleJdbcRepository",
        "fragment": "org.springframework.data.jdbc.repository.support.SimpleJdbcRepository"
      }
    }
  ]
}

[schauder]

I left some minor complaints.

In general this looks good to me.

[schauder]

I guess there is a "in the implementation" missing or something to that effect.

[schauder]

Shouldn't we call the other constructor, so we have a single place where initialization takes place?

[mp911de]

Calling this(…) potentially incurs a NullPointerException if tableEntity is null.

[schauder]

I would expect a ParameterBinding to be the binding of a value to a parameter. But this seems to be just a BindParameter: a parameter to which a value can be bound.

Correct?

[mp911de]

Actually, the ParameterBinding is intended as command to bind the parameter and not do this optionally. We have a similar naming setup in other modules. We could dive deeper into naming nuances if we wanted to. Feel free to create a ticket at the commons level.

[christophstrobl]

are we missing a @Nullable annotation here, or is the object != null check superfluous?

[christophstrobl]

IMO it is confusing to have something called parameterNames that contains a starting colon which influences the method called when being used in the CodeBlock via $L later on.

[christophstrobl]

$S$L magic method call switch via parameter names mentioned already above.

[christophstrobl]

should we use string formatting to bypass more expressive use of the builder API? Puts additional cognitive load on the reader having to deal with 2 placeholder patterns and a dynamic result type ref.

[christophstrobl]

do we need that ($1T) cast to do satisfy the compiler? (Optional) Optional.ofNullable(...) looks strange though.

[mp911de]

We have a bit of general dynamic in row mappers as we can have user-specified row mappers that do not necessarily comply with the RowMapper<ReturnType> declaration and we can end up with slightly different typing. Therefore, we broadly cast types to make it work now and refine typing later on, especially once we have a fluent API that would remove the need for broad casting.

[christophstrobl]

indexed placeholders maybe?