From 4bbf48389f5933b7086094a24a4aa36f36b6a402 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:23:11 +0900 Subject: [PATCH 01/13] Prepare 0.9.7 --- README.md | 2 +- pom.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bd87e280..45732dfe 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ You can get the binary using Maven from [Central Repository](http://mvnrepositor org.nkjmlab sorm4j - 0.9.6 + 0.9.7 ``` diff --git a/pom.xml b/pom.xml index b9205c44..98b3f449 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 org.nkjmlab sorm4j - 0.9.6 + 0.9.7 sorm4j Simple micro Object-Relation Mapper for Java https://github.com/yuu-nkjm/sorm4j From fde17dd5ee24ea5b4eb60ec07ad84d48505f4058 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:24:21 +0900 Subject: [PATCH 02/13] Fix judge threshold of batch. --- src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java index 6603dcc6..3aae0814 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java @@ -21,7 +21,7 @@ public BatchHelper(int batchSize, PreparedStatement stmt) { public void addBatchAndExecuteIfReachedThreshold() { addBatch(); - if (counter + 1 % batchSize == 0) { + if ((counter + 1) % batchSize == 0) { executeBatch(); } } @@ -52,4 +52,4 @@ private void executeBatch() { throw new OrmException(e); } } -} \ No newline at end of file +} From 77142bd0e69656f03d576d9ba74e685fb970b9f8 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:34:43 +0900 Subject: [PATCH 03/13] Update throws declaration --- .../org/nkjmlab/sorm4j/LazyResultSet.java | 8 ++- .../sorm4j/mapping/AbstractOrmMapper.java | 7 ++- .../nkjmlab/sorm4j/mapping/BatchHelper.java | 12 ++-- .../sorm4j/mapping/ColumnsMapping.java | 2 +- .../sorm4j/mapping/ResultSetConverter.java | 56 ++++++++----------- 5 files changed, 37 insertions(+), 48 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java index 6a9aff3a..54b23548 100644 --- a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java +++ b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java @@ -14,6 +14,7 @@ import java.util.stream.Stream; import java.util.stream.StreamSupport; import org.nkjmlab.sorm4j.mapping.AbstractOrmMapper; +import org.nkjmlab.sorm4j.util.Try; /** * Represents a result set from database. @@ -137,8 +138,11 @@ private final class LazyResultSetIterator implements Iterator { @SuppressWarnings("unchecked") public LazyResultSetIterator(AbstractOrmMapper orMapper, Class objectClass, PreparedStatement stmt, ResultSet resultSet) { - this.getFunction = objectClass.equals(Map.class) ? () -> (S) orMapper.toSingleMap(resultSet) - : () -> orMapper.toSingleObject(objectClass, resultSet); + this.getFunction = objectClass.equals(Map.class) + ? Try.createSupplierWithThrow(() -> (S) orMapper.toSingleMap(resultSet), + OrmException::new) + : Try.createSupplierWithThrow(() -> orMapper.toSingleObject(objectClass, resultSet), + OrmException::new); } @Override diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java index d16c4647..035ac427 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java @@ -441,19 +441,20 @@ protected final T readOneAux(final Class objectClass, final String sql, }); } - public Map toSingleMap(ResultSet resultSet) { + public Map toSingleMap(ResultSet resultSet) throws SQLException { ColumnsAndTypes ct = createColumnsAndTypes(resultSet); return resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes()); } - public T toSingleObject(Class objectClass, ResultSet resultSet) { + public T toSingleObject(Class objectClass, ResultSet resultSet) throws SQLException { return isEnableToConvertNativeSqlType(objectClass) ? resultSetConverter.toSingleNativeObject(resultSet, objectClass) : toSinglePojo(objectClass, resultSet); } - private final T toSinglePojo(final Class objectClass, final ResultSet resultSet) { + private final T toSinglePojo(final Class objectClass, final ResultSet resultSet) + throws SQLException { ColumnsMapping mapping = getColumnsMapping(objectClass); return mapping.loadObject(resultSet); } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java index 3aae0814..6c8abca7 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchHelper.java @@ -19,20 +19,16 @@ public BatchHelper(int batchSize, PreparedStatement stmt) { this.stmt = stmt; } - public void addBatchAndExecuteIfReachedThreshold() { + public void addBatchAndExecuteIfReachedThreshold() throws SQLException { addBatch(); if ((counter + 1) % batchSize == 0) { executeBatch(); } } - private void addBatch() { - try { - stmt.addBatch(); - counter++; - } catch (SQLException e) { - throw new OrmException(e); - } + private void addBatch() throws SQLException { + stmt.addBatch(); + counter++; } public int[] finish() { diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java b/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java index 1b023a25..5cdcbfa9 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java @@ -38,7 +38,7 @@ public String getFormattedString() { + super.getColumnToAccessorString(); } - public T loadObject(ResultSet resultSet) { + public T loadObject(ResultSet resultSet) throws SQLException { List columns = createColumns(resultSet); List> setterParamTypes = getSetterParamTypes(columns); return createObject(columns, diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/ResultSetConverter.java b/src/main/java/org/nkjmlab/sorm4j/mapping/ResultSetConverter.java index 793852fd..0180191d 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/ResultSetConverter.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/ResultSetConverter.java @@ -6,7 +6,6 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import org.nkjmlab.sorm4j.OrmException; import org.nkjmlab.sorm4j.config.ResultSetValueGetter; @@ -19,48 +18,37 @@ public ResultSetConverter(ResultSetValueGetter resultSetValueGetter) { } public Map toSingleMap(final ResultSet resultSet, List columns, - List columnTypes) { - try { - final Map ret = new LinkedHashMap<>(); - for (int i = 1; i <= columns.size(); i++) { - int type = columnTypes.get(i - 1); - Object value = resultSetValueGetter.getValueBySqlType(resultSet, i, type); - ret.put(columns.get(i - 1), value); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + List columnTypes) throws SQLException { + final Map ret = new LinkedHashMap<>(); + for (int i = 1; i <= columns.size(); i++) { + int type = columnTypes.get(i - 1); + Object value = resultSetValueGetter.getValueBySqlType(resultSet, i, type); + ret.put(columns.get(i - 1), value); } + return ret; } - public final T toSingleNativeObject(final ResultSet resultSet, final Class objectClass) { - try { - // Don't user type from metadata (metaData.getColumnType(1)) because object class of container - // is prior. - Object value = resultSetValueGetter.getValueBySetterType(resultSet, 1, objectClass); - @SuppressWarnings("unchecked") - T valueT = (T) value; - return valueT; - } catch (SQLException e) { - throw new OrmException("Fail to get value as [" + objectClass.getSimpleName() + "]", e); - } + public final T toSingleNativeObject(final ResultSet resultSet, final Class objectClass) throws SQLException { + // Don't user type from metadata (metaData.getColumnType(1)) because object class of container + // is prior. + Object value = resultSetValueGetter.getValueBySetterType(resultSet, 1, objectClass); + @SuppressWarnings("unchecked") + T valueT = (T) value; + return valueT; } public final List toObjectsByClasses(ResultSet resultSet, - List> setterParamTypes) { - try { - final List values = new ArrayList<>(setterParamTypes.size()); - for (int i = 1; i <= setterParamTypes.size(); i++) { - final Class type = setterParamTypes.get(i - 1); - values.add(resultSetValueGetter.getValueBySetterType(resultSet, i, type)); - } - return values; - } catch (IllegalArgumentException | SecurityException | SQLException e) { - throw new OrmException(e); + List> setterParamTypes) throws SQLException { + final List values = new ArrayList<>(setterParamTypes.size()); + for (int i = 1; i <= setterParamTypes.size(); i++) { + final Class type = setterParamTypes.get(i - 1); + values.add(resultSetValueGetter.getValueBySetterType(resultSet, i, type)); } + return values; } - public Object getValueByClass(ResultSet resultSet, int i, Class classType) throws SQLException { + public Object getValueByClass(ResultSet resultSet, int i, Class classType) + throws SQLException { return resultSetValueGetter.getValueBySetterType(resultSet, i, classType); } From 241c20f26d795a751c48d997bbedd23580a3ca42 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:40:08 +0900 Subject: [PATCH 04/13] Add tests --- .../java/org/nkjmlab/sorm4j/SormTest.java | 87 ++++++++++++++++++- 1 file changed, 86 insertions(+), 1 deletion(-) diff --git a/src/test/java/org/nkjmlab/sorm4j/SormTest.java b/src/test/java/org/nkjmlab/sorm4j/SormTest.java index c9b1c762..5b6c224d 100644 --- a/src/test/java/org/nkjmlab/sorm4j/SormTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/SormTest.java @@ -11,8 +11,8 @@ import org.nkjmlab.sorm4j.mapping.OrmTransaction; import org.nkjmlab.sorm4j.mapping.TypedOrmTransaction; import org.nkjmlab.sorm4j.util.Guest; -import org.nkjmlab.sorm4j.util.SormTestUtils; import org.nkjmlab.sorm4j.util.Player; +import org.nkjmlab.sorm4j.util.SormTestUtils; class SormTest { @@ -62,6 +62,91 @@ void testException1() throws SQLException { failBecauseExceptionWasNotThrown(OrmException.class); } catch (OrmException e) { } + try { + sorm.execute(con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.execute(Guest.class, con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.executeTransaction(con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.executeTransaction(Guest.class, con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.executeTransaction(1, con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.executeTransaction(Guest.class, 1, con -> { + return 1; + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.runWithJdbcConnection(con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.run(con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.run(Guest.class, con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.runTransaction(con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.runTransaction(Guest.class, con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.runTransaction(1, con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + try { + sorm.runTransaction(Guest.class, 1, con -> { + }); + failBecauseExceptionWasNotThrown(OrmException.class); + } catch (OrmException e) { + } + } @Test From 771b36898b171990c97d6081df0151a959c51170 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:43:19 +0900 Subject: [PATCH 05/13] Modify throw declaration --- .../nkjmlab/sorm4j/config/ColumnFieldMapper.java | 8 +++++--- .../sorm4j/mapping/DefaultColumnFieldMapper.java | 15 +++++---------- 2 files changed, 10 insertions(+), 13 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/config/ColumnFieldMapper.java b/src/main/java/org/nkjmlab/sorm4j/config/ColumnFieldMapper.java index 41e6d141..5ad5462f 100644 --- a/src/main/java/org/nkjmlab/sorm4j/config/ColumnFieldMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/config/ColumnFieldMapper.java @@ -3,6 +3,7 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.sql.DatabaseMetaData; +import java.sql.SQLException; import java.util.List; import java.util.Map; import java.util.Optional; @@ -37,11 +38,12 @@ public interface ColumnFieldMapper extends OrmConfig { */ List getColumnNameCandidates(List fieldNames); - List getAutoGeneratedColumns(DatabaseMetaData metaData, String tableName); + List getAutoGeneratedColumns(DatabaseMetaData metaData, String tableName) + throws SQLException; - List getColumns(DatabaseMetaData metaData, String tableName); + List getColumns(DatabaseMetaData metaData, String tableName) throws SQLException; - List getPrimaryKeys(DatabaseMetaData metaData, String tableName); + List getPrimaryKeys(DatabaseMetaData metaData, String tableName) throws SQLException; diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultColumnFieldMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultColumnFieldMapper.java index b3434e2b..49c8e3bb 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultColumnFieldMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultColumnFieldMapper.java @@ -13,7 +13,6 @@ import java.util.Objects; import java.util.Optional; import java.util.stream.Collectors; -import org.nkjmlab.sorm4j.OrmException; import org.nkjmlab.sorm4j.annotation.OrmColum; import org.nkjmlab.sorm4j.annotation.OrmGetter; import org.nkjmlab.sorm4j.annotation.OrmSetter; @@ -81,7 +80,8 @@ public List getColumnNameCandidates(List fieldNames) { @Override - public List getAutoGeneratedColumns(DatabaseMetaData metaData, String tableName) { + public List getAutoGeneratedColumns(DatabaseMetaData metaData, String tableName) + throws SQLException { try (ResultSet resultSet = metaData.getColumns(null, getSchemaPattern(metaData), tableName, "%")) { final List columnsList = new ArrayList<>(); @@ -93,14 +93,12 @@ public List getAutoGeneratedColumns(DatabaseMetaData metaData, String ta } } return columnsList; - } catch (SQLException e) { - throw new OrmException(e); } } @Override - public List getColumns(DatabaseMetaData metaData, String tableName) { + public List getColumns(DatabaseMetaData metaData, String tableName) throws SQLException { try (ResultSet resultSet = metaData.getColumns(null, getSchemaPattern(metaData), tableName, "%")) { final List columnsList = new ArrayList<>(); @@ -110,13 +108,12 @@ public List getColumns(DatabaseMetaData metaData, String tableName) { columnsList.add(new ColumnOnTable(columnName, dataType)); } return columnsList; - } catch (SQLException e) { - throw new OrmException(e); } } @Override - public List getPrimaryKeys(DatabaseMetaData metaData, String tableName) { + public List getPrimaryKeys(DatabaseMetaData metaData, String tableName) + throws SQLException { final List primaryKeysList = new ArrayList<>(); try (ResultSet resultSet = metaData.getPrimaryKeys(null, getSchemaPattern(metaData), tableName)) { @@ -125,8 +122,6 @@ public List getPrimaryKeys(DatabaseMetaData metaData, String tableName) primaryKeysList.add(columnName); } return primaryKeysList; - } catch (SQLException e) { - throw new OrmException(e); } } From 903ba47c6d948d469bc2e64227849bfbec577c1a Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 13:59:51 +0900 Subject: [PATCH 06/13] Add private constructor for util --- src/main/java/org/nkjmlab/sorm4j/util/ArrayUtils.java | 1 + src/main/java/org/nkjmlab/sorm4j/util/DebugPoint.java | 7 +------ .../java/org/nkjmlab/sorm4j/util/DebugPointFactory.java | 2 ++ src/main/java/org/nkjmlab/sorm4j/util/LoggerFactory.java | 2 ++ .../org/nkjmlab/sorm4j/util/PreparedStatementUtils.java | 2 ++ src/main/java/org/nkjmlab/sorm4j/util/StringUtils.java | 2 ++ src/main/java/org/nkjmlab/sorm4j/util/Try.java | 4 +++- 7 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/util/ArrayUtils.java b/src/main/java/org/nkjmlab/sorm4j/util/ArrayUtils.java index c2674747..d9cb620f 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/ArrayUtils.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/ArrayUtils.java @@ -7,6 +7,7 @@ public final class ArrayUtils { + private ArrayUtils() {} @SafeVarargs public static List split(int size, T... objects) { diff --git a/src/main/java/org/nkjmlab/sorm4j/util/DebugPoint.java b/src/main/java/org/nkjmlab/sorm4j/util/DebugPoint.java index 0e6ca69f..d6328d1c 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/DebugPoint.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/DebugPoint.java @@ -2,7 +2,7 @@ public final class DebugPoint { - public final String name; + private final String name; private final long startTime; public DebugPoint(String name) { @@ -10,11 +10,6 @@ public DebugPoint(String name) { this.startTime = System.nanoTime(); } - @Override - public String toString() { - return this.getClass().getSimpleName() + "(" + name + ")"; - } - public String getFormattedNameAndElapsedTime() { return "[" + name + "]" + " [" + String.format("%.3f", (double) (System.nanoTime() - startTime) / 1000 / 1000) diff --git a/src/main/java/org/nkjmlab/sorm4j/util/DebugPointFactory.java b/src/main/java/org/nkjmlab/sorm4j/util/DebugPointFactory.java index ec1c750b..82f4e4c0 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/DebugPointFactory.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/DebugPointFactory.java @@ -7,6 +7,8 @@ public final class DebugPointFactory { + private DebugPointFactory() {} + public enum Name { MAPPING, READ, LOAD_OBJECT, EXECUTE_BATCH, EXECUTE_UPDATE, TEMP; } diff --git a/src/main/java/org/nkjmlab/sorm4j/util/LoggerFactory.java b/src/main/java/org/nkjmlab/sorm4j/util/LoggerFactory.java index 71d70d81..58e5973f 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/LoggerFactory.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/LoggerFactory.java @@ -4,6 +4,8 @@ public final class LoggerFactory { + private LoggerFactory() {} + public static Logger getLogger() { String className = getInvokerClassName(3); return org.slf4j.LoggerFactory.getLogger(className); diff --git a/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java b/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java index e83f49bd..4fe5f55d 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java @@ -7,6 +7,8 @@ public final class PreparedStatementUtils { + private PreparedStatementUtils() {} + public static PreparedStatement getPreparedStatement(Connection connection, String sql) { try { return connection.prepareStatement(sql); diff --git a/src/main/java/org/nkjmlab/sorm4j/util/StringUtils.java b/src/main/java/org/nkjmlab/sorm4j/util/StringUtils.java index 6d0efbc1..c3cec944 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/StringUtils.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/StringUtils.java @@ -10,6 +10,8 @@ public final class StringUtils { + private StringUtils() {}; + private static final ConcurrentMap upperCaseCaches = new ConcurrentHashMap<>(); public static String toUpperCase(String str) { diff --git a/src/main/java/org/nkjmlab/sorm4j/util/Try.java b/src/main/java/org/nkjmlab/sorm4j/util/Try.java index c88d47c3..29b5d03c 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/Try.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/Try.java @@ -5,7 +5,9 @@ import java.util.function.Supplier; public final class Try { - //private static final org.slf4j.Logger log = org.nkjmlab.sorm4j.util.LoggerFactory.getLogger(); + // private static final org.slf4j.Logger log = org.nkjmlab.sorm4j.util.LoggerFactory.getLogger(); + + private Try() {} @FunctionalInterface public static interface ThrowableRunnable { From 44d363e50e936a653a1a85ffd1924fcb77469df2 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 14:03:32 +0900 Subject: [PATCH 07/13] Fix bug of indicate Map.class. --- .../java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java | 4 +++- src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java | 2 +- .../java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java | 6 ++++++ 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java index 035ac427..f7474899 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java @@ -9,6 +9,7 @@ import java.sql.SQLException; import java.util.ArrayList; import java.util.Collection; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; @@ -394,7 +395,8 @@ public LazyResultSet> readMapLazy(String sql, Object... para final ResultSet resultSet = stmt.executeQuery(); @SuppressWarnings({"unchecked", "rawtypes", "resource"}) LazyResultSet> ret = - (LazyResultSet>) new LazyResultSet(this, Map.class, stmt, resultSet); + (LazyResultSet>) new LazyResultSet(this, LinkedHashMap.class, stmt, + resultSet); return ret; } catch (SQLException e) { throw new OrmException(e); diff --git a/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java index 5e222061..2785f735 100644 --- a/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java @@ -11,8 +11,8 @@ import org.junit.jupiter.api.Test; import org.nkjmlab.sorm4j.util.DebugPointFactory; import org.nkjmlab.sorm4j.util.Guest; -import org.nkjmlab.sorm4j.util.SormTestUtils; import org.nkjmlab.sorm4j.util.Player; +import org.nkjmlab.sorm4j.util.SormTestUtils; class OrmConnectionTest { diff --git a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java index f4adba4e..2fa19182 100644 --- a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java @@ -328,6 +328,12 @@ void testReadLazy() { assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) .isEqualTo(a.getName()); + map = + m.readLazy(SqlStatement.of("select * from players")).toMapList().get(0); + assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) + .isEqualTo(a.getName()); + + map = m.readMapFirst(SqlStatement.of("select * from players")); assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) .isEqualTo(a.getName()); From 584772f7ed1af0efaecdc4a34c1ebc56d029cd87 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 14:19:04 +0900 Subject: [PATCH 08/13] Add tests --- .../sorm4j/TypedOrmConnectionTest.java | 5 +-- .../sorm4j/mapping/ValuesObjectTest.java | 39 +++++++++---------- 2 files changed, 21 insertions(+), 23 deletions(-) diff --git a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java index 2fa19182..c36422d6 100644 --- a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java @@ -48,7 +48,7 @@ void testTableName() { try { sorm.run(Guest.class, m -> { - new DefaultTableNameMapper().toValidTableName("aaa", m.getJdbcConnection()); + new DefaultTableNameMapper().toValidTableName("aaa", m.getJdbcConnection().getMetaData()); failBecauseExceptionWasNotThrown(Exception.class); }); } catch (Exception e) { @@ -328,8 +328,7 @@ void testReadLazy() { assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) .isEqualTo(a.getName()); - map = - m.readLazy(SqlStatement.of("select * from players")).toMapList().get(0); + map = m.readLazy(SqlStatement.of("select * from players")).toMapList().get(0); assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) .isEqualTo(a.getName()); diff --git a/src/test/java/org/nkjmlab/sorm4j/mapping/ValuesObjectTest.java b/src/test/java/org/nkjmlab/sorm4j/mapping/ValuesObjectTest.java index 90dd397e..1ef27ce4 100644 --- a/src/test/java/org/nkjmlab/sorm4j/mapping/ValuesObjectTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/mapping/ValuesObjectTest.java @@ -9,35 +9,34 @@ class ValuesObjectTest { @Test void testTableName() { System.out.println(LoggerFactory.class.getName()); + TableName v1 = new TableName("test"); + TableName v2 = new TableName("test"); + verify(v1, v2); + + } + + private void verify(Object v1, Object v2) { + assertThat(v1.toString().equals("test")).isTrue(); + assertThat(v1.equals(v1)).isTrue(); + assertThat(v1.equals(v2)).isTrue(); + assertThat(v1.equals("test")).isFalse(); + assertThat(v1.hashCode()).isEqualTo(v2.hashCode()); - TableName t1 = new TableName("test"); - TableName t2 = new TableName("test"); - assertThat(t1.toString()).isEqualTo("test"); - assertThat(t1).isEqualTo(t1); - assertThat(t1).isEqualTo(t2); - assertThat(t1.hashCode()).isEqualTo(t2.hashCode()); - assertThat(t1).isNotEqualTo("test"); - assertThat(t1.toString()).isEqualTo("test"); } @Test void testFieldName() { - FieldName t1 = new FieldName("test"); - FieldName t2 = new FieldName("test"); - assertThat(t1.toString()).isEqualTo("test"); - assertThat(t1).isEqualTo(t1); - assertThat(t1).isEqualTo(t2); - assertThat(t1.hashCode()).isEqualTo(t2.hashCode()); + FieldName v1 = new FieldName("test"); + FieldName v2 = new FieldName("test"); + verify(v1, v2); } @Test void testColumn() { - Column t1 = new Column("test"); - Column t2 = new Column("test"); - assertThat(t1.toString()).isEqualTo("test"); - assertThat(t1).isEqualTo(t1); - assertThat(t1).isEqualTo(t2); - assertThat(t1.hashCode()).isEqualTo(t2.hashCode()); + Column v1 = new Column("test"); + Column v2 = new Column("test"); + verify(v1, v2); + } } From 6f9271e399d0fa0032e60569c03dab0ee32f1e09 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 14:19:13 +0900 Subject: [PATCH 09/13] Modify throw --- .../sorm4j/config/TableNameMapper.java | 9 ++-- .../sorm4j/mapping/AbstractOrmMapper.java | 8 ++- .../mapping/DefaultTableNameMapper.java | 53 +++++++++---------- 3 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/config/TableNameMapper.java b/src/main/java/org/nkjmlab/sorm4j/config/TableNameMapper.java index 13acf8a0..40812c53 100644 --- a/src/main/java/org/nkjmlab/sorm4j/config/TableNameMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/config/TableNameMapper.java @@ -1,6 +1,7 @@ package org.nkjmlab.sorm4j.config; -import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.SQLException; import org.nkjmlab.sorm4j.mapping.TableName; public interface TableNameMapper extends OrmConfig { @@ -9,11 +10,11 @@ public interface TableNameMapper extends OrmConfig { * Get table name corresponding with the object class. * * @param objectClass object class mapping to table - * @param connection + * @param metaData * @return table name exists in database. */ - TableName getTableName(Class objectClass, Connection connection); + TableName getTableName(Class objectClass, DatabaseMetaData metaData) throws SQLException; - TableName toValidTableName(String tableName, Connection connection); + TableName toValidTableName(String tableName, DatabaseMetaData metaData) throws SQLException; } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java index f7474899..7459ce90 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java @@ -463,12 +463,16 @@ private final T toSinglePojo(final Class objectClass, final ResultSet res private TableName toTableName(Class objectClass) { return classNameToValidTableNameMap.computeIfAbsent(objectClass, - k -> tableNameMapper.getTableName(objectClass, connection)); + Try.createFunctionWithThrow( + k -> tableNameMapper.getTableName(objectClass, connection.getMetaData()), + OrmException::new)); } private TableName toTableName(String tableName) { return tableNameToValidTableNameMap.computeIfAbsent(tableName, - k -> tableNameMapper.toValidTableName(tableName, connection)); + Try.createFunctionWithThrow( + k -> tableNameMapper.toValidTableName(tableName, connection.getMetaData()), + OrmException::new)); } private static ColumnsAndTypes createColumnsAndTypes(ResultSet resultSet) { diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultTableNameMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultTableNameMapper.java index 43f7dacd..64c77718 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultTableNameMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/DefaultTableNameMapper.java @@ -1,7 +1,6 @@ package org.nkjmlab.sorm4j.mapping; import static org.nkjmlab.sorm4j.util.StringUtils.*; -import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.ResultSet; import java.sql.SQLException; @@ -17,34 +16,27 @@ public final class DefaultTableNameMapper implements TableNameMapper { @Override - public TableName toValidTableName(String tableName, Connection connection) { - try { - List candidates = List.of(StringUtils.toUpperCase(tableName)); - DatabaseMetaData metaData = connection.getMetaData(); - return getTableNameOnDb(metaData, candidates).orElseThrow(() -> new OrmException(StringUtils - .format("[{}] does not match a existing table in the db. Candidates Name are {}", - tableName, candidates))); - } catch (SQLException e) { - throw new OrmException(e); - } + public TableName toValidTableName(String tableName, DatabaseMetaData metaData) + throws SQLException { + List candidates = List.of(StringUtils.toUpperCase(tableName)); + return getTableNameOnDb(metaData, candidates).orElseThrow(() -> new OrmException(StringUtils + .format("[{}] does not match a existing table in the db. Candidates Name are {}", + tableName, candidates))); } @Override - public TableName getTableName(final Class objectClass, final Connection connection) { - try { - DatabaseMetaData metaData = connection.getMetaData(); - final OrmTable tableAnnotation = objectClass.getAnnotation(OrmTable.class); - List candidates = (tableAnnotation != null && !tableAnnotation.value().equals("")) - ? Arrays.asList(tableAnnotation.value()) - : guessTableNameCandidates(objectClass); - return getTableNameOnDb(metaData, candidates) - .orElseThrow(() -> new OrmException(StringUtils.format( - "[{}] does not match a existing table in the db. Use [{}] annotation correctly. Candidates Name are {}", - objectClass.getName(), OrmTable.class.getName(), candidates))); - } catch (SQLException e) { - throw new OrmException(e); - } + public TableName getTableName(Class objectClass, DatabaseMetaData metaData) + throws SQLException { + + final OrmTable tableAnnotation = objectClass.getAnnotation(OrmTable.class); + List candidates = (tableAnnotation != null && !tableAnnotation.value().equals("")) + ? Arrays.asList(tableAnnotation.value()) + : guessTableNameCandidates(objectClass); + return getTableNameOnDb(metaData, candidates) + .orElseThrow(() -> new OrmException(StringUtils.format( + "[{}] does not match a existing table in the db. Use [{}] annotation correctly. Candidates Name are {}", + objectClass.getName(), OrmTable.class.getName(), candidates))); } List guessTableNameCandidates(Class objectClass) { @@ -56,9 +48,14 @@ List guessTableNameCandidates(Class objectClass) { /** * Check if the given names corresponds to a table in the database and returns the corresponding * name returned by the database metadata + * + * @param metaData + * @param tableNameCandidates + * @return + * @throws SQLException */ - Optional getTableNameOnDb(DatabaseMetaData metaData, - List tableNameCandidates) { + public Optional getTableNameOnDb(DatabaseMetaData metaData, + List tableNameCandidates) throws SQLException { try ( ResultSet resultSet = metaData.getTables(null, null, "%", new String[] {"TABLE", "VIEW"})) { @@ -69,8 +66,6 @@ Optional getTableNameOnDb(DatabaseMetaData metaData, } } return Optional.empty(); - } catch (SQLException e) { - throw new OrmException(e); } } From 0ef149ba67840ee95f163056e7853044fa1e8d8a Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 14:38:03 +0900 Subject: [PATCH 10/13] Modify throw --- .../org/nkjmlab/sorm4j/LazyResultSet.java | 16 +- .../sorm4j/mapping/AbstractOrmMapper.java | 155 ++++++++---------- .../sorm4j/mapping/ColumnsMapping.java | 38 ++--- .../sorm4j/TypedOrmConnectionTest.java | 6 + ...OfMultiRowInOneStatementProcessorTest.java | 13 +- 5 files changed, 107 insertions(+), 121 deletions(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java index 54b23548..3d22e5d1 100644 --- a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java +++ b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java @@ -42,7 +42,7 @@ public LazyResultSet(AbstractOrmMapper ormMapper, Class objectClass, Prepared * @return */ public T one() { - T ret = ormMapper.loadOne(objectClass, resultSet); + T ret = Try.getOrThrow(() -> ormMapper.loadOne(objectClass, resultSet), OrmException::new); close(); return ret; } @@ -53,7 +53,7 @@ public T one() { * @return */ public T first() { - T ret = ormMapper.loadFirst(objectClass, resultSet); + T ret = Try.getOrThrow(() -> ormMapper.loadFirst(objectClass, resultSet), OrmException::new); close(); return ret; } @@ -64,13 +64,15 @@ public T first() { * @return */ public List toList() { - List ret = ormMapper.loadPojoList(objectClass, resultSet); + List ret = + Try.getOrThrow(() -> ormMapper.loadPojoList(objectClass, resultSet), OrmException::new); close(); return ret; } public Map oneMap() { - Map ret = ormMapper.loadOneMap(resultSet); + Map ret = + Try.getOrThrow(() -> ormMapper.loadOneMap(resultSet), OrmException::new); close(); return ret; } @@ -81,7 +83,8 @@ public Map oneMap() { * @return */ public Map firstMap() { - Map ret = ormMapper.loadFirstMap(resultSet); + Map ret = + Try.getOrThrow(() -> ormMapper.loadFirstMap(resultSet), OrmException::new); close(); return ret; } @@ -93,7 +96,8 @@ public Map firstMap() { * @return */ public List> toMapList() { - List> ret = ormMapper.loadMapList(resultSet); + List> ret = + Try.getOrThrow(() -> ormMapper.loadMapList(resultSet), OrmException::new); close(); return ret; } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java index 7459ce90..287b19c7 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java @@ -29,6 +29,7 @@ import org.nkjmlab.sorm4j.util.DebugPointFactory; import org.nkjmlab.sorm4j.util.StringUtils; import org.nkjmlab.sorm4j.util.Try; +import org.nkjmlab.sorm4j.util.Try.ThrowableFunction; public abstract class AbstractOrmMapper implements SqlExecutor { private static final org.slf4j.Logger log = org.nkjmlab.sorm4j.util.LoggerFactory.getLogger(); @@ -98,7 +99,7 @@ private R execPreparedStatementWithParameters(String sql, Object[] parameter } private R execResultSet(String sql, Object[] parameters, - Function sqlResultReader) { + ThrowableFunction sqlResultReader) { try (PreparedStatement stmt = getPreparedStatement(connection, sql)) { preparedParametersSetter.setParameters(stmt, parameters); try (ResultSet resultSet = stmt.executeQuery()) { @@ -111,7 +112,7 @@ private R execResultSet(String sql, Object[] parameters, Try.getOrNull(() -> connection.getMetaData().getURL()))); return ret; } - } catch (Exception e) { + } catch (Throwable e) { String msg = (parameters == null || parameters.length == 0) ? StringUtils.format("Error in [{}]", sql) : StringUtils.format("Error in [{}] with {}", sql, parameters); @@ -218,102 +219,80 @@ TableMapping getTableMapping(TableName tableName, Class objectClass) { } - public T loadFirst(Class objectClass, ResultSet resultSet) { - try { - if (resultSet.next()) { - return toSingleObject(objectClass, resultSet); - } - return null; - } catch (SQLException e) { - throw new OrmException(e); + public T loadFirst(Class objectClass, ResultSet resultSet) throws SQLException { + if (resultSet.next()) { + return toSingleObject(objectClass, resultSet); } + return null; } - public Map loadFirstMap(ResultSet resultSet) { - try { - Map ret = null; - if (resultSet.next()) { - ret = toSingleMap(resultSet); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + public Map loadFirstMap(ResultSet resultSet) throws SQLException { + Map ret = null; + if (resultSet.next()) { + ret = toSingleMap(resultSet); } + return ret; } - public List> loadMapList(ResultSet resultSet) { - try { - final List> ret = new ArrayList<>(); - ColumnsAndTypes ct = createColumnsAndTypes(resultSet); - while (resultSet.next()) { - ret.add(resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes())); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + public List> loadMapList(ResultSet resultSet) throws SQLException { + final List> ret = new ArrayList<>(); + ColumnsAndTypes ct = createColumnsAndTypes(resultSet); + while (resultSet.next()) { + ret.add(resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes())); } + return ret; } - private final List loadNativeObjectList(Class objectClass, ResultSet resultSet) { - try { - final Optional dp = - DebugPointFactory.createDebugPoint(DebugPointFactory.Name.LOAD_OBJECT); - final List ret = new ArrayList<>(); - while (resultSet.next()) { - ret.add(resultSetConverter.toSingleNativeObject(resultSet, objectClass)); - } - dp.ifPresent(sw -> { - try { - ResultSetMetaData metaData = resultSet.getMetaData(); - if (metaData.getColumnCount() != 1) { - throw new OrmException("ResultSet returned [" + metaData.getColumnCount() - + "] columns but 1 column was expected to load data into an instance of [" - + objectClass.getName() + "]"); - } - } catch (SQLException e) { - throw new OrmException(e); - } - }); - return ret; - } catch (SQLException e) { - throw new OrmException(e); + private final List loadNativeObjectList(Class objectClass, ResultSet resultSet) + throws SQLException { + final Optional dp = + DebugPointFactory.createDebugPoint(DebugPointFactory.Name.LOAD_OBJECT); + final List ret = new ArrayList<>(); + while (resultSet.next()) { + ret.add(resultSetConverter.toSingleNativeObject(resultSet, objectClass)); } + dp.ifPresent(sw -> { + try { + ResultSetMetaData metaData = resultSet.getMetaData(); + if (metaData.getColumnCount() != 1) { + throw new OrmException("ResultSet returned [" + metaData.getColumnCount() + + "] columns but 1 column was expected to load data into an instance of [" + + objectClass.getName() + "]"); + } + } catch (SQLException e) { + throw new OrmException(e); + } + }); + return ret; } - public T loadOne(Class objectClass, ResultSet resultSet) { - try { - T ret = null; - if (resultSet.next()) { - ret = toSingleObject(objectClass, resultSet); - } - if (resultSet.next()) { - throw new RuntimeException("Non-unique result returned"); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + public T loadOne(Class objectClass, ResultSet resultSet) throws SQLException { + T ret = null; + if (resultSet.next()) { + ret = toSingleObject(objectClass, resultSet); + } + if (resultSet.next()) { + throw new RuntimeException("Non-unique result returned"); } + return ret; } - public Map loadOneMap(ResultSet resultSet) { - try { - Map ret = null; - if (resultSet.next()) { - ret = toSingleMap(resultSet); - } - if (resultSet.next()) { - throw new OrmException("Non-unique result returned"); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + public Map loadOneMap(ResultSet resultSet) throws SQLException { + Map ret = null; + if (resultSet.next()) { + ret = toSingleMap(resultSet); + } + if (resultSet.next()) { + throw new OrmException("Non-unique result returned"); } + return ret; } - public final List loadPojoList(final Class objectClass, final ResultSet resultSet) { + public final List loadPojoList(final Class objectClass, final ResultSet resultSet) + throws SQLException { ColumnsMapping mapping = getColumnsMapping(objectClass); return mapping.loadObjectList(resultSet); } @@ -475,20 +454,16 @@ private TableName toTableName(String tableName) { OrmException::new)); } - private static ColumnsAndTypes createColumnsAndTypes(ResultSet resultSet) { - try { - ResultSetMetaData metaData = resultSet.getMetaData(); - int colNum = metaData.getColumnCount(); - List columns = new ArrayList<>(colNum); - List columnTypes = new ArrayList<>(colNum); - for (int i = 1; i <= colNum; i++) { - columns.add(metaData.getColumnName(i)); - columnTypes.add(metaData.getColumnType(i)); - } - return new ColumnsAndTypes(columns, columnTypes); - } catch (SQLException e) { - throw new OrmException(e); + private static ColumnsAndTypes createColumnsAndTypes(ResultSet resultSet) throws SQLException { + ResultSetMetaData metaData = resultSet.getMetaData(); + int colNum = metaData.getColumnCount(); + List columns = new ArrayList<>(colNum); + List columnTypes = new ArrayList<>(colNum); + for (int i = 1; i <= colNum; i++) { + columns.add(metaData.getColumnName(i)); + columnTypes.add(metaData.getColumnType(i)); } + return new ColumnsAndTypes(columns, columnTypes); } private static class ColumnsAndTypes { diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java b/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java index 5cdcbfa9..2ee3080e 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/ColumnsMapping.java @@ -45,20 +45,16 @@ public T loadObject(ResultSet resultSet) throws SQLException { resultSetConverter.toObjectsByClasses(resultSet, setterParamTypes)); } - public final List loadObjectList(ResultSet resultSet) { - try { - List columns = createColumns(resultSet); - List> setterParamTypes = getSetterParamTypes(columns); + public final List loadObjectList(ResultSet resultSet) throws SQLException { + List columns = createColumns(resultSet); + List> setterParamTypes = getSetterParamTypes(columns); - final List ret = new ArrayList<>(); - while (resultSet.next()) { - ret.add(createObject(columns, - resultSetConverter.toObjectsByClasses(resultSet, setterParamTypes))); - } - return ret; - } catch (IllegalArgumentException | SecurityException | SQLException e) { - throw new OrmException(e); + final List ret = new ArrayList<>(); + while (resultSet.next()) { + ret.add(createObject(columns, + resultSetConverter.toObjectsByClasses(resultSet, setterParamTypes))); } + return ret; } @@ -78,18 +74,14 @@ private T createObject(List columns, List values) { } } - private static List createColumns(ResultSet resultSet) { - try { - ResultSetMetaData metaData = resultSet.getMetaData(); - int colNum = metaData.getColumnCount(); - List columns = new ArrayList<>(colNum); - for (int i = 1; i <= colNum; i++) { - columns.add(metaData.getColumnName(i)); - } - return columns; - } catch (IllegalArgumentException | SecurityException | SQLException e) { - throw new OrmException(e); + private static List createColumns(ResultSet resultSet) throws SQLException { + ResultSetMetaData metaData = resultSet.getMetaData(); + int colNum = metaData.getColumnCount(); + List columns = new ArrayList<>(colNum); + for (int i = 1; i <= colNum; i++) { + columns.add(metaData.getColumnName(i)); } + return columns; } private final Map, List>> setterParamTypesMap = new ConcurrentHashMap<>(); diff --git a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java index c36422d6..1cd128b9 100644 --- a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java @@ -57,6 +57,12 @@ void testTableName() { Guest a = SormTestUtils.GUEST_ALICE; sorm.run(Guest.class, conn -> { + + conn.executeTransaction(tr -> { + return 1; + }); + + OrmConnection orm = Sorm.toUntyped(conn); Sorm.toTyped(orm, Guest.class); orm.runTransaction(tr -> { diff --git a/src/test/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessorTest.java b/src/test/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessorTest.java index 41b00ed6..9b5ec509 100644 --- a/src/test/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessorTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessorTest.java @@ -3,14 +3,17 @@ import static org.assertj.core.api.Assertions.*; import static org.nkjmlab.sorm4j.util.SormTestUtils.*; import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.nkjmlab.sorm4j.Sorm; import org.nkjmlab.sorm4j.connectionsource.ConnectionSource; import org.nkjmlab.sorm4j.util.DebugPointFactory; -import org.nkjmlab.sorm4j.util.SormTestUtils; +import org.nkjmlab.sorm4j.util.Guest; import org.nkjmlab.sorm4j.util.Player; +import org.nkjmlab.sorm4j.util.SormTestUtils; class BatchOfMultiRowInOneStatementProcessorTest { @@ -36,7 +39,7 @@ static void setUp() { @BeforeEach void setUpEach() { - SormTestUtils.dropAndCreateTable(sorm, Player.class); + SormTestUtils.dropAndCreateTableAll(sorm); } @Test @@ -52,6 +55,12 @@ void testMultiRowInsert() { sorm.run(Player.class, conn -> conn.insert(a, b)); } + @Test + void testMultiRowInsertMany() { + sorm.run(Guest.class, conn -> conn + .insert(Stream.generate(() -> GUEST_ALICE).limit(3000).collect(Collectors.toList()))); + } + @Test void testMultiRowMerge() { sorm.run(Player.class, conn -> conn.merge(a, b, c)); From 00081ee37c7645f6eced39909cd5859c453232e2 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 16:17:50 +0900 Subject: [PATCH 11/13] Modify throw error. --- .../sorm4j/mapping/AbstractOrmMapper.java | 160 ++++++++------- ...atchOfMultiRowInOneStatementProcessor.java | 10 +- .../MultiRowInOneStatementProcessor.java | 11 +- .../sorm4j/mapping/MultiRowProcessor.java | 2 +- .../nkjmlab/sorm4j/mapping/OrmMapperImpl.java | 4 +- .../nkjmlab/sorm4j/mapping/TableMapping.java | 185 +++++++++--------- .../sorm4j/mapping/TypedOrmMapperImpl.java | 6 +- .../sorm4j/util/PreparedStatementUtils.java | 30 +-- .../java/org/nkjmlab/sorm4j/util/Try.java | 24 +++ .../org/nkjmlab/sorm4j/OrmConnectionTest.java | 3 + .../sorm4j/TypedOrmConnectionTest.java | 11 ++ .../DefaultResultSetValueGetterTest.java | 7 + .../util/PreparedStatementUtilsTest.java | 23 --- 13 files changed, 237 insertions(+), 239 deletions(-) delete mode 100644 src/test/java/org/nkjmlab/sorm4j/util/PreparedStatementUtilsTest.java diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java index 287b19c7..d92e9a2f 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/AbstractOrmMapper.java @@ -41,7 +41,7 @@ public abstract class AbstractOrmMapper implements SqlExecutor { private final ResultSetConverter resultSetConverter; - private final PreparedStatementParametersSetter preparedParametersSetter; + private final PreparedStatementParametersSetter preparedStatementParametersSetter; private final Connection connection; @@ -70,7 +70,7 @@ public AbstractOrmMapper(Connection connection, OrmConfigStore configStore) { this.fieldMapper = configStore.getColumnFieldMapper(); this.tableNameMapper = configStore.getTableNameMapper(); this.resultSetConverter = new ResultSetConverter(configStore.getSqlToJavaDataConverter()); - this.preparedParametersSetter = configStore.getJavaToSqlDataConverter(); + this.preparedStatementParametersSetter = configStore.getJavaToSqlDataConverter(); String cacheName = configStore.getConfigName(); this.tableMappings = OrmCache.getTableMappings(cacheName); this.columnsMappings = OrmCache.getColumnsMappings(cacheName); @@ -88,37 +88,6 @@ public int deleteAllOn(String tableName) { } - private R execPreparedStatementWithParameters(String sql, Object[] parameters, - Function func) { - try (PreparedStatement stmt = getPreparedStatement(connection, sql)) { - preparedParametersSetter.setParameters(stmt, parameters); - return func.apply(stmt); - } catch (SQLException e) { - throw new OrmException(e); - } - } - - private R execResultSet(String sql, Object[] parameters, - ThrowableFunction sqlResultReader) { - try (PreparedStatement stmt = getPreparedStatement(connection, sql)) { - preparedParametersSetter.setParameters(stmt, parameters); - try (ResultSet resultSet = stmt.executeQuery()) { - Optional dp = DebugPointFactory.createDebugPoint(DebugPointFactory.Name.READ); - dp.ifPresent(sw -> log.debug("[{}] with {} ", sql, parameters)); - R ret = sqlResultReader.apply(resultSet); - dp.ifPresent( - sw -> log.debug("{} Read [{}] objects from [{}]", sw.getFormattedNameAndElapsedTime(), - ret instanceof Collection ? ((Collection) ret).size() : 1, - Try.getOrNull(() -> connection.getMetaData().getURL()))); - return ret; - } - } catch (Throwable e) { - String msg = - (parameters == null || parameters.length == 0) ? StringUtils.format("Error in [{}]", sql) - : StringUtils.format("Error in [{}] with {}", sql, parameters); - throw new OrmException(msg, e); - } - } protected final R execSqlIfParameterExists(T[] objects, Function, R> sqlFunction, Supplier notExists) { @@ -141,23 +110,59 @@ protected final R execSqlIfParameterExists(T[] objects, String tableName, @Override public boolean execute(String sql, Object... parameters) { - return execPreparedStatementWithParameters(sql, parameters, - Try.createFunctionWithThrow(stmt -> stmt.execute(), OrmException::new)); + return execPreparedStatementAndClose(preparedStatementParametersSetter, connection, sql, + parameters, stmt -> stmt.execute()); } @Override public ResultSet executeQuery(String sql, Object... parameters) { - return execPreparedStatementWithParameters(sql, parameters, - Try.createFunctionWithThrow(stmt -> stmt.executeQuery(), OrmException::new)); + return execPreparedStatementAndClose(preparedStatementParametersSetter, connection, sql, + parameters, stmt -> stmt.executeQuery()); } @Override public int executeUpdate(String sql, Object... parameters) { - return execPreparedStatementWithParameters(sql, parameters, - Try.createFunctionWithThrow(stmt -> stmt.executeUpdate(), OrmException::new)); + return execPreparedStatementAndClose(preparedStatementParametersSetter, connection, sql, + parameters, stmt -> stmt.executeUpdate()); } + private R execStatementAndReadResultSet(String sql, Object[] parameters, + ThrowableFunction sqlResultReader) { + try (PreparedStatement stmt = getPreparedStatement(connection, sql)) { + preparedStatementParametersSetter.setParameters(stmt, parameters); + try (ResultSet resultSet = stmt.executeQuery()) { + Optional dp = DebugPointFactory.createDebugPoint(DebugPointFactory.Name.READ); + dp.ifPresent(sw -> log.debug("[{}] with {} ", sql, parameters)); + R ret = sqlResultReader.apply(resultSet); + dp.ifPresent( + sw -> log.debug("{} Read [{}] objects from [{}]", sw.getFormattedNameAndElapsedTime(), + ret instanceof Collection ? ((Collection) ret).size() : 1, + Try.getOrNull(() -> connection.getMetaData().getURL()))); + return ret; + } + } catch (Throwable e) { + String msg = + (parameters == null || parameters.length == 0) ? StringUtils.format("Error in [{}]", sql) + : StringUtils.format("Error in [{}] with {}", sql, parameters); + throw new OrmException(msg, e); + } + } + + + public static final R execPreparedStatementAndClose( + PreparedStatementParametersSetter preparedStatementParametersSetter, Connection connection, + String sql, Object[] parameters, ThrowableFunction func) { + try (PreparedStatement stmt = getPreparedStatement(connection, sql)) { + preparedStatementParametersSetter.setParameters(stmt, parameters); + return func.apply(stmt); + } catch (Throwable e) { + throw new OrmException(e); + } + } + + + @SuppressWarnings("unchecked") protected TableMapping getCastedTableMapping(Class objectClass) { return (TableMapping) getTableMapping(objectClass); @@ -210,8 +215,8 @@ TableMapping getTableMapping(TableName tableName, Class objectClass) { TableMapping ret = (TableMapping) tableMappings.computeIfAbsent(key, Try.createFunctionWithThrow(_key -> { TableMapping m = - TableMapping.createMapping(resultSetConverter, preparedParametersSetter, objectClass, - tableName.getName(), fieldMapper, batchConfig, connection); + TableMapping.createMapping(resultSetConverter, preparedStatementParametersSetter, + objectClass, tableName.getName(), fieldMapper, batchConfig, connection); log.info(System.lineSeparator() + m.getFormattedString()); return m; }, OrmException::new)); @@ -321,20 +326,22 @@ public final LazyResultSet readAllLazyAux(Class objectClass) { protected final T readByPrimaryKeyAux(final Class objectClass, final Object... primaryKeyValues) { final TableMapping mapping = getTableMapping(objectClass); + mapping.throwExeptionIfPrimaryKeysIsNotExist(); final String sql = mapping.getSql().getSelectByPrimaryKeySql(); return readFirstAux(objectClass, sql, primaryKeyValues); } protected final T readFirstAux(Class objectClass, String sql, Object... parameters) { - return execResultSet(sql, parameters, resultSet -> loadFirst(objectClass, resultSet)); + return execStatementAndReadResultSet(sql, parameters, + resultSet -> loadFirst(objectClass, resultSet)); } public final LazyResultSet readLazyAux(Class objectClass, String sql, Object... parameters) { - final PreparedStatement stmt = getPreparedStatement(connection, sql); try { - preparedParametersSetter.setParameters(stmt, parameters); + final PreparedStatement stmt = getPreparedStatement(connection, sql); + preparedStatementParametersSetter.setParameters(stmt, parameters); final ResultSet resultSet = stmt.executeQuery(); return new LazyResultSet(this, objectClass, stmt, resultSet); } catch (SQLException e) { @@ -344,7 +351,7 @@ public final LazyResultSet readLazyAux(Class objectClass, String sql, protected final List readListAux(Class objectClass, String sql, Object... parameters) { - return execResultSet(sql, parameters, + return execStatementAndReadResultSet(sql, parameters, resultSet -> isEnableToConvertNativeSqlType(objectClass) ? loadNativeObjectList(objectClass, resultSet) : loadPojoList(objectClass, resultSet)); @@ -352,25 +359,21 @@ protected final List readListAux(Class objectClass, String sql, Object public Map readMapFirst(final String sql, final Object... parameters) { - return execResultSet(sql, parameters, resultSet -> { - try { - ColumnsAndTypes ct = createColumnsAndTypes(resultSet); - if (resultSet.next()) { - return resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes()); - } - return null; - } catch (SQLException e) { - throw new OrmException(e); + return execStatementAndReadResultSet(sql, parameters, resultSet -> { + ColumnsAndTypes ct = createColumnsAndTypes(resultSet); + if (resultSet.next()) { + return resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes()); } + return null; }); } public LazyResultSet> readMapLazy(String sql, Object... parameters) { - final PreparedStatement stmt = getPreparedStatement(connection, sql); try { - preparedParametersSetter.setParameters(stmt, parameters); + final PreparedStatement stmt = getPreparedStatement(connection, sql); + preparedStatementParametersSetter.setParameters(stmt, parameters); final ResultSet resultSet = stmt.executeQuery(); @SuppressWarnings({"unchecked", "rawtypes", "resource"}) LazyResultSet> ret = @@ -383,42 +386,34 @@ public LazyResultSet> readMapLazy(String sql, Object... para } public List> readMapList(final String sql, final Object... parameters) { - return execResultSet(sql, parameters, resultSet -> loadMapList(resultSet)); + return execStatementAndReadResultSet(sql, parameters, resultSet -> loadMapList(resultSet)); } public Map readMapOne(final String sql, final Object... parameters) { - return execResultSet(sql, parameters, resultSet -> { - try { - ColumnsAndTypes ct = createColumnsAndTypes(resultSet); - Map ret = null; - if (resultSet.next()) { - ret = resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes()); - } - if (resultSet.next()) { - throw new OrmException("Non-unique result returned"); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + return execStatementAndReadResultSet(sql, parameters, resultSet -> { + ColumnsAndTypes ct = createColumnsAndTypes(resultSet); + Map ret = null; + if (resultSet.next()) { + ret = resultSetConverter.toSingleMap(resultSet, ct.getColumns(), ct.getColumnTypes()); } + if (resultSet.next()) { + throw new OrmException("Non-unique result returned"); + } + return ret; }); } protected final T readOneAux(final Class objectClass, final String sql, Object... parameters) { - return execResultSet(sql, parameters, resultSet -> { - try { - T ret = null; - if (resultSet.next()) { - ret = toSingleObject(objectClass, resultSet); - } - if (resultSet.next()) { - throw new OrmException("Non-unique result returned"); - } - return ret; - } catch (SQLException e) { - throw new OrmException(e); + return execStatementAndReadResultSet(sql, parameters, resultSet -> { + T ret = null; + if (resultSet.next()) { + ret = toSingleObject(objectClass, resultSet); + } + if (resultSet.next()) { + throw new OrmException("Non-unique result returned"); } + return ret; }); } @@ -498,5 +493,4 @@ private static boolean isEnableToConvertNativeSqlType(final Class type) { return nativeSqlTypes.contains(type); } - } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessor.java b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessor.java index c50a6c20..9a4976af 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessor.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/BatchOfMultiRowInOneStatementProcessor.java @@ -3,11 +3,11 @@ import java.sql.Connection; import java.sql.PreparedStatement; import java.util.List; -import java.util.function.BiConsumer; -import java.util.function.Function; import org.nkjmlab.sorm4j.OrmException; import org.nkjmlab.sorm4j.util.ArrayUtils; import org.nkjmlab.sorm4j.util.PreparedStatementUtils; +import org.nkjmlab.sorm4j.util.Try.ThrowableBiConsumer; +import org.nkjmlab.sorm4j.util.Try.ThrowableFunction; public final class BatchOfMultiRowInOneStatementProcessor extends MultiRowProcessor { @@ -50,8 +50,8 @@ public final int[] multiRowMerge(Connection con, T... objects) { * @return */ private final int[] procMultiRowOneStatementAndBatch(Connection con, - Function multiRowStatementCreator, - BiConsumer parametersSetter, T[] objects) { + ThrowableFunction multiRowStatementCreator, + ThrowableBiConsumer parametersSetter, T[] objects) { final List objsPartitions = ArrayUtils.split(multiRowSize, objects); final int[] result = new int[objsPartitions.size()]; @@ -78,7 +78,7 @@ private final int[] procMultiRowOneStatementAndBatch(Connection con, result[lastPartition] = lastStmt.executeUpdate(); return result; } - } catch (Exception e) { + } catch (Throwable e) { rollbackIfRequired(con, origAutoCommit); throw new OrmException(e); } finally { diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowInOneStatementProcessor.java b/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowInOneStatementProcessor.java index 766da43e..f7a20b86 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowInOneStatementProcessor.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowInOneStatementProcessor.java @@ -2,13 +2,12 @@ import java.sql.Connection; import java.sql.PreparedStatement; -import java.sql.SQLException; import java.util.List; -import java.util.function.BiConsumer; -import java.util.function.Function; import org.nkjmlab.sorm4j.OrmException; import org.nkjmlab.sorm4j.util.ArrayUtils; import org.nkjmlab.sorm4j.util.PreparedStatementUtils; +import org.nkjmlab.sorm4j.util.Try.ThrowableBiConsumer; +import org.nkjmlab.sorm4j.util.Try.ThrowableFunction; public final class MultiRowInOneStatementProcessor extends MultiRowProcessor { @@ -43,8 +42,8 @@ public final int[] multiRowMerge(Connection con, T... objects) { private final int[] procMultiRowOneStatement(Connection con, - Function multiRowStatementCreator, - BiConsumer parametersSetter, T[] objects) { + ThrowableFunction multiRowStatementCreator, + ThrowableBiConsumer parametersSetter, T[] objects) { final List objsPartitions = ArrayUtils.split(multiRowSize, objects); final int[] result = new int[objsPartitions.size()]; final boolean origAutoCommit = getAutoCommit(con); @@ -65,7 +64,7 @@ private final int[] procMultiRowOneStatement(Connection con, result[lastPartition] = stmt.executeUpdate(); return result; } - } catch (SQLException e) { + } catch (Throwable e) { rollbackIfRequired(con, origAutoCommit); throw new OrmException(e); } finally { diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowProcessor.java b/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowProcessor.java index 0310f254..c7837048 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowProcessor.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/MultiRowProcessor.java @@ -67,7 +67,7 @@ private int[] batchAux(Connection con, String sql, Function paramet final BatchHelper batchHelper = new BatchHelper(batchSize, stmt); for (int i = 0; i < objects.length; i++) { T obj = objects[i]; - this.tableMapping.javaToSqlConverter.setParameters(stmt, parameterCreator.apply(obj)); + this.tableMapping.preparedStatementParametersSetter.setParameters(stmt, parameterCreator.apply(obj)); batchHelper.addBatchAndExecuteIfReachedThreshold(); } result = batchHelper.finish(); diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/OrmMapperImpl.java b/src/main/java/org/nkjmlab/sorm4j/mapping/OrmMapperImpl.java index 960845f5..d13b2bf4 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/OrmMapperImpl.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/OrmMapperImpl.java @@ -127,7 +127,7 @@ public int[] insert(@SuppressWarnings("unchecked") T... objects) { @Override public InsertResult insertAndGet(@SuppressWarnings("unchecked") T... objects) { return execSqlIfParameterExists(objects, - mapping -> mapping.insertAndGetResult(getJdbcConnection(), objects), + mapping -> mapping.insertAndGet(getJdbcConnection(), objects), () -> InsertResult.empty()); } @@ -165,7 +165,7 @@ public int[] insertOn(String tableName, @SuppressWarnings("unchecked") T... public InsertResult insertAndGetOn(String tableName, @SuppressWarnings("unchecked") T... objects) { return execSqlIfParameterExists(objects, tableName, - mapping -> mapping.insertAndGetResult(getJdbcConnection(), objects), + mapping -> mapping.insertAndGet(getJdbcConnection(), objects), () -> InsertResult.empty()); } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/TableMapping.java b/src/main/java/org/nkjmlab/sorm4j/mapping/TableMapping.java index a38de329..93e5732d 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/TableMapping.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/TableMapping.java @@ -34,7 +34,7 @@ public final class TableMapping extends Mapping { private static final org.slf4j.Logger log = org.nkjmlab.sorm4j.util.LoggerFactory.getLogger(); private final Map> setterParamTypeMap = new ConcurrentHashMap<>(); - final PreparedStatementParametersSetter javaToSqlConverter; + final PreparedStatementParametersSetter preparedStatementParametersSetter; private final String tableName; private final List primaryKeys; @@ -47,79 +47,75 @@ public final class TableMapping extends Mapping { private final SqlFromTableMapping sql; private final MultiRowProcessor multiRowProcessor; + private final boolean hasPrimaryKey; + private final boolean hasAutoGeneratedColumns; private TableMapping(ResultSetConverter sqlToJavaConverter, PreparedStatementParametersSetter javaToSqlConverter, Class objectClass, String tableName, List columns, ColumnFieldMapper fieldMapper, - MultiRowProcessorFactory multiRowProcessorFactory, Connection connection) { + MultiRowProcessorFactory multiRowProcessorFactory, Connection connection) + throws SQLException { super(sqlToJavaConverter, objectClass, columns, fieldMapper); - try { - this.javaToSqlConverter = javaToSqlConverter; - - @SuppressWarnings("unchecked") - MultiRowProcessor processor = - (MultiRowProcessor) multiRowProcessorFactory.getMultiRowProcessorFactory().apply(this); - this.multiRowProcessor = processor; - DatabaseMetaData metaData = connection.getMetaData(); - this.tableName = tableName; - - - - // all primary keys (from db) - this.primaryKeys = fieldMapper.getPrimaryKeys(metaData, tableName); - - - List _autoGeneratedColumns = fieldMapper.getAutoGeneratedColumns(metaData, tableName); - - this.autoGeneratedColumns = - _autoGeneratedColumns.stream().map(c -> c.getName()).collect(Collectors.toList()); - this.autoGeneratedColumnsArray = autoGeneratedColumns.toArray(String[]::new); - - this.notAutoGeneratedColumns = - columns.stream().filter(col -> !_autoGeneratedColumns.contains(col)).map(c -> c.getName()) - .collect(Collectors.toList()); - - List notPrimaryKeys = createNoPrimaryKeys(primaryKeys, columns).stream() - .map(c -> c.getName()).collect(Collectors.toList()); - this.columnsForUpdate = new ArrayList<>(notPrimaryKeys); - columnsForUpdate.addAll(primaryKeys); - - this.allColumns = columns.stream().map(c -> c.getName()).collect(Collectors.toList()); - // assemble sql blocks to be used by crud sql statements - this.sql = new SqlFromTableMapping(tableName, primaryKeys, notPrimaryKeys, - autoGeneratedColumns, notAutoGeneratedColumns, allColumns); + this.preparedStatementParametersSetter = javaToSqlConverter; - if (!StringUtils.equalsSetIgnoreCase(allColumns, columnToAccessorMap.keySet())) { - throw new OrmException(StringUtils.format( - "{} does not match any field. Table [{}] contains Columns {} but [{}] contains Fields {}.", - allColumns.stream().filter(e -> !columnToAccessorMap.keySet().contains(e)).sorted() - .collect(Collectors.toList()), - tableName, columns.stream().sorted().collect(Collectors.toList()), - objectClass.getName(), - columnToAccessorMap.keySet().stream().sorted().collect(Collectors.toList()))); - // .orElseThrow(() -> new RuntimeException(MessageUtils.format( - // "Column [{}] does not match any field of [{}]. The field names of the class are {}.", - // column, objectClass.getName(), fields.keySet()))) - } - - } catch (SQLException e) { - throw new OrmException(e); + @SuppressWarnings("unchecked") + MultiRowProcessor processor = + (MultiRowProcessor) multiRowProcessorFactory.getMultiRowProcessorFactory().apply(this); + this.multiRowProcessor = processor; + DatabaseMetaData metaData = connection.getMetaData(); + this.tableName = tableName; + + + + // all primary keys (from db) + this.primaryKeys = fieldMapper.getPrimaryKeys(metaData, tableName); + this.hasPrimaryKey = getPrimaryKeys().size() != 0; + + List _autoGeneratedColumns = fieldMapper.getAutoGeneratedColumns(metaData, tableName); + + this.autoGeneratedColumns = + _autoGeneratedColumns.stream().map(c -> c.getName()).collect(Collectors.toList()); + this.autoGeneratedColumnsArray = autoGeneratedColumns.toArray(String[]::new); + this.hasAutoGeneratedColumns = autoGeneratedColumns.size() != 0; + + this.notAutoGeneratedColumns = + columns.stream().filter(col -> !_autoGeneratedColumns.contains(col)).map(c -> c.getName()) + .collect(Collectors.toList()); + + List notPrimaryKeys = createNoPrimaryKeys(primaryKeys, columns).stream() + .map(c -> c.getName()).collect(Collectors.toList()); + this.columnsForUpdate = new ArrayList<>(notPrimaryKeys); + columnsForUpdate.addAll(primaryKeys); + + this.allColumns = columns.stream().map(c -> c.getName()).collect(Collectors.toList()); + // assemble sql blocks to be used by crud sql statements + this.sql = new SqlFromTableMapping(tableName, primaryKeys, notPrimaryKeys, autoGeneratedColumns, + notAutoGeneratedColumns, allColumns); + + if (!StringUtils.equalsSetIgnoreCase(allColumns, columnToAccessorMap.keySet())) { + throw new OrmException(StringUtils.format( + "{} does not match any field. Table [{}] contains Columns {} but [{}] contains Fields {}.", + allColumns.stream().filter(e -> !columnToAccessorMap.keySet().contains(e)).sorted() + .collect(Collectors.toList()), + tableName, columns.stream().sorted().collect(Collectors.toList()), objectClass.getName(), + columnToAccessorMap.keySet().stream().sorted().collect(Collectors.toList()))); + // .orElseThrow(() -> new RuntimeException(MessageUtils.format( + // "Column [{}] does not match any field of [{}]. The field names of the class are {}.", + // column, objectClass.getName(), fields.keySet()))) } + } public static final TableMapping createMapping(ResultSetConverter sqlToJavaConverter, PreparedStatementParametersSetter javaToSqlConverter, Class objectClass, String tableName, - ColumnFieldMapper fieldMapper, MultiRowProcessorFactory batchConfig, Connection connection) { - try { - DatabaseMetaData metaData = connection.getMetaData(); - return new TableMapping<>(sqlToJavaConverter, javaToSqlConverter, objectClass, tableName, - fieldMapper.getColumns(metaData, tableName), fieldMapper, batchConfig, connection); - } catch (SQLException e) { - throw new OrmException(e); - } + ColumnFieldMapper fieldMapper, MultiRowProcessorFactory batchConfig, Connection connection) + throws SQLException { + DatabaseMetaData metaData = connection.getMetaData(); + return new TableMapping<>(sqlToJavaConverter, javaToSqlConverter, objectClass, tableName, + fieldMapper.getColumns(metaData, tableName), fieldMapper, batchConfig, connection); } @@ -201,33 +197,25 @@ private List setAutoGeneratedKeys(PreparedStatement stmt, T object) { @SafeVarargs - final void setPrameters(PreparedStatement stmt, T... objects) { + final void setPrameters(PreparedStatement stmt, T... objects) throws SQLException { Object[] parameters = Arrays.stream(objects) .flatMap(obj -> Arrays.stream(getParametersWithoutAutoGeneratedColumns(obj))) .toArray(Object[]::new); - try { - javaToSqlConverter.setParameters(stmt, parameters); - } catch (SQLException e) { - throw new OrmException(e); - } + preparedStatementParametersSetter.setParameters(stmt, parameters); } private int executeUpdate(Connection connection, String sql, final Object... parameters) { - try (PreparedStatement stmt = PreparedStatementUtils.getPreparedStatement(connection, sql)) { - javaToSqlConverter.setParameters(stmt, parameters); - final Optional dp = - DebugPointFactory.createDebugPoint(DebugPointFactory.Name.EXECUTE_UPDATE); - int ret = stmt.executeUpdate(); - dp.ifPresent( - sw -> log.debug("{} ExecuteUpdate for one object of [{}] to [{}] Table at [{}] =? [{}]", - sw.getFormattedNameAndElapsedTime(), objectClass.getSimpleName(), getTableName(), - Try.getOrNull(() -> connection.getMetaData().getURL()), sql)); - return ret; - } catch (SQLException e) { - throw new OrmException(e); - } + final Optional dp = + DebugPointFactory.createDebugPoint(DebugPointFactory.Name.EXECUTE_UPDATE); + int ret = AbstractOrmMapper.execPreparedStatementAndClose(preparedStatementParametersSetter, + connection, sql, parameters, stmt -> stmt.executeUpdate()); + dp.ifPresent( + sw -> log.debug("{} ExecuteUpdate for one object of [{}] to [{}] Table at [{}] =? [{}]", + sw.getFormattedNameAndElapsedTime(), objectClass.getSimpleName(), getTableName(), + Try.getOrNull(() -> connection.getMetaData().getURL()), sql)); + return ret; } /** @@ -243,9 +231,18 @@ public int update(Connection connection, T object) { return executeUpdate(connection, getSql().getUpdateSql(), getUpdateParameters(object)); } - private void throwExeptionIfPrimaryKeysIsNotExist() { - if (getPrimaryKeys().size() == 0) { - throw new OrmException("Table " + getTableName() + " doesn't have a primary key"); + public void throwExeptionIfPrimaryKeysIsNotExist() { + if (!hasPrimaryKey) { + throw new OrmException("This opperation requiers primary keys but Table [" + getTableName() + + "] doesn't have them."); + } + } + + + public void throwExeptionIfAutoGeneratedColumnsExist() { + if (hasAutoGeneratedColumns) { + throw new OrmException("This opperation requiers no autogenerated columns but Table [" + + getTableName() + "] has them."); } } @@ -295,6 +292,7 @@ public int insert(Connection connection, T object) { } public int merge(Connection connection, T object) { + throwExeptionIfAutoGeneratedColumnsExist(); try { return executeUpdate(connection, sql.getMergeSql(), getMergeParameters(object)); } catch (OrmException e) { @@ -307,9 +305,9 @@ public int merge(Connection connection, T object) { public InsertResult insertAndGetResult(Connection connection, T object) { - try (PreparedStatement stmt = PreparedStatementUtils.getPreparedStatement(connection, - sql.getInsertSql(), autoGeneratedColumnsArray)) { - javaToSqlConverter.setParameters(stmt, getInsertParameters(object)); + try (PreparedStatement stmt = PreparedStatementUtils.getPreparedStatementWithAutoGeneratedKeys( + connection, sql.getInsertSql(), autoGeneratedColumnsArray)) { + preparedStatementParametersSetter.setParameters(stmt, getInsertParameters(object)); int rowsModified = stmt.executeUpdate(); List keys = setAutoGeneratedKeys(stmt, object); return new InsertResult(new int[] {rowsModified}, object, keys); @@ -327,12 +325,14 @@ public final int[] insert(Connection con, T... objects) { + /** + * + * @param con + * @param objects not allow {@code null} or {@code 0} length + * @return + */ @SafeVarargs - public final InsertResult insertAndGetResult(Connection con, T... objects) { - if (objects == null || objects.length == 0) { - return InsertResult.empty(); - } - + public final InsertResult insertAndGet(Connection con, T... objects) { @SuppressWarnings("unchecked") T[] objsWithoutLast = (T[]) Arrays.asList(objects).subList(0, objects.length - 1).toArray(Object[]::new); @@ -352,9 +352,9 @@ public int[] batch(Connection con, String sql, Function parameterCr } - @SuppressWarnings("unchecked") public int[] merge(Connection con, T... objects) { + throwExeptionIfAutoGeneratedColumnsExist(); try { int[] result = multiRowProcessor.multiRowMerge(con, objects); return result; @@ -365,7 +365,6 @@ public int[] merge(Connection con, T... objects) { } } - public String getFormattedString() { return "TABLE [" + tableName + "] is mapped to [" + objectClass.getSimpleName() + "] class. " + "PRIMARY KEY is " + primaryKeys + System.lineSeparator() @@ -373,6 +372,4 @@ public String getFormattedString() { + multiRowProcessor.getClass().getSimpleName() + "] is used for processing multirow."; } - - } diff --git a/src/main/java/org/nkjmlab/sorm4j/mapping/TypedOrmMapperImpl.java b/src/main/java/org/nkjmlab/sorm4j/mapping/TypedOrmMapperImpl.java index 57efee57..c10c6bbe 100644 --- a/src/main/java/org/nkjmlab/sorm4j/mapping/TypedOrmMapperImpl.java +++ b/src/main/java/org/nkjmlab/sorm4j/mapping/TypedOrmMapperImpl.java @@ -159,8 +159,7 @@ public int[] insert(@SuppressWarnings("unchecked") T... objects) { @Override public InsertResult insertAndGet(@SuppressWarnings("unchecked") T... objects) { return execSqlIfParameterExists(objects, - mapping -> mapping.insertAndGetResult(getJdbcConnection(), objects), - () -> InsertResult.empty()); + mapping -> mapping.insertAndGet(getJdbcConnection(), objects), () -> InsertResult.empty()); } @@ -197,8 +196,7 @@ public int[] insertOn(String tableName, @SuppressWarnings("unchecked") T... obje public InsertResult insertAndGetOn(String tableName, @SuppressWarnings("unchecked") T... objects) { return execSqlIfParameterExists(objects, tableName, - mapping -> mapping.insertAndGetResult(getJdbcConnection(), objects), - () -> InsertResult.empty()); + mapping -> mapping.insertAndGet(getJdbcConnection(), objects), () -> InsertResult.empty()); } diff --git a/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java b/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java index 4fe5f55d..2ba91070 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/PreparedStatementUtils.java @@ -2,34 +2,22 @@ import java.sql.Connection; import java.sql.PreparedStatement; -import java.util.Arrays; -import org.nkjmlab.sorm4j.OrmException; +import java.sql.SQLException; public final class PreparedStatementUtils { private PreparedStatementUtils() {} - public static PreparedStatement getPreparedStatement(Connection connection, String sql) { - try { - return connection.prepareStatement(sql); - } catch (Throwable e) { - throw new OrmException( - "Error creating prepared statement for sql [" + sql + "] : " + e.getMessage(), e); - } + public static PreparedStatement getPreparedStatement(Connection connection, String sql) + throws SQLException { + return connection.prepareStatement(sql); } - public static PreparedStatement getPreparedStatement(Connection connection, String sql, - String[] autoGeneratedKeys) { - try { - return (autoGeneratedKeys == null || autoGeneratedKeys.length == 0) - ? connection.prepareStatement(sql) - : connection.prepareStatement(sql, autoGeneratedKeys); - } catch (Throwable e) { - throw new OrmException( - "Error creating prepared statement for sql [" + sql + "] with autoGeneratedKeys " - + Arrays.toString(autoGeneratedKeys) + ": " + e.getMessage(), - e); - } + public static PreparedStatement getPreparedStatementWithAutoGeneratedKeys(Connection connection, + String sql, String[] autoGeneratedKeys) throws SQLException { + return (autoGeneratedKeys == null || autoGeneratedKeys.length == 0) + ? connection.prepareStatement(sql) + : connection.prepareStatement(sql, autoGeneratedKeys); } diff --git a/src/main/java/org/nkjmlab/sorm4j/util/Try.java b/src/main/java/org/nkjmlab/sorm4j/util/Try.java index 29b5d03c..4737664f 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/Try.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/Try.java @@ -1,5 +1,6 @@ package org.nkjmlab.sorm4j.util; +import java.util.function.BiConsumer; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; @@ -30,6 +31,11 @@ public static interface ThrowableFunction { R apply(T t) throws Throwable; } + @FunctionalInterface + public static interface ThrowableBiConsumer { + void accept(T t, S s) throws Throwable; + } + public static Runnable createRunnable(ThrowableRunnable onTry, Consumer onCatch) { @@ -93,6 +99,17 @@ public static Function createFunction(ThrowableFunction onTry }; } + public static BiConsumer createBiConsumer(ThrowableBiConsumer onTry, + Consumer onCatch) { + return (t, s) -> { + try { + onTry.accept(t, s); + } catch (Throwable e) { + onCatch.accept(e); + } + }; + } + public static Function createFunctionWithThrow( ThrowableFunction onTry, Function ex) throws X { return createFunction(onTry, e -> { @@ -100,6 +117,13 @@ public static Function createFunctionWi }); } + public static BiConsumer createBiConsumerWithThrow( + ThrowableBiConsumer onTry, Function ex) throws X { + return createBiConsumer(onTry, e -> { + throw ex.apply(e); + }); + } + public static T getOrNull(ThrowableSupplier onTry) { return createSupplier(onTry, e -> { diff --git a/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java index 2785f735..7fbbcf96 100644 --- a/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/OrmConnectionTest.java @@ -344,6 +344,9 @@ void testReadAllLazy() { } catch (Exception e) { } + assertThat(m.readList(Integer.class, "select id from players")).contains(1, 2); + + try { DebugPointFactory.on(); assertThat(m.readList(Integer.class, "select * from players")).contains(1, 2); diff --git a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java index 1cd128b9..e23237b3 100644 --- a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java @@ -170,6 +170,8 @@ void testInsertAndGetOnStringT() { sorm.run(Guest.class, m -> { InsertResult g = m.insertAndGet(a); assertThat(g.getObject().getId()).isEqualTo(1); + m.insertAndGet(new Guest[0]); + }); sorm.run(Guest.class, m -> { InsertResult g = m.insertAndGetOn("players1", a); @@ -278,6 +280,15 @@ void testMergeError() { } catch (OrmException e) { assertThat(e.getMessage()).contains("autogenerated"); } + try { + sorm.run(Guest.class, m -> { + Guest a = SormTestUtils.GUEST_ALICE; + m.merge(a, a, a); + failBecauseExceptionWasNotThrown(OrmException.class); + }); + } catch (OrmException e) { + assertThat(e.getMessage()).contains("autogenerated"); + } } @Test diff --git a/src/test/java/org/nkjmlab/sorm4j/mapping/DefaultResultSetValueGetterTest.java b/src/test/java/org/nkjmlab/sorm4j/mapping/DefaultResultSetValueGetterTest.java index bfff34da..47923119 100644 --- a/src/test/java/org/nkjmlab/sorm4j/mapping/DefaultResultSetValueGetterTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/mapping/DefaultResultSetValueGetterTest.java @@ -33,6 +33,13 @@ void testGetValueBySetterType() { sorm.run(con -> con.insert(Stream.generate(() -> LocalDateTimeSample.buildRandom()).limit(10000) .toArray(LocalDateTimeSample[]::new))); + try { + sorm.run(con -> con.update(a)); + failBecauseExceptionWasNotThrown(Exception.class); + } catch (Exception e) { + assertThat(e.getMessage()).contains("doesn't have them"); + } + } diff --git a/src/test/java/org/nkjmlab/sorm4j/util/PreparedStatementUtilsTest.java b/src/test/java/org/nkjmlab/sorm4j/util/PreparedStatementUtilsTest.java deleted file mode 100644 index 903b93c0..00000000 --- a/src/test/java/org/nkjmlab/sorm4j/util/PreparedStatementUtilsTest.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.nkjmlab.sorm4j.util; - -import org.junit.jupiter.api.Test; - -class PreparedStatementUtilsTest { - - @Test - void testGetPreparedStatementConnectionString() { - try { - PreparedStatementUtils.getPreparedStatement(null, "a"); - } catch (Exception e) { - } - } - - @Test - void testGetPreparedStatementConnectionStringStringArray() { - try { - PreparedStatementUtils.getPreparedStatement(null, "a", new String[] {}); - } catch (Exception e) { - } - } - -} From e2ee44a895fe9c4c16940774d8f639a24c588d71 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 16:40:07 +0900 Subject: [PATCH 12/13] Fix bug of LazyResultSet --- src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java index 3d22e5d1..7996012c 100644 --- a/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java +++ b/src/main/java/org/nkjmlab/sorm4j/LazyResultSet.java @@ -8,6 +8,7 @@ import java.sql.ResultSet; import java.sql.SQLException; import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.function.Supplier; @@ -142,7 +143,7 @@ private final class LazyResultSetIterator implements Iterator { @SuppressWarnings("unchecked") public LazyResultSetIterator(AbstractOrmMapper orMapper, Class objectClass, PreparedStatement stmt, ResultSet resultSet) { - this.getFunction = objectClass.equals(Map.class) + this.getFunction = objectClass.equals(LinkedHashMap.class) ? Try.createSupplierWithThrow(() -> (S) orMapper.toSingleMap(resultSet), OrmException::new) : Try.createSupplierWithThrow(() -> orMapper.toSingleObject(objectClass, resultSet), From 2959a334cc3fd3f6fcd77eb2fc703814866a6f02 Mon Sep 17 00:00:00 2001 From: Yuu Nakajima Date: Wed, 3 Mar 2021 16:40:24 +0900 Subject: [PATCH 13/13] Add tests --- .../java/org/nkjmlab/sorm4j/util/Try.java | 2 +- .../sorm4j/TypedOrmConnectionTest.java | 22 ++++++++++++ .../java/org/nkjmlab/sorm4j/util/TryTest.java | 34 +++++++++++++++++++ 3 files changed, 57 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/nkjmlab/sorm4j/util/Try.java b/src/main/java/org/nkjmlab/sorm4j/util/Try.java index 4737664f..896b2e29 100644 --- a/src/main/java/org/nkjmlab/sorm4j/util/Try.java +++ b/src/main/java/org/nkjmlab/sorm4j/util/Try.java @@ -142,7 +142,7 @@ public static void runOrThrow(ThrowableRunnable Function ex) throws X { createRunnable(onTry, e -> { throw ex.apply(e); - }).run();; + }).run(); } diff --git a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java index e23237b3..f00e8d6d 100644 --- a/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/TypedOrmConnectionTest.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.fail; import java.sql.Connection; import java.sql.SQLException; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.stream.Collectors; @@ -400,6 +401,27 @@ void testReadAllLazy() { assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) .isEqualTo(a.getName()); }); + + sorm.run(Player.class, m -> { + Map map = + m.readMapLazy("select * from players").stream().collect(Collectors.toList()).get(0); + assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) + .isEqualTo(a.getName()); + }); + + sorm.run(Player.class, m -> { + LazyResultSet r = m.readLazy("select * from players"); + Iterator it = r.iterator(); + r.close(); + try { + it.hasNext(); + failBecauseExceptionWasNotThrown(Exception.class); + } catch (Exception e) { + assertThat(e.getMessage()).contains("already closed"); + } + }); + + sorm.run(Player.class, m -> { Map map = m.readMapList(SqlStatement.of("select * from players")).get(0); assertThat(map.get("NAME") != null ? map.get("NAME") : map.get("name")) diff --git a/src/test/java/org/nkjmlab/sorm4j/util/TryTest.java b/src/test/java/org/nkjmlab/sorm4j/util/TryTest.java index 17de6420..fa3db174 100644 --- a/src/test/java/org/nkjmlab/sorm4j/util/TryTest.java +++ b/src/test/java/org/nkjmlab/sorm4j/util/TryTest.java @@ -52,9 +52,25 @@ void testCreateConsumer() { } catch (Exception e) { assertThat(e.getMessage()).contains("try"); } + } + @Test + void testCreateBiConsumer() { + try { + Try.createBiConsumer((con1, con2) -> { + throw new RuntimeException("try"); + }, e -> { + }).accept("a", "b"); + } catch (Exception e) { + assertThat(e.getMessage()).contains("try"); + } + Try.createBiConsumer((con1, con2) -> { + }, e -> { + }).accept("a", "b"); } + + @Test void testCreateConsumerWithThrow() { try { @@ -64,6 +80,19 @@ void testCreateConsumerWithThrow() { } catch (Exception e) { assertThat(e.getMessage()).contains("try"); } + Try.createConsumerWithThrow(con -> { + }, OrmException::new).accept("a"); + } + + @Test + void testCreateBiConsumerWithThrow() { + try { + Try.createBiConsumerWithThrow((c1, c2) -> { + throw new RuntimeException("try"); + }, OrmException::new).accept("a", "b"); + } catch (Exception e) { + assertThat(e.getMessage()).contains("try"); + } } @Test @@ -106,6 +135,9 @@ void testGetOrThrow() { } catch (Exception e) { assertThat(e.getMessage()).contains("try"); } + Try.getOrThrow(() -> { + return null; + }, OrmException::new); } @Test @@ -117,6 +149,8 @@ void testRunOrThrow() { } catch (Exception e) { assertThat(e.getMessage()).contains("try"); } + Try.runOrThrow(() -> { + }, OrmException::new); } }