Package io.micronaut.data.runtime.operations.internal.sql

Class AbstractSqlRepositoryOperations<RS,PS,Exc extends Exception>

java.lang.Object
io.micronaut.data.runtime.operations.internal.AbstractRepositoryOperations
io.micronaut.data.runtime.operations.internal.sql.AbstractSqlRepositoryOperations<RS,PS,Exc>
Type Parameters:
RS - The result set type
PS - The prepared statement type
Exc - The exception type
All Implemented Interfaces:
io.micronaut.context.ApplicationContextProvider, HintsCapableRepository, MethodContextAwareStoredQueryDecorator, PreparedQueryDecorator
Direct Known Subclasses:
DefaultJdbcRepositoryOperations
@Internal public abstract class AbstractSqlRepositoryOperations<RS,PS,Exc extends Exception> extends AbstractRepositoryOperations implements io.micronaut.context.ApplicationContextProvider, PreparedQueryDecorator, MethodContextAwareStoredQueryDecorator, HintsCapableRepository
Abstract SQL repository implementation not specifically bound to JDBC.
Since:
1.0.0
Author:
graemerocher, Denis Stepanov

  • Field Details

    • QUERY_LOG

      protected static final org.slf4j.Logger QUERY_LOG

    • dataSourceName

      protected final String dataSourceName

    • columnNameResultSetReader

      protected final ResultReader<RS,String> columnNameResultSetReader

    • columnIndexResultSetReader

      protected final ResultReader<RS,Integer> columnIndexResultSetReader

    • preparedStatementWriter

      protected final QueryStatement<PS,Integer> preparedStatementWriter

    • jsonMapper

      protected final io.micronaut.json.JsonMapper jsonMapper

    • sqlJsonColumnMapperProvider

      protected final SqlJsonColumnMapperProvider<RS> sqlJsonColumnMapperProvider

    • queryBuilders

      protected final Map<Class,SqlQueryBuilder> queryBuilders

    • repositoriesWithHardcodedDataSource

      protected final Map<Class,String> repositoriesWithHardcodedDataSource

  • Constructor Details

    • AbstractSqlRepositoryOperations

      protected AbstractSqlRepositoryOperations(String dataSourceName, ResultReader<RS,String> columnNameResultSetReader, ResultReader<RS,Integer> columnIndexResultSetReader, QueryStatement<PS,Integer> preparedStatementWriter, DateTimeProvider<Object> dateTimeProvider, RuntimeEntityRegistry runtimeEntityRegistry, io.micronaut.context.BeanContext beanContext, DataConversionService conversionService, AttributeConverterRegistry attributeConverterRegistry, io.micronaut.json.JsonMapper jsonMapper, SqlJsonColumnMapperProvider<RS> sqlJsonColumnMapperProvider)
      Default constructor.
      Parameters:
      dataSourceName - The datasource name
      columnNameResultSetReader - The column name result reader
      columnIndexResultSetReader - The column index result reader
      preparedStatementWriter - The prepared statement writer
      dateTimeProvider - The date time provider
      runtimeEntityRegistry - The entity registry
      beanContext - The bean context
      conversionService - The conversion service
      attributeConverterRegistry - The attribute converter registry
      jsonMapper - The JSON mapper
      sqlJsonColumnMapperProvider - The SQL JSON column mapper provider

  • Method Details

    • decorate

      public <E, R> PreparedQuery<E,R> decorate(PreparedQuery<E,R> preparedQuery)
      Description copied from interface: PreparedQueryDecorator
      Decorate prepared query.
      Specified by:
      decorate in interface PreparedQueryDecorator
      Type Parameters:
      E - The entity type
      R - The result type
      Parameters:
      preparedQuery - The query to be decorated
      Returns:
      decorated prepared query

    • decorate

      public <E, R> StoredQuery<E,R> decorate(io.micronaut.aop.MethodInvocationContext<?,?> context, StoredQuery<E,R> storedQuery)
      Description copied from interface: MethodContextAwareStoredQueryDecorator
      Decorate stored query.
      Specified by:
      decorate in interface MethodContextAwareStoredQueryDecorator
      Type Parameters:
      E - The entity type
      R - The result type
      Parameters:
      context - The context
      storedQuery - The query to be decorated
      Returns:
      decorated stored query

    • prepareStatement

      protected <T, R> PS prepareStatement(AbstractSqlRepositoryOperations.StatementSupplier<PS> statementFunction, @NonNull @NonNull PreparedQuery<T,R> preparedQuery, boolean isUpdate, boolean isSingleResult) throws Exc
      Prepare a statement for execution.
      Type Parameters:
      T - The query declaring type
      R - The query result type
      Parameters:
      statementFunction - The statement function
      preparedQuery - The prepared query
      isUpdate - Is this an update
      isSingleResult - Is it a single result
      Returns:
      The prepared statement
      Throws:
      Exc extends Exception

    • setStatementParameter

      protected void setStatementParameter(PS preparedStatement, int index, DataType dataType, JsonDataType jsonDataType, Object value, SqlStoredQuery<?,?> storedQuery)
      Set the parameter value on the given statement.
      Parameters:
      preparedStatement - The prepared statement
      index - The index
      dataType - The data type
      jsonDataType - The JSON representation type if data type is JSON
      value - The value
      storedQuery - The SQL stored query

    • resolveEntityInsert

      @NonNull protected <E> @NonNull SqlStoredQuery<E,E> resolveEntityInsert(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, Class<?> repositoryType, @NonNull @NonNull Class<E> rootEntity, @NonNull @NonNull RuntimePersistentEntity<E> persistentEntity)
      Resolves a stored insert for the given entity.
      Type Parameters:
      E - The entity type
      Parameters:
      annotationMetadata - The repository annotation metadata
      repositoryType - The repository type
      rootEntity - The root entity
      persistentEntity - The persistent entity
      Returns:
      The insert

    • resolveAssociationInsert

      protected <T> String resolveAssociationInsert(Class repositoryType, RuntimePersistentEntity<T> persistentEntity, RuntimeAssociation<T> association)
      Builds a join table insert.
      Type Parameters:
      T - The entity generic type
      Parameters:
      repositoryType - The repository type
      persistentEntity - The entity
      association - The association
      Returns:
      The insert statement

    • resolveEntityUpdate

      @NonNull protected <E> @NonNull SqlStoredQuery<E,E> resolveEntityUpdate(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, Class<?> repositoryType, @NonNull @NonNull Class<E> rootEntity, @NonNull @NonNull RuntimePersistentEntity<E> persistentEntity)
      Resolves a stored update for the given entity.
      Type Parameters:
      E - The entity type
      Parameters:
      annotationMetadata - The repository annotation metadata
      repositoryType - The repository type
      rootEntity - The root entity
      persistentEntity - The persistent entity
      Returns:
      The insert

    • resolveSqlInsertAssociation

      protected <T> SqlStoredQuery<T,?> resolveSqlInsertAssociation(Class<?> repositoryType, RuntimeAssociation<T> association, RuntimePersistentEntity<T> persistentEntity, T entity)
      Resolve SQL insert association operation.
      Type Parameters:
      T - The entity type
      Parameters:
      repositoryType - The repository type
      association - The association
      persistentEntity - The persistent entity
      entity - The entity
      Returns:
      The operation

    • getSqlPreparedQuery

      protected final <E, R> SqlPreparedQuery<E,R> getSqlPreparedQuery(PreparedQuery<E,R> preparedQuery)

    • getSqlStoredQuery

      protected final <E, R> SqlStoredQuery<E,R> getSqlStoredQuery(StoredQuery<E,R> storedQuery)

    • isSupportsBatchInsert

      protected boolean isSupportsBatchInsert(PersistentEntity persistentEntity, SqlStoredQuery<?,?> sqlStoredQuery)
      Does supports batch for update queries.
      Parameters:
      persistentEntity - The persistent entity
      sqlStoredQuery - The sqlStoredQuery
      Returns:
      true if supported

    • isSupportsBatchInsert

      protected boolean isSupportsBatchInsert(PersistentEntity persistentEntity, Dialect dialect)
      Does supports batch for update queries.
      Parameters:
      persistentEntity - The persistent entity
      dialect - The dialect
      Returns:
      true if supported

    • isSupportsBatchUpdate

      protected boolean isSupportsBatchUpdate(PersistentEntity persistentEntity, SqlStoredQuery<?,?> sqlStoredQuery)
      Does supports batch for update queries.
      Parameters:
      persistentEntity - The persistent entity
      sqlStoredQuery - The sqlStoredQuery
      Returns:
      true if supported

    • isSupportsBatchDelete

      protected boolean isSupportsBatchDelete(PersistentEntity persistentEntity, Dialect dialect)
      Does supports batch for delete queries.
      Parameters:
      persistentEntity - The persistent entity
      dialect - The dialect
      Returns:
      true if supported

    • createQueryResultMapper

      protected final <T, R> SqlTypeMapper<RS,R> createQueryResultMapper(SqlStoredQuery<?,?> sqlStoredQuery, String columnName, JsonDataType jsonDataType, Class<RS> resultSetType, RuntimePersistentEntity<T> persistentEntity, BiFunction<RuntimePersistentEntity<Object>,Object,Object> loadListener)
      Creates SqlTypeMapper for reading results from single column into an entity. For now, we support reading from JSON column, however in support we might add XML support etc.
      Type Parameters:
      T - the entity type
      R - the result type
      Parameters:
      sqlStoredQuery - the SQL prepared query
      columnName - the column name where we are reading from
      jsonDataType - the JSON representation type
      resultSetType - resultSetType the result set type (different for R2DBC and JDBC)
      persistentEntity - the persistent entity
      loadListener - the load listener if needed after entity loaded
      Returns:
      the SqlTypeMapper able to decode from column value into given type

    • mapQueryColumnResult

      protected final <R, T> R mapQueryColumnResult(SqlPreparedQuery<?,?> sqlPreparedQuery, RS rs, String columnName, JsonDataType jsonDataType, RuntimePersistentEntity<T> persistentEntity, Class<R> resultType, Class<RS> resultSetType, BiFunction<RuntimePersistentEntity<Object>,Object,Object> loadListener)
      Reads an object from the result set and given column.
      Type Parameters:
      R - the result type
      T - the entity type
      Parameters:
      sqlPreparedQuery - the SQL prepared query
      rs - the result set
      columnName - the column name where we are reading from
      jsonDataType - the JSON representation type
      persistentEntity - the persistent entity
      resultType - the result type
      resultSetType - the result set type
      loadListener - the load listener if needed after entity loaded
      Returns:
      an object read from the result set column

    • handleSqlException

      protected static Throwable handleSqlException(SQLException sqlException, Dialect dialect)
      Handles SQL exception, used in context of update but could be used elsewhere. It can throw custom exception based on the SQLException.
      Parameters:
      sqlException - the SQL exception
      dialect - the SQL dialect
      Returns:
      custom exception based on SQLException that was thrown or that same exception if nothing specific was about it

    • isJsonResult

      protected final boolean isJsonResult(StoredQuery<?,?> preparedQuery, QueryResultInfo queryResultInfo)
      Return an indicator telling whether prepared query result produces JSON result.
      Parameters:
      preparedQuery - the prepared query
      queryResultInfo - the query result info, if not null will hold info about result type
      Returns:
      true if result is JSON

    • isJsonEntityGeneratedId

      protected final boolean isJsonEntityGeneratedId(StoredQuery<?,?> storedQuery, PersistentEntity persistentEntity)
      Inserting JSON entity representation (like Oracle Json View) can generate new id, and we support retrieval only numeric auto generated ids.
      Parameters:
      storedQuery - the stored query
      persistentEntity - the persistent entity
      Returns:
      true if entity being inserted is JSON entity representation with auto generated numeric id

    • getJsonColumn

      protected final String getJsonColumn(QueryResultInfo queryResultInfo)
      Gets column name for JSON result. If QueryResult annotation is present, takes column value from there, otherwise defaults to 'DATA' column name.
      Parameters:
      queryResultInfo - the query result info from the QueryResult annotation, null if annotation not present
      Returns:
      the JSON column name

    • getJsonDataType

      protected final JsonDataType getJsonDataType(QueryResultInfo queryResultInfo)
      Gets JSON data type for JSON result. If QueryResult annotation is present, takes data type value from there, otherwise defaults to JsonDataType.DEFAULT.
      Parameters:
      queryResultInfo - the query result info from the QueryResult annotation, null if annotation not present
      Returns:
      the JSON data type

    • getFirstResultSetIndex

      protected abstract Integer getFirstResultSetIndex()
      Returns:
      The first result set index.
      Since:
      4.2.0

    • createMapper

      protected <E, R> SqlTypeMapper<RS,R> createMapper(SqlStoredQuery<E,R> preparedQuery, Class<RS> rsType)
      Creates a result mapper.
      Type Parameters:
      E - The entity type
      R - The result type
      Parameters:
      preparedQuery - The prepared query
      rsType - The result set type
      Returns:
      The new mapper
      Since:
      4.2.0