dependencies{implementationplatform"org.hibernate.orm:hibernate-platform:7.2.0.CR3"// use the versions from the platformimplementation"org.hibernate.orm:hibernate-core"implementation"jakarta.transaction:jakarta.transaction-api"}

<dependencyManagement><dependencies><dependency><groupId>org.hibernate.orm</groupId><artifactId>hibernate-platform</artifactId><version>7.2.0.CR3</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><!-- use the versions from the platform --><dependencies><dependency><groupId>org.hibernate.orm</groupId><artifactId>hibernate-core</artifactId></dependency><dependency><groupId>jakarta.transaction</groupId><artifactId>jakarta.transaction-api</artifactId></dependency></dependencies>

A value type is a piece of data that does not define its own lifecycle.It is, in effect, owned by an entity, which defines its lifecycle.

Looked at another way, all the state of an entity is made up entirely of value types.These state fields or JavaBean properties are termedpersistent attributes.The persistent attributes of theContact class are value types.

Value types are further classified into three sub-categories:

Basic types

in mapping theContact table, all attributes except for name would be basic types. Basic types are discussed in detail inBasic types

Embeddable types

thename attribute is an example of an embeddable type, which is discussed in details inEmbeddable types

Collection types

although not featured in the aforementioned example, collection types are also a distinct category among value types. Collection types are further discussed inCollections

Entities, by nature of their unique identifier, exist independently of other objects whereas values do not.Entities are domain model classes which correlate to rows in a database table, using a unique identifier.Because of the requirement for a unique identifier, entities exist independently and define their own lifecycle.TheContact class itself would be an example of an entity.

Mapping entities is discussed in detail inEntity types.

Strictly speaking, a basic type is denoted by thejakarta.persistence.Basic annotation.

Generally, the@Basic annotation can be ignored as it is assumed by default. Both of the followingexamples are ultimately the same.

The@Basic annotation defines 2 attributes.

optional - boolean (defaults to true)

Defines whether this attribute allows nulls. Jakarta Persistence definesthis as "a hint", which means the provider is free to ignore it. Jakarta Persistence also says that it will beignored if the type is primitive. As long as the type is not primitive, Hibernate will honor thisvalue. Works in conjunction with@Column#nullable - see@Column.

fetch - FetchType (defaults to EAGER)

Defines whether this attribute should be fetched eagerly or lazily.EAGER indicates that the value will be fetched as part of loading the owner.LAZY values arefetched only when the value is accessed. Jakarta Persistence requires providers to supportEAGER, while support forLAZY is optional meaning that a provider is free to not support it. Hibernate supports lazy loadingof basic values as long as you are using itsbytecode enhancementsupport.

Jakarta Persistence defines rules for implicitly determining the name of tables and columns.For a detailed discussion of implicit naming seeNaming strategies.

For basic type attributes, the implicit naming rule is that the column name is the same as the attribute name.If that implicit naming rule does not meet your requirements, you can explicitly tell Hibernate (and other providers) the column name to use.

Here we use@Column to explicitly map thedescription attribute to theNOTES column, as opposed to theimplicit column namedescription. SeeNaming strategies for additional details.

The@Column annotation defines other mapping information as well. See its Javadocs for details.

@Formula allows mapping any database computed value as a virtual read-only column.

When loading theAccount entity, Hibernate is going to calculate theinterest property using the configured@Formula:

To deal with values of basic type, Hibernate needs to understand a few things about the mapping:

• The capabilities of the Java type. For example:

  • How to compare values

  • How to calculate a hash-code

  • How to coerce values of this type to another type

• The JDBC type it should use

  • How to bind values to JDBC statements

  • How to extract from JDBC results

• Any conversion it should perform on the value to/from the database

• The mutability of the value - whether the internal state can change likejava.util.Date or is immutable likejava.lang.String

This section covers how Hibernate determines these pieces and how to influence that determination process.

Looking atthis example, how does Hibernate know what mappingto use for these attributes? The annotations do not really provide much information.

This is an illustration of Hibernate’s implicit basic-type resolution, which is a series of checks to determinethe appropriate mapping to use. Describing the complete process for implicit resolution is beyond the scopeof this documentation^[2].

This is primarily driven by the Java type defined for the basic type, which can generallybe determined through reflection. Is the Java type an enum? Is it temporal? These answerscan indicate certain mappings be used.

The fallback is to map the value to the "recommended" JDBC type.

Worst case, if the Java type isSerializable Hibernate will try to handle it via binary serialization.

For cases where the Java type is not a standard type or if some specialized handling is desired, Hibernateprovides 2 main approaches to influence this mapping resolution:

• A compositional approach using a combination of one-or-more annotations to describe specificaspects of the mapping. This approach is covered inCompositional basic mapping.

• TheUserType contract, which is covered inCustom type mapping

These 2 approaches should be considered mutually exclusive. A custom UserType will alwaystake precedence over compositional annotations.

The next few sections look at common, standard Java types and discusses various ways to map them.SeeCase Study : BitSet for examples of mappingBitSet as a basic type using all of these approaches.

Hibernate supports the mapping of Java enums as basic value types in a number of different ways.

@Enumerated

publicenumPhoneType{LAND_LINE,MOBILE;}

@Entity(name="Phone")publicstaticclassPhone{@IdprivateLongid;@Column(name="phone_number")privateStringnumber;@Enumerated(EnumType.ORDINAL)@Column(name="phone_type")privatePhoneTypetype;//Getters and setters are omitted for brevity}

Phonephone=newPhone();phone.setId(1L);phone.setNumber("123-456-78990");phone.setType(PhoneType.MOBILE);entityManager.persist(phone);

INSERTINTOPhone(phone_number,phone_type,id)VALUES('123-456-78990',1,1)

@Entity(name="Phone")publicstaticclassPhone{@IdprivateLongid;@Column(name="phone_number")privateStringnumber;@Enumerated(EnumType.STRING)@Column(name="phone_type")privatePhoneTypetype;//Getters and setters are omitted for brevity}

INSERTINTOPhone(phone_number,phone_type,id)VALUES('123-456-78990','MOBILE',1)

Using AttributeConverter

publicenumGender{MALE('M'),FEMALE('F');privatefinalcharcode;Gender(charcode){this.code=code;}publicstaticGenderfromCode(charcode){if(code=='M'||code=='m'){returnMALE;}if(code=='F'||code=='f'){returnFEMALE;}thrownewUnsupportedOperationException("The code "+code+" is not supported!");}publicchargetCode(){returncode;}}

@Entity(name="Person")publicstaticclassPerson{@IdprivateLongid;privateStringname;@Convert(converter=GenderConverter.class)publicGendergender;//Getters and setters are omitted for brevity}@ConverterpublicstaticclassGenderConverterimplementsAttributeConverter<Gender,Character>{publicCharacterconvertToDatabaseColumn(Gendervalue){if(value==null){returnnull;}returnvalue.getCode();}publicGenderconvertToEntityAttribute(Charactervalue){if(value==null){returnnull;}returnGender.fromCode(value);}}

Custom type

@Entity(name="Person")publicstaticclassPerson{@IdprivateLongid;privateStringname;@Type(GenderType.class)@Column(length=6)publicGendergender;//Getters and setters are omitted for brevity}publicclassGenderTypeextendsUserTypeSupport<Gender>{publicGenderType(){super(Gender.class,Types.CHAR);}}publicclassGenderJavaTypeextendsAbstractClassJavaType<Gender>{publicstaticfinalGenderJavaTypeINSTANCE=newGenderJavaType();protectedGenderJavaType(){super(Gender.class);}publicStringtoString(Gendervalue){returnvalue==null?null:value.name();}publicGenderfromString(CharSequencestring){returnstring==null?null:Gender.valueOf(string.toString());}public<X>Xunwrap(Gendervalue,Class<X>type,WrapperOptionsoptions){returnCharacterJavaType.INSTANCE.unwrap(value==null?null:value.getCode(),type,options);}public<X>Genderwrap(Xvalue,WrapperOptionsoptions){returnGender.fromCode(CharacterJavaType.INSTANCE.wrap(value,options));}}

By default,Boolean attributes map toBOOLEAN columns, at least when the database has adedicatedBOOLEAN type. On databases which don’t, Hibernate uses whatever else is available:BIT,TINYINT, orSMALLINT.

However, it is quite common to find boolean values encoded as a character or as an integer.Such cases are exactly the intention ofAttributeConverter. For convenience, Hibernateprovides 3 built-in converters for the common boolean mapping cases:

• YesNoConverter encodes a boolean value as'Y' or'N',

• TrueFalseConverter encodes a boolean value as'T' or'F', and

• NumericBooleanConverter encodes the value as an integer,1 for true, and0 for false.

If the boolean value is defined in the database as something other thanBOOLEAN, character or integer,the value can also be mapped using a customAttributeConverter - seeAttributeConverters.

AUserType may also be used - seeCustom type mapping

By default, Hibernate maps values ofByte /byte to theTINYINT JDBC type.

SeeByte array for mapping arrays of bytes.

By default, Hibernate maps values ofShort /short to theSMALLINT JDBC type.

By default, Hibernate maps values ofInteger /int to theINTEGER JDBC type.

By default, Hibernate maps values ofLong /long to theBIGINT JDBC type.

By default, Hibernate maps values ofBigInteger to theNUMERIC JDBC type.

By default, Hibernate maps values ofDouble to theDOUBLE,FLOAT,REAL orNUMERIC JDBC type depending on the capabilities of the database

A specific type can be influenced using any of the JDBC type influencers covered inJdbcType section.

If@JdbcTypeCode is used, the Dialect is still consulted to make sure the databasesupports the requested type. If not, an appropriate type is selected

By default, Hibernate maps values ofFloat to theFLOAT,REAL orNUMERIC JDBC type depending on the capabilities of the database.

A specific type can be influenced using any of the JDBC type influencers covered inMapping basic values section.

If@JdbcTypeCode is used, the Dialect is still consulted to make sure the databasesupports the requested type. If not, an appropriate type is selected

By default, Hibernate maps values ofBigDecimal to theNUMERIC JDBC type.

By default, Hibernate mapsCharacter to theCHAR JDBC type.

By default, Hibernate mapsString to theVARCHAR JDBC type.

Optionally, you may specify the maximum length of the string using@Column(length=…​),or using the@Size annotation from Hibernate Validator.For very large strings, you can use one of the constant values defined by the classorg.hibernate.Length, for example:

Alternatively, you may explicitly specify the JDBC typeLONGVARCHAR, which is treatedas aVARCHAR mapping with defaultlength=Length.LONG when nolength is explicitlyspecified:

If you use Hibernate for schema generation, Hibernate will generate DDL with a column typethat is large enough to accommodate the maximum length you’ve specified.

SeeHandling LOB data for details on mapping to a database CLOB.

For databases which support nationalized character sets, you can also store strings asnationalized data.

SeeHandling nationalized character data for details on mapping strings using nationalized character sets.

By default, Hibernate mapschar[] to theVARCHAR JDBC type.SinceCharacter[] can contain null elements, it is mapped asbasic array type instead.Prior to Hibernate 6.2, alsoCharacter[] mapped toVARCHAR, yet disallowednull elements.To continue mappingCharacter[] to theVARCHAR JDBC type, or for LOBs mapping to theCLOB JDBC type,it is necessary to annotate the persistent attribute with@JavaType( CharacterArrayJavaType.class ).

SeeHandling LOB data for details on mapping as database LOB.

For databases which support nationalized character sets, you can also store character arrays asnationalized data.

SeeHandling nationalized character data for details on mapping strings using nationalized character sets.

By default, Hibernate will map thejava.sql.Clob Java type toCLOB andjava.sql.NClob toNCLOB.

Considering we have the following database table:

Let’s first map this using the@Lob Jakarta Persistence annotation and thejava.sql.Clob type:

To persist such an entity, you have to create aClob using theClobProxy Hibernate utility:

To retrieve theClob content, you need to transform the underlyingjava.io.Reader:

We could also map the CLOB in a materialized form. This way, we can either use aString or achar[].

We might even want the materialized data as a char array.

Just like withCLOB, Hibernate can also deal withNCLOB SQL data types:

Hibernate can map theNCLOB to ajava.sql.NClob

To persist such an entity, you have to create anNClob using theNClobProxy Hibernate utility:

To retrieve theNClob content, you need to transform the underlyingjava.io.Reader:

We could also map theNCLOB in a materialized form. This way, we can either use aString or achar[].

We might even want the materialized data as a char array.

By default, Hibernate mapsbyte[] to theVARBINARY JDBC type.SinceByte[] can contain null elements, it is mapped asbasic array type instead.Prior to Hibernate 6.2, alsoByte[] mapped toVARBINARY, yet disallowednull elements.To continue mappingByte[] to theVARBINARY JDBC type, or for LOBs mapping to theBLOB JDBC type,it is necessary to annotate the persistent attribute with@JavaType( ByteArrayJavaType.class ).

Just like with strings, you may specify the maximum length using@Column(length=…​)or the@Size annotation from Hibernate Validator.For very large arrays, you can use the constants defined byorg.hibernate.Length.Alternatively@JdbcTypeCode(Types.LONGVARBINARY) is treated as aVARBINARY mappingwith defaultlength=Length.LONG when no length is explicitly specified.

If you use Hibernate for schema generation, Hibernate will generate DDL with a column typethat is large enough to accommodate the maximum length you’ve specified.

SeeHandling LOB data for details on mapping to a database BLOB.

By default, Hibernate will map thejava.sql.Blob Java type toBLOB.

Considering we have the following database table:

Let’s first map this using the JDBCjava.sql.Blob type.

To persist such an entity, you have to create aBlob using theBlobProxy Hibernate utility:

To retrieve theBlob content, you need to transform the underlyingjava.io.InputStream:

We could also map the BLOB in a materialized form (e.g.byte[]).

By default, Hibernate mapsDuration to theNUMERIC SQL type.

Instant is mapped to theTIMESTAMP_UTC SQL type.

SeeHandling temporal data for basics of temporal mapping

LocalDate is mapped to theDATE JDBC type.

SeeHandling temporal data for basics of temporal mapping

LocalDateTime is mapped to theTIMESTAMP JDBC type.

SeeHandling temporal data for basics of temporal mapping

LocalTime is mapped to theTIME JDBC type.

SeeHandling temporal data for basics of temporal mapping

OffsetDateTime is mapped to theTIMESTAMP orTIMESTAMP_WITH_TIMEZONE JDBC typedepending on the database.

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

OffsetTime is mapped to theTIME orTIME_WITH_TIMEZONE JDBC typedepending on the database.

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

TimeZone is mapped toVARCHAR JDBC type.

ZonedDateTime is mapped to theTIMESTAMP orTIMESTAMP_WITH_TIMEZONE JDBC typedepending on the database.

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

ZoneOffset is mapped toVARCHAR JDBC type.

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

SeeHandling temporal data for basics of temporal mappingSeeUsing a specific time zone for basics of time-zone handling

Hibernate mapsClass references toVARCHAR JDBC type

Hibernate mapsCurrency references toVARCHAR JDBC type

Hibernate mapsLocale references toVARCHAR JDBC type

Hibernate allows mapping UUID values in a number of ways. By default, Hibernate willstore UUID values in the native form by using the SQL typeUUID or in binary form with theBINARY JDBC typeif the database does not have a native UUID type.

UUID as binary

UUID as (var)char

UUID as identifier

By default, Hibernate will mapInetAddress to theINET SQL type and fallback toBINARY if necessary.

Hibernate will only use theJSON type if explicitly configured through@JdbcTypeCode( SqlTypes.JSON ).The JSON library used for serialization/deserialization is detected automatically,but can be overridden by settinghibernate.type.json_format_mapperas can be read in theConfigurations section.

Hibernate will only use theXML type if explicitly configured through@JdbcTypeCode( SqlTypes.SQLXML ).The XML library used for serialization/deserialization is detected automatically,but can be overridden by settinghibernate.type.xml_format_mapperas can be read in theConfigurations section.

Basic arrays, other thanbyte[]/Byte[] andchar[]/Character[], map to the type codeSqlTypes.ARRAY by default,which maps to the SQL standardarray type if possible,as determined via the new methodsgetArrayTypeName andsupportsStandardArrays oforg.hibernate.dialect.Dialect.If SQL standard array types are not available, data will be modeled asSqlTypes.JSON,SqlTypes.XML orSqlTypes.VARBINARY,depending on the database support as determined via the new methodorg.hibernate.dialect.Dialect.getPreferredSqlTypeCodeForArray.

Basic collections (only subtypes ofCollection), which are not annotated with@ElementCollection,map to the type codeSqlTypes.ARRAY by default, which maps to the SQL standardarray type if possible,as determined via the new methodsgetArrayTypeName andsupportsStandardArrays oforg.hibernate.dialect.Dialect.If SQL standard array types are not available, data will be modeled asSqlTypes.JSON,SqlTypes.XML orSqlTypes.VARBINARY,depending on the database support as determined via the new methodorg.hibernate.dialect.Dialect.getPreferredSqlTypeCodeForArray.

The compositional approach allows defining how the mapping should work in terms of influencingindividual parts that make up a basic-value mapping. This section will look at these individualparts and the specifics of influencing each.

JavaType

JdbcType

MutabilityPlan

BasicValueConverter

Resolving the composition

Another approach is to supply the implementation of theorg.hibernate.usertype.UserType contract using@Type.

There are also corresponding, specialized forms of@Type for specific model parts:

• When mapping a Map,@Type describes the Map value while@MapKeyType describe the Map key

• When mapping an id-bag,@Type describes the elements while@CollectionIdType describes the collection-id

• For other collection mappings,@Type describes the elements

• For discriminated association mappings (@Any and@ManyToAny),@Type describes the discriminator value

@Type allows for more complex mapping concerns; but,AttributeConverter andCompositional basic mapping should generally be preferred as simpler solutions

How nationalized character data is handled and stored depends on the underlying database.

Most databases support storing nationalized character data through the standardized SQLNCHAR, NVARCHAR, LONGNVARCHAR and NCLOB variants.

Others support storing nationalized data as part of CHAR, VARCHAR, LONGVARCHARand CLOB. Generally these databases do not support NCHAR, NVARCHAR, LONGNVARCHARand NCLOB, even as aliased types.

Ultimately Hibernate understands this throughDialect#getNationalizationSupport()

To ensure nationalized character data gets stored and accessed correctly,@Nationalizedcan be used locally orhibernate.use_nationalized_character_data can be set globally.

Considering we have the following database table:

To map a specific attribute to a nationalized variant data type, Hibernate defines the@Nationalized annotation.

The@Lob annotation specifies that character or binary data should be written to the databaseusing the special JDBC APIs for handling database LOB (Large OBject) types.

There’s two ways a LOB may be represented in the Java domain model:

• using a special JDBC-definedLOB locator type, or

• using a regular "materialized" type likeString,char[], orbyte[].

LOB Locator

Materialized LOB

Hibernate supports mapping temporal values in numerous ways, though ultimately these strategiesboil down to the 3 main Date/Time types defined by the SQL specification:

DATE

Represents a calendar date by storing years, months and days.

TIME

Represents the time of a day by storing hours, minutes and seconds.

TIMESTAMP

Represents both a DATE and a TIME plus nanoseconds.

TIMESTAMP WITH TIME ZONE

Represents both a DATE and a TIME plus nanoseconds and zone id or offset.

The mapping ofjava.time temporal types to the specific SQL Date/Time types is implied as follows:

DATE

java.time.LocalDate

TIME

java.time.LocalTime,java.time.OffsetTime

TIMESTAMP

java.time.Instant,java.time.LocalDateTime,java.time.OffsetDateTime andjava.time.ZonedDateTime

TIMESTAMP WITH TIME ZONE

java.time.OffsetDateTime,java.time.ZonedDateTime

Although Hibernate recommends the use of thejava.time package for representing temporal values,it does support usingjava.sql.Date,java.sql.Time,java.sql.Timestamp,java.util.Date andjava.util.Calendar.

The mappings forjava.sql.Date,java.sql.Time,java.sql.Timestamp are implicit:

DATE

java.sql.Date

TIME

java.sql.Time

TIMESTAMP

java.sql.Timestamp

When usingjava.util.Date orjava.util.Calendar, Hibernate assumesTIMESTAMP. To alter that,use@Temporal.

Using a specific time zone

Handling time zoned temporal data

settings.put(AvailableSettings.TIMEZONE_DEFAULT_STORAGE,TimeZoneStorageType.AUTO);

Hibernate supports defining the storage to use for time zone information for individual propertiesvia the@TimeZoneStorage and@TimeZoneColumn annotations.The storage type can be specified via the@TimeZoneStorage by specifying aorg.hibernate.annotations.TimeZoneStorageType.The default storage type isAUTO which will ensure that the time zone information is retained.The@TimeZoneColumn annotation can be used in conjunction withAUTO orCOLUMN and allows to definethe column details for the time zone information storage.

With a customAttributeConverter, the application developer can map a given JDBC type to an entity basic type.

In the following example, thejava.time.Period is going to be mapped to aVARCHAR database column.

To make use of this custom converter, the@Convert annotation must decorate the entity attribute.

When persisting such entity, Hibernate will do the type conversion based on theAttributeConverter logic:

AnAttributeConverter can be applied globally for (@Converter( autoApply=true )) or locally.

AttributeConverter Java and JDBC types

Mapping an AttributeConverter using HBM mappings

publicclassMoney{privatelongcents;publicMoney(longcents){this.cents=cents;}publiclonggetCents(){returncents;}publicvoidsetCents(longcents){this.cents=cents;}}

publicclassAccount{privateLongid;privateStringowner;privateMoneybalance;//Getters and setters are omitted for brevity}

publicclassMoneyConverterimplementsAttributeConverter<Money,Long>{@OverridepublicLongconvertToDatabaseColumn(Moneyattribute){returnattribute==null?null:attribute.getCents();}@OverridepublicMoneyconvertToEntityAttribute(LongdbData){returndbData==null?null:newMoney(dbData);}}

<?xmlversion="1.0"?><!--~SPDX-License-Identifier:Apache-2.0~CopyrightRedHatInc.andHibernateAuthors--><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mappingpackage="org.hibernate.orm.test.mapping.converter.hbm">    <class name="org.hibernate.orm.test.mapping.converter.hbm.Account" table="account" >        <id name="id"/>        <property name="owner"/>        <property name="balance"            type="converted::org.hibernate.orm.test.mapping.converter.hbm.MoneyConverter"/></class></hibernate-mapping>

AttributeConverter Mutability Plan

@Entity(name="Event")publicstaticclassEvent{@Id@GeneratedValueprivateLongid;@Convert(converter=PeriodStringConverter.class)@Column(columnDefinition="")privatePeriodspan;//Getters and setters are omitted for brevity}

Eventevent=entityManager.createQuery("from Event",Event.class).getSingleResult();event.setSpan(Period.ofYears(3).plusMonths(2).plusDays(1));

publicstaticclassMoney{privatelongcents;//Getters and setters are omitted for brevity}@Entity(name="Account")publicstaticclassAccount{@IdprivateLongid;privateStringowner;@Convert(converter=MoneyConverter.class)privateMoneybalance;//Getters and setters are omitted for brevity}publicstaticclassMoneyConverterimplementsAttributeConverter<Money,Long>{@OverridepublicLongconvertToDatabaseColumn(Moneyattribute){returnattribute==null?null:attribute.getCents();}@OverridepublicMoneyconvertToEntityAttribute(LongdbData){returndbData==null?null:newMoney(dbData);}}

Accountaccount=entityManager.find(Account.class,1L);account.getBalance().setCents(150*100L);entityManager.persist(account);

@Entity(name="Photo")publicstaticclassPhoto{@IdprivateIntegerid;@Column(length=256)privateStringname;@Column(length=256)@Convert(converter=CaptionConverter.class)privateCaptioncaption;//Getters and setters are omitted for brevity}

publicstaticclassCaption{privateStringtext;publicCaption(Stringtext){this.text=text;}publicStringgetText(){returntext;}publicvoidsetText(Stringtext){this.text=text;}@Overridepublicbooleanequals(Objecto){if(this==o){returntrue;}if(o==null||getClass()!=o.getClass()){returnfalse;}Captioncaption=(Caption)o;returntext!=null?text.equals(caption.text):caption.text==null;}@OverridepublicinthashCode(){returntext!=null?text.hashCode():0;}}

publicstaticclassCaptionConverterimplementsAttributeConverter<Caption,String>{@OverridepublicStringconvertToDatabaseColumn(Captionattribute){returnattribute.getText();}@OverridepublicCaptionconvertToEntityAttribute(StringdbData){returnnewCaption(dbData);}}

Photophoto=entityManager.createQuery("select p "+"from Photo p "+"where upper(caption) = upper(:caption) ",Photo.class).setParameter("caption","Nicolae Grigorescu").getSingleResult();

SessionFactoryImplementorsessionFactory=entityManager.getEntityManagerFactory().unwrap(SessionFactoryImplementor.class);finalMappingMetamodelImplementormappingMetamodel=sessionFactory.getRuntimeMetamodels().getMappingMetamodel();TypecaptionType=mappingMetamodel.getEntityDescriptor(Photo.class).getPropertyType("caption");Photophoto=(Photo)entityManager.createQuery("select p "+"from Photo p "+"where upper(caption) = upper(:caption) ",Photo.class).unwrap(Query.class).setParameter("caption",newCaption("Nicolae Grigorescu"),(BindableType)captionType).getSingleResult();