AutoClosable for SimpleRowWriter, Update Dependencies in pom

Author: bytefish

PgBulkInsert/pgbulkinsert-rowwriter/src/main/java/de/bytefish/pgbulkinsert/row/SimpleRowWriter.java

@@ -17,7 +17,7 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-public class SimpleRowWriter {
+public class SimpleRowWriter implements  AutoCloseable {
 
     public static class Table {
 

PgBulkInsert/pgbulkinsert-rowwriter/src/test/java/de/bytefish/pgbulkinsert/test/row/NullTerminatingStringTest.java

@@ -38,14 +38,12 @@ public void testWriterThrowsErrorForNullCharacter() throws SQLException {
 
         try {
             // Create the Writer:
-            SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection);
+            try(SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection)) {
 
-            writer.startRow((row) -> {
-                row.setText("value_text", "Hi\0");
-            });
-
-            // ... and make sure to close it:
-            writer.close();
+                writer.startRow((row) -> {
+                    row.setText("value_text", "Hi\0");
+                });
+            }
         } catch(Exception e) {
             exceptionHasBeenThrown = true;
         }

PgBulkInsert/pgbulkinsert-rowwriter/src/test/java/de/bytefish/pgbulkinsert/test/row/SimpleRowWriterTest.java

@@ -40,24 +40,22 @@ public void rowBasedWriterTest() throws SQLException {
         SimpleRowWriter.Table table = new SimpleRowWriter.Table(schema, tableName, columnNames);
 
         // Create the Writer:
-        SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection);
-
-        // ... write your data rows:
-        for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
-
-            // ... using startRow and work with the row, see how the order doesn't matter:
-            writer.startRow((row) -> {
-                row.setText("value_text", "Hi");
-                row.setInteger("value_int", 1);
-                row.setTsTzRange("value_range", new Range<>(
-                        ZonedDateTime.of(2020, 3, 1, 0, 0, 0, 0, ZoneId.of("GMT")),
-                        ZonedDateTime.of(2020, 3, 1, 0, 0, 0, 0, ZoneId.of("GMT"))));
-            });
+        try(SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection)) {
+
+            // ... write your data rows:
+            for (int rowIdx = 0; rowIdx < 10000; rowIdx++) {
+
+                // ... using startRow and work with the row, see how the order doesn't matter:
+                writer.startRow((row) -> {
+                    row.setText("value_text", "Hi");
+                    row.setInteger("value_int", 1);
+                    row.setTsTzRange("value_range", new Range<>(
+                            ZonedDateTime.of(2020, 3, 1, 0, 0, 0, 0, ZoneId.of("GMT")),
+                            ZonedDateTime.of(2020, 3, 1, 0, 0, 0, 0, ZoneId.of("GMT"))));
+                });
+            }
         }
 
-        // ... and make sure to close it:
-        writer.close();
-
         // Now assert, that we have written 10000 entities:
 
         Assert.assertEquals(10000, getRowCount());

PgBulkInsert/pgbulkinsert-rowwriter/src/test/java/de/bytefish/pgbulkinsert/test/row/SimpleRowWriterWithQuotesTest.java

@@ -36,24 +36,20 @@ public void rowBasedWriterTest() throws SQLException {
         SimpleRowWriter.Table table = new SimpleRowWriter.Table(schema, tableName, columnNames);
 
         // Create the Writer:
-        SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection, true);
+        try(SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection, true)) {
 
-        // ... write your data rows:
-        for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
-
-            // ... using startRow and work with the row, see how the order doesn't matter:
-            writer.startRow((row) -> {
-                row.setText("value_text", "Hi");
-                row.setInteger("Value_int", 1);
-            });
+            // ... write your data rows:
+            for (int rowIdx = 0; rowIdx < 10000; rowIdx++) {
 
+                // ... using startRow and work with the row, see how the order doesn't matter:
+                writer.startRow((row) -> {
+                    row.setText("value_text", "Hi");
+                    row.setInteger("Value_int", 1);
+                });
+            }
         }
 
-        // ... and make sure to close it:
-        writer.close();
-
         // Now assert, that we have written 10000 entities:
-
         Assert.assertEquals(10000, getRowCount());
     }
 

README.md

@@ -112,42 +112,30 @@ String[] columnNames = new String[] {
 
 // Create the Table Definition:
 SimpleRowWriter.Table table = new SimpleRowWriter.Table(schemaName, tableName, columnNames);
-
-// Create the Writer:
-SimpleRowWriter writer = new SimpleRowWriter(table);
 ```
 
-Once created you are required to open the ``SimpleRowWriter`` by yourself using a ``PGConnection``:
+Once created you create the ``SimpleRowWriter`` by using the ``Table`` and a ``PGConnection``.
 
-```java
-// ... open it:
-writer.open(pgConnection);
-```
-
-To write a row to PostgreSQL you call the ``startRow`` method. It expects you to pass a ``Consumer<SimpleRow>`` into it, 
-which defines what data to write to the row. The call to ``startRow`` is synchronized, so it is safe to be called from 
-multiple threads.
+Now to write a row to PostgreSQL you call the ``startRow`` method. It expects you to pass a 
+``Consumer<SimpleRow>`` into it, which defines what data to write to the row. The call to 
+``startRow`` is synchronized, so it is safe to be called from multiple threads.
 
 ```java
-// ... write your data rows:
-for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
+// Create the Writer:
+try(SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection)) {
 
-    // ... using startRow and work with the row, see how the order doesn't matter:
-    writer.startRow((row) -> {
-        row.setText("value_text", "Hi");
-        row.setInteger("value_int", 1);
-    });
+    // ... write your data rows:
+    for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
 
+        // ... using startRow and work with the row, see how the order doesn't matter:
+        writer.startRow((row) -> {
+            row.setText("value_text", "Hi");
+            row.setInteger("value_int", 1);
+        });
+    }
 }
 ```
 
-And to finish the COPY operation, you need to close the ``SimpleRowWriter``:
-
-```java
-// ... and make sure to close it:
-writer.close();
-```
-
 So the complete example looks like this:
 
 ```java
@@ -177,25 +165,20 @@ public class SimpleRowWriterTest extends TransactionalTestBase {
         SimpleRowWriter.Table table = new SimpleRowWriter.Table(schemaName, tableName, columnNames);
 
         // Create the Writer:
-        SimpleRowWriter writer = new SimpleRowWriter(table);
-
-        // ... open it:
-        writer.open(pgConnection);
+        try(SimpleRowWriter writer = new SimpleRowWriter(table, pgConnection)) {
 
-        // ... write your data rows:
-        for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
+            // ... write your data rows:
+            for(int rowIdx = 0; rowIdx < 10000; rowIdx++) {
 
-            // ... using startRow and work with the row, see how the order doesn't matter:
-            writer.startRow((row) -> {
-                row.setText("value_text", "Hi");
-                row.setInteger("value_int", 1);
-            });
+                // ... using startRow and work with the row, see how the order doesn't matter:
+                writer.startRow((row) -> {
+                    row.setText("value_text", "Hi");
+                    row.setInteger("value_int", 1);
+                });
 
+            }
         }
 
-        // ... and make sure to close it:
-        writer.close();
-
         // Now assert, that we have written 10000 entities:
 
         Assert.assertEquals(10000, getRowCount());