AbstractSqlRepositoryOperations (javadoc 3.0.1 API)

java.lang.Object
- io.micronaut.data.runtime.operations.internal.AbstractSqlRepositoryOperations<Cnt,RS,PS,Exc>

Type Parameters:

Cnt - The connection type

RS - The result set type

PS - The prepared statement type

Exc - The exception type

All Implemented Interfaces:

io.micronaut.context.ApplicationContextProvider

Direct Known Subclasses:

DefaultJdbcRepositoryOperations, DefaultR2dbcRepositoryOperations
```
@Internal
public abstract class AbstractSqlRepositoryOperations<Cnt,RS,PS,Exc extends java.lang.Exception>
extends java.lang.Object
implements io.micronaut.context.ApplicationContextProvider
```
Abstract SQL repository implementation not specifically bound to JDBC.

Since:

1.0.0

Author:

graemerocher, Denis Stepanov

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractSqlRepositoryOperations.BaseOperations<T>` The base entity operations class.
`protected static class`	`AbstractSqlRepositoryOperations.CascadeContext` The cascade context.
`protected static class`	`AbstractSqlRepositoryOperations.CascadeManyOp` The cascade operation of multiple entities - @Many mappings.
`protected static class`	`AbstractSqlRepositoryOperations.CascadeOneOp` The cascade operation of one entity.
`protected static class`	`AbstractSqlRepositoryOperations.CascadeOp` The base cascade operation.
`protected static interface`	`AbstractSqlRepositoryOperations.DBOperation1<In,Exc extends java.lang.Exception>` Simple function interface without return type.
`protected static interface`	`AbstractSqlRepositoryOperations.DBOperation2<In1,In2,Exc extends java.lang.Exception>` Simple function interface with two inputs and without return type.
`protected class`	`AbstractSqlRepositoryOperations.EntitiesOperations<T>` The entities operations container.
`protected class`	`AbstractSqlRepositoryOperations.EntityOperations<T>` The entity operations container.
`protected class`	`AbstractSqlRepositoryOperations.SqlOperation` The sql operation.
`protected static interface`	`AbstractSqlRepositoryOperations.StatementSupplier<PS>` Functional interface used to supply a statement.
`protected class`	`AbstractSqlRepositoryOperations.StoredAnnotationMetadataSqlOperation` Implementation of `AbstractSqlRepositoryOperations.StoredSqlOperation` that retrieves data from `AnnotationMetadata`.
`protected class`	`AbstractSqlRepositoryOperations.StoredSqlOperation` Implementation of `AbstractSqlRepositoryOperations.SqlOperation` that uses bindging paths.

Field Summary

Fields
Modifier and Type	Field and Description
`protected ResultReader<RS,java.lang.Integer>`	`columnIndexResultSetReader`
`protected ResultReader<RS,java.lang.String>`	`columnNameResultSetReader`
`protected DateTimeProvider`	`dateTimeProvider`
`protected static SqlQueryBuilder`	`DEFAULT_SQL_BUILDER`
`protected EntityEventListener<java.lang.Object>`	`entityEventRegistry`
`protected io.micronaut.http.codec.MediaTypeCodec`	`jsonCodec`
`protected QueryStatement<PS,java.lang.Integer>`	`preparedStatementWriter`
`protected static org.slf4j.Logger`	`QUERY_LOG`
`protected java.util.Map<java.lang.Class,SqlQueryBuilder>`	`queryBuilders`
`protected RuntimeEntityRegistry`	`runtimeEntityRegistry`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractSqlRepositoryOperations(java.lang.String dataSourceName, ResultReader<RS,java.lang.String> columnNameResultSetReader, ResultReader<RS,java.lang.Integer> columnIndexResultSetReader, QueryStatement<PS,java.lang.Integer> preparedStatementWriter, java.util.List<io.micronaut.http.codec.MediaTypeCodec> codecs, DateTimeProvider<java.lang.Object> dateTimeProvider, io.micronaut.context.BeanContext beanContext)` Deprecated. Use `AbstractSqlRepositoryOperations(String, ResultReader, ResultReader, QueryStatement, List, DateTimeProvider, RuntimeEntityRegistry, BeanContext)`
`protected`	`AbstractSqlRepositoryOperations(java.lang.String dataSourceName, ResultReader<RS,java.lang.String> columnNameResultSetReader, ResultReader<RS,java.lang.Integer> columnIndexResultSetReader, QueryStatement<PS,java.lang.Integer> preparedStatementWriter, java.util.List<io.micronaut.http.codec.MediaTypeCodec> codecs, DateTimeProvider<java.lang.Object> dateTimeProvider, RuntimeEntityRegistry runtimeEntityRegistry, io.micronaut.context.BeanContext beanContext)` Default constructor.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected <T> T`	`afterCascadedMany(T entity, java.util.List<Association> associations, java.lang.Iterable<java.lang.Object> prevChildren, java.util.List<java.lang.Object> newChildren)` Process after a children element has been cascaded.
`protected <T> T`	`afterCascadedOne(T entity, java.util.List<Association> associations, java.lang.Object prevChild, java.lang.Object newChild)` Process after a child element has been cascaded.
`protected <T> void`	`cascade(Dialect dialect, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, boolean fkOnly, Relation.Cascade cascadeType, AbstractSqlRepositoryOperations.CascadeContext ctx, RuntimePersistentEntity<T> persistentEntity, T entity, java.util.List<AbstractSqlRepositoryOperations.CascadeOp> cascadeOps)` Cascade on the entity instance and collect cascade operations.
`protected void`	`checkOptimisticLocking(int expected, int received)` Compare the expected modifications and the received rows count.
`protected <T> void`	`deleteInBatch(Cnt connection, Dialect dialect, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, AbstractSqlRepositoryOperations.EntitiesOperations<T> op)` Delete batch operation.
`protected <T> void`	`deleteOne(Cnt connection, Dialect dialect, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, AbstractSqlRepositoryOperations.EntityOperations<T> op, SqlQueryBuilder queryBuilder)` Delete one operation.
`io.micronaut.context.ApplicationContext`	`getApplicationContext()`
`<T> RuntimePersistentEntity<T>`	`getEntity(java.lang.Class<T> type)`
`protected RuntimePersistentProperty<java.lang.Object>`	`getIdReader(java.lang.Object o)` Obtain an ID reader for the given object.
`protected boolean`	`isOnlySingleEndedJoins(RuntimePersistentEntity<?> rootPersistentEntity, java.util.Set<JoinPath> joinFetchPaths)` Check if joined associated are all single ended (Can produce only one result).
`protected boolean`	`isSqlServerWithoutOrderBy(java.lang.String query, Dialect dialect)` In the dialect SQL server and is order by required.
`protected boolean`	`isSupportsBatchDelete(PersistentEntity persistentEntity, Dialect dialect)` Does supports batch for delete queries.
`protected boolean`	`isSupportsBatchInsert(PersistentEntity persistentEntity, Dialect dialect)` Does supports batch for update queries.
`protected boolean`	`isSupportsBatchUpdate(PersistentEntity persistentEntity, Dialect dialect)` Does supports batch for update queries.
`protected <T> void`	`persistInBatch(Cnt connection, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, AbstractSqlRepositoryOperations.SqlOperation sqlOperation, java.util.List<Association> associations, java.util.Set<java.lang.Object> persisted, AbstractSqlRepositoryOperations.EntitiesOperations<T> op)` Persist batch operation.
`protected <T> void`	`persistJoinTableAssociation(Cnt connection, java.lang.Class<?> repositoryType, Dialect dialect, Association association, java.lang.Object parent, AbstractSqlRepositoryOperations.BaseOperations<T> op)` Persist join table assocation.
`protected <T> void`	`persistOne(Cnt connection, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, AbstractSqlRepositoryOperations.SqlOperation sqlOperation, java.util.List<Association> associations, java.util.Set<java.lang.Object> persisted, AbstractSqlRepositoryOperations.EntityOperations<T> op)` Persist one operation.
`protected <T,R> PS`	`prepareStatement(AbstractSqlRepositoryOperations.StatementSupplier<PS> statementFunction, PreparedQuery<T,R> preparedQuery, boolean isUpdate, boolean isSingleResult)` Prepare a statement for execution.
`protected abstract void`	`prepareStatement(Cnt connection, Dialect dialect, PersistentProperty identity, boolean hasGeneratedID, java.lang.String insertSql, AbstractSqlRepositoryOperations.DBOperation1<PS,Exc> fn)` Prepare a statement and run a function.
`protected abstract void`	`prepareStatement(Cnt connection, java.lang.String query, AbstractSqlRepositoryOperations.DBOperation1<PS,Exc> fn)` Prepare a statement and run a function.
`protected <T> java.lang.String`	`resolveAssociationInsert(java.lang.Class repositoryType, RuntimePersistentEntity<T> persistentEntity, RuntimeAssociation<T> association)` Builds a join table insert.
`protected AbstractSqlRepositoryOperations.SqlOperation`	`resolveEntityInsert(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, java.lang.Class<?> rootEntity, RuntimePersistentEntity<?> persistentEntity)` Resolves a stored insert for the given entity.
`protected AbstractSqlRepositoryOperations.SqlOperation`	`resolveEntityUpdate(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, java.lang.Class<?> rootEntity, RuntimePersistentEntity<?> persistentEntity)` Resolves a stored update for the given entity.
`protected void`	`setStatementParameter(PS preparedStatement, int index, DataType dataType, java.lang.Object value, Dialect dialect)` Set the parameter value on the given statement.
`protected int`	`shiftIndex(int i)` Used to define the index whether it is 1 based (JDBC) or 0 based (R2DBC).
`protected int`	`sizeOf(java.lang.Object value)` Compute the size of the given object.
`protected <T> Sort`	`sortById(RuntimePersistentEntity<T> persistentEntity)` Build a sort for ID for the given entity.
`protected <T> T`	`triggerPostLoad(T entity, RuntimePersistentEntity<T> pe, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata)` Trigger the post load event.
`protected <T> void`	`updateInBatch(Cnt connection, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, AbstractSqlRepositoryOperations.StoredSqlOperation sqlOperation, java.util.List<Association> associations, java.util.Set<java.lang.Object> persisted, AbstractSqlRepositoryOperations.EntitiesOperations<T> op)` Update batch operation.
`protected <T> void`	`updateOne(Cnt connection, io.micronaut.core.annotation.AnnotationMetadata annotationMetadata, java.lang.Class<?> repositoryType, AbstractSqlRepositoryOperations.SqlOperation sqlOperation, java.util.List<Association> associations, java.util.Set<java.lang.Object> persisted, AbstractSqlRepositoryOperations.EntityOperations<T> op)` Update one operation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

QUERY_LOG

protected static final org.slf4j.Logger QUERY_LOG

DEFAULT_SQL_BUILDER

protected static final SqlQueryBuilder DEFAULT_SQL_BUILDER

columnNameResultSetReader

protected final ResultReader<RS,java.lang.String> columnNameResultSetReader

columnIndexResultSetReader

protected final ResultReader<RS,java.lang.Integer> columnIndexResultSetReader

preparedStatementWriter

protected final QueryStatement<PS,java.lang.Integer> preparedStatementWriter

queryBuilders

protected final java.util.Map<java.lang.Class,SqlQueryBuilder> queryBuilders

jsonCodec

protected final io.micronaut.http.codec.MediaTypeCodec jsonCodec

entityEventRegistry

protected final EntityEventListener<java.lang.Object> entityEventRegistry

dateTimeProvider

protected final DateTimeProvider dateTimeProvider

runtimeEntityRegistry

protected final RuntimeEntityRegistry runtimeEntityRegistry

Constructor Detail

AbstractSqlRepositoryOperations

@Deprecated
protected AbstractSqlRepositoryOperations(java.lang.String dataSourceName,
                                                      ResultReader<RS,java.lang.String> columnNameResultSetReader,
                                                      ResultReader<RS,java.lang.Integer> columnIndexResultSetReader,
                                                      QueryStatement<PS,java.lang.Integer> preparedStatementWriter,
                                                      java.util.List<io.micronaut.http.codec.MediaTypeCodec> codecs,
                                                      DateTimeProvider<java.lang.Object> dateTimeProvider,
                                                      io.micronaut.context.BeanContext beanContext)

Deprecated. Use

AbstractSqlRepositoryOperations(String, ResultReader, ResultReader, QueryStatement, List, DateTimeProvider, RuntimeEntityRegistry, BeanContext)

Default constructor.

Parameters:: dataSourceName - The datasource name; columnNameResultSetReader - The column name result reader; columnIndexResultSetReader - The column index result reader; preparedStatementWriter - The prepared statement writer; codecs - The media type codecs; dateTimeProvider - The date time provider; beanContext - The bean context

AbstractSqlRepositoryOperations

protected AbstractSqlRepositoryOperations(java.lang.String dataSourceName,
                                          ResultReader<RS,java.lang.String> columnNameResultSetReader,
                                          ResultReader<RS,java.lang.Integer> columnIndexResultSetReader,
                                          QueryStatement<PS,java.lang.Integer> preparedStatementWriter,
                                          java.util.List<io.micronaut.http.codec.MediaTypeCodec> codecs,
                                          DateTimeProvider<java.lang.Object> dateTimeProvider,
                                          RuntimeEntityRegistry runtimeEntityRegistry,
                                          io.micronaut.context.BeanContext beanContext)

Default constructor.

Parameters:: dataSourceName - The datasource name; columnNameResultSetReader - The column name result reader; columnIndexResultSetReader - The column index result reader; preparedStatementWriter - The prepared statement writer; codecs - The media type codecs; dateTimeProvider - The date time provider; runtimeEntityRegistry - The entity registry; beanContext - The bean context

Method Detail

getApplicationContext
```
public io.micronaut.context.ApplicationContext getApplicationContext()
```
Specified by:

getApplicationContext in interface io.micronaut.context.ApplicationContextProvider

getEntity

@NonNull
public final <T> RuntimePersistentEntity<T> getEntity(@NonNull
                                                               java.lang.Class<T> type)

prepareStatement

protected <T,R> PS prepareStatement(AbstractSqlRepositoryOperations.StatementSupplier<PS> statementFunction,
                                    @NonNull
                                    PreparedQuery<T,R> preparedQuery,
                                    boolean isUpdate,
                                    boolean isSingleResult)
                             throws Exc extends java.lang.Exception

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 java.lang.Exception

prepareStatement

protected abstract void prepareStatement(Cnt connection,
                                         java.lang.String query,
                                         AbstractSqlRepositoryOperations.DBOperation1<PS,Exc> fn)
                                  throws Exc extends java.lang.Exception

Prepare a statement and run a function.

Parameters:: connection - The connection.; query - The query; fn - The function to be run with a statement
Throws:: Exc - The exception type; Exc extends java.lang.Exception

prepareStatement

protected abstract void prepareStatement(Cnt connection,
                                         Dialect dialect,
                                         PersistentProperty identity,
                                         boolean hasGeneratedID,
                                         java.lang.String insertSql,
                                         AbstractSqlRepositoryOperations.DBOperation1<PS,Exc> fn)
                                  throws Exc extends java.lang.Exception

Prepare a statement and run a function.

Parameters:: connection - The connection; dialect - The dialect; identity - The identity property; hasGeneratedID - Is genereted idenntity; insertSql - Te query; fn - The function to be run with a statement
Throws:: Exc - The exception type; Exc extends java.lang.Exception

afterCascadedOne
```
protected <T> T afterCascadedOne(T entity,
                                 java.util.List<Association> associations,
                                 java.lang.Object prevChild,
                                 java.lang.Object newChild)
