Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

documentation improvements, especially to the boot package 

also deprecate some unused stuff
This commit is contained in:
Gavin 2022-12-28 19:27:59 +01:00 committed by Gavin King
parent 347ad56772
commit 37042f9b77
138 changed files with 949 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hibernate-core/src/main/java/org/hibernate/IdentifierLoadAccess.java
View File

@ -52,7 +52,7 @@ public interface IdentifierLoadAccess<T> {
/**
* Return the persistent instance with the given identifier, assuming that the instance exists. This method
* might return a proxied instance that is initialized on-demand, when a non-identifier method is accessed.
*
* <p>
* You should not use this method to determine if an instance exists; to check for existence, use {@link #load}
* instead. Use this only to retrieve an instance that you assume exists, where non-existence would be an
* actual error.

25
hibernate-core/src/main/java/org/hibernate/NaturalIdLoadAccess.java
View File

@ -44,25 +44,26 @@ public interface NaturalIdLoadAccess<T> {
/**
* Set multiple natural-id attribute values at once. The passed array is
* expected to have an even number of elements, with the attribute name followed
* by its value. E.g. `using( "system", "matrix", "username", "neo" )`
* by its value, for example, {@code using( "system", "matrix", "username", "neo" )}.
*
* @return {@code this}, for method chaining
*/
NaturalIdLoadAccess<T> using(Object... mappings);
/**
* For entities with mutable natural ids, should Hibernate perform "synchronization" prior to performing
* lookups? The default is to perform "synchronization" (for correctness).
* For entities with mutable natural ids, should natural ids be synchronized prior to performing a lookup?
* The default, for correctness, is to synchronize.
* <p>
* "synchronization" here indicates updating the natural-id -> pk cross reference maintained as part of the
* session. When enabled, prior to performing the lookup, Hibernate will check all entities of the given
* type associated with the session to see if its natural-id values have changed and, if so, update the
* cross reference. There is a performance impact associated with this, so if application developers are
* certain the natural-ids in play have not changed, this setting can be disabled to circumvent that impact.
* However, disabling this setting when natural-ids values have changed can result in incorrect results!
* Here "synchronization" means updating the natural id to primary key cross-reference maintained by the
* session. When enabled, prior to performing the lookup, Hibernate will check all entities of the given
* type associated with the session to see if any natural id values have changed and, if so, update the
* cross-reference. There is a performance penalty associated with this, so if it is completely certain
* the no natural id in play has changed, this setting can be disabled to circumvent that impact.
* Disabling this setting when natural id values <em>have</em> changed can result in incorrect results!
*
* @param enabled Should synchronization be performed? {@code true} indicates synchronization will be performed;
* {@code false} indicates it will be circumvented.
* @param enabled Should synchronization be performed?
* {@code true} indicates synchronization will be performed;
* {@code false} indicates it will be circumvented.
*
* @return {@code this}, for method chaining
*/
@ -71,7 +72,7 @@ public interface NaturalIdLoadAccess<T> {
/**
* Return the persistent instance with the natural id value(s) defined by the call(s) to {@link #using}. This
* method might return a proxied instance that is initialized on-demand, when a non-identifier method is accessed.
*
* <p>
* You should not use this method to determine if an instance exists; to check for existence, use {@link #load}
* instead. Use this only to retrieve an instance that you assume exists, where non-existence would be an
* actual error.

5
hibernate-core/src/main/java/org/hibernate/NaturalIdMultiLoadAccess.java
View File

@ -8,7 +8,6 @@ package org.hibernate;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import org.hibernate.graph.GraphSemantic;
import org.hibernate.graph.RootGraph;
@ -97,7 +96,7 @@ public interface NaturalIdMultiLoadAccess<T> {
/**
* Perform a load of multiple entities by natural-id.
*
* <p>
* See {@link #enableOrderedReturn} and {@link #enableReturnOfDeletedEntities}
* for options which effect the size and "shape" of the return list.
*
@ -109,7 +108,7 @@ public interface NaturalIdMultiLoadAccess<T> {
/**
* Perform a load of multiple entities by natural-id.
*
* <p>
* See {@link #enableOrderedReturn} and {@link #enableReturnOfDeletedEntities}
* for options which effect the size and "shape" of the return list.
*

3
hibernate-core/src/main/java/org/hibernate/SessionFactory.java
View File

@ -106,6 +106,9 @@ import jakarta.persistence.EntityManagerFactory;
* Furthermore, when Hibernate is acting as the JPA persistence provider, the
* method {@link EntityManagerFactory#unwrap(Class)} may be used to obtain the
* underlying {@code SessionFactory}.
* <p>
* The very simplest way to obtain a new {@code SessionFactory} is using a
* {@link org.hibernate.cfg.Configuration}.
*
* @see Session
* @see org.hibernate.cfg.Configuration

2
hibernate-core/src/main/java/org/hibernate/annotations/FilterDef.java
View File

@ -29,7 +29,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
* For example, if a filter is declared as follows:
* <pre>
* &#64;FilterDef(name = "Current",
* defaultCondition = "status<>'DELETED'")
* defaultCondition = "status&lt;&gt;'DELETED'")
* package org.hibernate.domain;
* </pre>
* <p>

2
hibernate-core/src/main/java/org/hibernate/boot/AttributeConverterInfo.java
View File

@ -15,7 +15,7 @@ import org.hibernate.boot.spi.MetadataBuildingContext;
/**
* Delayed information about an AttributeConverter. Delayed until we have
* access to {@link org.hibernate.boot.internal.ClassmateContext} during
* the MetadataSources -> Metadata process.
* the MetadataSources to Metadata process.
*
* @author Steve Ebersole
*

6
hibernate-core/src/main/java/org/hibernate/boot/MetadataBuilder.java
View File

@ -141,9 +141,9 @@ public interface MetadataBuilder {
/**
* Allows specifying a specific Jandex index to use for reading annotation information.
* <p>
* It is <i>important</i> to understand that if a Jandex index is passed in, it is expected that
* this Jandex index already contains all entries for all classes. No additional indexing will be
* done in this case.
* It's important to understand that if a Jandex index is passed in, it is expected that
* this Jandex index already contains all entries for all classes. No additional indexing
* will be done in this case.
*
* @apiNote Here for future expansion. At the moment the passed Jandex index is not used.
*

16
hibernate-core/src/main/java/org/hibernate/boot/archive/scan/spi/package-info.java Normal file
View File

@ -0,0 +1,16 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
/**
* SPI for scanning {@linkplain org.hibernate.boot.archive.spi.ArchiveDescriptor archives}
* to discover managed classes and named resources.
*
* @see org.hibernate.boot.archive.scan.spi.ScanResult
*
* @author Steve Ebersole
*/
package org.hibernate.boot.archive.scan.spi;

13
hibernate-core/src/main/java/org/hibernate/boot/archive/spi/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
/**
* Defines an SPI for {@linkplain org.hibernate.boot.archive.scan scanning}
* of {@linkplain org.hibernate.boot.archive.spi.ArchiveDescriptor archives}
* for discovery of managed resources.
*/
package org.hibernate.boot.archive.spi;

2
hibernate-core/src/main/java/org/hibernate/boot/beanvalidation/ActivationContext.java
View File

@ -13,7 +13,7 @@ import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.service.spi.SessionFactoryServiceRegistry;
/**
* Defines the context needed to call the {@link TypeSafeActivator}
* Defines the context needed to call the {@link TypeSafeActivator}.
*
* @author Steve Ebersole
*/

2
hibernate-core/src/main/java/org/hibernate/boot/beanvalidation/package-info.java
View File

@ -6,7 +6,7 @@
*/
/**
* Support for integrating Jakarta Bean Validation
* Support for integrating Jakarta Bean Validation.
*
* @author Steve Ebersole
*/

20
hibernate-core/src/main/java/org/hibernate/boot/model/convert/package-info.java
View File

@ -6,24 +6,24 @@
*/
/**
* Package defining boot-time handling of JPA's
* {@link jakarta.persistence.AttributeConverter}
*
* Package defining boot-time handling of JPA
* {@link jakarta.persistence.AttributeConverter}s.
* <p>
* The general paradigm is that handling converters is split into a
* boot-time piece and a run-time piece. This package defines the
* boot-time piece. Specifically the boot-time representation of a
* boot-time piece and a run-time piece. This package defines the
* boot-time piece. In particular, the boot-time representation of a
* converter is {@link org.hibernate.boot.model.convert.spi.ConverterDescriptor}.
* Another important aspect is managing the resolution of auto-applied
* converters which is handled by coordination between
* {@link org.hibernate.boot.model.convert.spi.AutoApplicableConverterDescriptor}
* and {@link org.hibernate.boot.model.convert.spi.ConverterAutoApplyHandler}
*
* The run-time piece is defined by
* and {@link org.hibernate.boot.model.convert.spi.ConverterAutoApplyHandler}.
* <p>
* The runtime piece is defined by
* {@link org.hibernate.metamodel.model.convert.spi.JpaAttributeConverter}.
* The bridge from boot-time to run-time is defined by
* The bridge from boot-time to runtime is defined by
* {@link org.hibernate.boot.model.convert.spi.ConverterDescriptor#createJpaAttributeConverter}.
* This process also incorporates integration with
* {@link org.hibernate.resource.beans.spi.ManagedBeanRegistry} for resolving
* converters from DI containers (if configured)
* converters from DI containers (if configured).
*/
package org.hibernate.boot.model.convert;

13
hibernate-core/src/main/java/org/hibernate/boot/model/convert/spi/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Defines the SPI of a
* {@linkplain org.hibernate.boot.model.convert.spi.ConverterRegistry registry}
* of JPA {@link jakarta.persistence.AttributeConverter}s.
*/
package org.hibernate.boot.model.convert.spi;

14
hibernate-core/src/main/java/org/hibernate/boot/model/naming/NamingStrategyHelper.java
View File

@ -15,13 +15,13 @@ public interface NamingStrategyHelper {
/**
* Called when the user supplied no explicit name/identifier for the given database object.
* <p>
* Typically implementations will access the {@link ImplicitNamingStrategy} via
* {@link MetadataBuildingContext#getBuildingOptions()} ->
* Typically, implementations will access the {@link ImplicitNamingStrategy} via
* {@link MetadataBuildingContext#getBuildingOptions()} to
* {@link org.hibernate.boot.spi.MetadataBuildingOptions#getImplicitNamingStrategy()}
* <p>
* For proper quoting, {@link org.hibernate.boot.model.relational.Database#toIdentifier(String)}
* should be used via
* {@link MetadataBuildingContext#getMetadataCollector()} ->
* {@link MetadataBuildingContext#getMetadataCollector()} to
* {@link org.hibernate.boot.spi.InFlightMetadataCollector#getDatabase()}
*
* @param buildingContext The building context in which this is called.
@ -34,12 +34,12 @@ public interface NamingStrategyHelper {
* Called when the user has supplied an explicit name for the database object.
* <p>
* Typically implementations will access the {@link ImplicitNamingStrategy} via
* {@link MetadataBuildingContext#getBuildingOptions()} ->
* {@link MetadataBuildingContext#getBuildingOptions()} to
* {@link org.hibernate.boot.spi.MetadataBuildingOptions#getImplicitNamingStrategy()}
* <p>
* For proper quoting, {@link org.hibernate.boot.model.relational.Database#toIdentifier(String)}
* should be used via
* {@link MetadataBuildingContext#getMetadataCollector()} ->
* {@link MetadataBuildingContext#getMetadataCollector()} to
* {@link org.hibernate.boot.spi.InFlightMetadataCollector#getDatabase()}
*
* @param explicitName The explicit object name.
@ -53,12 +53,12 @@ public interface NamingStrategyHelper {
* Handle converting a logical name to a physical name
* <p>
* Typically implementations will access the {@link PhysicalNamingStrategy} via
* {@link MetadataBuildingContext#getBuildingOptions()} ->
* {@link MetadataBuildingContext#getBuildingOptions()} to
* {@link org.hibernate.boot.spi.MetadataBuildingOptions#getPhysicalNamingStrategy()}
* <p>
* For proper quoting, {@link org.hibernate.boot.model.relational.Database#toIdentifier(String)}
* should be used via
* {@link MetadataBuildingContext#getMetadataCollector()} ->
* {@link MetadataBuildingContext#getMetadataCollector()} to
* {@link org.hibernate.boot.spi.InFlightMetadataCollector#getDatabase()}
*
* @param logicalName The logical name to convert to a physical name

29
hibernate-core/src/main/java/org/hibernate/boot/model/naming/package-info.java
View File

@ -6,25 +6,28 @@
*/
/**
* Represents a proposed new approach to allowing hooks into the process of determining
* the name of database objects (tables, columns, constraints, etc). Historically this is
* the role of the {@link org.hibernate.cfg.NamingStrategy} contract. However, NamingStrategy
* suffers from many design flaws that are just not addressable in any sort of backwards
* compatible manner. So this proposed approach is essentially a clean-room impl based
* on lessons learned through NamingStrategy.
* This API allows intervention by generic code in the process of determining the names of
* database objects (tables, columns, and constraints).
* <p>
* Naming is split here into 2 main pieces:<ol>
* Name determination happens in two phases:
* <ol>
* <li>
* <b>logical</b> - Is the process of applying naming rules to determine the names
* of objects which were not explicitly given names in mapping. See
* <em>Logical naming</em> is the process of applying naming rules to determine the
* names of objects which were not explicitly assigned names in the O/R mapping.
* <p>Here, this is the responsibility of an implementation of
* {@link org.hibernate.boot.model.naming.ImplicitNamingStrategy}.
* </li>
* <li>
* <b>physical</b> - Is the process of applying naming rules to transform the logical
* name into the actual (physical) name that will be used in the database. Rules here
* might be things like using standardized abbreviations ("NUMBER" -> "NUM"), applying
* identifier length shortening, etc. See {@link org.hibernate.boot.model.naming.PhysicalNamingStrategy}.
* <em>Physical naming</em> is the process of applying additional rules to transform
* a logical name into an actual "physical" name that will be used in the database.
* For example, the rules might include things like using standardized abbreviations,
* or trimming the length of identifiers.
* <p>Here, this is the responsibility of an implementation of
* {@link org.hibernate.boot.model.naming.PhysicalNamingStrategy}.
* </li>
* </ol>
*
* @apiNote The API defined in this package replaced the now-deprecated interface
* {@link org.hibernate.cfg.NamingStrategy} from older versions of Hibernate.
*/
package org.hibernate.boot.model.naming;

18
hibernate-core/src/main/java/org/hibernate/boot/model/package-info.java
View File

@ -6,17 +6,15 @@
*/
/**
* Package defining Hibernate's boot-time metamodel, which is an
* understanding of the application's domain model (its entities,
* attributes, etc.) and the mapping of those "domain model parts"
* to the database.
* <p/>
* It is {@linkplain org.hibernate.boot.model.process incrementally built}
* from {@linkplain org.hibernate.annotations annotations} and XML mappings
* This package defines the boot-time metamodel, which is an interpretation
* of the domain model (entity classes, embeddable classes, and attributes)
* and the mapping of these "domain model parts" to the database. It is
* {@linkplain org.hibernate.boot.model.process built incrementally} from
* {@linkplain org.hibernate.annotations annotations} and XML-based mappings.
*
* @implNote Ultimately, as part of the process of creating the
* {@link org.hibernate.SessionFactory}, Hibernate will interpret
* this boot metamodel to its runtime
* {@linkplain org.hibernate.metamodel.mapping mapping metamodel}
* {@link org.hibernate.SessionFactory}, Hibernate
* transforms this boot-time metamodel to its runtime
* {@linkplain org.hibernate.metamodel.mapping mapping metamodel}.
*/
package org.hibernate.boot.model;

6
hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java
View File

@ -88,7 +88,7 @@ public class MetadataBuildingProcess {
private static final Logger log = Logger.getLogger( MetadataBuildingProcess.class );
/**
* Unified single phase for MetadataSources->Metadata process
* Unified single phase for MetadataSources to Metadata process
*
* @param sources The MetadataSources
* @param options The building options
@ -103,7 +103,7 @@ public class MetadataBuildingProcess {
}
/**
* First step of 2-phase for MetadataSources->Metadata process
* First step of two-phase for MetadataSources to Metadata process
*
* @param sources The MetadataSources
* @param bootstrapContext The bootstrapContext
@ -129,7 +129,7 @@ public class MetadataBuildingProcess {
}
/**
* Second step of 2-phase for MetadataSources->Metadata process
* Second step of two-phase for MetadataSources to Metadata process
*
* @param managedResources The token/memento from 1st phase
* @param options The building options

13
hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Defines an SPI used during the process of transforming
* {@linkplain org.hibernate.boot.MetadataSources mapping sources} into
* the {@link org.hibernate.boot.Metadata} reference.
*/
package org.hibernate.boot.model.process.spi;

33
hibernate-core/src/main/java/org/hibernate/boot/model/relational/AuxiliaryDatabaseObject.java
View File

@ -11,9 +11,12 @@ import java.io.Serializable;
import org.hibernate.dialect.Dialect;
/**
* Auxiliary database objects (i.e., triggers, stored procedures, etc) defined
* in the mappings. Allows Hibernate to manage their lifecycle as part of
* creating/dropping the schema.
* An auxiliary database object is a trigger, function, stored procedure,
* or anything similar which is defined using explicit handwritten DDL
* {@code create} and {@code drop} statements in the mapping metadata.
* <p>
* This SPI allows Hibernate to export and clean up these objects along
* with the rest of the schema.
*
* @author Steve Ebersole
*/
@ -27,15 +30,19 @@ public interface AuxiliaryDatabaseObject extends Exportable, Serializable {
boolean appliesToDialect(Dialect dialect);
/**
* Defines a simple precedence. Should creation of this auxiliary object happen before creation of
* tables? If {@code true}, the auxiliary object creation will happen after any explicit schema creations
* but before table/sequence creations; if {@code false}, the auxiliary object creation will happen after
* explicit schema creations and after table/sequence creations.
* Defines a simple precedence.
* Should creation of this auxiliary object happen before creation of tables?
* <ul>
* <li>If {@code true}, the auxiliary object creation will happen after any
* explicit schema creation but before creation of tables and sequences.
* <li>If {@code false}, the auxiliary object creation will happen after
* explicit schema creation and after creation of tables and sequences.
* </ul>
* <p>
* This precedence is automatically inverted for when the schema is dropped.
*
* This precedence is automatically inverted for dropping.
*
* @return {@code true} indicates this object should be created before tables; {@code false} indicates
* it should be created after.
* @return {@code true} indicates this object should be created before tables;
* {@code false} indicates it should be created after tables.
*/
boolean beforeTablesOnCreation();
@ -58,8 +65,8 @@ public interface AuxiliaryDatabaseObject extends Exportable, Serializable {
String[] sqlDropStrings(SqlStringGenerationContext context);
/**
* Additional, optional interface for AuxiliaryDatabaseObject that want to allow
* expansion of allowable dialects via mapping.
* Additional, optional interface for {@code AuxiliaryDatabaseObject}s
* that want to allow expansion of allowable dialects via mapping.
*/
interface Expandable {
void addDialectScope(String dialectName);

4
hibernate-core/src/main/java/org/hibernate/boot/model/relational/ColumnOrderingStrategyStandard.java
View File

@ -24,8 +24,8 @@ import static java.lang.Math.log;
import static org.hibernate.type.SqlTypes.*;
/**
* Standard implementation that orders columns by size and name
* following roughly this ordering: <code>order by max(physicalSizeBytes, 4), physicalSizeBytes > 2048, name</code>
* Standard implementation that orders columns by size and name following roughly this ordering:
* {@code order by max(physicalSizeBytes, 4), physicalSizeBytes > 2048, name}
*/
public class ColumnOrderingStrategyStandard implements ColumnOrderingStrategy {
public static final ColumnOrderingStrategyStandard INSTANCE = new ColumnOrderingStrategyStandard();

46
hibernate-core/src/main/java/org/hibernate/boot/model/relational/Database.java
View File

@ -25,6 +25,8 @@ import org.hibernate.engine.jdbc.spi.JdbcServices;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.spi.TypeConfiguration;
import static java.util.Collections.emptyList;
/**
* @author Steve Ebersole
*/
@ -46,11 +48,11 @@ public class Database {
}
public Database(MetadataBuildingOptions buildingOptions, JdbcEnvironment jdbcEnvironment) {
this.serviceRegistry = buildingOptions.getServiceRegistry();
this.typeConfiguration = buildingOptions.getTypeConfiguration();
this.jdbcEnvironment = jdbcEnvironment;
this.physicalNamingStrategy = buildingOptions.getPhysicalNamingStrategy();
this.dialect = determineDialect( buildingOptions );
serviceRegistry = buildingOptions.getServiceRegistry();
typeConfiguration = buildingOptions.getTypeConfiguration();
physicalNamingStrategy = buildingOptions.getPhysicalNamingStrategy();
dialect = determineDialect( buildingOptions );
setImplicitNamespaceName(
toIdentifier( buildingOptions.getMappingDefaults().getImplicitCatalogName() ),
@ -59,7 +61,7 @@ public class Database {
}
private void setImplicitNamespaceName(Identifier catalogName, Identifier schemaName) {
this.physicalImplicitNamespaceName = new Namespace.Name(
physicalImplicitNamespaceName = new Namespace.Name(
physicalNamingStrategy.toPhysicalCatalogName( catalogName, jdbcEnvironment ),
physicalNamingStrategy.toPhysicalSchemaName( schemaName, jdbcEnvironment )
);
@ -76,8 +78,7 @@ public class Database {
}
private Namespace makeNamespace(Namespace.Name name) {
Namespace namespace;
namespace = new Namespace( this.getPhysicalNamingStrategy(), this.getJdbcEnvironment(), name );
final Namespace namespace = new Namespace( getPhysicalNamingStrategy(), getJdbcEnvironment(), name );
namespaceMap.put( name, namespace );
return namespace;
}
@ -91,8 +92,9 @@ public class Database {
}
/**
* Wrap the raw name of a database object in its Identifier form accounting for quoting from
* any of:<ul>
* Wrap the raw name of a database object in its Identifier form accounting
* for quoting from any of:
* <ul>
* <li>explicit quoting in the name itself</li>
* <li>global request to quote all identifiers</li>
* </ul>
@ -104,9 +106,7 @@ public class Database {
* @return The wrapped Identifier form
*/
public Identifier toIdentifier(String text) {
return text == null
? null
: jdbcEnvironment.getIdentifierHelper().toIdentifier( text );
return text == null ? null : jdbcEnvironment.getIdentifierHelper().toIdentifier( text );
}
public PhysicalNamingStrategy getPhysicalNamingStrategy() {
@ -119,7 +119,7 @@ public class Database {
/**
* @return The default namespace, with a {@code null} catalog and schema
* which will have to be interpreted with defaults at runtime.
* which will have to be interpreted with defaults at runtime.
* @see SqlStringGenerationContext
*/
public Namespace getDefaultNamespace() {
@ -127,8 +127,9 @@ public class Database {
}
/**
* @return The implicit name of the default namespace, with a {@code null} catalog and schema
* which will have to be interpreted with defaults at runtime.
* @return The implicit name of the default namespace, with a {@code null}
* catalog and schema which will have to be interpreted with defaults
* at runtime.
* @see SqlStringGenerationContext
*/
public Namespace.Name getPhysicalImplicitNamespaceName() {
@ -137,11 +138,8 @@ public class Database {
public Namespace locateNamespace(Identifier catalogName, Identifier schemaName) {
final Namespace.Name name = new Namespace.Name( catalogName, schemaName );
Namespace namespace = namespaceMap.get( name );
if ( namespace == null ) {
namespace = makeNamespace( name );
}
return namespace;
final Namespace namespace = namespaceMap.get( name );
return namespace == null ? makeNamespace( name ) : namespace;
}
public Namespace adjustDefaultNamespace(Identifier catalogName, Identifier schemaName) {
@ -158,15 +156,11 @@ public class Database {
}
public Collection<AuxiliaryDatabaseObject> getAuxiliaryDatabaseObjects() {
return auxiliaryDatabaseObjects == null
? Collections.emptyList()
: auxiliaryDatabaseObjects.values();
return auxiliaryDatabaseObjects == null ? emptyList() : auxiliaryDatabaseObjects.values();
}
public Collection<InitCommand> getInitCommands() {
return initCommands == null
? Collections.emptyList()
: initCommands;
return initCommands == null ? emptyList() : initCommands;
}
public void addInitCommand(InitCommand initCommand) {

8
hibernate-core/src/main/java/org/hibernate/boot/model/relational/QualifiedName.java
View File

@ -16,7 +16,7 @@ import org.hibernate.boot.model.naming.Identifier;
* </ol>
* <p>
* Also, be careful about the usage of {@link #render}. If the intention is to get the name
* as used in the database, the {@link org.hibernate.engine.jdbc.env.spi.JdbcEnvironment} ->
* as used in the database, the {@link org.hibernate.engine.jdbc.env.spi.JdbcEnvironment} to
* {@link org.hibernate.engine.jdbc.env.spi.QualifiedObjectNameFormatter#format} should be
* used instead.
*
@ -28,10 +28,10 @@ public interface QualifiedName {
Identifier getObjectName();
/**
* Returns a String-form of the qualified name.
* Returns a string form of the qualified name.
* <p>
* Depending on intention, may not be appropriate. May want
* {@link SqlStringGenerationContext#format}
* Depending on intention, may not be appropriate.
* May want {@link SqlStringGenerationContext#format}
* instead.
*
* @return The string form

14
hibernate-core/src/main/java/org/hibernate/boot/model/relational/package-info.java Normal file
View File

@ -0,0 +1,14 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
/**
* Some SPIs related to DDL generation and schema management.
* <p>
* Includes the extremely useful
* {@link org.hibernate.boot.model.relational.AuxiliaryDatabaseObject}.
*/
package org.hibernate.boot.model.relational;

28
hibernate-core/src/main/java/org/hibernate/boot/package-info.java
View File

@ -11,6 +11,32 @@
* configuration information and construct a new instance of
* {@link org.hibernate.SessionFactory}.
* <p>
* See the <i>Native Bootstrapping</i> guide for more details.
* Configuring Hibernate using these APIs usually starts with
* {@link org.hibernate.boot.MetadataBuilder} and
* {@link org.hibernate.boot.registry.StandardServiceRegistryBuilder}.
* See the <em>Native Bootstrapping</em> guide for more details.
* <p>
* Included in subpackages under this namespace are:
* <ul>
* <li>implementations of {@link org.hibernate.boot.MetadataBuilder}
* and {@link org.hibernate.boot.Metadata},
* <li>{@linkplain org.hibernate.boot.model.naming support} for
* {@link org.hibernate.boot.model.naming.ImplicitNamingStrategy}
* and {@link org.hibernate.boot.model.naming.PhysicalNamingStrategy},
* <li>{@linkplain org.hibernate.boot.spi a range of SPIs} allowing
* integration with the process of building metadata,
* <li>internal code for parsing and interpreting mapping information
* declared in XML or using annotations,
* <li>{@linkplain org.hibernate.boot.registry implementations} of
* {@link org.hibernate.service.ServiceRegistry} used during
* the bootstrap process,
* <li>{@linkplain org.hibernate.boot.beanvalidation support} for
* integrating an implementation of Bean Validation, such as
* Hibernate Validator, and
* <li>{@linkplain org.hibernate.boot.model.relational some SPIs}
* used for schema management including support for exporting
* {@linkplain org.hibernate.boot.model.relational.AuxiliaryDatabaseObject
* auxiliary database objects}.
* </ul>
*/
package org.hibernate.boot;

30
hibernate-core/src/main/java/org/hibernate/boot/registry/package-info.java
View File

@ -6,21 +6,21 @@
*/
/**
* Defines service registry contracts application are likely to want to utilize for
* configuring Hibernate behavior.
* Defines service registry contracts application are may utilize for configuring Hibernate.
* <p>
* Service registries are designed to be hierarchical. This works in 2 fashions. First registries can "hide" or
* "override" services from parent registries. It also allows granular building of registries as services
* become available.
* <p>
* {@link org.hibernate.boot.registry.BootstrapServiceRegistry} is the base service registry, intended to be built via
* {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder} if you need customization. For non-customized
* {@link org.hibernate.boot.registry.BootstrapServiceRegistry} usage, the {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder} and
* {@link org.hibernate.boot.registry.BootstrapServiceRegistry} can be bypassed altogether.
* <p>
* Usually the next level in a standard registry set up is the {@link org.hibernate.boot.registry.StandardServiceRegistry}, intended to be built
* by the {@link org.hibernate.boot.registry.StandardServiceRegistryBuilder} if you need customization. The builder optionally takes the
* {@link org.hibernate.boot.registry.BootstrapServiceRegistry} to use as a base; if none is provided a default one is generated assuming sensible
* defaults in Java SE and EE environments, particularly in respect to Class loading.
* Service registries are hierarchical. That is, a child registry may "hide" or "override" services from its parent
* registries. This allows for granular construction of registries as services become available.
* <ol>
* <li>
* {@link org.hibernate.boot.registry.BootstrapServiceRegistry} is the base service registry, and may be constructed via
* {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder} if customization is needed. For non-customized
* usage, these APIs may be bypassed completely.
* <li>
* The next level in a standard registry setup is the {@link org.hibernate.boot.registry.StandardServiceRegistry},
* which may be constructed using {@link org.hibernate.boot.registry.StandardServiceRegistryBuilder} if customization
* is needed. The builder optionally accepts s {@link org.hibernate.boot.registry.BootstrapServiceRegistry} to use as a
* base. If none is provided, a default instance is produced, assuming sensible defaults in Java SE and EE environments,
* particularly with respect to classloading.
* </ol>
*/
package org.hibernate.boot.registry;

5
hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingMetadataBuilderImplementor.java
View File

@ -36,10 +36,9 @@ import org.jboss.jandex.IndexView;
*
* @author Gunnar Morling
*
* @param <T> The type of a specific sub-class; Allows sub-classes to narrow down the return-type of the contract methods
* to a specialization of {@link MetadataBuilderImplementor}
* @param <T> The specific subclass; Allows subclasses to narrow the return type of the contract methods
* to a specialization of {@link MetadataBuilderImplementor}.
*/
@SuppressWarnings("unused")
public abstract class AbstractDelegatingMetadataBuilderImplementor<T extends MetadataBuilderImplementor> implements MetadataBuilderImplementor {
private final MetadataBuilderImplementor delegate;

5
hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingSessionFactoryBuilder.java
View File

@ -30,8 +30,9 @@ import org.hibernate.resource.jdbc.spi.StatementInspector;
* @author Steve Ebersole
* @author Gunnar Morling
* @author Guillaume Smet
* @param <T> The type of a specific sub-class; Allows sub-classes to narrow down the return-type of the contract methods
* to a specialization of {@link SessionFactoryBuilder}
*
* @param <T> The specific subclass; Allows subclasses to narrow the return type of the contract methods
* to a specialization of {@link MetadataBuilderImplementor}.
*/
public abstract class AbstractDelegatingSessionFactoryBuilder<T extends SessionFactoryBuilder> implements SessionFactoryBuilder {
private final SessionFactoryBuilder delegate;

5
hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingSessionFactoryBuilderImplementor.java
View File

@ -10,8 +10,9 @@ package org.hibernate.boot.spi;
* Convenience base class for custom implementors of {@link SessionFactoryBuilderImplementor}, using delegation
*
* @author Guillaume Smet
* @param <T> The type of a specific sub-class; Allows sub-classes to narrow down the return-type of the contract methods
* to a specialization of {@link SessionFactoryBuilderImplementor}
*
* @param <T> The specific subclass; Allows subclasses to narrow the return type of the contract methods
* to a specialization of {@link MetadataBuilderImplementor}.
*/
public abstract class AbstractDelegatingSessionFactoryBuilderImplementor<T extends SessionFactoryBuilderImplementor>
extends AbstractDelegatingSessionFactoryBuilder<T> implements SessionFactoryBuilderImplementor {

8
hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingSessionFactoryOptions.java
View File

@ -38,14 +38,14 @@ import org.hibernate.resource.jdbc.spi.StatementInspector;
import org.hibernate.type.FormatMapper;
/**
* Convenience base class for custom implementors of SessionFactoryOptions, using delegation
* Convenience base class for custom implementations of {@link SessionFactoryOptions}
* using delegation.
*
* @implNote non-abstract to ensure that all SessionFactoryOptions methods have at least
* a default implementation
* @implNote Declared non-abstract to ensure that all {@link SessionFactoryOptions} methods
* have at least a default implementation.
*
* @author Steve Ebersole
*/
@SuppressWarnings("unused")
public class AbstractDelegatingSessionFactoryOptions implements SessionFactoryOptions {
private final SessionFactoryOptions delegate;

51
hibernate-core/src/main/java/org/hibernate/boot/spi/AccessType.java
View File

@ -6,8 +6,11 @@
*/
package org.hibernate.boot.spi;
import org.hibernate.AssertionFailure;
import org.hibernate.HibernateException;
/**
* Enum defining different access strategies for accessing entity values.
* Enumerates various access strategies for accessing entity values.
*
* @author Hardy Ferentschik
*/
@ -34,7 +37,7 @@ public enum AccessType {
private final String accessType;
private AccessType(String type) {
AccessType(String type) {
this.accessType = type;
}
@ -48,47 +51,43 @@ public enum AccessType {
}
/**
* Resolve an externalized name to the AccessType enum value it names.
* Resolve an externalized name to the {@code AccessType} value it names.
*
* @param externalName The external name
*
* @return The matching AccessType; {@link #DEFAULT} is returned rather than {@code null}
* @return The matching {@code AccessType};
* {@link #DEFAULT} is returned rather than {@code null}
*/
public static AccessType getAccessStrategy(String externalName) {
if ( externalName == null ) {
return DEFAULT;
}
else if ( FIELD.getType().equals( externalName ) ) {
return FIELD;
}
else if ( PROPERTY.getType().equals( externalName ) ) {
return PROPERTY;
}
else if ( RECORD.getType().equals( externalName ) ) {
return RECORD;
}
else {
// TODO historically if the externalName string could not be matched default access was used. Maybe this should be an exception though!?
return DEFAULT;
for ( AccessType value : values() ) {
if ( value.accessType.equals( externalName ) ) {
return value;
}
}
return DEFAULT; // because sometimes we get passed magic values like "unsupported"
}
/**
* Convert the JPA access type enum to the corresponding AccessType enum value.
* Convert the JPA access type to the corresponding {@link AccessType} value.
*
* @param type The JPA enum value
* @param type The JPA access type
*
* @return The Hibernate AccessType
* @return The Hibernate {@link AccessType}
*/
public static AccessType getAccessStrategy(jakarta.persistence.AccessType type) {
if ( jakarta.persistence.AccessType.PROPERTY.equals( type ) ) {
return PROPERTY;
}
else if ( jakarta.persistence.AccessType.FIELD.equals( type ) ) {
return FIELD;
}
else {
if ( type == null ) {
return DEFAULT;
}
switch ( type ) {
case FIELD:
return FIELD;
case PROPERTY:
return PROPERTY;
default:
throw new AssertionFailure( "unrecognized AccessType" );
}
}
}

4
hibernate-core/src/main/java/org/hibernate/boot/spi/AdditionalJaxbMappingProducer.java
View File

@ -16,8 +16,8 @@ import org.jboss.jandex.IndexView;
/**
* @author Steve Ebersole
*
* @deprecated Intended for Envers integration until we can migrate Envers away from XML generation
* for building its model.
* @deprecated Intended for Envers integration until we can migrate Envers
* away from XML generation for building its model.
*/
@Deprecated
public interface AdditionalJaxbMappingProducer {

83
hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java
View File

@ -33,9 +33,9 @@ import org.hibernate.type.spi.TypeConfiguration;
import org.jboss.jandex.IndexView;
/**
* Defines a context for things generally available to the process of
* bootstrapping a SessionFactory that are expected to be released after
* the SessionFactory is built.
* Defines a context for things available during the process of bootstrapping
* a {@link org.hibernate.SessionFactory} which are expected to be cleaned up
* after the {@code SessionFactory} is built.
*
* @author Steve Ebersole
*/
@ -57,7 +57,7 @@ public interface BootstrapContext {
TypeConfiguration getTypeConfiguration();
/**
* BeanInstanceProducer to use when creating custom type references.
* The {@link BeanInstanceProducer} to use when creating custom type references.
*
* @implNote Generally this will be a {@link TypeBeanInstanceProducer}
* reference
@ -86,14 +86,15 @@ public interface BootstrapContext {
*
* Indicates that bootstrap was initiated from JPA bootstrapping.
*
* @implSpec Internally, {@code false} is the assumed value. We
* only need to call this to mark that as {@code true}.
* @implSpec Internally, {@code false} is the assumed value.
* We only need to call this to mark that as {@code true}.
*/
void markAsJpaBootstrap();
/**
* Access the temporary ClassLoader passed to us as defined by
* {@link jakarta.persistence.spi.PersistenceUnitInfo#getNewTempClassLoader()}, if any.
* Access the temporary {@link ClassLoader} passed to us, as defined by
* {@link jakarta.persistence.spi.PersistenceUnitInfo#getNewTempClassLoader()},
* if any.
*
* @return The tempo ClassLoader
*/
@ -105,17 +106,17 @@ public interface BootstrapContext {
ClassLoaderAccess getClassLoaderAccess();
/**
* Access to the shared Classmate objects used throughout Hibernate's
* bootstrap process.
* Access to the shared {@link ClassmateContext} object used
* throughout the bootstrap process.
*
* @return Access to the shared Classmate delegates.
* @return Access to the shared {@link ClassmateContext} delegates.
*/
ClassmateContext getClassmateContext();
/**
* Access to the ArchiveDescriptorFactory to be used for scanning
* Access to the {@link ArchiveDescriptorFactory} used for scanning.
*
* @return The ArchiveDescriptorFactory
* @return The {@link ArchiveDescriptorFactory}
*/
ArchiveDescriptorFactory getArchiveDescriptorFactory();
@ -127,15 +128,18 @@ public interface BootstrapContext {
ScanOptions getScanOptions();
/**
* Access to the environment for scanning. Consider this temporary; see discussion on
* {@link ScanEnvironment}
* Access to the environment for scanning.
*
* @apiNote Consider this temporary; see discussion on {@link ScanEnvironment}.
*
* @return The scan environment
*/
ScanEnvironment getScanEnvironment();
/**
* Access to the Scanner to be used for scanning. Can be:<ul>
* Access to the Scanner to be used for scanning.
* Can be:
* <ul>
* <li>A Scanner instance</li>
* <li>A Class reference to the Scanner implementor</li>
* <li>A String naming the Scanner implementor</li>
@ -146,13 +150,11 @@ public interface BootstrapContext {
Object getScanner();
/**
* Retrieve the Hibernate Commons Annotations ReflectionManager to use.
* Retrieve the Hibernate Commons Annotations {@link ReflectionManager}.
*
* @return The Hibernate Commons Annotations ReflectionManager to use.
*
* @apiNote Supported for internal use only. This method will go away as
* we migrate away from Hibernate Commons Annotations to Jandex for annotation
* handling and XMl->annotation merging.
* @apiNote Supported for internal use only. This method will go away as
* we migrate away from Hibernate Commons Annotations to Jandex for
* annotation handling and XMl to annotation merging.
*/
@Internal
ReflectionManager getReflectionManager();
@ -161,67 +163,70 @@ public interface BootstrapContext {
* Access to the Jandex index passed by call to
* {@link org.hibernate.boot.MetadataBuilder#applyIndexView(IndexView)}, if any.
* <p>
* Note that Jandex is currently not used. See https://github.com/hibernate/hibernate-orm/wiki/Roadmap7.0
* @apiNote Jandex is currently not used, see
* <a href="https://github.com/hibernate/hibernate-orm/wiki/Roadmap7.0">the roadmap</a>
*
* @return The Jandex index
*/
IndexView getJandexView();
/**
* Access to any SQL functions explicitly registered with the MetadataBuilder. This
* does not include Dialect defined functions, etc.
* Access to any SQL functions explicitly registered with the
* {@code MetadataBuilder}.
* This does not include {@code Dialect}-defined functions, etc.
* <p>
* Should never return {@code null}
* Should never return {@code null}.
*
* @return The SQLFunctions registered through MetadataBuilder
* @return The {@link SqmFunctionDescriptor}s registered via {@code MetadataBuilder}
*/
Map<String, SqmFunctionDescriptor> getSqlFunctions();
/**
* Access to any AuxiliaryDatabaseObject explicitly registered with the MetadataBuilder. This
* does not include AuxiliaryDatabaseObject defined in mappings.
* Access to any {@link AuxiliaryDatabaseObject}s explicitly registered with
* the {@code MetadataBuilder}.
* This does not include {@link AuxiliaryDatabaseObject}s defined in mappings.
* <p>
* Should never return {@code null}
* Should never return {@code null}.
*
* @return The AuxiliaryDatabaseObject registered through MetadataBuilder
* @return The {@link AuxiliaryDatabaseObject}s registered via {@code MetadataBuilder}
*/
Collection<AuxiliaryDatabaseObject> getAuxiliaryDatabaseObjectList();
/**
* Access to collected AttributeConverter definitions.
* Access to collected {@link jakarta.persistence.AttributeConverter} definitions.
* <p>
* Should never return {@code null}
* Should never return {@code null}.
*
* @return The AttributeConverterInfo registered through MetadataBuilder
* @return The {@link ConverterDescriptor}s registered via {@code MetadataBuilder}
*/
Collection<ConverterDescriptor> getAttributeConverters();
/**
* Access to all explicit cache region mappings.
* <p>
* Should never return {@code null}
* Should never return {@code null}.
*
* @return Explicit cache region mappings
*/
Collection<CacheRegionDefinition> getCacheRegionDefinitions();
/**
* See {@link ManagedTypeRepresentationResolver}
* @see ManagedTypeRepresentationResolver
*/
ManagedTypeRepresentationResolver getRepresentationStrategySelector();
/**
* Releases the "bootstrap only" resources held by this BootstrapContext.
* Releases the "bootstrap only" resources held by this {@code BootstrapContext}.
*/
void release();
/**
* To support envers
* To support Envers.
*/
void registerAdHocBasicType(BasicTypeImpl<?> basicType);
/**
* To support envers
* To support Envers.
*/
<T> BasicTypeImpl<T> resolveAdHocBasicType(String key);
}

6
hibernate-core/src/main/java/org/hibernate/boot/spi/ClassLoaderAccess.java
View File

@ -9,9 +9,9 @@ package org.hibernate.boot.spi;
import java.net.URL;
/**
* During the process of building this metamodel, accessing the ClassLoader
* is very discouraged. However, sometimes it is needed. This contract helps
* mitigate accessing the ClassLoader in these cases.
* During the process of building the metamodel, access to the {@link ClassLoader}
* is highly discouraged. However, sometimes it is needed. This contract helps mitigate
* access to the {@link ClassLoader} in these cases.
*
* @author Steve Ebersole
*

4
hibernate-core/src/main/java/org/hibernate/boot/spi/JpaOrmXmlPersistenceUnitDefaultAware.java
View File

@ -7,8 +7,8 @@
package org.hibernate.boot.spi;
/**
* Contract for things that need to be aware of JPA {@code orm.xml}-defined persistence-unit-defaults. Only
* MetadataBuildingOptions are supported to implement this contract.
* Contract for things that need to be aware of JPA {@code orm.xml}-defined persistence-unit-defaults.
* Only {@link MetadataBuildingOptions} are supported to implement this contract.
*
* @since 5.0
*

4
hibernate-core/src/main/java/org/hibernate/boot/spi/MappingDefaults.java
View File

@ -13,8 +13,8 @@ import org.hibernate.metamodel.CollectionClassification;
* Values to use as defaults in the absence of certain mapping information.
*
* @implSpec Designed with stacking in mind, such that the defaults can be overridden at
* various levels using simple wrapping and delegation. The "global" level is configuration
* settings.
* various levels using simple wrapping and delegation. The "global" level is
* configuration settings.
*
* @author Steve Ebersole
* @author Gail Badner

4
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuilderFactory.java
View File

@ -11,8 +11,8 @@ import org.hibernate.boot.MetadataSources;
/**
* An extension point for integrators that wish to hook into the process of how a {@link Metadata} is built. Intended as
* a "discoverable service" ({@link java.util.ServiceLoader}). There can be at most one implementation discovered that
* returns a non-null SessionFactoryBuilder.
* a "discoverable service" (a {@link java.util.ServiceLoader}). There can be at most one implementation discovered that
* returns a non-null {@link org.hibernate.boot.MetadataBuilder}.
*
* @author Gunnar Morling
*/

2
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuilderImplementor.java
View File

@ -9,7 +9,7 @@ package org.hibernate.boot.spi;
import org.hibernate.boot.MetadataBuilder;
/**
* Internal API for MetadataBuilder exposing the building options being collected.
* Internal API for {@link MetadataBuilder} exposing the building options being collected.
*
* @author Steve Ebersole
*/

10
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuilderInitializer.java
View File

@ -10,11 +10,11 @@ import org.hibernate.boot.MetadataBuilder;
import org.hibernate.boot.registry.StandardServiceRegistry;
/**
* Contract for contributing to the initialization of MetadataBuilder. Called
* immediately after any configuration settings have been applied from
* {@link org.hibernate.engine.config.spi.ConfigurationService}. Any values specified
* here override those. Any values set here can still be overridden explicitly by the user
* via the exposed config methods of {@link MetadataBuilder}
* Contract for contributing to the initialization of {@link MetadataBuilder}.
* Called immediately after any configuration settings have been applied from
* {@link org.hibernate.engine.config.spi.ConfigurationService}. Any values
* specified here override those. Any values set here can still be overridden
* explicitly by the user via the exposed methods of {@link MetadataBuilder}.
*
* @author Steve Ebersole
*

8
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuildingContext.java
View File

@ -12,10 +12,10 @@ import org.hibernate.boot.model.naming.ObjectNameNormalizer;
import org.hibernate.internal.util.config.ConfigurationHelper;
/**
* Describes the context in which the process of building Metadata out of MetadataSources occurs.
*
* BindingContext are generally hierarchical getting more specific as we "go
* down". E.g. global -> PU -> document -> mapping
* Describes the context in which the process of building {@link org.hibernate.boot.Metadata}
* from {@link org.hibernate.boot.MetadataSources} occurs.
* <p>
* {@link MetadataBuildingContext}s are hierarchical: global, persistence unit, document, mapping.
*
* @author Steve Ebersole
*

4
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuildingOptions.java
View File

@ -27,8 +27,8 @@ import org.hibernate.metamodel.spi.ManagedTypeRepresentationResolver;
import org.hibernate.type.spi.TypeConfiguration;
/**
* Describes the options used while building the Metadata object (during
* {@link org.hibernate.boot.MetadataBuilder#build()} processing).
* Describes the options used while building the {@link org.hibernate.boot.Metadata}
* object during {@link org.hibernate.boot.MetadataBuilder#build()} processing.
*
* @author Steve Ebersole
*

4
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataContributor.java
View File

@ -9,8 +9,8 @@ package org.hibernate.boot.spi;
import org.jboss.jandex.IndexView;
/**
* Contract for contributing to Metadata (InFlightMetadataCollector).
*
* Contract for contributing to {@link org.hibernate.boot.Metadata} ({@link InFlightMetadataCollector}).
* <p>
* This hook occurs just after all processing of all {@link org.hibernate.boot.MetadataSources},
* and just before {@link AdditionalJaxbMappingProducer}.
*

2
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataImplementor.java
View File

@ -19,7 +19,7 @@ import org.hibernate.query.named.NamedObjectRepository;
import org.hibernate.type.spi.TypeConfiguration;
/**
* The SPI-level Metadata contract.
* The SPI-level {@link Metadata} contract.
*
* @author Steve Ebersole
*

2
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataSourcesContributor.java
View File

@ -9,7 +9,7 @@ package org.hibernate.boot.spi;
import org.hibernate.boot.MetadataSources;
/**
* A bootstrap process hook for contributing sources to MetadataSources.
* A bootstrap process hook for contributing sources to {@link MetadataSources}.
*
* @author Steve Ebersole
*

2
hibernate-core/src/main/java/org/hibernate/boot/spi/PropertyData.java
View File

@ -11,7 +11,7 @@ import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.annotations.common.reflection.XProperty;
/**
* Details about an attribute as we process the {@linkplain org.hibernate.mapping boot model}
* Details about an attribute as we process the {@linkplain org.hibernate.mapping boot model}.
*/
public interface PropertyData {

2
hibernate-core/src/main/java/org/hibernate/boot/spi/SecondPass.java
View File

@ -15,7 +15,7 @@ import org.hibernate.mapping.PersistentClass;
/**
* Hibernate builds its {@linkplain org.hibernate.mapping build-time model}
* incrementally, often delaying operations until other pieces of information
* are available. A second pass represents one of these delay-able operations.
* are available. A second pass represents one of these delayed operations.
*
* @author Gavin King
* @author Emmanuel Bernard

16
hibernate-core/src/main/java/org/hibernate/boot/spi/SessionFactoryBuilderFactory.java
View File

@ -10,19 +10,21 @@ import org.hibernate.boot.SessionFactoryBuilder;
/**
* An extension point for integrators that wish to hook into the process of how a SessionFactory
* is built. Intended as a "discoverable service" ({@link java.util.ServiceLoader}). There can
* be at most one implementation discovered that returns a non-null SessionFactoryBuilder.
* is built. Intended as a "discoverable service" ({@link java.util.ServiceLoader}). There can
* be at most one implementation discovered that returns a non-null {@link SessionFactoryBuilder}.
*
* @author Steve Ebersole
*/
public interface SessionFactoryBuilderFactory {
/**
* The contract method. Return the SessionFactoryBuilder. May return {@code null}
* The contract method. Return the {@link SessionFactoryBuilder}. May return {@code null}
*
* @param metadata The metadata from which we will be building a SessionFactory.
* @param defaultBuilder The default SessionFactoryBuilder instance. If the SessionFactoryBuilder being built
* here needs to use this passed SessionFactoryBuilder instance it is the responsibility of the built
* SessionFactoryBuilder impl to delegate configuration calls to the passed default impl.
* @param metadata The metadata from which we will be building a {@code SessionFactory}.
* @param defaultBuilder The default SessionFactoryBuilder instance.
* If the {@code SessionFactoryBuilder} being built here needs to use
* this passed {@code SessionFactoryBuilder} instance, it is the
* responsibility of the built {@code SessionFactoryBuilder} impl
* to delegate configuration calls to the passed default impl.
*
* @return The SessionFactoryBuilder, or {@code null}
*/

4
hibernate-core/src/main/java/org/hibernate/boot/spi/SessionFactoryBuilderImplementor.java
View File

@ -9,8 +9,8 @@ package org.hibernate.boot.spi;
import org.hibernate.boot.SessionFactoryBuilder;
/**
* Additional contract for SessionFactoryBuilder mainly intended for implementors
* of SessionFactoryBuilderFactory.
* Additional contract for {@link SessionFactoryBuilder} mainly intended for implementors
* of {@link SessionFactoryBuilderFactory}.
*
* @author Steve Ebersole
*/

2
hibernate-core/src/main/java/org/hibernate/boot/spi/SessionFactoryBuilderService.java
View File

@ -10,7 +10,7 @@ import org.hibernate.boot.internal.MetadataImpl;
import org.hibernate.service.Service;
/**
* Allows bootstrapping Hibernate ORM using a custom {@link SessionFactoryBuilderImplementor}
* Allows bootstrapping Hibernate ORM using a custom {@link SessionFactoryBuilderImplementor}.
*/
public interface SessionFactoryBuilderService extends Service {

2
hibernate-core/src/main/java/org/hibernate/boot/spi/SessionFactoryOptions.java
View File

@ -35,7 +35,7 @@ import org.hibernate.stat.Statistics;
import org.hibernate.type.FormatMapper;
/**
* Aggregator of special options used to build the SessionFactory.
* Aggregator of special options used to build the {@link org.hibernate.SessionFactory}.
*
* @since 5.0
*/

5
hibernate-core/src/main/java/org/hibernate/boot/spi/XmlMappingBinderAccess.java
View File

@ -28,8 +28,9 @@ import org.hibernate.service.ServiceRegistry;
import org.jboss.logging.Logger;
/**
* Poor naming. Models the binder and a class-loader to be a
* one-stop-shop in terms of binding mappings.
* Holds the XML binder and a classloader used for binding mappings.
*
* @apiNote This class is very poorly named.
*
* @author Steve Ebersole
*/

11
hibernate-core/src/main/java/org/hibernate/boot/spi/package-info.java Normal file
View File

@ -0,0 +1,11 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* A range of SPIs allowing integration with&mdash;and customization of&mdash;the process of building metadata.
*/
package org.hibernate.boot.spi;

2
hibernate-core/src/main/java/org/hibernate/boot/xsd/package-info.java
View File

@ -6,6 +6,6 @@
*/
/**
* Support for XSD handling
* Support for XSD handling.
*/
package org.hibernate.boot.xsd;

2
hibernate-core/src/main/java/org/hibernate/cache/cfg/package-info.java vendored
View File

@ -6,6 +6,6 @@
*/
/**
* Package used to model various aspects of caching configuration.
* Package used to model various aspects of the second-level cache configuration.
*/
package org.hibernate.cache.cfg;

11
hibernate-core/src/main/java/org/hibernate/cache/cfg/spi/package-info.java vendored Normal file
View File

@ -0,0 +1,11 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
/**
* An SPI modelling various aspects of the second-level cache configuration.
*/
package org.hibernate.cache.cfg.spi;

4
hibernate-core/src/main/java/org/hibernate/cache/spi/access/CollectionDataAccess.java vendored
View File

@ -13,11 +13,11 @@ import org.hibernate.persister.collection.CollectionPersister;
* Contract for managing transactional and concurrent access to cached collection
* data. For cached collection data, all modification actions actually just
* invalidate the entry(s). The call sequence here is:
* {@link #lockItem} -> {@link #remove} -> {@link #unlockItem}
* {@link #lockItem} then {@link #remove} then {@link #unlockItem}
* <p>
* There is another usage pattern that is used to invalidate entries
* afterQuery performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
* {@link #lockRegion} then {@link #removeAll} then {@link #unlockRegion}
*
* @author Gavin King
* @author Steve Ebersole

12
hibernate-core/src/main/java/org/hibernate/cache/spi/access/EntityDataAccess.java vendored
View File

@ -14,15 +14,14 @@ import org.hibernate.persister.entity.EntityPersister;
/**
* Contract for managing transactional and concurrent access to cached entity
* data. The expected call sequences related to various operations are:<ul>
* <li><b>INSERTS</b> : {@link #insert} -> {@link #afterInsert}</li>
* <li><b>UPDATES</b> : {@link #lockItem} -> {@link #update} -> {@link #afterUpdate}</li>
* <li><b>DELETES</b> : {@link #lockItem} -> {@link #remove} -> {@link #unlockItem}</li>
* <li><b>INSERTS</b> : {@link #insert} then {@link #afterInsert}</li>
* <li><b>UPDATES</b> : {@link #lockItem} then {@link #update} then {@link #afterUpdate}</li>
* <li><b>DELETES</b> : {@link #lockItem} then {@link #remove} then {@link #unlockItem}</li>
* <li><b>LOADS</b> : {@link #putFromLoad}</li>
* </ul>
* <p>
* There is another usage pattern that is used to invalidate entries
* after performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
* There is another usage pattern that is used to invalidate entries after performing "bulk" HQL/SQL operations:
* {@link #lockRegion} then {@link #removeAll} then {@link #unlockRegion}
*
* @author Gavin King
* @author Steve Ebersole
@ -86,7 +85,6 @@ public interface EntityDataAccess extends CachedDomainDataAccess {
* instead of calling evict(). This method is used by "synchronous" concurrency
* strategies.
*
*
* @param session Current session
* @param key The item key
* @param value The item

11
hibernate-core/src/main/java/org/hibernate/cache/spi/access/NaturalIdDataAccess.java vendored
View File

@ -13,18 +13,17 @@ import org.hibernate.persister.entity.EntityPersister;
/**
* Contract for managing transactional and concurrent access to cached naturalId
* data. The expected call sequences related to various operations are:<ul>
* <li><b>INSERTS</b> : {@link #insert} -> {@link #afterInsert}</li>
* <li><b>UPDATES</b> : {@link #lockItem} -> {@link #remove} -> {@link #update} -> {@link #afterUpdate}</li>
* <li><b>DELETES</b> : {@link #lockItem} -> {@link #remove} -> {@link #unlockItem}</li>
* <li><b>INSERTS</b> : {@link #insert} then {@link #afterInsert}</li>
* <li><b>UPDATES</b> : {@link #lockItem} then {@link #remove} then {@link #update} then {@link #afterUpdate}</li>
* <li><b>DELETES</b> : {@link #lockItem} then {@link #remove} then {@link #unlockItem}</li>
* <li><b>LOADS</b> : {@link #putFromLoad}</li>
* </ul>
* <p>
* Note the special case of <b>UPDATES</b> above. Because the cache key itself has changed here we need to remove the
* old entry as well
* <p>
* There is another usage pattern that is used to invalidate entries
* afterQuery performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
* There is another usage pattern that is used to invalidate entries after a query performing "bulk" HQL/SQL operations:
* {@link #lockRegion} then {@link #removeAll} then {@link #unlockRegion}
* <p>
* IMPORTANT : NaturalIds are not versioned so {@code null} will always be passed to the version parameter to:<ul>
* <li>{@link CachedDomainDataAccess#putFromLoad(SharedSessionContractImplementor, Object, Object, Object)}</li>

4
hibernate-core/src/main/java/org/hibernate/cache/spi/access/package-info.java vendored
View File

@ -32,8 +32,8 @@
* The only <i>synchronous</i> access strategy is
* {@linkplain org.hibernate.cache.spi.access.AccessType#TRANSACTIONAL transactional}.
* <p>
* Note that, for an <i>asynchronous</i> cache, cache invalidation must be a two-step process (lock->unlock or
* lock->afterUpdate), since this is the only way to guarantee consistency with the database for a non-transactional
* Note that, for an <i>asynchronous</i> cache, cache invalidation must be a two-step process (lock to unlock or
* lock to afterUpdate), since this is the only way to guarantee consistency with the database for a non-transactional
* cache implementation. For a <i>synchronous</i> cache, cache invalidation is a single step process (evict or update).
* Hence, these contracts ({@link org.hibernate.cache.spi.access.EntityDataAccess} and
* {@link org.hibernate.cache.spi.access.CollectionDataAccess}) define a three-step process to cater for both

4
hibernate-core/src/main/java/org/hibernate/cfg/SecondPass.java
View File

@ -7,7 +7,9 @@
package org.hibernate.cfg;
/**
* Second pass operation
* Hibernate builds its {@linkplain org.hibernate.mapping build-time model}
* incrementally, often delaying operations until other pieces of information
* are available. A second pass represents one of these delayed operations.
*
* @author Emmanuel Bernard
*

5
hibernate-core/src/main/java/org/hibernate/cfg/package-info.java
View File

@ -12,7 +12,10 @@
* configuration properties recognized by Hibernate.
* <li>{@link org.hibernate.cfg.Configuration} provides a simplified
* API for bootstrapping Hibernate, as an alternative to the more
* APIs extensive facilities defined under {@link org.hibernate.boot}.
* extensive facilities defined under {@link org.hibernate.boot}.
* </ul>
* <p>
* Note that all the real meat behind these APIs is defined in the package
* {@link org.hibernate.boot}.
*/
package org.hibernate.cfg;

3
hibernate-core/src/main/java/org/hibernate/dialect/Dialect.java
View File

@ -4124,7 +4124,8 @@ public abstract class Dialect implements ConversionContext {
}
/**
* Whether a predicate like `a > 0` can appear in an expression context e.g. a select item list.
* Whether a predicate like {@code a > 0} can appear in an expression context,
* for example, in a {@code select} list item.
*/
protected boolean supportsPredicateAsExpression() {
// Most databases seem to allow that

14
hibernate-core/src/main/java/org/hibernate/dialect/aggregate/package-info.java Normal file
View File

@ -0,0 +1,14 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for {@link org.hibernate.dialect.Dialect}-specific aggregate column types,
* including user-defined composite types, and JSON or XML types.
*
* @see org.hibernate.dialect.aggregate.AggregateSupport
*/
package org.hibernate.dialect.aggregate;

13
hibernate-core/src/main/java/org/hibernate/dialect/hint/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for query hints using {@link org.hibernate.dialect.Dialect}-specific syntax.
*
* @see org.hibernate.dialect.hint.QueryHintHandler
*/
package org.hibernate.dialect.hint;

13
hibernate-core/src/main/java/org/hibernate/dialect/identity/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for {@link org.hibernate.dialect.Dialect}-specific identity column handling.
*
* @see org.hibernate.dialect.identity.IdentityColumnSupport
*/
package org.hibernate.dialect.identity;

4
hibernate-core/src/main/java/org/hibernate/dialect/lock/package-info.java
View File

@ -6,6 +6,8 @@
*/
/**
* Support for Dialect-specific locking strategies
* Support for {@link org.hibernate.dialect.Dialect}-specific locking strategies.
*
* @see org.hibernate.dialect.lock.LockingStrategy
*/
package org.hibernate.dialect.lock;

2
hibernate-core/src/main/java/org/hibernate/dialect/package-info.java
View File

@ -22,5 +22,7 @@
* {@value org.hibernate.cfg.AvailableSettings#DIALECT}, but
* this is not usually necessary unless a program uses a custom
* implementation.
*
* @see org.hibernate.dialect.Dialect
*/
package org.hibernate.dialect;

4
hibernate-core/src/main/java/org/hibernate/dialect/pagination/package-info.java
View File

@ -6,6 +6,8 @@
*/
/**
* Support for Dialect-specific pagination strategies
* Support for {@link org.hibernate.dialect.Dialect}-specific pagination strategies.
*
* @see org.hibernate.dialect.pagination.LimitHandler
*/
package org.hibernate.dialect.pagination;

13
hibernate-core/src/main/java/org/hibernate/dialect/sequence/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for {@link org.hibernate.dialect.Dialect}-specific sequence handling.
*
* @see org.hibernate.dialect.sequence.SequenceSupport
*/
package org.hibernate.dialect.sequence;

5
hibernate-core/src/main/java/org/hibernate/dialect/temptable/TemporaryTableExporter.java
View File

@ -11,6 +11,11 @@ import java.util.function.Function;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
/**
* An exporter for temporary tables.
* <p>
* Unlike other {@linkplain org.hibernate.tool.schema.spi.Exporter DDL exporters},
* this exporter is called at runtime, instead of during schema management.
*
* @author Steve Ebersole
*/
public interface TemporaryTableExporter {

13
hibernate-core/src/main/java/org/hibernate/dialect/temptable/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for temporary tables.
*
* @see org.hibernate.dialect.temptable.TemporaryTableExporter
*/
package org.hibernate.dialect.temptable;

2
hibernate-core/src/main/java/org/hibernate/dialect/unique/SkipNullableUniqueDelegate.java
View File

@ -17,7 +17,7 @@ import org.hibernate.mapping.UniqueKey;
* uniqueness for nullable columns.
* <p>
* Needed because unique constraints on nullable columns in Sybase always consider null values to be non-unique.
* There is simply no way to create a unique constraint with the semantics we want on a nullable column in Sybase >:-(
* There is simply no way to create a unique constraint with the semantics we want on a nullable column in Sybase.
* <p>
* You might argue that this behavior is bad because if the programmer explicitly specifies an {@code @UniqueKey},
* then we should damn well respect their wishes. But the simple answer is that the user should have also specified

4
hibernate-core/src/main/java/org/hibernate/dialect/unique/package-info.java
View File

@ -6,6 +6,8 @@
*/
/**
* Support for Dialect-specific unique constraint definition
* Support for {@link org.hibernate.dialect.Dialect}-specific unique constraint definition.
*
* @see org.hibernate.dialect.unique.UniqueDelegate
*/
package org.hibernate.dialect.unique;

2
hibernate-core/src/main/java/org/hibernate/engine/FetchStyle.java
View File

@ -7,7 +7,7 @@
package org.hibernate.engine;
/**
* Enumeration of values describing <b>HOW</b> fetching should occur.
* Enumeration of values describing <em>how</em> fetching should occur.
*
* @author Steve Ebersole
* @see FetchTiming

2
hibernate-core/src/main/java/org/hibernate/engine/FetchTiming.java
View File

@ -7,7 +7,7 @@
package org.hibernate.engine;
/**
* Enumeration of values describing <b>WHEN</b> fetching should occur.
* Enumeration of values describing <em>when</em> fetching should occur.
*
* @author Steve Ebersole
* @see FetchStyle

11
hibernate-core/src/main/java/org/hibernate/engine/jdbc/batch/package-info.java Normal file
View File

@ -0,0 +1,11 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for JDBC statement batching.
*/
package org.hibernate.engine.jdbc.batch;

11
hibernate-core/src/main/java/org/hibernate/engine/jdbc/mutation/package-info.java
View File

@ -6,8 +6,15 @@
*/
/**
* Package defining support for performing mutation SQL (INSERT, UPDATE,
* DELETE) against an entity or collection
* Package defining support for executing mutation SQL statements produced
* by the {@linkplain org.hibernate.persister persister} for an entity or
* collection.
* <p>
* The {@link org.hibernate.engine.jdbc.mutation.MutationExecutor} is
* usually called by the various SQL insert, update, and delete
* {@linkplain org.hibernate.persister.entity.mutation.AbstractMutationCoordinator
* coordinators} defined in {@link org.hibernate.persister.entity.mutation}
* and {@link org.hibernate.persister.collection.mutation}.
*
* @author Steve Ebersole
*/

2
hibernate-core/src/main/java/org/hibernate/engine/package-info.java
View File

@ -6,7 +6,7 @@
*/
/**
* This package contains classes which are "shared" by other packages,
* This package contains classes which are "shared" by other subsystems,
* and implementations of some key algorithms.
*/
package org.hibernate.engine;

11
hibernate-core/src/main/java/org/hibernate/engine/query/package-info.java Normal file
View File

@ -0,0 +1,11 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for dealing with parameters of native queries.
*/
package org.hibernate.engine.query;

4
hibernate-core/src/main/java/org/hibernate/engine/query/spi/package-info.java
View File

@ -6,6 +6,8 @@
*/
/**
* Defines support for query plans and stored metadata about queries
* An SPI for dealing with parameters of native queries.
*
* @see org.hibernate.engine.query.spi.NativeQueryInterpreter
*/
package org.hibernate.engine.query.spi;

2
hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionContractImplementor.java
View File

@ -389,7 +389,7 @@ public interface SharedSessionContractImplementor
* Set the current {@link FlushMode} for this session.
* <p>
* The flush mode determines the points at which the session is flushed.
* <i>Flushing</i> is the process of synchronizing the underlying persistent
* <em>Flushing</em> is the process of synchronizing the underlying persistent
* store with persistable state held in memory.
* <p>
* For a logically "read-only" session, it's reasonable to set the session

12
hibernate-core/src/main/java/org/hibernate/engine/spi/package-info.java Normal file
View File

@ -0,0 +1,12 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* This package defines some central internal SPI abstractions
* used throughout the implementation of Hibernate.
*/
package org.hibernate.engine.spi;

3
hibernate-core/src/main/java/org/hibernate/engine/transaction/internal/SynchronizationRegistryImpl.java
View File

@ -18,7 +18,10 @@ import org.jboss.logging.Logger;
* Manages a registry of {@link Synchronization}s.
*
* @author Steve Ebersole
*
* @deprecated This appears to no longer be used
*/
@Deprecated(since = "6")
public class SynchronizationRegistryImpl implements SynchronizationRegistry {
private static final CoreMessageLogger LOG = Logger.getMessageLogger( CoreMessageLogger.class, SynchronizationRegistryImpl.class.getName() );

11
hibernate-core/src/main/java/org/hibernate/engine/transaction/jta/platform/package-info.java Normal file
View File

@ -0,0 +1,11 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Support for integrating with container-provided implementations of JTA.
*/
package org.hibernate.engine.transaction.jta.platform;

13
hibernate-core/src/main/java/org/hibernate/engine/transaction/jta/platform/spi/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* An SPI for integrating with container-provided implementations of JTA.
*
* @see org.hibernate.engine.transaction.jta.platform.spi.JtaPlatform
*/
package org.hibernate.engine.transaction.jta.platform.spi;

3
hibernate-core/src/main/java/org/hibernate/engine/transaction/spi/JoinStatus.java
View File

@ -11,7 +11,10 @@ package org.hibernate.engine.transaction.spi;
*
* @author Emmanuel Bernard
* @author Steve Ebersole
*
* @deprecated This is no longer used
*/
@Deprecated(since = "6", forRemoval = true)
public enum JoinStatus {
NOT_JOINED,
MARKED_FOR_JOINED,

3
hibernate-core/src/main/java/org/hibernate/engine/transaction/spi/SynchronizationRegistry.java
View File

@ -13,7 +13,10 @@ import jakarta.transaction.Synchronization;
* Manages a registry of {@link Synchronization}s.
*
* @author Steve Ebersole
*
* @deprecated This appears to no longer be used
*/
@Deprecated(since = "6")
public interface SynchronizationRegistry extends Serializable {
/**
* Register a user {@link Synchronization} callback for this transaction.

2
hibernate-core/src/main/java/org/hibernate/engine/transaction/spi/TransactionImplementor.java
View File

@ -11,6 +11,8 @@ import org.hibernate.Transaction;
import org.hibernate.resource.transaction.spi.TransactionStatus;
/**
* Defines the "internal contract" for an implementation of {@link Transaction}.
*
* @author Steve Ebersole
*/
public interface TransactionImplementor extends Transaction {

5
hibernate-core/src/main/java/org/hibernate/engine/transaction/spi/TransactionObserver.java
View File

@ -8,6 +8,11 @@ package org.hibernate.engine.transaction.spi;
/**
* Observer of internal transaction events.
* <p>
* A {@link TransactionObserver} must be registered with the {@link org.hibernate.resource.transaction.spi.TransactionCoordinator}
* by calling {@link org.hibernate.resource.transaction.spi.TransactionCoordinator#addObserver(TransactionObserver) addObserver()}.
*
* @apiNote It seems like this interface rightly belongs in {@link org.hibernate.resource.transaction.spi}.
*
* @author Steve Ebersole
*/

13
hibernate-core/src/main/java/org/hibernate/engine/transaction/spi/package-info.java Normal file
View File

@ -0,0 +1,13 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* An SPI abstracting the object which implements {@link org.hibernate.Transaction}.
*
* @see org.hibernate.engine.transaction.spi.TransactionImplementor
*/
package org.hibernate.engine.transaction.spi;

2
hibernate-core/src/main/java/org/hibernate/event/package-info.java
View File

@ -12,7 +12,7 @@
* represents a request by the session API for some work to be
* performed, and an event listener must respond to the event and
* do that work, usually by scheduling some sort of
* {@linkplain org.hibernate.action.spi.Executable action}.
* {@linkplain org.hibernate.action.spi.Executable action}.
*
* @see org.hibernate.action
*/

18
hibernate-core/src/main/java/org/hibernate/event/spi/package-info.java Normal file
View File

@ -0,0 +1,18 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
/**
* Defines the event types and event listener interfaces for
* events produced by the stateful {@link org.hibernate.Session}.
* <p>
* An {@linkplain org.hibernate.event.spi.AbstractEvent event}
* represents a request by the session API for some work to be
* performed, and an event listener must respond to the event and
* do that work, usually by scheduling some sort of
* {@linkplain org.hibernate.action.spi.Executable action}.
*/
package org.hibernate.event.spi;

5
hibernate-core/src/main/java/org/hibernate/id/AbstractUUIDGenerator.java
View File

@ -41,7 +41,7 @@ public abstract class AbstractUUIDGenerator implements IdentifierGenerator, Stan
/**
* Unique across JVMs on this machine (unless they load this class
* in the same quarter second - very unlikely)
* in the same quarter-second, which is very unlikely)
*/
protected int getJVM() {
return JVM;
@ -49,7 +49,8 @@ public abstract class AbstractUUIDGenerator implements IdentifierGenerator, Stan
/**
* Unique in a millisecond for this JVM instance (unless there
* are > Short.MAX_VALUE instances created in a millisecond)
* are more than {@value Short#MAX_VALUE} instances created in
* a millisecond)
*/
protected short getCount() {
synchronized(AbstractUUIDGenerator.class) {

7
hibernate-core/src/main/java/org/hibernate/id/uuid/Helper.java
View File

@ -11,8 +11,6 @@ import java.net.InetAddress;
import org.hibernate.internal.util.BytesHelper;
/**
* TODO : javadoc
*
* @author Steve Ebersole
*/
public final class Helper {
@ -81,8 +79,9 @@ public final class Helper {
private static short counter = (short) 0;
/**
* Unique in a millisecond for this JVM instance (unless there are > Short.MAX_VALUE instances created in a
* millisecond)
* Unique in a millisecond for this JVM instance
* (unless there are more than {@value Short#MAX_VALUE}
* instances created in a millisecond)
*/
public static short getCountShort() {
synchronized ( Helper.class ) {

12
hibernate-core/src/main/java/org/hibernate/integrator/package-info.java Normal file
View File

@ -0,0 +1,12 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
/**
* Support for extensions which integrate with Hibernate via the
* {@link org.hibernate.service.Service} mechanism.
*/
package org.hibernate.integrator;

2
hibernate-core/src/main/java/org/hibernate/integrator/spi/Integrator.java
View File

@ -13,7 +13,7 @@ import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.service.spi.SessionFactoryServiceRegistry;
/**
* Contract for stuff that integrates with Hibernate.
* Contract for extensions that integrate with Hibernate.
*
* @implNote {@link #integrate(Metadata, BootstrapContext, SessionFactoryImplementor)}
* is called during the process of {@linkplain SessionFactoryImplementor

14
hibernate-core/src/main/java/org/hibernate/integrator/spi/package-info.java Normal file
View File

@ -0,0 +1,14 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
/**
* An SPI for extensions which integrate with Hibernate via the
* {@link org.hibernate.service.Service} mechanism.
*
* @see org.hibernate.integrator.spi.Integrator
*/
package org.hibernate.integrator.spi;

2
hibernate-core/src/main/java/org/hibernate/jpa/HibernatePersistenceProvider.java
View File

@ -28,7 +28,7 @@ import org.hibernate.jpa.internal.util.PersistenceUtilHelper;
import org.jboss.logging.Logger;
/**
* The Hibernate {@link PersistenceProvider} implementation
* The best-ever implementation of a JPA {@link PersistenceProvider}.
*
* @author Gavin King
* @author Steve Ebersole

2
hibernate-core/src/main/java/org/hibernate/jpa/JpaComplianceViolation.java
View File

@ -7,7 +7,7 @@
package org.hibernate.jpa;
/**
* Contract for exceptions describing JPA compliance violations
* Marker interface for exceptions describing JPA compliance violations.
*
* @author Steve Ebersole
*/

8
hibernate-core/src/main/java/org/hibernate/jpa/LegacySpecHints.java
View File

@ -7,12 +7,12 @@
package org.hibernate.jpa;
/**
* Legacy form (`javax.persistence` namespace) of the hints explicitly
* defined by the Jakarta Persistence
* Legacy form (the {@code javax.persistence} namespace) of the hints
* explicitly defined by the Jakarta Persistence.
*
* @apiNote These are a temporary migration aids for migrating from
* Java Persistence (`javax.persistence` namespace) to Jakarta
* Persistence (`jakarta.persistence` namespace)
* Java Persistence ({@code javax.persistence} namespace)
* to Jakarta Persistence ({@code jakarta.persistence} namespace).
*
* @see SpecHints
*

18
hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/EntityManagerFactoryBuilder.java
View File

@ -13,15 +13,15 @@ import org.hibernate.boot.model.process.spi.ManagedResources;
import org.hibernate.boot.spi.MetadataImplementor;
/**
* Represents a 2-phase JPA bootstrap process for building a Hibernate EntityManagerFactory.
*
* The first phase is the process of instantiating this builder. During the first phase, loading of Class references
* is highly discouraged.
*
* The second phase is building the EntityManagerFactory instance via {@link #build}.
*
* If anything goes wrong during either phase and the bootstrap process needs to be aborted, {@link #cancel()} should
* be called.
* Represents a two-phase JPA bootstrap process for building a Hibernate {@link EntityManagerFactory}.
* <p>
* The first phase is the process of instantiating this builder. During the first phase, loading of
* Class references is highly discouraged.
* <p>
* The second phase is building the {@code EntityManagerFactory} instance via {@link #build}.
* <p>
* If anything goes wrong during either phase and the bootstrap process needs to be aborted,
* {@link #cancel()} should be called.
*
* @author Steve Ebersole
* @author Scott Marlow

Some files were not shown because too many files have changed in this diff Show More