From d2c273c755908feba563abaedc2f513326b7297d Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 15 Dec 2023 14:58:26 +0900
Subject: [PATCH 01/15] Add test

---
 .../internal/TableConnectionImplTest.java     | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/TableConnectionImplTest.java

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<Player> tableConnection =
+        TableConnection.of(ormConnection, Player.class, "players");
+
+    assertDoesNotThrow(() -> tableConnection.close());
+    verify(mockConnection).close();
+  }
+}

From 1b64f1817b2e2ae20954a524e2cb9a5036b02984 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 15 Dec 2023 15:05:28 +0900
Subject: [PATCH 02/15] Add tests

---
 ...ColumnValueToJavaObjectConvertersTest.java | 59 ++++++++++++++++-
 .../result/ResultSetIteratorTest.java         | 66 +++++++++++++++++++
 .../sorm4j/util/h2/BasicH2TableTest.java      |  2 +-
 3 files changed, 125 insertions(+), 2 deletions(-)
 create mode 100644 sorm4j/src/test/java/org/nkjmlab/sorm4j/internal/result/ResultSetIteratorTest.java

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/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<Player> 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/util/h2/BasicH2TableTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java
index 2fd2c07f..afec90c1 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/BasicH2TableTest.java
@@ -58,7 +58,7 @@ void test() throws InterruptedException {
     }
     BasicH2Table<OrmRecordExample> table = new BasicH2Table<>(sorm, OrmRecordExample.class);
     {
-      BasicTable<OrmRecordExample> t = new BasicTable<>(sorm, OrmRecordExample.class);
+      new BasicTable<>(sorm, OrmRecordExample.class);
     }
     table.dropTableIfExists();
     table.createTableIfNotExists(CsvRead.builderForCsvWithHeader(tmpCsv).build());

From 239455795d4a839685112f8bc633e26559c18e13 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 15 Dec 2023 15:23:01 +0900
Subject: [PATCH 03/15] Add tests

