import javax.jdo.JDODataStoreException; //导入依赖的package包/类
/**
 * Convert the given JDOException to an appropriate exception from the
 * {@code org.springframework.dao} hierarchy.
 * <p>The most important cases like object not found or optimistic locking failure
 * are covered here. For more fine-granular conversion, JdoTransactionManager
 * supports sophisticated translation of exceptions via a JdoDialect.
 * @param ex JDOException that occured
 * @return the corresponding DataAccessException instance
 * @see JdoTransactionManager#convertJdoAccessException
 * @see JdoDialect#translateException
 */
public static DataAccessException convertJdoAccessException(JDOException ex) {
	if (ex instanceof JDOObjectNotFoundException) {
		throw new JdoObjectRetrievalFailureException((JDOObjectNotFoundException) ex);
	}
	if (ex instanceof JDOOptimisticVerificationException) {
		throw new JdoOptimisticLockingFailureException((JDOOptimisticVerificationException) ex);
	}
	if (ex instanceof JDODataStoreException) {
		return new JdoResourceFailureException((JDODataStoreException) ex);
	}
	if (ex instanceof JDOFatalDataStoreException) {
		return new JdoResourceFailureException((JDOFatalDataStoreException) ex);
	}
	if (ex instanceof JDOUserException) {
		return new JdoUsageException((JDOUserException) ex);
	}
	if (ex instanceof JDOFatalUserException) {
		return new JdoUsageException((JDOFatalUserException) ex);
	}
	// fallback
	return new JdoSystemException(ex);
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
private static void runWithOneAutoCreateRetry(Consumer<Boolean> r) {
	boolean autoCreate = true;//Set to false to try first without autoCreate
	boolean exception = true;
	while (exception) {
		try {
			r.accept(autoCreate);
			exception = false;
		} catch (MissingTableException | JDODataStoreException e) {
			if (autoCreate) {
				throw e;
			} else {
				autoCreate = true;
			}
		}
	}
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
protected static String getMessageFromCause(Throwable cause) {
    String message = "Persistence error";
    if (cause instanceof ConstraintViolationException) {
        Set<ConstraintViolation<?>> violations = ((ConstraintViolationException) cause).getConstraintViolations();
        message = "";
        for (ConstraintViolation violation : violations) {
            message += (String.format("Field %s %s\n", violation.getPropertyPath(), violation.getMessage()));
        }
    } else if (cause instanceof JDODataStoreException) {
        for (Throwable exception : ((JDODataStoreException) cause).getNestedExceptions()) {
            if (exception instanceof SQLIntegrityConstraintViolationException) {
                message = exception.getMessage();
                break;
            }
        }
    }
    return message;
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
/**
 * Convert the given JDOException to an appropriate exception from the
 * {@code org.springframework.dao} hierarchy.
 * <p>The most important cases like object not found or optimistic locking
 * failure are covered here. For more fine-granular conversion, JdoAccessor and
 * JdoTransactionManager support sophisticated translation of exceptions via a
 * JdoDialect.
 * @param ex JDOException that occured
 * @return the corresponding DataAccessException instance
 * @see JdoAccessor#convertJdoAccessException
 * @see JdoTransactionManager#convertJdoAccessException
 * @see JdoDialect#translateException
 */
public static DataAccessException convertJdoAccessException(JDOException ex) {
	if (ex instanceof JDOObjectNotFoundException) {
		throw new JdoObjectRetrievalFailureException((JDOObjectNotFoundException) ex);
	}
	if (ex instanceof JDOOptimisticVerificationException) {
		throw new JdoOptimisticLockingFailureException((JDOOptimisticVerificationException) ex);
	}
	if (ex instanceof JDODataStoreException) {
		return new JdoResourceFailureException((JDODataStoreException) ex);
	}
	if (ex instanceof JDOFatalDataStoreException) {
		return new JdoResourceFailureException((JDOFatalDataStoreException) ex);
	}
	if (ex instanceof JDOUserException) {
		return new JdoUsageException((JDOUserException) ex);
	}
	if (ex instanceof JDOFatalUserException) {
		return new JdoUsageException((JDOFatalUserException) ex);
	}
	// fallback
	return new JdoSystemException(ex);
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
private void assertNotRollbackOnly()
{
    if (rollbackOnlyFlag)
    {
        throw new JDODataStoreException("Rollback Only !");
    }
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
@Test
public void alreadyExists() throws Exception {

    // then
    expectedExceptions.expect(ThrowableMatchers.causalChainContains(JDODataStoreException.class));

    // given
    applicationUserMenu.newDelegateUser("fred", null, true);

    // when
    applicationUserMenu.newDelegateUser("fred", null, true);
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
@Test
public void when_name_already_in_use() {
    // given
    Taxonomy italianColours = (Taxonomy) categoryRepository.findByReference("ITACOL");
    assertThat(italianColours.getName()).isEqualTo("Italian Colours");
    sessionManagementService.nextSession();

    // then
    expectedException.expect(JDODataStoreException.class);
    expectedException.expectMessage("Classification_fullyQualifiedName_UNQ");

    // when
    categoryRepository.createTaxonomy("Italian Colours");
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private MSentryVersion getMSentryVersion()
    throws SentryNoSuchObjectException, SentryAccessDeniedException {
  boolean rollbackTransaction = true;
  PersistenceManager pm = null;
  try {
    pm = openTransaction();
    Query query = pm.newQuery(MSentryVersion.class);
    List<MSentryVersion> mSentryVersions = (List<MSentryVersion>) query
        .execute();
    pm.retrieveAll(mSentryVersions);
    rollbackTransaction = false;
    commitTransaction(pm);
    if (mSentryVersions.isEmpty()) {
      throw new SentryNoSuchObjectException("No matching version found");
    }
    if (mSentryVersions.size() > 1) {
      throw new SentryAccessDeniedException(
          "Metastore contains multiple versions");
    }
    return mSentryVersions.get(0);
  } catch (JDODataStoreException e) {
    if (e.getCause() instanceof MissingTableException) {
      throw new SentryAccessDeniedException("Version table not found. "
          + "The sentry store is not set or corrupt ");
    } else {
      throw e;
    }
  } finally {
    if (rollbackTransaction) {
      rollbackTransaction(pm);
    }
  }
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
/**
 * Drop given privilege from all roles
 */
public void dropPrivilege(TSentryAuthorizable tAuthorizable)
    throws SentryNoSuchObjectException, SentryInvalidInputException {
  PersistenceManager pm = null;
  boolean rollbackTransaction = true;

  TSentryPrivilege tPrivilege = toSentryPrivilege(tAuthorizable);
  try {
    pm = openTransaction();

    if (isMultiActionsSupported(tPrivilege)) {
      for (String privilegeAction : ALL_ACTIONS) {
        tPrivilege.setAction(privilegeAction);
        dropPrivilegeForAllRoles(pm, new TSentryPrivilege(tPrivilege));
      }
    } else {
      dropPrivilegeForAllRoles(pm, new TSentryPrivilege(tPrivilege));
    }
    rollbackTransaction = false;
    commitTransaction(pm);
  } catch (JDODataStoreException e) {
    throw new SentryInvalidInputException("Failed to get privileges: "
        + e.getMessage());
  } finally {
    if (rollbackTransaction) {
      rollbackTransaction(pm);
    }
  }
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
/**
 * Rename given privilege from all roles drop the old privilege and create the new one
 * @param tAuthorizable
 * @param newTAuthorizable
 * @throws SentryNoSuchObjectException
 * @throws SentryInvalidInputException
 */
public void renamePrivilege(TSentryAuthorizable tAuthorizable,
    TSentryAuthorizable newTAuthorizable)
    throws SentryNoSuchObjectException, SentryInvalidInputException {
  PersistenceManager pm = null;
  boolean rollbackTransaction = true;

  TSentryPrivilege tPrivilege = toSentryPrivilege(tAuthorizable);
  TSentryPrivilege newPrivilege = toSentryPrivilege(newTAuthorizable);

  try {
    pm = openTransaction();
    // In case of tables or DBs, check all actions
    if (isMultiActionsSupported(tPrivilege)) {
      for (String privilegeAction : ALL_ACTIONS) {
        tPrivilege.setAction(privilegeAction);
        newPrivilege.setAction(privilegeAction);
        renamePrivilegeForAllRoles(pm, tPrivilege, newPrivilege);
      }
    } else {
      renamePrivilegeForAllRoles(pm, tPrivilege, newPrivilege);
    }
    rollbackTransaction = false;
    commitTransaction(pm);
  } catch (JDODataStoreException e) {
    throw new SentryInvalidInputException("Failed to get privileges: "
        + e.getMessage());
  } finally {
    if (rollbackTransaction) {
      rollbackTransaction(pm);
    }
  }
}
 

import javax.jdo.JDODataStoreException; //导入依赖的package包/类
public JdoResourceFailureException(JDODataStoreException ex) {
	super(ex.getMessage(), ex);
}