org.springframework.dao.EmptyResultDataAccessException Java Examples

public AccountData findByUserId(long userId) {
    final String sql = "SELECT * FROM " + TABLE_NAME + " WHERE user_id=? LIMIT 1";
    AccountData accountData = null;
    try {
        accountData = jdbcTemplate.queryForObject(sql,
                new Object[]{userId}, new int[]{Types.BIGINT}
                , new AccountDataMapper());
    } catch (EmptyResultDataAccessException e) {
        return null;
    }

    return accountData;
}
 

private String getTargetIds(int mailingId, @VelocityCheck int companyId) throws Exception {
	String query = "SELECT target_expression FROM mailing_tbl WHERE mailing_id = ? AND company_id = ?";
	String targetExpression = "";
	try {
		targetExpression = select(logger, query, String.class, mailingId, companyId);
	} catch (EmptyResultDataAccessException e) {
		// nothing to do
	}
	final Pattern pattern = Pattern.compile("^.*?(\\d+)(.*)$");
	Set<Integer> targetIds = new HashSet<>();
	if (targetExpression != null) {
		Matcher matcher = pattern.matcher(targetExpression);
		while (matcher.matches()) {
			targetIds.add(Integer.parseInt(matcher.group(1)));
			targetExpression = matcher.group(2);
			matcher = pattern.matcher(targetExpression);
		}
	}
	return StringUtils.join(targetIds, ",");
}
 

/**
 * Loads the {@link Owner} with the supplied <code>id</code>; also loads the
 * {@link Pet Pets} and {@link Visit Visits} for the corresponding owner, if not
 * already loaded.
 */
@Override
public Owner findById(int id) throws DataAccessException {
    Owner owner;
    try {
        Map<String, Object> params = new HashMap<>();
        params.put("id", id);
        owner = this.namedParameterJdbcTemplate.queryForObject(
                "SELECT id, first_name, last_name, address, city, telephone FROM owners WHERE id= :id", params,
                BeanPropertyRowMapper.newInstance(Owner.class));
    } catch (EmptyResultDataAccessException ex) {
        throw new DataRetrievalFailureException("Cannot find Owner: " + id);
    }
    loadPetsAndVisits(owner);
    return owner;
}
 

@Override
public long findPastMaxRSS(JobInterface job, String name) {
    try {
        long maxRss = getJdbcTemplate().queryForObject(FIND_PAST_MAX_RSS,
                Long.class, job.getJobId(), name);
        if (maxRss >= Dispatcher.MEM_RESERVED_MIN) {
            return maxRss;
        }
        else {
            return Dispatcher.MEM_RESERVED_MIN;
        }
    } catch (EmptyResultDataAccessException e) {
        // Actually want to return 0 here, which means
        // there is no past history.
        return 0;
    }
}
 

@Override
public long findPastMaxRSS(JobInterface job, String name) {
    try {
        long maxRss = getJdbcTemplate().queryForObject(FIND_PAST_MAX_RSS,
                Long.class, job.getJobId(), name);
        if (maxRss >= Dispatcher.MEM_RESERVED_MIN) {
            return maxRss;
        }
        else {
            return Dispatcher.MEM_RESERVED_MIN;
        }
    } catch (EmptyResultDataAccessException e) {
        // Actually want to return 0 here, which means
        // there is no past history.
        return 0;
    }
}
 

@Override
public String[] findRolesByUserId(String userId, Token token) {
    // 判断是否自定义查询
    if (getFindRolesSql() == null || getFindRolesSql().trim().isEmpty()) {
        return token.getRoles();
    }
    try {
        List<String> roleList = jdbcTemplate.query(getFindRolesSql(), new RowMapper<String>() {
            @Override
            public String mapRow(ResultSet rs, int rowNum) throws SQLException {
                return rs.getString(1);
            }
        }, userId);
        return JacksonUtil.stringListToArray(roleList);
    } catch (EmptyResultDataAccessException e) {
        logger.debug("JwtPermission", e.getCause());
    }
    return null;
}
 

@Override
public void find(SubscriptionFindRequest request, StreamObserver<SubscriptionFindResponse> responseObserver)
        throws CueGrpcException{
    String name = request.getName();
    try {
        String[] parts = name.split("\\.", 3);
        if (parts.length != 3) {
            throw new CueGrpcException("Subscription names must be in the form of alloc.show");
        }
        SubscriptionFindResponse response = SubscriptionFindResponse.newBuilder()
                .setSubscription(whiteboard.findSubscription(parts[2], parts[0] + "." + parts[1]))
                .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    } catch (EmptyResultDataAccessException e) {
        responseObserver.onError(Status.NOT_FOUND
                .withDescription("A subscription to " + name + " was not found.")
                .withCause(e)
                .asRuntimeException());
    }
}
 

@DeleteMapping("/{orderId}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void deleteOrder(@PathVariable("orderId") Long orderId) {
  try {
    repo.deleteById(orderId);
  } catch (EmptyResultDataAccessException e) {}
}
 

