From 9356c503a908c0c138dc17c2ef2ba984bd58705b Mon Sep 17 00:00:00 2001 From: Gavin King Date: Fri, 5 Dec 2025 19:50:28 +0100 Subject: [PATCH 1/3] fill in impl of methods of EntityJavaType this is sorta useful with SQL result set mappings --- .../descriptor/java/spi/EntityJavaType.java | 40 +++++++++++++------ 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java index 07114c69110f..a4304068fafe 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java @@ -21,14 +21,17 @@ public class EntityJavaType extends AbstractClassJavaType { public EntityJavaType(Class type, MutabilityPlan mutabilityPlan) { - super( type, mutabilityPlan , IncomparableComparator.INSTANCE ); + super( type, mutabilityPlan, IncomparableComparator.INSTANCE ); } @Override public JdbcType getRecommendedJdbcType(JdbcTypeIndicators context) { - throw new JdbcTypeRecommendationException( - "Could not determine recommended JdbcType for '" + getTypeName() + "'" - ); + return context.getTypeConfiguration().getSessionFactory() + .getMappingMetamodel() + .getEntityDescriptor(getJavaTypeClass()) + .getIdentifierDescriptor() + .getJavaType() + .getRecommendedJdbcType( context ); } @Override @@ -66,18 +69,31 @@ public T fromString(CharSequence string) { ); } - @Override + @Override @SuppressWarnings("unchecked") // safe, we do check public X unwrap(T value, Class type, WrapperOptions options) { - throw new UnsupportedOperationException( - "Unwrap strategy not known for this Java type: " + getTypeName() - ); + final var id = + options.getSessionFactory().getMappingMetamodel() + .getEntityDescriptor( getJavaTypeClass() ) + .getIdentifier( value ); + if ( !type.isInstance( id ) ) { + throw new IllegalArgumentException( "Id not an instance of type " + type.getName() ); + } + return (X) value; } - @Override + @Override @SuppressWarnings("unchecked") // safe, we do check public T wrap(X value, WrapperOptions options) { - throw new UnsupportedOperationException( - "Wrap strategy not known for this Java type: " + getTypeName() - ); + final var persister = + options.getSessionFactory().getMappingMetamodel() + .getEntityDescriptor( getJavaTypeClass() ); + final var idType = persister.getIdentifierType().getReturnedClass(); + if ( !idType.isInstance( value ) ) { + throw new IllegalArgumentException( "Not an instance of id type " + idType.getName() ); + } + final var entity = + options.getSession() + .internalLoad( persister.getEntityName(), value, false, true ); + return (T) entity; } @Override From de66ab360a3ec4347e278b8beb82afe387789cc1 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Fri, 5 Dec 2025 19:50:51 +0100 Subject: [PATCH 2/3] remove unnecessary LOG in Table --- .../java/org/hibernate/mapping/Table.java | 45 +++++++++---------- 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/Table.java b/hibernate-core/src/main/java/org/hibernate/mapping/Table.java index 04d3f60d8a6b..79e2a29d16bc 100644 --- a/hibernate-core/src/main/java/org/hibernate/mapping/Table.java +++ b/hibernate-core/src/main/java/org/hibernate/mapping/Table.java @@ -30,7 +30,6 @@ import org.hibernate.dialect.Dialect; import org.hibernate.resource.transaction.spi.DdlTransactionIsolator; -import org.jboss.logging.Logger; import static java.util.Collections.emptyList; import static java.util.Collections.singletonList; @@ -46,7 +45,6 @@ * @author Gavin King */ public class Table implements Serializable, ContributableDatabaseObject { - private static final Logger LOG = Logger.getLogger( Table.class ); private static final Column[] EMPTY_COLUMN_ARRAY = new Column[0]; private final String contributor; @@ -110,8 +108,9 @@ public Table( String subselect, boolean isAbstract) { this.contributor = contributor; - this.catalog = namespace.getPhysicalName().catalog(); - this.schema = namespace.getPhysicalName().schema(); + final var physicalName = namespace.getPhysicalName(); + this.catalog = physicalName.catalog(); + this.schema = physicalName.schema(); this.name = physicalTableName; this.subselect = subselect; this.isAbstract = isAbstract; @@ -119,8 +118,9 @@ public Table( public Table(String contributor, Namespace namespace, String subselect, boolean isAbstract) { this.contributor = contributor; - this.catalog = namespace.getPhysicalName().catalog(); - this.schema = namespace.getPhysicalName().schema(); + final var physicalName = namespace.getPhysicalName(); + this.catalog = physicalName.catalog(); + this.schema = physicalName.schema(); this.subselect = subselect; this.isAbstract = isAbstract; } @@ -247,7 +247,7 @@ public Column getColumn(Column column) { return null; } else { - final Column existing = columns.get( column.getCanonicalName() ); + final var existing = columns.get( column.getCanonicalName() ); return column.equals( existing ) ? existing : null; } } @@ -276,15 +276,11 @@ public void addColumn(Column column) { if ( oldColumn == null ) { if ( primaryKey != null ) { for ( var primaryKeyColumn : primaryKey.getColumns() ) { - if ( primaryKeyColumn.getCanonicalName().equals( column.getCanonicalName() ) ) { + if ( Objects.equals( column.getCanonicalName(), + primaryKeyColumn.getCanonicalName() ) ) { + // Force the column to be non-null + // as it is part of the primary key column.setNullable( false ); - if ( LOG.isTraceEnabled() ) { - LOG.tracef( - "Forcing column [%s] to be non-null as it is part of the primary key for table [%s]", - column.getCanonicalName(), - getNameIdentifier().getCanonicalName() - ); - } } } } @@ -452,18 +448,21 @@ public void setPrimaryKey(PrimaryKey primaryKey) { } public Index getOrCreateIndex(String indexName) { - Index index = indexes.get( indexName ); - if ( index == null ) { - index = new Index(); - index.setName( indexName ); - index.setTable( this ); - indexes.put( indexName, index ); + final var index = indexes.get( indexName ); + if ( index != null ) { + return index; + } + else { + final var newIndex = new Index(); + newIndex.setName( indexName ); + newIndex.setTable( this ); + indexes.put( indexName, newIndex ); + return newIndex; } - return index; } public Index getIndex(String indexName) { - return indexes.get( indexName ); + return indexes.get( indexName ); } public Index addIndex(Index index) { From d3eaed40c54688b0c0614e661e23a59c2955f4bd Mon Sep 17 00:00:00 2001 From: Gavin King Date: Fri, 5 Dec 2025 20:08:52 +0100 Subject: [PATCH 3/3] code cleanups in sql.results.jdbc.internal mostly just lots of var --- .../jdbc/internal/AbstractJdbcValues.java | 18 ++-- .../internal/AbstractResultSetAccess.java | 11 ++- .../internal/CachedJdbcValuesMetadata.java | 13 ++- .../internal/DeferredResultSetAccess.java | 88 ++++++++++--------- .../jdbc/internal/DirectResultSetAccess.java | 4 +- .../jdbc/internal/JdbcValuesCacheHit.java | 60 ++++++------- .../JdbcValuesMappingProducerStandard.java | 4 +- .../JdbcValuesMappingResolutionImpl.java | 7 +- .../internal/JdbcValuesResultSetImpl.java | 34 ++++--- ...luesSourceProcessingStateStandardImpl.java | 19 +--- .../internal/StandardJdbcValuesMapping.java | 32 +++---- 11 files changed, 139 insertions(+), 151 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractJdbcValues.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractJdbcValues.java index 26f6f835cdcf..1433fa7383e7 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractJdbcValues.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractJdbcValues.java @@ -21,9 +21,9 @@ public final boolean next(RowProcessingState rowProcessingState) { @Override public boolean previous(RowProcessingState rowProcessingState) { - // NOTE : we do not even bother interacting with the query-cache put manager because - // this method is implicitly related to scrolling and caching of scrolled results - // is not supported + // NOTE: we do not even bother interacting with the query-cache put manager because + // this method is implicitly related to scrolling and caching of scrolled results + // is not supported return processPrevious( rowProcessingState ); } @@ -31,9 +31,9 @@ public boolean previous(RowProcessingState rowProcessingState) { @Override public boolean scroll(int numberOfRows, RowProcessingState rowProcessingState) { - // NOTE : we do not even bother interacting with the query-cache put manager because - // this method is implicitly related to scrolling and caching of scrolled results - // is not supported + // NOTE: we do not even bother interacting with the query-cache put manager because + // this method is implicitly related to scrolling and caching of scrolled results + // is not supported return processScroll( numberOfRows, rowProcessingState ); } @@ -41,9 +41,9 @@ public boolean scroll(int numberOfRows, RowProcessingState rowProcessingState) { @Override public boolean position(int position, RowProcessingState rowProcessingState) { - // NOTE : we do not even bother interacting with the query-cache put manager because - // this method is implicitly related to scrolling and caching of scrolled results - // is not supported + // NOTE: we do not even bother interacting with the query-cache put manager because + // this method is implicitly related to scrolling and caching of scrolled results + // is not supported return processPosition( position, rowProcessingState ); } diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractResultSetAccess.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractResultSetAccess.java index 99184c081997..800fe88ef3a6 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractResultSetAccess.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/AbstractResultSetAccess.java @@ -17,7 +17,6 @@ import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; -import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeRegistry; import org.hibernate.type.spi.TypeConfiguration; /** @@ -108,18 +107,18 @@ public int getResultCountEstimate() { @Override public BasicType resolveType(int position, JavaType explicitJavaType, TypeConfiguration typeConfiguration) { try { - final ResultSetMetaData metaData = getResultSetMetaData(); - final JdbcTypeRegistry registry = typeConfiguration.getJdbcTypeRegistry(); + final var metaData = getResultSetMetaData(); + final var registry = typeConfiguration.getJdbcTypeRegistry(); final String columnTypeName = metaData.getColumnTypeName( position ); final int columnType = metaData.getColumnType( position ); final int scale = metaData.getScale( position ); final int precision = metaData.getPrecision( position ); final int displaySize = metaData.getColumnDisplaySize( position ); - final Dialect dialect = getDialect(); + final var dialect = getDialect(); final int length = dialect.resolveSqlTypeLength( columnTypeName, columnType, precision, scale, displaySize ); - final JdbcType resolvedJdbcType = + final var resolvedJdbcType = dialect.resolveSqlTypeDescriptor( columnTypeName, columnType, length, scale, registry ); - final JdbcType jdbcType = + final var jdbcType = explicitJavaType == null ? resolvedJdbcType : jdbcType( explicitJavaType, resolvedJdbcType, length, precision, scale, typeConfiguration ); diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/CachedJdbcValuesMetadata.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/CachedJdbcValuesMetadata.java index ba45c9873eb1..8d07a3a374a6 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/CachedJdbcValuesMetadata.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/CachedJdbcValuesMetadata.java @@ -6,12 +6,13 @@ import java.io.Serializable; -import org.hibernate.internal.util.collections.ArrayHelper; import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata; import org.hibernate.type.BasicType; import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.spi.TypeConfiguration; +import static org.hibernate.internal.util.collections.ArrayHelper.indexOf; + public final class CachedJdbcValuesMetadata implements JdbcValuesMetadata, Serializable { private final String[] columnNames; private final BasicType[] types; @@ -28,7 +29,7 @@ public int getColumnCount() { @Override public int resolveColumnPosition(String columnName) { - final int position = ArrayHelper.indexOf( columnNames, columnName ) + 1; + final int position = indexOf( columnNames, columnName ) + 1; if ( position == 0 ) { throw new IllegalStateException( "Unexpected resolving of unavailable column: " + columnName ); } @@ -49,7 +50,7 @@ public BasicType resolveType( int position, JavaType explicitJavaType, TypeConfiguration typeConfiguration) { - final BasicType type = types[position - 1]; + final var type = types[position - 1]; if ( type == null ) { throw new IllegalStateException( "Unexpected resolving of unavailable column at position: " + position ); } @@ -58,10 +59,8 @@ public BasicType resolveType( return (BasicType) type; } else { - return typeConfiguration.getBasicTypeRegistry().resolve( - explicitJavaType, - type.getJdbcType() - ); + return typeConfiguration.getBasicTypeRegistry() + .resolve( explicitJavaType, type.getJdbcType() ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DeferredResultSetAccess.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DeferredResultSetAccess.java index fde5c29cf3ce..4a2060226842 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DeferredResultSetAccess.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DeferredResultSetAccess.java @@ -9,14 +9,10 @@ import org.hibernate.dialect.Dialect; import org.hibernate.dialect.pagination.LimitHandler; import org.hibernate.dialect.pagination.NoopLimitHandler; -import org.hibernate.engine.jdbc.spi.JdbcCoordinator; import org.hibernate.engine.jdbc.spi.JdbcServices; import org.hibernate.engine.jdbc.spi.SqlStatementLogger; import org.hibernate.engine.spi.SessionEventListenerManager; import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.engine.spi.SharedSessionContractImplementor; -import org.hibernate.event.monitor.spi.DiagnosticEvent; -import org.hibernate.event.monitor.spi.EventMonitor; import org.hibernate.query.spi.Limit; import org.hibernate.query.spi.QueryOptions; import org.hibernate.resource.jdbc.spi.JdbcSessionContext; @@ -62,7 +58,7 @@ public DeferredResultSetAccess( JdbcSelectExecutor.StatementCreator statementCreator, int resultCountEstimate) { super( executionContext.getSession() ); - final JdbcServices jdbcServices = executionContext.getSession().getJdbcServices(); + final var jdbcServices = executionContext.getSession().getJdbcServices(); this.jdbcParameterBindings = jdbcParameterBindings; this.executionContext = executionContext; @@ -71,7 +67,7 @@ public DeferredResultSetAccess( this.sqlStatementLogger = jdbcServices.getSqlStatementLogger(); this.resultCountEstimate = resultCountEstimate; - final QueryOptions queryOptions = executionContext.getQueryOptions(); + final var queryOptions = executionContext.getQueryOptions(); if ( queryOptions == null ) { finalSql = jdbcSelect.getSqlString(); limit = null; @@ -80,41 +76,54 @@ public DeferredResultSetAccess( else { // Note that limit and lock aren't set for SQM as that is applied during SQL rendering // But for native queries, we have to adapt the SQL string - final Dialect dialect = jdbcServices.getDialect(); + final var dialect = jdbcServices.getDialect(); final String sql = jdbcSelect.getSqlString(); limit = queryOptions.getLimit(); final boolean needsLimitHandler = needsLimitHandler( jdbcSelect ); limitHandler = needsLimitHandler ? dialect.getLimitHandler() : NoopLimitHandler.NO_LIMIT; - final String sqlWithLimit = !needsLimitHandler ? sql : limitHandler.processSql( - sql, - jdbcParameterBindings.getBindings().size(), - jdbcServices.getParameterMarkerStrategy(), - queryOptions - ); + final String sqlWithLimit = + needsLimitHandler + ? sqlWithLimit( jdbcParameterBindings, sql, jdbcServices, queryOptions ) + : sql; + + final String sqlWithLocking = + sqlWithLocking( jdbcSelect.getLockStrategy(), sqlWithLimit, queryOptions, dialect ); + + finalSql = + dialect.addSqlHintOrComment( sqlWithLocking, queryOptions, + executionContext.getSession().getFactory() + .getSessionFactoryOptions().isCommentsEnabled() ); + } + } - final var lockOptions = queryOptions.getLockOptions(); - final var jdbcLockStrategy = jdbcSelect.getLockStrategy(); - final String sqlWithLocking; - if ( hasLocking( jdbcLockStrategy, lockOptions ) ) { - final boolean usesFollowOnLocking = useFollowOnLocking( jdbcLockStrategy, sqlWithLimit, queryOptions, lockOptions, dialect ); - if ( usesFollowOnLocking ) { - sqlWithLocking = sqlWithLimit; - } - else { - sqlWithLocking = dialect.applyLocksToSql( sqlWithLimit, lockOptions, emptyMap() ); - } - } - else { - sqlWithLocking = sqlWithLimit; - } + private String sqlWithLimit( + JdbcParameterBindings jdbcParameterBindings, + String sql, + JdbcServices jdbcServices, + QueryOptions queryOptions) { + return limitHandler.processSql( + sql, + jdbcParameterBindings.getBindings().size(), + jdbcServices.getParameterMarkerStrategy(), + queryOptions + ); + } - final boolean commentsEnabled = executionContext.getSession() - .getFactory() - .getSessionFactoryOptions() - .isCommentsEnabled(); - finalSql = dialect.addSqlHintOrComment( sqlWithLocking, queryOptions, commentsEnabled ); + private static String sqlWithLocking( + JdbcLockStrategy jdbcLockStrategy, + String sqlWithLimit, + QueryOptions queryOptions, + Dialect dialect) { + final var lockOptions = queryOptions.getLockOptions(); + if ( hasLocking( jdbcLockStrategy, lockOptions ) ) { + return useFollowOnLocking( jdbcLockStrategy, sqlWithLimit, queryOptions, lockOptions, dialect ) + ? sqlWithLimit + : dialect.applyLocksToSql( sqlWithLimit, lockOptions, emptyMap() ); + } + else { + return sqlWithLimit; } } @@ -221,7 +230,7 @@ protected void bindParameters(PreparedStatement preparedStatement) throws SQLExc } private void setQueryOptions(PreparedStatement preparedStatement) throws SQLException { - final QueryOptions queryOptions = executionContext.getQueryOptions(); + final var queryOptions = executionContext.getQueryOptions(); // set options if ( queryOptions != null ) { final Integer fetchSize = queryOptions.getFetchSize(); @@ -238,10 +247,10 @@ private void setQueryOptions(PreparedStatement preparedStatement) throws SQLExce } private void executeQuery() { - final LogicalConnectionImplementor logicalConnection = + final var logicalConnection = getPersistenceContext().getJdbcCoordinator().getLogicalConnection(); - final SharedSessionContractImplementor session = executionContext.getSession(); + final var session = executionContext.getSession(); try { CORE_LOGGER.tracef( "Executing query to retrieve ResultSet: %s", finalSql ); // prepare the query @@ -254,8 +263,8 @@ private void executeQuery() { if ( sqlStatementLogger.getLogSlowQuery() > 0 ) { executeStartNanos = System.nanoTime(); } - final EventMonitor eventMonitor = session.getEventMonitor(); - final DiagnosticEvent jdbcPreparedStatementExecutionEvent = + final var eventMonitor = session.getEventMonitor(); + final var jdbcPreparedStatementExecutionEvent = eventMonitor.beginJdbcPreparedStatementExecutionEvent(); try { eventListenerManager.jdbcExecuteStatementStart(); @@ -326,8 +335,7 @@ protected LockMode determineFollowOnLockMode(LockOptions lockOptions) { @Override public void release() { - final JdbcCoordinator jdbcCoordinator = - getPersistenceContext().getJdbcCoordinator(); + final var jdbcCoordinator = getPersistenceContext().getJdbcCoordinator(); final LogicalConnectionImplementor logicalConnection = jdbcCoordinator.getLogicalConnection(); if ( resultSet != null ) { logicalConnection.getResourceRegistry().release( resultSet, preparedStatement ); diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DirectResultSetAccess.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DirectResultSetAccess.java index bc2a40a3f88a..8a589ff38565 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DirectResultSetAccess.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DirectResultSetAccess.java @@ -25,7 +25,9 @@ public DirectResultSetAccess( this.resultSetSource = resultSetSource; this.resultSet = resultSet; - persistenceContext.getJdbcCoordinator().getLogicalConnection().getResourceRegistry() + persistenceContext.getJdbcCoordinator() + .getLogicalConnection() + .getResourceRegistry() .register( resultSet, resultSetSource ); } diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesCacheHit.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesCacheHit.java index 45c7f0a037a8..200b050df28e 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesCacheHit.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesCacheHit.java @@ -36,47 +36,44 @@ public JdbcValuesCacheHit(List cachedResults, JdbcValuesMapping resolvedMappi @Override protected boolean processNext(RowProcessingState rowProcessingState) { - // NOTE : explicitly skipping limit handling because the cached state ought - // already be the limited size since the cache key includes limits - + // NOTE: explicitly skipping limit handling because the cached state ought + // already be the limited size since the cache key includes limits position++; - if ( position >= numberOfRows ) { position = numberOfRows; return false; } - - return true; + else { + return true; + } } @Override protected boolean processPrevious(RowProcessingState rowProcessingState) { - // NOTE : explicitly skipping limit handling because the cached state ought - // already be the limited size since the cache key includes limits - + // NOTE: explicitly skipping limit handling because the cached state ought + // already be the limited size since the cache key includes limits position--; - if ( position >= numberOfRows ) { position = numberOfRows; return false; } - - return true; + else { + return true; + } } @Override protected boolean processScroll(int numberOfRows, RowProcessingState rowProcessingState) { - // NOTE : explicitly skipping limit handling because the cached state should - // already be the limited size since the cache key includes limits - + // NOTE: explicitly skipping limit handling because the cached state should + // already be the limited size since the cache key includes limits position += numberOfRows; - if ( position >= this.numberOfRows ) { position = this.numberOfRows; return false; } - - return true; + else { + return true; + } } @Override @@ -86,8 +83,8 @@ public int getPosition() { @Override protected boolean processPosition(int position, RowProcessingState rowProcessingState) { - // NOTE : explicitly skipping limit handling because the cached state should - // already be the limited size since the cache key includes limits + // NOTE: explicitly skipping limit handling because the cached state should + // already be the limited size since the cache key includes limits if ( position < 0 ) { // we need to subtract it from `numberOfRows` @@ -102,9 +99,10 @@ protected boolean processPosition(int position, RowProcessingState rowProcessing this.position = numberOfRows; return false; } - - this.position = position; - return true; + else { + this.position = position; + return true; + } } @Override @@ -140,12 +138,9 @@ public void afterLast(RowProcessingState rowProcessingState) { @Override public boolean isLast(RowProcessingState rowProcessingState) { - if ( numberOfRows == 0 ) { - return position == 0; - } - else { - return position == numberOfRows - 1; - } + return numberOfRows == 0 + ? position == 0 + : position == numberOfRows - 1; } @Override @@ -154,9 +149,10 @@ public boolean last(RowProcessingState rowProcessingState) { position = 0; return false; } - - position = numberOfRows - 1; - return true; + else { + position = numberOfRows - 1; + return true; + } } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingProducerStandard.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingProducerStandard.java index a7af8c6dc243..5d7256703b43 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingProducerStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingProducerStandard.java @@ -50,8 +50,8 @@ public JdbcValuesMapping resolve( final List sqlSelections = resolvedMapping.getSqlSelections(); List resolvedSelections = null; for ( int i = 0; i < sqlSelections.size(); i++ ) { - final SqlSelection sqlSelection = sqlSelections.get( i ); - final SqlSelection resolvedSelection = sqlSelection.resolve( jdbcResultsMetadata, sessionFactory ); + final var sqlSelection = sqlSelections.get( i ); + final var resolvedSelection = sqlSelection.resolve( jdbcResultsMetadata, sessionFactory ); if ( resolvedSelection != sqlSelection ) { if ( resolvedSelections == null ) { resolvedSelections = new ArrayList<>( sqlSelections ); diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingResolutionImpl.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingResolutionImpl.java index fb54e6a4bdc6..2e7414d4ab93 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingResolutionImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesMappingResolutionImpl.java @@ -22,7 +22,10 @@ public JdbcValuesMappingResolutionImpl( DomainResultAssembler[] domainResultAssemblers, boolean hasCollectionInitializers, InitializersList initializersList) { - this( domainResultAssemblers, getResultInitializers( domainResultAssemblers ), hasCollectionInitializers, initializersList ); + this( domainResultAssemblers, + getResultInitializers( domainResultAssemblers ), + hasCollectionInitializers, + initializersList ); } private JdbcValuesMappingResolutionImpl( @@ -38,7 +41,7 @@ private JdbcValuesMappingResolutionImpl( private static Initializer[] getResultInitializers(DomainResultAssembler[] resultAssemblers) { final LinkedHashSet> initializers = new LinkedHashSet<>( resultAssemblers.length ); - for ( DomainResultAssembler resultAssembler : resultAssemblers ) { + for ( var resultAssembler : resultAssemblers ) { resultAssembler.forEachResultAssembler( (initializer, list) -> list.add( initializer ), initializers ); } return initializers.toArray(Initializer.EMPTY_ARRAY); diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesResultSetImpl.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesResultSetImpl.java index 0dd467d924e0..0a20cabb211e 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesResultSetImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesResultSetImpl.java @@ -9,11 +9,8 @@ import java.util.Arrays; import java.util.BitSet; -import org.hibernate.JDBCException; import org.hibernate.QueryTimeoutException; import org.hibernate.cache.spi.QueryKey; -import org.hibernate.cache.spi.QueryResultsCache; -import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.exception.DataException; import org.hibernate.exception.LockTimeoutException; @@ -27,6 +24,8 @@ import org.hibernate.sql.results.jdbc.spi.JdbcValuesMapping; import org.hibernate.sql.results.jdbc.spi.RowProcessingState; +import static java.util.Arrays.copyOf; + /** * {@link AbstractJdbcValues} implementation for a JDBC {@link ResultSet} as the source * @@ -77,7 +76,7 @@ public JdbcValuesResultSetImpl( final int rowSize = valuesMapping.getRowSize(); this.sqlSelections = new SqlSelection[rowSize]; - for ( SqlSelection selection : valuesMapping.getSqlSelections() ) { + for ( var selection : valuesMapping.getSqlSelections() ) { this.sqlSelections[selection.getValuesArrayPosition()] = selection; } this.initializedIndexes = new BitSet( rowSize ); @@ -127,11 +126,10 @@ private static QueryCachePutManager resolveQueryCachePutManager( String queryIdentifier, CachedJdbcValuesMetadata metadataForCache) { if ( queryCacheKey != null ) { - final SessionFactoryImplementor factory = executionContext.getSession().getFactory(); - final QueryResultsCache queryCache = factory.getCache() - .getQueryResultsCache( queryOptions.getResultCacheRegionName() ); + final var factory = executionContext.getSession().getFactory(); return new QueryCachePutManagerEnabledImpl( - queryCache, + factory.getCache() + .getQueryResultsCache( queryOptions.getResultCacheRegionName() ), factory.getStatistics(), queryCacheKey, queryIdentifier, @@ -300,18 +298,16 @@ private boolean advancePrevious() { } private boolean advance(final boolean hasResult) { - if ( ! hasResult ) { - return false; + if ( hasResult ) { + readCurrentRowValues(); } - - readCurrentRowValues(); - return true; + return hasResult; } private ExecutionException makeExecutionException(String message, SQLException cause) { - final JDBCException jdbcException = - executionContext.getSession().getJdbcServices().getSqlExceptionHelper() - .convert( cause, message ); + final var jdbcException = + executionContext.getSession().getJdbcServices() + .getSqlExceptionHelper().convert( cause, message ); if ( jdbcException instanceof QueryTimeoutException || jdbcException instanceof DataException || jdbcException instanceof LockTimeoutException ) { @@ -352,7 +348,7 @@ public void finishRowProcessing(RowProcessingState rowProcessingState, boolean w } final Object objectToCache; if ( valueIndexesToCacheIndexes == null ) { - objectToCache = Arrays.copyOf( currentRowJdbcValues, currentRowJdbcValues.length ); + objectToCache = copyOf( currentRowJdbcValues, currentRowJdbcValues.length ); } else if ( rowToCacheSize < 1 ) { if ( !wasAdded ) { @@ -362,7 +358,7 @@ else if ( rowToCacheSize < 1 ) { objectToCache = currentRowJdbcValues[-rowToCacheSize]; } else { - final Object[] rowToCache = new Object[rowToCacheSize]; + final var rowToCache = new Object[rowToCacheSize]; for ( int i = 0; i < currentRowJdbcValues.length; i++ ) { final int cacheIndex = valueIndexesToCacheIndexes[i]; if ( cacheIndex != -1 ) { @@ -379,7 +375,7 @@ else if ( rowToCacheSize < 1 ) { public Object getCurrentRowValue(int valueIndex) { if ( !initializedIndexes.get( valueIndex ) ) { initializedIndexes.set( valueIndex ); - final SqlSelection sqlSelection = sqlSelections[valueIndex]; + final var sqlSelection = sqlSelections[valueIndex]; final int index = sqlSelection.getJdbcResultSetIndex(); try { currentRowJdbcValues[valueIndex] = sqlSelection.getJdbcValueExtractor().extract( diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesSourceProcessingStateStandardImpl.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesSourceProcessingStateStandardImpl.java index a45c3200e46f..0b77d5c813db 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesSourceProcessingStateStandardImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/JdbcValuesSourceProcessingStateStandardImpl.java @@ -12,7 +12,6 @@ import org.hibernate.engine.spi.CollectionKey; import org.hibernate.engine.spi.EntityHolder; import org.hibernate.engine.spi.SharedSessionContractImplementor; -import org.hibernate.event.spi.EventSource; import org.hibernate.event.spi.PostLoadEvent; import org.hibernate.event.spi.PreLoadEvent; import org.hibernate.query.spi.QueryOptions; @@ -46,7 +45,7 @@ public JdbcValuesSourceProcessingStateStandardImpl( this.processingOptions = processingOptions; if ( executionContext.getSession().isEventSource() ) { - final EventSource eventSource = executionContext.getSession().asEventSource(); + final var eventSource = executionContext.getSession().asEventSource(); preLoadEvent = new PreLoadEvent( eventSource ); postLoadEvent = new PostLoadEvent( eventSource ); } @@ -151,33 +150,19 @@ public SharedSessionContractImplementor getSession() { public void finishUp(boolean registerSubselects) { // now we can finalize loading collections finishLoadingCollections(); - getSession().getPersistenceContextInternal() .postLoad( this, registerSubselects ? executionContext::registerLoadingEntityHolder : null ); } - private boolean isReadOnly() { - if ( getQueryOptions().isReadOnly() != null ) { - return getQueryOptions().isReadOnly(); - } - else if ( getSession() instanceof EventSource ) { - return getSession().isDefaultReadOnly(); - } - else { - return false; - } - } - /** * For Hibernate Reactive */ public void finishLoadingCollections() { if ( loadingCollectionMap != null ) { - for ( LoadingCollectionEntry loadingCollectionEntry : loadingCollectionMap.values() ) { + for ( var loadingCollectionEntry : loadingCollectionMap.values() ) { loadingCollectionEntry.finishLoading( getExecutionContext() ); } - loadingCollectionMap = null; } } diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/StandardJdbcValuesMapping.java b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/StandardJdbcValuesMapping.java index e83c28974af9..5e0736432f70 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/StandardJdbcValuesMapping.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/StandardJdbcValuesMapping.java @@ -6,6 +6,7 @@ import java.util.BitSet; import java.util.List; +import java.util.Objects; import java.util.function.Supplier; import org.hibernate.LockMode; @@ -55,15 +56,15 @@ public StandardJdbcValuesMapping( this.domainResults = domainResults; final int rowSize = sqlSelections.size(); - final BitSet valueIndexesToCache = new BitSet( rowSize ); - for ( DomainResult domainResult : domainResults ) { + final var valueIndexesToCache = new BitSet( rowSize ); + for ( var domainResult : domainResults ) { domainResult.collectValueIndexesToCache( valueIndexesToCache ); } final int[] valueIndexesToCacheIndexes = new int[rowSize]; int cacheIndex = 0; boolean needsResolve = false; for ( int i = 0; i < valueIndexesToCacheIndexes.length; i++ ) { - final SqlSelection sqlSelection = sqlSelections.get( i ); + final var sqlSelection = sqlSelections.get( i ); needsResolve = needsResolve || sqlSelection instanceof SqlSelectionImpl selection && selection.needsResolve(); if ( valueIndexesToCache.get( i ) ) { @@ -114,7 +115,7 @@ public JdbcValuesMappingResolution resolveAssemblers(SessionFactoryImplementor s return resolution; } else { - final AssemblerCreationStateImpl creationState = + final var creationState = new AssemblerCreationStateImpl( this, sessionFactory.getSqlTranslationEngine() ); final var domainResultAssemblers = resolveAssemblers( creationState ); @@ -132,7 +133,7 @@ private DomainResultAssembler[] resolveAssemblers(AssemblerCreationState crea final int size = domainResults.size(); final List> assemblers = arrayList( size ); for ( int i = 0; i < size; i++ ) { - final DomainResultAssembler resultAssembler = + final var resultAssembler = domainResults.get( i ) .createResultAssembler( null, creationState ); assemblers.add( resultAssembler ); @@ -166,9 +167,9 @@ public AssemblerCreationStateImpl( @Override public boolean isDynamicInstantiation() { if ( dynamicInstantiation == null ) { - dynamicInstantiation = jdbcValuesMapping.getDomainResults() - .stream() - .anyMatch( domainResult -> domainResult instanceof DynamicInstantiationResult ); + dynamicInstantiation = + jdbcValuesMapping.getDomainResults().stream() + .anyMatch( domainResult -> domainResult instanceof DynamicInstantiationResult ); } return dynamicInstantiation; } @@ -177,7 +178,7 @@ public boolean isDynamicInstantiation() { public boolean containsMultipleCollectionFetches() { if ( containsMultipleCollectionFetches == null ) { int collectionFetchesCount = 0; - for ( DomainResult domainResult : jdbcValuesMapping.getDomainResults() ) { + for ( var domainResult : jdbcValuesMapping.getDomainResults() ) { if ( domainResult instanceof FetchParent fetchParent ) { collectionFetchesCount += fetchParent.getCollectionFetchesCount(); } @@ -226,16 +227,15 @@ public Initializer resolveInitializer( T resultGraphNode, InitializerParent parent, InitializerProducer producer) { - final Initializer existing = initializerMap.get( navigablePath ); - if ( existing != null ) { - if ( fetchedModelPart.getNavigableRole().equals( + final var existing = initializerMap.get( navigablePath ); + if ( existing != null + && Objects.equals( fetchedModelPart.getNavigableRole(), existing.getInitializedPart().getNavigableRole() ) ) { - RESULTS_MESSAGE_LOGGER.tracef( "Returning previously-registered initializer: %s", existing ); - return existing; - } + RESULTS_MESSAGE_LOGGER.tracef( "Returning previously-registered initializer: %s", existing ); + return existing; } - final Initializer initializer = producer.createInitializer( resultGraphNode, parent, this ); + final var initializer = producer.createInitializer( resultGraphNode, parent, this ); RESULTS_MESSAGE_LOGGER.tracef( "Registering initializer: %s", initializer ); if ( initializer instanceof AbstractImmediateCollectionInitializer ) {