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

HHH-11646 revert errant after -> afterQuery search and replace

This commit is contained in:
Richard Bradley 2017-04-19 15:32:23 +01:00 committed by Vlad Mihalcea
parent 1752da008e
commit 3a813dcbb4
354 changed files with 715 additions and 715 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0MessageLogger.java
View File

@ -22,7 +22,7 @@ import static org.jboss.logging.Logger.Level.WARN;
* The jboss-logging {@link MessageLogger} for the hibernate-c3p0 module. It reserves message ids ranging from
* 10001 to 15000 inclusively.
* <p/>
* New messages must be added afterQuery the last message defined to ensure message codes are unique.
* New messages must be added after the last message defined to ensure message codes are unique.
*/
@MessageLogger(projectCode = "HHH")
public interface C3P0MessageLogger extends ConnectionPoolingLogger {

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

@ -189,7 +189,7 @@ public interface BasicQueryContract {
* @see org.hibernate.engine.spi.PersistenceContext#isDefaultReadOnly()
*
* The read-only/modifiable setting has no impact on entities/proxies returned by the
* query that existed in the session beforeQuery the query was executed.
* query that existed in the session before the query was executed.
*
* @return {@code true} if the entities and proxies loaded by the query will be put
* in read-only mode; {@code false} otherwise (they will be modifiable)
@ -216,7 +216,7 @@ public interface BasicQueryContract {
* proxy has, regardless of the session's current setting.
*
* The read-only/modifiable setting has no impact on entities/proxies
* returned by the query that existed in the session beforeQuery the query was executed.
* returned by the query that existed in the session before the query was executed.
*
* @return {@code this}, for method chaining
*

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

@ -9,7 +9,7 @@ package org.hibernate;
/**
* Intended to be thrown from {@link org.hibernate.classic.Lifecycle} and {@link Interceptor} callbacks.
* <p/>
* IMPL NOTE : This is a legacy exception type from back in the day beforeQuery Hibernate moved to a untyped (runtime)
* IMPL NOTE : This is a legacy exception type from back in the day before Hibernate moved to a untyped (runtime)
* exception strategy.
*
* @author Gavin King

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

@ -18,7 +18,7 @@ import org.hibernate.internal.util.StringHelper;
*/
public enum ConnectionReleaseMode{
/**
* Indicates that JDBC connection should be aggressively released afterQuery each
* Indicates that JDBC connection should be aggressively released after each
* SQL statement is executed. In this mode, the application <em>must</em>
* explicitly close all iterators and scrollable results. This mode may
* only be used with a JTA datasource.
@ -26,7 +26,7 @@ public enum ConnectionReleaseMode{
AFTER_STATEMENT,
/**
* Indicates that JDBC connections should be released afterQuery each transaction
* Indicates that JDBC connections should be released after each transaction
* ends (works with both JTA-registered synch and HibernateTransaction API).
* This mode may not be used with an application server JTA datasource.
* <p/>

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

@ -403,7 +403,7 @@ public interface Criteria extends CriteriaSpecification {
* @see org.hibernate.engine.spi.PersistenceContext#isDefaultReadOnly()
*
* The read-only/modifiable setting has no impact on entities/proxies returned by the
* Criteria that existed in the session beforeQuery the Criteria was executed.
* Criteria that existed in the session before the Criteria was executed.
*
* @return true, entities and proxies loaded by the criteria will be put in read-only mode
* false, entities and proxies loaded by the criteria will be put in modifiable mode
@ -433,7 +433,7 @@ public interface Criteria extends CriteriaSpecification {
* proxy has, regardless of the session's current setting.
*
* The read-only/modifiable setting has no impact on entities/proxies
* returned by the criteria that existed in the session beforeQuery the criteria was executed.
* returned by the criteria that existed in the session before the criteria was executed.
*
* @param readOnly true, entities and proxies loaded by the criteria will be put in read-only mode
* false, entities and proxies loaded by the criteria will be put in modifiable mode

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

@ -47,7 +47,7 @@ public interface CustomEntityDirtinessStrategy {
/**
* Callback used by Hibernate to signal that the entity dirty flag should be cleared. Generally this
* happens afterQuery previous dirty changes were written to the database.
* happens after previous dirty changes were written to the database.
*
* @param entity The entity to reset
* @param persister The persister corresponding to the given entity

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

@ -64,7 +64,7 @@ public interface Filter {
/**
* Perform validation of the filter state. This is used to verify the
* state of the filter afterQuery its enablement and beforeQuery its use.
* state of the filter after its enablement and before its use.
*
* @throws HibernateException If the state is not currently valid.
*/

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

@ -34,14 +34,14 @@ public enum FlushMode {
COMMIT(5 ),
/**
* The {@link Session} is sometimes flushed beforeQuery query execution
* The {@link Session} is sometimes flushed before query execution
* in order to ensure that queries never return stale state. This
* is the default flush mode.
*/
AUTO(10 ),
/**
* The {@link Session} is flushed beforeQuery every query. This is
* The {@link Session} is flushed before every query. This is
* almost always unnecessary and inefficient.
*/
ALWAYS(20 );
@ -70,7 +70,7 @@ public enum FlushMode {
*
* @return true/false
*
* @deprecated Just use equality check against {@link #MANUAL}. Legacy from beforeQuery this was an enum
* @deprecated Just use equality check against {@link #MANUAL}. Legacy from before this was an enum
*/
@Deprecated
public static boolean isManualFlushMode(FlushMode mode) {

22
hibernate-core/src/main/java/org/hibernate/Interceptor.java
View File

@ -14,7 +14,7 @@ import org.hibernate.type.Type;
/**
* Allows user code to inspect and/or change property values.
*
* Inspection occurs beforeQuery property values are written and afterQuery they are read
* Inspection occurs before property values are written and after they are read
* from the database.
*
* There might be a single instance of <tt>Interceptor</tt> for a <tt>SessionFactory</tt>, or a new instance
@ -37,7 +37,7 @@ import org.hibernate.type.Type;
*/
public interface Interceptor {
/**
* Called just beforeQuery an object is initialized. The interceptor may change the <tt>state</tt>, which will
* Called just before an object is initialized. The interceptor may change the <tt>state</tt>, which will
* be propagated to the persistent object. Note that when this method is called, <tt>entity</tt> will be
* an empty uninitialized instance of the class.
* <p/>
@ -85,7 +85,7 @@ public interface Interceptor {
Type[] types) throws CallbackException;
/**
* Called beforeQuery an object is saved. The interceptor may modify the <tt>state</tt>, which will be used for
* Called before an object is saved. The interceptor may modify the <tt>state</tt>, which will be used for
* the SQL <tt>INSERT</tt> and propagated to the persistent object.
*
* @param entity The entity instance whose state is being inserted
@ -101,7 +101,7 @@ public interface Interceptor {
boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) throws CallbackException;
/**
* Called beforeQuery an object is deleted. It is not recommended that the interceptor modify the <tt>state</tt>.
* Called before an object is deleted. It is not recommended that the interceptor modify the <tt>state</tt>.
*
* @param entity The entity instance being deleted
* @param id The identifier of the entity
@ -114,7 +114,7 @@ public interface Interceptor {
void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) throws CallbackException;
/**
* Called beforeQuery a collection is (re)created.
* Called before a collection is (re)created.
*
* @param collection The collection instance.
* @param key The collection key value.
@ -124,7 +124,7 @@ public interface Interceptor {
void onCollectionRecreate(Object collection, Serializable key) throws CallbackException;
/**
* Called beforeQuery a collection is deleted.
* Called before a collection is deleted.
*
* @param collection The collection instance.
* @param key The collection key value.
@ -134,7 +134,7 @@ public interface Interceptor {
void onCollectionRemove(Object collection, Serializable key) throws CallbackException;
/**
* Called beforeQuery a collection is updated.
* Called before a collection is updated.
*
* @param collection The collection instance.
* @param key The collection key value.
@ -144,7 +144,7 @@ public interface Interceptor {
void onCollectionUpdate(Object collection, Serializable key) throws CallbackException;
/**
* Called beforeQuery a flush.
* Called before a flush.
*
* @param entities The entities to be flushed.
*
@ -153,7 +153,7 @@ public interface Interceptor {
void preFlush(Iterator entities) throws CallbackException;
/**
* Called afterQuery a flush that actually ends in execution of the SQL statements required to synchronize
* Called after a flush that actually ends in execution of the SQL statements required to synchronize
* in-memory state with the database.
*
* @param entities The entities that were flushed.
@ -250,14 +250,14 @@ public interface Interceptor {
void afterTransactionBegin(Transaction tx);
/**
* Called beforeQuery a transaction is committed (but not beforeQuery rollback).
* Called before a transaction is committed (but not before rollback).
*
* @param tx The Hibernate transaction facade object
*/
void beforeTransactionCompletion(Transaction tx);
/**
* Called afterQuery a transaction is committed or rolled back.
* Called after a transaction is committed or rolled back.
*
* @param tx The Hibernate transaction facade object
*/

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

@ -13,7 +13,7 @@ import org.jboss.logging.Logger;
/**
* Indicates an attempt to access not-yet-fetched data outside of a session context.
*
* For example, when an uninitialized proxy or collection is accessed afterQuery the session was closed.
* For example, when an uninitialized proxy or collection is accessed after the session was closed.
*
* @see Hibernate#initialize(java.lang.Object)
* @see Hibernate#isInitialized(java.lang.Object)

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

@ -245,7 +245,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* @see org.hibernate.engine.spi.PersistenceContext#isDefaultReadOnly()
*
* The read-only/modifiable setting has no impact on entities/proxies returned by the
* query that existed in the session beforeQuery the query was executed.
* query that existed in the session before the query was executed.
*
* @return {@code true} if the entities and proxies loaded by the query will be put
* in read-only mode; {@code false} otherwise (they will be modifiable)
@ -272,7 +272,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* proxy has, regardless of the session's current setting.
*
* The read-only/modifiable setting has no impact on entities/proxies
* returned by the query that existed in the session beforeQuery the query was executed.
* returned by the query that existed in the session before the query was executed.
*
* @return {@code this}, for method chaining
*

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

@ -75,13 +75,13 @@ public interface ScrollableResults extends AutoCloseable {
boolean first();
/**
* Go to a location just beforeQuery first result, This is the location of the cursor on a newly returned
* Go to a location just before first result, This is the location of the cursor on a newly returned
* scrollable result.
*/
void beforeFirst();
/**
* Go to a location just afterQuery the last result.
* Go to a location just after the last result.
*/
void afterLast();

12
hibernate-core/src/main/java/org/hibernate/Session.java
View File

@ -73,7 +73,7 @@ import org.hibernate.stat.SessionStatistics;
* <br>
* If the <tt>Session</tt> throws an exception, the transaction must be rolled back
* and the session discarded. The internal state of the <tt>Session</tt> might not
* be consistent with the database afterQuery the exception occurs.
* be consistent with the database after the exception occurs.
*
* @see SessionFactory
*
@ -90,7 +90,7 @@ public interface Session extends SharedSessionContract, EntityManager, Hibernate
/**
* Force this session to flush. Must be called at the end of a
* unit of work, beforeQuery committing the transaction and closing the
* unit of work, before committing the transaction and closing the
* session (depending on {@link #setFlushMode(FlushMode)},
* {@link Transaction#commit()} calls this method).
* <p/>
@ -601,8 +601,8 @@ public interface Session extends SharedSessionContract, EntityManager, Hibernate
* For example
* <ul>
* <li>where a database trigger alters the object state upon insert or update
* <li>afterQuery executing direct SQL (eg. a mass update) in the same session
* <li>afterQuery inserting a <tt>Blob</tt> or <tt>Clob</tt>
* <li>after executing direct SQL (eg. a mass update) in the same session
* <li>after inserting a <tt>Blob</tt> or <tt>Clob</tt>
* </ul>
*
* @param object a persistent or detached instance
@ -616,8 +616,8 @@ public interface Session extends SharedSessionContract, EntityManager, Hibernate
* For example
* <ul>
* <li>where a database trigger alters the object state upon insert or update
* <li>afterQuery executing direct SQL (eg. a mass update) in the same session
* <li>afterQuery inserting a <tt>Blob</tt> or <tt>Clob</tt>
* <li>after executing direct SQL (eg. a mass update) in the same session
* <li>after inserting a <tt>Blob</tt> or <tt>Clob</tt>
* </ul>
*
* @param entityName a persistent class

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

@ -129,7 +129,7 @@ public interface SessionBuilder<T extends SessionBuilder> {
T flushMode(FlushMode flushMode);
/**
* Should the session be automatically flushed during the "beforeQuery completion" phase of transaction handling.
* Should the session be automatically flushed during the "before completion" phase of transaction handling.
*
* @param flushBeforeCompletion Should the session be automatically flushed
*

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

@ -115,7 +115,7 @@ public interface SessionFactory extends EntityManagerFactory, HibernateEntityMan
* connection pools, etc).
* <p/>
* It is the responsibility of the application to ensure that there are no
* open {@link Session sessions} beforeQuery calling this method as the impact
* open {@link Session sessions} before calling this method as the impact
* on those {@link Session sessions} is indeterminate.
* <p/>
* No-ops if already {@link #isClosed closed}.

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

@ -50,7 +50,7 @@ public interface Transaction extends EntityTransaction {
/**
* Set the transaction timeout for any transaction started by a subsequent call to {@link #begin} on this instance.
*
* @param seconds The number of seconds beforeQuery a timeout.
* @param seconds The number of seconds before a timeout.
*/
void setTimeout(int seconds);

8
hibernate-core/src/main/java/org/hibernate/action/internal/AbstractEntityInsertAction.java
View File

@ -161,10 +161,10 @@ public abstract class AbstractEntityInsertAction extends EntityAction {
}
/**
* Handle sending notifications needed for natural-id beforeQuery saving
* Handle sending notifications needed for natural-id before saving
*/
protected void handleNaturalIdPreSaveNotifications() {
// beforeQuery save, we need to add a local (transactional) natural id cross-reference
// before save, we need to add a local (transactional) natural id cross-reference
getSession().getPersistenceContext().getNaturalIdHelper().manageLocalNaturalIdCrossReference(
getPersister(),
getId(),
@ -175,7 +175,7 @@ public abstract class AbstractEntityInsertAction extends EntityAction {
}
/**
* Handle sending notifications needed for natural-id afterQuery saving
* Handle sending notifications needed for natural-id after saving
*
* @param generatedId The generated entity identifier
*/
@ -190,7 +190,7 @@ public abstract class AbstractEntityInsertAction extends EntityAction {
CachedNaturalIdValueSource.INSERT
);
}
// afterQuery save, we need to manage the shared cache entries
// after save, we need to manage the shared cache entries
getSession().getPersistenceContext().getNaturalIdHelper().manageSharedNaturalIdCrossReference(
getPersister(),
generatedId,

4
hibernate-core/src/main/java/org/hibernate/action/internal/CollectionAction.java
View File

@ -54,7 +54,7 @@ public abstract class CollectionAction implements Executable, Serializable, Comp
}
/**
* Reconnect to session afterQuery deserialization...
* Reconnect to session after deserialization...
*
* @param session The session being deserialized
*/
@ -72,7 +72,7 @@ public abstract class CollectionAction implements Executable, Serializable, Comp
@Override
public final void beforeExecutions() throws CacheException {
// we need to obtain the lock beforeQuery any actions are executed, since this may be an inverse="true"
// we need to obtain the lock before any actions are executed, since this may be an inverse="true"
// bidirectional association and it is one of the earlier entity actions which actually updates
// the database (this action is responsible for second-level cache invalidation only)
if ( persister.hasCache() ) {

2
hibernate-core/src/main/java/org/hibernate/action/internal/CollectionRemoveAction.java
View File

@ -51,7 +51,7 @@ public final class CollectionRemoveAction extends CollectionAction {
throw new AssertionFailure("collection == null");
}
this.emptySnapshot = emptySnapshot;
// the loaded owner will be set to null afterQuery the collection is removed,
// the loaded owner will be set to null after the collection is removed,
// so capture its value as the affected owner so it is accessible to
// both pre- and post- events
this.affectedOwner = session.getPersistenceContext().getLoadedCollectionOwnerOrNull( collection );

2
hibernate-core/src/main/java/org/hibernate/action/internal/EntityAction.java
View File

@ -156,7 +156,7 @@ public abstract class EntityAction
}
/**
* Reconnect to session afterQuery deserialization...
* Reconnect to session after deserialization...
*
* @param session The session being deserialized
*/

2
hibernate-core/src/main/java/org/hibernate/action/internal/EntityDeleteAction.java
View File

@ -60,7 +60,7 @@ public class EntityDeleteAction extends EntityAction {
this.isCascadeDeleteEnabled = isCascadeDeleteEnabled;
this.state = state;
// beforeQuery remove we need to remove the local (transactional) natural id cross-reference
// before remove we need to remove the local (transactional) natural id cross-reference
naturalIdValues = session.getPersistenceContext().getNaturalIdHelper().removeLocalNaturalIdCrossReference(
getPersister(),
getId(),

2
hibernate-core/src/main/java/org/hibernate/action/internal/EntityIdentityInsertAction.java
View File

@ -91,7 +91,7 @@ public final class EntityIdentityInsertAction extends AbstractEntityInsertAction
}
//TODO: this bit actually has to be called afterQuery all cascades!
//TODO: this bit actually has to be called after all cascades!
// but since identity insert is called *synchronously*,
// instead of asynchronously as other actions, it isn't
/*if ( persister.hasCache() && !persister.isCacheInvalidationRequired() ) {

4
hibernate-core/src/main/java/org/hibernate/action/internal/EntityIncrementVersionProcess.java
View File

@ -13,7 +13,7 @@ import org.hibernate.persister.entity.EntityPersister;
/**
* A BeforeTransactionCompletionProcess impl to verify and increment an entity version as party
* of beforeQuery-transaction-completion processing
* of before-transaction-completion processing
*
* @author Scott Marlow
*/
@ -33,7 +33,7 @@ public class EntityIncrementVersionProcess implements BeforeTransactionCompletio
}
/**
* Perform whatever processing is encapsulated here beforeQuery completion of the transaction.
* Perform whatever processing is encapsulated here before completion of the transaction.
*
* @param session The session on which the transaction is preparing to complete.
*/

2
hibernate-core/src/main/java/org/hibernate/action/internal/EntityVerifyVersionProcess.java
View File

@ -15,7 +15,7 @@ import org.hibernate.pretty.MessageHelper;
/**
* A BeforeTransactionCompletionProcess impl to verify an entity version as part of
* beforeQuery-transaction-completion processing
* before-transaction-completion processing
*
* @author Scott Marlow
*/

10
hibernate-core/src/main/java/org/hibernate/action/internal/UnresolvedEntityInsertActions.java
View File

@ -37,7 +37,7 @@ import org.jboss.logging.Logger;
* an unsaved transient entity, and the foreign key points to that
* unsaved transient entity.
*
* These references must be resolved beforeQuery an insert action can be
* These references must be resolved before an insert action can be
* executed.
*
* @author Gail Badner
@ -91,7 +91,7 @@ public class UnresolvedEntityInsertActions {
* Throws {@link org.hibernate.PropertyValueException} if there are any unresolved
* entity insert actions that depend on non-nullable associations with
* a transient entity. This method should be called on completion of
* an operation (afterQuery all cascades are completed) that saves an entity.
* an operation (after all cascades are completed) that saves an entity.
*
* @throws org.hibernate.PropertyValueException if there are any unresolved entity
* insert actions; {@link org.hibernate.PropertyValueException#getEntityName()}
@ -117,7 +117,7 @@ public class UnresolvedEntityInsertActions {
nonNullableTransientDependencies.getNonNullableTransientPropertyPaths( firstTransientDependency ).iterator().next();
throw new TransientPropertyValueException(
"Not-null property references a transient value - transient instance must be saved beforeQuery current operation",
"Not-null property references a transient value - transient instance must be saved before current operation",
firstDependentAction.getSession().guessEntityName( firstTransientDependency ),
firstDependentAction.getEntityName(),
firstPropertyPath
@ -203,7 +203,7 @@ public class UnresolvedEntityInsertActions {
final Set<AbstractEntityInsertAction> resolvedActions = new IdentitySet( );
if ( traceEnabled ) {
LOG.tracev(
"Unresolved inserts beforeQuery resolving [{0}]: [{1}]",
"Unresolved inserts before resolving [{0}]: [{1}]",
MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() ),
toString()
);
@ -233,7 +233,7 @@ public class UnresolvedEntityInsertActions {
}
if ( traceEnabled ) {
LOG.tracev(
"Unresolved inserts afterQuery resolving [{0}]: [{1}]",
"Unresolved inserts after resolving [{0}]: [{1}]",
MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() ),
toString()
);

4
hibernate-core/src/main/java/org/hibernate/action/spi/AfterTransactionCompletionProcess.java
View File

@ -9,13 +9,13 @@ package org.hibernate.action.spi;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
/**
* Contract representing some process that needs to occur during afterQuery transaction completion.
* Contract representing some process that needs to occur during after transaction completion.
*
* @author Steve Ebersole
*/
public interface AfterTransactionCompletionProcess {
/**
* Perform whatever processing is encapsulated here afterQuery completion of the transaction.
* Perform whatever processing is encapsulated here after completion of the transaction.
*
* @param success Did the transaction complete successfully? True means it did.
* @param session The session on which the transaction is completing.

4
hibernate-core/src/main/java/org/hibernate/action/spi/BeforeTransactionCompletionProcess.java
View File

@ -9,13 +9,13 @@ package org.hibernate.action.spi;
import org.hibernate.engine.spi.SessionImplementor;
/**
* Contract representing some process that needs to occur during beforeQuery transaction completion.
* Contract representing some process that needs to occur during before transaction completion.
*
* @author Steve Ebersole
*/
public interface BeforeTransactionCompletionProcess {
/**
* Perform whatever processing is encapsulated here beforeQuery completion of the transaction.
* Perform whatever processing is encapsulated here before completion of the transaction.
*
* @param session The session on which the transaction is preparing to complete.
*/

16
hibernate-core/src/main/java/org/hibernate/action/spi/Executable.java
View File

@ -27,7 +27,7 @@ public interface Executable {
Serializable[] getPropertySpaces();
/**
* Called beforeQuery executing any actions. Gives actions a chance to perform any preparation.
* Called before executing any actions. Gives actions a chance to perform any preparation.
*
* @throws HibernateException Indicates a problem during preparation.
*/
@ -41,23 +41,23 @@ public interface Executable {
void execute() throws HibernateException;
/**
* Get the afterQuery-transaction-completion process, if any, for this action.
* Get the after-transaction-completion process, if any, for this action.
*
* @return The afterQuery-transaction-completion process, or null if we have no
* afterQuery-transaction-completion process
* @return The after-transaction-completion process, or null if we have no
* after-transaction-completion process
*/
AfterTransactionCompletionProcess getAfterTransactionCompletionProcess();
/**
* Get the beforeQuery-transaction-completion process, if any, for this action.
* Get the before-transaction-completion process, if any, for this action.
*
* @return The beforeQuery-transaction-completion process, or null if we have no
* beforeQuery-transaction-completion process
* @return The before-transaction-completion process, or null if we have no
* before-transaction-completion process
*/
BeforeTransactionCompletionProcess getBeforeTransactionCompletionProcess();
/**
* Reconnect to session afterQuery deserialization
* Reconnect to session after deserialization
*
* @param session The session being deserialized
*/

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

@ -16,7 +16,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
* For updating, should this entity use dynamic sql generation where only changed columns get referenced in the
* prepared sql statement?
* <p/>
* Note, for re-attachment of detached entities this is not possible without select-beforeQuery-update being enabled.
* Note, for re-attachment of detached entities this is not possible without select-before-update being enabled.
*
* @author Steve Ebersole
*

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

@ -43,7 +43,7 @@ public @interface Entity {
@Deprecated
boolean dynamicUpdate() default false;
/**
* Do a select to retrieve the entity beforeQuery any potential update.
* Do a select to retrieve the entity before any potential update.
* @deprecated Use {@link SelectBeforeUpdate} instead
*/
@Deprecated

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

@ -26,7 +26,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
@Repeatable(NamedNativeQueries.class)
public @interface NamedNativeQuery {
/**
* The name. It is a named query afterQuery all :)
* The name. It is a named query after all :)
*/
String name();

4
hibernate-core/src/main/java/org/hibernate/annotations/SelectBeforeUpdate.java
View File

@ -23,8 +23,8 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
public @interface SelectBeforeUpdate {
/**
* {@code true} (which is the default when this annotation is present) indicates that
* {@code select-beforeQuery-update} processing should occur. {@code false} indicates
* {@code select-beforeQuery-update} processing should not occur.
* {@code select-before-update} processing should occur. {@code false} indicates
* {@code select-before-update} processing should not occur.
*/
boolean value() default true;
}

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

@ -699,7 +699,7 @@ public interface SessionFactoryBuilder {
/**
* Should resources held by {@link javax.persistence.EntityManager} instance be released immediately on close?
* <p/>
* The other option is to release them as part of an afterQuery-transaction callback.
* The other option is to release them as part of an after-transaction callback.
*
*/
SessionFactoryBuilder enableReleaseResourcesOnCloseEnabled(boolean enable);

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

@ -1567,7 +1567,7 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector
/**
* Ugh! But we need this done beforeQuery we ask Envers to produce its entities.
* Ugh! But we need this done before we ask Envers to produce its entities.
*/
public void processSecondPasses(MetadataBuildingContext buildingContext) {
inSecondPass = true;

2
hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/stax/BufferedXMLEventReader.java
View File

@ -162,7 +162,7 @@ public class BufferedXMLEventReader extends BaseXMLEventReader {
}
/**
* If reading from the buffer afterQuery a {@link #reset()} call an {@link IllegalStateException} will be thrown.
* If reading from the buffer after a {@link #reset()} call an {@link IllegalStateException} will be thrown.
*/
@Override
public void remove() {

2
hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/stax/FilteringXMLEventReader.java
View File

@ -19,7 +19,7 @@ import javax.xml.stream.events.XMLEvent;
/**
* Base class for {@link javax.xml.stream.XMLEventReader}s that want to modify or remove events from the reader stream.
* If a {@link javax.xml.stream.events.StartElement} event is removed the subclass's {@link #filterEvent(javax.xml.stream.events.XMLEvent, boolean)} will
* not see any events until afterQuery the matching {@link javax.xml.stream.events.EndElement} event.
* not see any events until after the matching {@link javax.xml.stream.events.EndElement} event.
*
* Note, copied from the uPortal project by permission of author. See
* https://github.com/Jasig/uPortal/blob/master/uportal-war/src/main/java/org/jasig/portal/xml/stream/FilteringXMLEventReader.java

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

@ -135,7 +135,7 @@ public class MetadataBuildingProcess {
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Set up the processors and start binding
// NOTE : this becomes even more simplified afterQuery we move purely
// NOTE : this becomes even more simplified after we move purely
// to unified model
final MetadataSourceProcessor processor = new MetadataSourceProcessor() {

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

@ -27,15 +27,15 @@ public interface AuxiliaryDatabaseObject extends Exportable, Serializable {
public boolean appliesToDialect(Dialect dialect);
/**
* Defines a simple precedence. Should creation of this auxiliary object happen beforeQuery creation of
* tables? If {@code true}, the auxiliary object creation will happen afterQuery any explicit schema creations
* but beforeQuery table/sequence creations; if {@code false}, the auxiliary object creation will happen afterQuery
* explicit schema creations and afterQuery table/sequence creations.
* 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.
*
* This precedence is automatically inverted for dropping.
*
* @return {@code true} indicates this object should be created beforeQuery tables; {@code false} indicates
* it should be created afterQuery.
* @return {@code true} indicates this object should be created before tables; {@code false} indicates
* it should be created after.
*/
public boolean beforeTablesOnCreation();

2
hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/EntityHierarchyBuilder.java
View File

@ -52,7 +52,7 @@ public class EntityHierarchyBuilder {
}
/**
* To be called afterQuery all mapping documents have been processed (via {@link #indexMappingDocument})
* To be called after all mapping documents have been processed (via {@link #indexMappingDocument})
*
* @return The built hierarchies
*

2
hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/NamedQueryBinder.java
View File

@ -156,7 +156,7 @@ public class NamedQueryBinder {
// returns it defines. But binding for those entities may have not been
// completed yet. For "normal" ResultSet mappings, this is already handled by
// the fact that MetadataSourceProcessor#processResultSetMappings() is called
// afterQuery all entity hierarchies have been processed. However, here we are in
// after all entity hierarchies have been processed. However, here we are in
// the middle of processing named-queries (either top-level or entity-level)
// and have no guarantee that any entity bindings we may need here are bound.
// So we add the second-pass to bind the implicit resultSet mapping.

2
hibernate-core/src/main/java/org/hibernate/boot/registry/selector/internal/StrategySelectorImpl.java
View File

@ -101,7 +101,7 @@ public class StrategySelectorImpl implements StrategySelector {
}
}
// try tp clean up afterQuery ourselves...
// try to clean up after ourselves...
if ( namedStrategyImplementorMap.isEmpty() ) {
namedStrategyImplementorByStrategyMap.remove( strategy );
}

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

@ -11,7 +11,7 @@ import org.hibernate.boot.registry.StandardServiceRegistry;
/**
* Contract for contributing to the initialization of MetadataBuilder. Called
* immediately afterQuery any configuration settings have been applied from
* 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}

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

@ -11,8 +11,8 @@ import org.jboss.jandex.IndexView;
/**
* Contract for contributing to Metadata (InFlightMetadataCollector).
*
* This hook occurs just afterQuery all processing of all {@link org.hibernate.boot.MetadataSources},
* and just beforeQuery {@link org.hibernate.boot.spi.AdditionalJaxbMappingProducer}.
* This hook occurs just after all processing of all {@link org.hibernate.boot.MetadataSources},
* and just before {@link org.hibernate.boot.spi.AdditionalJaxbMappingProducer}.
*
* @author Steve Ebersole
*

4
hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/tracker/SortedFieldTracker.java
View File

@ -38,7 +38,7 @@ public final class SortedFieldTracker implements DirtyTracker {
insert = middle;
}
else if( compare < 0 ) {
// top half: lower bound in (middle + 1) and insert position afterQuery middle
// top half: lower bound in (middle + 1) and insert position after middle
insert = low = middle + 1;
}
else {
@ -62,7 +62,7 @@ public final class SortedFieldTracker implements DirtyTracker {
high = middle - 1;
}
else if( compare < 0 ) {
// top half: lower bound in (middle + 1) and insert position afterQuery middle
// top half: lower bound in (middle + 1) and insert position after middle
low = middle + 1;
}
else {

4
hibernate-core/src/main/java/org/hibernate/bytecode/spi/ByteCodeHelper.java
View File

@ -51,7 +51,7 @@ public class ByteCodeHelper {
final byte[] temp = new byte[ classBytes.length + buffer.length ];
// copy any previously read bytes into the temp array
System.arraycopy( classBytes, 0, temp, 0, classBytes.length );
// copy the just read bytes into the temp array (afterQuery the previously read)
// copy the just read bytes into the temp array (after the previously read)
System.arraycopy( buffer, 0, temp, classBytes.length, buffer.length );
classBytes = temp;
// read the next set of bytes into buffer
@ -61,7 +61,7 @@ public class ByteCodeHelper {
final byte[] temp = new byte[ classBytes.length + r ];
// copy any previously read bytes into the temp array
System.arraycopy( classBytes, 0, temp, 0, classBytes.length );
// copy the just read bytes into the temp array (afterQuery the previously read)
// copy the just read bytes into the temp array (after the previously read)
System.arraycopy( buffer, 0, temp, classBytes.length, r );
classBytes = temp;
}

2
hibernate-core/src/main/java/org/hibernate/bytecode/spi/ClassTransformer.java
View File

@ -14,7 +14,7 @@ import java.security.ProtectionDomain;
* to the PersistenceUnitInfo.addTransformer method.
* The supplied transformer instance will get called to transform
* entity class files when they are loaded and redefined. The transformation
* occurs beforeQuery the class is defined by the JVM
* occurs before the class is defined by the JVM
*
* @author <a href="mailto:bill@jboss.org">Bill Burke</a>
* @author Emmanuel Bernard

2
hibernate-core/src/main/java/org/hibernate/cache/spi/QueryKey.java vendored
View File

@ -55,7 +55,7 @@ public class QueryKey implements Serializable {
* @param queryParameters The query parameters
* @param filterKeys The keys of any enabled filters.
* @param session The current session.
* @param customTransformer The result transformer; should be null if data is not transformed beforeQuery being cached.
* @param customTransformer The result transformer; should be null if data is not transformed before being cached.
*
* @return The generate query cache key.
*/

2
hibernate-core/src/main/java/org/hibernate/cache/spi/access/CollectionRegionAccessStrategy.java vendored
View File

@ -17,7 +17,7 @@ import org.hibernate.persister.collection.CollectionPersister;
* {@link #lockItem} -> {@link #remove} -> {@link #unlockItem}
* <p/>
* There is another usage pattern that is used to invalidate entries
* afterQuery performing "bulk" HQL/SQL operations:
* after performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
*
* @author Gavin King

10
hibernate-core/src/main/java/org/hibernate/cache/spi/access/EntityRegionAccessStrategy.java vendored
View File

@ -22,7 +22,7 @@ import org.hibernate.persister.entity.EntityPersister;
* </ul>
* <p/>
* There is another usage pattern that is used to invalidate entries
* afterQuery performing "bulk" HQL/SQL operations:
* after performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
*
* @author Gavin King
@ -61,7 +61,7 @@ public interface EntityRegionAccessStrategy extends RegionAccessStrategy {
EntityRegion getRegion();
/**
* Called afterQuery an item has been inserted (beforeQuery the transaction completes),
* Called after an item has been inserted (before the transaction completes),
* instead of calling evict().
* This method is used by "synchronous" concurrency strategies.
*
@ -75,7 +75,7 @@ public interface EntityRegionAccessStrategy extends RegionAccessStrategy {
boolean insert(SharedSessionContractImplementor session, Object key, Object value, Object version) throws CacheException;
/**
* Called afterQuery an item has been inserted (afterQuery the transaction completes),
* Called after an item has been inserted (after the transaction completes),
* instead of calling release().
* This method is used by "asynchronous" concurrency strategies.
*
@ -89,7 +89,7 @@ public interface EntityRegionAccessStrategy extends RegionAccessStrategy {
boolean afterInsert(SharedSessionContractImplementor session, Object key, Object value, Object version) throws CacheException;
/**
* Called afterQuery an item has been updated (beforeQuery the transaction completes),
* Called after an item has been updated (before the transaction completes),
* instead of calling evict(). This method is used by "synchronous" concurrency
* strategies.
*
@ -105,7 +105,7 @@ public interface EntityRegionAccessStrategy extends RegionAccessStrategy {
boolean update(SharedSessionContractImplementor session, Object key, Object value, Object currentVersion, Object previousVersion) throws CacheException;
/**
* Called afterQuery an item has been updated (afterQuery the transaction completes),
* Called after an item has been updated (after the transaction completes),
* instead of calling release(). This method is used by "asynchronous"
* concurrency strategies.
*

10
hibernate-core/src/main/java/org/hibernate/cache/spi/access/NaturalIdRegionAccessStrategy.java vendored
View File

@ -23,7 +23,7 @@ import org.hibernate.persister.entity.EntityPersister;
* old entry as well as
* <p/>
* There is another usage pattern that is used to invalidate entries
* afterQuery performing "bulk" HQL/SQL operations:
* after performing "bulk" HQL/SQL operations:
* {@link #lockRegion} -> {@link #removeAll} -> {@link #unlockRegion}
* <p/>
* IMPORTANT : NaturalIds are not versioned so {@code null} will always be passed to the version parameter to:<ul>
@ -67,7 +67,7 @@ public interface NaturalIdRegionAccessStrategy extends RegionAccessStrategy {
NaturalIdRegion getRegion();
/**
* Called afterQuery an item has been inserted (beforeQuery the transaction completes),
* Called after an item has been inserted (before the transaction completes),
* instead of calling evict().
* This method is used by "synchronous" concurrency strategies.
*
@ -80,7 +80,7 @@ public interface NaturalIdRegionAccessStrategy extends RegionAccessStrategy {
boolean insert(SharedSessionContractImplementor session, Object key, Object value) throws CacheException;
/**
* Called afterQuery an item has been inserted (afterQuery the transaction completes),
* Called after an item has been inserted (after the transaction completes),
* instead of calling release().
* This method is used by "asynchronous" concurrency strategies.
*
@ -93,7 +93,7 @@ public interface NaturalIdRegionAccessStrategy extends RegionAccessStrategy {
boolean afterInsert(SharedSessionContractImplementor session, Object key, Object value) throws CacheException;
/**
* Called afterQuery an item has been updated (beforeQuery the transaction completes),
* Called after an item has been updated (before the transaction completes),
* instead of calling evict(). This method is used by "synchronous" concurrency
* strategies.
*
@ -106,7 +106,7 @@ public interface NaturalIdRegionAccessStrategy extends RegionAccessStrategy {
boolean update(SharedSessionContractImplementor session, Object key, Object value) throws CacheException;
/**
* Called afterQuery an item has been updated (afterQuery the transaction completes),
* Called after an item has been updated (after the transaction completes),
* instead of calling release(). This method is used by "asynchronous"
* concurrency strategies.
*

10
hibernate-core/src/main/java/org/hibernate/cache/spi/access/RegionAccessStrategy.java vendored
View File

@ -30,7 +30,7 @@ public interface RegionAccessStrategy {
Object get(SharedSessionContractImplementor session, Object key, long txTimestamp) throws CacheException;
/**
* Attempt to cache an object, afterQuery loading from the database.
* Attempt to cache an object, after loading from the database.
*
* @param session Current session.
* @param key The item key
@ -48,7 +48,7 @@ public interface RegionAccessStrategy {
Object version) throws CacheException;
/**
* Attempt to cache an object, afterQuery loading from the database, explicitly
* Attempt to cache an object, after loading from the database, explicitly
* specifying the minimalPut behavior.
*
* @param session Current session.
@ -94,7 +94,7 @@ public interface RegionAccessStrategy {
/**
* Called when we have finished the attempted update/delete (which may or
* may not have been successful), afterQuery transaction completion. This method
* may not have been successful), after transaction completion. This method
* is used by "asynchronous" concurrency strategies.
*
* @param session Current session.
@ -105,7 +105,7 @@ public interface RegionAccessStrategy {
void unlockItem(SharedSessionContractImplementor session, Object key, SoftLock lock) throws CacheException;
/**
* Called afterQuery we have finished the attempted invalidation of the entire
* Called after we have finished the attempted invalidation of the entire
* region
*
* @param lock The lock previously obtained from {@link #lockRegion}
@ -114,7 +114,7 @@ public interface RegionAccessStrategy {
void unlockRegion(SoftLock lock) throws CacheException;
/**
* Called afterQuery an item has become stale (beforeQuery the transaction completes).
* Called after an item has become stale (before the transaction completes).
* This method is used by "synchronous" concurrency strategies.
*
* @param session

2
hibernate-core/src/main/java/org/hibernate/cache/spi/entry/StandardCacheEntryImpl.java vendored
View File

@ -144,7 +144,7 @@ public class StandardCacheEntryImpl implements CacheEntry {
session, instance
);
//persister.setIdentifier(instance, id); //beforeQuery calling interceptor, for consistency with normal load
//persister.setIdentifier(instance, id); //before calling interceptor, for consistency with normal load
//TODO: reuse the PreLoadEvent
final PreLoadEvent preLoadEvent = new PreLoadEvent( session )

8
hibernate-core/src/main/java/org/hibernate/cfg/AnnotationBinder.java
View File

@ -474,7 +474,7 @@ public final class AnnotationBinder {
}
/**
* Bind a class having JSR175 annotations. Subclasses <b>have to</b> be bound afterQuery its parent class.
* Bind a class having JSR175 annotations. Subclasses <b>have to</b> be bound after its parent class.
*
* @param clazzToProcess entity to bind as {@code XClass} instance
* @param inheritanceStatePerClass Meta data about the inheritance relationships for all mapped classes
@ -1277,7 +1277,7 @@ public final class AnnotationBinder {
//check if superclass is not a potential persistent class
if ( inheritanceState.hasParents() ) {
throw new AssertionFailure(
"Subclass has to be binded afterQuery it's mother class: "
"Subclass has to be binded after it's mother class: "
+ superEntityState.getClazz().getName()
);
}
@ -1534,7 +1534,7 @@ public final class AnnotationBinder {
/*
* put element annotated by @Id in front
* since it has to be parsed beforeQuery any association by Hibernate
* since it has to be parsed before any association by Hibernate
*/
final XAnnotatedElement element = propertyAnnotatedElement.getProperty();
if ( element.isAnnotationPresent( Id.class ) || element.isAnnotationPresent( EmbeddedId.class ) ) {
@ -2299,7 +2299,7 @@ public final class AnnotationBinder {
}
}
//init index
//process indexes afterQuery everything: in second pass, many to one has to be done beforeQuery indexes
//process indexes after everything: in second pass, many to one has to be done before indexes
Index index = property.getAnnotation( Index.class );
if ( index != null ) {
if ( joinColumns != null ) {

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

@ -912,7 +912,7 @@ public interface AvailableSettings {
String C3P0_ACQUIRE_INCREMENT = "hibernate.c3p0.acquire_increment";
/**
* Idle time beforeQuery a C3P0 pooled connection is validated
* Idle time before a C3P0 pooled connection is validated
*/
String C3P0_IDLE_TEST_PERIOD = "hibernate.c3p0.idle_test_period";
@ -1292,7 +1292,7 @@ public interface AvailableSettings {
/**
* Comma-separated names of the optional files containing SQL DML statements executed
* during the SessionFactory creation.
* File order matters, the statements of a give file are executed beforeQuery the statements of the
* File order matters, the statements of a give file are executed before the statements of the
* following files.
* <p/>
* These statements are only executed if the schema is created ie if <tt>hibernate.hbm2ddl.auto</tt>

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

@ -185,7 +185,7 @@ class ColumnsBuilder {
}
Ejb3JoinColumn[] buildExplicitJoinColumns(XProperty property, PropertyData inferredData) {
//process @JoinColumn(s) beforeQuery @Column(s) to handle collection of entities properly
//process @JoinColumn(s) before @Column(s) to handle collection of entities properly
JoinColumn[] joinColumnAnnotations = null;
if ( property.isAnnotationPresent( JoinColumn.class ) ) {

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

@ -639,7 +639,7 @@ public class Configuration {
/**
* Create a {@link SessionFactory} using the properties and mappings in this configuration. The
* SessionFactory will be immutable, so changes made to this Configuration afterQuery building the
* SessionFactory will be immutable, so changes made to this Configuration after building the
* SessionFactory will not affect it.
*
* @param serviceRegistry The registry of services to be used in creating this session factory.
@ -713,7 +713,7 @@ public class Configuration {
/**
* Create a {@link SessionFactory} using the properties and mappings in this configuration. The
* {@link SessionFactory} will be immutable, so changes made to {@code this} {@link Configuration} afterQuery
* {@link SessionFactory} will be immutable, so changes made to {@code this} {@link Configuration} after
* building the {@link SessionFactory} will not affect it.
*
* @return The build {@link SessionFactory}

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

@ -632,7 +632,7 @@ public class Ejb3Column {
}
}
//must only be called afterQuery all setters are defined and beforeQuery bind
//must only be called after all setters are defined and before bind
private void extractDataFromPropertyData(PropertyData inferredData) {
if ( inferredData != null ) {
XProperty property = inferredData.getProperty();

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

@ -955,7 +955,7 @@ public class Ejb3JoinColumn extends Ejb3Column {
currentJoinColumn.setMappedBy( mappedBy );
currentJoinColumn.setJoinAnnotation( annJoin, propertyName );
currentJoinColumn.setNullable( false ); //I break the spec, but it's for good
//done afterQuery the annotation to override it
//done after the annotation to override it
currentJoinColumn.bind();
joinColumns[index] = currentJoinColumn;
}

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

@ -112,7 +112,7 @@ import org.jboss.logging.Logger;
* <tr>
* <td><tt>hibernate.jdbc.use_getGeneratedKeys</tt></td>
* <td>enable use of JDBC3 PreparedStatement.getGeneratedKeys() to retrieve
* natively generated keys afterQuery insert. Requires JDBC3+ driver and JRE1.4+</td>
* natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+</td>
* </tr>
* <tr>
* <td><tt>hibernate.hbm2ddl.auto</tt></td>

6
hibernate-core/src/main/java/org/hibernate/cfg/annotations/EntityBinder.java
View File

@ -163,7 +163,7 @@ public class EntityBinder {
/**
* For the most part, this is a simple delegation to {@link PersistentClass#isPropertyDefinedInHierarchy},
* afterQuery verifying that PersistentClass is indeed set here.
* after verifying that PersistentClass is indeed set here.
*
* @param name The name of the property to check
*
@ -702,8 +702,8 @@ public class EntityBinder {
public void finalSecondaryTableBinding(PropertyHolder propertyHolder) {
/*
* Those operations has to be done afterQuery the id definition of the persistence class.
* ie afterQuery the properties parsing
* Those operations has to be done after the id definition of the persistence class.
* ie after the properties parsing
*/
Iterator joins = secondaryTables.values().iterator();
Iterator joinColumns = secondaryTableJoins.values().iterator();

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

@ -160,7 +160,7 @@ public class PropertyBinder {
);
}
if ( !declaringClassSet ) {
throw new AssertionFailure( "declaringClass has not been set beforeQuery a bind" );
throw new AssertionFailure( "declaringClass has not been set before a bind" );
}
}

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

@ -297,7 +297,7 @@ public class SimpleValueBinder {
// implicit type will check basic types and Serializable classes
if ( columns == null ) {
throw new AssertionFailure( "SimpleValueBinder.setColumns should be set beforeQuery SimpleValueBinder.setType" );
throw new AssertionFailure( "SimpleValueBinder.setColumns should be set before SimpleValueBinder.setType" );
}
if ( BinderHelper.ANNOTATION_STRING_DEFAULT.equals( type ) ) {

12
hibernate-core/src/main/java/org/hibernate/classic/Lifecycle.java
View File

@ -15,11 +15,11 @@ import org.hibernate.Session;
* Persistent classes <b>may</b> implement this interface but they are not
* required to.<br>
* <br>
* <b>onSave:</b> called just beforeQuery the object is saved<br>
* <b>onUpdate:</b> called just beforeQuery an object is updated,
* <b>onSave:</b> called just before the object is saved<br>
* <b>onUpdate:</b> called just before an object is updated,
* ie. when <tt>Session.update()</tt> is called<br>
* <b>onDelete:</b> called just beforeQuery an object is deleted<br>
* <b>onLoad:</b> called just afterQuery an object is loaded<br>
* <b>onDelete:</b> called just before an object is deleted<br>
* <b>onLoad:</b> called just after an object is loaded<br>
* <br>
* <tt>onLoad()</tt> may be used to initialize transient properties of the
* object from its persistent state. It may <b>not</b> be used to load
@ -35,7 +35,7 @@ import org.hibernate.Session;
* <tt>CallbackException</tt> is thrown, the operation is vetoed and the
* exception is passed back to the application.<br>
* <br>
* Note that <tt>onSave()</tt> is called afterQuery an identifier is assigned
* Note that <tt>onSave()</tt> is called after an identifier is assigned
* to the object, except when identity column key generation is used.
*
* @see CallbackException
@ -80,7 +80,7 @@ public interface Lifecycle {
public boolean onDelete(Session s) throws CallbackException;
/**
* Called afterQuery an entity is loaded. <em>It is illegal to
* Called after an entity is loaded. <em>It is illegal to
* access the <tt>Session</tt> from inside this method.</em>
* However, the object may keep a reference to the session
* for later use.

2
hibernate-core/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java
View File

@ -533,7 +533,7 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
@Override
public boolean afterInitialize() {
setInitialized();
//do this bit afterQuery setting initialized to true or it will recurse
//do this bit after setting initialized to true or it will recurse
if ( operationQueue != null ) {
performQueuedOperations();
operationQueue = null;

20
hibernate-core/src/main/java/org/hibernate/collection/spi/PersistentCollection.java
View File

@ -92,19 +92,19 @@ public interface PersistentCollection {
Object getValue();
/**
* Called just beforeQuery reading any rows from the JDBC result set
* Called just before reading any rows from the JDBC result set
*/
void beginRead();
/**
* Called afterQuery reading all rows from the JDBC result set
* Called after reading all rows from the JDBC result set
*
* @return Whether to end the read.
*/
boolean endRead();
/**
* Called afterQuery initializing from cache
* Called after initializing from cache
*
* @return ??
*/
@ -190,7 +190,7 @@ public interface PersistentCollection {
*
* @param entry The collection entry/element
* @param i The assumed index
* @param persister it was more elegant beforeQuery we added this...
* @param persister it was more elegant before we added this...
*
* @return The index value
*/
@ -217,11 +217,11 @@ public interface PersistentCollection {
Object getSnapshotElement(Object entry, int i);
/**
* Called beforeQuery any elements are read into the collection,
* Called before any elements are read into the collection,
* allowing appropriate initializations to occur.
*
* @param persister The underlying collection persister.
* @param anticipatedSize The anticipated size of the collection afterQuery initialization is complete.
* @param anticipatedSize The anticipated size of the collection after initialization is complete.
*/
void beforeInitialize(CollectionPersister persister, int anticipatedSize);
@ -388,7 +388,7 @@ public interface PersistentCollection {
/**
* Is the collection dirty? Note that this is only
* reliable during the flush cycle, afterQuery the
* reliable during the flush cycle, after the
* collection elements are dirty checked against
* the snapshot.
*
@ -397,7 +397,7 @@ public interface PersistentCollection {
boolean isDirty();
/**
* Clear the dirty flag, afterQuery flushing changes
* Clear the dirty flag, after flushing changes
* to the database.
*/
void clearDirty();
@ -415,7 +415,7 @@ public interface PersistentCollection {
void dirty();
/**
* Called beforeQuery inserting rows, to ensure that any surrogate keys
* Called before inserting rows, to ensure that any surrogate keys
* are fully generated
*
* @param persister The collection persister
@ -423,7 +423,7 @@ public interface PersistentCollection {
void preInsert(CollectionPersister persister);
/**
* Called afterQuery inserting a row, to fetch the natively generated id
* Called after inserting a row, to fetch the natively generated id
*
* @param persister The collection persister
* @param entry The collection element just inserted

6
hibernate-core/src/main/java/org/hibernate/context/internal/JTASessionContext.java
View File

@ -25,7 +25,7 @@ import org.jboss.logging.Logger;
/**
* An implementation of {@link org.hibernate.context.spi.CurrentSessionContext} which scopes the notion
* of a current session to a JTA transaction. Because JTA gives us a nice tie-in to clean up afterQuery
* of a current session to a JTA transaction. Because JTA gives us a nice tie-in to clean up after
* ourselves, this implementation will generate Sessions as needed provided a JTA transaction is in
* effect. If a session is not already associated with the current JTA transaction at the time
* {@link #currentSession()} is called, a new session will be opened and it will be associated with that
@ -36,7 +36,7 @@ import org.jboss.logging.Logger;
* {@link org.hibernate.cfg.Environment#AUTO_CLOSE_SESSION auto-close} attributes set to true, meaning
* that the Session will be automatically flushed and closed as part of the lifecycle for the JTA
* transaction to which it is associated. Additionally, it will also be configured to aggressively
* release JDBC connections afterQuery each statement is executed. These settings are governed by the
* release JDBC connections after each statement is executed. These settings are governed by the
* {@link #isAutoFlushEnabled()}, {@link #isAutoCloseEnabled()}, and {@link #getConnectionReleaseMode()}
* methods; these are provided (along with the {@link #buildOrObtainSession()} method) for easier
* subclassing for custom JTA-based session tracking logic (like maybe long-session semantics).
@ -118,7 +118,7 @@ public class JTASessionContext extends AbstractCurrentSessionContext {
}
/**
* Builds a {@link org.hibernate.context.internal.JTASessionContext.CleanupSync} capable of cleaning up the the current session map as an afterQuery transaction
* Builds a {@link org.hibernate.context.internal.JTASessionContext.CleanupSync} capable of cleaning up the the current session map as an after transaction
* callback.
*
* @param transactionIdentifier The transaction identifier under which the current session is registered.

4
hibernate-core/src/main/java/org/hibernate/context/internal/ThreadLocalSessionContext.java
View File

@ -38,9 +38,9 @@ import org.jboss.logging.Logger;
* session by the current thread of execution. Unlike the JTA counterpart, threads do not give us a nice
* hook to perform any type of cleanup making it questionable for this impl to actually generate Session
* instances. In the interest of usability, it was decided to have this default impl actually generate
* a session upon first request and then clean it up afterQuery the {@link org.hibernate.Transaction}
* a session upon first request and then clean it up after the {@link org.hibernate.Transaction}
* associated with that session is committed/rolled-back. In order for ensuring that happens, the
* sessions generated here are unusable until afterQuery {@link Session#beginTransaction()} has been
* sessions generated here are unusable until after {@link Session#beginTransaction()} has been
* called. If <tt>close()</tt> is called on a session managed by this class, it will be automatically
* unbound.
*

2
hibernate-core/src/main/java/org/hibernate/criterion/Projection.java Executable file → Normal file
View File

@ -29,7 +29,7 @@ public interface Projection extends Serializable {
* Render the SQL fragment to be used in the <tt>SELECT</tt> clause.
*
* @param criteria The local criteria to which this project is attached (for resolution).
* @param position The number of columns rendered in the <tt>SELECT</tt> clause beforeQuery this projection. Generally
* @param position The number of columns rendered in the <tt>SELECT</tt> clause before this projection. Generally
* speaking this is useful to ensure uniqueness of the individual columns aliases.
* @param criteriaQuery The overall criteria query instance.
* @return The SQL fragment to plug into the <tt>SELECT</tt>

2
hibernate-core/src/main/java/org/hibernate/criterion/ProjectionList.java Executable file → Normal file
View File

@ -57,7 +57,7 @@ public class ProjectionList implements EnhancedProjection {
}
/**
* Adds a projection to this list of projections afterQuery wrapping it with an alias
* Adds a projection to this list of projections after wrapping it with an alias
*
* @param projection The projection to add
* @param alias The alias to apply to the projection

4
hibernate-core/src/main/java/org/hibernate/dialect/AbstractHANADialect.java
View File

@ -96,7 +96,7 @@ public abstract class AbstractHANADialect extends Dialect {
// changed from the standard ones. The HANA JDBC driver currently closes any
// stream passed in via
// PreparedStatement.setCharacterStream(int,Reader,long)
// afterQuery the stream has been processed. this causes problems later if we are
// after the stream has been processed. this causes problems later if we are
// using non-contexual lob creation and HANA then closes our StringReader.
// see test case LobLocatorTest
@ -568,7 +568,7 @@ public abstract class AbstractHANADialect extends Dialect {
registerKeyword( "all" );
registerKeyword( "alter" );
registerKeyword( "as" );
registerKeyword( "beforeQuery" );
registerKeyword( "before" );
registerKeyword( "begin" );
registerKeyword( "both" );
registerKeyword( "case" );

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

@ -221,7 +221,7 @@ abstract class AbstractTransactSQLDialect extends Dialect {
return "#" + baseName;
}
},
// sql-server, at least needed this dropped afterQuery use; strange!
// sql-server, at least needed this dropped after use; strange!
AfterUseAction.DROP,
TempTableDdlTransactionHandling.NONE
);

4
hibernate-core/src/main/java/org/hibernate/dialect/Cache71Dialect.java
View File

@ -431,7 +431,7 @@ public class Cache71Dialect extends Dialect {
@Override
public boolean dropConstraints() {
// Do we need to drop constraints beforeQuery dropping tables in this dialect?
// Do we need to drop constraints before dropping tables in this dialect?
return true;
}
@ -516,7 +516,7 @@ public class Cache71Dialect extends Dialect {
@Override
public LockingStrategy getLockingStrategy(Lockable lockable, LockMode lockMode) {
// InterSystems Cache' does not current support "SELECT ... FOR UPDATE" syntax...
// Set your transaction mode to READ_COMMITTED beforeQuery using
// Set your transaction mode to READ_COMMITTED before using
if ( lockMode==LockMode.PESSIMISTIC_FORCE_INCREMENT) {
return new PessimisticForceIncrementLockingStrategy( lockable, lockMode);
}

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

@ -1031,7 +1031,7 @@ public abstract class Dialect implements ConversionContext {
* Does the <tt>LIMIT</tt> clause come at the start of the
* <tt>SELECT</tt> statement, rather than at the end?
*
* @return true if limit parameters should come beforeQuery other parameters
* @return true if limit parameters should come before other parameters
* @deprecated {@link #getLimitHandler()} should be overridden instead.
*/
@Deprecated
@ -2045,7 +2045,7 @@ public abstract class Dialect implements ConversionContext {
}
/**
* Do we need to drop constraints beforeQuery dropping tables in this dialect?
* Do we need to drop constraints before dropping tables in this dialect?
*
* @return True if constraints must be dropped prior to dropping
* the table; false otherwise.
@ -2198,44 +2198,44 @@ public abstract class Dialect implements ConversionContext {
}
/**
* For dropping a table, can the phrase "if exists" be applied beforeQuery the table name?
* For dropping a table, can the phrase "if exists" be applied before the table name?
* <p/>
* NOTE : Only one or the other (or neither) of this and {@link #supportsIfExistsAfterTableName} should return true
*
* @return {@code true} if the "if exists" can be applied beforeQuery the table name
* @return {@code true} if the "if exists" can be applied before the table name
*/
public boolean supportsIfExistsBeforeTableName() {
return false;
}
/**
* For dropping a table, can the phrase "if exists" be applied afterQuery the table name?
* For dropping a table, can the phrase "if exists" be applied after the table name?
* <p/>
* NOTE : Only one or the other (or neither) of this and {@link #supportsIfExistsBeforeTableName} should return true
*
* @return {@code true} if the "if exists" can be applied afterQuery the table name
* @return {@code true} if the "if exists" can be applied after the table name
*/
public boolean supportsIfExistsAfterTableName() {
return false;
}
/**
* For dropping a constraint with an "alter table", can the phrase "if exists" be applied beforeQuery the constraint name?
* For dropping a constraint with an "alter table", can the phrase "if exists" be applied before the constraint name?
* <p/>
* NOTE : Only one or the other (or neither) of this and {@link #supportsIfExistsAfterConstraintName} should return true
*
* @return {@code true} if the "if exists" can be applied beforeQuery the constraint name
* @return {@code true} if the "if exists" can be applied before the constraint name
*/
public boolean supportsIfExistsBeforeConstraintName() {
return false;
}
/**
* For dropping a constraint with an "alter table", can the phrase "if exists" be applied afterQuery the constraint name?
* For dropping a constraint with an "alter table", can the phrase "if exists" be applied after the constraint name?
* <p/>
* NOTE : Only one or the other (or neither) of this and {@link #supportsIfExistsBeforeConstraintName} should return true
*
* @return {@code true} if the "if exists" can be applied afterQuery the constraint name
* @return {@code true} if the "if exists" can be applied after the constraint name
*/
public boolean supportsIfExistsAfterConstraintName() {
return false;

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

@ -432,7 +432,7 @@ public class H2Dialect extends Dialect {
@Override
public boolean dropConstraints() {
// We don't need to drop constraints beforeQuery dropping tables, that just leads to error
// We don't need to drop constraints before dropping tables, that just leads to error
// messages about missing tables when we don't have a schema in the database
return false;
}

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

@ -28,7 +28,7 @@ public class SybaseAnywhereDialect extends SybaseDialect {
}
/**
* ASA does not require to drop constraint beforeQuery dropping tables, so disable it.
* ASA does not require to drop constraint before dropping tables, so disable it.
* <p/>
* NOTE : Also, the DROP statement syntax used by Hibernate to drop constraints is
* not compatible with ASA.

2
hibernate-core/src/main/java/org/hibernate/dialect/lock/OptimisticForceIncrementLockingStrategy.java
View File

@ -17,7 +17,7 @@ import org.hibernate.event.spi.EventSource;
import org.hibernate.persister.entity.Lockable;
/**
* An optimistic locking strategy that forces an increment of the version (afterQuery verifying that version hasn't changed).
* An optimistic locking strategy that forces an increment of the version (after verifying that version hasn't changed).
* This takes place just prior to transaction commit.
* <p/>
* This strategy is valid for LockMode.OPTIMISTIC_FORCE_INCREMENT

2
hibernate-core/src/main/java/org/hibernate/dialect/pagination/AbstractLimitHandler.java
View File

@ -56,7 +56,7 @@ public abstract class AbstractLimitHandler implements LimitHandler {
* Does the <tt>LIMIT</tt> clause come at the start of the
* <tt>SELECT</tt> statement, rather than at the end?
*
* @return true if limit parameters should come beforeQuery other parameters
* @return true if limit parameters should come before other parameters
*/
public boolean bindLimitParametersFirst() {
return false;

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

@ -45,7 +45,7 @@ public interface LimitHandler {
String processSql(String sql, RowSelection selection);
/**
* Bind parameter values needed by the LIMIT clause beforeQuery original SELECT statement.
* Bind parameter values needed by the LIMIT clause before original SELECT statement.
*
* @param selection the selection criteria for rows.
* @param statement Statement to which to bind limit parameter values.
@ -56,7 +56,7 @@ public interface LimitHandler {
int bindLimitParametersAtStartOfQuery(RowSelection selection, PreparedStatement statement, int index) throws SQLException;
/**
* Bind parameter values needed by the LIMIT clause afterQuery original SELECT statement.
* Bind parameter values needed by the LIMIT clause after original SELECT statement.
*
* @param selection the selection criteria for rows.
* @param statement Statement to which to bind limit parameter values.

4
hibernate-core/src/main/java/org/hibernate/engine/internal/Cascade.java
View File

@ -298,13 +298,13 @@ public final class Cascade {
if ( type.isAssociationType() && ( (AssociationType) type ).getForeignKeyDirection().equals(
ForeignKeyDirection.TO_PARENT
) ) {
// If FK direction is to-parent, we must remove the orphan *beforeQuery* the queued update(s)
// If FK direction is to-parent, we must remove the orphan *before* the queued update(s)
// occur. Otherwise, replacing the association on a managed entity, without manually
// nulling and flushing, causes FK constraint violations.
eventSource.removeOrphanBeforeUpdates( entityName, loadedValue );
}
else {
// Else, we must delete afterQuery the updates.
// Else, we must delete after the updates.
eventSource.delete( entityName, loadedValue, isCascadeDeleteEnabled, new HashSet() );
}
}

24
hibernate-core/src/main/java/org/hibernate/engine/internal/CascadePoint.java
View File

@ -13,52 +13,52 @@ package org.hibernate.engine.internal;
*/
public enum CascadePoint {
/**
* A cascade point that occurs just afterQuery the insertion of the parent entity and
* just beforeQuery deletion
* A cascade point that occurs just after the insertion of the parent entity and
* just before deletion
*/
AFTER_INSERT_BEFORE_DELETE,
/**
* A cascade point that occurs just beforeQuery the insertion of the parent entity and
* just afterQuery deletion
* A cascade point that occurs just before the insertion of the parent entity and
* just after deletion
*/
BEFORE_INSERT_AFTER_DELETE,
/**
* A cascade point that occurs just afterQuery the insertion of the parent entity and
* just beforeQuery deletion, inside a collection
* A cascade point that occurs just after the insertion of the parent entity and
* just before deletion, inside a collection
*/
AFTER_INSERT_BEFORE_DELETE_VIA_COLLECTION,
/**
* A cascade point that occurs just afterQuery update of the parent entity
* A cascade point that occurs just after update of the parent entity
*/
AFTER_UPDATE,
/**
* A cascade point that occurs just beforeQuery the session is flushed
* A cascade point that occurs just before the session is flushed
*/
BEFORE_FLUSH,
/**
* A cascade point that occurs just afterQuery eviction of the parent entity from the
* A cascade point that occurs just after eviction of the parent entity from the
* session cache
*/
AFTER_EVICT,
/**
* A cascade point that occurs just afterQuery locking a transient parent entity into the
* A cascade point that occurs just after locking a transient parent entity into the
* session cache
*/
BEFORE_REFRESH,
/**
* A cascade point that occurs just afterQuery refreshing a parent entity
* A cascade point that occurs just after refreshing a parent entity
*/
AFTER_LOCK,
/**
* A cascade point that occurs just beforeQuery merging from a transient parent entity into
* A cascade point that occurs just before merging from a transient parent entity into
* the object in the session cache
*/
BEFORE_MERGE

2
hibernate-core/src/main/java/org/hibernate/engine/internal/Collections.java Executable file → Normal file
View File

@ -177,7 +177,7 @@ public final class Collections {
// The CollectionEntry.isReached() stuff is just to detect any silly users
// who set up circular or shared references between/to collections.
if ( ce.isReached() ) {
// We've been here beforeQuery
// We've been here before
throw new HibernateException(
"Found shared references to a collection: " + type.getRole()
);

4
hibernate-core/src/main/java/org/hibernate/engine/internal/ForeignKeys.java Executable file → Normal file
View File

@ -234,7 +234,7 @@ public final class ForeignKeys {
return assumed;
}
// hit the database, afterQuery checking the session cache for a snapshot
// hit the database, after checking the session cache for a snapshot
final Object[] snapshot = session.getPersistenceContext().getDatabaseSnapshot(
persister.getIdentifier( entity, session ),
persister
@ -275,7 +275,7 @@ public final class ForeignKeys {
// deeper checks...
if ( isTransient( entityName, object, Boolean.FALSE, session ) ) {
throw new TransientObjectException(
"object references an unsaved transient instance - save the transient instance beforeQuery flushing: " +
"object references an unsaved transient instance - save the transient instance before flushing: " +
(entityName == null ? session.guessEntityName( object ) : entityName)
);
}

4
hibernate-core/src/main/java/org/hibernate/engine/internal/NaturalIdXrefDelegate.java
View File

@ -310,7 +310,7 @@ public class NaturalIdXrefDelegate {
/**
* As part of "load synchronization process", if a particular natural id is found to have changed we need to track
* its invalidity until afterQuery the next flush. This method lets the "load synchronization process" indicate
* its invalidity until after the next flush. This method lets the "load synchronization process" indicate
* when it has encountered such changes.
*
* @param persister The persister representing the entity type.
@ -331,7 +331,7 @@ public class NaturalIdXrefDelegate {
/**
* Again, as part of "load synchronization process" we need to also be able to clear references to these
* known-invalid natural-ids afterQuery flush. This method exposes that capability.
* known-invalid natural-ids after flush. This method exposes that capability.
*/
public void unStashInvalidNaturalIdReferences() {
for ( NaturalIdResolutionCache naturalIdResolutionCache : naturalIdResolutionCacheMap.values() ) {

4
hibernate-core/src/main/java/org/hibernate/engine/internal/Nullability.java Executable file → Normal file
View File

@ -161,11 +161,11 @@ public final class Nullability {
// IMPL NOTE : we currently skip checking "any" and "many to any" mappings.
//
// This is not the best solution. But atm there is a mismatch between AnyType#getPropertyNullability
// and the fact that cascaded-saves for "many to any" mappings are not performed until afterQuery this nullability
// and the fact that cascaded-saves for "many to any" mappings are not performed until after this nullability
// check. So the nullability check fails for transient entity elements with generated identifiers because
// the identifier is not yet generated/assigned (is null)
//
// The more correct fix would be to cascade saves of the many-to-any elements beforeQuery the Nullability checking
// The more correct fix would be to cascade saves of the many-to-any elements before the Nullability checking
if ( compositeType.isAnyType() ) {
return null;

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

@ -60,7 +60,7 @@ public class ParameterBinder {
* @param source The named parameter source, for resolving the locations of named parameters
* @param session The session
*
* @return The next bind position afterQuery the last position we bound here.
* @return The next bind position after the last position we bound here.
*
* @throws SQLException Indicates a problem calling JDBC bind methods
* @throws HibernateException Indicates a problem access bind values.

8
hibernate-core/src/main/java/org/hibernate/engine/internal/StatefulPersistenceContext.java
View File

@ -1073,7 +1073,7 @@ public class StatefulPersistenceContext implements PersistenceContext {
if ( removeOrphanBeforeUpdatesCounter >= getCascadeLevel() ) {
throw new IllegalStateException(
String.format(
"Cascade level [%d] is out of sync with removeOrphanBeforeUpdatesCounter [%d] beforeQuery incrementing removeOrphanBeforeUpdatesCounter",
"Cascade level [%d] is out of sync with removeOrphanBeforeUpdatesCounter [%d] before incrementing removeOrphanBeforeUpdatesCounter",
getCascadeLevel(),
removeOrphanBeforeUpdatesCounter
)
@ -1089,7 +1089,7 @@ public class StatefulPersistenceContext implements PersistenceContext {
if ( removeOrphanBeforeUpdatesCounter > getCascadeLevel() ) {
throw new IllegalStateException(
String.format(
"Cascade level [%d] is out of sync with removeOrphanBeforeUpdatesCounter [%d] beforeQuery decrementing removeOrphanBeforeUpdatesCounter",
"Cascade level [%d] is out of sync with removeOrphanBeforeUpdatesCounter [%d] before decrementing removeOrphanBeforeUpdatesCounter",
getCascadeLevel(),
removeOrphanBeforeUpdatesCounter
)
@ -1099,7 +1099,7 @@ public class StatefulPersistenceContext implements PersistenceContext {
}
/**
* Call this beforeQuery beginning a two-phase load
* Call this before beginning a two-phase load
*/
@Override
public void beforeLoad() {
@ -1107,7 +1107,7 @@ public class StatefulPersistenceContext implements PersistenceContext {
}
/**
* Call this afterQuery finishing a two-phase load
* Call this after finishing a two-phase load
*/
@Override
public void afterLoad() {

10
hibernate-core/src/main/java/org/hibernate/engine/internal/TwoPhaseLoad.java Executable file → Normal file
View File

@ -55,7 +55,7 @@ public final class TwoPhaseLoad {
}
/**
* Register the "hydrated" state of an entity instance, afterQuery the first step of 2-phase loading.
* Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
*
* Add the "hydrated state" (an array) of an uninitialized entity to the session. We don't try
* to resolve any associations yet, because there might be other entities waiting to be
@ -166,7 +166,7 @@ public final class TwoPhaseLoad {
}
}
//Must occur afterQuery resolving identifiers!
//Must occur after resolving identifiers!
if ( session.isEventSource() ) {
preLoadEvent.setEntity( entity ).setState( hydratedState ).setId( id ).setPersister( persister );
@ -268,7 +268,7 @@ public final class TwoPhaseLoad {
hydratedState,
persister.getPropertyTypes(),
persister.getPropertyUpdateability(),
//afterQuery setting values to object
//after setting values to object
hydratedState,
session
);
@ -290,7 +290,7 @@ public final class TwoPhaseLoad {
}
/**
* PostLoad cannot occur during initializeEntity, as that call occurs *beforeQuery*
* PostLoad cannot occur during initializeEntity, as that call occurs *before*
* the Set collections are added to the persistence context by Loader.
* Without the split, LazyInitializationExceptions can occur in the Entity's
* postLoad if it acts upon the collection.
@ -335,7 +335,7 @@ public final class TwoPhaseLoad {
/**
* Add an uninitialized instance of an entity class, as a placeholder to ensure object
* identity. Must be called beforeQuery <tt>postHydrate()</tt>.
* identity. Must be called before <tt>postHydrate()</tt>.
*
* Create a "temporary" entry for a newly instantiated entity. The entity is uninitialized,
* but we need the mapping from id to instance in order to guarantee uniqueness.

6
hibernate-core/src/main/java/org/hibernate/engine/jdbc/ContextualLobCreator.java
View File

@ -52,7 +52,7 @@ public class ContextualLobCreator extends AbstractLobCreator implements LobCreat
return blob;
}
catch ( SQLException e ) {
throw new JDBCException( "Unable to set BLOB bytes afterQuery creation", e );
throw new JDBCException( "Unable to set BLOB bytes after creation", e );
}
}
@ -80,7 +80,7 @@ public class ContextualLobCreator extends AbstractLobCreator implements LobCreat
return clob;
}
catch ( SQLException e ) {
throw new JDBCException( "Unable to set CLOB string afterQuery creation", e );
throw new JDBCException( "Unable to set CLOB string after creation", e );
}
}
@ -108,7 +108,7 @@ public class ContextualLobCreator extends AbstractLobCreator implements LobCreat
return nclob;
}
catch ( SQLException e ) {
throw new JDBCException( "Unable to set NCLOB string afterQuery creation", e );
throw new JDBCException( "Unable to set NCLOB string after creation", e );
}
}

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

@ -44,7 +44,7 @@ public class SerializableBlobProxy implements InvocationHandler, Serializable {
*/
public Blob getWrappedBlob() {
if ( blob == null ) {
throw new IllegalStateException( "Blobs may not be accessed afterQuery serialization" );
throw new IllegalStateException( "Blobs may not be accessed after serialization" );
}
else {
return blob;

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

@ -44,7 +44,7 @@ public class SerializableClobProxy implements InvocationHandler, Serializable {
*/
public Clob getWrappedClob() {
if ( clob == null ) {
throw new IllegalStateException( "Clobs may not be accessed afterQuery serialization" );
throw new IllegalStateException( "Clobs may not be accessed after serialization" );
}
else {
return clob;

2
hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentImpl.java vendored
View File

@ -257,7 +257,7 @@ public class JdbcEnvironmentImpl implements JdbcEnvironment {
}
this.identifierHelper = identifierHelper;
// and that current-catalog and current-schema happen afterQuery it
// and that current-catalog and current-schema happen after it
this.currentCatalog = identifierHelper.toIdentifier( extractedMetaDataSupport.getConnectionCatalogName() );
this.currentSchema = identifierHelper.toIdentifier( extractedMetaDataSupport.getConnectionSchemaName() );

2
hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/spi/IdentifierHelper.java vendored
View File

@ -17,7 +17,7 @@ import org.hibernate.cfg.AvailableSettings;
public interface IdentifierHelper {
/**
* Essentially quotes the identifier if it needs to be. Useful to apply global quoting,
* as well as reserved word quoting afterQuery calls to naming strategies.
* as well as reserved word quoting after calls to naming strategies.
*
* @param identifier The identifier for which to normalize quoting.
*

2
hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/spi/IdentifierHelperBuilder.java vendored
View File

@ -21,7 +21,7 @@ import org.jboss.logging.Logger;
/**
* Builder for IdentifierHelper instances. Mainly here to allow progressive
* building of the immutable (afterQuery instantiation) IdentifierHelper.
* building of the immutable (after instantiation) IdentifierHelper.
*
* @author Steve Ebersole
*/

4
hibernate-core/src/main/java/org/hibernate/engine/jdbc/internal/JdbcCoordinatorImpl.java
View File

@ -66,7 +66,7 @@ public class JdbcCoordinatorImpl implements JdbcCoordinator {
/**
* This is a marker value to insert instead of null values for when a Statement gets registered in xref
* but has no associated ResultSets registered. This is useful to efficiently check against duplicate
* registration but you'll have to check against instance equality rather than null beforeQuery attempting
* registration but you'll have to check against instance equality rather than null before attempting
* to add elements to this set.
*/
private static final Set<ResultSet> EMPTY_RESULTSET = Collections.emptySet();
@ -260,7 +260,7 @@ public class JdbcCoordinatorImpl implements JdbcCoordinator {
@Override
public void afterStatementExecution() {
LOG.tracev( "Starting afterQuery statement execution processing [{0}]", getConnectionReleaseMode() );
LOG.tracev( "Starting after statement execution processing [{0}]", getConnectionReleaseMode() );
if ( getConnectionReleaseMode() == ConnectionReleaseMode.AFTER_STATEMENT ) {
if ( ! releasesEnabled ) {
LOG.debug( "Skipping aggressive release due to manual disabling" );

6
hibernate-core/src/main/java/org/hibernate/engine/jdbc/spi/JdbcCoordinator.java
View File

@ -78,7 +78,7 @@ public interface JdbcCoordinator extends Serializable, TransactionCoordinatorOwn
/**
* Callback to let us know that a flush is beginning. We use this fact
* to temporarily circumvent aggressive connection releasing until afterQuery
* to temporarily circumvent aggressive connection releasing until after
* the flush cycle is complete {@link #flushEnding()}
*/
void flushBeginning();
@ -101,7 +101,7 @@ public interface JdbcCoordinator extends Serializable, TransactionCoordinatorOwn
/**
* Signals the end of transaction.
* <p/>
* Intended for use from the transaction coordinator, afterQuery local transaction completion. Used to conditionally
* Intended for use from the transaction coordinator, after local transaction completion. Used to conditionally
* release the JDBC connection aggressively if the configured release mode indicates.
*/
void afterTransaction();
@ -128,7 +128,7 @@ public interface JdbcCoordinator extends Serializable, TransactionCoordinatorOwn
void cancelLastQuery();
/**
* Calculate the amount of time, in seconds, still remaining beforeQuery transaction timeout occurs.
* Calculate the amount of time, in seconds, still remaining before transaction timeout occurs.
*
* @return The number of seconds remaining until until a transaction timeout occurs. A negative value indicates
* no timeout was requested.

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

@ -171,7 +171,7 @@ public class ParameterParser {
final String param = sqlString.substring( indx + 1, chopLocation );
if ( StringHelper.isEmpty( param ) ) {
throw new QueryException(
"Space is not allowed afterQuery parameter prefix ':' [" + sqlString + "]"
"Space is not allowed after parameter prefix ':' [" + sqlString + "]"
);
}
recognizer.namedParameter( param, indx );

14
hibernate-core/src/main/java/org/hibernate/engine/spi/ActionQueue.java
View File

@ -250,9 +250,9 @@ public class ActionQueue {
private void addInsertAction(AbstractEntityInsertAction insert) {
if ( insert.isEarlyInsert() ) {
// For early inserts, must execute inserts beforeQuery finding non-nullable transient entities.
// For early inserts, must execute inserts before finding non-nullable transient entities.
// TODO: find out why this is necessary
LOG.tracev( "Executing inserts beforeQuery finding non-nullable transient entities for early insert: [{0}]", insert );
LOG.tracev( "Executing inserts before finding non-nullable transient entities for early insert: [{0}]", insert );
executeInserts();
}
NonNullableTransientDependencies nonNullableTransientDependencies = insert.findNonNullableTransientEntities();
@ -274,7 +274,7 @@ public class ActionQueue {
private void addResolvedEntityInsertAction(AbstractEntityInsertAction insert) {
if ( insert.isEarlyInsert() ) {
LOG.trace( "Executing insertions beforeQuery resolved early-insert" );
LOG.trace( "Executing insertions before resolved early-insert" );
executeInserts();
LOG.debug( "Executing identity-insert immediately" );
execute( insert );
@ -409,7 +409,7 @@ public class ActionQueue {
/**
* Throws {@link org.hibernate.PropertyValueException} if there are any unresolved entity insert actions that depend
* on non-nullable associations with a transient entity. This method should be called on completion of an operation
* (afterQuery all cascades are completed) that saves an entity.
* (after all cascades are completed) that saves an entity.
*
* @throws org.hibernate.PropertyValueException if there are any unresolved entity insert actions;
* {@link org.hibernate.PropertyValueException#getEntityName()} and
@ -607,7 +607,7 @@ public class ActionQueue {
finally {
if ( session.getFactory().getSessionFactoryOptions().isQueryCacheEnabled() ) {
// Strictly speaking, only a subset of the list may have been processed if a RuntimeException occurs.
// We still invalidate all spaces. I don't see this as a big deal - afterQuery all, RuntimeExceptions are
// We still invalidate all spaces. I don't see this as a big deal - after all, RuntimeExceptions are
// unexpected.
Set<Serializable> propertySpaces = list.getQuerySpaces();
invalidateSpaces( propertySpaces.toArray( new Serializable[propertySpaces.size()] ) );
@ -922,7 +922,7 @@ public class ActionQueue {
}
/**
* Encapsulates behavior needed for beforeQuery transaction processing
* Encapsulates behavior needed for before transaction processing
*/
private static class BeforeTransactionCompletionProcessQueue extends AbstractTransactionCompletionProcessQueue<BeforeTransactionCompletionProcess> {
private BeforeTransactionCompletionProcessQueue(SessionImplementor session) {
@ -945,7 +945,7 @@ public class ActionQueue {
}
/**
* Encapsulates behavior needed for afterQuery transaction processing
* Encapsulates behavior needed for after transaction processing
*/
private static class AfterTransactionCompletionProcessQueue extends AbstractTransactionCompletionProcessQueue<AfterTransactionCompletionProcess> {
private Set<String> querySpacesToInvalidate = new HashSet<String>();

10
hibernate-core/src/main/java/org/hibernate/engine/spi/BatchFetchQueue.java Executable file → Normal file
View File

@ -71,7 +71,7 @@ public class BatchFetchQueue {
/**
* Clears all entries from this fetch queue.
* <p/>
* Called afterQuery flushing or clearing the session.
* Called after flushing or clearing the session.
*/
public void clear() {
batchLoadableEntityKeys.clear();
@ -106,7 +106,7 @@ public class BatchFetchQueue {
/**
* After evicting or deleting an entity, we don't need to
* know the query that was used to load it anymore (don't
* call this afterQuery loading the entity, since we might still
* call this after loading the entity, since we might still
* need to load its collections)
*/
public void removeSubselect(EntityKey key) {
@ -166,7 +166,7 @@ public class BatchFetchQueue {
/**
* Get a batch of unloaded identifiers for this class, using a slightly
* complex algorithm that tries to grab keys registered immediately afterQuery
* complex algorithm that tries to grab keys registered immediately after
* the given key.
*
* @param persister The persister for the entities being loaded.
@ -191,7 +191,7 @@ public class BatchFetchQueue {
if ( set != null ) {
for ( EntityKey key : set ) {
if ( checkForEnd && i == end ) {
//the first id found afterQuery the given id
//the first id found after the given id
return ids;
}
if ( persister.getIdentifierType().isEqual( id, key.getIdentifier() ) ) {
@ -300,7 +300,7 @@ public class BatchFetchQueue {
}
if ( checkForEnd && i == end ) {
return keys; //the first key found afterQuery the given key
return keys; //the first key found after the given key
}
final boolean isEqual = collectionPersister.getKeyType().isEqual(

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

@ -378,7 +378,7 @@ public class CascadingActions {
String parentEntiytName = persister.getEntityName();
String propertyName = persister.getPropertyNames()[propertyIndex];
throw new TransientPropertyValueException(
"object references an unsaved transient instance - save the transient instance beforeQuery flushing",
"object references an unsaved transient instance - save the transient instance before flushing",
childEntityName,
parentEntiytName,
propertyName

6
hibernate-core/src/main/java/org/hibernate/engine/spi/CollectionEntry.java
View File

@ -94,7 +94,7 @@ public final class CollectionEntry implements Serializable {
collection.setSnapshot(loadedKey, role, null);
//postInitialize() will be called afterQuery initialization
//postInitialize() will be called after initialization
}
/**
@ -209,7 +209,7 @@ public final class CollectionEntry implements Serializable {
}
/**
* Called afterQuery a successful flush
* Called after a successful flush
*/
public void postFlush(PersistentCollection collection) throws HibernateException {
if ( isIgnore() ) {
@ -222,7 +222,7 @@ public final class CollectionEntry implements Serializable {
}
/**
* Called afterQuery execution of an action
* Called after execution of an action
*/
public void afterAction(PersistentCollection collection) {
loadedKey = getCurrentKey();

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