```
Process after a child element has been cascaded.

Type Parameters:

T - The entity type

Parameters:

entity - The parent entity.

associations - The association leading to the child

prevChild - The previous child value

newChild - The new child value

Returns:

The entity instance

afterCascadedMany
```
protected <T> T afterCascadedMany(T entity,
                                  java.util.List<Association> associations,
                                  java.lang.Iterable<java.lang.Object> prevChildren,
                                  java.util.List<java.lang.Object> newChildren)
```
Process after a children element has been cascaded.

Type Parameters:

T - The entity type

Parameters:

entity - The parent entity.

associations - The association leading to the child

prevChildren - The previous children value

newChildren - The new children value

Returns:

The entity instance

triggerPostLoad

protected <T> T triggerPostLoad(@NonNull
                                T entity,
                                RuntimePersistentEntity<T> pe,
                                io.micronaut.core.annotation.AnnotationMetadata annotationMetadata)

Trigger the post load event.

Type Parameters:: T - The generic type
Parameters:: entity - The entity; pe - The persistent entity; annotationMetadata - The annotation metadata
Returns:: The entity, possibly modified

persistOne

protected <T> void persistOne(Cnt connection,
                              io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                              java.lang.Class<?> repositoryType,
                              AbstractSqlRepositoryOperations.SqlOperation sqlOperation,
                              java.util.List<Association> associations,
                              java.util.Set<java.lang.Object> persisted,
                              AbstractSqlRepositoryOperations.EntityOperations<T> op)

Persist one operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; annotationMetadata - The annotationMetadata; repositoryType - The repositoryType; sqlOperation - The sql operation; associations - The associations; persisted - Already persisted values; op - The operation

persistInBatch

protected <T> void persistInBatch(Cnt connection,
                                  io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                                  java.lang.Class<?> repositoryType,
                                  AbstractSqlRepositoryOperations.SqlOperation sqlOperation,
                                  java.util.List<Association> associations,
                                  java.util.Set<java.lang.Object> persisted,
                                  AbstractSqlRepositoryOperations.EntitiesOperations<T> op)

Persist batch operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; annotationMetadata - The annotationMetadata; repositoryType - The repositoryType; sqlOperation - The sql operation; associations - The associations; persisted - Already persisted values; op - The operation

deleteOne

protected <T> void deleteOne(Cnt connection,
                             Dialect dialect,
                             io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                             AbstractSqlRepositoryOperations.EntityOperations<T> op,
                             SqlQueryBuilder queryBuilder)

Delete one operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; dialect - The dialect; annotationMetadata - The annotationMetadata; op - The operation; queryBuilder - The queryBuilder

deleteInBatch

protected <T> void deleteInBatch(Cnt connection,
                                 Dialect dialect,
                                 io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                                 AbstractSqlRepositoryOperations.EntitiesOperations<T> op)

Delete batch operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; dialect - The dialect; annotationMetadata - The annotationMetadata; op - The operation

updateOne

protected <T> void updateOne(Cnt connection,
                             io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                             java.lang.Class<?> repositoryType,
                             AbstractSqlRepositoryOperations.SqlOperation sqlOperation,
                             java.util.List<Association> associations,
                             java.util.Set<java.lang.Object> persisted,
                             AbstractSqlRepositoryOperations.EntityOperations<T> op)

Update one operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; annotationMetadata - The annotationMetadata; repositoryType - The repositoryType; sqlOperation - The sql operation; associations - The associations; persisted - Already persisted values; op - The operation

updateInBatch

protected <T> void updateInBatch(Cnt connection,
                                 io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                                 java.lang.Class<?> repositoryType,
                                 AbstractSqlRepositoryOperations.StoredSqlOperation sqlOperation,
                                 java.util.List<Association> associations,
                                 java.util.Set<java.lang.Object> persisted,
                                 AbstractSqlRepositoryOperations.EntitiesOperations<T> op)

Update batch operation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; annotationMetadata - The annotationMetadata; repositoryType - The repositoryType; sqlOperation - The sql operation; associations - The associations; persisted - Already persisted values; op - The operation

shiftIndex
```
protected int shiftIndex(int i)
```
Used to define the index whether it is 1 based (JDBC) or 0 based (R2DBC).

Parameters:

i - The index to shift

Returns:

the index

getIdReader

@NonNull
protected final RuntimePersistentProperty<java.lang.Object> getIdReader(@NonNull
                                                                                 java.lang.Object o)

Obtain an ID reader for the given object.

Parameters:: o - The object
Returns:: The ID reader

sortById
```
@NonNull
protected final <T> Sort sortById(RuntimePersistentEntity<T> persistentEntity)
```
Build a sort for ID for the given entity.

Type Parameters:

T - The entity type

Parameters:

persistentEntity - The entity

Returns:

The sort

isSqlServerWithoutOrderBy

protected final boolean isSqlServerWithoutOrderBy(java.lang.String query,
                                                  Dialect dialect)

In the dialect SQL server and is order by required.

Parameters:: query - The query; dialect - The dialect
Returns:: True if it is

sizeOf
```
protected final int sizeOf(java.lang.Object value)
```
Compute the size of the given object.

Parameters:

value - The value

Returns:

The size

setStatementParameter

protected final void setStatementParameter(PS preparedStatement,
                                           int index,
                                           DataType dataType,
                                           java.lang.Object value,
                                           Dialect dialect)

Set the parameter value on the given statement.

Parameters:: preparedStatement - The prepared statement; index - The index; dataType - The data type; value - The value; dialect - The dialect

resolveEntityInsert

@NonNull
protected AbstractSqlRepositoryOperations.SqlOperation resolveEntityInsert(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                                                                                    java.lang.Class<?> repositoryType,
                                                                                    @NonNull
                                                                                    java.lang.Class<?> rootEntity,
                                                                                    @NonNull
                                                                                    RuntimePersistentEntity<?> persistentEntity)

Resolves a stored insert for the given entity.

Parameters:: annotationMetadata - The repository annotation metadata; repositoryType - The repository type; rootEntity - The root entity; persistentEntity - The persistent entity
Returns:: The insert

resolveAssociationInsert

protected <T> java.lang.String resolveAssociationInsert(java.lang.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

cascade

protected <T> void cascade(Dialect dialect,
                           io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                           java.lang.Class<?> repositoryType,
                           boolean fkOnly,
                           Relation.Cascade cascadeType,
                           AbstractSqlRepositoryOperations.CascadeContext ctx,
                           RuntimePersistentEntity<T> persistentEntity,
                           T entity,
                           java.util.List<AbstractSqlRepositoryOperations.CascadeOp> cascadeOps)

Cascade on the entity instance and collect cascade operations.

Type Parameters:: T - The entity type
Parameters:: dialect - The dialect; annotationMetadata - The annotationMetadata; repositoryType - The repositoryType; fkOnly - Is FK only; cascadeType - The cascadeType; ctx - The cascade context; persistentEntity - The persistent entity; entity - The entity instance; cascadeOps - The cascade operations

persistJoinTableAssociation

protected <T> void persistJoinTableAssociation(Cnt connection,
                                               java.lang.Class<?> repositoryType,
                                               Dialect dialect,
                                               Association association,
                                               java.lang.Object parent,
                                               AbstractSqlRepositoryOperations.BaseOperations<T> op)

Persist join table assocation.

Type Parameters:: T - The entity type
Parameters:: connection - The connection; repositoryType - The repositoryType; dialect - The dialect; association - The association; parent - The parent; op - The operation

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

resolveEntityUpdate

@NonNull
protected AbstractSqlRepositoryOperations.SqlOperation resolveEntityUpdate(io.micronaut.core.annotation.AnnotationMetadata annotationMetadata,
                                                                                    java.lang.Class<?> repositoryType,
                                                                                    @NonNull
                                                                                    java.lang.Class<?> rootEntity,
                                                                                    @NonNull
                                                                                    RuntimePersistentEntity<?> persistentEntity)

Resolves a stored update for the given entity.

Parameters:: annotationMetadata - The repository annotation metadata; repositoryType - The repository type; rootEntity - The root entity; persistentEntity - The persistent entity
Returns:: The insert

checkOptimisticLocking
```
protected void checkOptimisticLocking(int expected,
                                      int received)