@Override
public int getStrandedCoreUnits(HostInterface h) {
    try {
        int idle_cores =  getJdbcTemplate().queryForObject(
                "SELECT int_cores_idle FROM host WHERE pk_host = ? AND int_mem_idle <= ?",
                Integer.class, h.getHostId(),
                Dispatcher.MEM_STRANDED_THRESHHOLD);
        return (int) (Math.floor(idle_cores / 100.0)) * 100;
    } catch (EmptyResultDataAccessException e) {
        return 0;
    }
}
 

@DeleteMapping("/{orderId}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void deleteOrder(@PathVariable("orderId") Long orderId) {
  try {
    repo.deleteById(orderId);
  } catch (EmptyResultDataAccessException e) {}
}
 

@Override
public LayerInterface findLayer(JobInterface job, String name) {
    try {
        return getJdbcTemplate().queryForObject(
                GET_LAYER + " AND layer.pk_job=? AND layer.str_name=?",
                LAYER_MAPPER, job.getJobId(), name);
    } catch (org.springframework.dao.EmptyResultDataAccessException e) {
        throw new EmptyResultDataAccessException("The layer " +
                name + " was not found in " + job.getName() + e, 0);
    }
}
 

@Override
public String getToken(long userId) {
    final String sql = "SELECT token FROM " + TABLE_NAME + " WHERE user_id=:userId LIMIT 1";
    Map<String, Object> param = new HashMap<String, Object>();
    param.put("userId", userId);
    String token = null;
    try {
        token = namedParameterJdbcTemplate.queryForObject(sql, param, String.class);
    } catch (EmptyResultDataAccessException e) {
        token = null;
    }

    return token;
}
 

public Report findByName(String name) {
    String sql = "SELECT id, name, style, project FROM p_report WHERE name=?";
    try {
        return (Report) jt.queryForObject(sql, new Object[]{ name }, new ReportRowMapper());
    } catch (EmptyResultDataAccessException e) {
        return null;
    }
}
 

@Override
public void findFrame(FrameFindFrameRequest request, StreamObserver<FrameFindFrameResponse> responseObserver) {
    try {
        responseObserver.onNext(FrameFindFrameResponse.newBuilder()
                .setFrame(whiteboard.findFrame(request.getJob(), request.getLayer(), request.getFrame()))
                .build());
        responseObserver.onCompleted();
    } catch (EmptyResultDataAccessException e) {
        responseObserver.onError(Status.NOT_FOUND
                .withDescription(e.getMessage())
                .withCause(e)
                .asRuntimeException());
    }
}
 

public Moment findById(long id) {
    final String sql = "SELECT * FROM " + TABLE_NAME + " WHERE id=? LIMIT 1";
    Moment moment = null;
    try {
        moment = jdbcTemplate.queryForObject(sql, new Object[]{id}, new int[]{Types.BIGINT}
                , new MomentMapper());
    } catch (EmptyResultDataAccessException e) {
        return null;
    }

    return moment;
}
 

@Override
public void getJob(JobGetJobRequest request, StreamObserver<JobGetJobResponse> responseObserver) {
    try {
        responseObserver.onNext(JobGetJobResponse.newBuilder()
                .setJob(whiteboard.getJob(request.getId()))
                .build());
        responseObserver.onCompleted();
    } catch (EmptyResultDataAccessException e) {
        responseObserver.onError(Status.NOT_FOUND
                .withDescription(e.getMessage())
                .withCause(e)
                .asRuntimeException());
    }
}
 

@Override
public Integer count() {
    try {
        return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM user", Integer.class);
    } catch (EmptyResultDataAccessException e) {
        return null;
    }
}
 

@Override
public int getStrandedCoreUnits(HostInterface h) {
    try {
        int idle_cores =  getJdbcTemplate().queryForObject(
                "SELECT int_cores_idle FROM host WHERE pk_host = ? AND int_mem_idle <= ?",
                Integer.class, h.getHostId(),
                Dispatcher.MEM_STRANDED_THRESHHOLD);
        return (int) (Math.floor(idle_cores / 100.0)) * 100;
    } catch (EmptyResultDataAccessException e) {
        return 0;
    }
}
 

public boolean isShowOverSize(VirtualProc proc) {
    try {
        return getJdbcTemplate().queryForObject(IS_SHOW_OVER_SIZE,
                Integer.class, proc.getShowId(), proc.getAllocationId()) > 0;
    } catch (EmptyResultDataAccessException e) {
        return false;
    }
}
 

Option<Book> findBy(ISBN isbn) {
    try {
        return Option.of(
                jdbcTemplate.queryForObject(
                        "SELECT b.* FROM catalogue_book b WHERE b.isbn = ?",
                        new BeanPropertyRowMapper<>(BookDatabaseRow.class),
                        isbn.getIsbn())
                        .toBook());
    } catch (EmptyResultDataAccessException e) {
        return Option.none();

    }
}
 

