HHH-17775 Standardize spelling of "round-trip" and "roundtrip" to "round

trip"

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

@@ -59,7 +59,7 @@ While simple statement logging is fine, using https://github.com/ttddyy/datasour
 === JDBC batching
 
 JDBC allows us to batch multiple SQL statements and to send them to the database server into a single request.
-This saves database roundtrips, and so it https://leanpub.com/high-performance-java-persistence/read#jdbc-batch-updates[reduces response time significantly].
+This saves database round trips, and so it https://leanpub.com/high-performance-java-persistence/read#jdbc-batch-updates[reduces response time significantly].
 
 Not only `INSERT` and `UPDATE` statements, but even `DELETE` statements can be batched as well.
 For `INSERT` and `UPDATE` statements, make sure that you have all the right configuration properties in place, like ordering inserts and updates and activating batching for versioned data.
@@ -101,7 +101,7 @@ However, you should keep in mind that the `IDENTITY` generators disables JDBC ba
 ====
 
 If you're using the `SEQUENCE` generator, then you should be using the enhanced identifier generators that were enabled by default in Hibernate 5.
-The *pooled* and the *pooled-lo* optimizers are very useful to reduce the number of database roundtrips when writing multiple entities per database transaction.
+The *pooled* and the *pooled-lo* optimizers are very useful to reduce the number of database round trips when writing multiple entities per database transaction.
 
 [[best-practices-mapping-associations]]
 ==== Associations

documentation/src/main/asciidoc/userguide/chapters/batch/Batching.adoc

@@ -72,7 +72,7 @@ There are several problems associated with this example:
   If the maximum memory allocated to the JVM is rather low, this example could fail with an `OutOfMemoryException`.
   The Java 1.8 JVM allocated either 1/4 of available RAM or 1Gb, which can easily accommodate 100 000 objects on the heap.
 . long-running transactions can deplete a connection pool so other transactions don't get a chance to proceed.
-. JDBC batching is not enabled by default, so every insert statement requires a database roundtrip.
+. JDBC batching is not enabled by default, so every insert statement requires a database round trip.
   To enable JDBC batching, set the `hibernate.jdbc.batch_size` property to an integer between 10 and 50.
 
 [IMPORTANT]

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

@@ -635,7 +635,7 @@ include::{extrasdir}/id/identifiers-generators-pooled-lo-optimizer-persist-examp
 ====
 
 As you can see from the list of generated SQL statements, you can insert 3 entities with just one database sequence call.
-This way, the pooled and the pooled-lo optimizers allow you to reduce the number of database roundtrips, therefore reducing the overall transaction response time.
+This way, the pooled and the pooled-lo optimizers allow you to reduce the number of database round trips, therefore reducing the overall transaction response time.
 
 [[identifiers-derived]]
 ==== Derived Identifiers

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

@@ -427,7 +427,7 @@ include::{example-dir-fetching}/BatchFetchingTest.java[tags=fetching-batch-mappi
 
 Considering that we have previously fetched several `Department` entities,
 and now we need to initialize the `employees` entity collection for each particular `Department`,
-the `@BatchSize` annotations allows us to load multiple `Employee` entities in a single database roundtrip.
+the `@BatchSize` annotations allows us to load multiple `Employee` entities in a single database round trip.
 
 [[fetching-batch-fetching-example]]
 .`@BatchSize` fetching example

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

@@ -164,7 +164,7 @@ include::{doc-emeddable-example-dir}/SQLTest.java[tags=sql-hibernate-entity-asso
 This will allow the `Phone#person` to function properly since the `many-to-one` or `one-to-one`
 association is going to use a proxy that will be initialized when being navigated for the first time.
 
-It is possible to eagerly join the `Phone` and the `Person` entities to avoid the possible extra roundtrip for initializing the `many-to-one` association.
+It is possible to eagerly join the `Phone` and the `Person` entities to avoid the possible extra round trip for initializing the `many-to-one` association.
 
 [[sql-hibernate-entity-associations-query-many-to-one-join-example]]
 .Hibernate native query selecting entities with joined many-to-one association
@@ -182,7 +182,7 @@ include::{extrasdir}/sql-hibernate-entity-associations-query-many-to-one-join-ex
 
 [NOTE]
 ====
-As seen in the associated SQL query, Hibernate manages to construct the entity hierarchy without requiring any extra database roundtrip.
+As seen in the associated SQL query, Hibernate manages to construct the entity hierarchy without requiring any extra database round trips.
 ====
 
 Even when using the `addJoin()` method, the result list will only contain the root entity.

hibernate-core/src/main/java/org/hibernate/annotations/BatchSize.java

@@ -19,7 +19,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  * entity or collection.
  * <p>
  * When batch fetching is enabled, Hibernate is able to fetch multiple
- * instances of an entity or collection in a single round-trip to the
+ * instances of an entity or collection in a single round trip to the
  * database. Instead of a SQL {@code select} with just one primary key
  * value in the {@code where} clause, the {@code where} clause contains
  * a list of primary keys inside a SQL {@code in} condition. The primary

hibernate-core/src/main/java/org/hibernate/id/enhanced/NoopOptimizer.java

@@ -11,7 +11,7 @@ import java.io.Serializable;
 import org.hibernate.id.IntegralDataTypeHolder;
 
 /**
- * An optimizer that performs no optimization. A round-trip to
+ * An optimizer that performs no optimization. A round trip to
  * the database is required for each new id.
  * <p>
  * This implementation is not the most efficient one.