```
Compare the expected modifications and the received rows count. If not equals throw OptimisticLockException.

Parameters:

expected - The expected value

received - THe received value

isOnlySingleEndedJoins
```
protected boolean isOnlySingleEndedJoins(RuntimePersistentEntity<?> rootPersistentEntity,
                                         java.util.Set<JoinPath> joinFetchPaths)
```
Check if joined associated are all single ended (Can produce only one result).

Parameters:

rootPersistentEntity - The root entity

joinFetchPaths - The join paths

Returns:

true if there are no "many" joins

Class AbstractSqlRepositoryOperations<Cnt,RS,PS,Exc extends java.lang.Exception>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

QUERY_LOG

DEFAULT_SQL_BUILDER

columnNameResultSetReader

columnIndexResultSetReader

preparedStatementWriter

queryBuilders

jsonCodec

entityEventRegistry

dateTimeProvider

runtimeEntityRegistry

Constructor Detail

AbstractSqlRepositoryOperations

AbstractSqlRepositoryOperations

Method Detail

getApplicationContext

getEntity

prepareStatement

prepareStatement

prepareStatement

afterCascadedOne

afterCascadedMany

triggerPostLoad

persistOne

persistInBatch

deleteOne

deleteInBatch

updateOne

updateInBatch

shiftIndex

getIdReader

sortById

isSqlServerWithoutOrderBy

sizeOf

setStatementParameter

resolveEntityInsert

resolveAssociationInsert

cascade

persistJoinTableAssociation

isSupportsBatchInsert

isSupportsBatchUpdate

isSupportsBatchDelete

resolveEntityUpdate

checkOptimisticLocking

isOnlySingleEndedJoins