Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
*
* @param stmtSetter
* @return
* @throws IllegalArgumentException
* @throws SQLException
*/
@Beta
public This configStmt(final Throwables.BiConsumer stmtSetter)
throws IllegalArgumentException, SQLException {
checkArgNotNull(stmtSetter, "stmtSetter");
boolean noException = false;
try {
stmtSetter.accept((This) this, stmt);
noException = true;
} finally {
if (!noException) {
close();
}
}
return (This) this;
}
int getFetchSize() throws SQLException {
return stmt.getFetchSize();
}
int getFetchDirection() throws SQLException {
return stmt.getFetchDirection();
}
/**
* Returns an {@code OptionalBoolean} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalBoolean}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalBoolean queryForBoolean() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalBoolean.of(rs.getBoolean(1)) : OptionalBoolean.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
static final Type charType = TypeFactory.getType(char.class);
/**
* Returns an {@code OptionalChar} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalChar}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalChar queryForChar() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
return OptionalChar.of(charType.get(rs, 1));
} else {
return OptionalChar.empty();
}
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalByte} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalByte}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalByte queryForByte() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalByte.of(rs.getByte(1)) : OptionalByte.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalShort} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalShort}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalShort queryForShort() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalShort.of(rs.getShort(1)) : OptionalShort.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalInt} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalInt}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalInt queryForInt() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalInt.of(rs.getInt(1)) : OptionalInt.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalLong} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalLong}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalLong queryForLong() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalLong.of(rs.getLong(1)) : OptionalLong.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalFloat} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalFloat}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalFloat queryForFloat() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalFloat.of(rs.getFloat(1)) : OptionalFloat.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code OptionalDouble} describing the value in the first row/column if it exists, otherwise return an empty {@code OptionalDouble}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public OptionalDouble queryForDouble() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? OptionalDouble.of(rs.getDouble(1)) : OptionalDouble.empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForString() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getString(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
private static final Type BIG_INTEGER_TYPE = Type.of(BigInteger.class);
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
@Beta
public Nullable queryForBigInteger() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(BIG_INTEGER_TYPE.get(rs, 1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
@Beta
public Nullable queryForBigDecimal() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getBigDecimal(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForDate() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getDate(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForTime() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getTime(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForTimestamp() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getTimestamp(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForBytes() throws IllegalStateException, SQLException {
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(rs.getBytes(1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @param the value type
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForSingleResult(final Class targetType) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
return queryForSingleResult(Type.of(targetType));
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @param
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Nullable queryForSingleResult(final Type targetType) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Nullable.of(targetType.get(rs, 1)) : Nullable. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code Optional} describing the value in the first row/column if it exists, otherwise return an empty {@code Optional}.
*
* @param the value type
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Optional queryForSingleNonNull(final Class targetType) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
return queryForSingleNonNull(Type.of(targetType));
}
/**
* Returns an {@code Optional} describing the value in the first row/column if it exists, otherwise return an empty {@code Optional}.
*
* @param
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public Optional queryForSingleNonNull(final Type targetType) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return rs.next() ? Optional.of(targetType.get(rs, 1)) : Optional. empty();
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @param the value type
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException if more than one record found by the specified {@code id} (or {@code condition}).
* @throws SQLException
*/
public Nullable queryForUniqueResult(final Class targetType)
throws IllegalArgumentException, IllegalStateException, DuplicatedResultException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
return queryForUniqueResult(Type.of(targetType));
}
/**
* Returns a {@code Nullable} describing the value in the first row/column if it exists, otherwise return an empty {@code Nullable}.
*
* @param
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException if more than one record found by the specified {@code id} (or {@code condition}).
* @throws SQLException
*/
public Nullable queryForUniqueResult(final Type targetType)
throws IllegalArgumentException, IllegalStateException, DuplicatedResultException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
final Nullable result = rs.next() ? Nullable.of(targetType.get(rs, 1)) : Nullable. empty();
if (result.isPresent() && rs.next()) {
throw new DuplicatedResultException(
"At least two results found: " + Strings.concat(result.get(), ", ", N.convert(JdbcUtil.getColumnValue(rs, 1), targetType)));
}
return result;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Returns an {@code Optional} describing the value in the first row/column if it exists, otherwise return an empty {@code Optional}.
*
* @param the value type
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException if more than one record found by the specified {@code id} (or {@code condition}).
* @throws SQLException
*/
public Optional queryForUniqueNonNull(final Class targetType)
throws IllegalArgumentException, IllegalStateException, DuplicatedResultException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
return queryForUniqueNonNull(Type.of(targetType));
}
/**
* Returns an {@code Optional} describing the value in the first row/column if it exists, otherwise return an empty {@code Optional}.
*
* @param the value type
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException if more than one record found by the specified {@code id} (or {@code condition}).
* @throws SQLException
*/
public Optional queryForUniqueNonNull(final Type targetType)
throws IllegalArgumentException, IllegalStateException, DuplicatedResultException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
final Optional result = rs.next() ? Optional.of(targetType.get(rs, 1)) : Optional. empty();
if (result.isPresent() && rs.next()) {
throw new DuplicatedResultException(
"At least two results found: " + Strings.concat(result.get(), ", ", N.convert(JdbcUtil.getColumnValue(rs, 1), targetType)));
}
return result;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
* @param rs
* @param targetType
* @param
* @return
* @throws SQLException
*/
private static T getRow(final ResultSet rs, final Class targetType) throws SQLException {
final List columnLabels = JdbcUtil.getColumnLabelList(rs);
return Jdbc.BiRowMapper.to(targetType).apply(rs, columnLabels);
}
/**
* Retrieves the first {@code ResultSet}.
*
* @return
* @throws SQLException
*/
public DataSet query() throws SQLException {
return query(Jdbc.ResultExtractor.TO_DATA_SET);
}
/**
* Retrieves the first {@code ResultSet}.
*
* @param entityClass used to fetch fields from columns
* @return
* @throws SQLException
* @see {@link Jdbc.ResultExtractor#toDataSet(Class)}
*/
public DataSet query(final Class entityClass) throws SQLException {
return query(Jdbc.ResultExtractor.toDataSet(entityClass));
}
/**
* Retrieves the first {@code ResultSet}.
*
* @param
* @param resultExtractor Don't save/return {@code ResultSet}. It will be closed after this call.
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public R query(final Jdbc.ResultExtractor resultExtractor) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor, "resultExtractor");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return JdbcUtil.checkNotResultSet(resultExtractor.apply(rs));
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Retrieves the first {@code ResultSet}.
*
* @param
* @param resultExtractor Don't save/return {@code ResultSet}. It will be closed after this call.
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public R query(final Jdbc.BiResultExtractor resultExtractor) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor, "resultExtractor");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
return JdbcUtil.checkNotResultSet(resultExtractor.apply(rs, JdbcUtil.getColumnLabelList(rs)));
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Retrieves at most two {@code ResultSets}.
*
* @param
* @param
* @param resultExtractor1 Don't save/return {@code ResultSet}. It will be closed after this call.
* @param resultExtractor2 Don't save/return {@code ResultSet}. It will be closed after this call.
* @return {@code R1/R2} extracted from the first two {@code ResultSets} returned by the executed procedure.
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
@Beta
public Tuple2 query2Resultsets(final Jdbc.BiResultExtractor resultExtractor1,
final Jdbc.BiResultExtractor resultExtractor2) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor1, "resultExtractor1");
checkArgNotNull(resultExtractor2, "resultExtractor2");
assertNotClosed();
Throwables.Iterator iter = null;
try {
final boolean isResultSet = JdbcUtil.execute(stmt);
iter = JdbcUtil.iterateAllResultSets(stmt, isResultSet);
R1 result1 = null;
R2 result2 = null;
if (iter.hasNext()) {
result1 = JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor1);
}
if (iter.hasNext()) {
result2 = JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor2);
}
return Tuple.of(result1, result2);
} finally {
try {
if (iter != null) {
iter.close();
}
} finally {
closeAfterExecutionIfAllowed();
}
}
}
/**
* Retrieves at most three {@code ResultSets}.
*
* @param
* @param
* @param
* @param resultExtractor1 Don't save/return {@code ResultSet}. It will be closed after this call.
* @param resultExtractor2 Don't save/return {@code ResultSet}. It will be closed after this call.
* @param resultExtractor3 Don't save/return {@code ResultSet}. It will be closed after this call.
* @return {@code R1/R2/R3} extracted from the first three {@code ResultSets} returned by the executed procedure.
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
@Beta
public Tuple3 query3Resultsets(final Jdbc.BiResultExtractor resultExtractor1,
final Jdbc.BiResultExtractor resultExtractor2, final Jdbc.BiResultExtractor resultExtractor3)
throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor1, "resultExtractor1");
checkArgNotNull(resultExtractor2, "resultExtractor2");
checkArgNotNull(resultExtractor3, "resultExtractor3");
assertNotClosed();
Throwables.Iterator iter = null;
try {
final boolean isResultSet = JdbcUtil.execute(stmt);
iter = JdbcUtil.iterateAllResultSets(stmt, isResultSet);
R1 result1 = null;
R2 result2 = null;
R3 result3 = null;
if (iter.hasNext()) {
result1 = JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor1);
}
if (iter.hasNext()) {
result2 = JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor2);
}
if (iter.hasNext()) {
result3 = JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor3);
}
return Tuple.of(result1, result2, result3);
} finally {
try {
if (iter != null) {
iter.close();
}
} finally {
closeAfterExecutionIfAllowed();
}
}
}
/**
* Retrieves all the {@code ResultSets}.
*
* @return a list of {@code DataSet} extracted from all {@code ResultSets} returned by the executed procedure and a list of {@code Out Parameters}.
* @throws SQLException
*/
public List queryMultiResultsets() throws SQLException {
return queryMultiResultsets(ResultExtractor.TO_DATA_SET);
}
/**
* Retrieves all the {@code ResultSets}.
*
* @param
* @param resultExtractor Don't save/return {@code ResultSet}. It will be closed after this call.
* @return a list of {@code R} extracted from all {@code ResultSets} returned by the executed procedure and a list of {@code Out Parameters}.
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public List queryMultiResultsets(final Jdbc.ResultExtractor resultExtractor)
throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor, "resultExtractor");
assertNotClosed();
Throwables.Iterator iter = null;
try {
final boolean isResultSet = JdbcUtil.execute(stmt);
iter = JdbcUtil.iterateAllResultSets(stmt, isResultSet);
final List result = new ArrayList<>();
while (iter.hasNext()) {
result.add(JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor));
}
return result;
} finally {
try {
if (iter != null) {
iter.close();
}
} finally {
closeAfterExecutionIfAllowed();
}
}
}
/**
* Retrieves all the {@code ResultSets}.
*
* @param
* @param resultExtractor Don't save/return {@code ResultSet}. It will be closed after this call.
* @return a list of {@code R} extracted from all {@code ResultSets} returned by the executed procedure and a list of {@code Out Parameters}.
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public List queryMultiResultsets(final Jdbc.BiResultExtractor resultExtractor)
throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(resultExtractor, "resultExtractor");
assertNotClosed();
Throwables.Iterator iter = null;
try {
final boolean isResultSet = JdbcUtil.execute(stmt);
iter = JdbcUtil.iterateAllResultSets(stmt, isResultSet);
final List result = new ArrayList<>();
while (iter.hasNext()) {
result.add(JdbcUtil.extractAndCloseResultSet(iter.next(), resultExtractor));
}
return result;
} finally {
try {
if (iter != null) {
iter.close();
}
} finally {
closeAfterExecutionIfAllowed();
}
}
}
/**
*
* @param
* @param
* @param func
* @return
* @throws SQLException
* @throws E
*/
@Beta
public R queryThenApply(final Throwables.Function func) throws SQLException, E {
return func.apply(query());
}
/**
*
* @param
* @param
* @param entityClass used to fetch fields from columns
* @param func
* @return
* @throws SQLException
* @throws E
* @see {@link Jdbc.ResultExtractor#toDataSet(Class)}
*/
@Beta
public R queryThenApply(final Class entityClass, final Throwables.Function func)
throws SQLException, E {
return func.apply(query(entityClass));
}
/**
*
*
* @param
* @param action
* @throws SQLException
* @throws E
*/
@Beta
public void queryThenAccept(final Throwables.Consumer action) throws SQLException, E {
action.accept(query());
}
/**
*
*
* @param
* @param entityClass used to fetch fields from columns
* @param action
* @throws SQLException
* @throws E
* @see {@link Jdbc.ResultExtractor#toDataSet(Class)}
*/
@Beta
public void queryThenAccept(final Class entityClass, final Throwables.Consumer action) throws SQLException, E {
action.accept(query(entityClass));
}
// /**
// *
// * @param
// * @param targetType
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @deprecated replaced by {@code findOnlyOne}.
// */
// @Deprecated
// public Optional get(final Class targetType) throws DuplicatedResultException, SQLException {
// return Optional.ofNullable(gett(targetType));
// }
//
// /**
// *
// * @param
// * @param rowMapper
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
// * @deprecated replaced by {@code findOnlyOne}.
// */
// @Deprecated
// public Optional get(Jdbc.RowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
// return Optional.ofNullable(gett(rowMapper));
// }
//
// /**
// *
// * @param
// * @param rowMapper
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
// * @deprecated replaced by {@code findOnlyOne}.
// */
// @Deprecated
// public Optional get(Jdbc.BiRowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
// return Optional.ofNullable(gett(rowMapper));
// }
//
// /**
// *
// * @param
// * @param targetType
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @deprecated replaced by {@code findOnlyOneOrNull}.
// */
// @Deprecated
// public T gett(final Class targetType) throws DuplicatedResultException, SQLException {
// return findOnlyOneOrNull(targetType);
// }
//
// /**
// *
// * @param
// * @param rowMapper
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
// * @deprecated replaced by {@code findOnlyOneOrNull}.
// */
// @Deprecated
// public T gett(Jdbc.RowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
// return findOnlyOneOrNull(rowMapper);
// }
//
// /**
// *
// * @param
// * @param rowMapper
// * @return
// * @throws DuplicatedResultException If More than one record found by the query
// * @throws SQLException
// * @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
// * @deprecated replaced by {@code findOnlyOneOrNull}.
// */
// @Deprecated
// public T gett(Jdbc.BiRowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
// return findOnlyOneOrNull(rowMapper);
// }
/**
*
* @return
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
*/
public Optional> findOnlyOne() throws DuplicatedResultException, SQLException {
return findOnlyOne(Jdbc.BiRowMapper.TO_MAP);
}
/**
*
*
* @param
* @param targetType
* @return
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public Optional findOnlyOne(final Class targetType) throws DuplicatedResultException, SQLException {
return Optional.ofNullable(findOnlyOneOrNull(targetType));
}
/**
*
* @param
* @param rowMapper
* @return
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public Optional findOnlyOne(final Jdbc.RowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
return Optional.ofNullable(findOnlyOneOrNull(rowMapper));
}
/**
*
* @param
* @param rowMapper
* @return
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public Optional findOnlyOne(final Jdbc.BiRowMapper rowMapper) throws DuplicatedResultException, SQLException, IllegalArgumentException {
return Optional.ofNullable(findOnlyOneOrNull(rowMapper));
}
/**
*
* @return
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
*/
public Map findOnlyOneOrNull() throws DuplicatedResultException, SQLException {
return findOnlyOneOrNull(Jdbc.BiRowMapper.TO_MAP);
}
/**
*
*
* @param
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
*/
public T findOnlyOneOrNull(final Class targetType)
throws IllegalArgumentException, IllegalStateException, DuplicatedResultException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
final T result = Objects.requireNonNull(getRow(rs, targetType));
if (rs.next()) {
throw new DuplicatedResultException("More than one record found by the query");
}
return result;
} else {
return null;
}
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public T findOnlyOneOrNull(final Jdbc.RowMapper rowMapper)
throws IllegalStateException, DuplicatedResultException, SQLException, IllegalArgumentException {
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
final T result = Objects.requireNonNull(rowMapper.apply(rs));
if (rs.next()) {
throw new DuplicatedResultException("More than one record found by the query");
}
return result;
} else {
return null;
}
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws DuplicatedResultException If More than one record found by the query
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public T findOnlyOneOrNull(final Jdbc.BiRowMapper rowMapper)
throws IllegalStateException, DuplicatedResultException, SQLException, IllegalArgumentException {
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
final T result = Objects.requireNonNull(rowMapper.apply(rs, JdbcUtil.getColumnLabelList(rs)));
if (rs.next()) {
throw new DuplicatedResultException("More than one record found by the query");
}
return result;
} else {
return null;
}
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
* @return
* @throws SQLException
*/
public Optional> findFirst() throws SQLException {
return findFirst(Jdbc.BiRowMapper.TO_MAP);
}
/**
*
* @param
* @param targetType
* @return
* @throws SQLException
*/
public Optional findFirst(final Class targetType) throws SQLException {
return Optional.ofNullable(findFirstOrNull(targetType));
}
/**
*
* @param
* @param rowMapper
* @return
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public Optional findFirst(final Jdbc.RowMapper rowMapper) throws SQLException, IllegalArgumentException {
return Optional.ofNullable(findFirstOrNull(rowMapper));
}
/**
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
* @deprecated Use {@code stream(RowFilter, RowMapper).first()} instead.
*/
@Deprecated
public Optional findFirst(final Jdbc.RowFilter rowFilter, final Jdbc.RowMapper rowMapper)
throws SQLException, IllegalArgumentException {
return Optional.ofNullable(findFirstOrNull(rowFilter, rowMapper));
}
/**
*
* @param
* @param rowMapper
* @return
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public Optional findFirst(final Jdbc.BiRowMapper rowMapper) throws SQLException, IllegalArgumentException {
return Optional.ofNullable(findFirstOrNull(rowMapper));
}
/**
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
* @deprecated Use {@code stream(BiRowFilter, BiRowMapper).first()} instead.
*/
@Deprecated
public Optional findFirst(final Jdbc.BiRowFilter rowFilter, final Jdbc.BiRowMapper rowMapper)
throws SQLException, IllegalArgumentException {
return Optional.ofNullable(findFirstOrNull(rowFilter, rowMapper));
}
/**
*
* @return
* @throws SQLException
*/
public Map findFirstOrNull() throws SQLException {
return findFirstOrNull(Jdbc.BiRowMapper.TO_MAP);
}
/**
*
*
* @param
* @param targetType
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public T findFirstOrNull(final Class targetType) throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(targetType, "targetType");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
return Objects.requireNonNull(getRow(rs, targetType));
}
return null;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public T findFirstOrNull(final Jdbc.RowMapper rowMapper) throws IllegalStateException, SQLException, IllegalArgumentException {
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
return Objects.requireNonNull(rowMapper.apply(rs));
}
return null;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
* @deprecated Use {@code stream(RowFilter, RowMapper).first()} instead.
*/
@Deprecated
public T findFirstOrNull(final Jdbc.RowFilter rowFilter, final Jdbc.RowMapper rowMapper)
throws IllegalStateException, SQLException, IllegalArgumentException {
checkArgNotNull(rowFilter, "rowFilter");
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
while (rs.next()) {
if (rowFilter.test(rs)) {
return Objects.requireNonNull(rowMapper.apply(rs));
}
}
return null;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
*/
public T findFirstOrNull(final Jdbc.BiRowMapper rowMapper) throws IllegalStateException, SQLException, IllegalArgumentException {
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
if (rs.next()) {
return Objects.requireNonNull(rowMapper.apply(rs, JdbcUtil.getColumnLabelList(rs)));
} else {
return null;
}
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
*
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws IllegalStateException if this is closed
* @throws SQLException
* @throws IllegalArgumentException if {@code rowMapper} returns {@code null} for the found record.
* @deprecated Use {@code stream(BiRowFilter, BiRowMapper).first()} instead.
*/
@Deprecated
public T findFirstOrNull(final Jdbc.BiRowFilter rowFilter, final Jdbc.BiRowMapper rowMapper)
throws IllegalStateException, SQLException, IllegalArgumentException {
checkArgNotNull(rowFilter, "rowFilter");
checkArgNotNull(rowMapper, "rowMapper");
assertNotClosed();
try (ResultSet rs = executeQuery()) {
final List columnLabels = JdbcUtil.getColumnLabelList(rs);
while (rs.next()) {
if (rowFilter.test(rs, columnLabels)) {
return Objects.requireNonNull(rowMapper.apply(rs, columnLabels));
}
}
return null;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @return
* @throws SQLException
*/
public List> list() throws SQLException {
return list(Jdbc.BiRowMapper.TO_MAP);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param targetType
* @return
* @throws SQLException
*/
public List list(final Class targetType) throws SQLException {
return list(Jdbc.BiRowMapper.to(targetType));
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param targetType
* @param maxResult
* @return
* @throws SQLException
* @deprecated the result size should be limited in database server side by sql scripts.
*/
@Deprecated
public List list(final Class targetType, final int maxResult) throws SQLException {
return list(Jdbc.BiRowMapper.to(targetType), maxResult);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowMapper
* @return
* @throws SQLException
*/
public List list(final Jdbc.RowMapper rowMapper) throws SQLException {
return list(rowMapper, Integer.MAX_VALUE);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowMapper
* @param maxResult
* @return
* @throws SQLException
* @deprecated the result size should be limited in database server side by sql scripts.
*/
@Deprecated
public List list(final Jdbc.RowMapper rowMapper, final int maxResult) throws SQLException {
return list(Jdbc.RowFilter.ALWAYS_TRUE, rowMapper, maxResult);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws SQLException
*/
public List list(final Jdbc.RowFilter rowFilter, final Jdbc.RowMapper rowMapper) throws SQLException {
return list(rowFilter, rowMapper, Integer.MAX_VALUE);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowFilter
* @param rowMapper
* @param maxResult
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public List list(final Jdbc.RowFilter rowFilter, final Jdbc.RowMapper rowMapper, int maxResult)
throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(rowFilter, "rowFilter");
checkArgNotNull(rowMapper, "rowMapper");
checkArg(maxResult >= 0, "'maxResult' can' be negative: " + maxResult);
assertNotClosed();
try (ResultSet rs = executeQuery()) {
final List result = new ArrayList<>();
while (maxResult > 0 && rs.next()) {
if (rowFilter.test(rs)) {
result.add(rowMapper.apply(rs));
maxResult--;
}
}
return result;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowMapper
* @return
* @throws SQLException
*/
public List list(final Jdbc.BiRowMapper rowMapper) throws SQLException {
return list(rowMapper, Integer.MAX_VALUE);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowMapper
* @param maxResult
* @return
* @throws SQLException
* @deprecated the result size should be limited in database server side by sql scripts.
*/
@Deprecated
public List list(final Jdbc.BiRowMapper rowMapper, final int maxResult) throws SQLException {
return list(Jdbc.BiRowFilter.ALWAYS_TRUE, rowMapper, maxResult);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowFilter
* @param rowMapper
* @return
* @throws SQLException
*/
public List list(final Jdbc.BiRowFilter rowFilter, final Jdbc.BiRowMapper rowMapper) throws SQLException {
return list(rowFilter, rowMapper, Integer.MAX_VALUE);
}
/**
* Lists the rows in the first {@code ResultSet}.
*
* @param
* @param rowFilter
* @param rowMapper
* @param maxResult
* @return
* @throws IllegalArgumentException
* @throws IllegalStateException if this is closed
* @throws SQLException
*/
public List list(final Jdbc.BiRowFilter rowFilter, final Jdbc.BiRowMapper rowMapper, int maxResult)
throws IllegalArgumentException, IllegalStateException, SQLException {
checkArgNotNull(rowFilter, "rowFilter");
checkArgNotNull(rowMapper, "rowMapper");
checkArg(maxResult >= 0, "'maxResult' can' be negative: " + maxResult);
assertNotClosed();
try (ResultSet rs = executeQuery()) {
final List columnLabels = JdbcUtil.getColumnLabelList(rs);
final List result = new ArrayList<>();
while (maxResult > 0 && rs.next()) {
if (rowFilter.test(rs, columnLabels)) {
result.add(rowMapper.apply(rs, columnLabels));
maxResult--;
}
}
return result;
} finally {
closeAfterExecutionIfAllowed();
}
}
/**
* Lists all the {@code ResultSets}.
*
* @param
