HHH-14837 - Move to Jakarta EE

preliminary transformation;
only `javax.persistence.*` settings supported atm

build.gradle

@@ -22,16 +22,17 @@ buildscript {
 
 
 plugins {
+	id 'org.hibernate.build.xjc-jakarta' version '1.0.2' apply false
+	id 'org.hibernate.matrix-test' version '3.1.1' apply false
+	id 'org.hibernate.orm.database-service' version '1.0.0-SNAPSHOT' apply false
+
 	id 'io.github.gradle-nexus.publish-plugin' version '1.1.0'
 	id 'nu.studer.credentials' version '2.1'
-	id 'org.hibernate.orm.database-service' version '1.0.0-SNAPSHOT' apply false
 
 	id 'idea'
 	id 'org.jetbrains.gradle.plugin.idea-ext' version '1.0'
 	id 'eclipse'
 
-	id 'org.hibernate.build.xjc' version '2.2.0' apply false
-	id 'org.hibernate.matrix-test' version '3.1.1' apply false
 	id 'biz.aQute.bnd' version '5.1.1' apply false
 }
 

documentation/documentation.gradle

@@ -19,9 +19,10 @@ def projectsToIncludeInAggregatedJavadoc = [
 		':hibernate-c3p0',
 		':hibernate-graalvm',
 		':hibernate-hikaricp',
-		':hibernate-jcache',
+//		':hibernate-jcache',
 		':hibernate-micrometer',
 		':hibernate-proxool',
+		':hibernate-spatial',
 		':hibernate-vibur',
 		':hibernate-gradle-plugin',
 		':hibernate-enhance-maven-plugin',
@@ -48,10 +49,8 @@ dependencies {
 
 	testImplementation project(':hibernate-testing')
 	testImplementation project(':hibernate-envers')
-	// todo (6.0) - add back hibernate-spatial dependency
+	testImplementation project(':hibernate-spatial')
-	//testImplementation project(':hibernate-spatial')
+//	testImplementation project( ':hibernate-jcache' )
-	testImplementation project( ':hibernate-jcache' )
-	testImplementation libraries.jcache
 	testImplementation project( path: ':hibernate-core', configuration: 'tests' )
 
 	testImplementation 'org.apache.commons:commons-lang3:3.4'

documentation/src/main/asciidoc/quickstart/guides/tutorial_annotations.adoc

@@ -36,9 +36,9 @@ public class Event {
 ----
 ====
 
-The `@javax.persistence.Entity` annotation is used to mark a class as an entity.  It functions the same as the
+The `@jakarta.persistence.Entity` annotation is used to mark a class as an entity.  It functions the same as the
 `<class/>` mapping element discussed in <<hibernate-gsg-tutorial-basic-mapping>>.   Additionally the
-`@javax.persistence.Table` annotation explicitly specifies the table name. Without this specification, the default
+`@jakarta.persistence.Table` annotation explicitly specifies the table name. Without this specification, the default
 table name would be _EVENT_.
 
 
@@ -56,9 +56,9 @@ public Long getId() {
 ----
 ====
 
-`@javax.persistence.Id` marks the property which defines the entity's identifier.
+`@jakarta.persistence.Id` marks the property which defines the entity's identifier.
 
-`@javax.persistence.GeneratedValue` and `@org.hibernate.annotations.GenericGenerator` work in tandem
+`@jakarta.persistence.GeneratedValue` and `@org.hibernate.annotations.GenericGenerator` work in tandem
 to indicate that Hibernate should use Hibernate's `increment` generation strategy for this entity's identifier values.
 
 

documentation/src/main/asciidoc/quickstart/guides/tutorial_envers.adoc

@@ -47,7 +47,7 @@ public void testBasicUsage() {
 ====
 
 We see that an `org.hibernate.envers.AuditReader` is obtained from the `org.hibernate.envers.AuditReaderFactory`
-which wraps the `javax.persistence.EntityManager`.
+which wraps the `jakarta.persistence.EntityManager`.
 
 Next, the `find` method retrieves specific revisions of the entity.  The first call says to find revision number
 1 of Event with id 2.  The second call says to find revision number 2 of Event with id 2.

documentation/src/main/asciidoc/quickstart/guides/tutorial_jpa.adoc

@@ -35,12 +35,15 @@ is required to locate all JPA configuration files by classpath lookup of the `ME
 ====
 
 `persistence.xml` files should provide a unique name for each "persistence unit".  Applications use this name to
-reference the configuration when obtaining an `javax.persistence.EntityManagerFactory` reference.
+reference the configuration when obtaining an `jakarta.persistence.EntityManagerFactory` reference.
 
 The settings defined in the `<properties/>` element are discussed in <<hibernate-gsg-tutorial-basic-config>>.
-Here the `javax.persistence`-prefixed varieties are used when possible.  Notice that the remaining
+Here the `jakarta.persistence`-prefixed varieties are used when possible.  Notice that the remaining
 Hibernate-specific configuration setting names are now prefixed with `hibernate.`.
 
+NOTE:: Configuration properties prefixed with the legacy Java EE "namespace" (`javax.persistence.*`) are also still
+supported, although the Jakarta EE version (`jakarta.persistence.*`) should be preferred
+
 Additionally, the `<class/>` element functions the same as we saw in <<hibernate-gsg-tutorial-annotations-config>>.
 
 
@@ -56,7 +59,7 @@ The entity is exactly the same as in <<hibernate-gsg-tutorial-annotations-entity
 The previous tutorials used the Hibernate native APIs.  This tutorial uses the JPA APIs.
 
 [[hibernate-gsg-tutorial-jpa-test-setUp]]
-.Obtaining the javax.persistence.EntityManagerFactory
+.Obtaining the jakarta.persistence.EntityManagerFactory
 ====
 [source, JAVA]
 ----
@@ -83,7 +86,7 @@ entityManager.close();
 ----
 ====
 
-The code is similar to <<hibernate-gsg-tutorial-basic-test-saving>>.  The `javax.persistence.EntityManager` interface
+The code is similar to <<hibernate-gsg-tutorial-basic-test-saving>>.  The `jakarta.persistence.EntityManager` interface
 is used instead of the `org.hibernate.Session` interface.  JPA calls this operation "persist" instead of "save".
 
 

documentation/src/main/asciidoc/quickstart/tutorials/annotations/src/test/java/org/hibernate/tutorial/annotations/Event.java

@@ -24,13 +24,13 @@
 package org.hibernate.tutorial.annotations;
 
 import java.util.Date;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
-import javax.persistence.Temporal;
+import jakarta.persistence.Temporal;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
 
 import org.hibernate.annotations.GenericGenerator;
 

documentation/src/main/asciidoc/quickstart/tutorials/entitymanager/src/test/java/org/hibernate/tutorial/em/EntityManagerIllustrationTest.java

@@ -25,9 +25,9 @@ package org.hibernate.tutorial.em;
 
 import java.util.Date;
 import java.util.List;
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
+import jakarta.persistence.EntityManagerFactory;
-import javax.persistence.Persistence;
+import jakarta.persistence.Persistence;
 
 import junit.framework.TestCase;
 

documentation/src/main/asciidoc/quickstart/tutorials/entitymanager/src/test/java/org/hibernate/tutorial/em/Event.java

@@ -24,13 +24,13 @@
 package org.hibernate.tutorial.em;
 
 import java.util.Date;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
-import javax.persistence.Temporal;
+import jakarta.persistence.Temporal;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
 
 import org.hibernate.annotations.GenericGenerator;
 

documentation/src/main/asciidoc/quickstart/tutorials/entitymanager/src/test/resources/META-INF/persistence.xml

@@ -17,10 +17,10 @@
         <class>org.hibernate.tutorial.em.Event</class>
 
         <properties>
-            <property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
+            <property name="jakarta.persistence.jdbc.driver" value="org.h2.Driver" />
-            <property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
+            <property name="jakarta.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
-            <property name="javax.persistence.jdbc.user" value="sa" />
+            <property name="jakarta.persistence.jdbc.user" value="sa" />
-            <property name="javax.persistence.jdbc.password" value="" />
+            <property name="jakarta.persistence.jdbc.password" value="" />
 
             <property name="hibernate.show_sql" value="true" />
             <property name="hibernate.hbm2ddl.auto" value="create" />

documentation/src/main/asciidoc/quickstart/tutorials/envers/src/test/java/org/hibernate/tutorial/envers/EnversIllustrationTest.java

@@ -25,9 +25,9 @@ package org.hibernate.tutorial.envers;
 
 import java.util.Date;
 import java.util.List;
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
+import jakarta.persistence.EntityManagerFactory;
-import javax.persistence.Persistence;
+import jakarta.persistence.Persistence;
 
 import junit.framework.TestCase;
 

documentation/src/main/asciidoc/quickstart/tutorials/envers/src/test/java/org/hibernate/tutorial/envers/Event.java

@@ -24,13 +24,13 @@
 package org.hibernate.tutorial.envers;
 
 import java.util.Date;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
-import javax.persistence.Temporal;
+import jakarta.persistence.Temporal;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
 
 import org.hibernate.annotations.GenericGenerator;
 import org.hibernate.envers.Audited;

documentation/src/main/asciidoc/quickstart/tutorials/envers/src/test/resources/META-INF/persistence.xml

@@ -17,10 +17,10 @@
         <class>org.hibernate.tutorial.envers.Event</class>
 
         <properties>
-            <property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
+            <property name="jakarta.persistence.jdbc.driver" value="org.h2.Driver" />
-            <property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
+            <property name="jakarta.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
-            <property name="javax.persistence.jdbc.user" value="sa" />
+            <property name="jakarta.persistence.jdbc.user" value="sa" />
-            <property name="javax.persistence.jdbc.password" value="" />
+            <property name="jakarta.persistence.jdbc.password" value="" />
 
             <property name="hibernate.show_sql" value="true" />
             <property name="hibernate.hbm2ddl.auto" value="create" />

documentation/src/main/asciidoc/quickstart/tutorials/osgi/managed-jpa/src/main/java/org/hibernate/osgitest/DataPointServiceImpl.java

@@ -22,7 +22,7 @@ package org.hibernate.osgitest;
 
 import java.util.List;
 
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
 
 import org.hibernate.osgitest.entity.DataPoint;
 

documentation/src/main/asciidoc/quickstart/tutorials/osgi/managed-jpa/src/main/java/org/hibernate/osgitest/entity/DataPoint.java

@@ -20,9 +20,9 @@
  */
 package org.hibernate.osgitest.entity;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 /**
  * @author Brett Meyer

documentation/src/main/asciidoc/quickstart/tutorials/osgi/unmanaged-jpa/src/main/java/org/hibernate/osgitest/DataPointServiceImpl.java

@@ -22,7 +22,7 @@ package org.hibernate.osgitest;
 
 import java.util.List;
 
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
 
 import org.hibernate.osgitest.entity.DataPoint;
 

documentation/src/main/asciidoc/quickstart/tutorials/osgi/unmanaged-jpa/src/main/java/org/hibernate/osgitest/HibernateUtil.java

@@ -20,9 +20,9 @@
  */
 package org.hibernate.osgitest;
 
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
+import jakarta.persistence.EntityManagerFactory;
-import javax.persistence.spi.PersistenceProvider;
+import jakarta.persistence.spi.PersistenceProvider;
 
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;

documentation/src/main/asciidoc/quickstart/tutorials/osgi/unmanaged-jpa/src/main/java/org/hibernate/osgitest/entity/DataPoint.java

@@ -20,9 +20,9 @@
  */
 package org.hibernate.osgitest.entity;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 /**
  * @author Brett Meyer

documentation/src/main/asciidoc/quickstart/tutorials/osgi/unmanaged-native/src/main/java/org/hibernate/osgitest/entity/DataPoint.java

@@ -22,9 +22,9 @@ package org.hibernate.osgitest.entity;
 
 import java.io.Serializable;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.envers.Audited;
 

documentation/src/main/asciidoc/topical/bootstrap/JpaBootstrapping.adoc

@@ -10,9 +10,9 @@ the _Native Bootstrapping_ guide as well.
 
 == JPA-compliant bootstrapping
 
-In JPA we are ultimately interested in bootstrapping an `javax.persistence.EntityManagerFactory` instance.  The
+In JPA we are ultimately interested in bootstrapping an `jakarta.persistence.EntityManagerFactory` instance.  The
 JPA specification defines 2 primary standardized bootstrap approaches depending on how the application intends to
-access the `javax.persistence.EntityManager` instances from an `EntityManagerFactory`. It uses the terms "EE" and
+access the `jakarta.persistence.EntityManager` instances from an `EntityManagerFactory`. It uses the terms "EE" and
 "SE" for these 2 approaches, but those terms are very misleading in this context.  What the JPA spec calls EE
 bootstrapping is cases where a container (EE, OSGi, etc) will manage and inject the persistence context on behalf
 of the application.  What it calls SE bootstrapping is everything else.  We will use the terms
@@ -27,7 +27,7 @@ respectively.
 
 The container will build an `EntityManagerFactory` for each persistent-unit defined in the deployment's
 `META-INF/persistence.xml` and make that available to the application for injection via the
-`javax.persistence.PersistenceUnit` annotation or via JNDI lookup.
+`jakarta.persistence.PersistenceUnit` annotation or via JNDI lookup.
 
 [[container-bootstrap-injection-example]]
 .Injecting a EntityManagerFactory
@@ -43,7 +43,7 @@ EntityManagerFactory emf;
 === Application-bootstrapping
 
 Rather than something a container building the `EntityManagerFactory` for the application, the application
-can build the `EntityManagerFactory` using the `javax.persistence.Persistence` bootstrap class.  The application
+can build the `EntityManagerFactory` using the `jakarta.persistence.Persistence` bootstrap class.  The application
 creates an entity manager factory by calling the createEntityManagerFactory method:
 
 [[application-bootstrap-example]]

documentation/src/main/asciidoc/topical/metamodelgen/MetamodelGenerator.adoc

@@ -126,7 +126,7 @@ package p is created.
 managed class by appending "_" to the name of the managed class.
 
 * The metamodel class X_ must be annotated with the 
-`javax.persistence.StaticMetamodel` annotation.
+`jakarta.persistence.StaticMetamodel` annotation.
 
 * If class X extends another class S, where S is the most derived
 managed class (i.e., entity or mapped superclass) extended by X, then
@@ -160,7 +160,7 @@ a declaration as follows:
 +
 where K is the type of the key of the map in class X
 
-Import statements must be included for the needed `javax.persistence.metamodel` types as
+Import statements must be included for the needed `jakarta.persistence.metamodel` types as
 appropriate and all classes X, Y, Z, and K.
 
 [[chapter-usage]]

documentation/src/main/asciidoc/userguide/Hibernate_User_Guide.adoc

@@ -27,7 +27,6 @@ include::chapters/query/criteria/Criteria.adoc[]
 include::chapters/query/native/Native.adoc[]
 include::chapters/query/spatial/Spatial.adoc[]
 include::chapters/multitenancy/MultiTenancy.adoc[]
-include::chapters/osgi/OSGi.adoc[]
 include::chapters/envers/Envers.adoc[]
 include::chapters/portability/Portability.adoc[]
 include::chapters/statistics/Statistics.adoc[]
@@ -38,7 +37,6 @@ include::appendices/BestPractices.adoc[]
 include::appendices/Legacy_Bootstrap.adoc[]
 include::appendices/Legacy_DomainModel.adoc[]
 include::appendices/LegacyBasicTypeResolution.adoc[]
-include::appendices/Legacy_Criteria.adoc[]
 include::appendices/Legacy_Native_Queries.adoc[]
 
 include::Bibliography.adoc[]

documentation/src/main/asciidoc/userguide/appendices/Annotations.adoc

@@ -670,7 +670,7 @@ See the <<chapters/caching/Caching.adoc#caching,Caching>> chapter for more info.
 
 The https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/annotations/Cascade.html[`@Cascade`] annotation is used to apply the Hibernate specific https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/annotations/CascadeType.html[`CascadeType`] strategies (e.g. `CascadeType.LOCK`, `CascadeType.SAVE_UPDATE`, `CascadeType.REPLICATE`) on a given association.
 
-For JPA cascading, prefer using the {jpaJavadocUrlPrefix}CascadeType.html[`javax.persistence.CascadeType`] instead.
+For JPA cascading, prefer using the {jpaJavadocUrlPrefix}CascadeType.html[`jakarta.persistence.CascadeType`] instead.
 
 When combining both JPA and Hibernate `CascadeType` strategies, Hibernate will merge both sets of cascades.
 

documentation/src/main/asciidoc/userguide/appendices/Configurations.adoc

@@ -38,24 +38,24 @@ Note that for backward compatibility, if a `CurrentSessionContext` is not config
 === JPA compliance
 
 `*hibernate.jpa.compliance.transaction*` (e.g. `true` or `false` (default value))::
-This setting controls if Hibernate  `Transaction` should behave as defined by the spec for JPA's `javax.persistence.EntityTransaction`
+This setting controls if Hibernate  `Transaction` should behave as defined by the spec for JPA's `jakarta.persistence.EntityTransaction`
 since it extends the JPA one.
 
 `*hibernate.jpa.compliance.query*` (e.g. `true` or `false` (default value))::
-Controls whether Hibernate's handling of `javax.persistence.Query` (JPQL, Criteria and native query) should strictly follow the JPA spec.
+Controls whether Hibernate's handling of `jakarta.persistence.Query` (JPQL, Criteria and native query) should strictly follow the JPA spec.
 +
-This includes both in terms of parsing or translating a query as well as calls to the `javax.persistence.Query` methods throwing spec
+This includes both in terms of parsing or translating a query as well as calls to the `jakarta.persistence.Query` methods throwing spec
 defined exceptions whereas Hibernate might not.
 
 `*hibernate.jpa.compliance.list*` (e.g. `true` or `false` (default value))::
 Controls whether Hibernate should recognize what it considers a "bag" (`org.hibernate.collection.internal.PersistentBag`)
 as a List (`org.hibernate.collection.internal.PersistentList`) or as a bag.
 +
-If enabled, we will recognize it as a List where `javax.persistence.OrderColumn`
+If enabled, we will recognize it as a List where `jakarta.persistence.OrderColumn`
 is just missing (and its defaults will apply).
 
 `*hibernate.jpa.compliance.closed*` (e.g. `true` or `false` (default value))::
-JPA defines specific exceptions upon calling specific methods on `javax.persistence.EntityManager` and `javax.persistence.EntityManagerFactory`
+JPA defines specific exceptions upon calling specific methods on `jakarta.persistence.EntityManager` and `jakarta.persistence.EntityManagerFactory`
 objects which have been closed previously.
 +
 This setting controls whether the JPA spec-defined behavior or the Hibernate behavior will be used.
@@ -63,7 +63,7 @@ This setting controls whether the JPA spec-defined behavior or the Hibernate beh
 If enabled, Hibernate will operate in the JPA specified way, throwing exceptions when the spec says it should.
 
 `*hibernate.jpa.compliance.proxy*` (e.g. `true` or `false` (default value))::
-The JPA spec says that a `javax.persistence.EntityNotFoundException` should be thrown when accessing an entity proxy
+The JPA spec says that a `jakarta.persistence.EntityNotFoundException` should be thrown when accessing an entity proxy
 which does not have an associated table row in the database.
 +
 Traditionally, Hibernate does not initialize an entity proxy when accessing its identifier since we already know the identifier value,
@@ -82,16 +82,16 @@ with the same name will cause a `java.lang.IllegalArgumentException` to be throw
 [[configurations-database-connection]]
 === Database connection properties
 
-`*hibernate.connection.driver_class*` or `*javax.persistence.jdbc.driver*` (e.g. `org.postgresql.Driver`)::
+`*hibernate.connection.driver_class*` or `*jakarta.persistence.jdbc.driver*` (e.g. `org.postgresql.Driver`)::
 Names the JDBC `Driver` class name.
 
-`*hibernate.connection.url*` or `*javax.persistence.jdbc.url*` (e.g. `jdbc:postgresql:hibernate_orm_test`)::
+`*hibernate.connection.url*` or `*jakarta.persistence.jdbc.url*` (e.g. `jdbc:postgresql:hibernate_orm_test`)::
 Names the JDBC connection URL.
 
-`*hibernate.connection.username*` or `*javax.persistence.jdbc.user*`::
+`*hibernate.connection.username*` or `*jakarta.persistence.jdbc.user*`::
 Names the JDBC connection user name.
 
-`*hibernate.connection.password*` or `*javax.persistence.jdbc.password*`::
+`*hibernate.connection.password*` or `*jakarta.persistence.jdbc.password*`::
 Names the JDBC connection password.
 
 `*hibernate.connection.isolation*` (e.g. `REPEATABLE_READ` or `Connection.TRANSACTION_REPEATABLE_READ`)::
@@ -289,8 +289,8 @@ meaning that an Exception is thrown when detecting such a conflict.
 Should all database identifiers be quoted.
 
 `*hibernate.globally_quoted_identifiers_skip_column_definitions*` (e.g. `true` or `false` (default value))::
-Assuming `hibernate.globally_quoted_identifiers` is `true`, this allows the global quoting to skip column-definitions as defined by `javax.persistence.Column`,
+Assuming `hibernate.globally_quoted_identifiers` is `true`, this allows the global quoting to skip column-definitions as defined by `jakarta.persistence.Column`,
-`javax.persistence.JoinColumn`, etc., and while it avoids column-definitions being quoted due to global quoting, they can still be explicitly quoted in the annotation/xml mappings.
+`jakarta.persistence.JoinColumn`, etc., and while it avoids column-definitions being quoted due to global quoting, they can still be explicitly quoted in the annotation/xml mappings.
 
 `*hibernate.auto_quote_keyword*` (e.g. `true` or `false` (default value))::
 Specifies whether to automatically quote any names that are deemed keywords.
@@ -393,7 +393,7 @@ Unless specified, the JDBC Driver uses the default JVM time zone. If a different
 This setting applies to Oracle Dialect only, and it specifies whether `byte[]` or `Byte[]` arrays should be mapped to the deprecated `LONG RAW` (when this configuration property value is `true`) or to a `BLOB` column type (when this configuration property value is `false`).
 
 ==== Bean Validation options
-`*javax.persistence.validation.factory*` (e.g. `javax.validation.ValidationFactory` implementation)::
+`*jakarta.persistence.validation.factory*` (e.g. `jakarta.validation.ValidationFactory` implementation)::
 Specify the  `javax.validation.ValidationFactory` implementation to use for Bean Validation.
 
 `*hibernate.check_nullability*` (e.g. `true` or `false`)::
@@ -499,7 +499,7 @@ Can reference a
 
 `*hibernate.query.validate_parameters*` (e.g. `true` (default value) or `false`)::
 This configuration property can be used to disable parameters validation performed by `org.hibernate.query.Query#setParameter` when the Session is bootstrapped via JPA
-`javax.persistence.EntityManagerFactory`.
+`jakarta.persistence.EntityManagerFactory`.
 
 `*hibernate.criteria.value_handling_mode*` (e.g. `BIND` (default value) or `INLINE`)::
 By default, Criteria queries uses bind parameters for any value passed through the JPA Criteria API.
@@ -535,7 +535,7 @@ This way, an IN clause with 5, 6, or 7 bind parameters will use the 8 IN clause,
 therefore reusing its execution plan.
 
 `*hibernate.query.omit_join_of_superclass_tables*` (e.g. `false` or `true` (default value))::
-When you use `javax.persistence.InheritanceType#JOINED` strategy for inheritance mapping and query
+When you use `jakarta.persistence.InheritanceType#JOINED` strategy for inheritance mapping and query
 a value from an entity, all superclass tables are joined in the query regardless you need them.
 +
 With this setting set to true only superclass tables which are really needed are joined.
@@ -680,7 +680,7 @@ Either a shortcut name (e.g. `jcache`, `ehcache`) or the fully-qualified name of
 
 `*hibernate.cache.default_cache_concurrency_strategy*`::
 Setting used to give the name of the default https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/annotations/CacheConcurrencyStrategy.html[`CacheConcurrencyStrategy`] to use
-when `@javax.persistence.Cacheable`, `@org.hibernate.annotations.Cache` or `@org.hibernate.annotations.Cache` is used to override the global setting.
+when `@jakarta.persistence.Cacheable`, `@org.hibernate.annotations.Cache` or `@org.hibernate.annotations.Cache` is used to override the global setting.
 
 `*hibernate.cache.use_minimal_puts*` (e.g. `true` (default value) or `false`)::
 Optimizes second-level cache operation to minimize writes, at the cost of more frequent reads. This is most useful for clustered caches and is enabled by default for clustered cache implementations.
@@ -813,7 +813,7 @@ Valid options are defined by the `externalHbm2ddlName` value of the https://docs
 `validate`::: Validate the database schema.
 `update`::: Update the database schema.
 
-`*javax.persistence.schema-generation.database.action*` (e.g. `none` (default value), `create-only`, `drop`, `create`, `create-drop`, `validate`, and `update`)::
+`*jakarta.persistence.schema-generation.database.action*` (e.g. `none` (default value), `create-only`, `drop`, `create`, `create-drop`, `validate`, and `update`)::
 Setting to perform `SchemaManagementTool` actions automatically as part of the `SessionFactory` lifecycle.
 Valid options are defined by the `externalJpaName` value of the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/Action.html[`Action`] enum:
 +
@@ -822,7 +822,7 @@ Valid options are defined by the `externalJpaName` value of the https://docs.jbo
 `drop`::: Database dropping will be generated.
 `drop-and-create`::: Database dropping will be generated followed by database creation.
 
-`*javax.persistence.schema-generation.scripts.action*` (e.g. `none` (default value), `create-only`, `drop`, `create`, `create-drop`, `validate`, and `update`)::
+`*jakarta.persistence.schema-generation.scripts.action*` (e.g. `none` (default value), `create-only`, `drop`, `create`, `create-drop`, `validate`, and `update`)::
 Setting to perform `SchemaManagementTool` actions writing the commands into a DDL script file.
 Valid options are defined by the `externalJpaName` value of the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/Action.html[`Action`] enum:
 +
@@ -831,77 +831,77 @@ Valid options are defined by the `externalJpaName` value of the https://docs.jbo
 `drop`::: Database dropping will be generated.
 `drop-and-create`::: Database dropping will be generated followed by database creation.
 
-`*javax.persistence.schema-generation-connection*`::
+`*jakarta.persistence.schema-generation-connection*`::
 Allows passing a specific `java.sql.Connection` instance to be used by `SchemaManagementTool`.
 
-`*javax.persistence.database-product-name*`::
+`*jakarta.persistence.database-product-name*`::
 Specifies the name of the database provider in cases where a Connection to the underlying database is not available (aka, mainly in generating scripts).
 In such cases, a value for this setting _must_ be specified.
 +
 The value of this setting is expected to match the value returned by `java.sql.DatabaseMetaData#getDatabaseProductName()` for the target database.
 +
-Additionally, specifying `javax.persistence.database-major-version` and/or `javax.persistence.database-minor-version` may be required to understand exactly how to generate the required schema commands.
+Additionally, specifying `jakarta.persistence.database-major-version` and/or `jakarta.persistence.database-minor-version` may be required to understand exactly how to generate the required schema commands.
 
-`*javax.persistence.database-major-version*`::
+`*jakarta.persistence.database-major-version*`::
 Specifies the major version of the underlying database, as would be returned by `java.sql.DatabaseMetaData#getDatabaseMajorVersion` for the target database.
 +
-This value is used to help more precisely determine how to perform schema generation tasks for the underlying database in cases where `javax.persistence.database-product-name` does not provide enough distinction.
+This value is used to help more precisely determine how to perform schema generation tasks for the underlying database in cases where `jakarta.persistence.database-product-name` does not provide enough distinction.
 
-`*javax.persistence.database-minor-version*`::
+`*jakarta.persistence.database-minor-version*`::
 Specifies the minor version of the underlying database, as would be returned by `java.sql.DatabaseMetaData#getDatabaseMinorVersion` for the target database.
 +
-This value is used to help more precisely determine how to perform schema generation tasks for the underlying database in cases where `javax.persistence.database-product-name` and `javax.persistence.database-major-version` does not provide enough distinction.
+This value is used to help more precisely determine how to perform schema generation tasks for the underlying database in cases where `jakarta.persistence.database-product-name` and `jakarta.persistence.database-major-version` does not provide enough distinction.
 
-`*javax.persistence.schema-generation.create-source*`::
+`*jakarta.persistence.schema-generation.create-source*`::
 Specifies whether schema generation commands for schema creation are to be determined based on object/relational mapping metadata, DDL scripts, or a combination of the two.
 See https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/SourceType.html[`SourceType`] for valid set of values.
 +
 If no value is specified, a default is assumed as follows:
 +
-* if source scripts are specified (per `javax.persistence.schema-generation.create-script-source`), then `script` is assumed
+* if source scripts are specified (per `jakarta.persistence.schema-generation.create-script-source`), then `script` is assumed
 * otherwise, `metadata` is assumed
 
-`*javax.persistence.schema-generation.drop-source*`::
+`*jakarta.persistence.schema-generation.drop-source*`::
 Specifies whether schema generation commands for schema dropping are to be determined based on object/relational mapping metadata, DDL scripts, or a combination of the two.
 See https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/SourceType.html[`SourceType`] for valid set of values.
 +
 If no value is specified, a default is assumed as follows:
 +
-* if source scripts are specified (per `javax.persistence.schema-generation.drop-script-source`), then the `script` option is assumed
+* if source scripts are specified (per `jakarta.persistence.schema-generation.drop-script-source`), then the `script` option is assumed
 * otherwise, `metadata` is assumed
 
-`*javax.persistence.schema-generation.create-script-source*`::
+`*jakarta.persistence.schema-generation.create-script-source*`::
 Specifies the `create` script file as either a `java.io.Reader` configured for reading of the DDL script file or a string designating a file `java.net.URL` for the DDL script.
 +
-Hibernate historically also accepted `hibernate.hbm2ddl.import_files` for a similar purpose, but `javax.persistence.schema-generation.create-script-source` should be preferred over `hibernate.hbm2ddl.import_files`.
+Hibernate historically also accepted `hibernate.hbm2ddl.import_files` for a similar purpose, but `jakarta.persistence.schema-generation.create-script-source` should be preferred over `hibernate.hbm2ddl.import_files`.
 
-`*javax.persistence.schema-generation.drop-script-source*`::
+`*jakarta.persistence.schema-generation.drop-script-source*`::
  Specifies the `drop` script file as either a `java.io.Reader` configured for reading of the DDL script file or a string designating a file `java.net.URL` for the DDL script.
 
-`*javax.persistence.schema-generation.scripts.create-target*`::
+`*jakarta.persistence.schema-generation.scripts.create-target*`::
-For cases where the `javax.persistence.schema-generation.scripts.action` value indicates that schema creation commands should be written to DDL script file, `javax.persistence.schema-generation.scripts.create-target` specifies either a `java.io.Writer` configured for output of the DDL script or a string specifying the file URL for the DDL script.
+For cases where the `jakarta.persistence.schema-generation.scripts.action` value indicates that schema creation commands should be written to DDL script file, `jakarta.persistence.schema-generation.scripts.create-target` specifies either a `java.io.Writer` configured for output of the DDL script or a string specifying the file URL for the DDL script.
 
-`*javax.persistence.schema-generation.scripts.drop-target*`::
+`*jakarta.persistence.schema-generation.scripts.drop-target*`::
-For cases where the `javax.persistence.schema-generation.scripts.action` value indicates that schema dropping commands should be written to DDL script file, `javax.persistence.schema-generation.scripts.drop-target` specifies either a `java.io.Writer` configured for output of the DDL script or a string specifying the file URL for the DDL script.
+For cases where the `jakarta.persistence.schema-generation.scripts.action` value indicates that schema dropping commands should be written to DDL script file, `jakarta.persistence.schema-generation.scripts.drop-target` specifies either a `java.io.Writer` configured for output of the DDL script or a string specifying the file URL for the DDL script.
 
 `*hibernate.hbm2ddl.schema-generation.script.append*` (e.g. `true` (default value) or `false`)::
-For cases where the `javax.persistence.schema-generation.scripts.action` value indicates that schema commands should be written to DDL script file, `hibernate.hbm2ddl.schema-generation.script.append` specifies if schema commands should be appended to the end of the file rather than written at the beginning of the file.
+For cases where the `jakarta.persistence.schema-generation.scripts.action` value indicates that schema commands should be written to DDL script file, `hibernate.hbm2ddl.schema-generation.script.append` specifies if schema commands should be appended to the end of the file rather than written at the beginning of the file.
 Values are `true` for appending schema commands to the end of the file, `false` for writing achema commands at the beginning of the file.
 
-`*javax.persistence.hibernate.hbm2ddl.import_files*` (e.g. `import.sql` (default value))::
+`*jakarta.persistence.hibernate.hbm2ddl.import_files*` (e.g. `import.sql` (default value))::
 Comma-separated names of the optional files containing SQL DML statements executed during the `SessionFactory` creation.
 File order matters, the statements of a given file are executed before the statements of the following one.
 +
 These statements are only executed if the schema is created, meaning that `hibernate.hbm2ddl.auto` is set to `create`, `create-drop`, or `update`.
-`javax.persistence.schema-generation.create-script-source` / `javax.persistence.schema-generation.drop-script-source` should be preferred.
+`jakarta.persistence.schema-generation.create-script-source` / `jakarta.persistence.schema-generation.drop-script-source` should be preferred.
 
-`*javax.persistence.sql-load-script-source*`::
+`*jakarta.persistence.sql-load-script-source*`::
 JPA variant of `hibernate.hbm2ddl.import_files`. Specifies a `java.io.Reader` configured for reading of the SQL load script or a string designating the file `java.net.URL` for the SQL load script.
 A "SQL load script" is a script that performs some database initialization (INSERT, etc).
 
 `*hibernate.hbm2ddl.import_files_sql_extractor*`::
-Reference to the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/hbm2ddl/ImportSqlCommandExtractor.html[`ImportSqlCommandExtractor`] implementation class to use for parsing source/import files as defined by `javax.persistence.schema-generation.create-script-source`,
+Reference to the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/hbm2ddl/ImportSqlCommandExtractor.html[`ImportSqlCommandExtractor`] implementation class to use for parsing source/import files as defined by `jakarta.persistence.schema-generation.create-script-source`,
-`javax.persistence.schema-generation.drop-script-source` or `hibernate.hbm2ddl.import_files`.
+`jakarta.persistence.schema-generation.drop-script-source` or `hibernate.hbm2ddl.import_files`.
 +
 Reference may refer to an instance, a Class implementing `ImportSqlCommandExtractor` or the fully-qualified name of the `ImportSqlCommandExtractor` implementation.
 If the fully-qualified name is given, the implementation must provide a no-arg constructor.
@@ -911,7 +911,7 @@ The default value is https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/ja
 `*hibernate.hbm2ddl.create_namespaces*` (e.g. `true` or `false` (default value))::
 Specifies whether to automatically create the database schema/catalog also.
 
-`*javax.persistence.create-database-schemas*` (e.g. `true` or `false` (default value))::
+`*jakarta.persistence.create-database-schemas*` (e.g. `true` or `false` (default value))::
 The JPA variant of `hibernate.hbm2ddl.create_namespaces`. Specifies whether the persistence provider is to create the database schema(s) in addition to creating database objects (tables, sequences, constraints, etc).
 The value of this boolean property should be set to `true` if the persistence provider is to create schemas in the database or to generate DDL that contains "CREATE SCHEMA" commands.
 +
@@ -925,8 +925,8 @@ Used to specify the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/jav
 Setting to choose the strategy used to access the JDBC Metadata.
 Valid options are defined by the `strategy` value of the https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/JdbcMetadaAccessStrategy.html[`JdbcMetadaAccessStrategy`] enum:
 +
-`grouped`::: https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaMigrator.html[`SchemaMigrator`] and https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaValidator.html[`SchemaValidator`] execute a single `java.sql.DatabaseMetaData#getTables(String, String, String, String[])` call to retrieve all the database table in order to determine if all the ``javax.persistence.Entity``s have a corresponding mapped database tables. This strategy may require `hibernate.default_schema` and/or `hibernate.default_catalog` to be provided.
+`grouped`::: https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaMigrator.html[`SchemaMigrator`] and https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaValidator.html[`SchemaValidator`] execute a single `java.sql.DatabaseMetaData#getTables(String, String, String, String[])` call to retrieve all the database table in order to determine if all the ``jakarta.persistence.Entity``s have a corresponding mapped database tables. This strategy may require `hibernate.default_schema` and/or `hibernate.default_catalog` to be provided.
-`individually`::: https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaMigrator.html[`SchemaMigrator`] and https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaValidator.html[`SchemaValidator`] execute one `java.sql.DatabaseMetaData#getTables(String, String, String, String[])` call for each `javax.persistence.Entity` in order to determine if a corresponding database table exists.
+`individually`::: https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaMigrator.html[`SchemaMigrator`] and https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/tool/schema/spi/SchemaValidator.html[`SchemaValidator`] execute one `java.sql.DatabaseMetaData#getTables(String, String, String, String[])` call for each `jakarta.persistence.Entity` in order to determine if a corresponding database table exists.
 
 `*hibernate.hbm2ddl.delimiter*` (e.g. `;`)::
 Identifies the delimiter to use to separate schema management statements in script outputs.
@@ -942,7 +942,7 @@ If enabled, allows schema update and validation to support synonyms. Due to the
 Identifies a comma-separated list of values to specify extra table types, other than the default `TABLE` value, to recognize as defining a physical table by schema update, creation and validation.
 
 `*hibernate.hbm2ddl.default_constraint_mode*` (`CONSTRAINT` (default value) or `NO_CONSTRAINT`)::
-Default `javax.persistence.ConstraintMode` for foreign key mapping if `PROVIDER_DEFAULT` strategy used.
+Default `jakarta.persistence.ConstraintMode` for foreign key mapping if `PROVIDER_DEFAULT` strategy used.
 
 `*hibernate.schema_update.unique_constraint_strategy*` (e.g. `DROP_RECREATE_QUIETLY`, `RECREATE_QUIETLY`, `SKIP`)::
 Unique columns and unique keys both use unique constraints in most dialects.
@@ -1153,7 +1153,7 @@ Defines delayed access to CDI `BeanManager`. Starting in 5.1 the preferred means
 Identifies an explicit `org.hibernate.resource.beans.container.spi.BeanContainer` to be used.
 +
 Note that, for CDI-based containers, setting this is not necessary.
-Simply pass the `BeanManager` to use via `javax.persistence.bean.manager` and optionally specify `hibernate.delay_cdi_access`.
+Simply pass the `BeanManager` to use via `jakarta.persistence.bean.manager` and optionally specify `hibernate.delay_cdi_access`.
 +
 This setting is more meant to integrate non-CDI bean containers such as Spring.
 
@@ -1169,7 +1169,7 @@ false::: does not allow
 Setting which indicates whether or not the new JOINs over collection tables should be rewritten to subqueries.
 
 `*hibernate.allow_refresh_detached_entity*` (e.g. `true` (default value when using Hibernate native bootstrapping) or `false` (default value when using JPA bootstrapping))::
-Setting that allows to call `javax.persistence.EntityManager#refresh(entity)` or `Session#refresh(entity)` on a detached instance even when the `org.hibernate.Session` is obtained from a JPA `javax.persistence.EntityManager`.
+Setting that allows to call `jakarta.persistence.EntityManager#refresh(entity)` or `Session#refresh(entity)` on a detached instance even when the `org.hibernate.Session` is obtained from a JPA `jakarta.persistence.EntityManager`.
 
 `*hibernate.use_entity_where_clause_for_collections*` (e.g., `true` (default) or `false`)::
 Setting controls whether an entity's "where" clause, mapped using `@Where(clause = "...")` or `<entity ... where="...">` is taken into account when loading one-to-many or many-to-many collections of that type of entity.

documentation/src/main/asciidoc/userguide/chapters/bootstrap/Bootstrap.adoc

@@ -182,15 +182,15 @@ The standardized approach has some limitations in certain environments, but asid
 [[bootstrap-jpa-compliant]]
 ==== JPA-compliant bootstrapping
 
-In JPA, we are ultimately interested in bootstrapping a `javax.persistence.EntityManagerFactory` instance.
+In JPA, we are ultimately interested in bootstrapping a `jakarta.persistence.EntityManagerFactory` instance.
-The JPA specification defines two primary standardized bootstrap approaches depending on how the application intends to access the `javax.persistence.EntityManager` instances from an `EntityManagerFactory`.
+The JPA specification defines two primary standardized bootstrap approaches depending on how the application intends to access the `jakarta.persistence.EntityManager` instances from an `EntityManagerFactory`.
 
 It uses the terms _EE_ and _SE_ for these two approaches, but those terms are very misleading in this context.
 What the JPA spec calls EE bootstrapping implies the existence of a container (EE, OSGi, etc), who'll manage and inject the persistence context on behalf of the application.
 What it calls SE bootstrapping is everything else. We will use the terms container-bootstrapping and application-bootstrapping in this guide.
 
 For compliant container-bootstrapping, the container will build an `EntityManagerFactory` for each persistent-unit defined in the `META-INF/persistence.xml` configuration file
-and make that available to the application for injection via the `javax.persistence.PersistenceUnit` annotation or via JNDI lookup.
+and make that available to the application for injection via the `jakarta.persistence.PersistenceUnit` annotation or via JNDI lookup.
 
 [[bootstrap-jpa-compliant-PersistenceUnit-example]]
 .Injecting the default `EntityManagerFactory`
@@ -224,7 +224,7 @@ include::{extrasdir}/persistence.xml[]
 ----
 ====
 
-For compliant application-bootstrapping, rather than the container building the `EntityManagerFactory` for the application, the application builds the `EntityManagerFactory` itself using the `javax.persistence.Persistence` bootstrap class.
+For compliant application-bootstrapping, rather than the container building the `EntityManagerFactory` for the application, the application builds the `EntityManagerFactory` itself using the `jakarta.persistence.Persistence` bootstrap class.
 The application creates an `EntityManagerFactory` by calling the `createEntityManagerFactory` method:
 
 [[bootstrap-jpa-compliant-EntityManagerFactory-example]]
@@ -240,7 +240,7 @@ include::{sourcedir}/BootstrapTest.java[tags=bootstrap-jpa-compliant-EntityManag
 ====
 If you don't want to provide a `persistence.xml` configuration file, JPA allows you to provide all the configuration options in a
 {jpaJavadocUrlPrefix}spi/PersistenceUnitInfo.html[`PersistenceUnitInfo`] implementation and call
-https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/jpa/HibernatePersistenceProvider.html#createContainerEntityManagerFactory-javax.persistence.spi.PersistenceUnitInfo-java.util.Map-[`HibernatePersistenceProvider.html#createContainerEntityManagerFactory`].
+https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/jpa/HibernatePersistenceProvider.html#createContainerEntityManagerFactory-jakarta.persistence.spi.PersistenceUnitInfo-java.util.Map-[`HibernatePersistenceProvider.html#createContainerEntityManagerFactory`].
 ====
 
 To inject the default Persistence Context, you can use the {jpaJavadocUrlPrefix}PersistenceContext.html[`@PersistenceContext`] annotation.

documentation/src/main/asciidoc/userguide/chapters/bootstrap/extras/persistence-external.xml

@@ -14,16 +14,16 @@
         <mapping-file>file:///etc/opt/app/mappings/orm.xml</mapping-file>
 
         <properties>
-            <property name="javax.persistence.jdbc.driver"
+            <property name="jakarta.persistence.jdbc.driver"
                       value="org.h2.Driver" />
 
-            <property name="javax.persistence.jdbc.url"
+            <property name="jakarta.persistence.jdbc.url"
                       value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
 
-            <property name="javax.persistence.jdbc.user"
+            <property name="jakarta.persistence.jdbc.user"
                       value="sa" />
 
-            <property name="javax.persistence.jdbc.password"
+            <property name="jakarta.persistence.jdbc.password"
                       value="" />
 
             <property name="hibernate.show_sql"

documentation/src/main/asciidoc/userguide/chapters/bootstrap/extras/persistence.xml

@@ -14,16 +14,16 @@
         <class>org.hibernate.documentation.userguide.Document</class>
 
         <properties>
-            <property name="javax.persistence.jdbc.driver"
+            <property name="jakarta.persistence.jdbc.driver"
                       value="org.h2.Driver" />
 
-            <property name="javax.persistence.jdbc.url"
+            <property name="jakarta.persistence.jdbc.url"
                       value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
 
-            <property name="javax.persistence.jdbc.user"
+            <property name="jakarta.persistence.jdbc.user"
                       value="sa" />
 
-            <property name="javax.persistence.jdbc.password"
+            <property name="jakarta.persistence.jdbc.password"
                       value="" />
 
             <property name="hibernate.show_sql"

documentation/src/main/asciidoc/userguide/chapters/caching/Caching.adoc

@@ -85,7 +85,7 @@ The cache mappings can be configured via JPA annotations or XML descriptors or u
 
 By default, entities are not part of the second level cache and we recommend you to stick to this setting.
 However, you can override this by setting the `shared-cache-mode` element in your `persistence.xml` file
-or by using the `javax.persistence.sharedCache.mode` property in your configuration file.
+or by using the `jakarta.persistence.sharedCache.mode` property in your configuration file.
 The following values are possible:
 
 `ENABLE_SELECTIVE` (Default and recommended value)::
@@ -460,7 +460,7 @@ include::{sourcedir}/SecondLevelCacheTest.java[tags=caching-management-cache-mod
 Because the second level cache is bound to the `EntityManagerFactory` or the `SessionFactory`,
 cache eviction must be done through these two interfaces.
 
-JPA only supports entity eviction through the {jpaJavadocUrlPrefix}Cache.html[`javax.persistence.Cache`] interface:
+JPA only supports entity eviction through the {jpaJavadocUrlPrefix}Cache.html[`jakarta.persistence.Cache`] interface:
 
 [[caching-management-evict-jpa-example]]
 .Evicting entities with JPA

documentation/src/main/asciidoc/userguide/chapters/domain/associations.adoc

@@ -306,7 +306,7 @@ Hibernate would throw an exception because another person is still associated wi
 Person person1 = entityManager.find(Person.class, personId);
 entityManager.remove(person1);
 
-Caused by: javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: could not execute statement
+Caused by: jakarta.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: could not execute statement
 Caused by: org.hibernate.exception.ConstraintViolationException: could not execute statement
 Caused by: java.sql.SQLIntegrityConstraintViolationException: integrity constraint violation: foreign key no action; FKM7J0BNABH2YR0PE99IL1D066U table: PERSON_ADDRESS
 ----

documentation/src/main/asciidoc/userguide/chapters/domain/basic_types.adoc

@@ -47,7 +47,7 @@ The JPA specification strictly limits the Java types that can be marked as basic
 
 If provider portability is a concern, you should stick to just these basic types.
 
-JPA 2.1 introduced the `javax.persistence.AttributeConverter` providing support for handling
+JPA 2.1 introduced the `jakarta.persistence.AttributeConverter` providing support for handling
 types beyond those defined in the specification. See <<basic-jpa-convert>> for more on this topic.
 ====
 
@@ -69,7 +69,7 @@ This chapter covers how Hibernate determines these pieces and how to influence t
 [[basic-basic-annotation]]
 ==== @Basic
 
-Strictly speaking, a basic type is denoted by the `javax.persistence.Basic` annotation.
+Strictly speaking, a basic type is denoted by the `jakarta.persistence.Basic` annotation.
 
 Generally, the `@Basic` annotation can be ignored as it is assumed by default.  Both of the following
 examples are ultimately the same.
@@ -1381,7 +1381,7 @@ Hibernate supports the mapping of Java enums as basic value types in a number of
 [[basic-enums-Enumerated]]
 ===== `@Enumerated`
 
-The original JPA-compliant way to map enums was via the `@Enumerated` or `@MapKeyEnumerated`  annotations, working on the principle that the enum values are stored according to one of 2 strategies indicated by `javax.persistence.EnumType`:
+The original JPA-compliant way to map enums was via the `@Enumerated` or `@MapKeyEnumerated`  annotations, working on the principle that the enum values are stored according to one of 2 strategies indicated by `jakarta.persistence.EnumType`:
 
 `ORDINAL`::
 stored according to the enum value's ordinal position within the enum class, as indicated by `java.lang.Enum#ordinal`

documentation/src/main/asciidoc/userguide/chapters/domain/entity.adoc

@@ -21,7 +21,7 @@ Throughout this chapter and thereafter, entity types will be simply referred to
 Section _2.1 The Entity Class_ of the _JPA 2.1 specification_ defines its requirements for an entity class.
 Applications that wish to remain portable across JPA providers should adhere to these requirements:
 
-* The entity class must be annotated with the `javax.persistence.Entity` annotation (or be denoted as such in XML mapping).
+* The entity class must be annotated with the `jakarta.persistence.Entity` annotation (or be denoted as such in XML mapping).
 * The entity class must have a public or protected no-argument constructor. It may define additional constructors as well.
 * The entity class must be a top-level class.
 * An enum or interface may not be designated as an entity.
@@ -114,7 +114,7 @@ Hibernate offers multiple identifier generation strategies, see the <<chapters/d
 [[entity-pojo-mapping]]
 ==== Mapping the entity
 
-The main piece in mapping the entity is the {jpaJavadocUrlPrefix}Entity.html[`javax.persistence.Entity`] annotation.
+The main piece in mapping the entity is the {jpaJavadocUrlPrefix}Entity.html[`jakarta.persistence.Entity`] annotation.
 
 The `@Entity` annotation defines just the {jpaJavadocUrlPrefix}Entity.html#name--[`name`] attribute which is used to give a specific entity name for use in JPQL queries.
 
@@ -152,7 +152,7 @@ include::{sourcedir-mapping}/identifier/SimpleEntityTest.java[tag=entity-pojo-ma
 An entity models a database table.
 The identifier uniquely identifies each row in that table.
 By default, the name of the table is assumed to be the same as the name of the entity.
-To explicitly give the name of the table or to specify other information about the table, we would use the `javax.persistence.Table` annotation.
+To explicitly give the name of the table or to specify other information about the table, we would use the `jakarta.persistence.Table` annotation.
 
 [[entity-pojo-table-mapping-example]]
 .Simple `@Entity` with `@Table`

documentation/src/main/asciidoc/userguide/chapters/domain/extras/immutability/collection-immutability-update-example.log.txt

@@ -1,6 +1,6 @@
-javax.persistence.RollbackException: Error while committing the transaction
+jakarta.persistence.RollbackException: Error while committing the transaction
 
-Caused by: javax.persistence.PersistenceException: org.hibernate.HibernateException:
+Caused by: jakarta.persistence.PersistenceException: org.hibernate.HibernateException:
 
 Caused by: org.hibernate.HibernateException: changed an immutable collection instance: [
     org.hibernate.userguide.immutability.CollectionImmutabilityTest$Batch.events#1

documentation/src/main/asciidoc/userguide/chapters/domain/identifiers.adoc

@@ -31,7 +31,7 @@ An identifier might be simple (single value) or composite (multiple values).
 [[identifiers-simple]]
 ==== Simple identifiers
 
-Simple identifiers map to a single basic attribute, and are denoted using the `javax.persistence.Id` annotation.
+Simple identifiers map to a single basic attribute, and are denoted using the `jakarta.persistence.Id` annotation.
 
 According to JPA only the following types should be used as identifier attribute types:
 
@@ -63,7 +63,7 @@ include::{sourcedir}/AssignedIdentifierTest.java[tag=identifiers-simple-assigned
 [[identifiers-simple-generated]]
 ===== Generated identifiers
 
-Values for simple identifiers can be generated. To denote that an identifier attribute is generated, it is annotated with `javax.persistence.GeneratedValue`
+Values for simple identifiers can be generated. To denote that an identifier attribute is generated, it is annotated with `jakarta.persistence.GeneratedValue`
 
 [[identifiers-simple-generated-mapping-example]]
 .Simple generated identifier
@@ -87,8 +87,8 @@ Composite identifiers correspond to one or more persistent attributes.
 Here are the rules governing composite identifiers, as defined by the JPA specification:
 
 * The composite identifier must be represented by a "primary key class".
-The primary key class may be defined using the `javax.persistence.EmbeddedId` annotation (see <<identifiers-composite-aggregated>>),
+The primary key class may be defined using the `jakarta.persistence.EmbeddedId` annotation (see <<identifiers-composite-aggregated>>),
-or defined using the `javax.persistence.IdClass` annotation (see <<identifiers-composite-nonaggregated>>).
+or defined using the `jakarta.persistence.IdClass` annotation (see <<identifiers-composite-nonaggregated>>).
 * The primary key class must be public and must have a public no-arg constructor.
 * The primary key class must be serializable.
 * The primary key class must define equals and hashCode methods, consistent with equality for the underlying database types to which the primary key is mapped.
@@ -283,8 +283,8 @@ You can also auto-generate values for non-identifier attributes. For more detail
 Hibernate supports identifier value generation across a number of different types.
 Remember that JPA portably defines identifier value generation just for integer types.
 
-Identifier value generation is indicated using the `javax.persistence.GeneratedValue` annotation.
+Identifier value generation is indicated using the `jakarta.persistence.GeneratedValue` annotation.
-The most important piece of information here is the specified `javax.persistence.GenerationType` which indicates how values will be generated.
+The most important piece of information here is the specified `jakarta.persistence.GenerationType` which indicates how values will be generated.
 
 [NOTE]
 ====
@@ -348,7 +348,7 @@ It is important to note that SequenceStyleGenerator is capable of working agains
 This gives Hibernate a huge degree of portability across databases while still maintaining consistent id generation behavior (versus say choosing between SEQUENCE and IDENTITY).
 This backing storage is completely transparent to the user.
 
-The preferred (and portable) way to configure this generator is using the JPA-defined `javax.persistence.SequenceGenerator` annotation.
+The preferred (and portable) way to configure this generator is using the JPA-defined `jakarta.persistence.SequenceGenerator` annotation.
 
 The simplest form is to simply request sequence generation; Hibernate will use a single, implicitly-named sequence (`hibernate_sequence`) for all such unnamed definitions.
 
@@ -361,7 +361,7 @@ include::{sourcedir}/SequenceGeneratorUnnamedTest.java[tag=identifiers-generator
 ----
 ====
 
-Using `javax.persistence.SequenceGenerator`, you can specify a specific database sequence name.
+Using `jakarta.persistence.SequenceGenerator`, you can specify a specific database sequence name.
 
 [[identifiers-generators-sequence-named]]
 .Named sequence
@@ -372,7 +372,7 @@ include::{sourcedir}/SequenceGeneratorNamedTest.java[tag=identifiers-generators-
 ----
 ====
 
-The `javax.persistence.SequenceGenerator` annotation allows you to specify additional configurations as well.
+The `jakarta.persistence.SequenceGenerator` annotation allows you to specify additional configurations as well.
 
 [[identifiers-generators-sequence-configured]]
 .Configured sequence
@@ -434,7 +434,7 @@ include::{extrasdir}/id/identifiers-generators-table-unnamed-mapping-example.sql
 
 If no table name is given Hibernate assumes an implicit name of `hibernate_sequences`.
 
-Additionally, because no `javax.persistence.TableGenerator#pkColumnValue` is specified,
+Additionally, because no `jakarta.persistence.TableGenerator#pkColumnValue` is specified,
 Hibernate will use the default segment (`sequence_name='default'`) from the hibernate_sequences table.
 
 However, you can configure the table identifier generator using the {jpaJavadocUrlPrefix}TableGenerator.html[`@TableGenerator`] annotation.

documentation/src/main/asciidoc/userguide/chapters/domain/inheritance.adoc

@@ -114,7 +114,7 @@ Use the `@DiscriminatorColumn` to define the discriminator column as well as the
 
 [NOTE]
 ====
-The enum `DiscriminatorType` used in `javax.persistence.DiscriminatorColumn` only contains the values `STRING`, `CHAR` and `INTEGER` which means that not all Hibernate supported types are available via the `@DiscriminatorColumn` annotation.
+The enum `DiscriminatorType` used in `jakarta.persistence.DiscriminatorColumn` only contains the values `STRING`, `CHAR` and `INTEGER` which means that not all Hibernate supported types are available via the `@DiscriminatorColumn` annotation.
 You can also use `@DiscriminatorFormula` to express in SQL a virtual discriminator column.
 This is particularly useful when the discriminator value can be extracted from one or more columns of the table.
 Both `@DiscriminatorColumn` and `@DiscriminatorFormula` are to be set on the root entity (once per persisted hierarchy).

documentation/src/main/asciidoc/userguide/chapters/envers/Envers.adoc

@@ -340,7 +340,7 @@ please see <<envers-mappingexceptions>> for a description of the additional `@Au
 If you want to audit a relation, where the target entity is not audited (that is the case for example with dictionary-like entities, which don't change and don't have to be audited),
 just annotate it with `@Audited( targetAuditMode = RelationTargetAuditMode.NOT_AUDITED )`.
 Then, while reading historic versions of your entity, the relation will always point to the "current" related entity.
-By default Envers throws `javax.persistence.EntityNotFoundException` when "current" entity does not exist in the database.
+By default Envers throws `jakarta.persistence.EntityNotFoundException` when "current" entity does not exist in the database.
 Apply `@NotFound( action = NotFoundAction.IGNORE )` annotation to silence the exception and assign null value instead.
 The hereby solution causes implicit eager loading of to-one relations.
 
@@ -1431,7 +1431,7 @@ Although Hibernate allows this, Envers (or more precisely the database connector
 
 There are at least two ways out if you need bag semantics:
 
-. use an indexed collection, with the `@javax.persistence.OrderColumn` annotation.
+. use an indexed collection, with the `@jakarta.persistence.OrderColumn` annotation.
 . provide a unique id for your elements with the `@CollectionId` annotation.
 
 ==== What isn't and _will_ be supported

documentation/src/main/asciidoc/userguide/chapters/events/Events.adoc

@@ -144,7 +144,7 @@ There are two available approaches defined for specifying callback handling:
 * The second is to use a separate entity listener class.
 An entity listener is a stateless class with a no-arg constructor.
 The callback annotations are placed on a method of this class instead of the entity class.
-The entity listener class is then associated with the entity using the `javax.persistence.EntityListeners` annotation
+The entity listener class is then associated with the entity using the `jakarta.persistence.EntityListeners` annotation
 
 [[events-jpa-callbacks-example]]
 .Example of specifying JPA callbacks
@@ -170,10 +170,10 @@ A callback method must not invoke `EntityManager` or `Query` methods!
 It is possible that multiple callback methods are defined for a particular lifecycle event.
 When that is the case, the defined order of execution is well defined by the JPA spec (specifically section 3.5.4):
 
-* Any default listeners associated with the entity are invoked first, in the order they were specified in the XML. See the `javax.persistence.ExcludeDefaultListeners` annotation.
+* Any default listeners associated with the entity are invoked first, in the order they were specified in the XML. See the `jakarta.persistence.ExcludeDefaultListeners` annotation.
 * Next, entity listener class callbacks associated with the entity hierarchy are invoked, in the order they are defined in the `EntityListeners`.
 If multiple classes in the entity hierarchy define entity listeners, the listeners defined for a superclass are invoked before the listeners defined for its subclasses.
-See the ``javax.persistence.ExcludeSuperclassListener``'s annotation.
+See the ``jakarta.persistence.ExcludeSuperclassListener``'s annotation.
 * Lastly, callback methods defined on the entity hierarchy are invoked.
 If a callback type is annotated on both an entity and one or more of its superclasses without method overriding, both would be called, the most general superclass first.
 An entity class is also allowed to override a callback method defined in a superclass in which case the super callback would not get invoked; the overriding method would get invoked provided it is annotated.

documentation/src/main/asciidoc/userguide/chapters/fetching/Fetching.adoc

@@ -358,7 +358,7 @@ creates a single AttributeNode with 3 distinct SubGraphs.  It is functionally th
 [source, JAVA, indent=0]
 ----
 Class<Invoice> invoiceClass = ...;
-javax.persistence.EntityGraph<Invoice> invoiceGraph = entityManager.createEntityGraph( invoiceClass );
+jakarta.persistence.EntityGraph<Invoice> invoiceGraph = entityManager.createEntityGraph( invoiceClass );
 invoiceGraph.addAttributeNode( "responsibleParty" );
 invoiceGraph.addSubgraph( "responsibleParty" ).addAttributeNode( "taxIdNumber" );
 invoiceGraph.addSubgraph( "responsibleParty", Corporation.class ).addAttributeNode( "ceo" );

documentation/src/main/asciidoc/userguide/chapters/jdbc/Database_Access.adoc

@@ -32,7 +32,8 @@ For cases where a JNDI name is given, be sure to read <<chapters/jndi/JNDI.adoc#
 
 [NOTE]
 ====
-For JPA applications, note that `hibernate.connection.datasource` corresponds to either `javax.persistence.jtaDataSource` or `javax.persistence.nonJtaDataSource`.
+For JPA applications, note that `hibernate.connection.datasource` corresponds to
+`jakarta.persistence.jtaDataSource` or `jakarta.persistence.nonJtaDataSource`.
 ====
 
 The `DataSource` `ConnectionProvider` also (optionally) accepts the `hibernate.connection.username` and `hibernate.connection.password`.

documentation/src/main/asciidoc/userguide/chapters/locking/Locking.adoc

@@ -40,7 +40,7 @@ especially useful if you use assigned identifiers or composite keys.
 ==== Mapping optimistic locking
 
 JPA defines support for optimistic locking based on either a version (sequential numeric) or timestamp strategy.
-To enable this style of optimistic locking simply add the `javax.persistence.Version` to the persistent attribute that defines the optimistic locking value.
+To enable this style of optimistic locking simply add the `jakarta.persistence.Version` to the persistent attribute that defines the optimistic locking value.
 According to JPA, the valid types for these attributes are limited to:
 
 * `int` or `Integer`
@@ -324,8 +324,8 @@ JPA comes with its own {jpaJavadocUrlPrefix}LockModeType.html[`LockModeType`] en
 |`PESSIMISTIC_FORCE_INCREMENT`|`PESSIMISTIC_FORCE_INCREMENT` | The entity is locked pessimistically and its version is incremented automatically even if the entity has not changed.
 |`PESSIMISTIC_READ`|`PESSIMISTIC_READ` | The entity is locked pessimistically using a shared lock if the database supports such a feature. Otherwise, an explicit lock is used.
 |`PESSIMISTIC_WRITE`|`PESSIMISTIC_WRITE`, `UPGRADE` | The entity is locked using an explicit lock.
-|`PESSIMISTIC_WRITE` with a `javax.persistence.lock.timeout` setting of 0 |`UPGRADE_NOWAIT` | The lock acquisition request fails fast if the row s already locked.
+|`PESSIMISTIC_WRITE` with a `jakarta.persistence.lock.timeout` setting of 0 |`UPGRADE_NOWAIT` | The lock acquisition request fails fast if the row s already locked.
-|`PESSIMISTIC_WRITE` with a `javax.persistence.lock.timeout` setting of -2 |`UPGRADE_SKIPLOCKED` | The lock acquisition request skips the already locked rows. It uses a `SELECT ... FOR UPDATE SKIP LOCKED` in Oracle and PostgreSQL 9.5, or `SELECT ... with (rowlock, updlock, readpast) in SQL Server`.
+|`PESSIMISTIC_WRITE` with a `jakarta.persistence.lock.timeout` setting of -2 |`UPGRADE_SKIPLOCKED` | The lock acquisition request skips the already locked rows. It uses a `SELECT ... FOR UPDATE SKIP LOCKED` in Oracle and PostgreSQL 9.5, or `SELECT ... with (rowlock, updlock, readpast) in SQL Server`.
 |=======================================================================
 
 The explicit user request mentioned above occurs as a consequence of any of the following actions:
@@ -350,12 +350,12 @@ This ensures that applications are portable.
 
 JPA 2.0 introduced two query hints:
 
-javax.persistence.lock.timeout:: it gives the number of milliseconds a lock acquisition request will wait before throwing an exception
+jakarta.persistence.lock.timeout:: it gives the number of milliseconds a lock acquisition request will wait before throwing an exception
-javax.persistence.lock.scope:: defines the {jpaJavadocUrlPrefix}PessimisticLockScope.html[_scope_] of the lock acquisition request.
+jakarta.persistence.lock.scope:: defines the {jpaJavadocUrlPrefix}PessimisticLockScope.html[_scope_] of the lock acquisition request.
 The scope can either be `NORMAL` (default value) or `EXTENDED`. The `EXTENDED` scope will cause a lock acquisition request to be passed to other owned table structured (e.g. `@Inheritance(strategy=InheritanceType.JOINED)`, `@ElementCollection`)
 
 [[locking-jpa-query-hints-timeout-example]]
-.`javax.persistence.lock.timeout` example
+.`jakarta.persistence.lock.timeout` example
 ====
 [source, JAVA,indent=0]
 ----
@@ -376,7 +376,7 @@ If not supported, the Hibernate dialect ignores this query hint.
 
 [NOTE]
 ====
-The `javax.persistence.lock.scope` is https://hibernate.atlassian.net/browse/HHH-9636[not yet supported] as specified by the JPA standard.
+The `jakarta.persistence.lock.scope` is https://hibernate.atlassian.net/browse/HHH-9636[not yet supported] as specified by the JPA standard.
 ====
 
 [[locking-buildLockRequest]]

documentation/src/main/asciidoc/userguide/chapters/pc/PersistenceContext.adoc

@@ -4,7 +4,7 @@
 :sourcedir-caching: ../../../../../test/java/org/hibernate/userguide/caching
 :extrasdir: extras
 
-Both the `org.hibernate.Session` API and `javax.persistence.EntityManager` API represent a context for dealing with persistent data.
+Both the `org.hibernate.Session` API and `jakarta.persistence.EntityManager` API represent a context for dealing with persistent data.
 This concept is called a `persistence context`.
 Persistent data has a state in relation to both a persistence context and the underlying database.
 
@@ -15,7 +15,7 @@ It may or may not physically exist in the database yet.
 `detached`:: the entity has an associated identifier but is no longer associated with a persistence context (usually because the persistence context was closed or the instance was evicted from the context)
 `removed`:: the entity has an associated identifier and is associated with a persistence context, however, it is scheduled for removal from the database.
 
-Much of the `org.hibernate.Session` and `javax.persistence.EntityManager` methods deal with moving entities among these states.
+Much of the `org.hibernate.Session` and `jakarta.persistence.EntityManager` methods deal with moving entities among these states.
 
 [[pc-unwrap]]
 === Accessing Hibernate APIs from JPA
@@ -37,7 +37,7 @@ include::BytecodeEnhancement.adoc[]
 === Making entities persistent
 
 Once you've created a new entity instance (using the standard `new` operator) it is in `new` state.
-You can make it persistent by associating it to either an `org.hibernate.Session` or a `javax.persistence.EntityManager`.
+You can make it persistent by associating it to either an `org.hibernate.Session` or a `jakarta.persistence.EntityManager`.
 
 [[pc-persist-jpa-example]]
 .Making an entity persistent with JPA
@@ -58,7 +58,7 @@ include::{sourcedir}/PersistenceContextTest.java[tags=pc-persist-native-example]
 ====
 
 `org.hibernate.Session` also has a method named persist which follows the exact semantics defined in the JPA specification for the persist method.
-It is this `org.hibernate.Session` method to which the Hibernate `javax.persistence.EntityManager` implementation delegates.
+It is this `org.hibernate.Session` method to which the Hibernate `jakarta.persistence.EntityManager` implementation delegates.
 
 If the `DomesticCat` entity type has a generated identifier, the value is associated with the instance when the save or persist is called.
 If the identifier is not automatically generated, the manually assigned (usually natural) key value has to be set on the instance before the save or persist methods are called.
@@ -92,7 +92,7 @@ Hibernate itself can handle deleting entities in detached state.
 JPA, however, disallows this behavior.
 
 The implication here is that the entity instance passed to the `org.hibernate.Session` delete method can be either in managed or detached state,
-while the entity instance passed to remove on `javax.persistence.EntityManager` must be in the managed state.
+while the entity instance passed to remove on `jakarta.persistence.EntityManager` must be in the managed state.
 ====
 
 [[pc-get-reference]]
@@ -1069,7 +1069,7 @@ include::{sourcedir}/PersistenceContextTest.java[tags=pc-verify-lazy-native-exam
 ----
 ====
 
-In JPA there is an alternative means to check laziness using the following `javax.persistence.PersistenceUtil` pattern (which is recommended wherever possible).
+In JPA there is an alternative means to check laziness using the following `jakarta.persistence.PersistenceUtil` pattern (which is recommended wherever possible).
 
 [[pc-verify-lazy-jpa-alternative-example]]
 .Alternative JPA means to verify laziness
@@ -1130,7 +1130,7 @@ include::{sourcedir-caching}/FirstLevelCacheTest.java[tags=caching-management-co
 === Cascading entity state transitions
 
 JPA allows you to propagate the state transition from a parent entity to a child.
-For this purpose, the JPA `javax.persistence.CascadeType` defines various cascade types:
+For this purpose, the JPA `jakarta.persistence.CascadeType` defines various cascade types:
 
 `ALL`:: cascades all entity state transitions.
 `PERSIST`:: cascades the entity persist operation.
@@ -1236,7 +1236,7 @@ include::{sourcedir}/CascadeDetachTest.java[tags=pc-cascade-detach-example]
 ==== `CascadeType.LOCK`
 
 Although unintuitively, `CascadeType.LOCK` does not propagate a lock request from a parent entity to its children.
-Such a use case requires the use of the `PessimisticLockScope.EXTENDED` value of the `javax.persistence.lock.scope` property.
+Such a use case requires the use of the `PessimisticLockScope.EXTENDED` value of the `jakarta.persistence.lock.scope` property.
 
 However, `CascadeType.LOCK` allows us to reattach a parent entity along with its children to the currently running Persistence Context.
 

documentation/src/main/asciidoc/userguide/chapters/query/criteria/Criteria.adoc

@@ -8,7 +8,7 @@ Criteria queries offer a type-safe alternative to HQL, JPQL and native SQL queri
 ====
 Hibernate offers an older, legacy `org.hibernate.Criteria` API which should be considered deprecated.
 
-No feature development will target those APIs. Eventually, Hibernate-specific Criteria features will be ported as extensions to the JPA `javax.persistence.criteria.CriteriaQuery`.
+No feature development will target those APIs. Eventually, Hibernate-specific Criteria features will be ported as extensions to the JPA `jakarta.persistence.criteria.CriteriaQuery`.
 For details on the `org.hibernate.Criteria` API, see <<appendices/Legacy_Criteria.adoc#appendix-legacy-criteria, Legacy Hibernate Criteria Queries>>.
 
 This chapter will focus on the JPA APIs for declaring type-safe criteria queries.
@@ -21,12 +21,12 @@ Users of the older Hibernate `org.hibernate.Criteria` query API will recognize t
 
 Criteria queries are essentially an object graph, where each part of the graph represents an increasing (as we navigate down this graph) more atomic part of the query.
 The first step in performing a criteria query is building this graph.
-The `javax.persistence.criteria.CriteriaBuilder` interface is the first thing with which you need to become acquainted with before using criteria queries.
+The `jakarta.persistence.criteria.CriteriaBuilder` interface is the first thing with which you need to become acquainted with before using criteria queries.
 Its role is that of a factory for all the individual pieces of the criteria.
-You obtain a `javax.persistence.criteria.CriteriaBuilder` instance by calling the `getCriteriaBuilder()` method of either `javax.persistence.EntityManagerFactory` or `javax.persistence.EntityManager`.
+You obtain a `jakarta.persistence.criteria.CriteriaBuilder` instance by calling the `getCriteriaBuilder()` method of either `jakarta.persistence.EntityManagerFactory` or `jakarta.persistence.EntityManager`.
 
-The next step is to obtain a `javax.persistence.criteria.CriteriaQuery`.
+The next step is to obtain a `jakarta.persistence.criteria.CriteriaQuery`.
-This is accomplished using one of the three methods on `javax.persistence.criteria.CriteriaBuilder` for this purpose:
+This is accomplished using one of the three methods on `jakarta.persistence.criteria.CriteriaBuilder` for this purpose:
 
 * `<T> CriteriaQuery<T> createQuery( Class<T> resultClass )`
 * `CriteriaQuery<Tuple> createTupleQuery()`
@@ -111,7 +111,7 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-typedquery-multiselect-arra
 Technically this is classified as a typed query, but you can see from handling the results that this is sort of misleading.
 Anyway, the expected result type here is an array.
 
-The example then uses the array method of `javax.persistence.criteria.CriteriaBuilder` which explicitly combines individual selections into a `javax.persistence.criteria.CompoundSelection`.
+The example then uses the array method of `jakarta.persistence.criteria.CriteriaBuilder` which explicitly combines individual selections into a `jakarta.persistence.criteria.CompoundSelection`.
 
 [[criteria-typedquery-multiselect-array-implicit-example]]
 .Selecting an array using `multiselect`
@@ -148,14 +148,14 @@ First, we see the simple definition of the wrapper object we will be using to wr
 Specifically, notice the constructor and its argument types.
 Since we will be returning `PersonWrapper` objects, we use `PersonWrapper` as the type of our criteria query.
 
-This example illustrates the use of the `javax.persistence.criteria.CriteriaBuilder` method construct which is used to build a wrapper expression.
+This example illustrates the use of the `jakarta.persistence.criteria.CriteriaBuilder` method construct which is used to build a wrapper expression.
 For every row in the result, we are saying we would like a `PersonWrapper` instantiated with the remaining arguments by the matching constructor.
 This wrapper expression is then passed as the select.
 
 [[criteria-tuple]]
 === Tuple criteria queries
 
-A better approach to <<criteria-typedquery-multiselect>> is to use either a wrapper (which we just saw in <<criteria-typedquery-wrapper>>) or using the `javax.persistence.Tuple` contract.
+A better approach to <<criteria-typedquery-multiselect>> is to use either a wrapper (which we just saw in <<criteria-typedquery-wrapper>>) or using the `jakarta.persistence.Tuple` contract.
 
 [[criteria-tuple-example]]
 .Selecting a tuple
@@ -166,18 +166,18 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-tuple-example]
 ----
 ====
 
-This example illustrates accessing the query results through the `javax.persistence.Tuple` interface.
+This example illustrates accessing the query results through the `jakarta.persistence.Tuple` interface.
-The example uses the explicit `createTupleQuery()` of `javax.persistence.criteria.CriteriaBuilder`.
+The example uses the explicit `createTupleQuery()` of `jakarta.persistence.criteria.CriteriaBuilder`.
 An alternate approach is to use `createQuery( Tuple.class )`.
 
 Again we see the use of the `multiselect()` method, just like in <<criteria-typedquery-multiselect-array-implicit-example>>.
-The difference here is that the type of the `javax.persistence.criteria.CriteriaQuery` was defined as `javax.persistence.Tuple` so the compound selections, in this case, are interpreted to be the tuple elements.
+The difference here is that the type of the `jakarta.persistence.criteria.CriteriaQuery` was defined as `jakarta.persistence.Tuple` so the compound selections, in this case, are interpreted to be the tuple elements.
 
-The javax.persistence.Tuple contract provides three forms of access to the underlying elements:
+The jakarta.persistence.Tuple contract provides three forms of access to the underlying elements:
 
 typed::
   The <<criteria-tuple-example>> example illustrates this form of access in the `tuple.get( idPath )` and `tuple.get( nickNamePath )` calls.
-  This allows typed access to the underlying tuple values based on the `javax.persistence.TupleElement` expressions used to build the criteria.
+  This allows typed access to the underlying tuple values based on the `jakarta.persistence.TupleElement` expressions used to build the criteria.
 positional::
   Allows access to the underlying tuple values based on the position.
   The simple _Object get(int position)_ form is very similar to the access illustrated in <<criteria-typedquery-multiselect-array-explicit-example>> and <<criteria-typedquery-multiselect-array-implicit-example>>.
@@ -185,7 +185,7 @@ positional::
 aliased::
   Allows access to the underlying tuple values based on (optionally) assigned alias.
   The example query did not apply an alias.
-  An alias would be applied via the alias method on `javax.persistence.criteria.Selection`.
+  An alias would be applied via the alias method on `jakarta.persistence.criteria.Selection`.
   Just like `positional` access, there is both a typed (__Object get(String alias)__) and an untyped (__<X> X get(String alias, Class<X> type)__) form.
 
 [[criteria-from]]
@@ -200,14 +200,14 @@ The root objects of the query are entities, from which the other types are reach
 
 [NOTE]
 ====
-All the individual parts of the FROM clause (roots, joins, paths) implement the `javax.persistence.criteria.From` interface.
+All the individual parts of the FROM clause (roots, joins, paths) implement the `jakarta.persistence.criteria.From` interface.
 ====
 
 [[criteria-from-root]]
 === Roots
 
 Roots define the basis from which all joins, paths and attributes are available in the query.
-A root is always an entity type. Roots are defined and added to the criteria by the overloaded __from__ methods on `javax.persistence.criteria.CriteriaQuery`:
+A root is always an entity type. Roots are defined and added to the criteria by the overloaded __from__ methods on `jakarta.persistence.criteria.CriteriaQuery`:
 
 [[criteria-from-root-methods-example]]
 .Root methods
@@ -244,8 +244,8 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-from-multiple-root-example]
 [[criteria-from-join]]
 === Joins
 
-Joins allow navigation from other `javax.persistence.criteria.From` to either association or embedded attributes.
+Joins allow navigation from other `jakarta.persistence.criteria.From` to either association or embedded attributes.
-Joins are created by the numerous overloaded __join__ methods of the `javax.persistence.criteria.From` interface.
+Joins are created by the numerous overloaded __join__ methods of the `jakarta.persistence.criteria.From` interface.
 
 [[criteria-from-join-example]]
 .Join example
@@ -260,7 +260,7 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-from-join-example]
 === Fetches
 
 Just like in HQL and JPQL, criteria queries can specify that associated data be fetched along with the owner.
-Fetches are created by the numerous overloaded __fetch__ methods of the `javax.persistence.criteria.From` interface.
+Fetches are created by the numerous overloaded __fetch__ methods of the `jakarta.persistence.criteria.From` interface.
 
 [[criteria-from-fetch-example]]
 .Join fetch example
@@ -274,7 +274,7 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-from-fetch-example]
 [NOTE]
 ====
 Technically speaking, embedded attributes are always fetched with their owner.
-However, in order to define the fetching of _Phone#addresses_ we needed a `javax.persistence.criteria.Fetch` because element collections are `LAZY` by default.
+However, in order to define the fetching of _Phone#addresses_ we needed a `jakarta.persistence.criteria.Fetch` because element collections are `LAZY` by default.
 ====
 
 [[criteria-path]]
@@ -297,8 +297,8 @@ include::{sourcedir}/CriteriaTest.java[tags=criteria-param-example]
 ----
 ====
 
-Use the parameter method of `javax.persistence.criteria.CriteriaBuilder` to obtain a parameter reference.
+Use the parameter method of `jakarta.persistence.criteria.CriteriaBuilder` to obtain a parameter reference.
-Then use the parameter reference to bind the parameter value to the `javax.persistence.Query`.
+Then use the parameter reference to bind the parameter value to the `jakarta.persistence.Query`.
 
 [[criteria-group-by]]
 === Using group by

documentation/src/main/asciidoc/userguide/chapters/query/hql/HQL.adoc

@@ -46,14 +46,14 @@ include::{modeldir}/WireTransferPayment.java[tags=hql-examples-domain-model-exam
 
 When using Hibernate, you can execute entity queries either via JPA or the Hibernate-specific API.
 Since 5.2, the Hibernate `Session` interface extends the JPA `EntityManager` interface.
-For this reason, the query API was also merged, and now the Hibernate `org.hibernate.query.Query` interface extends the JPA `javax.persistence.Query`.
+For this reason, the query API was also merged, and now the Hibernate `org.hibernate.query.Query` interface extends the JPA `jakarta.persistence.Query`.
 
 Next, we are going to see how the query API differs between the standard JPA interfaces and the Hibernate-specific API.
 
 [[jpql-api]]
 ==== JPA Query API
 
-In JPA, the query is represented by `javax.persistence.Query` or `javax.persistence.TypedQuery` as obtained from the `EntityManager`.
+In JPA, the query is represented by `jakarta.persistence.Query` or `jakarta.persistence.TypedQuery` as obtained from the `EntityManager`.
 The create an inline `Query` or `TypedQuery`, you need to use the `EntityManager#createQuery` method.
 For named queries, the `EntityManager#createNamedQuery` method is needed.
 
@@ -109,13 +109,13 @@ Many of the settings controlling the execution of the query are defined as hints
 JPA defines some standard hints (like timeout in the example), but most are provider specific.
 Relying on provider specific hints limits your applications portability to some degree.
 
-`javax.persistence.query.timeout`::
+`jakarta.persistence.query.timeout`::
     Defines the query timeout, in milliseconds.
-`javax.persistence.fetchgraph`::
+`jakarta.persistence.fetchgraph`::
     Defines a _fetchgraph_ EntityGraph.
     Attributes explicitly specified as `AttributeNodes` are treated as `FetchType.EAGER` (via join fetch or subsequent select).
     For details, see the EntityGraph discussions in <<chapters/fetching/Fetching.adoc#fetching,Fetching>>.
-`javax.persistence.loadgraph`::
+`jakarta.persistence.loadgraph`::
     Defines a _loadgraph_ EntityGraph.
     Attributes explicitly specified as AttributeNodes are treated as `FetchType.EAGER` (via join fetch or subsequent select).
     Attributes that are not specified are treated as `FetchType.LAZY` or `FetchType.EAGER` depending on the attribute's definition in metadata.
@@ -131,7 +131,7 @@ Relying on provider specific hints limits your applications portability to some
 `org.hibernate.fetchSize`::
     Defines the JDBC fetch-size to use. See `org.hibernate.query.Query#setFetchSize`.
 `org.hibernate.flushMode`::
-    Defines the Hibernate-specific `FlushMode` to use. See `org.hibernate.query.Query#setFlushMode.` If possible, prefer using `javax.persistence.Query#setFlushMode` instead.
+    Defines the Hibernate-specific `FlushMode` to use. See `org.hibernate.query.Query#setFlushMode.` If possible, prefer using `jakarta.persistence.Query#setFlushMode` instead.
 `org.hibernate.readOnly`:: Defines that entities and collections loaded by this query should be marked as read-only. See `org.hibernate.query.Query#setReadOnly`.
 
 The final thing that needs to happen before the query can be executed is to bind the values for any defined parameters.
@@ -542,7 +542,7 @@ Versioned updates is a Hibernate-specific feature and will not work in a portabl
 Custom version types, `org.hibernate.usertype.UserVersionType`, are not allowed in conjunction with an `update versioned` statement.
 ====
 
-An `UPDATE` statement is executed using the `executeUpdate()` of either `org.hibernate.query.Query` or `javax.persistence.Query`.
+An `UPDATE` statement is executed using the `executeUpdate()` of either `org.hibernate.query.Query` or `jakarta.persistence.Query`.
 The method is named for those familiar with the JDBC `executeUpdate()` on `java.sql.PreparedStatement`.
 
 The `int` value returned by the `executeUpdate()` method indicates the number of entities affected by the operation.
@@ -582,7 +582,7 @@ include::{extrasdir}/statement_delete_bnf.txt[]
 ----
 ====
 
-A `DELETE` statement is also executed using the `executeUpdate()` method of either `org.hibernate.query.Query` or `javax.persistence.Query`.
+A `DELETE` statement is also executed using the `executeUpdate()` method of either `org.hibernate.query.Query` or `jakarta.persistence.Query`.
 
 [[hql-insert]]
 === Insert statements
@@ -975,7 +975,7 @@ VALUE::
   Useful to explicitly show intent.
   Valid for any type of collection-valued reference.
 INDEX::
-  According to HQL rules, this is valid for both `Maps` and `Lists` which specify a `javax.persistence.OrderColumn` annotation to refer to the `Map` key or the `List` position (aka the `OrderColumn` value).
+  According to HQL rules, this is valid for both `Maps` and `Lists` which specify a `jakarta.persistence.OrderColumn` annotation to refer to the `Map` key or the `List` position (aka the `OrderColumn` value).
   JPQL however, reserves this for use in the `List` case and adds `KEY` for the `Map` case.
   Applications interested in JPA provider portability should be aware of this distinction.
 KEY::

documentation/src/main/asciidoc/userguide/chapters/query/native/Native.adoc

@@ -272,7 +272,7 @@ include::{sourcedir}/SQLTest.java[tags=sql-hibernate-multi-entity-query-alias-ex
 
 [NOTE]
 ====
-There's no such equivalent in JPA because the `javax.persistence.Query` interface does not define an `addEntity` method equivalent.
+There's no such equivalent in JPA because the `jakarta.persistence.Query` interface does not define an `addEntity` method equivalent.
 ====
 
 The `{pr.*}` and `{pt.*}` notation used above is shorthand for "all properties".
@@ -337,7 +337,7 @@ include::{sourcedir}/SQLTest.java[tags=sql-hibernate-dto-query-example, indent=0
 
 [NOTE]
 ====
-There's no such equivalent in JPA because the `javax.persistence.Query` interface does not define a `setResultTransformer` method equivalent.
+There's no such equivalent in JPA because the `jakarta.persistence.Query` interface does not define a `setResultTransformer` method equivalent.
 ====
 
 The above query will return a list of `PersonSummaryDTO` which has been instantiated and injected the values of `id` and `name` into its corresponding properties or fields.
@@ -358,7 +358,7 @@ include::{sourcedir}/SQLTest.java[tags=sql-hibernate-inheritance-query-example]
 
 [NOTE]
 ====
-There's no such equivalent in JPA because the `javax.persistence.Query` interface does not define an `addEntity` method equivalent.
+There's no such equivalent in JPA because the `jakarta.persistence.Query` interface does not define an `addEntity` method equivalent.
 ====
 
 [[sql-query-parameters]]
@@ -390,7 +390,7 @@ include::{sourcedir}/SQLTest.java[tags=sql-hibernate-query-parameters-example]
 Named SQL queries can also be defined during mapping and called in exactly the same way as a named HQL query.
 In this case, you do _not_ need to call `addEntity()` anymore.
 
-JPA defines the `javax.persistence.NamedNativeQuery` annotation for this purpose,
+JPA defines the `jakarta.persistence.NamedNativeQuery` annotation for this purpose,
 and the Hibernate `org.hibernate.annotations.NamedNativeQuery` annotation extends it and adds the following attributes:
 
 `flushMode()`::

documentation/src/main/java/org/hibernate/userguide/model/Call.java

@@ -7,12 +7,12 @@
 package org.hibernate.userguide.model;
 
 import java.util.Date;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/CreditCardPayment.java

@@ -6,7 +6,7 @@
  */
 package org.hibernate.userguide.model;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/Image.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.model;
 
-import javax.persistence.Basic;
+import jakarta.persistence.Basic;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Lob;
+import jakarta.persistence.Lob;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/Partner.java

@@ -6,10 +6,10 @@
  */
 package org.hibernate.userguide.model;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Version;
+import jakarta.persistence.Version;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/Payment.java

@@ -7,12 +7,12 @@
 package org.hibernate.userguide.model;
 
 import java.math.BigDecimal;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Inheritance;
+import jakarta.persistence.Inheritance;
-import javax.persistence.InheritanceType;
+import jakarta.persistence.InheritanceType;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/Person.java

@@ -11,33 +11,33 @@ import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.ColumnResult;
+import jakarta.persistence.ColumnResult;
-import javax.persistence.ConstructorResult;
+import jakarta.persistence.ConstructorResult;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.EntityResult;
+import jakarta.persistence.EntityResult;
-import javax.persistence.EnumType;
+import jakarta.persistence.EnumType;
-import javax.persistence.FieldResult;
+import jakarta.persistence.FieldResult;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.MapKeyEnumerated;
+import jakarta.persistence.MapKeyEnumerated;
-import javax.persistence.NamedNativeQueries;
+import jakarta.persistence.NamedNativeQueries;
-import javax.persistence.NamedNativeQuery;
+import jakarta.persistence.NamedNativeQuery;
-import javax.persistence.NamedQueries;
+import jakarta.persistence.NamedQueries;
-import javax.persistence.NamedQuery;
+import jakarta.persistence.NamedQuery;
-import javax.persistence.NamedStoredProcedureQueries;
+import jakarta.persistence.NamedStoredProcedureQueries;
-import javax.persistence.NamedStoredProcedureQuery;
+import jakarta.persistence.NamedStoredProcedureQuery;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
-import javax.persistence.OrderColumn;
+import jakarta.persistence.OrderColumn;
-import javax.persistence.ParameterMode;
+import jakarta.persistence.ParameterMode;
-import javax.persistence.QueryHint;
+import jakarta.persistence.QueryHint;
-import javax.persistence.SqlResultSetMapping;
+import jakarta.persistence.SqlResultSetMapping;
-import javax.persistence.SqlResultSetMappings;
+import jakarta.persistence.SqlResultSetMappings;
-import javax.persistence.StoredProcedureParameter;
+import jakarta.persistence.StoredProcedureParameter;
-import javax.persistence.Temporal;
+import jakarta.persistence.Temporal;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
-import javax.persistence.Version;
+import jakarta.persistence.Version;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/java/org/hibernate/userguide/model/Phone.java

@@ -11,24 +11,24 @@ import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.ColumnResult;
+import jakarta.persistence.ColumnResult;
-import javax.persistence.ConstructorResult;
+import jakarta.persistence.ConstructorResult;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.EntityResult;
+import jakarta.persistence.EntityResult;
-import javax.persistence.EnumType;
+import jakarta.persistence.EnumType;
-import javax.persistence.Enumerated;
+import jakarta.persistence.Enumerated;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.FieldResult;
+import jakarta.persistence.FieldResult;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.MapKey;
+import jakarta.persistence.MapKey;
-import javax.persistence.MapKeyTemporal;
+import jakarta.persistence.MapKeyTemporal;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
-import javax.persistence.SqlResultSetMapping;
+import jakarta.persistence.SqlResultSetMapping;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
 
 import org.hibernate.annotations.NamedNativeQueries;
 import org.hibernate.annotations.NamedNativeQuery;

documentation/src/main/java/org/hibernate/userguide/model/WireTransferPayment.java

@@ -6,7 +6,7 @@
  */
 package org.hibernate.userguide.model;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
 
 /**
  * @author Vlad Mihalcea

documentation/src/main/javadoc/overview.html

@@ -37,7 +37,7 @@ These interfaces are fully intended to be exposed to application code.
 <p></p>
 
 <h3>JPA</h3>
-The JPA interfaces are all defined by the JPA specification.  For details see {@link javax.persistence}.
+The JPA interfaces are all defined by the JPA specification.  For details see {@link jakarta.persistence}.
 Not that since 5.2 Hibernate extends JPA (e.g. SessionFactory extends EntityManagerFactory) rather
 than wrapping it.
 <p></p>

documentation/src/test/java/org/hibernate/userguide/associations/BidirectionalTwoOneToManyMapsIdTest.java

@@ -11,16 +11,16 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Embeddable;
+import jakarta.persistence.Embeddable;
-import javax.persistence.EmbeddedId;
+import jakarta.persistence.EmbeddedId;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.MapsId;
+import jakarta.persistence.MapsId;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/CompositeIdAssociationTest.java

@@ -8,11 +8,11 @@ package org.hibernate.userguide.associations;
 
 import java.io.Serializable;
 import java.util.Objects;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/DerivedIdentifierPrimaryKeyJoinColumnTest.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
+import jakarta.persistence.PrimaryKeyJoinColumn;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/DerivedIdentifierTest.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.MapsId;
+import jakarta.persistence.MapsId;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/JoinColumnOrFormulaTest.java

@@ -8,12 +8,12 @@ package org.hibernate.userguide.associations;
 
 import java.io.Serializable;
 import java.util.Objects;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.JoinColumnOrFormula;
 import org.hibernate.annotations.JoinFormula;

documentation/src/test/java/org/hibernate/userguide/associations/JoinFormulaTest.java

@@ -7,10 +7,10 @@
 package org.hibernate.userguide.associations;
 
 import java.util.Objects;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.JoinFormula;
 import org.hibernate.dialect.PostgreSQLDialect;

documentation/src/test/java/org/hibernate/userguide/associations/ManyToManyBidirectionalTest.java

@@ -9,12 +9,12 @@ package org.hibernate.userguide.associations;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToMany;
+import jakarta.persistence.ManyToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/ManyToManyBidirectionalWithLinkEntityTest.java

@@ -10,13 +10,13 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/ManyToManyUnidirectionalTest.java

@@ -8,12 +8,12 @@ package org.hibernate.userguide.associations;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToMany;
+import jakarta.persistence.ManyToMany;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/associations/ManyToOneTest.java

@@ -6,13 +6,13 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.ForeignKey;
+import jakarta.persistence.ForeignKey;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/associations/NotFoundTest.java

@@ -1,13 +1,13 @@
 package org.hibernate.userguide.associations;
 
 import java.io.Serializable;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.NotFound;
 import org.hibernate.annotations.NotFoundAction;

documentation/src/test/java/org/hibernate/userguide/associations/OneToManyBidirectionalTest.java

@@ -9,13 +9,13 @@ package org.hibernate.userguide.associations;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/OneToManyUnidirectionalTest.java

@@ -8,12 +8,12 @@ package org.hibernate.userguide.associations;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/associations/OneToOneBidirectionalLazyTest.java

@@ -6,14 +6,14 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.OneToOne;
+import jakarta.persistence.OneToOne;
 
 import org.hibernate.annotations.LazyToOne;
 import org.hibernate.annotations.LazyToOneOption;

documentation/src/test/java/org/hibernate/userguide/associations/OneToOneBidirectionalTest.java

@@ -6,14 +6,14 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.OneToOne;
+import jakarta.persistence.OneToOne;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 
@@ -71,7 +71,7 @@ public class OneToOneBidirectionalTest extends BaseEntityManagerFunctionalTestCa
 				entityManager.flush();
 				entityManager.clear();
 
-				//throws javax.persistence.PersistenceException: org.hibernate.HibernateException: More than one row with the given identifier was found: 1
+				//throws jakarta.persistence.PersistenceException: org.hibernate.HibernateException: More than one row with the given identifier was found: 1
 				phone = entityManager.find( Phone.class, phone.getId() );
 				//end::associations-one-to-one-bidirectional-constraint-example[]
 				phone.getDetails().getProvider();

documentation/src/test/java/org/hibernate/userguide/associations/OneToOneMapsIdTest.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.MapsId;
+import jakarta.persistence.MapsId;
-import javax.persistence.OneToOne;
+import jakarta.persistence.OneToOne;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/OneToOnePrimaryKeyJoinColumnTest.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.MapsId;
+import jakarta.persistence.MapsId;
-import javax.persistence.OneToOne;
+import jakarta.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
+import jakarta.persistence.PrimaryKeyJoinColumn;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/associations/OneToOneUnidirectionalTest.java

@@ -6,12 +6,12 @@
  */
 package org.hibernate.userguide.associations;
 
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.OneToOne;
+import jakarta.persistence.OneToOne;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/associations/UnidirectionalManyToManyRemoveTest.java

@@ -8,12 +8,12 @@ package org.hibernate.userguide.associations;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToMany;
+import jakarta.persistence.ManyToMany;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/associations/any/IntegerProperty.java

@@ -6,10 +6,10 @@
  */
 package org.hibernate.userguide.associations.any;
 
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 //tag::associations-any-property-example[]
 

documentation/src/test/java/org/hibernate/userguide/associations/any/PropertyHolder.java

@@ -6,11 +6,11 @@
  */
 package org.hibernate.userguide.associations.any;
 
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.Any;
 

documentation/src/test/java/org/hibernate/userguide/associations/any/PropertyRepository.java

@@ -8,12 +8,12 @@ package org.hibernate.userguide.associations.any;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.JoinTable;
+import jakarta.persistence.JoinTable;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.Cascade;
 import org.hibernate.annotations.ManyToAny;

documentation/src/test/java/org/hibernate/userguide/associations/any/StringProperty.java

@@ -6,10 +6,10 @@
  */
 package org.hibernate.userguide.associations.any;
 
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 //tag::associations-any-property-example[]
 

documentation/src/test/java/org/hibernate/userguide/batch/BatchTest.java

@@ -6,8 +6,8 @@
  */
 package org.hibernate.userguide.batch;
 
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
-import javax.persistence.EntityTransaction;
+import jakarta.persistence.EntityTransaction;
 
 import org.hibernate.CacheMode;
 import org.hibernate.ScrollMode;

documentation/src/test/java/org/hibernate/userguide/bootstrap/BootstrapTest.java

@@ -14,20 +14,20 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
-import javax.persistence.AttributeConverter;
+import jakarta.persistence.AttributeConverter;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.EntityManager;
+import jakarta.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
+import jakarta.persistence.EntityManagerFactory;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.Persistence;
+import jakarta.persistence.Persistence;
-import javax.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContext;
-import javax.persistence.PersistenceProperty;
+import jakarta.persistence.PersistenceProperty;
-import javax.persistence.PersistenceUnit;
+import jakarta.persistence.PersistenceUnit;
-import javax.persistence.SharedCacheMode;
+import jakarta.persistence.SharedCacheMode;
-import javax.persistence.ValidationMode;
+import jakarta.persistence.ValidationMode;
-import javax.persistence.spi.ClassTransformer;
+import jakarta.persistence.spi.ClassTransformer;
-import javax.persistence.spi.PersistenceUnitInfo;
+import jakarta.persistence.spi.PersistenceUnitInfo;
-import javax.persistence.spi.PersistenceUnitTransactionType;
+import jakarta.persistence.spi.PersistenceUnitTransactionType;
 import javax.sql.DataSource;
 
 import org.hibernate.EmptyInterceptor;
@@ -336,7 +336,7 @@ public class BootstrapTest {
     }
 
     //tag::bootstrap-event-listener-registration-example[]
-    public class MyIntegrator implements org.hibernate.integrator.spi.Integrator {
+    public class MyIntegrator implements Integrator {
 
         @Override
         public void integrate(

documentation/src/test/java/org/hibernate/userguide/caching/FirstLevelCacheTest.java

@@ -8,18 +8,17 @@ package org.hibernate.userguide.caching;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
 
 import org.hibernate.Session;
-import org.hibernate.cfg.AvailableSettings;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 
 import org.junit.Test;
 
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+
 import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
 
 
@@ -30,16 +29,7 @@ public class FirstLevelCacheTest extends BaseEntityManagerFunctionalTestCase {
 
     @Override
     protected Class<?>[] getAnnotatedClasses() {
-        return new Class<?>[] {
+        return new Class<?>[] { Person.class };
-            Person.class
-        };
-    }
-
-    @Override
-    @SuppressWarnings( "unchecked" )
-    protected void addConfigOptions(Map options) {
-        options.put( AvailableSettings.USE_SECOND_LEVEL_CACHE, Boolean.TRUE.toString() );
-        options.put( AvailableSettings.CACHE_REGION_FACTORY, "jcache" );
     }
 
     @Test

documentation/src/test/java/org/hibernate/userguide/caching/NonStrictReadWriteCacheTest.java

@@ -9,25 +9,23 @@ package org.hibernate.userguide.caching;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import javax.cache.configuration.MutableConfiguration;
-import javax.persistence.Cacheable;
-import javax.persistence.CascadeType;
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.ManyToOne;
-import javax.persistence.OneToMany;
-import javax.persistence.Version;
 
 import org.hibernate.annotations.CacheConcurrencyStrategy;
-import org.hibernate.cache.jcache.JCacheHelper;
 import org.hibernate.cfg.AvailableSettings;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 
+import org.hibernate.testing.FailureExpected;
 import org.junit.Test;
 
-import org.jboss.logging.Logger;
+import jakarta.persistence.Cacheable;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Version;
 
 import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
 
@@ -35,22 +33,23 @@ import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
 /**
  * @author Vlad Mihalcea
  */
+@FailureExpected( jiraKey = "", message = "Relies on hibernate-jcache + JCache + Ehcache - Ehcache uses JAXB and has not been updated to use Jakarta" )
 public class NonStrictReadWriteCacheTest extends BaseEntityManagerFunctionalTestCase {
 
 	@Override
 	public void buildEntityManagerFactory() {
-		JCacheHelper.locateStandardCacheManager().createCache(
+//		JCacheHelper.locateStandardCacheManager().createCache(
-				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Person",
+//				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Person",
-				new MutableConfiguration<>()
+//				new MutableConfiguration<>()
-		);
+//		);
-		JCacheHelper.locateStandardCacheManager().createCache(
+//		JCacheHelper.locateStandardCacheManager().createCache(
-				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Phone",
+//				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Phone",
-				new MutableConfiguration<>()
+//				new MutableConfiguration<>()
-		);
+//		);
-		JCacheHelper.locateStandardCacheManager().createCache(
+//		JCacheHelper.locateStandardCacheManager().createCache(
-				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Person.phones",
+//				"hibernate.test.org.hibernate.userguide.caching.NonStrictReadWriteCacheTest$Person.phones",
-				new MutableConfiguration<>()
+//				new MutableConfiguration<>()
-		);
+//		);
 
 		super.buildEntityManagerFactory();
 	}

documentation/src/test/java/org/hibernate/userguide/caching/SecondLevelCacheTest.java

@@ -9,14 +9,14 @@ package org.hibernate.userguide.caching;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import javax.persistence.CacheRetrieveMode;
+import jakarta.persistence.CacheRetrieveMode;
-import javax.persistence.CacheStoreMode;
+import jakarta.persistence.CacheStoreMode;
-import javax.persistence.Cacheable;
+import jakarta.persistence.Cacheable;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
+import jakarta.persistence.GenerationType;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.CacheMode;
 import org.hibernate.Session;
@@ -162,7 +162,7 @@ public class SecondLevelCacheTest extends BaseEntityManagerFunctionalTestCase {
 			.setParameter( "id", 0L)
 			.setHint( QueryHints.HINT_CACHEABLE, "true")
 			.setHint( QueryHints.HINT_CACHE_REGION, "query.cache.person" )
-			.setHint( "javax.persistence.cache.storeMode", CacheStoreMode.REFRESH )
+			.setHint( "jakarta.persistence.cache.storeMode", CacheStoreMode.REFRESH )
 			.getResultList();
 			//end::caching-query-region-store-mode-jpa-example[]
 		});
@@ -206,8 +206,8 @@ public class SecondLevelCacheTest extends BaseEntityManagerFunctionalTestCase {
 		doInJPA( this::entityManagerFactory, entityManager -> {
 			//tag::caching-management-cache-mode-entity-jpa-example[]
 			Map<String, Object> hints = new HashMap<>(  );
-			hints.put( "javax.persistence.cache.retrieveMode" , CacheRetrieveMode.USE );
+			hints.put( "jakarta.persistence.cache.retrieveMode" , CacheRetrieveMode.USE );
-			hints.put( "javax.persistence.cache.storeMode" , CacheStoreMode.REFRESH );
+			hints.put( "jakarta.persistence.cache.storeMode" , CacheStoreMode.REFRESH );
 			Person person = entityManager.find( Person.class, 1L , hints);
 			//end::caching-management-cache-mode-entity-jpa-example[]
 		});
@@ -225,8 +225,8 @@ public class SecondLevelCacheTest extends BaseEntityManagerFunctionalTestCase {
 			List<Person> persons = entityManager.createQuery(
 				"select p from Person p", Person.class)
 			.setHint( QueryHints.HINT_CACHEABLE, "true")
-			.setHint( "javax.persistence.cache.retrieveMode" , CacheRetrieveMode.USE )
+			.setHint( "jakarta.persistence.cache.retrieveMode" , CacheRetrieveMode.USE )
-			.setHint( "javax.persistence.cache.storeMode" , CacheStoreMode.REFRESH )
+			.setHint( "jakarta.persistence.cache.storeMode" , CacheStoreMode.REFRESH )
 			.getResultList();
 			//end::caching-management-cache-mode-query-jpa-example[]
 

documentation/src/test/java/org/hibernate/userguide/collections/ArrayTest.java

@@ -6,8 +6,8 @@
  */
 package org.hibernate.userguide.collections;
 
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/BasicTypeCollectionTest.java

@@ -8,8 +8,8 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.annotations.Type;
 import org.hibernate.cfg.Configuration;

documentation/src/test/java/org/hibernate/userguide/collections/BasicTypeElementCollectionTest.java

@@ -8,9 +8,9 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/BasicTypeOrderColumnElementCollectionTest.java

@@ -8,10 +8,10 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.OrderColumn;
+import jakarta.persistence.OrderColumn;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalBagOrphanRemovalTest.java

@@ -9,12 +9,12 @@ package org.hibernate.userguide.collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalBagTest.java

@@ -9,12 +9,12 @@ package org.hibernate.userguide.collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalComparatorSortedSetTest.java

@@ -11,12 +11,12 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.annotations.SortComparator;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalMapTest.java

@@ -11,15 +11,15 @@ import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.MapKey;
+import jakarta.persistence.MapKey;
-import javax.persistence.MapKeyEnumerated;
+import jakarta.persistence.MapKeyEnumerated;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalOrderByListTest.java

@@ -9,13 +9,13 @@ package org.hibernate.userguide.collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
-import javax.persistence.OrderBy;
+import jakarta.persistence.OrderBy;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalOrderColumnListTest.java

@@ -9,13 +9,13 @@ package org.hibernate.userguide.collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
-import javax.persistence.OrderColumn;
+import jakarta.persistence.OrderColumn;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalSetTest.java

@@ -9,12 +9,12 @@ package org.hibernate.userguide.collections;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/BidirectionalSortedSetTest.java

@@ -10,12 +10,12 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.annotations.SortNatural;

documentation/src/test/java/org/hibernate/userguide/collections/ElementCollectionMapTest.java

@@ -9,15 +9,15 @@ package org.hibernate.userguide.collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
-import javax.persistence.CollectionTable;
+import jakarta.persistence.CollectionTable;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Embeddable;
+import jakarta.persistence.Embeddable;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.MapKeyJoinColumn;
+import jakarta.persistence.MapKeyJoinColumn;
-import javax.persistence.Temporal;
+import jakarta.persistence.Temporal;
-import javax.persistence.TemporalType;
+import jakarta.persistence.TemporalType;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/EmbeddableTypeElementCollectionTest.java

@@ -8,11 +8,11 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Embeddable;
+import jakarta.persistence.Embeddable;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/MapKeyClassTest.java

@@ -9,16 +9,16 @@ package org.hibernate.userguide.collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
-import javax.persistence.CollectionTable;
+import jakarta.persistence.CollectionTable;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Embeddable;
+import jakarta.persistence.Embeddable;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.MapKeyClass;
+import jakarta.persistence.MapKeyClass;
-import javax.persistence.MapKeyColumn;
+import jakarta.persistence.MapKeyColumn;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/MapKeyTypeTest.java

@@ -12,15 +12,15 @@ import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
-import javax.persistence.CollectionTable;
+import jakarta.persistence.CollectionTable;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.ElementCollection;
+import jakarta.persistence.ElementCollection;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.EntityManagerFactory;
+import jakarta.persistence.EntityManagerFactory;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.JoinColumn;
+import jakarta.persistence.JoinColumn;
-import javax.persistence.MapKeyColumn;
+import jakarta.persistence.MapKeyColumn;
-import javax.persistence.Table;
+import jakarta.persistence.Table;
 
 import org.hibernate.annotations.MapKeyType;
 import org.hibernate.annotations.Type;

documentation/src/test/java/org/hibernate/userguide/collections/OrderColumnListIndexBaseTest.java

@@ -9,13 +9,13 @@ package org.hibernate.userguide.collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
-import javax.persistence.OrderColumn;
+import jakarta.persistence.OrderColumn;
 
 import org.hibernate.annotations.ListIndexBase;
 import org.hibernate.annotations.NaturalId;

documentation/src/test/java/org/hibernate/userguide/collections/OrderedBySQLTest.java

@@ -8,13 +8,13 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.FetchType;
+import jakarta.persistence.FetchType;
-import javax.persistence.GeneratedValue;
+import jakarta.persistence.GeneratedValue;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.ManyToOne;
+import jakarta.persistence.ManyToOne;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.dialect.H2Dialect;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;

documentation/src/test/java/org/hibernate/userguide/collections/QueueTest.java

@@ -10,11 +10,11 @@ import java.util.Collection;
 import java.util.LinkedList;
 import java.util.Objects;
 import java.util.Queue;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.CollectionType;
 import org.hibernate.annotations.NaturalId;

documentation/src/test/java/org/hibernate/userguide/collections/UnidirectionalBagTest.java

@@ -8,11 +8,11 @@ package org.hibernate.userguide.collections;
 
 import java.util.ArrayList;
 import java.util.List;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 

documentation/src/test/java/org/hibernate/userguide/collections/UnidirectionalComparatorSortedSetTest.java

@@ -11,11 +11,11 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import javax.persistence.CascadeType;
+import jakarta.persistence.CascadeType;
-import javax.persistence.Column;
+import jakarta.persistence.Column;
-import javax.persistence.Entity;
+import jakarta.persistence.Entity;
-import javax.persistence.Id;
+import jakarta.persistence.Id;
-import javax.persistence.OneToMany;
+import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.NaturalId;
 import org.hibernate.annotations.SortComparator;