---
 .../sorm4j/internal/SormContextImpl.java      |  2 +-
 .../util/h2/server/H2WebBrowsingService.java  | 11 -----
 .../sorm4j/internal/SormContextImplTest.java  | 47 ++++++++++++++++++-
 .../h2/server/H2WebBrowsingServiceTest.java   |  7 +--
 4 files changed, 51 insertions(+), 16 deletions(-)

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormContextImpl.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormContextImpl.java
index 6060dedf..9d0eb03a 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormContextImpl.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormContextImpl.java
@@ -40,7 +40,7 @@ public final class SormContextImpl implements SormContext {
   private final ConcurrentMap<Class<?>, SqlResultToColumnsMapping<?>> sqlResultToColumnsMappings;
   private final SormConfig config;
 
-  private SormContextImpl(SormConfig sormConfig) {
+  SormContextImpl(SormConfig sormConfig) {
     this.config = sormConfig;
     this.tableMetaDataMap = new ConcurrentHashMap<>();
     this.tableSqlMap = new ConcurrentHashMap<>();
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..cda2c4ec 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
@@ -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/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/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();
   }
 }

From 3aaae35c72f567fde7557d979ddbd15459bb7f92 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 15 Dec 2023 16:03:08 +0900
Subject: [PATCH 04/15] Add tests

---
 .../org/nkjmlab/sorm4j/result/RowMap.java     |  25 +-
 .../nkjmlab/sorm4j/internal/util/TryTest.java | 260 ++++++++++++++++++
 .../org/nkjmlab/sorm4j/result/RowMapTest.java |  71 ++++-
 3 files changed, 351 insertions(+), 5 deletions(-)

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/result/RowMap.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/result/RowMap.java
index 92a850df..af13211b 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/result/RowMap.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/result/RowMap.java
@@ -107,7 +107,7 @@ static String toKey(String key) {
    * @return
    */
   @Experimental
-  public static <T extends Record> RowMap fromRecord(T src) {
+  static <T extends Record> RowMap fromRecord(T src) {
     try {
       RecordComponent[] recordComponents = src.getClass().getRecordComponents();
       BasicRowMap destMap = new BasicRowMap();
@@ -133,19 +133,19 @@ public static <T extends Record> RowMap fromRecord(T src) {
    * </pre>
    *
    * @param <T>
-   * @param <S>
+   * @param src
    * @param toType
    * @return
    */
   @Experimental
-  default <T extends Record> T toRecord(Class<T> toType) {
+  static <T extends Record> T toRecord(RowMap src, Class<T> toType) {
     try {
       RecordComponent[] recordComponents = toType.getRecordComponents();
       Class<?>[] types = new Class<?>[recordComponents.length];
       Object[] args = new Object[recordComponents.length];
       for (int i = 0; i < recordComponents.length; i++) {
         types[i] = recordComponents[i].getType();
-        args[i] = get(StringCache.toCanonicalCase(recordComponents[i].getName()));
+        args[i] = src.get(StringCache.toCanonicalCase(recordComponents[i].getName()));
       }
       return toType.getDeclaredConstructor(types).newInstance(args);
     } catch (InstantiationException
@@ -157,4 +157,21 @@ default <T extends Record> T toRecord(Class<T> toType) {
       throw Try.rethrow(e);
     }
   }
+  /**
+   * The object is converted to a record object.
+   *
+   * <pre>
+   * A key of the map is included in the record components. =>  the record component set the value.
+   * A key of the map is not included in the record components. => the entry of the map is ignore.
+   * A record component does not exists in the key set of the map => the record component set as null. if the component is primitive type, an exception is thrown.
+   * </pre>
+   *
+   * @param <T>
+   * @param toType
+   * @return
+   */
+  @Experimental
+  default <T extends Record> T toRecord(Class<T> toType) {
+    return toRecord(this, toType);
+  }
 }
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/RowMapTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
index 3206bfae..f1f2577c 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,19 @@
 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.ArgumentMatchers.anyString;
+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 +77,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) {}
 }

From 2e0e5cf41f4f3d07d44ddc2fbbdc86dd910b8349 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 15 Dec 2023 16:06:22 +0900
Subject: [PATCH 05/15] Modify import

---
 .../org/nkjmlab/sorm4j/util/h2/server/H2WebBrowsingService.java | 2 +-
 sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java  | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

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 cda2c4ec..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;
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 f1f2577c..0cff82a7 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/result/RowMapTest.java
@@ -3,7 +3,6 @@
 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.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 

From c462a4c1b0606be06c4451b50c6cba126ca0caad Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 20 Dec 2023 10:26:34 +0900
Subject: [PATCH 06/15] Modify returned type

---
 .../nkjmlab/sorm4j/util/h2/BasicH2Table.java    | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java
index 763c2b2a..f004eec0 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java
@@ -37,6 +37,15 @@ public BasicH2Table<T> createTableIfNotExists() {
     return this;
   }
 
+  public BasicH2Table<T> createTableIfNotExists(CsvRead csvRead) {
+    getOrm()
+        .execute(
+            getTableDefinition().getCreateTableIfNotExistsStatement()
+                + " as select * from "
+                + csvRead);
+    return this;
+  }
+
   @Experimental
   @Override
   public BasicH2Table<T> createIndexesIfNotExists() {
@@ -57,12 +66,4 @@ public BasicH2Table<T> dropTableIfExistsCascade() {
     super.dropTableIfExistsCascade();
     return this;
   }
-
-  public void createTableIfNotExists(CsvRead csvRead) {
-    getOrm()
-        .execute(
-            getTableDefinition().getCreateTableIfNotExistsStatement()
-                + " as select * from "
-                + csvRead);
-  }
 }

From bdad051e738d3c226bb83037e94d664706f6be17 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 20 Dec 2023 14:04:10 +0900
Subject: [PATCH 07/15] Add build script

---
 README.md                                |  2 +-
 sorm4j-example/pom.xml                   |  2 +-
 sorm4j-jmh/pom.xml                       |  2 +-
 sorm4j/.gitignore                        |  1 +
 sorm4j/build/mvn-caller.bat              | 18 ++++++++++++++++++
 sorm4j/build/mvn-use-latest-versions.bat | 11 +++++++++++
 sorm4j/build/sorm4j-compile.bat          |  3 +++
 sorm4j/build/sorm4j-deploy.bat           |  4 ++++
 sorm4j/build/sorm4j-install.bat          |  4 ++++
 sorm4j/pom.xml                           |  2 +-
 10 files changed, 45 insertions(+), 4 deletions(-)
 create mode 100644 sorm4j/build/mvn-caller.bat
 create mode 100644 sorm4j/build/mvn-use-latest-versions.bat
 create mode 100644 sorm4j/build/sorm4j-compile.bat
 create mode 100644 sorm4j/build/sorm4j-deploy.bat
 create mode 100644 sorm4j/build/sorm4j-install.bat

diff --git a/README.md b/README.md
index b148ff8a..427158a1 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ The latest release is available at [Maven Central Repository](https://mvnreposit
  <dependency>
    <groupId>org.nkjmlab</groupId>
    <artifactId>sorm4j</artifactId>
-   <version>2.1.0</version>
+   <version>2.1.1</version>
  </dependency>
 ```
 We assume the following customer table in example: `create table customer (id int primary key, name varchar, address varchar)`
diff --git a/sorm4j-example/pom.xml b/sorm4j-example/pom.xml
index e66e2d73..69bb0284 100644
--- a/sorm4j-example/pom.xml
+++ b/sorm4j-example/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j-example</artifactId>
-	<version>2.1.0</version>
+	<version>2.1.1</version>
 	<description>Example of Sorm4j</description>
 
 	<properties>
diff --git a/sorm4j-jmh/pom.xml b/sorm4j-jmh/pom.xml
index 6d7ba85c..1b06c932 100644
--- a/sorm4j-jmh/pom.xml
+++ b/sorm4j-jmh/pom.xml
@@ -21,7 +21,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.nkjmlab</groupId>
   <artifactId>sorm4j-jmh</artifactId>
-  <version>2.0.7</version>
+  <version>2.1.1</version>
   <packaging>jar</packaging>
   <name>Sorm4j benchmark</name>
 
diff --git a/sorm4j/.gitignore b/sorm4j/.gitignore
index fa2faa2d..d1c6e541 100644
--- a/sorm4j/.gitignore
+++ b/sorm4j/.gitignore
@@ -30,3 +30,4 @@ hs_err_pid*
 
 db.properties
 db.properties1
+sorm4j-coveralls.bat
diff --git a/sorm4j/build/mvn-caller.bat b/sorm4j/build/mvn-caller.bat
new file mode 100644
index 00000000..b4ce094b
--- /dev/null
+++ b/sorm4j/build/mvn-caller.bat
@@ -0,0 +1,18 @@
+setlocal
+chcp 65001
+@echo off
+set CURRENT_DIR=%~dp0
+cd /d %CURRENT_DIR%
+cd ../
+
+set JAVA_HOME=%JAVA_17_HOME%
+set PATH=%JAVA_HOME%/bin;%PATH%
+
+@echo on
+java -version
+@echo off
+
+call %~1
+
+@if errorlevel 1 pause
+endlocal
diff --git a/sorm4j/build/mvn-use-latest-versions.bat b/sorm4j/build/mvn-use-latest-versions.bat
new file mode 100644
index 00000000..4866f49d
--- /dev/null
+++ b/sorm4j/build/mvn-use-latest-versions.bat
@@ -0,0 +1,11 @@
+setlocal
+@echo off
+
+set CURRENT_DIR=%~dp0
+cd /d %CURRENT_DIR%
+cd ../
+
+call mvn versions:use-latest-versions
+
+@if errorlevel 1 pause
+endlocal
diff --git a/sorm4j/build/sorm4j-compile.bat b/sorm4j/build/sorm4j-compile.bat
new file mode 100644
index 00000000..217ec882
--- /dev/null
+++ b/sorm4j/build/sorm4j-compile.bat
@@ -0,0 +1,3 @@
+setlocal
+cd /d %~dp0
+mvn-caller.bat "mvn clean compile"
\ No newline at end of file
diff --git a/sorm4j/build/sorm4j-deploy.bat b/sorm4j/build/sorm4j-deploy.bat
new file mode 100644
index 00000000..b1b7039c
--- /dev/null
+++ b/sorm4j/build/sorm4j-deploy.bat
@@ -0,0 +1,4 @@
+setlocal
+cd /d %~dp0
+killall java
+mvn-caller.bat "mvn clean deploy -P ossrh"
diff --git a/sorm4j/build/sorm4j-install.bat b/sorm4j/build/sorm4j-install.bat
new file mode 100644
index 00000000..b1b7039c
--- /dev/null
+++ b/sorm4j/build/sorm4j-install.bat
@@ -0,0 +1,4 @@
+setlocal
+cd /d %~dp0
+killall java
+mvn-caller.bat "mvn clean deploy -P ossrh"
diff --git a/sorm4j/pom.xml b/sorm4j/pom.xml
index 25988453..f74a5ad6 100644
--- a/sorm4j/pom.xml
+++ b/sorm4j/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j</artifactId>
-	<version>2.1.0</version>
+	<version>2.1.1</version>
 	<name>sorm4j</name>
 	<description>Simple micro Object-Relation Mapper for Java</description>
 	<url>https://github.com/yuu-nkjm/sorm4j</url>

From 2cc576a1a6b6c45fc48d0dbd9e4317f4fa32186d Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 20 Dec 2023 14:05:40 +0900
Subject: [PATCH 08/15] Rename some classes

---
 .../sorm4j/example/first/TableExample.java    |  4 +--
 .../example/opendata/LoadOpenDataExample.java | 16 +++++-----
 .../{BasicH2Table.java => H2BasicTable.java}  | 18 +++++------
 .../org/nkjmlab/sorm4j/util/h2/H2Table.java   |  3 +-
 .../nkjmlab/sorm4j/util/h2/SimpleH2Table.java | 30 -----------------
 .../h2/commands/annotation/CsvColumn.java     |  4 +--
 ...eFactory.java => H2DataSourceFactory.java} | 28 ++++++++--------
 ...le.java => SimpleTableWithDefinition.java} |  8 ++---
 .../util/table_def/TableWithDefinition.java   |  5 +++
 .../util/table_def/annotation/package.html    |  5 +++
 .../sorm4j/util/table_def/package.html        |  5 +++
 .../result/JdbcDatabaseMetaDataTest.java      |  4 +--
 .../org/nkjmlab/sorm4j/table/TableTest.java   |  6 ++--
 .../sorm4j/test/common/SormTestUtils.java     | 16 +++++-----
 ...H2TableTest.java => H2BasicTableTest.java} | 10 +++---
 .../sorm4j/util/h2/SimpleH2TableTest.java     | 32 -------------------
 ...Test.java => H2DataSourceFactoryTest.java} | 24 +++++++-------
 .../functions/table/SelectCsvReadSqlTest.java |  8 ++---
 .../util/jackson/JacksonSormContextTest.java  |  6 ++--
 .../nkjmlab/sorm4j/util/jts/GeometryTest.java |  6 ++--
 .../util/table_def/TableDefinitionTest.java   |  4 +--
 21 files changed, 97 insertions(+), 145 deletions(-)
 rename sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/{BasicH2Table.java => H2BasicTable.java} (67%)
 delete mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/SimpleH2Table.java
 rename sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/{H2LocalDataSourceFactory.java => H2DataSourceFactory.java} (91%)
 rename sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/{BasicTable.java => SimpleTableWithDefinition.java} (69%)
 create mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/TableWithDefinition.java
 create mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/annotation/package.html
 create mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/table_def/package.html
 rename sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/{BasicH2TableTest.java => H2BasicTableTest.java} (88%)
 delete mode 100644 sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/SimpleH2TableTest.java
 rename sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/datasource/{H2LocalDataSourceFactoryTest.java => H2DataSourceFactoryTest.java} (83%)

diff --git a/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/first/TableExample.java b/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/first/TableExample.java
index b90e325c..aa73bb8f 100644
--- a/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/first/TableExample.java
+++ b/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/first/TableExample.java
@@ -3,7 +3,7 @@
 import org.nkjmlab.sorm4j.Sorm;
 import org.nkjmlab.sorm4j.annotation.OrmRecord;
 import org.nkjmlab.sorm4j.table.TableConnection;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
 
 public class TableExample {
 
@@ -12,7 +12,7 @@ public static void main(String[] args) {
     Sorm sorm = Sorm.create("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;");
 
     // Create a table access object.
-    BasicH2Table<Customer> customerTable = new BasicH2Table<>(sorm, Customer.class);
+    H2BasicTable<Customer> customerTable = new H2BasicTable<>(sorm, Customer.class);
 
     // Create the table based on Customer.class
     customerTable.createTableIfNotExists();
diff --git a/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/opendata/LoadOpenDataExample.java b/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/opendata/LoadOpenDataExample.java
index 14547612..26b97185 100644
--- a/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/opendata/LoadOpenDataExample.java
+++ b/sorm4j-example/src/main/java/org/nkjmlab/sorm4j/example/opendata/LoadOpenDataExample.java
@@ -16,8 +16,8 @@
 import org.nkjmlab.sorm4j.example.opendata.LoadOpenDataExample.ModClothsTable.ModCloth;
 import org.nkjmlab.sorm4j.example.opendata.LoadOpenDataExample.TwitchsTable.Twitch;
 import org.nkjmlab.sorm4j.internal.util.Try;
-import org.nkjmlab.sorm4j.util.h2.BasicH2Table;
-import org.nkjmlab.sorm4j.util.h2.datasource.H2LocalDataSourceFactory;
+import org.nkjmlab.sorm4j.util.h2.H2BasicTable;
+import org.nkjmlab.sorm4j.util.h2.datasource.H2DataSourceFactory;
 import org.nkjmlab.sorm4j.util.h2.functions.table.CsvRead;
 import org.nkjmlab.sorm4j.util.h2.server.H2Startup;
 import org.nkjmlab.sorm4j.util.table_def.annotation.PrimaryKeyColumns;
@@ -26,8 +26,8 @@ public class LoadOpenDataExample {
   private static final org.apache.logging.log4j.Logger log =
       org.apache.logging.log4j.LogManager.getLogger();
 
-  private static final H2LocalDataSourceFactory dataSourceFactory =
-      H2LocalDataSourceFactory.builder(new File("$TMPDIR/sorm4j"), "sorm4j_example", "sa", "")
+  private static final H2DataSourceFactory dataSourceFactory =
+      H2DataSourceFactory.builder(new File("$TMPDIR/sorm4j"), "sorm4j_example", "sa", "")
           .build();
 
   static {
@@ -108,7 +108,7 @@ private static File downloadFile(String fileURL, String fileName) {
    * @see <a href="https://github.com/MengtingWan/marketBias/tree/master/data">marketBias/data at
    *     master · MengtingWan/marketBias</a>
    */
-  public static class ModClothsTable extends BasicH2Table<ModCloth> {
+  public static class ModClothsTable extends H2BasicTable<ModCloth> {
 
     @OrmRecord
     @PrimaryKeyColumns({"item_id", "user_id"})
@@ -137,7 +137,7 @@ public File getCsv() {
     }
   }
 
-  public static class ElectronicsTable extends BasicH2Table<Electronic> {
+  public static class ElectronicsTable extends H2BasicTable<Electronic> {
 
     @OrmRecord
     @PrimaryKeyColumns({"item_id", "user_id"})
@@ -164,7 +164,7 @@ public File getCsv() {
     }
   }
 
-  public static class TwitchsTable extends BasicH2Table<Twitch> {
+  public static class TwitchsTable extends H2BasicTable<Twitch> {
 
     /**
      * This is a dataset of users consuming streaming content on Twitch. We retrieved all streamers,
@@ -194,7 +194,7 @@ public File getCsv() {
   }
 
   private void load(String logLabel, String tableName, Consumer<Sorm> func) {
-    Sorm mem = Sorm.create(H2LocalDataSourceFactory.createTemporalInMemoryDataSource());
+    Sorm mem = Sorm.create(H2DataSourceFactory.createTemporalInMemoryDataSource());
     long start = System.currentTimeMillis();
     log.info("[START] {} - {}", logLabel, tableName);
     func.accept(mem);
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTable.java
similarity index 67%
rename from sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java
rename to sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTable.java
index f004eec0..20292251 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/BasicH2Table.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTable.java
@@ -3,11 +3,11 @@
 import org.nkjmlab.sorm4j.Sorm;
 import org.nkjmlab.sorm4j.annotation.Experimental;
 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;
 import org.nkjmlab.sorm4j.util.table_def.TableDefinition;
 
 @Experimental
-public class BasicH2Table<T> extends BasicTable<T> implements H2Table<T> {
+public class H2BasicTable<T> extends SimpleTableWithDefinition<T> implements H2Table<T> {
 
   /**
    * This table instance is bind to the table name defined in the given {@link TableDefinition}.
@@ -16,7 +16,7 @@ public class BasicH2Table<T> extends BasicTable<T> implements H2Table<T> {
    * @param valueType
    * @param tableDefinition
    */
-  public BasicH2Table(Sorm orm, Class<T> valueType, TableDefinition tableDefinition) {
+  public H2BasicTable(Sorm orm, Class<T> valueType, TableDefinition tableDefinition) {
     super(orm, valueType, tableDefinition);
   }
 
@@ -26,18 +26,18 @@ public BasicH2Table(Sorm orm, Class<T> valueType, TableDefinition tableDefinitio
    * @param sorm
    * @param valueType
    */
-  public BasicH2Table(Sorm orm, Class<T> valueType) {
+  public H2BasicTable(Sorm orm, Class<T> valueType) {
     this(orm, valueType, TableDefinition.builder(valueType).build());
   }
 
   @Experimental
   @Override
-  public BasicH2Table<T> createTableIfNotExists() {
+  public H2BasicTable<T> createTableIfNotExists() {
     super.createTableIfNotExists();
     return this;
   }
 
-  public BasicH2Table<T> createTableIfNotExists(CsvRead csvRead) {
+  public H2BasicTable<T> createTableIfNotExists(CsvRead csvRead) {
     getOrm()
         .execute(
             getTableDefinition().getCreateTableIfNotExistsStatement()
@@ -48,21 +48,21 @@ public BasicH2Table<T> createTableIfNotExists(CsvRead csvRead) {
 
   @Experimental
   @Override
-  public BasicH2Table<T> createIndexesIfNotExists() {
+  public H2BasicTable<T> createIndexesIfNotExists() {
     super.createIndexesIfNotExists();
     return this;
   }
 
   @Experimental
   @Override
-  public BasicH2Table<T> dropTableIfExists() {
+  public H2BasicTable<T> dropTableIfExists() {
     super.dropTableIfExists();
     return this;
   }
 
   @Experimental
   @Override
-  public BasicH2Table<T> dropTableIfExistsCascade() {
+  public H2BasicTable<T> dropTableIfExistsCascade() {
     super.dropTableIfExistsCascade();
     return this;
   }
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
index 760b6fac..77bd9b20 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
@@ -5,9 +5,10 @@
 import org.nkjmlab.sorm4j.annotation.Experimental;
 import org.nkjmlab.sorm4j.table.Table;
 import org.nkjmlab.sorm4j.util.h2.functions.system.CsvWrite;
+import org.nkjmlab.sorm4j.util.table_def.WithTableDefinition;
 
 @Experimental
-public interface H2Table<T> extends Table<T>, H2Orm {
+public interface H2Table<T> extends Table<T>, WithTableDefinition, H2Orm {
 
   /**
    * Write all rows to csv file.
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/SimpleH2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/SimpleH2Table.java
deleted file mode 100644
index 9b9fb0c8..00000000
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/SimpleH2Table.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.nkjmlab.sorm4j.util.h2;
-
-import org.nkjmlab.sorm4j.Sorm;
-import org.nkjmlab.sorm4j.annotation.Experimental;
-import org.nkjmlab.sorm4j.table.SimpleTable;
-
-@Experimental
-public class SimpleH2Table<T> extends SimpleTable<T> implements H2Table<T> {
-
-  /**
-   * A table instance binded to the table by the value type.
-   *
-   * @param sorm
-   * @param valueType
-   */
-  public SimpleH2Table(Sorm orm, Class<T> valueType) {
-    super(orm, valueType);
-  }
-
-  /**
-   * A table instance binded to the table by the table name.
-   *
-   * @param orm
-   * @param valueType
-   * @param tableName
-   */
-  public SimpleH2Table(Sorm orm, Class<T> 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 @@
  * </code>
  * </pre>
  *
- * {@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.
  *
  * <pre>
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..943907cb 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.
    *
    * <p>following variables in the path of database directory will be expanded.
    *
@@ -227,7 +227,7 @@ public static Builder builder() {
    *   <li>"%TEMP%" or "$TMPDIR" to "java.io.tmpdir"
    * </ul>
    *
-   * @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/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<T> extends SimpleTable<T>
-    implements WithTableDefinition, Table<T> {
+public class SimpleTableWithDefinition<T> extends SimpleTable<T> implements TableWithDefinition<T> {
 
   private final TableDefinition tableDefinition;
 
@@ -18,12 +16,12 @@ public class BasicTable<T> extends SimpleTable<T>
    * @param valueType
    * @param tableDefinition
    */
-  public BasicTable(Sorm orm, Class<T> valueType, TableDefinition tableDefinition) {
+  public SimpleTableWithDefinition(Sorm orm, Class<T> valueType, TableDefinition tableDefinition) {
     super(orm, valueType, tableDefinition.getTableName());
     this.tableDefinition = tableDefinition;
   }
 
-  public BasicTable(Sorm orm, Class<T> valueType) {
+  public SimpleTableWithDefinition(Sorm orm, Class<T> 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<T> extends Table<T>, 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 @@
+<html>
+<body>
+  <p>Package for table definition annotations.</p>
+</body>
+</html>
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 @@
+<html>
+<body>
+	<p>Package for table definitions.</p>
+</body>
+</html>
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<Player> playersTable =
+    SimpleTableWithDefinition<Player> playersTable =
         SormTestUtils.createPlayersTable(SormTestUtils.createSormWithNewContext());
     String version = "2.";
     JdbcDatabaseMetaData md = playersTable.getOrm().getJdbcDatabaseMetaData();
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<Player> playersTable;
-  private BasicTable<Sport> sportsTable;
+  private SimpleTableWithDefinition<Player> playersTable;
+  private SimpleTableWithDefinition<Sport> 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<Guest> createGuestsTable(Sorm sorm) {
+  public static SimpleTableWithDefinition<Guest> createGuestsTable(Sorm sorm) {
     TableDefinition schema =
         TableDefinition.builder("guests")
             .addColumnDefinition("id", INT, AUTO_INCREMENT, PRIMARY_KEY)
@@ -46,16 +46,16 @@ public static BasicTable<Guest> createGuestsTable(Sorm sorm) {
             .addIndexDefinition("name")
             .build();
 
-    BasicTable<Guest> tbl = new BasicTable<>(sorm, Guest.class, schema);
+    SimpleTableWithDefinition<Guest> tbl = new SimpleTableWithDefinition<>(sorm, Guest.class, schema);
     tbl.dropTableIfExists().createTableIfNotExists().createIndexesIfNotExists();
     return tbl;
   }
 
-  public static BasicTable<Player> createPlayersTable(Sorm sorm) {
+  public static SimpleTableWithDefinition<Player> createPlayersTable(Sorm sorm) {
     return createPlayersTable(sorm, "players");
   }
 
-  public static BasicTable<Player> createPlayersTable(Sorm sorm, String tableName) {
+  public static SimpleTableWithDefinition<Player> createPlayersTable(Sorm sorm, String tableName) {
 
     TableDefinition schema =
         TableDefinition.builder(tableName)
@@ -66,20 +66,20 @@ public static BasicTable<Player> createPlayersTable(Sorm sorm, String tableName)
             .addIndexDefinition("name")
             .build();
 
-    BasicTable<Player> tbl = new BasicTable<>(sorm, Player.class, schema);
+    SimpleTableWithDefinition<Player> tbl = new SimpleTableWithDefinition<>(sorm, Player.class, schema);
     tbl.dropTableIfExists();
     tbl.createTableIfNotExists().createIndexesIfNotExists();
     return tbl;
   }
 
-  public static BasicTable<Sport> createSportsTable(Sorm sorm) {
+  public static SimpleTableWithDefinition<Sport> createSportsTable(Sorm sorm) {
     TableDefinition schema =
         TableDefinition.builder("sports")
             .addColumnDefinition("id", INT, PRIMARY_KEY)
             .addColumnDefinition("name", VARCHAR)
             .build();
 
-    BasicTable<Sport> tbl = new BasicTable<>(sorm, Sport.class, schema);
+    SimpleTableWithDefinition<Sport> tbl = new SimpleTableWithDefinition<>(sorm, Sport.class, schema);
 
     tbl.dropTableIfExists();
     tbl.createTableIfNotExists().createIndexesIfNotExists();
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 88%
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 afec90c1..2879866b 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<OrmRecordExample> table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+    H2BasicTable<OrmRecordExample> table = new H2BasicTable<>(sorm, OrmRecordExample.class);
     table.dropTableIfExists();
     table.createTableIfNotExists();
 
@@ -56,9 +56,9 @@ void test() throws InterruptedException {
     } catch (IOException e) {
       throw Try.rethrow(e);
     }
-    BasicH2Table<OrmRecordExample> table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+    H2BasicTable<OrmRecordExample> table = new H2BasicTable<>(sorm, OrmRecordExample.class);
     {
-      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/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<OrmRecordExample> table = new BasicH2Table<>(sorm, OrmRecordExample.class);
+    Sorm sorm = Sorm.create(H2DataSourceFactory.createTemporalInMemoryDataSource());
+    H2BasicTable<OrmRecordExample> 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/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<JacksonRecord> table = new BasicH2Table<>(sorm, JacksonRecord.class);
+    H2BasicTable<JacksonRecord> 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<HasJsonColumn> table = new BasicH2Table<>(sorm, HasJsonColumn.class);
+    H2BasicTable<HasJsonColumn> 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<GeometryStringRecord> table = new BasicH2Table<>(sorm, GeometryStringRecord.class);
+    H2BasicTable<GeometryStringRecord> 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<GeometryJtsRecord> table = new BasicH2Table<>(sorm, GeometryJtsRecord.class);
+    H2BasicTable<GeometryJtsRecord> 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<TableDefExample> table = new BasicH2Table<>(sorm, TableDefExample.class, def);
+    H2BasicTable<TableDefExample> table = new H2BasicTable<>(sorm, TableDefExample.class, def);
     table.insertMapIn(csvRows);
 
     assertThat(sorm.selectAll(TableDefExample.class).get(0).phoneNumber).isEqualTo("000-000-0000");

From af433ee89d1e84ee1b20952a5b39eabd9c3c26e1 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Thu, 21 Dec 2023 13:22:59 +0900
Subject: [PATCH 09/15] add Query escape

---
 .../util/h2/datasource/H2DataSourceFactory.java      |  4 ++--
 .../sorm4j/util/h2/functions/system/CsvWrite.java    | 12 +++++++++++-
 .../nkjmlab/sorm4j/util/h2/grammar/CsvOptions.java   |  4 ++++
 .../util/h2/grammar/ScriptCompressionEncryption.java | 10 ++++++++++
 .../util/h2/functions/system/CsvWriteTest.java       |  7 +++++--
 5 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
index 943907cb..dd52fd1c 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/datasource/H2DataSourceFactory.java
@@ -262,8 +262,8 @@ public String toString() {
   }
 
   public static class Builder {
-    private File databaseDirectory = new File(getTempDir(), "h2db_tmp");
-    private String databaseName = "h2db_tmp";
+    private File databaseDirectory = new File(getTempDir(), "h2db-tmp");
+    private String databaseName = "h2db-tmp";
     private String username = "";
     private String 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<String> 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<String, String> 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<String, String> 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/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());
   }
 

From 59b98d49839a92750262126008bf0b0032fb4c0a Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 22 Dec 2023 10:09:57 +0900
Subject: [PATCH 10/15] Modify retured value of csvWrite

---
 sorm4j-example/pom.xml                               |  2 +-
 sorm4j-jmh/pom.xml                                   |  2 +-
 sorm4j/pom.xml                                       |  2 +-
 .../java/org/nkjmlab/sorm4j/util/h2/H2Table.java     | 12 +++++-------
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/sorm4j-example/pom.xml b/sorm4j-example/pom.xml
index 69bb0284..1bd32ad2 100644
--- a/sorm4j-example/pom.xml
+++ b/sorm4j-example/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j-example</artifactId>
-	<version>2.1.1</version>
+	<version>2.1.2</version>
 	<description>Example of Sorm4j</description>
 
 	<properties>
diff --git a/sorm4j-jmh/pom.xml b/sorm4j-jmh/pom.xml
index 1b06c932..40c9bca3 100644
--- a/sorm4j-jmh/pom.xml
+++ b/sorm4j-jmh/pom.xml
@@ -21,7 +21,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.nkjmlab</groupId>
   <artifactId>sorm4j-jmh</artifactId>
-  <version>2.1.1</version>
+  <version>2.1.2</version>
   <packaging>jar</packaging>
   <name>Sorm4j benchmark</name>
 
diff --git a/sorm4j/pom.xml b/sorm4j/pom.xml
index f74a5ad6..a6873a44 100644
--- a/sorm4j/pom.xml
+++ b/sorm4j/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j</artifactId>
-	<version>2.1.1</version>
+	<version>2.1.2</version>
 	<name>sorm4j</name>
 	<description>Simple micro Object-Relation Mapper for Java</description>
 	<url>https://github.com/yuu-nkjm/sorm4j</url>
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
index 77bd9b20..fd9ec604 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
@@ -16,19 +16,17 @@ public interface H2Table<T> extends Table<T>, WithTableDefinition, H2Orm {
    * @param toFile
    * @return
    */
-  default File writeCsv(File toFile) {
-    return writeCsv(toFile, "select * from " + getTableName());
+  default void writeCsv(File toFile) {
+    writeCsv(CsvWrite.builder(toFile).query("select * from " + getTableName()).build());
   }
 
   /**
    * Write selected rows to csv file.
    *
-   * @param toFile
-   * @param query
+   * @param csvWrite
    * @return
    */
-  default File writeCsv(File toFile, String query) {
-    getOrm().executeUpdate("call " + CsvWrite.builder(toFile).query(query).build().getSql());
-    return toFile;
+  default void writeCsv(CsvWrite csvWrite) {
+    getOrm().executeUpdate("call " + csvWrite.getSql());
   }
 }

From b91fe795fc69523a8e194f0b0dc57bc8e373efe7 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Fri, 12 Jan 2024 11:40:21 +0900
Subject: [PATCH 11/15] Rename methods: insertIn  to insertInto and updateBy to
 updateWith.

---
 sorm4j-example/pom.xml                        |   5 +-
 sorm4j-jmh/pom.xml                            | 395 +++++++++---------
 sorm4j/build/sorm4j-install.bat               |   2 +-
 sorm4j/pom.xml                                | 137 +++---
 .../src/main/java/org/nkjmlab/sorm4j/Orm.java |  42 +-
 .../context/DefaultTableSqlFactory.java       |  11 +-
 .../org/nkjmlab/sorm4j/context/TableSql.java  |   9 +-
 .../sorm4j/internal/OrmConnectionImpl.java    |  30 +-
 .../org/nkjmlab/sorm4j/internal/SormImpl.java |  40 +-
 .../nkjmlab/sorm4j/table/TableMappedOrm.java  |  20 +-
 .../internal/OrmConnectionImplTest.java       |  14 +-
 .../nkjmlab/sorm4j/internal/OrmImplTest.java  |  26 +-
 .../sf/persist/tests/common/TestSimple.java   |   4 +-
 13 files changed, 367 insertions(+), 368 deletions(-)

diff --git a/sorm4j-example/pom.xml b/sorm4j-example/pom.xml
index 1bd32ad2..4f4470a9 100644
--- a/sorm4j-example/pom.xml
+++ b/sorm4j-example/pom.xml
@@ -4,11 +4,10 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j-example</artifactId>
-	<version>2.1.2</version>
+	<version>2.1.4</version>
 	<description>Example of Sorm4j</description>
 
 	<properties>
-		<sorm4j-version>${project.version}</sorm4j-version>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<additionalparam>-Xdoclint:none</additionalparam>
 		<downloadSources>true</downloadSources>
@@ -20,7 +19,7 @@
 		<dependency>
 			<groupId>org.nkjmlab</groupId>
 			<artifactId>sorm4j</artifactId>
-			<version>${sorm4j-version}</version>
+			<version>${project.version}</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
 		<dependency>
diff --git a/sorm4j-jmh/pom.xml b/sorm4j-jmh/pom.xml
index 40c9bca3..58b96094 100644
--- a/sorm4j-jmh/pom.xml
+++ b/sorm4j-jmh/pom.xml
@@ -1,206 +1,223 @@
-<!-- Copyright (c) 2014, Oracle America, Inc. All rights reserved. Redistribution and use in source and
-  binary forms, with or without modification, are permitted provided that the following conditions are
-  met: * Redistributions of source code must retain the above copyright notice, this list of conditions
-  and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation and/or other materials provided
-  with the distribution. * Neither the name of Oracle nor the names of its contributors may be used to
-  endorse or promote products derived from this software without specific prior written permission. THIS
-  SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
-  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+<!-- Copyright (c) 2014, Oracle America, Inc. All rights reserved.
+Redistribution and use in source and
+  binary forms, with or without modification, are permitted provided that the
+following conditions are
+  met: * Redistributions of source code must retain the above copyright notice,
+this list of conditions
+  and the following disclaimer. * Redistributions in binary form must reproduce
+the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+and/or other materials provided
+  with the distribution. * Neither the name of Oracle nor the names of its
+contributors may be used to
+  endorse or promote products derived from this software without specific prior
+written permission. THIS
+  SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES,
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT
+  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED
+  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE
+  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY
   OF SUCH DAMAGE. -->
-<!-- this xml file is generate from groupId: org.openjdk.jmh, artifactId:jmh-java-benchmark-archetype,
+<!-- this xml file is generate from groupId: org.openjdk.jmh,
+artifactId:jmh-java-benchmark-archetype,
   version: 1.2.8 and modified. -->
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.nkjmlab</groupId>
-  <artifactId>sorm4j-jmh</artifactId>
-  <version>2.1.2</version>
-  <packaging>jar</packaging>
-  <name>Sorm4j benchmark</name>
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>org.nkjmlab</groupId>
+	<artifactId>sorm4j-jmh</artifactId>
+	<version>2.1.4</version>
+	<packaging>jar</packaging>
+	<name>Sorm4j benchmark</name>
 
-  <properties>
-    <sorm4j-version>${project.version}</sorm4j-version>
+	<properties>
+		<sorm4j-version>${project.version}</sorm4j-version>
 
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
-    <!-- JMH version to use with this project. -->
-    <jmh.version>1.37</jmh.version>
+		<!-- JMH version to use with this project. -->
+		<jmh.version>1.37</jmh.version>
 
-    <!-- Java source/target to use for compilation. -->
-    <javac.target>21</javac.target>
+		<!-- Java source/target to use for compilation. -->
+		<javac.target>21</javac.target>
 
-    <!-- Name of the benchmark Uber-JAR to generate. -->
-    <uberjar.name>benchmarks</uberjar.name>
+		<!-- Name of the benchmark Uber-JAR to generate. -->
+		<uberjar.name>benchmarks</uberjar.name>
 
-  </properties>
+	</properties>
 
 
-  <dependencies>
-    <dependency>
-      <groupId>org.openjdk.jmh</groupId>
-      <artifactId>jmh-core</artifactId>
-      <version>${jmh.version}</version>
-    </dependency>
-    <dependency>
-      <groupId>org.openjdk.jmh</groupId>
-      <artifactId>jmh-generator-annprocess</artifactId>
-      <version>${jmh.version}</version>
-      <scope>provided</scope>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/org.nkjmlab/sorm4j -->
-    <dependency>
-      <groupId>org.nkjmlab</groupId>
-      <artifactId>sorm4j</artifactId>
-      <version>${sorm4j-version}</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
-    <dependency>
-      <groupId>commons-dbutils</groupId>
-      <artifactId>commons-dbutils</artifactId>
-      <version>1.8.1</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
-    <dependency>
-      <groupId>com.h2database</groupId>
-      <artifactId>h2</artifactId>
-      <version>2.2.224</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/org.sql2o/sql2o -->
-    <dependency>
-      <groupId>org.sql2o</groupId>
-      <artifactId>sql2o</artifactId>
-      <version>1.6.0</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/org.jdbi/jdbi3-core -->
-    <dependency>
-      <groupId>org.jdbi</groupId>
-      <artifactId>jdbi3-core</artifactId>
-      <version>3.42.0</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/org.jooq/jooq -->
-    <dependency>
-      <groupId>org.jooq</groupId>
-      <artifactId>jooq</artifactId>
-      <version>3.18.7</version>
-    </dependency>
+	<dependencies>
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-core</artifactId>
+			<version>${jmh.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-generator-annprocess</artifactId>
+			<version>${jmh.version}</version>
+			<scope>provided</scope>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/org.nkjmlab/sorm4j -->
+		<dependency>
+			<groupId>org.nkjmlab</groupId>
+			<artifactId>sorm4j</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
+		<dependency>
+			<groupId>commons-dbutils</groupId>
+			<artifactId>commons-dbutils</artifactId>
+			<version>1.8.1</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
+		<dependency>
+			<groupId>com.h2database</groupId>
+			<artifactId>h2</artifactId>
+			<version>2.2.224</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/org.sql2o/sql2o -->
+		<dependency>
+			<groupId>org.sql2o</groupId>
+			<artifactId>sql2o</artifactId>
+			<version>1.6.0</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/org.jdbi/jdbi3-core -->
+		<dependency>
+			<groupId>org.jdbi</groupId>
+			<artifactId>jdbi3-core</artifactId>
+			<version>3.42.0</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/org.jooq/jooq -->
+		<dependency>
+			<groupId>org.jooq</groupId>
+			<artifactId>jooq</artifactId>
+			<version>3.18.7</version>
+		</dependency>
 
-    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
-    <dependency>
-      <groupId>org.mybatis</groupId>
-      <artifactId>mybatis</artifactId>
-      <version>3.5.14</version>
-    </dependency>
+		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
+		<dependency>
+			<groupId>org.mybatis</groupId>
+			<artifactId>mybatis</artifactId>
+			<version>3.5.14</version>
+		</dependency>
 
-    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
-    <dependency>
-      <groupId>org.springframework</groupId>
-      <artifactId>spring-jdbc</artifactId>
-      <version>6.1.1</version>
-    </dependency>
-    <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
-    <dependency>
-      <groupId>joda-time</groupId>
-      <artifactId>joda-time</artifactId>
-      <version>2.12.5</version>
-    </dependency>
+		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-jdbc</artifactId>
+			<version>6.1.1</version>
+		</dependency>
+		<!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
+		<dependency>
+			<groupId>joda-time</groupId>
+			<artifactId>joda-time</artifactId>
+			<version>2.12.5</version>
+		</dependency>
 
-  </dependencies>
+	</dependencies>
 
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.11.0</version>
-        <configuration>
-          <compilerVersion>${javac.target}</compilerVersion>
-          <source>${javac.target}</source>
-          <target>${javac.target}</target>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>3.2.1</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <finalName>${uberjar.name}</finalName>
-              <transformers>
-                <transformer
-                  implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                  <mainClass>org.openjdk.jmh.Main</mainClass>
-                </transformer>
-                <transformer
-                  implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
-              </transformers>
-              <filters>
-                <filter>
-                  <!-- Shading signed JARs will fail without this. http://stackoverflow.com/questions/999489/invalid-signature-file-when-attempting-to-run-a-jar -->
-                  <artifact>*:*</artifact>
-                  <excludes>
-                    <exclude>META-INF/*.SF</exclude>
-                    <exclude>META-INF/*.DSA</exclude>
-                    <exclude>META-INF/*.RSA</exclude>
-                  </excludes>
-                </filter>
-              </filters>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-    <pluginManagement>
-      <plugins>
-        <plugin>
-          <artifactId>maven-clean-plugin</artifactId>
-          <version>2.5</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-deploy-plugin</artifactId>
-          <version>2.8.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-install-plugin</artifactId>
-          <version>2.5.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-jar-plugin</artifactId>
-          <version>2.4</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-javadoc-plugin</artifactId>
-          <version>2.9.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-resources-plugin</artifactId>
-          <version>2.6</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-site-plugin</artifactId>
-          <version>3.3</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-source-plugin</artifactId>
-          <version>2.2.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-surefire-plugin</artifactId>
-          <version>2.17</version>
-        </plugin>
-      </plugins>
-    </pluginManagement>
-  </build>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.11.0</version>
+				<configuration>
+					<compilerVersion>${javac.target}</compilerVersion>
+					<source>${javac.target}</source>
+					<target>${javac.target}</target>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-shade-plugin</artifactId>
+				<version>3.2.1</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>shade</goal>
+						</goals>
+						<configuration>
+							<finalName>${uberjar.name}</finalName>
+							<transformers>
+								<transformer
+									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+									<mainClass>org.openjdk.jmh.Main</mainClass>
+								</transformer>
+								<transformer
+									implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+							</transformers>
+							<filters>
+								<filter>
+									<!-- Shading signed JARs will fail without
+									this.
+									http://stackoverflow.com/questions/999489/invalid-signature-file-when-attempting-to-run-a-jar -->
+									<artifact>*:*</artifact>
+									<excludes>
+										<exclude>META-INF/*.SF</exclude>
+										<exclude>META-INF/*.DSA</exclude>
+										<exclude>META-INF/*.RSA</exclude>
+									</excludes>
+								</filter>
+							</filters>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+		<pluginManagement>
+			<plugins>
+				<plugin>
+					<artifactId>maven-clean-plugin</artifactId>
+					<version>2.5</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-deploy-plugin</artifactId>
+					<version>2.8.1</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-install-plugin</artifactId>
+					<version>2.5.1</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-jar-plugin</artifactId>
+					<version>2.4</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-javadoc-plugin</artifactId>
+					<version>2.9.1</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-resources-plugin</artifactId>
+					<version>2.6</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-site-plugin</artifactId>
+					<version>3.3</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-source-plugin</artifactId>
+					<version>2.2.1</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-surefire-plugin</artifactId>
+					<version>2.17</version>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+	</build>
 
 </project>
diff --git a/sorm4j/build/sorm4j-install.bat b/sorm4j/build/sorm4j-install.bat
index b1b7039c..4f2fd0c9 100644
--- a/sorm4j/build/sorm4j-install.bat
+++ b/sorm4j/build/sorm4j-install.bat
@@ -1,4 +1,4 @@
 setlocal
 cd /d %~dp0
 killall java
-mvn-caller.bat "mvn clean deploy -P ossrh"
+mvn-caller.bat "mvn clean install"
diff --git a/sorm4j/pom.xml b/sorm4j/pom.xml
index a6873a44..ed066733 100644
--- a/sorm4j/pom.xml
+++ b/sorm4j/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j</artifactId>
-	<version>2.1.2</version>
+	<version>2.1.4</version>
 	<name>sorm4j</name>
 	<description>Simple micro Object-Relation Mapper for Java</description>
 	<url>https://github.com/yuu-nkjm/sorm4j</url>
@@ -41,7 +41,6 @@
 
 	<properties>
 		<javassist-version>3.27.0-GA</javassist-version>
-		<jaxb-api-version-in-plugin>2.3.1</jaxb-api-version-in-plugin>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<downloadSources>true</downloadSources>
 		<downloadJavadocs>true</downloadJavadocs>
@@ -53,14 +52,14 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-api</artifactId>
-			<version>2.22.0</version>
+			<version>2.22.1</version>
 			<optional>true</optional>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-api</artifactId>
-			<version>2.0.9</version>
+			<version>2.0.11</version>
 			<optional>true</optional>
 		</dependency>
 		<!--
@@ -68,7 +67,7 @@
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>2.16.0</version>
+			<version>2.16.1</version>
 			<optional>true</optional>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.locationtech.jts/jts-core -->
@@ -97,7 +96,7 @@
 		<dependency>
 			<groupId>org.assertj</groupId>
 			<artifactId>assertj-core</artifactId>
-			<version>3.24.2</version>
+			<version>3.25.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
@@ -112,7 +111,7 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-iostreams</artifactId>
-			<version>2.22.0</version>
+			<version>2.22.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
@@ -127,7 +126,7 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-slf4j2-impl</artifactId>
-			<version>2.22.0</version>
+			<version>2.22.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!--
@@ -135,7 +134,7 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-core</artifactId>
-			<version>2.22.0</version>
+			<version>2.22.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
@@ -169,57 +168,21 @@
 		</dependency>
 	</dependencies>
 	<build>
+		<testResources>
+			<testResource>
+				<directory>src/test/resources</directory>
+			</testResource>
+			<testResource>
+				<directory>src/test/java</directory>
+				<includes>
+					<include>**</include>
+				</includes>
+				<excludes>
+					<exclude>**/*.java</exclude>
+				</excludes>
+			</testResource>
+		</testResources>
 		<plugins>
-			<!--
-				https://mvnrepository.com/artifact/org.jacoco/jacoco-maven-plugin -->
-			<plugin>
-				<groupId>org.jacoco</groupId>
-				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.7</version>
-				<executions>
-					<execution>
-						<id>jacoco-initialize</id>
-						<goals>
-							<goal>prepare-agent</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>jacoco-site</id>
-						<phase>test</phase>
-						<goals>
-							<goal>report</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-			<!--
-			https://mvnrepository.com/artifact/org.codehaus.mojo/cobertura-maven-plugin -->
-			<plugin>
-				<groupId>org.codehaus.mojo</groupId>
-				<artifactId>cobertura-maven-plugin</artifactId>
-				<version>2.7</version>
-				<configuration>
-					<format>xml</format>
-					<maxmem>256m</maxmem>
-					<aggregate>true</aggregate>
-				</configuration>
-			</plugin>
-			<!--
-				https://mvnrepository.com/artifact/org.eluder.coveralls/coveralls-maven-plugin -->
-			<plugin>
-				<groupId>org.eluder.coveralls</groupId>
-				<artifactId>coveralls-maven-plugin</artifactId>
-				<version>4.3.0</version>
-				<dependencies>
-					<!--
-						https://mvnrepository.com/artifact/javax.xml.bind/jaxb-api -->
-					<dependency>
-						<groupId>javax.xml.bind</groupId>
-						<artifactId>jaxb-api</artifactId>
-						<version>${jaxb-api-version-in-plugin}</version>
-					</dependency>
-				</dependencies>
-			</plugin>
 			<!--
 			https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-jar-plugin -->
 			<plugin>
@@ -240,11 +203,15 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0</version>
+				<version>3.2.3</version>
 				<configuration>
 					<additionalClasspathElements>
 						<additionalClasspathElement>src/test/java/</additionalClasspathElement>
 					</additionalClasspathElements>
+					<argLine>
+						--add-opens java.base/java.lang=ALL-UNNAMED
+						${argLine}
+					</argLine>
 				</configuration>
 			</plugin>
 			<!--
@@ -252,7 +219,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.11.0</version>
+				<version>3.12.0</version>
 				<configuration>
 					<release>17</release>
 				</configuration>
@@ -262,7 +229,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>versions-maven-plugin</artifactId>
-				<version>2.15.0</version>
+				<version>2.16.2</version>
 				<configuration>
 					<ruleSet>
 						<ignoreVersions>
@@ -297,14 +264,8 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-source-plugin</artifactId>
-				<version>3.2.0</version>
+				<version>3.3.0</version>
 				<executions>
-					<execution>
-						<phase>package</phase>
-						<goals>
-							<goal>jar</goal>
-						</goals>
-					</execution>
 					<execution>
 						<id>attach-sources</id>
 						<goals>
@@ -318,7 +279,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-javadoc-plugin</artifactId>
-				<version>3.5.0</version>
+				<version>3.6.3</version>
 				<configuration>
 					<excludePackageNames>
 						org.nkjmlab.sorm4j.internal:org.nkjmlab.sorm4j.internal.*</excludePackageNames>
@@ -351,20 +312,28 @@
 					</execution>
 				</executions>
 			</plugin>
+			<!--
+				https://mvnrepository.com/artifact/org.jacoco/jacoco-maven-plugin -->
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.8.11</version>
+				<executions>
+					<execution>
+						<id>prepare-agent</id>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<!--
+			https://github.com/hazendaz/coveralls-maven-plugin">hazendaz/coveralls-maven-plugin -->
+			<plugin>
+				<groupId>com.github.hazendaz.maven</groupId>
+				<artifactId>coveralls-maven-plugin</artifactId>
+				<version>4.5.0-M2</version>
+			</plugin>
 		</plugins>
-		<testResources>
-			<testResource>
-				<directory>src/test/resources</directory>
-			</testResource>
-			<testResource>
-				<directory>src/test/java</directory>
-				<includes>
-					<include>**</include>
-				</includes>
-				<excludes>
-					<exclude>**/*.java</exclude>
-				</excludes>
-			</testResource>
-		</testResources>
 	</build>
 </project>
\ No newline at end of file
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/Orm.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/Orm.java
index af39ec3f..89cf929d 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/Orm.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/Orm.java
@@ -409,7 +409,7 @@ <T> List<T> executeQuery(
    * @return
    */
   @Experimental
-  int[] insertMapIn(String tableName, List<RowMap> result);
+  int[] insertMapInto(String tableName, List<RowMap> result);
 
   /**
    * @param tableName
@@ -417,7 +417,7 @@ <T> List<T> executeQuery(
    * @return
    */
   @Experimental
-  int insertMapIn(String tableName, RowMap object);
+  int insertMapInto(String tableName, RowMap object);
 
   /**
    * This method is experimental.
@@ -427,7 +427,7 @@ <T> List<T> executeQuery(
    * @return
    */
   @Experimental
-  int[] insertMapIn(String tableName, RowMap... objects);
+  int[] insertMapInto(String tableName, RowMap... objects);
 
   /**
    * Inserts objects and get the last insert result.
@@ -437,7 +437,7 @@ <T> List<T> executeQuery(
    * @param objects
    * @return
    */
-  <T> int[] insertIn(String tableName, List<T> objects);
+  <T> int[] insertInto(String tableName, List<T> objects);
 
   /**
    * Inserts an object and get the insert result.
@@ -447,7 +447,7 @@ <T> List<T> executeQuery(
    * @param object
    * @return
    */
-  <T> int insertIn(String tableName, T object);
+  <T> int insertInto(String tableName, T object);
 
   /**
    * Inserts objects and get the last insert result.
@@ -457,7 +457,7 @@ <T> List<T> executeQuery(
    * @param objects
    * @return
    */
-  <T> int[] insertIn(String tableName, @SuppressWarnings("unchecked") T... objects);
+  <T> int[] insertInto(String tableName, @SuppressWarnings("unchecked") T... objects);
 
   @Experimental
   <T1, T2> List<Tuple2<T1, T2>> join(Class<T1> t1, Class<T2> t2, String sql, Object... parameters);
@@ -704,7 +704,7 @@ <T1, T2> List<Tuple2<T1, T2>> readTupleList(
   <T> T selectByPrimaryKey(Class<T> type, Object... primaryKeyValues);
 
   /**
-   * Updates by objects in the table corresponding to the class of the given objects.
+   * Updates with objects in the table corresponding to the class of the given objects.
    *
    * @param <T>
    * @param objects
@@ -713,7 +713,7 @@ <T1, T2> List<Tuple2<T1, T2>> readTupleList(
   <T> int[] update(List<T> objects);
 
   /**
-   * Updates by an object in the table corresponding to the class of the given object.
+   * Updates with an object in the table corresponding to the class of the given object.
    *
    * @param <T>
    * @param object
@@ -722,7 +722,7 @@ <T1, T2> List<Tuple2<T1, T2>> readTupleList(
   <T> int update(T object);
 
   /**
-   * Updates by objects in the table corresponding to the class of the given objects.
+   * Updates with objects in the table corresponding to the class of the given objects.
    *
    * @param <T>
    * @param objects
@@ -731,9 +731,12 @@ <T1, T2> List<Tuple2<T1, T2>> readTupleList(
   <T> int[] update(@SuppressWarnings("unchecked") T... objects);
 
   /**
+   * Updates with map in the table corresponding to the class. the map should not be included
+   * primary keys.
+   *
    * @param <T>
    * @param clazz
-   * @param object
+   * @param object should not include primary keys.
    * @param primaryKeyValues the order should be the same as the column order.
    * @return
    */
@@ -741,43 +744,46 @@ <T1, T2> List<Tuple2<T1, T2>> readTupleList(
   <T> int updateByPrimaryKey(Class<T> clazz, RowMap object, Object... primaryKeyValues);
 
   /**
+   * Updates with map in the table corresponding to the given table name. the map should not be
+   * included primary keys.
+   *
    * @param tableName
-   * @param object
+   * @param object should not include primary keys.
    * @param primaryKeyValues the order should be the same as the column order.
    * @return
    */
   @Experimental
-  int updateByPrimaryKeyIn(String tableName, RowMap object, Object... primaryKeyValues);
+  int updateByPrimaryKey(String tableName, RowMap object, Object... primaryKeyValues);
 
   /**
-   * Updates by objects in the table corresponding to the given table name.
+   * Updates with objects in the table corresponding to the given table name.
    *
    * @param <T>
    * @param tableName
    * @param objects
    * @return
    */
-  <T> int[] updateIn(String tableName, List<T> objects);
+  <T> int[] updateWith(String tableName, List<T> objects);
 
   /**
-   * Updates by an object in the table corresponding to the given table name.
+   * Updates with an object in the table corresponding to the given table name.
    *
    * @param <T>
    * @param tableName
    * @param object
    * @return
    */
-  <T> int updateIn(String tableName, T object);
+  <T> int updateWith(String tableName, T object);
 
   /**
-   * Updates by objects in the table corresponding to the given table name.
+   * Updates with objects in the table corresponding to the given table name.
    *
    * @param <T>
    * @param tableName
    * @param objects
    * @return
    */
-  <T> int[] updateIn(String tableName, @SuppressWarnings("unchecked") T... objects);
+  <T> int[] updateWith(String tableName, @SuppressWarnings("unchecked") T... objects);
 
   /**
    * Returns {@link ResultSetStream} represents all rows from the table indicated by object class.
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/DefaultTableSqlFactory.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/DefaultTableSqlFactory.java
index 7bf530b3..7bb2e77b 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/DefaultTableSqlFactory.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/DefaultTableSqlFactory.java
@@ -1,9 +1,11 @@
 package org.nkjmlab.sorm4j.context;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
 import org.nkjmlab.sorm4j.common.JdbcTableMetaData;
 import org.nkjmlab.sorm4j.internal.util.StringCache;
 import org.nkjmlab.sorm4j.result.JdbcDatabaseMetaData;
@@ -48,7 +50,7 @@ public TableSql create(JdbcTableMetaData tableMetaData, JdbcDatabaseMetaData dat
             tableName,
             tableMetaData.getNotPrimaryKeys(),
             whereClauseIdentifyByPrimaryKeys);
-    String updateSql = updateSqlFactory.create(tableMetaData.getNotPrimaryKeys());
+    String updateSql = updateSqlFactory.createUpdateSql(tableMetaData.getNotPrimaryKeys());
     String deleteSql =
         !tableMetaData.hasPrimaryKey()
             ? errorMsg
@@ -85,7 +87,8 @@ public TableSql create(JdbcTableMetaData tableMetaData, JdbcDatabaseMetaData dat
         existsSql,
         insertSqlPrefix,
         mergeSqlPrefix,
-        updateSqlFactory);
+        updateSqlFactory,
+        primaryKeys);
   }
 
   public static class UpdateSqlFactory {
@@ -110,7 +113,7 @@ public UpdateSqlFactory(
           columns.stream().collect(Collectors.toMap(c -> StringCache.toCanonicalCase(c), c -> c));
     }
 
-    public String create(List<String> columns) {
+    public String createUpdateSql(Collection<String> columns) {
       return !hasPrimaryKey
           ? errorMsg
           : "update "
@@ -119,7 +122,7 @@ public String create(List<String> columns) {
               + whereClauseIdentifyByPrimaryKeys;
     }
 
-    private String createUpdateSetClause(List<String> columns) {
+    private String createUpdateSetClause(Collection<String> columns) {
       return " set "
           + String.join(
               ", ",
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/TableSql.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/TableSql.java
index d5400501..d20eea8d 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/TableSql.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/context/TableSql.java
@@ -1,9 +1,10 @@
 package org.nkjmlab.sorm4j.context;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
 import org.nkjmlab.sorm4j.context.DefaultTableSqlFactory.UpdateSqlFactory;
 import org.nkjmlab.sorm4j.internal.util.ConcurrentCache;
 import org.nkjmlab.sorm4j.result.RowMap;
@@ -59,6 +60,7 @@ public final class TableSql {
    * @param insertSqlPrefix
    * @param mergeSqlPrefix
    * @param updateSqlFactory
+   * @param primaryKeys
    */
   public TableSql(
       String inserPlaceholders,
@@ -72,7 +74,8 @@ public TableSql(
       String existsSql,
       String insertSqlPrefix,
       String mergeSqlPrefix,
-      UpdateSqlFactory updateSqlFactory) {
+      UpdateSqlFactory updateSqlFactory,
+      List<String> primaryKeys) {
     this.insertPlaceholders = inserPlaceholders;
     this.mergePlaceholders = mergePlaceholders;
     this.selectByPrimaryKeySql = selectByPrimaryKeySql;
@@ -169,6 +172,6 @@ public String toString() {
   }
 
   public String getUpdateSql(RowMap object) {
-    return updateSqlFactory.create(new ArrayList<>(object.keySet()));
+    return updateSqlFactory.createUpdateSql(object.keySet());
   }
 }
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/OrmConnectionImpl.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/OrmConnectionImpl.java
index be85f944..fb04491c 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/OrmConnectionImpl.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/OrmConnectionImpl.java
@@ -5,6 +5,7 @@
 import static org.nkjmlab.sorm4j.util.sql.SqlKeyword.LEFT;
 import static org.nkjmlab.sorm4j.util.sql.SqlKeyword.ON;
 import static org.nkjmlab.sorm4j.util.sql.SqlKeyword.SELECT;
+
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
@@ -16,6 +17,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Supplier;
+
 import org.nkjmlab.sorm4j.OrmConnection;
 import org.nkjmlab.sorm4j.common.FunctionHandler;
 import org.nkjmlab.sorm4j.common.JdbcTableMetaData;
@@ -455,18 +457,18 @@ public <T> InsertResult insertAndGetIn(
   }
 
   @Override
-  public <T> int[] insertIn(String tableName, List<T> objects) {
-    return applytoArray(objects, array -> insertIn(tableName, array));
+  public <T> int[] insertInto(String tableName, List<T> objects) {
+    return applytoArray(objects, array -> insertInto(tableName, array));
   }
 
   @Override
-  public <T> int insertIn(String tableName, T object) {
+  public <T> int insertInto(String tableName, T object) {
     SqlParametersToTableMapping<T> mapping = getCastedTableMapping(tableName, object.getClass());
     return executeUpdate(mapping.getSql().getInsertSql(), mapping.getInsertParameters(object));
   }
 
   @Override
-  public <T> int[] insertIn(String tableName, @SuppressWarnings("unchecked") T... objects) {
+  public <T> int[] insertInto(String tableName, @SuppressWarnings("unchecked") T... objects) {
     return execSqlIfParameterExists(
         tableName,
         objects,
@@ -475,11 +477,11 @@ public <T> int[] insertIn(String tableName, @SuppressWarnings("unchecked") T...
   }
 
   @Override
-  public int[] insertMapIn(String tableName, List<RowMap> objects) {
+  public int[] insertMapInto(String tableName, List<RowMap> objects) {
     boolean origAutoCommit = getAutoCommit(connection);
     try {
       setAutoCommit(connection, false);
-      int[] ret = objects.stream().mapToInt(o -> insertMapIn(tableName, o)).toArray();
+      int[] ret = objects.stream().mapToInt(o -> insertMapInto(tableName, o)).toArray();
       setAutoCommit(connection, true);
       commit();
       return ret;
@@ -490,7 +492,7 @@ public int[] insertMapIn(String tableName, List<RowMap> objects) {
   }
 
   @Override
-  public int insertMapIn(String tableName, RowMap object) {
+  public int insertMapInto(String tableName, RowMap object) {
     String sql = getTableSql(tableName).getInsertSql();
     return executeUpdate(sql, toInsertParameters(tableName, object));
   }
@@ -501,8 +503,8 @@ private Object[] toInsertParameters(String tableName, RowMap object) {
   }
 
   @Override
-  public int[] insertMapIn(String tableName, RowMap... objects) {
-    return insertMapIn(tableName, Arrays.asList(objects));
+  public int[] insertMapInto(String tableName, RowMap... objects) {
+    return insertMapInto(tableName, Arrays.asList(objects));
   }
 
   @Override
@@ -952,7 +954,7 @@ public <T> int updateByPrimaryKey(Class<T> clazz, RowMap object, Object... prima
   }
 
   @Override
-  public int updateByPrimaryKeyIn(String tableName, RowMap object, Object... primaryKeyValues) {
+  public int updateByPrimaryKey(String tableName, RowMap object, Object... primaryKeyValues) {
     final String sql = getTableSql(tableName).getUpdateSql(object);
     List<Object> params = new ArrayList<>(object.values());
     params.addAll(Arrays.asList(primaryKeyValues));
@@ -973,18 +975,18 @@ public <T> int[] update(@SuppressWarnings("unchecked") T... objects) {
   }
 
   @Override
-  public <T> int[] updateIn(String tableName, List<T> objects) {
-    return applytoArray(objects, array -> updateIn(tableName, array));
+  public <T> int[] updateWith(String tableName, List<T> objects) {
+    return applytoArray(objects, array -> updateWith(tableName, array));
   }
 
   @Override
-  public <T> int updateIn(String tableName, T object) {
+  public <T> int updateWith(String tableName, T object) {
     SqlParametersToTableMapping<T> mapping = getCastedTableMapping(tableName, object.getClass());
     return executeUpdate(mapping.getSql().getUpdateSql(), mapping.getUpdateParameters(object));
   }
 
   @Override
-  public <T> int[] updateIn(String tableName, @SuppressWarnings("unchecked") T... objects) {
+  public <T> int[] updateWith(String tableName, @SuppressWarnings("unchecked") T... objects) {
     return execSqlIfParameterExists(
         tableName,
         objects,
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormImpl.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormImpl.java
index f99589f9..76cf437e 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormImpl.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/SormImpl.java
@@ -331,18 +331,18 @@ public <T> int insert(T object) {
   }
 
   @Override
-  public int insertMapIn(String tableName, RowMap object) {
-    return applyAndClose(conn -> conn.insertMapIn(tableName, object));
+  public int insertMapInto(String tableName, RowMap object) {
+    return applyAndClose(conn -> conn.insertMapInto(tableName, object));
   }
 
   @Override
-  public int[] insertMapIn(String tableName, RowMap... objects) {
-    return applyAndClose(conn -> conn.insertMapIn(tableName, objects));
+  public int[] insertMapInto(String tableName, RowMap... objects) {
+    return applyAndClose(conn -> conn.insertMapInto(tableName, objects));
   }
 
   @Override
-  public int[] insertMapIn(String tableName, List<RowMap> objects) {
-    return applyAndClose(conn -> conn.insertMapIn(tableName, objects));
+  public int[] insertMapInto(String tableName, List<RowMap> objects) {
+    return applyAndClose(conn -> conn.insertMapInto(tableName, objects));
   }
 
   @Override
@@ -382,18 +382,18 @@ public <T> InsertResult insertAndGetIn(
   }
 
   @Override
-  public <T> int[] insertIn(String tableName, List<T> objects) {
-    return applyAndClose(conn -> conn.insertIn(tableName, objects));
+  public <T> int[] insertInto(String tableName, List<T> objects) {
+    return applyAndClose(conn -> conn.insertInto(tableName, objects));
   }
 
   @Override
-  public <T> int insertIn(String tableName, T object) {
-    return applyAndClose(conn -> conn.insertIn(tableName, object));
+  public <T> int insertInto(String tableName, T object) {
+    return applyAndClose(conn -> conn.insertInto(tableName, object));
   }
 
   @Override
-  public <T> int[] insertIn(String tableName, @SuppressWarnings("unchecked") T... objects) {
-    return applyAndClose(conn -> conn.insertIn(tableName, objects));
+  public <T> int[] insertInto(String tableName, @SuppressWarnings("unchecked") T... objects) {
+    return applyAndClose(conn -> conn.insertInto(tableName, objects));
   }
 
   @Override
@@ -447,23 +447,23 @@ public <T> int updateByPrimaryKey(Class<T> clazz, RowMap object, Object... prima
   }
 
   @Override
-  public int updateByPrimaryKeyIn(String tableName, RowMap object, Object... primaryKeyValues) {
-    return applyAndClose(conn -> conn.updateByPrimaryKeyIn(tableName, object, primaryKeyValues));
+  public int updateByPrimaryKey(String tableName, RowMap object, Object... primaryKeyValues) {
+    return applyAndClose(conn -> conn.updateByPrimaryKey(tableName, object, primaryKeyValues));
   }
 
   @Override
-  public <T> int[] updateIn(String tableName, List<T> objects) {
-    return applyAndClose(conn -> conn.updateIn(tableName, objects));
+  public <T> int[] updateWith(String tableName, List<T> objects) {
+    return applyAndClose(conn -> conn.updateWith(tableName, objects));
   }
 
   @Override
-  public <T> int updateIn(String tableName, T object) {
-    return applyAndClose(conn -> conn.updateIn(tableName, object));
+  public <T> int updateWith(String tableName, T object) {
+    return applyAndClose(conn -> conn.updateWith(tableName, object));
   }
 
   @Override
-  public <T> int[] updateIn(String tableName, @SuppressWarnings("unchecked") T... objects) {
-    return applyAndClose(conn -> conn.updateIn(tableName, objects));
+  public <T> int[] updateWith(String tableName, @SuppressWarnings("unchecked") T... objects) {
+    return applyAndClose(conn -> conn.updateWith(tableName, objects));
   }
 
   @Override
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/table/TableMappedOrm.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/table/TableMappedOrm.java
index 603509c6..206d474a 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/table/TableMappedOrm.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/table/TableMappedOrm.java
@@ -116,27 +116,27 @@ default int deleteByPrimaryKeyIn(String tableName, Object... primaryKeyValues) {
   }
 
   default int[] insert(List<T> objects) {
-    return getOrm().insertIn(getTableName(), objects);
+    return getOrm().insertInto(getTableName(), objects);
   }
 
   default int insert(T object) {
-    return getOrm().insertIn(getTableName(), object);
+    return getOrm().insertInto(getTableName(), object);
   }
 
   default int[] insert(@SuppressWarnings("unchecked") T... objects) {
-    return getOrm().insertIn(getTableName(), objects);
+    return getOrm().insertInto(getTableName(), objects);
   }
 
   default int insertMapIn(RowMap object) {
-    return getOrm().insertMapIn(getTableName(), object);
+    return getOrm().insertMapInto(getTableName(), object);
   }
 
   default int[] insertMapIn(RowMap... objects) {
-    return getOrm().insertMapIn(getTableName(), objects);
+    return getOrm().insertMapInto(getTableName(), objects);
   }
 
   default int[] insertMapIn(List<RowMap> objects) {
-    return getOrm().insertMapIn(getTableName(), objects);
+    return getOrm().insertMapInto(getTableName(), objects);
   }
 
   default InsertResult insertAndGet(List<T> objects) {
@@ -164,19 +164,19 @@ default int[] merge(@SuppressWarnings("unchecked") T... objects) {
   }
 
   default int[] update(List<T> objects) {
-    return getOrm().updateIn(getTableName(), objects);
+    return getOrm().updateWith(getTableName(), objects);
   }
 
   default int update(T object) {
-    return getOrm().updateIn(getTableName(), object);
+    return getOrm().updateWith(getTableName(), object);
   }
 
   default int[] update(@SuppressWarnings("unchecked") T... objects) {
-    return getOrm().updateIn(getTableName(), objects);
+    return getOrm().updateWith(getTableName(), objects);
   }
 
   default int updateByPrimaryKey(RowMap object, Object... primaryKeyValues) {
-    return getOrm().updateByPrimaryKeyIn(getTableName(), object, primaryKeyValues);
+    return getOrm().updateByPrimaryKey(getTableName(), object, primaryKeyValues);
   }
 
   default <S> List<Tuple2<T, S>> joinUsing(TableMappedOrm<S> other, String... columns) {
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/repackage/net/sf/persist/tests/common/TestSimple.java b/sorm4j/src/test/java/repackage/net/sf/persist/tests/common/TestSimple.java
index b34dfcc3..f7157f20 100644
--- a/sorm4j/src/test/java/repackage/net/sf/persist/tests/common/TestSimple.java
+++ b/sorm4j/src/test/java/repackage/net/sf/persist/tests/common/TestSimple.java
@@ -118,8 +118,8 @@ public void testInsert() throws SQLException {
         OrmConnection orm = OrmConnection.of(conn, SormContext.builder().build())) {
       orm.insert(List.of(buildSimple()));
       orm.insert(buildSimple(), buildSimple());
-      orm.insertIn("simple", List.of(buildSimple()));
-      orm.insertIn("simple", buildSimple(), buildSimple());
+      orm.insertInto("simple", List.of(buildSimple()));
+      orm.insertInto("simple", buildSimple(), buildSimple());
     }
   }
 

From 56ee75af8d3c8aa47391b331aeb3f0dd27d45d79 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 17 Jan 2024 10:01:34 +0900
Subject: [PATCH 12/15] Remove log4j2.xml

---
 sorm4j/pom.xml                       |  2 +-
 sorm4j/src/main/resources/log4j2.xml | 34 ----------------------------
 2 files changed, 1 insertion(+), 35 deletions(-)
 delete mode 100644 sorm4j/src/main/resources/log4j2.xml

diff --git a/sorm4j/pom.xml b/sorm4j/pom.xml
index ed066733..5cffcd12 100644
--- a/sorm4j/pom.xml
+++ b/sorm4j/pom.xml
@@ -118,7 +118,7 @@
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
-			<version>5.8.0</version>
+			<version>5.9.0</version>
 			<scope>test</scope>
 		</dependency>
 		<!--
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 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE configuration>
-<configuration status="OFF">
-  <Properties>
-    <property name="sorm4j_log_level">DEBUG</property>
-    <property name="log_pattern">${log_pattern_loc}</property>
-    <property name="log_pattern_loc">
-      %d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%t] %c.%M(%F:%L) %m%n
-    </property>
-    <property name="log_pattern_noloc">
-      %d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%t] %c{3.} %m%n
-    </property>
-  </Properties>
-  <Appenders>
-    <Console name="stdout" target="SYSTEM_OUT">
-      <PatternLayout pattern="${log_pattern}" />
-      <Filters>
-        <ThresholdFilter level="WARN" onMatch="DENY" onMismatch="ACCEPT" />
-      </Filters>
-    </Console>
-    <Console name="stderr" target="SYSTEM_ERR">
-      <PatternLayout pattern="${log_pattern}" />
-      <Filters>
-        <ThresholdFilter level="WARN" onMatch="ACCEPT" />
-      </Filters>
-    </Console>
-  </Appenders>
-  <Loggers>
-    <Logger name="org.nkjmlab.sorm4j" level="${sorm4j_log_level}" additivity="false">
-      <AppenderRef ref="stdout" />
-      <AppenderRef ref="stderr" />
-    </Logger>
-  </Loggers>
-</configuration>

From 224ca1e9f430b07ec3fac21bf439a80db02da6c7 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 17 Apr 2024 09:28:08 +0900
Subject: [PATCH 13/15] Add H2TableMappedOrm

---
 .../sorm4j/util/h2/H2BasicTableMappedOrm.java | 56 +++++++++++++++++++
 .../org/nkjmlab/sorm4j/util/h2/H2Orm.java     |  4 +-
 .../org/nkjmlab/sorm4j/util/h2/H2Table.java   | 28 +---------
 .../sorm4j/util/h2/H2TableMappedOrm.java      | 32 +++++++++++
 .../util/h2/H2BasicTableMappedOrmTest.java    | 28 ++++++++++
 .../sorm4j/util/h2/H2BasicTableTest.java      |  4 +-
 6 files changed, 119 insertions(+), 33 deletions(-)
 create mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrm.java
 create mode 100644 sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2TableMappedOrm.java
 create mode 100644 sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrmTest.java

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrm.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrm.java
new file mode 100644
index 00000000..3fc0940d
--- /dev/null
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableMappedOrm.java
@@ -0,0 +1,56 @@
+package org.nkjmlab.sorm4j.util.h2;
+
+import org.nkjmlab.sorm4j.Orm;
+import org.nkjmlab.sorm4j.annotation.Experimental;
+import org.nkjmlab.sorm4j.util.table_def.TableDefinition;
+
+@Experimental
+public class H2BasicTableMappedOrm<T> implements H2TableMappedOrm<T> {
+
+  private final Orm orm;
+  private final Class<T> valueType;
+  private final TableDefinition tableDefinition;
+
+  /**
+   * This table instance is bind to the table name defined in the given {@link TableDefinition}.
+   *
+   * @param orm
+   * @param valueType
+   * @param tableDefinition
+   */
+  public H2BasicTableMappedOrm(Orm orm, Class<T> valueType, TableDefinition tableDefinition) {
+    this.orm = orm;
+    this.valueType = valueType;
+    this.tableDefinition = tableDefinition;
+  }
+
+  /**
+   * This table instance is bind to the table name defined in the given class.
+   *
+   * @param sorm
+   * @param valueType
+   */
+  public H2BasicTableMappedOrm(Orm orm, Class<T> valueType) {
+    this(orm, valueType, TableDefinition.builder(valueType).build());
+  }
+
+  @Override
+  public Orm getOrm() {
+    return orm;
+  }
+
+  @Override
+  public String getTableName() {
+    return tableDefinition.getTableName();
+  }
+
+  @Override
+  public Class<T> getValueType() {
+    return valueType;
+  }
+
+  @Override
+  public TableDefinition getTableDefinition() {
+    return tableDefinition;
+  }
+}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Orm.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Orm.java
index b454bd55..ac99874f 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Orm.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Orm.java
@@ -1,14 +1,12 @@
 package org.nkjmlab.sorm4j.util.h2;
 
 import org.nkjmlab.sorm4j.Orm;
-import org.nkjmlab.sorm4j.OrmConnection;
 import org.nkjmlab.sorm4j.annotation.Experimental;
 
 @Experimental
 public interface H2Orm {
-
   /**
-   * Gets {@link OrmConnection} object
+   * Gets {@link Orm} object
    *
    * @return
    */
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
index fd9ec604..2c5471aa 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2Table.java
@@ -1,32 +1,6 @@
 package org.nkjmlab.sorm4j.util.h2;
 
-import java.io.File;
-
 import org.nkjmlab.sorm4j.annotation.Experimental;
-import org.nkjmlab.sorm4j.table.Table;
-import org.nkjmlab.sorm4j.util.h2.functions.system.CsvWrite;
-import org.nkjmlab.sorm4j.util.table_def.WithTableDefinition;
 
 @Experimental
-public interface H2Table<T> extends Table<T>, WithTableDefinition, H2Orm {
-
-  /**
-   * Write all rows to csv file.
-   *
-   * @param toFile
-   * @return
-   */
-  default void writeCsv(File toFile) {
-    writeCsv(CsvWrite.builder(toFile).query("select * from " + getTableName()).build());
-  }
-
-  /**
-   * Write selected rows to csv file.
-   *
-   * @param csvWrite
-   * @return
-   */
-  default void writeCsv(CsvWrite csvWrite) {
-    getOrm().executeUpdate("call " + csvWrite.getSql());
-  }
-}
+public interface H2Table<T> extends H2TableMappedOrm<T> {}
diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2TableMappedOrm.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2TableMappedOrm.java
new file mode 100644
index 00000000..3781f231
--- /dev/null
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/util/h2/H2TableMappedOrm.java
@@ -0,0 +1,32 @@
+package org.nkjmlab.sorm4j.util.h2;
+
+import java.io.File;
+
+import org.nkjmlab.sorm4j.annotation.Experimental;
+import org.nkjmlab.sorm4j.table.TableMappedOrm;
+import org.nkjmlab.sorm4j.util.h2.functions.system.CsvWrite;
+import org.nkjmlab.sorm4j.util.table_def.WithTableDefinition;
+
+@Experimental
+public interface H2TableMappedOrm<T> extends TableMappedOrm<T>, WithTableDefinition, H2Orm {
+
+  /**
+   * Write all rows to csv file.
+   *
+   * @param toFile
+   * @return
+   */
+  default void writeCsv(File toFile) {
+    writeCsv(CsvWrite.builder(toFile).query("select * from " + getTableName()).build());
+  }
+
+  /**
+   * Write selected rows to csv file.
+   *
+   * @param csvWrite
+   * @return
+   */
+  default void writeCsv(CsvWrite csvWrite) {
+    getOrm().executeUpdate("call " + csvWrite.getSql());
+  }
+}
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<Example> 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/H2BasicTableTest.java b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
index 2879866b..f7efe488 100644
--- a/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
+++ b/sorm4j/src/test/java/org/nkjmlab/sorm4j/util/h2/H2BasicTableTest.java
@@ -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);
     }
   }
 

From 6412462083422d2a957f5af07b15bf8821339870 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 17 Apr 2024 09:29:17 +0900
Subject: [PATCH 14/15] Modify Record class handling

---
 .../mapping/SqlResultToColumnsMapping.java    | 24 +++++++++++--------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/mapping/SqlResultToColumnsMapping.java b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/mapping/SqlResultToColumnsMapping.java
index 040b1151..fa39deae 100644
--- a/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/mapping/SqlResultToColumnsMapping.java
+++ b/sorm4j/src/main/java/org/nkjmlab/sorm4j/internal/mapping/SqlResultToColumnsMapping.java
@@ -8,6 +8,7 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
+
 import org.nkjmlab.sorm4j.annotation.OrmConstructor;
 import org.nkjmlab.sorm4j.annotation.OrmRecord;
 import org.nkjmlab.sorm4j.common.SormException;
@@ -42,15 +43,19 @@ public SqlResultToColumnsMapping(
     this.objectClass = objectClass;
     this.columnToAccessorMap = columnToAccessorMap;
 
-    Constructor<T> ormConstructor = getOrmConstructor(objectClass);
     Constructor<T> ormRecordConstructor = getOrmRecordConstructor(objectClass);
-    this.containerObjectCreator =
-        ormRecordConstructor != null
-            ? createContainerRecordCreator(objectClass, ormRecordConstructor)
-            : (ormConstructor != null
-                ? createOrmConstructorPojoCreator(objectClass, ormConstructor)
-                : new SqlResultToContainerMappingWithSetter<>(
-                    columnToAccessorMap, getDefaultConstructor(objectClass)));
+    if (ormRecordConstructor != null) {
+      this.containerObjectCreator = createContainerRecordCreator(objectClass, ormRecordConstructor);
+    } else {
+      Constructor<T> ormConstructor = getOrmConstructor(objectClass);
+      if (ormConstructor != null) {
+        this.containerObjectCreator = createOrmConstructorPojoCreator(objectClass, ormConstructor);
+      } else {
+        this.containerObjectCreator =
+            new SqlResultToContainerMappingWithSetter<>(
+                columnToAccessorMap, getDefaultConstructor(objectClass));
+      }
+    }
   }
 
   private SqlResultToContainerMapping<T> createContainerRecordCreator(
@@ -62,8 +67,7 @@ private SqlResultToContainerMapping<T> createContainerRecordCreator(
   }
 
   private Constructor<T> getOrmRecordConstructor(Class<T> objectClass) {
-    OrmRecord a = objectClass.getAnnotation(OrmRecord.class);
-    if (a == null) {
+    if (!objectClass.isRecord() && objectClass.getAnnotation(OrmRecord.class) == null) {
       return null;
     }
     Object[] params = {objectClass, OrmRecord.class.getSimpleName()};

From 9fb32fee5b5bd5f19e750276e7bb36cf924c8ae7 Mon Sep 17 00:00:00 2001
From: Yuu NAKAJIMA <yuu.nkjm.pub@gmail.com>
Date: Wed, 17 Apr 2024 09:29:49 +0900
Subject: [PATCH 15/15] Update pom.xml

---
 README.md      | 18 ++++++++++--------
 sorm4j/pom.xml | 42 ++++++++++++++++++++----------------------
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/README.md b/README.md
index 427158a1..a0d8e31b 100644
--- a/README.md
+++ b/README.md
@@ -21,12 +21,20 @@ The latest release is available at [Maven Central Repository](https://mvnreposit
  <dependency>
    <groupId>org.nkjmlab</groupId>
    <artifactId>sorm4j</artifactId>
-   <version>2.1.1</version>
+   <version>2.1.5</version>
  </dependency>
 ```
 We assume the following customer table in example: `create table customer (id int primary key, name varchar, address varchar)`
 
-Create a class with public fields and a default constructor matching a table name. For example:
+Create a Record class that has components and names matching the columns and the table name. For example:
+
+
+```java
+public record Customer (int id, String name, String address){}
+```
+
+You could also use a class with public fields and a default constructor matching a table name. For example:
+
 
 ```java
 public class Customer {
@@ -34,13 +42,7 @@ public class Customer {
   public String name;
   public String address;
 }
-```
 
-You could also use Record class. For example:
-
-```java
- @OrmRecord
- public record Customer (int id, String name, String address){}
 ```
 
 Create an entry point:
diff --git a/sorm4j/pom.xml b/sorm4j/pom.xml
index 5cffcd12..b03c3b48 100644
--- a/sorm4j/pom.xml
+++ b/sorm4j/pom.xml
@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.nkjmlab</groupId>
 	<artifactId>sorm4j</artifactId>
-	<version>2.1.4</version>
+	<version>2.1.5</version>
 	<name>sorm4j</name>
 	<description>Simple micro Object-Relation Mapper for Java</description>
 	<url>https://github.com/yuu-nkjm/sorm4j</url>
@@ -52,14 +52,14 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-api</artifactId>
-			<version>2.22.1</version>
+			<version>2.23.1</version>
 			<optional>true</optional>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-api</artifactId>
-			<version>2.0.11</version>
+			<version>2.0.13</version>
 			<optional>true</optional>
 		</dependency>
 		<!--
@@ -67,7 +67,7 @@
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>2.16.1</version>
+			<version>2.17.0</version>
 			<optional>true</optional>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.locationtech.jts/jts-core -->
@@ -89,14 +89,14 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-engine</artifactId>
-			<version>5.10.1</version>
+			<version>5.10.2</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.assertj/assertj-core -->
 		<dependency>
 			<groupId>org.assertj</groupId>
 			<artifactId>assertj-core</artifactId>
-			<version>3.25.1</version>
+			<version>3.25.3</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
@@ -111,14 +111,14 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-iostreams</artifactId>
-			<version>2.22.1</version>
+			<version>2.23.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
-			<version>5.9.0</version>
+			<version>5.11.0</version>
 			<scope>test</scope>
 		</dependency>
 		<!--
@@ -126,7 +126,7 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-slf4j2-impl</artifactId>
-			<version>2.22.1</version>
+			<version>2.23.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!--
@@ -134,7 +134,7 @@
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-core</artifactId>
-			<version>2.22.1</version>
+			<version>2.23.1</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
@@ -148,22 +148,20 @@
 		<dependency>
 			<groupId>org.postgresql</groupId>
 			<artifactId>postgresql</artifactId>
-			<version>42.7.1</version>
-			<scope>test</scope>
-		</dependency>
-		<!--
-		https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc -->
-		<dependency>
-			<groupId>com.microsoft.sqlserver</groupId>
-			<artifactId>mssql-jdbc</artifactId>
-			<version>12.4.2.jre11</version>
+			<version>42.7.3</version>
 			<scope>test</scope>
 		</dependency>
+    <!-- https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc -->
+    <dependency>
+        <groupId>com.microsoft.sqlserver</groupId>
+        <artifactId>mssql-jdbc</artifactId>
+        <version>12.6.1.jre11</version>
+    </dependency>
 		<!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc10 -->
 		<dependency>
 			<groupId>com.oracle.database.jdbc</groupId>
 			<artifactId>ojdbc10</artifactId>
-			<version>19.21.0.0</version>
+			<version>19.22.0.0</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>
@@ -332,8 +330,8 @@
 			<plugin>
 				<groupId>com.github.hazendaz.maven</groupId>
 				<artifactId>coveralls-maven-plugin</artifactId>
-				<version>4.5.0-M2</version>
+				<version>4.5.0-M3</version>
 			</plugin>
 		</plugins>
 	</build>
-</project>
\ No newline at end of file
+</project>