Skip to content

Commit 2ca37ac

Browse files
beikovbeikov
committed
HHH-16781 @javatype annotation is ignored when basic type is already registered for the preferred JdbcType
1 parent e61c30e commit 2ca37ac

File tree

6 files changed

+51
-59
lines changed

6 files changed

+51
-59
lines changed

‎hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@
4040
import org.hibernate.query.sqm.function.SqmFunctionDescriptor;
4141
import org.hibernate.query.sqm.function.SqmFunctionRegistry;
4242
import org.hibernate.resource.beans.spi.BeanInstanceProducer;
43-
import org.hibernate.type.internal.BasicTypeImpl;
43+
import org.hibernate.type.BasicType;
4444
import org.hibernate.type.spi.TypeConfiguration;
4545

4646
import org.jboss.jandex.IndexView;
@@ -220,17 +220,17 @@ public Collection<CacheRegionDefinition> getCacheRegionDefinitions() {
220220
return cacheRegionDefinitions == null ? Collections.emptyList() : cacheRegionDefinitions;
221221
}
222222

223-
private final Map<String,BasicTypeImpl<?>> adHocBasicTypeRegistrations = new HashMap<>();
223+
private final Map<String,BasicType<?>> adHocBasicTypeRegistrations = new HashMap<>();
224224

225225
@Override
226-
public void registerAdHocBasicType(BasicTypeImpl<?> basicType) {
226+
public void registerAdHocBasicType(BasicType<?> basicType) {
227227
adHocBasicTypeRegistrations.put( basicType.getName(), basicType );
228228
}
229229

230230
@Override
231-
public <T> BasicTypeImpl<T> resolveAdHocBasicType(String key) {
231+
public <T> BasicType<T> resolveAdHocBasicType(String key) {
232232
//noinspection unchecked
233-
return (BasicTypeImpl<T>) adHocBasicTypeRegistrations.get( key );
233+
return (BasicType<T>) adHocBasicTypeRegistrations.get( key );
234234
}
235235

236236
@Override

‎hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -527,7 +527,8 @@ public static <T> InferredBasicValueResolution<T,T> fromTemporal(
527527
);
528528
}
529529
else {
530-
jtd = reflectedJtd;
530+
// Avoid using the DateJavaType and prefer the JdbcTimestampJavaType
531+
jtd = reflectedJtd.resolveTypeForPrecision( reflectedJtd.getPrecision(), typeConfiguration );
531532
}
532533

533534
final BasicType<T> jdbcMapping = typeConfiguration.getBasicTypeRegistry().resolve( jtd, explicitJdbcType );
@@ -556,7 +557,8 @@ public static <T> InferredBasicValueResolution<T,T> fromTemporal(
556557
}
557558
else {
558559
basicType = typeConfiguration.getBasicTypeRegistry().resolve(
559-
reflectedJtd,
560+
// Avoid using the DateJavaType and prefer the JdbcTimestampJavaType
561+
reflectedJtd.resolveTypeForPrecision( reflectedJtd.getPrecision(), typeConfiguration ),
560562
reflectedJtd.getRecommendedJdbcType( stdIndicators )
561563
);
562564
}

‎hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@
2727
import org.hibernate.query.sqm.function.SqmFunctionDescriptor;
2828
import org.hibernate.query.sqm.function.SqmFunctionRegistry;
2929
import org.hibernate.resource.beans.spi.BeanInstanceProducer;
30-
import org.hibernate.type.internal.BasicTypeImpl;
30+
import org.hibernate.type.BasicType;
3131
import org.hibernate.type.spi.TypeConfiguration;
3232

3333
import org.jboss.jandex.IndexView;
@@ -232,10 +232,10 @@ default IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
232232
/**
233233
* To support Envers.
234234
*/
235-
void registerAdHocBasicType(BasicTypeImpl<?> basicType);
235+
void registerAdHocBasicType(BasicType<?> basicType);
236236

237237
/**
238238
* To support Envers.
239239
*/
240-
<T> BasicTypeImpl<T> resolveAdHocBasicType(String key);
240+
<T> BasicType<T> resolveAdHocBasicType(String key);
241241
}

‎hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -595,8 +595,7 @@ public TypeConfiguration getTypeConfiguration() {
595595
}
596596

