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 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> SqlStoredQuery<E,E> resolveEntityInsert(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, Class<?> repositoryType, @NonNull Class<E> rootEntity, @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> SqlStoredQuery<E,E> resolveEntityUpdate(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, Class<?> repositoryType, @NonNull Class<E> rootEntity, @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, 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, Dialect dialect)
      Does supports batch for update queries.
      Parameters:
      persistentEntity - The persistent entity
      dialect - The dialect
      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(SqlPreparedQuery<?,?> sqlPreparedQuery, 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:
      sqlPreparedQuery - 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