valueType, String tableName) {
- super(orm, valueType, tableName);
- }
-}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/commands/annotation/CsvColumn.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/commands/annotation/CsvColumn.java
index 3a04d925..eeb8b54d 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/commands/annotation/CsvColumn.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/commands/annotation/CsvColumn.java
@@ -6,7 +6,7 @@
import java.lang.annotation.Target;
import org.nkjmlab.sorm4j.annotation.Experimental;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
/**
* Mapping a csv column to a table column.
@@ -25,7 +25,7 @@
*
*
*
- * {@link BasicH2Table#getReadCsvWithHeaderSql(java.io.File, java.nio.charset.Charset, char)}
+ * {@link H2BasicTable#getReadCsvWithHeaderSql(java.io.File, java.nio.charset.Charset, char)}
* generates the following SQL statement.
*
*
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactory.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
similarity index 91%
rename from sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactory.java
rename to sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
index a76097a2..dd52fd1c 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactory.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
@@ -25,7 +25,7 @@
* @author nkjm
*/
@Experimental
-public class H2LocalDataSourceFactory {
+public class H2DataSourceFactory {
private final File databaseDirectory;
private final String databaseName;
@@ -37,7 +37,7 @@ public class H2LocalDataSourceFactory {
private final String embeddedModeJdbcUrl;
private final String mixedModeJdbcUrl;
- private H2LocalDataSourceFactory(
+ private H2DataSourceFactory(
File databaseDirectory, String databaseName, String username, String password) {
this.username = username;
this.password = password;
@@ -217,8 +217,8 @@ public static Builder builder() {
}
/**
- * Initializes a newly created {@link H2LocalDataSourceFactory.Builder} object; you can get
- * {{@code LocalDataSourceFactory} object via build method.
+ * Initializes a newly created {@link H2DataSourceFactory.Builder} object; you can get {{@code
+ * LocalDataSourceFactory} object via build method.
*
* following variables in the path of database directory will be expanded.
*
@@ -227,7 +227,7 @@ public static Builder builder() {
*
"%TEMP%" or "$TMPDIR" to "java.io.tmpdir"
*
*
- * @see {@link H2LocalDataSourceFactory.Builder#setDatabaseDirectory(File)}
+ * @see {@link H2DataSourceFactory.Builder#setDatabaseDirectory(File)}
* @param databaseDirectory the directory including the database file.
* @param databaseName the name of database.
* @param username
@@ -262,8 +262,8 @@ public String toString() {
}
public static class Builder {
- private File databaseDirectory = getTempDir();
- private String databaseName = "tmph2db";
+ private File databaseDirectory = new File(getTempDir(), "h2db-tmp");
+ private String databaseName = "h2db-tmp";
private String username = "";
private String password = "";
@@ -276,12 +276,12 @@ private Builder(File databaseDirectory, String dbName, String username, String p
setDatabaseDirectory(databaseDirectory);
}
- public H2LocalDataSourceFactory.Builder setUsername(String username) {
+ public H2DataSourceFactory.Builder setUsername(String username) {
this.username = username;
return this;
}
- public H2LocalDataSourceFactory.Builder setPassword(String password) {
+ public H2DataSourceFactory.Builder setPassword(String password) {
this.password = password;
return this;
}
@@ -302,7 +302,7 @@ public H2LocalDataSourceFactory.Builder setPassword(String password) {
* @param databaseDirectoryPath
* @return
*/
- public H2LocalDataSourceFactory.Builder setDatabaseDirectory(File databaseDirectoryPath) {
+ public H2DataSourceFactory.Builder setDatabaseDirectory(File databaseDirectoryPath) {
String databaseDirectoryPathStr = databaseDirectoryPath.toString();
if (!databaseDirectoryPath.isAbsolute()
&& allowPrefixes.stream()
@@ -333,7 +333,7 @@ private File convertVariableInFilePath(File databaseDirectoryPath) {
}
}
- public H2LocalDataSourceFactory.Builder setDatabaseName(String dbName) {
+ public H2DataSourceFactory.Builder setDatabaseName(String dbName) {
this.databaseName = dbName;
return this;
}
@@ -347,12 +347,12 @@ private static File getUserHomeDir() {
}
/**
- * Builds a {@link H2LocalDataSourceFactory} instance.
+ * Builds a {@link H2DataSourceFactory} instance.
*
* @return
*/
- public H2LocalDataSourceFactory build() {
- return new H2LocalDataSourceFactory(databaseDirectory, databaseName, username, password);
+ public H2DataSourceFactory build() {
+ return new H2DataSourceFactory(databaseDirectory, databaseName, username, password);
}
}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWrite.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWrite.java
index d2f96683..e1d9e798 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWrite.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWrite.java
@@ -42,12 +42,18 @@ public static class Builder {
private String query;
private final org.nkjmlab.sorm4j.util.h2.grammar.CsvOptions.Builder csvOptionsBuilder =
new CsvOptions.Builder();
+ private boolean queryEscape = true;
public CsvWrite.Builder query(String query) {
this.query = query;
return this;
}
+ public CsvWrite.Builder queryEscape(boolean queryEscape) {
+ this.queryEscape = queryEscape;
+ return this;
+ }
+
public CsvWrite.Builder file(File file) {
this.file = file;
return this;
@@ -114,7 +120,7 @@ public CsvWrite build() {
List l =
Stream.of(
wrapSingleQuote(file.getAbsolutePath().toString()),
- wrapSingleQuote(query),
+ wrapSingleQuote(queryEscape ? escapeQuery(query) : query),
csvOptions == null || csvOptions.getSql() == null
? null
: "stringdecode(" + wrapSingleQuote(csvOptions.getSql()) + ")")
@@ -123,4 +129,8 @@ public CsvWrite build() {
return new CsvWrite("csvwrite(" + String.join(", ", l) + ")");
}
}
+
+ private static String escapeQuery(String query) {
+ return query.replace("'", "''");
+ }
}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/CsvOptions.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/CsvOptions.java
index 5d86006b..72ab0bc0 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/CsvOptions.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/CsvOptions.java
@@ -23,6 +23,10 @@ public String getFieldSeparator() {
return fieldSeparator;
}
+ public Builder builder() {
+ return new Builder();
+ }
+
public static class Builder {
private final Map csvOptions = new TreeMap<>();
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/ScriptCompressionEncryption.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/ScriptCompressionEncryption.java
index 2535697a..81b07abf 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/ScriptCompressionEncryption.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/grammar/ScriptCompressionEncryption.java
@@ -20,6 +20,10 @@ public String getSql() {
return sql;
}
+ public Builder builder() {
+ return new Builder();
+ }
+
public static class Builder {
private final Map props = new LinkedHashMap<>();
@@ -36,6 +40,12 @@ public Builder compression(String compression) {
return this;
}
+ public Builder cipherAndPassword(String cipher, String password) {
+ cipher(cipher);
+ password(password);
+ return this;
+ }
+
public Builder cipher(String cipher) {
this.props.put("cipher", cipher);
return this;
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingService.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingService.java
index e5d209f0..5715de25 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingService.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingService.java
@@ -2,7 +2,7 @@
import java.sql.Connection;
import java.sql.SQLException;
-import javax.sql.DataSource;
+
import org.h2.server.web.WebServer;
import org.h2.tools.Server;
import org.nkjmlab.sorm4j.annotation.Experimental;
@@ -60,15 +60,4 @@ public void open(Connection conn) {
log.error("{}", e.getMessage());
}
}
-
- /**
- * Open a new browser tab or window.
- *
- * @param dataSource
- * @return
- * @see #startTemporalWebConsoleServer(boolean)
- */
- public void open(DataSource dataSource) {
- Try.runOrElseThrow(() -> open(dataSource.getConnection()), Try::rethrow);
- }
}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/BasicTable.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/SimpleTableWithDefinition.java
similarity index 69%
rename from sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/BasicTable.java
rename to sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/SimpleTableWithDefinition.java
index 69a6ea61..8436cb31 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/BasicTable.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/SimpleTableWithDefinition.java
@@ -3,11 +3,9 @@
import org.nkjmlab.sorm4j.Sorm;
import org.nkjmlab.sorm4j.annotation.Experimental;
import org.nkjmlab.sorm4j.table.SimpleTable;
-import org.nkjmlab.sorm4j.table.Table;
@Experimental
-public class BasicTable extends SimpleTable
- implements WithTableDefinition, Table {
+public class SimpleTableWithDefinition extends SimpleTable implements TableWithDefinition {
private final TableDefinition tableDefinition;
@@ -18,12 +16,12 @@ public class BasicTable extends SimpleTable
* @param valueType
* @param tableDefinition
*/
- public BasicTable(Sorm orm, Class valueType, TableDefinition tableDefinition) {
+ public SimpleTableWithDefinition(Sorm orm, Class valueType, TableDefinition tableDefinition) {
super(orm, valueType, tableDefinition.getTableName());
this.tableDefinition = tableDefinition;
}
- public BasicTable(Sorm orm, Class valueType) {
+ public SimpleTableWithDefinition(Sorm orm, Class valueType) {
this(orm, valueType, TableDefinition.builder(valueType).build());
}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/TableWithDefinition.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/TableWithDefinition.java
new file mode 100644
index 00000000..fe098e79
--- /dev/null
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/TableWithDefinition.java
@@ -0,0 +1,5 @@
+package org.nkjmlab.sorm4j.util.table_def;
+
+import org.nkjmlab.sorm4j.table.Table;
+
+public interface TableWithDefinition extends Table, WithTableDefinition {}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/annotation/package.html b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/annotation/package.html
new file mode 100644
index 00000000..6c565aa0
--- /dev/null
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/annotation/package.html
@@ -0,0 +1,5 @@
+
+
+ Package for table definition annotations.
+
+
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/package.html b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/package.html
new file mode 100644
index 00000000..6a54ea63
--- /dev/null
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/package.html
@@ -0,0 +1,5 @@
+
+
+ Package for table definitions.
+
+
diff --git a/sorm4j/src/main/resources/log4j2.xml b/sorm4j/src/main/resources/log4j2.xml
deleted file mode 100644
index 5cdd2cdc..00000000
--- a/sorm4j/src/main/resources/log4j2.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-
-
-
-
- DEBUG
- ${log_pattern_loc}
-
- %d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%t] %c.%M(%F:%L) %m%n
-
-
- %d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%t] %c{3.} %m%n
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/context/DefaultColumnValueToJavaObjectConvertersTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/context/DefaultColumnValueToJavaObjectConvertersTest.java
index 95455041..d1e7e490 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/context/DefaultColumnValueToJavaObjectConvertersTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/context/DefaultColumnValueToJavaObjectConvertersTest.java
@@ -1,13 +1,22 @@
package org.nkjmlab.sorm4j.context;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import java.net.Inet4Address;
import java.sql.Connection;
+import java.sql.JDBCType;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+
import org.junit.jupiter.api.Test;
import org.nkjmlab.sorm4j.Sorm;
+import org.nkjmlab.sorm4j.common.SormException;
import org.nkjmlab.sorm4j.test.common.Guest;
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
@@ -80,4 +89,52 @@ public PreparedStatement prepareStatement(Connection connection, String sql)
fail();
}
}
+
+ @Test
+ void testConvertToWithSQLException() throws SQLException {
+ ResultSet mockResultSet = mock(ResultSet.class);
+ when(mockResultSet.getString(anyInt())).thenThrow(new SQLException("Test exception"));
+
+ DefaultColumnValueToJavaObjectConverters converters =
+ new DefaultColumnValueToJavaObjectConverters();
+
+ assertThrows(
+ SormException.class,
+ () ->
+ converters.convertTo(
+ mockResultSet, 1, JDBCType.VARCHAR.getVendorTypeNumber(), String.class));
+ }
+
+ public enum TestEnum {
+ VALUE1,
+ VALUE2
+ }
+
+ @Test
+ void testUnsupportedTypeConversion() throws SQLException {
+ ResultSet mockResultSet = mock(ResultSet.class);
+ when(mockResultSet.getObject(anyInt(), eq(TestEnum.class))).thenReturn(null);
+
+ DefaultColumnValueToJavaObjectConverters converters =
+ new DefaultColumnValueToJavaObjectConverters();
+
+ assertThrows(
+ SormException.class,
+ () ->
+ converters.convertTo(
+ mockResultSet, 1, JDBCType.OTHER.getVendorTypeNumber(), TestEnum.class));
+ }
+
+ @Test
+ void testArrayConversionException() throws SQLException {
+ ResultSet mockResultSet = mock(ResultSet.class);
+ when(mockResultSet.getArray(anyInt())).thenThrow(new SQLException("Test exception"));
+
+ DefaultColumnValueToJavaObjectConverters converters =
+ new DefaultColumnValueToJavaObjectConverters();
+
+ assertThrows(
+ SormException.class,
+ () -> converters.convertTo(mockResultSet, 1, JDBCType.ARRAY.getVendorTypeNumber(), int[].class));
+ }
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmConnectionImplTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmConnectionImplTest.java
index 62778d18..7366bcf2 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmConnectionImplTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmConnectionImplTest.java
@@ -264,10 +264,10 @@ void testDeleteOnStringT() {
m -> {
Player a = PLAYER_ALICE;
Player b = PLAYER_BOB;
- m.insertIn("players1", a);
+ m.insertInto("players1", a);
m.deleteIn("players1", a);
assertThat(m.readList(Player.class, "select * from players1").size()).isEqualTo(0);
- m.insertIn("players1", a, b);
+ m.insertInto("players1", a, b);
m.deleteIn("players1", a, b);
assertThat(m.readList(Player.class, "select * from players1").size()).isEqualTo(0);
});
@@ -378,7 +378,7 @@ void testInsertOnStringT() {
m -> {
Player a = PLAYER_ALICE;
Player b = PLAYER_BOB;
- m.insertIn("players1", a, b);
+ m.insertInto("players1", a, b);
assertThat(m.readList(Player.class, "select * from players1")).contains(a, b);
m.deleteAllIn("players1");
assertThat(m.readList(Player.class, "select * from players1").size()).isEqualTo(0);
@@ -387,7 +387,7 @@ void testInsertOnStringT() {
m -> {
Player a = PLAYER_ALICE;
Player b = PLAYER_BOB;
- m.insertIn("players1", List.of(a, b));
+ m.insertInto("players1", List.of(a, b));
assertThat(m.readList(Player.class, "select * from players1")).contains(a, b);
m.deleteIn("players1", List.of(a, b));
assertThat(m.readList(Player.class, "select * from players1").size()).isEqualTo(0);
@@ -587,12 +587,12 @@ void testUpdateOnT() {
orm.acceptHandler(
m -> {
m.insert(a);
- m.updateIn("players", new Player(a.getId(), "UPDATED", "UPDATED"));
- m.updateIn(
+ m.updateWith("players", new Player(a.getId(), "UPDATED", "UPDATED"));
+ m.updateWith(
"players",
new Player(a.getId(), "UPDATED", "UPDATED"),
new Player(b.getId(), "UPDATED", "UPDATED"));
- m.updateIn(
+ m.updateWith(
"players",
List.of(
new Player(a.getId(), "UPDATED", "UPDATED"),
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmImplTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmImplTest.java
index 9321c7f7..ab4a6048 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmImplTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/OrmImplTest.java
@@ -138,7 +138,7 @@ void testDeleteOnStringListOfT() {
@Test
void testDeleteOnStringT() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(1);
sorm.deleteIn(PLAYERS1, PLAYER_ALICE);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(0);
@@ -146,7 +146,7 @@ void testDeleteOnStringT() {
@Test
void testDeleteOnStringTArray() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(2);
sorm.deleteIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(0);
@@ -162,7 +162,7 @@ void testDeleteAll() {
@Test
void testDeleteAllIn() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(2);
sorm.deleteAllIn(PLAYERS1);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(0);
@@ -212,19 +212,19 @@ void testInsertAndGetOnStringTArray() {
@Test
void testInsertOnStringListOfT() {
- sorm.insertIn(PLAYERS1, List.of(PLAYER_ALICE, PLAYER_BOB));
+ sorm.insertInto(PLAYERS1, List.of(PLAYER_ALICE, PLAYER_BOB));
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(2);
}
@Test
void testInsertOnStringT() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(1);
}
@Test
void testInsertOnStringTArray() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(2);
}
@@ -254,7 +254,7 @@ void testmergeTArray() {
@Test
void testmergeInStringListOfT() {
- sorm.insertIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
+ sorm.insertInto(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(2);
sorm.mergeIn(PLAYERS1, List.of(PLAYER_ALICE, PLAYER_CAROL));
assertThat(sorm.getTable(Player.class, PLAYERS1).count()).isEqualTo(3);
@@ -295,19 +295,19 @@ void testUpdateTArray() {
@Test
void testUpdateOnStringListOfT() {
sorm.insert(PLAYER_ALICE, PLAYER_BOB);
- sorm.updateIn(PLAYERS1, List.of(PLAYER_ALICE, PLAYER_BOB));
+ sorm.updateWith(PLAYERS1, List.of(PLAYER_ALICE, PLAYER_BOB));
}
@Test
void testUpdateOnStringT() {
sorm.insert(PLAYER_ALICE);
- sorm.updateIn(PLAYERS1, PLAYER_ALICE);
+ sorm.updateWith(PLAYERS1, PLAYER_ALICE);
}
@Test
void testUpdateOnStringTArray() {
sorm.insert(PLAYER_ALICE, PLAYER_BOB);
- sorm.updateIn(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
+ sorm.updateWith(PLAYERS1, PLAYER_ALICE, PLAYER_BOB);
}
@Test
@@ -352,11 +352,11 @@ void testOpenMapStream() {
void testInsertMapIn() {
RowMap map = RowMap.of("id", 99, "name", "Test", "address", "Chiba");
- sorm.insertMapIn(PLAYERS1, map);
+ sorm.insertMapInto(PLAYERS1, map);
sorm.deleteAllIn(PLAYERS1);
- sorm.insertMapIn(PLAYERS1, List.of(map));
+ sorm.insertMapInto(PLAYERS1, List.of(map));
sorm.deleteAllIn(PLAYERS1);
- sorm.insertMapIn(PLAYERS1, new RowMap[] {map});
+ sorm.insertMapInto(PLAYERS1, new RowMap[] {map});
}
@Test
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/SormContextImplTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/SormContextImplTest.java
index 509630bb..37f53b9c 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/SormContextImplTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/SormContextImplTest.java
@@ -1,20 +1,33 @@
package org.nkjmlab.sorm4j.internal;
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import java.sql.Connection;
import java.sql.SQLException;
+
import org.junit.jupiter.api.Test;
import org.nkjmlab.sorm4j.Sorm;
import org.nkjmlab.sorm4j.annotation.OrmConstructor;
import org.nkjmlab.sorm4j.annotation.OrmRecord;
import org.nkjmlab.sorm4j.common.SormException;
+import org.nkjmlab.sorm4j.context.ColumnToFieldAccessorMapper;
+import org.nkjmlab.sorm4j.context.ColumnValueToJavaObjectConverters;
+import org.nkjmlab.sorm4j.context.ColumnValueToMapValueConverters;
import org.nkjmlab.sorm4j.context.DefaultColumnToFieldAccessorMapper;
import org.nkjmlab.sorm4j.context.DefaultColumnValueToJavaObjectConverters;
import org.nkjmlab.sorm4j.context.DefaultColumnValueToMapValueConverters;
import org.nkjmlab.sorm4j.context.DefaultSqlParametersSetter;
import org.nkjmlab.sorm4j.context.DefaultTableNameMapper;
import org.nkjmlab.sorm4j.context.MultiRowProcessorFactory;
+import org.nkjmlab.sorm4j.context.PreparedStatementSupplier;
import org.nkjmlab.sorm4j.context.SormContext;
+import org.nkjmlab.sorm4j.context.SqlParametersSetter;
+import org.nkjmlab.sorm4j.context.TableNameMapper;
+import org.nkjmlab.sorm4j.context.TableSqlFactory;
import org.nkjmlab.sorm4j.test.common.Guest;
import org.nkjmlab.sorm4j.test.common.Player;
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
@@ -82,6 +95,38 @@ void testBuild() {
System.out.println(context.toString());
}
+ @Test
+ void testBuilder() {
+ SormConfig mockConfig = mock(SormConfig.class);
+ SormContextImpl sormContextImpl = new SormContextImpl(mockConfig);
+ ColumnToFieldAccessorMapper mockColumnFieldMapper = mock(ColumnToFieldAccessorMapper.class);
+ ColumnValueToJavaObjectConverters mockColumnValueToJavaObjectConverter =
+ mock(ColumnValueToJavaObjectConverters.class);
+ ColumnValueToMapValueConverters mockColumnValueToMapValueConverter =
+ mock(ColumnValueToMapValueConverters.class);
+ LoggerContext mockLoggerContext = mock(LoggerContext.class);
+ MultiRowProcessorFactory mockMultiRowProcessorFactory = mock(MultiRowProcessorFactory.class);
+ PreparedStatementSupplier mockPreparedStatementSupplier = mock(PreparedStatementSupplier.class);
+ SqlParametersSetter mockSqlParametersSetter = mock(SqlParametersSetter.class);
+ TableNameMapper mockTableNameMapper = mock(TableNameMapper.class);
+ TableSqlFactory mockTableSqlFactory = mock(TableSqlFactory.class);
+
+ when(mockConfig.getColumnToFieldAccessorMapper()).thenReturn(mockColumnFieldMapper);
+ when(mockConfig.getColumnValueToJavaObjectConverter())
+ .thenReturn(mockColumnValueToJavaObjectConverter);
+ when(mockConfig.getColumnValueToMapValueConverter())
+ .thenReturn(mockColumnValueToMapValueConverter);
+ when(mockConfig.getLoggerContext()).thenReturn(mockLoggerContext);
+ when(mockConfig.getMultiRowProcessorFactory()).thenReturn(mockMultiRowProcessorFactory);
+ when(mockConfig.getPreparedStatementSupplier()).thenReturn(mockPreparedStatementSupplier);
+ when(mockConfig.getSqlParametersSetter()).thenReturn(mockSqlParametersSetter);
+ when(mockConfig.getTableNameMapper()).thenReturn(mockTableNameMapper);
+ when(mockConfig.getTableSqlFactory()).thenReturn(mockTableSqlFactory);
+
+ SormContext.Builder builder = sormContextImpl.builder();
+ assertNotNull(builder);
+ }
+
@OrmRecord
public static class Temp {
public int id;
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/TableConnectionImplTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/TableConnectionImplTest.java
new file mode 100644
index 00000000..a3944cf7
--- /dev/null
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/TableConnectionImplTest.java
@@ -0,0 +1,31 @@
+package org.nkjmlab.sorm4j.internal;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import org.junit.jupiter.api.Test;
+import org.nkjmlab.sorm4j.OrmConnection;
+import org.nkjmlab.sorm4j.table.TableConnection;
+import org.nkjmlab.sorm4j.test.common.Player;
+
+class TableConnectionImplTest {
+
+ @Test
+ void testCloseException() throws SQLException {
+ Connection mockConnection = mock(Connection.class);
+ OrmConnection ormConnection = OrmConnection.of(mockConnection);
+
+ doThrow(SQLException.class).when(mockConnection).close();
+
+ TableConnection tableConnection =
+ TableConnection.of(ormConnection, Player.class, "players");
+
+ assertDoesNotThrow(() -> tableConnection.close());
+ verify(mockConnection).close();
+ }
+}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/result/ResultSetIteratorTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/result/ResultSetIteratorTest.java
new file mode 100644
index 00000000..853a4d28
--- /dev/null
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/result/ResultSetIteratorTest.java
@@ -0,0 +1,66 @@
+package org.nkjmlab.sorm4j.internal.result;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.nkjmlab.sorm4j.internal.OrmConnectionImpl;
+import org.nkjmlab.sorm4j.test.common.Player;
+
+class ResultSetIteratorTest {
+
+ private OrmConnectionImpl mockOrmConnection;
+ private ResultSet mockResultSet;
+ private ResultSetIterator resultSetIterator;
+
+ @BeforeEach
+ void setUp() throws SQLException {
+ mockOrmConnection = mock(OrmConnectionImpl.class);
+ mockResultSet = mock(ResultSet.class);
+ resultSetIterator = new ResultSetIterator<>(mockOrmConnection, Player.class, mockResultSet);
+ }
+
+ @Test
+ void testHasNext() throws SQLException {
+ when(mockResultSet.next()).thenReturn(true).thenReturn(false);
+
+ assertTrue(resultSetIterator.hasNext());
+ assertFalse(resultSetIterator.hasNext());
+ }
+
+ @Test
+ void testHasNextWithSQLException() throws SQLException {
+ when(mockResultSet.next()).thenThrow(new SQLException("Test exception"));
+
+ assertThrows(SQLException.class, () -> resultSetIterator.hasNext());
+ }
+
+ @Test
+ void testNext() throws SQLException {
+ Player expectedObject = new Player();
+ when(mockOrmConnection.mapRowToObject(Player.class, mockResultSet)).thenReturn(expectedObject);
+
+ assertEquals(expectedObject, resultSetIterator.next());
+ }
+
+ @Test
+ void testNextWithSQLException() throws SQLException {
+ when(mockOrmConnection.mapRowToObject(Player.class, mockResultSet))
+ .thenThrow(new SQLException("Test exception"));
+
+ assertThrows(SQLException.class, () -> resultSetIterator.next());
+ }
+
+ @Test
+ void testRemove() {
+ assertThrows(UnsupportedOperationException.class, () -> resultSetIterator.remove());
+ }
+}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/util/TryTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/util/TryTest.java
index bb7e6343..1c302668 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/util/TryTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/util/TryTest.java
@@ -390,4 +390,264 @@ void testRunOrElseThrow() {
NullPointerException.class, () -> Try.runOrElseThrow(null, e -> Try.rethrow(e)));
Try.runOrElseThrow(() -> {}, e -> Try.rethrow(e));
}
+
+ @Test
+ void test1CreateBiConsumer() {
+
+ Try.createBiConsumer((t, s) -> {}, e -> {}).accept("test", "test");
+
+ assertDoesNotThrow(
+ () ->
+ Try.createBiConsumer(
+ (t, s) -> {
+ throw new RuntimeException();
+ },
+ e -> {})
+ .accept("test", "test"));
+ }
+
+ @Test
+ void test1CreateBiConsumerWithThrow() {
+
+ Try.createBiConsumerWithThrow((t, s) -> {}, e -> new RuntimeException()).accept("test", "test");
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.createBiConsumerWithThrow(
+ (t, s) -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException())
+ .accept("test", "test"));
+ }
+
+ @Test
+ void test1CreateConsumer() {
+
+ Try.createConsumer(t -> {}, e -> {}).accept("test");
+
+ assertDoesNotThrow(
+ () ->
+ Try.createConsumer(
+ t -> {
+ throw new RuntimeException();
+ },
+ e -> {})
+ .accept("test"));
+ }
+
+ @Test
+ void test1CreateConsumerWithThrow() {
+
+ Try.createConsumerWithThrow(t -> {}, e -> new RuntimeException()).accept("test");
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.createConsumerWithThrow(
+ t -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException())
+ .accept("test"));
+ }
+
+ @Test
+ void test1CreateFunction() {
+
+ assertEquals("test", Try.createFunction(t -> "test", e -> "error").apply("test"));
+
+ assertEquals(
+ "error",
+ Try.createFunction(
+ t -> {
+ throw new RuntimeException();
+ },
+ e -> "error")
+ .apply("test"));
+ }
+
+ @Test
+ void test1CreateFunctionWithThrow() {
+
+ assertEquals(
+ "test",
+ Try.createFunctionWithThrow(t -> "test", e -> new RuntimeException()).apply("test"));
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.createFunctionWithThrow(
+ t -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException())
+ .apply("test"));
+ }
+
+ @Test
+ void test1CreateRunnable() {
+
+ Try.createRunnable(() -> {}, e -> {}).run();
+
+ assertDoesNotThrow(
+ () ->
+ Try.createRunnable(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> {})
+ .run());
+ }
+
+ @Test
+ void test1CreateRunnableWithThrow() {
+
+ Try.createRunnableWithThrow(() -> {}, e -> new RuntimeException()).run();
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.createRunnableWithThrow(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException())
+ .run());
+ }
+
+ @Test
+ void test1CreateSupplier() {
+
+ assertEquals("test", Try.createSupplier(() -> "test", e -> "error").get());
+
+ assertEquals(
+ "error",
+ Try.createSupplier(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> "error")
+ .get());
+ }
+
+ @Test
+ void test1CreateSupplierWithThrow() {
+
+ assertEquals(
+ "test", Try.createSupplierWithThrow(() -> "test", e -> new RuntimeException()).get());
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.createSupplierWithThrow(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException())
+ .get());
+ }
+
+ @Test
+ void test1OrElse() {
+
+ assertEquals("test", Try.getOrElse(() -> "test", "other"));
+
+ assertEquals(
+ "other",
+ Try.getOrElse(
+ () -> {
+ throw new RuntimeException();
+ },
+ "other"));
+ }
+
+ @Test
+ void test1OrElseGet() {
+
+ assertEquals("test", Try.getOrElseGet(() -> "test", e -> "error"));
+
+ assertEquals(
+ "error",
+ Try.getOrElseGet(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> "error"));
+ }
+
+ @Test
+ void test1OrElseThrow() {
+
+ assertEquals("test", Try.getOrElseThrow(() -> "test", e -> new RuntimeException()));
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.getOrElseThrow(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException()));
+ }
+
+ @Test
+ void test1OrElseNull() {
+
+ assertEquals("test", Try.getOrElseNull(() -> "test"));
+
+ assertNull(
+ Try.getOrElseNull(
+ () -> {
+ throw new RuntimeException();
+ }));
+ }
+
+ @Test
+ void test1Rethrow() {
+
+ RuntimeException exception = new RuntimeException("test");
+ assertThrows(RuntimeException.class, () -> Try.rethrow(exception));
+ }
+
+ @Test
+ void test1RunOrElseDo() {
+ Try.runOrElseDo(() -> {}, e -> {});
+
+ assertDoesNotThrow(
+ () ->
+ Try.runOrElseDo(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> {}));
+ }
+
+ @Test
+ void test1RunOrElseThrow() {
+
+ assertDoesNotThrow(() -> Try.runOrElseThrow(() -> {}, e -> new RuntimeException()));
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.runOrElseThrow(
+ () -> {
+ throw new RuntimeException();
+ },
+ e -> new RuntimeException()));
+ }
+
+ @Test
+ void test1RunOrElseRethrow() {
+
+ assertThrows(
+ RuntimeException.class,
+ () ->
+ Try.runOrElseRethrow(
+ () -> {
+ throw new RuntimeException();
+ }));
+ }
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/JdbcDatabaseMetaDataTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/JdbcDatabaseMetaDataTest.java
index 2d52d175..1b3ccd69 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/JdbcDatabaseMetaDataTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/JdbcDatabaseMetaDataTest.java
@@ -7,13 +7,13 @@
import org.junit.jupiter.api.Test;
import org.nkjmlab.sorm4j.test.common.Player;
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
-import org.nkjmlab.sorm4j.util.table_def.BasicTable;
+import org.nkjmlab.sorm4j.util.table_def.SimpleTableWithDefinition;
class JdbcDatabaseMetaDataTest {
@Test
void test() {
- BasicTable playersTable =
+ SimpleTableWithDefinition playersTable =
SormTestUtils.createPlayersTable(SormTestUtils.createSormWithNewContext());
String version = "2.";
JdbcDatabaseMetaData md = playersTable.getOrm().getJdbcDatabaseMetaData();
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
index 3206bfae..0cff82a7 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
@@ -1,11 +1,18 @@
package org.nkjmlab.sorm4j.result;
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.lang.reflect.InvocationTargetException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
import java.util.Map;
+
import org.junit.jupiter.api.Test;
class RowMapTest {
@@ -69,4 +76,65 @@ void testOf() {
rm.put("by", by);
assertThat(rm.getString("by").equals("aaa")).isTrue();
}
+
+ @Test
+ void testFromRecord() {
+ TestRecord record = new TestRecord(LocalDate.now(), LocalDateTime.now(), LocalTime.now());
+ RowMap rowMap = RowMap.fromRecord(record);
+ assertEquals(record.date(), rowMap.getLocalDate("date"));
+ assertEquals(record.dateTime(), rowMap.getLocalDateTime("dateTime"));
+ assertEquals(record.time(), rowMap.getLocalTime("time"));
+ }
+
+ @Test
+ void testToRecord() {
+ RowMap rowMap =
+ RowMap.of(
+ "date", LocalDate.now(),
+ "dateTime", LocalDateTime.now(),
+ "time", LocalTime.now());
+
+ TestRecord record = rowMap.toRecord(TestRecord.class);
+
+ assertEquals(rowMap.getLocalDate("date"), record.date());
+ assertEquals(rowMap.getLocalDateTime("dateTime"), record.dateTime());
+ assertEquals(rowMap.getLocalTime("time"), record.time());
+ }
+
+ @Test
+ void testFromRecordWithException() {
+ TestRecord mockRecord = mock(TestRecord.class);
+ when(mockRecord.date()).thenThrow(new RuntimeException("Test exception"));
+ assertThrows(InvocationTargetException.class, () -> RowMap.fromRecord(mockRecord));
+ }
+
+ @Test
+ void testOfMethod() {
+ RowMap rowMap =
+ RowMap.of("key1", "value1", "key2", 2, "key3", 3.0, "key4", true, "key5", "value5");
+
+ assertEquals("value1", rowMap.getString("key1"));
+ assertEquals(2, rowMap.getInteger("key2"));
+ assertEquals(3.0, rowMap.getDouble("key3"));
+ assertEquals(true, rowMap.get("key4"));
+ assertEquals("value5", rowMap.getString("key5"));
+
+ assertEquals(5, rowMap.size());
+ }
+
+ @Test
+ void testToRecord1() {
+ LocalDate date = LocalDate.now();
+ RowMap rowMap =
+ RowMap.of("date", date, "dateTime", LocalDateTime.now(), "time", LocalTime.now());
+ assertThat(rowMap.toRecord(TestRecord.class).date()).isEqualTo(date);
+ }
+
+ @Test
+ void testToRecordWithException() {
+ RowMap rowMap = RowMap.of("date", "b");
+ assertThrows(RuntimeException.class, () -> rowMap.toRecord(TestRecord.class));
+ }
+
+ record TestRecord(LocalDate date, LocalDateTime dateTime, LocalTime time) {}
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/table/TableTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/table/TableTest.java
index ed0eedcb..6a1d3862 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/table/TableTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/table/TableTest.java
@@ -32,15 +32,15 @@
import org.nkjmlab.sorm4j.test.common.Player;
import org.nkjmlab.sorm4j.test.common.Sport;
import org.nkjmlab.sorm4j.util.sql.JoinSql;
-import org.nkjmlab.sorm4j.util.table_def.BasicTable;
+import org.nkjmlab.sorm4j.util.table_def.SimpleTableWithDefinition;
class TableTest {
private static final String SELECT_FROM_PLAYERS_WHERE_ID_SQL = "select * from players where id=?";
private static final ParameterizedSql SELECT_FROM_PLAYERS_WHERE_ID_PSQL =
ParameterizedSql.of(SELECT_FROM_PLAYERS_WHERE_ID_SQL, 1);
- private BasicTable playersTable;
- private BasicTable sportsTable;
+ private SimpleTableWithDefinition playersTable;
+ private SimpleTableWithDefinition sportsTable;
@BeforeEach
void setUp() {
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/test/common/SormTestUtils.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/test/common/SormTestUtils.java
index e1b04c26..b5fae137 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/test/common/SormTestUtils.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/test/common/SormTestUtils.java
@@ -10,7 +10,7 @@
import org.nkjmlab.sorm4j.Sorm;
import org.nkjmlab.sorm4j.common.DriverManagerDataSource;
import org.nkjmlab.sorm4j.context.SormContext;
-import org.nkjmlab.sorm4j.util.table_def.BasicTable;
+import org.nkjmlab.sorm4j.util.table_def.SimpleTableWithDefinition;
import org.nkjmlab.sorm4j.util.table_def.TableDefinition;
public class SormTestUtils {
@@ -36,7 +36,7 @@ public class SormTestUtils {
public static final Sport TENNIS = new Sport(1, Sport.Sports.TENNIS);
public static final Sport SOCCER = new Sport(2, Sport.Sports.SOCCER);
- public static BasicTable createGuestsTable(Sorm sorm) {
+ public static SimpleTableWithDefinition createGuestsTable(Sorm sorm) {
TableDefinition schema =
TableDefinition.builder("guests")
.addColumnDefinition("id", INT, AUTO_INCREMENT, PRIMARY_KEY)
@@ -46,16 +46,16 @@ public static BasicTable createGuestsTable(Sorm sorm) {
.addIndexDefinition("name")
.build();
- BasicTable tbl = new BasicTable<>(sorm, Guest.class, schema);
+ SimpleTableWithDefinition tbl = new SimpleTableWithDefinition<>(sorm, Guest.class, schema);
tbl.dropTableIfExists().createTableIfNotExists().createIndexesIfNotExists();
return tbl;
}
- public static BasicTable createPlayersTable(Sorm sorm) {
+ public static SimpleTableWithDefinition createPlayersTable(Sorm sorm) {
return createPlayersTable(sorm, "players");
}
- public static BasicTable createPlayersTable(Sorm sorm, String tableName) {
+ public static SimpleTableWithDefinition createPlayersTable(Sorm sorm, String tableName) {
TableDefinition schema =
TableDefinition.builder(tableName)
@@ -66,20 +66,20 @@ public static BasicTable createPlayersTable(Sorm sorm, String tableName)
.addIndexDefinition("name")
.build();
- BasicTable tbl = new BasicTable<>(sorm, Player.class, schema);
+ SimpleTableWithDefinition tbl = new SimpleTableWithDefinition<>(sorm, Player.class, schema);
tbl.dropTableIfExists();
tbl.createTableIfNotExists().createIndexesIfNotExists();
return tbl;
}
- public static BasicTable createSportsTable(Sorm sorm) {
+ public static SimpleTableWithDefinition createSportsTable(Sorm sorm) {
TableDefinition schema =
TableDefinition.builder("sports")
.addColumnDefinition("id", INT, PRIMARY_KEY)
.addColumnDefinition("name", VARCHAR)
.build();
- BasicTable tbl = new BasicTable<>(sorm, Sport.class, schema);
+ SimpleTableWithDefinition tbl = new SimpleTableWithDefinition<>(sorm, Sport.class, schema);
tbl.dropTableIfExists();
tbl.createTableIfNotExists().createIndexesIfNotExists();
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrmTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrmTest.java
new file mode 100644
index 00000000..5df0cf9c
--- /dev/null
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrmTest.java
@@ -0,0 +1,28 @@
+package org.nkjmlab.sorm4j.util.h2;
+
+import org.junit.jupiter.api.Test;
+import org.nkjmlab.sorm4j.OrmConnection;
+import org.nkjmlab.sorm4j.Sorm;
+import org.nkjmlab.sorm4j.annotation.OrmRecord;
+import org.nkjmlab.sorm4j.test.common.SormTestUtils;
+
+class H2BasicTableMappedOrmTest {
+
+ @Test
+ void test2() throws InterruptedException {
+ Sorm sorm = SormTestUtils.createSormWithNewContext();
+ try (OrmConnection con = sorm.open()) {
+ H2BasicTableMappedOrm table = new H2BasicTableMappedOrm<>(con, Example.class);
+ table.dropTableIfExists();
+ table.createTableIfNotExists();
+ table.getOrm();
+ table.getTableName();
+ table.getTableDefinition();
+ table.getValueType();
+ table.insert(new Example(0, "name"));
+ }
+ }
+
+ @OrmRecord
+ public record Example(int id, String name) {}
+}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
similarity index 85%
rename from sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java
rename to sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
index 2fd2c07f..f7efe488 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
@@ -19,14 +19,14 @@
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
import org.nkjmlab.sorm4j.util.datatype.JsonByte;
import org.nkjmlab.sorm4j.util.h2.functions.table.CsvRead;
-import org.nkjmlab.sorm4j.util.table_def.BasicTable;
+import org.nkjmlab.sorm4j.util.table_def.SimpleTableWithDefinition;
-class BasicH2TableTest {
+class H2BasicTableTest {
@Test
void test2() throws InterruptedException {
Sorm sorm = SormTestUtils.createSormWithNewContext();
- BasicH2Table table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, OrmRecordExample.class);
table.dropTableIfExists();
table.createTableIfNotExists();
@@ -37,10 +37,8 @@ void test2() throws InterruptedException {
ps.setString(2, "C");
ps.setObject(3, "{\"3\":\"val1\"}".getBytes());
ps.execute();
- // H2ServerUtils.openBrowser(con, true);
- // Thread.sleep(1000000);
} catch (SQLException e) {
- e.printStackTrace();
+ throw Try.rethrow(e);
}
}
@@ -56,9 +54,9 @@ void test() throws InterruptedException {
} catch (IOException e) {
throw Try.rethrow(e);
}
- BasicH2Table table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, OrmRecordExample.class);
{
- BasicTable t = new BasicTable<>(sorm, OrmRecordExample.class);
+ new SimpleTableWithDefinition<>(sorm, OrmRecordExample.class);
}
table.dropTableIfExists();
table.createTableIfNotExists(CsvRead.builderForCsvWithHeader(tmpCsv).build());
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/SimpleH2TableTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/SimpleH2TableTest.java
deleted file mode 100644
index 419df760..00000000
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/SimpleH2TableTest.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.nkjmlab.sorm4j.util.h2;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.Mockito.mock;
-
-import org.junit.jupiter.api.Test;
-import org.nkjmlab.sorm4j.Sorm;
-import org.nkjmlab.sorm4j.test.common.Player;
-
-class SimpleH2TableTest {
-
- @Test
- void testSimpleH2TableWithValueType() {
- Class> valueType =Player.class;
- Sorm mockSorm = mock(Sorm.class);
-
- SimpleH2Table> table = new SimpleH2Table<>(mockSorm, valueType);
-
- assertNotNull(table);
- }
-
- @Test
- void testSimpleH2TableWithValueTypeAndTableName() {
- Class> valueType = Player.class;
- String tableName = "test_table";
- Sorm mockSorm = mock(Sorm.class);
-
- SimpleH2Table> table = new SimpleH2Table<>(mockSorm, valueType, tableName);
-
- assertNotNull(table);
- }
-}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactoryTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactoryTest.java
similarity index 83%
rename from sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactoryTest.java
rename to sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactoryTest.java
index 36408c0b..0c01042b 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2LocalDataSourceFactoryTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactoryTest.java
@@ -18,15 +18,15 @@
import com.fasterxml.jackson.databind.DatabindException;
import com.fasterxml.jackson.databind.ObjectMapper;
-class H2LocalDataSourceFactoryTest {
+class H2DataSourceFactoryTest {
@Test
void test() throws StreamReadException, DatabindException, IOException, SQLException {
- H2LocalDataSourceFactory factory =
+ H2DataSourceFactory factory =
new ObjectMapper()
.readValue(
- H2LocalDataSourceFactoryTest.class.getResourceAsStream("h2.json.sample"),
- H2LocalDataSourceFactory.Builder.class)
+ H2DataSourceFactoryTest.class.getResourceAsStream("h2.json.sample"),
+ H2DataSourceFactory.Builder.class)
.build();
factory.getDatabaseFile().delete();
factory.makeFileDatabaseIfNotExists();
@@ -45,14 +45,14 @@ void test() throws StreamReadException, DatabindException, IOException, SQLExcep
assertThat(factory.toString()).contains("jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1");
- H2LocalDataSourceFactory.builder();
- H2LocalDataSourceFactory.builder(
+ H2DataSourceFactory.builder();
+ H2DataSourceFactory.builder(
factory.getDatabaseDirectory(),
factory.getDatabaseName(),
factory.getUsername(),
factory.getPassword());
- H2LocalDataSourceFactory.createTemporalInMemoryDataSource();
+ H2DataSourceFactory.createTemporalInMemoryDataSource();
factory.createEmbeddedModeDataSource().getConnection();
factory.createInMemoryModeDataSource().getConnection();
@@ -76,8 +76,8 @@ void testBuilderAndCreationMethods() {
String username = "user";
String password = "pass";
- H2LocalDataSourceFactory factory =
- H2LocalDataSourceFactory.builder(tempDir, dbName, username, password).build();
+ H2DataSourceFactory factory =
+ H2DataSourceFactory.builder(tempDir, dbName, username, password).build();
assertEquals(tempDir.getAbsolutePath(), factory.getDatabaseDirectory().getAbsolutePath());
assertEquals(dbName, factory.getDatabaseName());
@@ -124,7 +124,7 @@ void testBuilderWithInvalidArguments() {
assertThrows(
IllegalArgumentException.class,
() -> {
- H2LocalDataSourceFactory.builder(invalidDir, dbName, username, password);
+ H2DataSourceFactory.builder(invalidDir, dbName, username, password);
});
}
@@ -135,8 +135,8 @@ void testMakeFileDatabaseIfNotExists() {
String username = "user";
String password = "pass";
- H2LocalDataSourceFactory factory =
- H2LocalDataSourceFactory.builder(tempDir, dbName, username, password).build();
+ H2DataSourceFactory factory =
+ H2DataSourceFactory.builder(tempDir, dbName, username, password).build();
boolean result = factory.makeFileDatabaseIfNotExists();
assertTrue(result || !result);
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWriteTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWriteTest.java
index 23543005..7162e46d 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWriteTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/system/CsvWriteTest.java
@@ -24,9 +24,12 @@ public void testBuilderWithFileAndQuery() {
@Test
public void testBuilderWithFileOnly() {
File csvFile = new File("output.csv");
- CsvWrite csvWrite = CsvWrite.builder(csvFile).query("SELECT * FROM table").build();
+ CsvWrite csvWrite =
+ CsvWrite.builder(csvFile).query("SELECT * FROM table where id='sorm'").build();
assertEquals(
- "csvwrite('" + csvFile.getAbsolutePath() + "', 'SELECT * FROM table', null)",
+ "csvwrite('"
+ + csvFile.getAbsolutePath()
+ + "', 'SELECT * FROM table where id=''sorm''', null)",
csvWrite.getSql());
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/table/SelectCsvReadSqlTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/table/SelectCsvReadSqlTest.java
index 3e348fa9..a991b1e6 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/table/SelectCsvReadSqlTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/functions/table/SelectCsvReadSqlTest.java
@@ -16,12 +16,12 @@
import org.junit.jupiter.api.Test;
import org.nkjmlab.sorm4j.Sorm;
import org.nkjmlab.sorm4j.annotation.OrmRecord;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
import org.nkjmlab.sorm4j.util.h2.commands.InsertSelectCsvReadSql;
import org.nkjmlab.sorm4j.util.h2.commands.SelectCsvReadSql;
import org.nkjmlab.sorm4j.util.h2.commands.annotation.CsvColumn;
import org.nkjmlab.sorm4j.util.h2.commands.annotation.SkipCsvRead;
-import org.nkjmlab.sorm4j.util.h2.datasource.H2LocalDataSourceFactory;
+import org.nkjmlab.sorm4j.util.h2.datasource.H2DataSourceFactory;
class SelectCsvReadSqlTest {
@Test
@@ -76,8 +76,8 @@ void testBuilderWithMappingAndColumns() {
@Test
void test0() throws URISyntaxException {
File file = Paths.get(SelectCsvReadSqlTest.class.getResource("test.tsv").toURI()).toFile();
- Sorm sorm = Sorm.create(H2LocalDataSourceFactory.createTemporalInMemoryDataSource());
- BasicH2Table table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+ Sorm sorm = Sorm.create(H2DataSourceFactory.createTemporalInMemoryDataSource());
+ H2BasicTable table = new H2BasicTable<>(sorm, OrmRecordExample.class);
table.createTableIfNotExists(
CsvRead.builderForCsvWithoutHeader(file, 2).charset("UTF-16").fieldSeparator("\t").build());
assertThat(table.selectAll().get(0).id).isEqualTo(1);
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingServiceTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingServiceTest.java
index 3c22a9ba..1e5bc18a 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingServiceTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingServiceTest.java
@@ -1,6 +1,7 @@
package org.nkjmlab.sorm4j.util.h2.server;
import java.io.IOException;
+import java.sql.Connection;
import java.sql.SQLException;
import org.junit.jupiter.api.Test;
import org.nkjmlab.sorm4j.common.DriverManagerDataSource;
@@ -12,11 +13,11 @@ class H2WebBrowsingServiceTest {
@Test
void test() throws StreamReadException, DatabindException, IOException, SQLException {
- @SuppressWarnings("unused")
DriverManagerDataSource ds = SormTestUtils.createNewDatabaseDataSource();
H2WebBrowsingService server = new H2WebBrowsingService(true);
- // server.open(ds);
- // server.open(ds.getConnection());
+ Connection conn = ds.getConnection();
+ conn.close();
+ server.open(conn);
server.getWebServer().stop();
}
}
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jackson/JacksonSormContextTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jackson/JacksonSormContextTest.java
index efec3ca5..c5338d02 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jackson/JacksonSormContextTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jackson/JacksonSormContextTest.java
@@ -7,7 +7,7 @@
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
import org.nkjmlab.sorm4j.util.datatype.JsonByte;
import org.nkjmlab.sorm4j.util.datatype.OrmJsonColumnContainer;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -21,7 +21,7 @@ void testBuilder() {
SormTestUtils.createNewDatabaseDataSource(),
JacksonSormContext.builder(new ObjectMapper()).build());
- BasicH2Table table = new BasicH2Table<>(sorm, JacksonRecord.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, JacksonRecord.class);
table.createTableIfNotExists();
table.insert(new JacksonRecord(new JsonByte("{\"name\":\"Alice\",\"age\":20}")));
assertThat(table.selectAll().get(0).jsonCol.toString()).contains("Alice");
@@ -42,7 +42,7 @@ void testBuilder1() {
SormTestUtils.createNewDatabaseDataSource(),
JacksonSormContext.builder(new ObjectMapper()).build());
- BasicH2Table table = new BasicH2Table<>(sorm, HasJsonColumn.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, HasJsonColumn.class);
assertThat(table.getTableDefinition().getCreateTableIfNotExistsStatement())
.isEqualTo("create table if not exists HAS_JSON_COLUMNS(ID integer, JSON_COL json)");
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jts/GeometryTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jts/GeometryTest.java
index 8c9db7f5..ef184bac 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jts/GeometryTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/jts/GeometryTest.java
@@ -9,7 +9,7 @@
import org.nkjmlab.sorm4j.annotation.OrmRecord;
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
import org.nkjmlab.sorm4j.util.datatype.GeometryString;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
class GeometryTest {
@@ -18,7 +18,7 @@ void stringTest() {
Sorm sorm = Sorm.create(SormTestUtils.createNewDatabaseDataSource());
- BasicH2Table table = new BasicH2Table<>(sorm, GeometryStringRecord.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, GeometryStringRecord.class);
assertThat(table.getTableDefinition().getCreateTableIfNotExistsStatement())
.contains("GEO_STR geometry");
table.createTableIfNotExists();
@@ -45,7 +45,7 @@ void jtsTest() {
Sorm sorm =
Sorm.create(SormTestUtils.createNewDatabaseDataSource(), JtsSormContext.builder().build());
- BasicH2Table table = new BasicH2Table<>(sorm, GeometryJtsRecord.class);
+ H2BasicTable table = new H2BasicTable<>(sorm, GeometryJtsRecord.class);
assertThat(table.getTableDefinition().getCreateTableIfNotExistsStatement())
.contains("GEO_JTS geometry");
table.createTableIfNotExists();
diff --git a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/table_def/TableDefinitionTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/table_def/TableDefinitionTest.java
index 0f785eb3..d2fe5be4 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/table_def/TableDefinitionTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/table_def/TableDefinitionTest.java
@@ -21,7 +21,7 @@
import org.nkjmlab.sorm4j.annotation.OrmRecord;
import org.nkjmlab.sorm4j.result.RowMap;
import org.nkjmlab.sorm4j.test.common.SormTestUtils;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
import org.nkjmlab.sorm4j.util.h2.functions.table.CsvRead;
import org.nkjmlab.sorm4j.util.table_def.annotation.AutoIncrement;
import org.nkjmlab.sorm4j.util.table_def.annotation.Check;
@@ -69,7 +69,7 @@ void test() throws URISyntaxException {
.build()
.getSql());
- BasicH2Table table = new BasicH2Table<>(sorm, TableDefExample.class, def);
+ H2BasicTable