597597
if ( name.startsWith( BasicTypeImpl.EXTERNALIZED_PREFIX ) ) {
598-
final BasicTypeImpl<Object> basicType = context.getBootstrapContext().resolveAdHocBasicType( name );
599-
598+
final BasicType<Object> basicType = context.getBootstrapContext().resolveAdHocBasicType( name );
600599
return new NamedBasicTypeResolution<>(
601600
basicType.getJavaTypeDescriptor(),
602601
basicType,

‎hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java‎

Lines changed: 35 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -146,9 +146,9 @@ public <J> BasicType<J> resolve(java.lang.reflect.Type javaType, int sqlTypeCode
146146
return resolve( typeConfiguration.getJavaTypeRegistry().getDescriptor( javaType ), sqlTypeCode );
147147
}
148148

149-
public <J> BasicType<J> resolve(JavaType<J> jtdToUse, int sqlTypeCode) {
149+
public <J> BasicType<J> resolve(JavaType<J> javaType, int sqlTypeCode) {
150150
return resolve(
151-
jtdToUse,
151+
javaType,
152152
typeConfiguration.getJdbcTypeRegistry().getDescriptor( sqlTypeCode )
153153
);
154154
}
@@ -157,63 +157,54 @@ public <J> BasicType<J> resolve(JavaType<J> jtdToUse, int sqlTypeCode) {
157157
* Find an existing {@link BasicType} registration for the given {@link JavaType}
158158
* descriptor and {@link JdbcType} descriptor combo or create (and register) one.
159159
*/
160-
public <J> BasicType<J> resolve(JavaType<J> jtdToUse, JdbcType stdToUse) {
160+
public <J> BasicType<J> resolve(JavaType<J> javaType, JdbcType jdbcType) {
161161
return resolve(
162-
jtdToUse,
163-
stdToUse,
164-
() -> {
165-
final BasicTypeImpl<J> basicType = new BasicTypeImpl<>( jtdToUse, stdToUse );
166-
167-
// if we are still building mappings, register this ad-hoc type
168-
// via a unique code. this is to support envers
169-
try {
170-
typeConfiguration.getMetadataBuildingContext().getBootstrapContext()
171-
.registerAdHocBasicType( basicType );
172-
}
173-
catch (Exception ignore) {
174-
}
175-
176-
return basicType;
177-
}
162+
javaType,
163+
jdbcType,
164+
() -> new BasicTypeImpl<>( javaType, jdbcType )
178165
);
179166
}
180167

181-
public <J> BasicType<J> resolve(JavaType<J> jtdToUse, JdbcType stdToUse, String baseTypeName) {
168+
public <J> BasicType<J> resolve(JavaType<J> javaType, JdbcType jdbcType, String baseTypeName) {
182169
return resolve(
183-
jtdToUse,
184-
stdToUse,
185-
() -> new NamedBasicTypeImpl<>( jtdToUse, stdToUse, baseTypeName )
170+
javaType,
171+
jdbcType,
172+
() -> new NamedBasicTypeImpl<>( javaType, jdbcType, baseTypeName )
186173
);
187174
}
188175

189176
/**
190177
* Find an existing BasicType registration for the given JavaType and
191178
* JdbcType combo or create (and register) one.
192179
*/
193-
public <J> BasicType<J> resolve(JavaType<J> jtdToUse, JdbcType stdToUse, Supplier<BasicType<J>> creator) {
194-
final Map<JavaType<?>, BasicType<?>> typeByJtdForStd = registryValues.computeIfAbsent(
195-
stdToUse,
196-
sqlTypeDescriptor -> new ConcurrentHashMap<>()
180+
public <J> BasicType<J> resolve(JavaType<J> javaType, JdbcType jdbcType, Supplier<BasicType<J>> creator) {
181+
final Map<JavaType<?>, BasicType<?>> typeByJavaTypeForJdbcType = registryValues.computeIfAbsent(
182+
jdbcType,
183+
key -> new ConcurrentHashMap<>()
197184
);
198185

199-
final BasicType<?> foundBasicType = typeByJtdForStd.get( jtdToUse );
186+
final BasicType<?> foundBasicType = typeByJavaTypeForJdbcType.get( javaType );
200187
if ( foundBasicType != null ) {
201188
//noinspection unchecked
202189
return (BasicType<J>) foundBasicType;
203190
}
204191
// Before simply creating the type, we try to find if there is a registered type for this java type,
205192
// and if so, if the jdbc type descriptor matches. Unless it does, we at least reuse the name
206-
final BasicType<J> basicType = getRegisteredType( jtdToUse.getJavaType() );
207-
if ( basicType != null ) {
208-
if ( basicType.getJdbcType() == stdToUse ) {
209-
return basicType;
210-
}
211-
else {
212-
return new NamedBasicTypeImpl<>( jtdToUse, stdToUse, basicType.getName() );
213-
}
193+
final BasicType<J> registeredType = getRegisteredType( javaType.getJavaType() );
194+
if ( registeredType != null && registeredType.getJdbcType() == jdbcType && registeredType.getMappedJavaType() == javaType ) {
195+
return registeredType;
214196
}
215197
final BasicType<J> createdBasicType = creator.get();
216-
typeByJtdForStd.put( jtdToUse, createdBasicType );
198+
typeByJavaTypeForJdbcType.put( javaType, createdBasicType );
199+
200+
// if we are still building mappings, register this ad-hoc type
201+
// via a unique code. this is to support envers
202+
try {
203+
typeConfiguration.getMetadataBuildingContext().getBootstrapContext()
204+
.registerAdHocBasicType( createdBasicType );
205+
}
206+
catch (Exception ignore) {
207+
}
217208
return createdBasicType;
218209
}
219210

@@ -250,12 +241,12 @@ public void register(BasicType<?> type, String... keys) {
250241
}
251242

252243
private void applyOrOverwriteEntry(BasicType<?> type) {
253-
final Map<JavaType<?>, BasicType<?>> mappingsForStdToUse = registryValues.computeIfAbsent(
244+
final Map<JavaType<?>, BasicType<?>> typeByJavaTypeForJdbcType = registryValues.computeIfAbsent(
254245
type.getJdbcType(),
255-
sqlTypeDescriptor -> new ConcurrentHashMap<>()
246+
jdbcType -> new ConcurrentHashMap<>()
256247
);
257248

258-
final BasicType<?> existing = mappingsForStdToUse.put( type.getMappedJavaType(), type );
249+
final BasicType<?> existing = typeByJavaTypeForJdbcType.put( type.getMappedJavaType(), type );
259250
if ( existing != null ) {
260251
LOG.debugf(
261252
"BasicTypeRegistry registration overwritten (%s + %s); previous =`%s`",
@@ -350,12 +341,12 @@ public void addPrimeEntry(BasicTypeReference<?> type, String legacyTypeClassName
350341
}
351342

352343
private void primeRegistryEntry(BasicType<?> type) {
353-
final Map<JavaType<?>, BasicType<?>> mappingsForStdToUse = registryValues.computeIfAbsent(
344+
final Map<JavaType<?>, BasicType<?>> typeByJavaTypeForJdbcType = registryValues.computeIfAbsent(
354345
type.getJdbcType(),
355-
sqlTypeDescriptor -> new ConcurrentHashMap<>()
346+
jdbcType -> new ConcurrentHashMap<>()
356347
);
357348

358-
final BasicType<?> existing = mappingsForStdToUse.get( type.getMappedJavaType() );
349+
final BasicType<?> existing = typeByJavaTypeForJdbcType.get( type.getMappedJavaType() );
359350

360351
if ( existing != null ) {
361352
LOG.debugf(
@@ -366,7 +357,7 @@ private void primeRegistryEntry(BasicType<?> type) {
366357
);
367358
}
368359
else {
369-
mappingsForStdToUse.put( type.getMappedJavaType(), type );
360+
typeByJavaTypeForJdbcType.put( type.getMappedJavaType(), type );
370361
}
371362
}
372363

‎hibernate-testing/src/main/java/org/hibernate/testing/boot/BootstrapContextImpl.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@
2929
import org.hibernate.query.sqm.function.SqmFunctionDescriptor;
3030
import org.hibernate.query.sqm.function.SqmFunctionRegistry;
3131
import org.hibernate.resource.beans.spi.BeanInstanceProducer;
32-
import org.hibernate.type.internal.BasicTypeImpl;
32+
import org.hibernate.type.BasicType;
3333
import org.hibernate.type.spi.TypeConfiguration;
3434

3535
import org.jboss.jandex.IndexView;
@@ -159,11 +159,11 @@ public ManagedTypeRepresentationResolver getRepresentationStrategySelector() {
159159
}
160160

161161
@Override
162-
public void registerAdHocBasicType(BasicTypeImpl<?> basicType) {
162+
public void registerAdHocBasicType(BasicType<?> basicType) {
163163
}
164164

165165
@Override
166-
public <T> BasicTypeImpl<T> resolveAdHocBasicType(String key) {
166+
public <T> BasicType<T> resolveAdHocBasicType(String key) {
167167
return null;
168168
}
169169

0 commit comments

Comments
 (0)