public MomentLike findExist(long momentId, long userId) {
    String tableName = getTableName(momentId);
    final String sql = "SELECT * FROM " + tableName + " WHERE moment_id=? " +
            " AND like_user_id=? LIMIT 1";
    MomentLike momentLike = null;
    try {
        momentLike = jdbcTemplate.queryForObject(sql, new Object[]{momentId, userId}
                , new int[]{Types.BIGINT, Types.BIGINT}
                , new MomentLikeMapper());
    } catch (EmptyResultDataAccessException e) {
        return null;
    }

    return momentLike;
}
 

@Override
public Optional<TemplateInfo> getTemplateInfoWithoutConvert(String group, String template) {
    try {
        return Optional.ofNullable(templateDao.selectTemplateInfo(group, template));
    } catch (EmptyResultDataAccessException ignore) {
        return Optional.empty();
    }
}
 

@Override
public Optional<TemplateInfo> getTemplateInfo(String group, String template) {
    try {
        TemplateInfo templateInfo = templateDao.selectTemplateInfo(group, template);
        dealNewJsonTemplate(templateInfo);
        return Optional.ofNullable(templateInfo);
    } catch (EmptyResultDataAccessException ignore) {
        return Optional.empty();
    }
}
 

@Override
public ConfigEditorSettings settingsOf(final String groupId, final String dataId) {
    Preconditions.checkArgument(!Strings.isNullOrEmpty(groupId), "groupId不能为空");
    Preconditions.checkArgument(!Strings.isNullOrEmpty(dataId), "dataId不能为空");
    try {
        return configEditorSettingsDao.query(groupId, dataId);
    } catch (EmptyResultDataAccessException ignore) {
        return ConfigEditorSettings.DEFAULT;
    }
}
 

public User findByUsernameAndTempPassword(String username, String rawTempPassword) {
    String encryptedPassword = PasswordUtils.getMd5Hash(rawTempPassword);
    String sql = "SELECT id, username, name, sys_role "
                + "FROM p_user "
                + "WHERE username=? AND temp_password=?";
    try {
        User user = (User) jt.queryForObject(sql, new Object[]{username, encryptedPassword}, new UserInfoRowMapper());
        return user;
    } catch (EmptyResultDataAccessException e) {
        return null;
    }
}
 

public int countByMomentId(long momentId) {
    int count;
    final String sql = "SELECT COUNT(*) FROM " + TABLE_NAME + " WHERE moment_id=?";
    try {
        count = jdbcTemplate.queryForObject(sql, new Object[]{momentId}, new int[]{Types.BIGINT}
                , Integer.class);
    } catch (EmptyResultDataAccessException e) {
        count = 0;
    }
    return count;
}
 

@Test(expected=EmptyResultDataAccessException.class)
@Transactional
@Rollback(true)
public void testFindShowDetailByHost() {
    // TODO: Add code to setup a host and make the sow
    //  prefer the host, then check result again.
    showDao.getShowDetail(createHost());
}
 

@Test
@SuppressWarnings("serial")
public void testConvertJpaPersistenceException() {
	EntityNotFoundException entityNotFound = new EntityNotFoundException();
	assertSame(JpaObjectRetrievalFailureException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityNotFound).getClass());

	NoResultException noResult = new NoResultException();
	assertSame(EmptyResultDataAccessException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(noResult).getClass());

	NonUniqueResultException nonUniqueResult = new NonUniqueResultException();
	assertSame(IncorrectResultSizeDataAccessException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(nonUniqueResult).getClass());

	OptimisticLockException optimisticLock = new OptimisticLockException();
	assertSame(JpaOptimisticLockingFailureException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(optimisticLock).getClass());

	EntityExistsException entityExists = new EntityExistsException("foo");
	assertSame(DataIntegrityViolationException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityExists).getClass());

	TransactionRequiredException transactionRequired = new TransactionRequiredException("foo");
	assertSame(InvalidDataAccessApiUsageException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(transactionRequired).getClass());

	PersistenceException unknown = new PersistenceException() {
	};
	assertSame(JpaSystemException.class,
			EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(unknown).getClass());
}
 

public User findByShareKey(String shareKey) {
    String sql = "SELECT u.id, u.username, u.name, u.sys_role, u.session_key "
                + "FROM p_user u, p_shared_report sr "
                + "WHERE u.id = sr.user_id "
                + "AND sr.share_key=?";
    try {
        User user = (User) jt.queryForObject(sql, new Object[]{ shareKey }, new UserSesssionKeyMapper());
        return user;
    } catch (EmptyResultDataAccessException e) {
        return null;
    }
}
 

@Override
public boolean isShowAtOrOverBurst(ShowInterface show, AllocationInterface alloc) {
    try {
        return getJdbcTemplate().queryForObject(IS_SHOW_AT_OR_OVER_BURST,
                Integer.class, show.getShowId(), alloc.getAllocationId()) > 0;
    } catch (EmptyResultDataAccessException e) {
        return true;
    }
}