Java DataIntegrityViolationException类代码示例

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
public String deleteBuilding(long buildingId) {

    AssertParam.throwIfNull(buildingId, "buildingId");

    try {
        buildingRepository.delete(buildingId);
        Building deletedBuilding = buildingRepository.findOne(buildingId);
        boolean operationSuccessful = deletedBuilding == null;

        if (operationSuccessful) {
            return ResponseConstants.BUILDING_DELETE_SUCCESS;
        } else {
            return ResponseConstants.BUILDING_DELETE_FAILURE_DB_WRITE;
        }
    } catch (DataIntegrityViolationException e) {
        e.printStackTrace();
        return ResponseConstants.BUILDING_DELETE_FAILURE_CONSTRAINT_VIOLATION;
    }


}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
public String deleteEvaalFile(long evaalFileId) {

    AssertParam.throwIfNull(evaalFileId, "evaalFileId");

    try{
        evaalFileRepository.delete(evaalFileId);
        EvaalFile deletedEvaalFile = evaalFileRepository.findOne(evaalFileId);
        boolean operationSuccess = deletedEvaalFile == null;

        if(operationSuccess){
            return ResponseConstants.EVAAL_DELETE_SUCCESS;
        }else{
            return ResponseConstants.EVAAL_DELETE_FAILURE_DB_WRITE;
        }
    }catch(DataIntegrityViolationException e){
        e.printStackTrace();
        return ResponseConstants.EVAAL_DELETE_FAILURE_CONSTRAINT_VIOLATION;
    }


}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
public JsonResult<User> register(User userToAdd) {

    if (userToAdd.getAccount() == null || !Util.checkEmail(userToAdd.getAccount())) {
        return JsonResult.<User>builder().error("注册帐号错误!").build();
    }

    BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    final String rawPassword = userToAdd.getPassword();
    userToAdd.setPassword(encoder.encode(rawPassword));
    userToAdd.setLastPasswordResetDate(new Date());
    Role userRole = roleRepository.findByName("ROLE_USER");
    if (userRole == null){
        userRole = roleRepository.save(new Role("ROLE_USER"));
    }
    userToAdd.setRoles(Collections.singletonList(userRole));
    try {
        return JsonResult.<User>builder().data(userRepository.save(userToAdd)).build();
    } catch (DataIntegrityViolationException e) {
        logger.debug(e.getMessage());
        return JsonResult.<User>builder().error(e.getRootCause().getMessage()).build();
    }
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
public Serializable getPropertyById(Long id)
{
    if (id == null)
    {
        throw new IllegalArgumentException("Cannot look up entity by null ID.");
    }
    Pair<Long, Serializable> entityPair = propertyCache.getByKey(id);
    if (entityPair == null)
    {
        // Remove from cache
        propertyCache.removeByKey(id);
        
        throw new DataIntegrityViolationException("No property value exists for ID " + id);
    }
    return entityPair.getSecond();
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
/**
 * Updates a property.  The <b>alf_prop_root</b> entity is updated
 * to ensure concurrent modification is detected.
 * 
 * @return              Returns 1 always
 */
@Override
public int updateValue(Long key, Serializable value)
{
    // Remove all entries for the root
    PropertyRootEntity entity = getPropertyRoot(key);
    if (entity == null)
    {
        throw new DataIntegrityViolationException("No property root exists for ID " + key);
    }
    // Remove all links using the root
    deletePropertyLinks(key);
    // Create the new properties and update the cache
    createPropertyImpl(key, 0L, 0L, null, value);
    // Update the property root to detect concurrent modification
    updatePropertyRoot(entity);
    // Done
    if (logger.isDebugEnabled())
    {
        logger.debug(
                "Updated property: \n" +
                "   ID: " + key + "\n" +
                "   Value: " + value);
    }
    return 1;
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
public void updateAuditApplicationModel(Long id, Long modelId)
{
    AuditApplicationEntity entity = getAuditApplicationById(id);
    if (entity == null)
    {
        throw new DataIntegrityViolationException("No audit application exists for ID " + id);
    }
    if (entity.getAuditModelId().equals(modelId))
    {
        // There is nothing to update
        return;
    }
    // Update
    entity.setAuditModelId(modelId);
    updateAuditApplication(entity);
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void updateAuditApplicationDisabledPaths(Long id, Set<String> disabledPaths)
{
    AuditApplicationEntity entity = getAuditApplicationById(id);
    if (entity == null)
    {
        throw new DataIntegrityViolationException("No audit application exists for ID " + id);
    }
    // Resolve the current set
    Long disabledPathsId = entity.getDisabledPathsId();
    Set<String> oldDisabledPaths = (Set<String>) propertyValueDAO.getPropertyById(disabledPathsId);
    if (oldDisabledPaths.equals(disabledPaths))
    {
        // Nothing changed
        return;
    }
    // Update the property
    propertyValueDAO.updateProperty(disabledPathsId, (Serializable) disabledPaths);
    // Do a precautionary update to ensure that the application row is locked appropriately
    updateAuditApplication(entity);
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
public void updateNamespace(String oldNamespaceUri, String newNamespaceUri)
{
    ParameterCheck.mandatory("newNamespaceUri", newNamespaceUri);

    Pair<Long, String> oldEntityPair = getNamespace(oldNamespaceUri);   // incl. null check
    if (oldEntityPair == null)
    {
        throw new DataIntegrityViolationException(
                "Cannot update namespace as it doesn't exist: " + oldNamespaceUri);
    }
    // Find the value
    int updated = namespaceCache.updateValue(oldEntityPair.getFirst(), newNamespaceUri);
    if (updated != 1)
    {
        throw new ConcurrencyFailureException(
                "Incorrect update count: \n" +
                "   Namespace:    " + oldNamespaceUri + "\n" +
                "   Rows Updated: " + updated);
    }
    // All the QNames need to be dumped
    qnameCache.clear();
    // Done
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
protected int deleteContentDataEntity(Long id)
{
    // Get the content urls
    try
    {
        ContentData contentData = getContentData(id).getSecond();
        String contentUrl = contentData.getContentUrl();
        if (contentUrl != null)
        {
            // It has been dereferenced and may be orphaned - we'll check later
            registerDereferencedContentUrl(contentUrl);
        }
    }
    catch (DataIntegrityViolationException e)
    {
        // Doesn't exist.  The node doesn't enforce a FK constraint, so we protect against this.
    }
    // Issue the delete statement
    Map<String, Object> params = new HashMap<String, Object>(11);
    params.put("id", id);
    return template.delete(DELETE_CONTENT_DATA, params);
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
public Pair<NodeVersionKey, Set<QName>> findByKey(NodeVersionKey nodeVersionKey)
{
    Long nodeId = nodeVersionKey.getNodeId();
    Set<Long> nodeIds = Collections.singleton(nodeId);
    Map<NodeVersionKey, Set<QName>> nodeAspectQNameIdsByVersionKey = selectNodeAspects(nodeIds);
    Set<QName> nodeAspectQNames = nodeAspectQNameIdsByVersionKey.get(nodeVersionKey);
    if (nodeAspectQNames == null)
    {
        // Didn't find a match.  Is this because there are none?
        if (nodeAspectQNameIdsByVersionKey.size() == 0)
        {
            // This is OK.  The node has no properties
            nodeAspectQNames = Collections.emptySet();
        }
        else
        {
            // We found properties associated with a different node ID and version
            invalidateNodeCaches(nodeId);
            throw new DataIntegrityViolationException(
                    "Detected stale node entry: " + nodeVersionKey +
                    " (now " + nodeAspectQNameIdsByVersionKey.keySet() + ")");
        }
    }
    // Done
    return new Pair<NodeVersionKey, Set<QName>>(nodeVersionKey, Collections.unmodifiableSet(nodeAspectQNames));
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
private void refreshFromGameAdminData(String address, Map<String, String> data) {
    String subId = data.get("SUBID");
    String name = data.get("name");

    GameServer server = gameServerRepository.findByAddress(address).orElseGet(this::newGameServer);

    boolean changed = !server.getId().equals(subId)
        || !server.getName().equals(name)
        || !server.getAddress().equals(address);

    server.setId(subId);
    server.setAddress(address);
    server.setName(name);
    try {
        server = gameServerRepository.save(server);
        if (changed) {
            initServerMetrics(server);
        }
    } catch (DataIntegrityViolationException e) {
        log.warn("Unable to update server data", e);
    }
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
/**
 * Maps and handles custom behavior in the Edit page (POST mode)
 * @param message The information that is bound to the HTML form and used to update the database
 * @return Custom message sent to the client - in this case, a redirect
 */
@RequestMapping(value="/edit", method=RequestMethod.POST)
public String submit(@ModelAttribute Message message)
{
    try
    {
        String username = Util.getUsername();
        message.setUsername(username);

        message = encryptMessage(message);
        messageRepository.save(message);

        // TO-DO: redirect and show a success message
        return "redirect:/cpanel.html";
    }
    catch(DataIntegrityViolationException ex) // message is too long for DB field
    {
        return "redirect:/edit?error";
    }
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
public void process(ResultItems resultItems, Task task) {
    List<IndustryInfo> industryInfos = resultItems.get("industryInfos");
    if (industryInfos != null && industryInfos.size() > 0) {
        for (IndustryInfo industryInfo : industryInfos) {
            try {
                industryInfoDao.add(industryInfo);
            } catch (Exception e) {
                if (e instanceof DataIntegrityViolationException) {

                } else {
                    e.printStackTrace();
                }
            }
        }
    }
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
@Transactional(propagation = Propagation.MANDATORY)
public void renameTermValue(Term term, String newValue)
{
	final Taxonomy taxonomy = term.getTaxonomy();

	newValue = newValue.trim();
	checkTermValue(newValue, taxonomy, term.getParent());

	term.setValue(newValue);
	try
	{
		save(term);	
		invalidateFullValues(term);
		updateFullValues(taxonomy);
	}catch(DataIntegrityViolationException e2){
		throw new DataIntegrityViolationException("SIBLING_CHECK");			
	}
}
 

import org.springframework.dao.DataIntegrityViolationException; //导入依赖的package包/类
@Override
protected DataAccessException doTranslate(String task, String sql, SQLException ex) {
	String sqlState = getSqlState(ex);
	if (sqlState != null && sqlState.length() >= 2) {
		String classCode = sqlState.substring(0, 2);
		if (logger.isDebugEnabled()) {
			logger.debug("Extracted SQL state class '" + classCode + "' from value '" + sqlState + "'");
		}
		if (BAD_SQL_GRAMMAR_CODES.contains(classCode)) {
			return new BadSqlGrammarException(task, sql, ex);
		}
		else if (DATA_INTEGRITY_VIOLATION_CODES.contains(classCode)) {
			return new DataIntegrityViolationException(buildMessage(task, sql, ex), ex);
		}
		else if (DATA_ACCESS_RESOURCE_FAILURE_CODES.contains(classCode)) {
			return new DataAccessResourceFailureException(buildMessage(task, sql, ex), ex);
		}
		else if (TRANSIENT_DATA_ACCESS_RESOURCE_CODES.contains(classCode)) {
			return new TransientDataAccessResourceException(buildMessage(task, sql, ex), ex);
		}
		else if (CONCURRENCY_FAILURE_CODES.contains(classCode)) {
			return new ConcurrencyFailureException(buildMessage(task, sql, ex), ex);
		}
	}
	return null;
}