Here are the examples of the java api org.hibernate.LockMode taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
195 Examples
19
Source : EntityCriteria.java
with MIT License
from theonedev
with MIT License
from theonedev
public EnreplacedyCriteria<T> setLockMode(String alias, LockMode lockMode) {
criteria.setLockMode(alias, lockMode);
return this;
}
19
Source : EntityCriteria.java
with MIT License
from theonedev
with MIT License
from theonedev
public EnreplacedyCriteria<T> setLockMode(LockMode lockMode) {
criteria.setLockMode(lockMode);
return this;
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
emr.session.lock(enreplacedyName, object, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void lock(Object object, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
emr.session.lock(object, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
return emr.session.load(theClreplaced, id, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
return emr.session.get(enreplacedyName, id, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void refresh(Object object, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
emr.session.refresh(object, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public <T> T get(Clreplaced<T> enreplacedyType, Serializable id, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
return emr.session.get(enreplacedyType, id, lockMode);
}
}
19
Source : TransactionScopedSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
checkBlocking();
try (SessionResult emr = acquireSession()) {
return emr.session.load(enreplacedyName, id, lockMode);
}
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
return delegate().load(theClreplaced, id, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
return delegate().get(enreplacedyName, id, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
delegate().lock(enreplacedyName, object, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public <T> T get(Clreplaced<T> enreplacedyType, Serializable id, LockMode lockMode) {
return delegate().get(enreplacedyType, id, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void lock(Object object, LockMode lockMode) {
delegate().lock(object, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public void refresh(Object object, LockMode lockMode) {
delegate().refresh(object, lockMode);
}
19
Source : ForwardingSession.java
with Apache License 2.0
from quarkusio
with Apache License 2.0
from quarkusio
@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
return delegate().load(enreplacedyName, id, lockMode);
}
19
Source : CheckIDUtil.java
with GNU Lesser General Public License v2.1
from phoenixctms
with GNU Lesser General Public License v2.1
from phoenixctms
public static Object checkEnreplacedyId(String enreplacedyName, Long id, Object dao, LockMode lockMode) throws Exception {
return replacedociationPath.findMethod(CHECK_ENreplacedY_ID_METHOD_PREFIX + enreplacedyName + CHECK_ENreplacedY_ID_METHOD_SUFFIX, LOCK_MODE_METHOD_TRANSFILTER, false, CheckIDUtil.clreplaced.getMethods()).invoke(null, id, dao, lockMode);
}
19
Source : CheckIDUtil.java
with GNU Lesser General Public License v2.1
from phoenixctms
with GNU Lesser General Public License v2.1
from phoenixctms
public static ECRF checkEcrfId(Long ecrfId, ECRFDao ecrfDao, LockMode lockMode) throws ServiceException {
ECRF ecrf = ecrfDao.load(ecrfId, lockMode);
if (ecrf == null) {
throw L10nUtil.initServiceException(ServiceExceptionCodes.INVALID_ECRF_ID, ecrfId == null ? null : ecrfId.toString());
}
return ecrf;
}
19
Source : SimpleSelect.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public SimpleSelect setLockMode(LockMode lockMode) {
this.lockOptions.setLockMode(lockMode);
return this;
}
19
Source : ForUpdateFragment.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* @author Gavin King
*/
public clreplaced ForUpdateFragment {
private final StringBuilder aliases = new StringBuilder();
private boolean isNowaitEnabled;
private boolean isSkipLockedEnabled;
private final Dialect dialect;
private LockMode lockMode;
private LockOptions lockOptions;
public ForUpdateFragment(Dialect dialect) {
this.dialect = dialect;
}
public ForUpdateFragment(Dialect dialect, LockOptions lockOptions, Map<String, String[]> keyColumnNames) throws QueryException {
this(dialect);
LockMode upgradeType = null;
Iterator iter = lockOptions.getAliasLockIterator();
this.lockOptions = lockOptions;
if (!iter.hasNext()) {
// no tables referenced
final LockMode lockMode = lockOptions.getLockMode();
if (LockMode.READ.lessThan(lockMode)) {
upgradeType = lockMode;
this.lockMode = lockMode;
}
}
while (iter.hasNext()) {
final Map.Entry me = (Map.Entry) iter.next();
final LockMode lockMode = (LockMode) me.getValue();
if (LockMode.READ.lessThan(lockMode)) {
final String tableAlias = (String) me.getKey();
if (dialect.forUpdateOfColumns()) {
// use the id column alias
String[] keyColumns = keyColumnNames.get(tableAlias);
if (keyColumns == null) {
throw new IllegalArgumentException("alias not found: " + tableAlias);
}
keyColumns = StringHelper.qualify(tableAlias, keyColumns);
for (String keyColumn : keyColumns) {
addTableAlias(keyColumn);
}
} else {
addTableAlias(tableAlias);
}
if (upgradeType != null && lockMode != upgradeType) {
throw new QueryException("mixed LockModes");
}
upgradeType = lockMode;
}
}
if (upgradeType == LockMode.UPGRADE_NOWAIT || lockOptions.getTimeOut() == LockOptions.NO_WAIT) {
setNowaitEnabled(true);
}
if (upgradeType == LockMode.UPGRADE_SKIPLOCKED || lockOptions.getTimeOut() == LockOptions.SKIP_LOCKED) {
setSkipLockedEnabled(true);
}
}
public ForUpdateFragment addTableAlias(String alias) {
if (aliases.length() > 0) {
aliases.append(", ");
}
aliases.append(alias);
return this;
}
public String toFragmentString() {
if (lockOptions != null) {
if (aliases.length() == 0) {
return dialect.getForUpdateString(lockOptions);
} else {
return dialect.getForUpdateString(aliases.toString(), lockOptions);
}
} else if (aliases.length() == 0) {
if (lockMode != null) {
return dialect.getForUpdateString(lockMode);
}
return "";
}
// TODO: preplaced lockmode
if (isNowaitEnabled) {
return dialect.getForUpdateNowaitString(aliases.toString());
} else if (isSkipLockedEnabled) {
return dialect.getForUpdateSkipLockedString(aliases.toString());
} else {
return dialect.getForUpdateString(aliases.toString());
}
}
public ForUpdateFragment setNowaitEnabled(boolean nowait) {
isNowaitEnabled = nowait;
return this;
}
public ForUpdateFragment setSkipLockedEnabled(boolean skipLocked) {
isSkipLockedEnabled = skipLocked;
return this;
}
}
19
Source : NativeQueryReturnBuilderRootImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* @author Steve Ebersole
*/
public clreplaced NativeQueryReturnBuilderRootImpl implements NativeQuery.RootReturn, NativeQueryReturnBuilder {
private final String alias;
private final String enreplacedyName;
private LockMode lockMode = LockMode.READ;
private Map<String, String[]> propertyMappings;
public NativeQueryReturnBuilderRootImpl(String alias, String enreplacedyName) {
this.alias = alias;
this.enreplacedyName = enreplacedyName;
}
public NativeQuery.RootReturn setLockMode(LockMode lockMode) {
this.lockMode = lockMode;
return this;
}
public NativeQuery.RootReturn setDiscriminatorAlias(String alias) {
addProperty("clreplaced", alias);
return this;
}
public NativeQuery.RootReturn addProperty(String propertyName, String columnAlias) {
addProperty(propertyName).addColumnAlias(columnAlias);
return this;
}
public NativeQuery.ReturnProperty addProperty(final String propertyName) {
if (propertyMappings == null) {
propertyMappings = new HashMap<>();
}
return new NativeQuery.ReturnProperty() {
public NativeQuery.ReturnProperty addColumnAlias(String columnAlias) {
String[] columnAliases = propertyMappings.get(propertyName);
if (columnAliases == null) {
columnAliases = new String[] { columnAlias };
} else {
String[] newColumnAliases = new String[columnAliases.length + 1];
System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
newColumnAliases[columnAliases.length] = columnAlias;
columnAliases = newColumnAliases;
}
propertyMappings.put(propertyName, columnAliases);
return this;
}
};
}
public NativeSQLQueryReturn buildReturn() {
return new NativeSQLQueryRootReturn(alias, enreplacedyName, propertyMappings, lockMode);
}
}
19
Source : NativeQueryReturnBuilderRootImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public NativeQuery.RootReturn setLockMode(LockMode lockMode) {
this.lockMode = lockMode;
return this;
}
19
Source : NativeQueryReturnBuilderFetchImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* @author Steve Ebersole
*/
public clreplaced NativeQueryReturnBuilderFetchImpl implements NativeQuery.FetchReturn, NativeQueryReturnBuilder {
private final String alias;
private String ownerTableAlias;
private final String joinedPropertyName;
private LockMode lockMode = LockMode.READ;
private Map<String, String[]> propertyMappings;
public NativeQueryReturnBuilderFetchImpl(String alias, String ownerTableAlias, String joinedPropertyName) {
this.alias = alias;
this.ownerTableAlias = ownerTableAlias;
this.joinedPropertyName = joinedPropertyName;
}
public NativeQuery.FetchReturn setLockMode(LockMode lockMode) {
this.lockMode = lockMode;
return this;
}
public NativeQuery.FetchReturn addProperty(String propertyName, String columnAlias) {
addProperty(propertyName).addColumnAlias(columnAlias);
return this;
}
public NativeQuery.ReturnProperty addProperty(final String propertyName) {
if (propertyMappings == null) {
propertyMappings = new HashMap<>();
}
return new NativeQuery.ReturnProperty() {
public NativeQuery.ReturnProperty addColumnAlias(String columnAlias) {
String[] columnAliases = propertyMappings.get(propertyName);
if (columnAliases == null) {
columnAliases = new String[] { columnAlias };
} else {
String[] newColumnAliases = new String[columnAliases.length + 1];
System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
newColumnAliases[columnAliases.length] = columnAlias;
columnAliases = newColumnAliases;
}
propertyMappings.put(propertyName, columnAliases);
return this;
}
};
}
public NativeSQLQueryReturn buildReturn() {
return new NativeSQLQueryJoinReturn(alias, ownerTableAlias, joinedPropertyName, propertyMappings, lockMode);
}
}
19
Source : NativeQueryReturnBuilderFetchImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public NativeQuery.FetchReturn setLockMode(LockMode lockMode) {
this.lockMode = lockMode;
return this;
}
19
Source : SelectStatementBuilder.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Sets the lock mode for the select statement.
*
* @param lockMode The lock mode.
*/
public void setLockMode(LockMode lockMode) {
this.lockOptions.setLockMode(lockMode);
}
19
Source : NonScalarReturn.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Represents some non-scalar (enreplacedy/collection) return within the query result.
*
* @author Steve Ebersole
*/
public abstract clreplaced NonScalarReturn implements Return {
private final String alias;
private final LockMode lockMode;
public NonScalarReturn(String alias, LockMode lockMode) {
this.alias = alias;
if (alias == null) {
throw new HibernateException("alias must be specified");
}
this.lockMode = lockMode;
}
public String getAlias() {
return alias;
}
public LockMode getLockMode() {
return lockMode;
}
}
19
Source : LockModeTypeHelper.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public static LockMode interpretLockMode(Object value) {
if (value == null) {
return LockMode.NONE;
}
if (LockMode.clreplaced.isInstance(value)) {
return (LockMode) value;
} else if (LockModeType.clreplaced.isInstance(value)) {
return getLockMode((LockModeType) value);
} else if (String.clreplaced.isInstance(value)) {
// first try LockMode name
LockMode lockMode = LockMode.valueOf((String) value);
if (lockMode == null) {
try {
lockMode = getLockMode(LockModeType.valueOf((String) value));
} catch (Exception ignore) {
}
}
if (lockMode != null) {
return lockMode;
}
}
throw new IllegalArgumentException("Unknown lock mode source : " + value);
}
19
Source : ArrayHelper.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public static LockMode[] fillArray(LockMode lockMode, int length) {
LockMode[] array = new LockMode[length];
Arrays.fill(array, lockMode);
return array;
}
19
Source : StatelessSessionImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
private LockMode getNullSafeLockMode(LockMode lockMode) {
return lockMode == null ? LockMode.NONE : lockMode;
}
19
Source : CriteriaImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public Criteria setLockMode(String alias, LockMode lockMode) {
lockModes.put(alias, lockMode);
return this;
}
19
Source : CriteriaImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public Criteria setLockMode(LockMode lockMode) {
return setLockMode(getAlias(), lockMode);
}
19
Source : ResolveNaturalIdEvent.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Defines an event clreplaced for the resolving of an enreplacedy id from the enreplacedy's natural-id
*
* @author Eric Dalquist
* @author Steve Ebersole
*/
public clreplaced ResolveNaturalIdEvent extends AbstractEvent {
public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;
private final EnreplacedyPersister enreplacedyPersister;
private final Map<String, Object> naturalIdValues;
private final Object[] orderedNaturalIdValues;
private final LockOptions lockOptions;
private Serializable enreplacedyId;
public ResolveNaturalIdEvent(Map<String, Object> naturalIdValues, EnreplacedyPersister enreplacedyPersister, EventSource source) {
this(naturalIdValues, enreplacedyPersister, new LockOptions(), source);
}
public ResolveNaturalIdEvent(Map<String, Object> naturalIdValues, EnreplacedyPersister enreplacedyPersister, LockOptions lockOptions, EventSource source) {
super(source);
if (enreplacedyPersister == null) {
throw new IllegalArgumentException("EnreplacedyPersister is required for loading");
}
if (!enreplacedyPersister.hasNaturalIdentifier()) {
throw new HibernateException("Enreplacedy did not define a natural-id");
}
if (naturalIdValues == null || naturalIdValues.isEmpty()) {
throw new IllegalArgumentException("natural-id to load is required");
}
if (enreplacedyPersister.getNaturalIdentifierProperties().length != naturalIdValues.size()) {
throw new HibernateException(String.format("Enreplacedy [%s] defines its natural-id with %d properties but only %d were specified", enreplacedyPersister.getEnreplacedyName(), enreplacedyPersister.getNaturalIdentifierProperties().length, naturalIdValues.size()));
}
if (lockOptions.getLockMode() == LockMode.WRITE) {
throw new IllegalArgumentException("Invalid lock mode for loading");
} else if (lockOptions.getLockMode() == null) {
lockOptions.setLockMode(DEFAULT_LOCK_MODE);
}
this.enreplacedyPersister = enreplacedyPersister;
this.naturalIdValues = naturalIdValues;
this.lockOptions = lockOptions;
int[] naturalIdPropertyPositions = enreplacedyPersister.getNaturalIdentifierProperties();
orderedNaturalIdValues = new Object[naturalIdPropertyPositions.length];
int i = 0;
for (int position : naturalIdPropertyPositions) {
final String propertyName = enreplacedyPersister.getPropertyNames()[position];
if (!naturalIdValues.containsKey(propertyName)) {
throw new HibernateException(String.format("No value specified for natural-id property %s#%s", getEnreplacedyName(), propertyName));
}
orderedNaturalIdValues[i++] = naturalIdValues.get(enreplacedyPersister.getPropertyNames()[position]);
}
}
public Map<String, Object> getNaturalIdValues() {
return Collections.unmodifiableMap(naturalIdValues);
}
public Object[] getOrderedNaturalIdValues() {
return orderedNaturalIdValues;
}
public EnreplacedyPersister getEnreplacedyPersister() {
return enreplacedyPersister;
}
public String getEnreplacedyName() {
return getEnreplacedyPersister().getEnreplacedyName();
}
public LockOptions getLockOptions() {
return lockOptions;
}
public Serializable getEnreplacedyId() {
return enreplacedyId;
}
public void setEnreplacedyId(Serializable enreplacedyId) {
this.enreplacedyId = enreplacedyId;
}
}
19
Source : LockEvent.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public void setLockMode(LockMode lockMode) {
this.lockOptions.setLockMode(lockMode);
}
19
Source : LoadEvent.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Defines an event clreplaced for the loading of an enreplacedy.
*
* @author Steve Ebersole
*/
public clreplaced LoadEvent extends AbstractEvent {
public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;
// Performance hotspot: avoid allocating unneeded LockOptions
public static final LockOptions DEFAULT_LOCK_OPTIONS = new LockOptions() {
@Override
public LockOptions setLockMode(LockMode lockMode) {
throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
}
@Override
public LockOptions setAlireplacedpecificLockMode(String alias, LockMode lockMode) {
throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
}
@Override
public LockOptions setTimeOut(int timeout) {
throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
}
@Override
public LockOptions setScope(boolean scope) {
throw new replacedertionFailure("Should not be invoked: DEFAULT_LOCK_OPTIONS needs to be treated as immutable.");
}
};
private Serializable enreplacedyId;
private String enreplacedyClreplacedName;
private Object instanceToLoad;
private LockOptions lockOptions;
private boolean isreplacedociationFetch;
private Object result;
private PostLoadEvent postLoadEvent;
public LoadEvent(Serializable enreplacedyId, Object instanceToLoad, EventSource source) {
this(enreplacedyId, null, instanceToLoad, DEFAULT_LOCK_OPTIONS, false, source);
}
public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, LockMode lockMode, EventSource source) {
this(enreplacedyId, enreplacedyClreplacedName, null, lockMode, false, source);
}
public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, LockOptions lockOptions, EventSource source) {
this(enreplacedyId, enreplacedyClreplacedName, null, lockOptions, false, source);
}
public LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, boolean isreplacedociationFetch, EventSource source) {
this(enreplacedyId, enreplacedyClreplacedName, null, DEFAULT_LOCK_OPTIONS, isreplacedociationFetch, source);
}
public boolean isreplacedociationFetch() {
return isreplacedociationFetch;
}
private LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, Object instanceToLoad, LockMode lockMode, boolean isreplacedociationFetch, EventSource source) {
this(enreplacedyId, enreplacedyClreplacedName, instanceToLoad, lockMode == DEFAULT_LOCK_MODE ? DEFAULT_LOCK_OPTIONS : new LockOptions().setLockMode(lockMode), isreplacedociationFetch, source);
}
private LoadEvent(Serializable enreplacedyId, String enreplacedyClreplacedName, Object instanceToLoad, LockOptions lockOptions, boolean isreplacedociationFetch, EventSource source) {
super(source);
if (enreplacedyId == null) {
throw new IllegalArgumentException("id to load is required for loading");
}
if (lockOptions.getLockMode() == LockMode.WRITE) {
throw new IllegalArgumentException("Invalid lock mode for loading");
} else if (lockOptions.getLockMode() == null) {
lockOptions.setLockMode(DEFAULT_LOCK_MODE);
}
this.enreplacedyId = enreplacedyId;
this.enreplacedyClreplacedName = enreplacedyClreplacedName;
this.instanceToLoad = instanceToLoad;
this.lockOptions = lockOptions;
this.isreplacedociationFetch = isreplacedociationFetch;
this.postLoadEvent = new PostLoadEvent(source);
}
public Serializable getEnreplacedyId() {
return enreplacedyId;
}
public void setEnreplacedyId(Serializable enreplacedyId) {
this.enreplacedyId = enreplacedyId;
}
public String getEnreplacedyClreplacedName() {
return enreplacedyClreplacedName;
}
public void setEnreplacedyClreplacedName(String enreplacedyClreplacedName) {
this.enreplacedyClreplacedName = enreplacedyClreplacedName;
}
public Object getInstanceToLoad() {
return instanceToLoad;
}
public void setInstanceToLoad(Object instanceToLoad) {
this.instanceToLoad = instanceToLoad;
}
public LockOptions getLockOptions() {
return lockOptions;
}
public LockMode getLockMode() {
return lockOptions.getLockMode();
}
public void setLockMode(LockMode lockMode) {
if (lockMode != lockOptions.getLockMode()) {
writingOnLockOptions();
this.lockOptions.setLockMode(lockMode);
}
}
private void writingOnLockOptions() {
if (lockOptions == DEFAULT_LOCK_OPTIONS) {
this.lockOptions = new LockOptions();
}
}
public void setLockTimeout(int timeout) {
if (timeout != lockOptions.getTimeOut()) {
writingOnLockOptions();
this.lockOptions.setTimeOut(timeout);
}
}
public int getLockTimeout() {
return this.lockOptions.getTimeOut();
}
public void setLockScope(boolean cascade) {
if (lockOptions.getScope() != cascade) {
writingOnLockOptions();
this.lockOptions.setScope(cascade);
}
}
public boolean getLockScope() {
return this.lockOptions.getScope();
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
public PostLoadEvent getPostLoadEvent() {
return postLoadEvent;
}
public void setPostLoadEvent(PostLoadEvent postLoadEvent) {
this.postLoadEvent = postLoadEvent;
}
}
19
Source : LoadEvent.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public void setLockMode(LockMode lockMode) {
if (lockMode != lockOptions.getLockMode()) {
writingOnLockOptions();
this.lockOptions.setLockMode(lockMode);
}
}
19
Source : DefaultPostLoadEventListener.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public void onPostLoad(PostLoadEvent event) {
final Object enreplacedy = event.getEnreplacedy();
callbackRegistry.postLoad(enreplacedy);
final EnreplacedyEntry entry = event.getSession().getPersistenceContext().getEntry(enreplacedy);
if (entry == null) {
throw new replacedertionFailure("possible non-threadsafe access to the session");
}
final LockMode lockMode = entry.getLockMode();
if (LockMode.PESSIMISTIC_FORCE_INCREMENT.equals(lockMode)) {
final EnreplacedyPersister persister = entry.getPersister();
final Object nextVersion = persister.forceVersionIncrement(entry.getId(), entry.getVersion(), event.getSession());
entry.forceLocked(enreplacedy, nextVersion);
} else if (LockMode.OPTIMISTIC_FORCE_INCREMENT.equals(lockMode)) {
final EnreplacedyIncrementVersionProcess incrementVersion = new EnreplacedyIncrementVersionProcess(enreplacedy, entry);
event.getSession().getActionQueue().registerProcess(incrementVersion);
} else if (LockMode.OPTIMISTIC.equals(lockMode)) {
final EnreplacedyVerifyVersionProcess verifyVersion = new EnreplacedyVerifyVersionProcess(enreplacedy, entry);
event.getSession().getActionQueue().registerProcess(verifyVersion);
}
if (event.getPersister().implementsLifecycle()) {
// log.debug( "calling onLoad()" );
((Lifecycle) event.getEnreplacedy()).onLoad(event.getSession(), event.getId());
}
}
19
Source : DefaultLoadEventListener.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Defines the default load event listeners used by hibernate for loading enreplacedies
* in response to generated load events.
*
* @author Steve Ebersole
*/
public clreplaced DefaultLoadEventListener extends AbstractLockUpgradeEventListener implements LoadEventListener {
public static final Object REMOVED_ENreplacedY_MARKER = new Object();
public static final Object INCONSISTENT_RTN_CLreplaced_MARKER = new Object();
public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;
private static final CoreMessageLogger LOG = CoreLogging.messageLogger(DefaultLoadEventListener.clreplaced);
private static final boolean traceEnabled = LOG.isTraceEnabled();
/**
* Handle the given load event.
*
* @param event The load event to be handled.
*
* @throws HibernateException
*/
public void onLoad(final LoadEvent event, final LoadEventListener.LoadType loadType) throws HibernateException {
final EnreplacedyPersister persister = getPersister(event);
if (persister == null) {
throw new HibernateException("Unable to locate persister: " + event.getEnreplacedyClreplacedName());
}
final Clreplaced idClreplaced = persister.getIdentifierType().getReturnedClreplaced();
if (idClreplaced != null && !idClreplaced.isInstance(event.getEnreplacedyId()) && !DelayedPostInsertIdentifier.clreplaced.isInstance(event.getEnreplacedyId())) {
checkIdClreplaced(persister, event, loadType, idClreplaced);
}
doOnLoad(persister, event, loadType);
}
protected EnreplacedyPersister getPersister(final LoadEvent event) {
if (event.getInstanceToLoad() != null) {
// the load() which takes an enreplacedy does not preplaced an enreplacedyName
event.setEnreplacedyClreplacedName(event.getInstanceToLoad().getClreplaced().getName());
return event.getSession().getEnreplacedyPersister(null, event.getInstanceToLoad());
} else {
return event.getSession().getFactory().getEnreplacedyPersister(event.getEnreplacedyClreplacedName());
}
}
private void doOnLoad(final EnreplacedyPersister persister, final LoadEvent event, final LoadEventListener.LoadType loadType) {
try {
final EnreplacedyKey keyToLoad = event.getSession().generateEnreplacedyKey(event.getEnreplacedyId(), persister);
if (loadType.isNakedEnreplacedyReturned()) {
// do not return a proxy!
// (this option indicates we are initializing a proxy)
event.setResult(load(event, persister, keyToLoad, loadType));
} else {
// return a proxy if appropriate
if (event.getLockMode() == LockMode.NONE) {
event.setResult(proxyOrLoad(event, persister, keyToLoad, loadType));
} else {
event.setResult(lockAndLoad(event, persister, keyToLoad, loadType, event.getSession()));
}
}
} catch (HibernateException e) {
LOG.unableToLoadCommand(e);
throw e;
}
}
private void checkIdClreplaced(final EnreplacedyPersister persister, final LoadEvent event, final LoadEventListener.LoadType loadType, final Clreplaced idClreplaced) {
// we may have the kooky jpa requirement of allowing find-by-id where
// "id" is the "simple pk value" of a dependent objects parent. This
// is part of its generally goofy "derived idenreplacedy" "feature"
if (persister.getEnreplacedyMetamodel().getIdentifierProperty().isEmbedded()) {
final EmbeddedComponentType dependentIdType = (EmbeddedComponentType) persister.getEnreplacedyMetamodel().getIdentifierProperty().getType();
if (dependentIdType.getSubtypes().length == 1) {
final Type singleSubType = dependentIdType.getSubtypes()[0];
if (singleSubType.isEnreplacedyType()) {
final EnreplacedyType dependentParentType = (EnreplacedyType) singleSubType;
final Type dependentParentIdType = dependentParentType.getIdentifierOrUniqueKeyType(event.getSession().getFactory());
if (dependentParentIdType.getReturnedClreplaced().isInstance(event.getEnreplacedyId())) {
// yep that's what we have...
loadByDerivedIdenreplacedySimplePkValue(event, loadType, persister, dependentIdType, event.getSession().getFactory().getEnreplacedyPersister(dependentParentType.getreplacedociatedEnreplacedyName()));
return;
}
}
}
}
throw new TypeMismatchException("Provided id of the wrong type for clreplaced " + persister.getEnreplacedyName() + ". Expected: " + idClreplaced + ", got " + event.getEnreplacedyId().getClreplaced());
}
private void loadByDerivedIdenreplacedySimplePkValue(LoadEvent event, LoadEventListener.LoadType options, EnreplacedyPersister dependentPersister, EmbeddedComponentType dependentIdType, EnreplacedyPersister parentPersister) {
final EnreplacedyKey parentEnreplacedyKey = event.getSession().generateEnreplacedyKey(event.getEnreplacedyId(), parentPersister);
final Object parent = doLoad(event, parentPersister, parentEnreplacedyKey, options);
final Serializable dependent = (Serializable) dependentIdType.instantiate(parent, event.getSession());
dependentIdType.setPropertyValues(dependent, new Object[] { parent }, dependentPersister.getEnreplacedyMode());
final EnreplacedyKey dependentEnreplacedyKey = event.getSession().generateEnreplacedyKey(dependent, dependentPersister);
event.setEnreplacedyId(dependent);
event.setResult(doLoad(event, dependentPersister, dependentEnreplacedyKey, options));
}
/**
* Performs the load of an enreplacedy.
*
* @param event The initiating load request event
* @param persister The persister corresponding to the enreplacedy to be loaded
* @param keyToLoad The key of the enreplacedy to be loaded
* @param options The defined load options
*
* @return The loaded enreplacedy.
*
* @throws HibernateException
*/
private Object load(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
if (event.getInstanceToLoad() != null) {
if (event.getSession().getPersistenceContext().getEntry(event.getInstanceToLoad()) != null) {
throw new PersistentObjectException("attempted to load into an instance that was already replacedociated with the session: " + MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
persister.setIdentifier(event.getInstanceToLoad(), event.getEnreplacedyId(), event.getSession());
}
final Object enreplacedy = doLoad(event, persister, keyToLoad, options);
boolean isOptionalInstance = event.getInstanceToLoad() != null;
if (enreplacedy == null && (!options.isAllowNulls() || isOptionalInstance)) {
event.getSession().getFactory().getEnreplacedyNotFoundDelegate().handleEnreplacedyNotFound(event.getEnreplacedyClreplacedName(), event.getEnreplacedyId());
} else if (isOptionalInstance && enreplacedy != event.getInstanceToLoad()) {
throw new NonUniqueObjectException(event.getEnreplacedyId(), event.getEnreplacedyClreplacedName());
}
return enreplacedy;
}
/**
* Based on configured options, will either return a pre-existing proxy,
* generate a new proxy, or perform an actual load.
*
* @param event The initiating load request event
* @param persister The persister corresponding to the enreplacedy to be loaded
* @param keyToLoad The key of the enreplacedy to be loaded
* @param options The defined load options
*
* @return The result of the proxy/load operation.
*/
private Object proxyOrLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
if (traceEnabled) {
LOG.tracev("Loading enreplacedy: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
// this clreplaced has no proxies (so do a shortcut)
if (!persister.hasProxy()) {
return load(event, persister, keyToLoad, options);
}
final PersistenceContext persistenceContext = event.getSession().getPersistenceContext();
// look for a proxy
Object proxy = persistenceContext.getProxy(keyToLoad);
if (proxy != null) {
return returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy);
}
if (options.isAllowProxyCreation()) {
return createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext);
}
// return a newly loaded object
return load(event, persister, keyToLoad, options);
}
/**
* Given a proxy, initialize it and/or narrow it provided either
* is necessary.
*
* @param event The initiating load request event
* @param persister The persister corresponding to the enreplacedy to be loaded
* @param keyToLoad The key of the enreplacedy to be loaded
* @param options The defined load options
* @param persistenceContext The originating session
* @param proxy The proxy to narrow
*
* @return The created/existing proxy
*/
private Object returnNarrowedProxy(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext, final Object proxy) {
if (traceEnabled) {
LOG.trace("Enreplacedy proxy found in session cache");
}
LazyInitializer li = ((HibernateProxy) proxy).getHibernateLazyInitializer();
if (li.isUnwrap()) {
return li.getImplementation();
}
Object impl = null;
if (!options.isAllowProxyCreation()) {
impl = load(event, persister, keyToLoad, options);
if (impl == null) {
event.getSession().getFactory().getEnreplacedyNotFoundDelegate().handleEnreplacedyNotFound(persister.getEnreplacedyName(), keyToLoad.getIdentifier());
}
}
return persistenceContext.narrowProxy(proxy, persister, keyToLoad, impl);
}
/**
* If there is already a corresponding proxy replacedociated with the
* persistence context, return it; otherwise create a proxy, replacedociate it
* with the persistence context, and return the just-created proxy.
*
* @param event The initiating load request event
* @param persister The persister corresponding to the enreplacedy to be loaded
* @param keyToLoad The key of the enreplacedy to be loaded
* @param options The defined load options
* @param persistenceContext The originating session
*
* @return The created/existing proxy
*/
private Object createProxyIfNecessary(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext) {
Object existing = persistenceContext.getEnreplacedy(keyToLoad);
if (existing != null) {
// return existing object or initialized proxy (unless deleted)
if (traceEnabled) {
LOG.trace("Enreplacedy found in session cache");
}
if (options.isCheckDeleted()) {
EnreplacedyEntry entry = persistenceContext.getEntry(existing);
Status status = entry.getStatus();
if (status == Status.DELETED || status == Status.GONE) {
return null;
}
}
return existing;
}
if (traceEnabled) {
LOG.trace("Creating new proxy for enreplacedy");
}
// return new uninitialized proxy
Object proxy = persister.createProxy(event.getEnreplacedyId(), event.getSession());
persistenceContext.getBatchFetchQueue().addBatchLoadableEnreplacedyKey(keyToLoad);
persistenceContext.addProxy(keyToLoad, proxy);
return proxy;
}
/**
* If the clreplaced to be loaded has been configured with a cache, then lock
* given id in that cache and then perform the load.
*
* @param event The initiating load request event
* @param persister The persister corresponding to the enreplacedy to be loaded
* @param keyToLoad The key of the enreplacedy to be loaded
* @param options The defined load options
* @param source The originating session
*
* @return The loaded enreplacedy
*
* @throws HibernateException
*/
private Object lockAndLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options, final SessionImplementor source) {
SoftLock lock = null;
final Object ck;
final EnreplacedyDataAccess cache = persister.getCacheAccessStrategy();
if (persister.canWriteToCache()) {
ck = cache.generateCacheKey(event.getEnreplacedyId(), persister, source.getFactory(), source.getTenantIdentifier());
lock = persister.getCacheAccessStrategy().lockItem(source, ck, null);
} else {
ck = null;
}
Object enreplacedy;
try {
enreplacedy = load(event, persister, keyToLoad, options);
} finally {
if (persister.canWriteToCache()) {
cache.unlockItem(source, ck, lock);
}
}
return event.getSession().getPersistenceContext().proxyFor(persister, keyToLoad, enreplacedy);
}
/**
* Coordinates the efforts to load a given enreplacedy. First, an attempt is
* made to load the enreplacedy from the session-level cache. If not found there,
* an attempt is made to locate it in second-level cache. Lastly, an
* attempt is made to load it directly from the datasource.
*
* @param event The load event
* @param persister The persister for the enreplacedy being requested for load
* @param keyToLoad The EnreplacedyKey representing the enreplacedy to be loaded.
* @param options The load options.
*
* @return The loaded enreplacedy, or null.
*/
private Object doLoad(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) {
if (traceEnabled) {
LOG.tracev("Attempting to resolve: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
Object enreplacedy = loadFromSessionCache(event, keyToLoad, options);
if (enreplacedy == REMOVED_ENreplacedY_MARKER) {
LOG.debug("Load request found matching enreplacedy in context, but it is scheduled for removal; returning null");
return null;
}
if (enreplacedy == INCONSISTENT_RTN_CLreplaced_MARKER) {
LOG.debug("Load request found matching enreplacedy in context, but the matched enreplacedy was of an inconsistent return type; returning null");
return null;
}
if (enreplacedy != null) {
if (traceEnabled) {
LOG.tracev("Resolved object in session cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
return enreplacedy;
}
enreplacedy = loadFromSecondLevelCache(event, persister, keyToLoad);
if (enreplacedy != null) {
if (traceEnabled) {
LOG.tracev("Resolved object in second-level cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
} else {
if (traceEnabled) {
LOG.tracev("Object not resolved in any cache: {0}", MessageHelper.infoString(persister, event.getEnreplacedyId(), event.getSession().getFactory()));
}
enreplacedy = loadFromDatasource(event, persister);
}
if (enreplacedy != null && persister.hasNaturalIdentifier()) {
event.getSession().getPersistenceContext().getNaturalIdHelper().cacheNaturalIdCrossReferenceFromLoad(persister, event.getEnreplacedyId(), event.getSession().getPersistenceContext().getNaturalIdHelper().extractNaturalIdValues(enreplacedy, persister));
}
return enreplacedy;
}
/**
* Performs the process of loading an enreplacedy from the configured
* underlying datasource.
*
* @param event The load event
* @param persister The persister for the enreplacedy being requested for load
*
* @return The object loaded from the datasource, or null if not found.
*/
protected Object loadFromDatasource(final LoadEvent event, final EnreplacedyPersister persister) {
Object enreplacedy = persister.load(event.getEnreplacedyId(), event.getInstanceToLoad(), event.getLockOptions(), event.getSession());
if (event.isreplacedociationFetch() && event.getSession().getFactory().getStatistics().isStatisticsEnabled()) {
event.getSession().getFactory().getStatistics().fetchEnreplacedy(event.getEnreplacedyClreplacedName());
}
return enreplacedy;
}
/**
* Attempts to locate the enreplacedy in the session-level cache.
* <p/>
* If allowed to return nulls, then if the enreplacedy happens to be found in
* the session cache, we check the enreplacedy type for proper handling
* of enreplacedy hierarchies.
* <p/>
* If checkDeleted was set to true, then if the enreplacedy is found in the
* session-level cache, it's current status within the session cache
* is checked to see if it has previously been scheduled for deletion.
*
* @param event The load event
* @param keyToLoad The EnreplacedyKey representing the enreplacedy to be loaded.
* @param options The load options.
*
* @return The enreplacedy from the session-level cache, or null.
*
* @throws HibernateException Generally indicates problems applying a lock-mode.
*/
protected Object loadFromSessionCache(final LoadEvent event, final EnreplacedyKey keyToLoad, final LoadEventListener.LoadType options) throws HibernateException {
SessionImplementor session = event.getSession();
Object old = session.getEnreplacedyUsingInterceptor(keyToLoad);
if (old != null) {
// this object was already loaded
EnreplacedyEntry oldEntry = session.getPersistenceContext().getEntry(old);
if (options.isCheckDeleted()) {
Status status = oldEntry.getStatus();
if (status == Status.DELETED || status == Status.GONE) {
return REMOVED_ENreplacedY_MARKER;
}
}
if (options.isAllowNulls()) {
final EnreplacedyPersister persister = event.getSession().getFactory().getEnreplacedyPersister(keyToLoad.getEnreplacedyName());
if (!persister.isInstance(old)) {
return INCONSISTENT_RTN_CLreplaced_MARKER;
}
}
upgradeLock(old, oldEntry, event.getLockOptions(), event.getSession());
}
return old;
}
/**
* Attempts to load the enreplacedy from the second-level cache.
*
* @param event The load event
* @param persister The persister for the enreplacedy being requested for load
*
* @return The enreplacedy from the second-level cache, or null.
*/
private Object loadFromSecondLevelCache(final LoadEvent event, final EnreplacedyPersister persister, final EnreplacedyKey enreplacedyKey) {
final SessionImplementor source = event.getSession();
final boolean useCache = persister.canReadFromCache() && source.getCacheMode().isGetEnabled() && event.getLockMode().lessThan(LockMode.READ);
if (!useCache) {
// we can't use cache here
return null;
}
final Object ce = getFromSharedCache(event, persister, source);
if (ce == null) {
// nothing was found in cache
return null;
}
return processCachedEntry(event, persister, ce, source, enreplacedyKey);
}
private Object processCachedEntry(final LoadEvent event, final EnreplacedyPersister persister, final Object ce, final SessionImplementor source, final EnreplacedyKey enreplacedyKey) {
CacheEntry entry = (CacheEntry) persister.getCacheEntryStructure().destructure(ce, source.getFactory());
if (entry.isReferenceEntry()) {
if (event.getInstanceToLoad() != null) {
throw new HibernateException("Attempt to load enreplacedy [%s] from cache using provided object instance, but cache " + "is storing references: " + event.getEnreplacedyId());
} else {
return convertCacheReferenceEntryToEnreplacedy((ReferenceCacheEntryImpl) entry, event.getSession(), enreplacedyKey);
}
} else {
Object enreplacedy = convertCacheEntryToEnreplacedy(entry, event.getEnreplacedyId(), persister, event, enreplacedyKey);
if (!persister.isInstance(enreplacedy)) {
throw new WrongClreplacedException("loaded object was of wrong clreplaced " + enreplacedy.getClreplaced(), event.getEnreplacedyId(), persister.getEnreplacedyName());
}
return enreplacedy;
}
}
private Object getFromSharedCache(final LoadEvent event, final EnreplacedyPersister persister, SessionImplementor source) {
final EnreplacedyDataAccess cache = persister.getCacheAccessStrategy();
final Object ck = cache.generateCacheKey(event.getEnreplacedyId(), persister, source.getFactory(), source.getTenantIdentifier());
final Object ce = CacheHelper.fromSharedCache(source, ck, persister.getCacheAccessStrategy());
if (source.getFactory().getStatistics().isStatisticsEnabled()) {
if (ce == null) {
source.getFactory().getStatistics().enreplacedyCacheMiss(StatsHelper.INSTANCE.getRootEnreplacedyRole(persister), cache.getRegion().getName());
} else {
source.getFactory().getStatistics().enreplacedyCacheHit(StatsHelper.INSTANCE.getRootEnreplacedyRole(persister), cache.getRegion().getName());
}
}
return ce;
}
private Object convertCacheReferenceEntryToEnreplacedy(ReferenceCacheEntryImpl referenceCacheEntry, EventSource session, EnreplacedyKey enreplacedyKey) {
final Object enreplacedy = referenceCacheEntry.getReference();
if (enreplacedy == null) {
throw new IllegalStateException("Reference cache entry contained null : " + referenceCacheEntry.toString());
} else {
makeEnreplacedyCircularReferenceSafe(referenceCacheEntry, session, enreplacedy, enreplacedyKey);
return enreplacedy;
}
}
private void makeEnreplacedyCircularReferenceSafe(ReferenceCacheEntryImpl referenceCacheEntry, EventSource session, Object enreplacedy, EnreplacedyKey enreplacedyKey) {
// make it circular-reference safe
final StatefulPersistenceContext statefulPersistenceContext = (StatefulPersistenceContext) session.getPersistenceContext();
if ((enreplacedy instanceof ManagedEnreplacedy)) {
statefulPersistenceContext.addReferenceEntry(enreplacedy, Status.READ_ONLY);
} else {
TwoPhaseLoad.addUninitializedCachedEnreplacedy(enreplacedyKey, enreplacedy, referenceCacheEntry.getSubclreplacedPersister(), LockMode.NONE, referenceCacheEntry.getVersion(), session);
}
statefulPersistenceContext.initializeNonLazyCollections();
}
private Object convertCacheEntryToEnreplacedy(CacheEntry entry, Serializable enreplacedyId, EnreplacedyPersister persister, LoadEvent event, EnreplacedyKey enreplacedyKey) {
final EventSource session = event.getSession();
final SessionFactoryImplementor factory = session.getFactory();
final EnreplacedyPersister subclreplacedPersister;
if (traceEnabled) {
LOG.tracef("Converting second-level cache entry [%s] into enreplacedy : %s", entry, MessageHelper.infoString(persister, enreplacedyId, factory));
}
final Object enreplacedy;
subclreplacedPersister = factory.getEnreplacedyPersister(entry.getSubclreplaced());
final Object optionalObject = event.getInstanceToLoad();
enreplacedy = optionalObject == null ? session.instantiate(subclreplacedPersister, enreplacedyId) : optionalObject;
// make it circular-reference safe
TwoPhaseLoad.addUninitializedCachedEnreplacedy(enreplacedyKey, enreplacedy, subclreplacedPersister, LockMode.NONE, entry.getVersion(), session);
final PersistenceContext persistenceContext = session.getPersistenceContext();
final Object[] values;
final Object version;
final boolean isReadOnly;
final Type[] types = subclreplacedPersister.getPropertyTypes();
// initializes the enreplacedy by (desired) side-effect
values = ((StandardCacheEntryImpl) entry).replacedemble(enreplacedy, enreplacedyId, subclreplacedPersister, session.getInterceptor(), session);
if (((StandardCacheEntryImpl) entry).isDeepCopyNeeded()) {
TypeHelper.deepCopy(values, types, subclreplacedPersister.getPropertyUpdateability(), values, session);
}
version = Versioning.getVersion(values, subclreplacedPersister);
LOG.tracef("Cached Version : %s", version);
final Object proxy = persistenceContext.getProxy(enreplacedyKey);
if (proxy != null) {
// there is already a proxy for this impl
// only set the status to read-only if the proxy is read-only
isReadOnly = ((HibernateProxy) proxy).getHibernateLazyInitializer().isReadOnly();
} else {
isReadOnly = session.isDefaultReadOnly();
}
persistenceContext.addEntry(enreplacedy, (isReadOnly ? Status.READ_ONLY : Status.MANAGED), values, null, enreplacedyId, version, LockMode.NONE, true, subclreplacedPersister, false);
subclreplacedPersister.afterInitialize(enreplacedy, session);
persistenceContext.initializeNonLazyCollections();
// PostLoad is needed for EJB3
PostLoadEvent postLoadEvent = event.getPostLoadEvent().setEnreplacedy(enreplacedy).setId(enreplacedyId).setPersister(persister);
for (PostLoadEventListener listener : postLoadEventListeners(session)) {
listener.onPostLoad(postLoadEvent);
}
return enreplacedy;
}
private Iterable<PostLoadEventListener> postLoadEventListeners(EventSource session) {
return session.getFactory().getServiceRegistry().getService(EventListenerRegistry.clreplaced).getEventListenerGroup(EventType.POST_LOAD).listeners();
}
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public <T> T get(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
return delegate.get(theClreplaced, id, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public <T> T load(Clreplaced<T> theClreplaced, Serializable id, LockMode lockMode) {
return delegate.load(theClreplaced, id, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public Object get(String enreplacedyName, Serializable id, LockMode lockMode) {
return delegate.get(enreplacedyName, id, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public void lock(String enreplacedyName, Object object, LockMode lockMode) {
delegate.lock(enreplacedyName, object, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public void lock(Object object, LockMode lockMode) {
delegate.lock(object, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public void refresh(Object object, LockMode lockMode) {
delegate.refresh(object, lockMode);
}
19
Source : SessionDelegatorBaseImpl.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public Object load(String enreplacedyName, Serializable id, LockMode lockMode) {
return delegate.load(enreplacedyName, id, lockMode);
}
19
Source : NativeSQLQueryNonScalarReturn.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Represents the base information for a non-scalar return defined as part of
* a native sql query.
*
* @author Steve Ebersole
*/
public abstract clreplaced NativeSQLQueryNonScalarReturn implements NativeSQLQueryReturn, Serializable {
private final String alias;
private final LockMode lockMode;
private final Map<String, String[]> propertyResults = new HashMap<String, String[]>();
private final int hashCode;
/**
* Constructs some form of non-scalar return descriptor
*
* @param alias The result alias
* @param propertyResults Any user-supplied column->property mappings
* @param lockMode The lock mode to apply to the return.
*/
protected NativeSQLQueryNonScalarReturn(String alias, Map<String, String[]> propertyResults, LockMode lockMode) {
this.alias = alias;
if (alias == null) {
throw new HibernateException("alias must be specified");
}
this.lockMode = lockMode;
if (propertyResults != null) {
this.propertyResults.putAll(propertyResults);
}
this.hashCode = determineHashCode();
}
private int determineHashCode() {
int result = alias != null ? alias.hashCode() : 0;
result = 31 * result + (getClreplaced().getName().hashCode());
result = 31 * result + (lockMode != null ? lockMode.hashCode() : 0);
result = 31 * result + propertyResults.hashCode();
return result;
}
/**
* Retrieve the defined result alias
*
* @return The result alias.
*/
public String getAlias() {
return alias;
}
/**
* Retrieve the lock-mode to apply to this return
*
* @return The lock mode
*/
public LockMode getLockMode() {
return lockMode;
}
/**
* Retrieve the user-supplied column->property mappings.
*
* @return The property mappings.
*/
public Map<String, String[]> getPropertyResultsMap() {
return Collections.unmodifiableMap(propertyResults);
}
@Override
public int hashCode() {
return hashCode;
}
@Override
@SuppressWarnings("RedundantIfStatement")
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClreplaced() != o.getClreplaced()) {
return false;
}
final NativeSQLQueryNonScalarReturn that = (NativeSQLQueryNonScalarReturn) o;
if (alias != null ? !alias.equals(that.alias) : that.alias != null) {
return false;
}
if (lockMode != null ? !lockMode.equals(that.lockMode) : that.lockMode != null) {
return false;
}
if (!propertyResults.equals(that.propertyResults)) {
return false;
}
return true;
}
@Override
public void traceLog(TraceLogger logger) {
if (NativeSQLQueryRootReturn.clreplaced.isInstance(this)) {
logger.writeLine("Enreplacedy(...)");
} else if (NativeSQLQueryCollectionReturn.clreplaced.isInstance(this)) {
logger.writeLine("Collection(...)");
} else if (NativeSQLQueryJoinReturn.clreplaced.isInstance(this)) {
logger.writeLine("Join(...)");
} else {
logger.writeLine(getClreplaced().getName() + "(...)");
}
}
}
19
Source : MutableEntityEntryFactory.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public EnreplacedyEntry createEnreplacedyEntry(Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EnreplacedyPersister persister, boolean disableVersionIncrement, PersistenceContext persistenceContext) {
return new MutableEnreplacedyEntry(status, loadedState, rowId, id, version, lockMode, existsInDatabase, persister, disableVersionIncrement, persistenceContext);
}
19
Source : ImmutableEntityEntryFactory.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
@Override
public EnreplacedyEntry createEnreplacedyEntry(Status status, Object[] loadedState, Object rowId, Serializable id, Object version, LockMode lockMode, boolean existsInDatabase, EnreplacedyPersister persister, boolean disableVersionIncrement, PersistenceContext persistenceContext) {
return new ImmutableEnreplacedyEntry(status, loadedState, rowId, id, version, lockMode, existsInDatabase, persister, disableVersionIncrement, persistenceContext);
}
19
Source : DetachedCriteria.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Set an alias-specific lock mode. The specified lock mode applies only to that alias.
*
* @param alias The alias to apply the lock to
* @param lockMode The lock mode to use.
*
* @return {@code this}, for method chaining
*/
public DetachedCriteria setLockMode(String alias, LockMode lockMode) {
criteria.setLockMode(alias, lockMode);
return this;
}
19
Source : DetachedCriteria.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
/**
* Set the lock mode to use.
*
* @param lockMode The lock mode to use
*
* @return {@code this}, for method chaining
*/
public DetachedCriteria setLockMode(LockMode lockMode) {
criteria.setLockMode(lockMode);
return this;
}
19
Source : LockModeConverter.java
with GNU General Public License v2.0
from lamsfoundation
with GNU General Public License v2.0
from lamsfoundation
public static String toXml(LockMode lockMode) {
return lockMode.toExternalForm();
}
See More Examples