@Override
protected String applyLocks(
String sql,
QueryParameters parameters,
Dialect dialect,
List<AfterLoadAction> afterLoadActions)
throws QueryException {
final LockOptions lockOptions = parameters.getLockOptions();
if (lockOptions == null
|| (lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0)) {
return sql;
}
// user is request locking, lets see if we can apply locking directly to the SQL...
// some dialects wont allow locking with paging...
afterLoadActions.add(
new AfterLoadAction() {
private final LockOptions originalLockOptions = lockOptions.makeCopy();
@Override
public void afterLoad(SessionImplementor session, Object entity, Loadable persister) {
((Session) session)
.buildLockRequest(originalLockOptions)
.lock(persister.getEntityName(), entity);
}
});
parameters.getLockOptions().setLockMode(LockMode.READ);
return sql;
}
@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {
// unfortunately this stuff can't be cached because
// it is per-invocation, not constant for the
// QueryTranslator instance
HashMap nameLockOptions = new HashMap();
if (lockOptions == null) {
lockOptions = LockOptions.NONE;
}
if (lockOptions.getAliasLockCount() > 0) {
Iterator iter = lockOptions.getAliasLockIterator();
while (iter.hasNext()) {
Map.Entry me = (Map.Entry) iter.next();
nameLockOptions.put(getAliasName((String) me.getKey()), me.getValue());
}
}
LockMode[] lockModesArray = new LockMode[names.length];
for (int i = 0; i < names.length; i++) {
LockMode lm = (LockMode) nameLockOptions.get(names[i]);
// if ( lm == null ) lm = LockOptions.NONE;
if (lm == null) lm = lockOptions.getLockMode();
lockModesArray[i] = lm;
}
return lockModesArray;
}
protected PersistenceException wrapLockException(HibernateException e, LockOptions lockOptions) {
final PersistenceException pe;
if (e instanceof OptimisticEntityLockException) {
final OptimisticEntityLockException lockException = (OptimisticEntityLockException) e;
pe =
new OptimisticLockException(
lockException.getMessage(), lockException, lockException.getEntity());
} else if (e instanceof org.hibernate.exception.LockTimeoutException) {
pe = new LockTimeoutException(e.getMessage(), e, null);
} else if (e instanceof PessimisticEntityLockException) {
final PessimisticEntityLockException lockException = (PessimisticEntityLockException) e;
if (lockOptions != null && lockOptions.getTimeOut() > -1) {
// assume lock timeout occurred if a timeout or NO WAIT was specified
pe =
new LockTimeoutException(
lockException.getMessage(), lockException, lockException.getEntity());
} else {
pe =
new PessimisticLockException(
lockException.getMessage(), lockException, lockException.getEntity());
}
} else if (e instanceof org.hibernate.PessimisticLockException) {
final org.hibernate.PessimisticLockException jdbcLockException =
(org.hibernate.PessimisticLockException) e;
if (lockOptions != null && lockOptions.getTimeOut() > -1) {
// assume lock timeout occurred if a timeout or NO WAIT was specified
pe = new LockTimeoutException(jdbcLockException.getMessage(), jdbcLockException, null);
} else {
pe = new PessimisticLockException(jdbcLockException.getMessage(), jdbcLockException, null);
}
} else {
pe = new OptimisticLockException(e);
}
return pe;
}
public QueryParameters getQueryParameters() {
LockOptions lockOptions = new LockOptions();
RowSelection selection = new RowSelection();
selection.setFirstRow(rootCriteria.getFirstResult());
selection.setMaxRows(rootCriteria.getMaxResults());
selection.setTimeout(rootCriteria.getTimeout());
selection.setFetchSize(rootCriteria.getFetchSize());
final Map<String, LockMode> lockModeMap = rootCriteria.getLockModes();
for (final String key : lockModeMap.keySet()) {
final Criteria subcriteria = getAliasedCriteria(key);
lockOptions.setAliasSpecificLockMode(getSQLAlias(subcriteria), lockModeMap.get(key));
}
final List<Object> values = new ArrayList<Object>();
final List<Type> types = new ArrayList<Type>();
final Iterator<CriteriaImpl.Subcriteria> subcriteriaIterator =
rootCriteria.iterateSubcriteria();
while (subcriteriaIterator.hasNext()) {
CriteriaImpl.Subcriteria subcriteria = subcriteriaIterator.next();
LockMode lm = subcriteria.getLockMode();
if (lm != null) {
lockOptions.setAliasSpecificLockMode(getSQLAlias(subcriteria), lm);
}
if (subcriteria.getWithClause() != null) {
TypedValue[] tv = subcriteria.getWithClause().getTypedValues(subcriteria, this);
for (TypedValue aTv : tv) {
values.add(aTv.getValue());
types.add(aTv.getType());
}
}
}
// Type and value gathering for the WHERE clause needs to come AFTER lock mode gathering,
// because the lock mode gathering loop now contains join clauses which can contain
// parameter bindings (as in the HQL WITH clause).
Iterator<CriteriaImpl.CriterionEntry> iter = rootCriteria.iterateExpressionEntries();
while (iter.hasNext()) {
CriteriaImpl.CriterionEntry ce = iter.next();
TypedValue[] tv = ce.getCriterion().getTypedValues(ce.getCriteria(), this);
for (TypedValue aTv : tv) {
values.add(aTv.getValue());
types.add(aTv.getType());
}
}
Object[] valueArray = values.toArray();
Type[] typeArray = ArrayHelper.toTypeArray(types);
return new QueryParameters(
typeArray,
valueArray,
lockOptions,
selection,
rootCriteria.isReadOnlyInitialized(),
(rootCriteria.isReadOnlyInitialized() && rootCriteria.isReadOnly()),
rootCriteria.getCacheable(),
rootCriteria.getCacheRegion(),
rootCriteria.getComment(),
rootCriteria.getQueryHints(),
rootCriteria.isLookupByNaturalKey(),
rootCriteria.getResultTransformer());
}
public QueryParameters getQueryParameters() {
LockOptions lockOptions = new LockOptions();
RowSelection selection = new RowSelection();
selection.setFirstRow(rootCriteria.getFirstResult());
selection.setMaxRows(rootCriteria.getMaxResults());
selection.setTimeout(rootCriteria.getTimeout());
selection.setFetchSize(rootCriteria.getFetchSize());
Iterator iter = rootCriteria.getLockModes().entrySet().iterator();
while (iter.hasNext()) {
Map.Entry me = (Map.Entry) iter.next();
final Criteria subcriteria = getAliasedCriteria((String) me.getKey());
lockOptions.setAliasSpecificLockMode(getSQLAlias(subcriteria), (LockMode) me.getValue());
}
List values = new ArrayList();
List types = new ArrayList();
iter = rootCriteria.iterateSubcriteria();
while (iter.hasNext()) {
CriteriaImpl.Subcriteria subcriteria = (CriteriaImpl.Subcriteria) iter.next();
LockMode lm = subcriteria.getLockMode();
if (lm != null) {
lockOptions.setAliasSpecificLockMode(getSQLAlias(subcriteria), lm);
}
if (subcriteria.getWithClause() != null) {
TypedValue[] tv = subcriteria.getWithClause().getTypedValues(subcriteria, this);
for (int i = 0; i < tv.length; i++) {
values.add(tv[i].getValue());
types.add(tv[i].getType());
}
}
}
// Type and value gathering for the WHERE clause needs to come AFTER lock mode gathering,
// because the lock mode gathering loop now contains join clauses which can contain
// parameter bindings (as in the HQL WITH clause).
iter = rootCriteria.iterateExpressionEntries();
while (iter.hasNext()) {
CriteriaImpl.CriterionEntry ce = (CriteriaImpl.CriterionEntry) iter.next();
TypedValue[] tv = ce.getCriterion().getTypedValues(ce.getCriteria(), this);
for (int i = 0; i < tv.length; i++) {
values.add(tv[i].getValue());
types.add(tv[i].getType());
}
}
Object[] valueArray = values.toArray();
Type[] typeArray = ArrayHelper.toTypeArray(types);
return new QueryParameters(
typeArray,
valueArray,
lockOptions,
selection,
rootCriteria.isReadOnlyInitialized(),
(rootCriteria.isReadOnlyInitialized() ? rootCriteria.isReadOnly() : false),
rootCriteria.getCacheable(),
rootCriteria.getCacheRegion(),
rootCriteria.getComment(),
rootCriteria.isLookupByNaturalKey(),
rootCriteria.getResultTransformer());
}
public LockOptions getLockRequest(LockModeType lockModeType, Map<String, Object> properties) {
LockOptions lockOptions = new LockOptions();
LockOptions.copy(this.lockOptions, lockOptions);
lockOptions.setLockMode(getLockMode(lockModeType));
if (properties != null) {
setLockOptions(properties, lockOptions);
}
return lockOptions;
}
private Query applyProperties(Query query) {
if (lockOptions.getLockMode() != LockMode.NONE) {
query.setLockMode(getLockMode(lockOptions.getLockMode()));
}
Object queryTimeout;
if ((queryTimeout = getProperties().get(QueryHints.SPEC_HINT_TIMEOUT)) != null) {
query.setHint(QueryHints.SPEC_HINT_TIMEOUT, queryTimeout);
}
return query;
}
protected void initPersisters(
final List associations,
final LockOptions lockOptions,
final AssociationInitCallback callback)
throws MappingException {
final int joins = countEntityPersisters(associations);
final int collections = countCollectionPersisters(associations);
collectionOwners = collections == 0 ? null : new int[collections];
collectionPersisters = collections == 0 ? null : new CollectionPersister[collections];
collectionSuffixes = BasicLoader.generateSuffixes(joins + 1, collections);
this.lockOptions = lockOptions;
persisters = new Loadable[joins];
aliases = new String[joins];
owners = new int[joins];
ownerAssociationTypes = new EntityType[joins];
lockModeArray = ArrayHelper.fillArray(lockOptions.getLockMode(), joins);
int i = 0;
int j = 0;
Iterator iter = associations.iterator();
while (iter.hasNext()) {
final OuterJoinableAssociation oj = (OuterJoinableAssociation) iter.next();
if (!oj.isCollection()) {
persisters[i] = (Loadable) oj.getJoinable();
aliases[i] = oj.getRHSAlias();
owners[i] = oj.getOwner(associations);
ownerAssociationTypes[i] = (EntityType) oj.getJoinableType();
callback.associationProcessed(oj, i);
i++;
} else {
QueryableCollection collPersister = (QueryableCollection) oj.getJoinable();
if (oj.getJoinType() == JoinType.LEFT_OUTER_JOIN && !oj.hasRestriction()) {
// it must be a collection fetch
collectionPersisters[j] = collPersister;
collectionOwners[j] = oj.getOwner(associations);
j++;
}
if (collPersister.isOneToMany()) {
persisters[i] = (Loadable) collPersister.getElementPersister();
aliases[i] = oj.getRHSAlias();
callback.associationProcessed(oj, i);
i++;
}
}
}
if (ArrayHelper.isAllNegative(owners)) owners = null;
if (collectionOwners != null && ArrayHelper.isAllNegative(collectionOwners)) {
collectionOwners = null;
}
}
/* 77: */
/* 78: */ protected String generateLockString(int lockTimeout) /* 79: */ {
/* 80:122 */ SessionFactoryImplementor factory = getLockable().getFactory();
/* 81:123 */ LockOptions lockOptions = new LockOptions(getLockMode());
/* 82:124 */ lockOptions.setTimeOut(lockTimeout);
/* 83:125 */ SimpleSelect select =
new SimpleSelect(factory.getDialect())
.setLockOptions(lockOptions)
.setTableName(getLockable().getRootTableName())
.addColumn(getLockable().getRootTableIdentifierColumnNames()[0])
.addCondition(getLockable().getRootTableIdentifierColumnNames(), "=?");
/* 84:130 */ if (getLockable().isVersioned()) {
/* 85:131 */ select.addCondition(getLockable().getVersionColumnName(), "=?");
/* 86: */ }
/* 87:133 */ if (factory.getSettings().isCommentsEnabled()) {
/* 88:134 */ select.setComment(getLockMode() + " lock " + getLockable().getEntityName());
/* 89: */ }
/* 90:136 */ return select.toStatementString();
/* 91: */ }
protected String generateLockString(int lockTimeout) {
SessionFactoryImplementor factory = getLockable().getFactory();
LockOptions lockOptions = new LockOptions(getLockMode());
lockOptions.setTimeOut(lockTimeout);
SimpleSelect select =
new SimpleSelect(factory.getDialect())
.setLockOptions(lockOptions)
.setTableName(getLockable().getRootTableName())
.addColumn(getLockable().getRootTableIdentifierColumnNames()[0])
.addCondition(getLockable().getRootTableIdentifierColumnNames(), "=?");
if (getLockable().isVersioned()) {
select.addCondition(getLockable().getVersionColumnName(), "=?");
}
if (factory.getSettings().isCommentsEnabled()) {
select.setComment(getLockMode() + " lock " + getLockable().getEntityName());
}
return select.toStatementString();
}
private void setLockOptions(Map<String, Object> props, LockOptions options) {
Object lockScope = props.get(AvailableSettings.LOCK_SCOPE);
if (lockScope instanceof String
&& PessimisticLockScope.valueOf((String) lockScope) == PessimisticLockScope.EXTENDED) {
options.setScope(true);
} else if (lockScope instanceof PessimisticLockScope) {
boolean extended = PessimisticLockScope.EXTENDED.equals((PessimisticLockScope) lockScope);
options.setScope(extended);
} else if (lockScope != null) {
throw new PersistenceException(
"Unable to parse " + AvailableSettings.LOCK_SCOPE + ": " + lockScope);
}
Object lockTimeout = props.get(AvailableSettings.LOCK_TIMEOUT);
int timeout = 0;
boolean timeoutSet = false;
if (lockTimeout instanceof String) {
timeout = Integer.parseInt((String) lockTimeout);
timeoutSet = true;
} else if (lockTimeout instanceof Number) {
timeout = ((Number) lockTimeout).intValue();
timeoutSet = true;
} else if (lockTimeout != null) {
throw new PersistenceException(
"Unable to parse " + AvailableSettings.LOCK_TIMEOUT + ": " + lockTimeout);
}
if (timeoutSet) {
if (timeout < 0) {
options.setTimeOut(LockOptions.WAIT_FOREVER);
} else if (timeout == 0) {
options.setTimeOut(LockOptions.NO_WAIT);
} else {
options.setTimeOut(timeout);
}
}
}
public PersistenceException wrapLockException(HibernateException e, LockOptions lockOptions) {
PersistenceException pe;
if (e instanceof org.hibernate.OptimisticLockException) {
org.hibernate.OptimisticLockException ole = (org.hibernate.OptimisticLockException) e;
pe = new OptimisticLockException(ole.getMessage(), ole, ole.getEntity());
} else if (e instanceof org.hibernate.PessimisticLockException) {
org.hibernate.PessimisticLockException ple = (org.hibernate.PessimisticLockException) e;
if (lockOptions != null && lockOptions.getTimeOut() > -1) {
// assume lock timeout occurred if a timeout or NO WAIT was specified
pe = new LockTimeoutException(ple.getMessage(), ple, ple.getEntity());
} else {
pe = new PessimisticLockException(ple.getMessage(), ple, ple.getEntity());
}
} else {
pe = new OptimisticLockException(e);
}
return pe;
}
@Override
public String applyLocksToSql(String sql, LockOptions aliasedLockOptions, Map keyColumnNames) {
// TODO: merge additional lockoptions support in Dialect.applyLocksToSql
final Iterator itr = aliasedLockOptions.getAliasLockIterator();
final StringBuilder buffer = new StringBuilder(sql);
int correction = 0;
while (itr.hasNext()) {
final Map.Entry entry = (Map.Entry) itr.next();
final LockMode lockMode = (LockMode) entry.getValue();
if (lockMode.greaterThan(LockMode.READ)) {
final String alias = (String) entry.getKey();
int start = -1;
int end = -1;
if (sql.endsWith(" " + alias)) {
start = (sql.length() - alias.length()) + correction;
end = start + alias.length();
} else {
int position = sql.indexOf(" " + alias + " ");
if (position <= -1) {
position = sql.indexOf(" " + alias + ",");
}
if (position > -1) {
start = position + correction + 1;
end = start + alias.length();
}
}
if (start > -1) {
final String lockHint = appendLockHint(lockMode, alias);
buffer.replace(start, end, lockHint);
correction += (lockHint.length() - alias.length());
}
}
}
return buffer.toString();
}
@Override
public String appendLockHint(LockOptions lockOptions, String tableName) {
return lockOptions.getLockMode().greaterThan(LockMode.READ)
? tableName + " holdlock"
: tableName;
}
@Override
protected String applyLocks(
String sql,
QueryParameters parameters,
Dialect dialect,
List<AfterLoadAction> afterLoadActions)
throws QueryException {
// can't cache this stuff either (per-invocation)
final LockOptions lockOptions = parameters.getLockOptions();
final String result;
if (lockOptions == null
|| (lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0)) {
return sql;
} else {
LockOptions locks = new LockOptions();
locks.setLockMode(lockOptions.getLockMode());
locks.setTimeOut(lockOptions.getTimeOut());
locks.setScope(lockOptions.getScope());
Iterator iter = lockOptions.getAliasLockIterator();
while (iter.hasNext()) {
Map.Entry me = (Map.Entry) iter.next();
locks.setAliasSpecificLockMode(
getAliasName((String) me.getKey()), (LockMode) me.getValue());
}
Map keyColumnNames = null;
if (dialect.forUpdateOfColumns()) {
keyColumnNames = new HashMap();
for (int i = 0; i < names.length; i++) {
keyColumnNames.put(names[i], persisters[i].getIdentifierColumnNames());
}
}
result = dialect.applyLocksToSql(sql, locks, keyColumnNames);
}
logQuery(queryString, result);
return result;
}
/**
* @see EntityPersister#load(Serializable, Object, org.hibernate.LockOptions , SessionImplementor)
*/
public Object load(
Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session)
throws HibernateException {
return load(id, optionalObject, lockOptions.getLockMode(), session);
}