refactor to remove duplicate code

Author: jonfreedman

PgBulkInsert/pgbulkinsert-core/src/main/java/de/bytefish/pgbulkinsert/PgBulkInsert.java

@@ -43,11 +43,7 @@ public void saveAll(PGConnection connection, Stream<TEntity> entities) throws SQ
     }
 
     public void saveAll(PGConnection connection, Collection<TEntity> entities) throws SQLException {
-        // Wrap the CopyOutputStream in our own Writer:
-        try (PgBinaryWriter bw = new PgBinaryWriter(new PGCopyOutputStream(connection, mapping.getCopyCommand(), 1), configuration.getBufferSize())) {
-            // Insert Each Column:
-            entities.forEach(entity -> saveEntity(bw, entity));
-        }
+        saveAll(connection, entities.stream());
     }
 
     private void saveEntity(PgBinaryWriter bw, TEntity entity) throws SaveEntityFailedException {

PgBulkInsert/pgbulkinsert-core/src/main/java/de/bytefish/pgbulkinsert/pgsql/handlers/BigDecimalValueHandler.java

@@ -12,119 +12,79 @@
 
 /**
  * The Algorithm for turning a BigDecimal into a Postgres Numeric is heavily inspired by the Intermine Implementation:
- *
+ * <p>
  * https://github.com/intermine/intermine/blob/master/intermine/objectstore/main/src/org/intermine/sql/writebatch/BatchWriterPostgresCopyImpl.java
- *
  */
 public class BigDecimalValueHandler<T extends Number> extends BaseValueHandler<T> {
 
     private static final int DECIMAL_DIGITS = 4;
-
-    protected static final BigInteger TEN = new BigInteger("10");
-    protected static final BigInteger TEN_THOUSAND = new BigInteger("10000");
+    private static final BigInteger TEN_THOUSAND = new BigInteger("10000");
 
     @Override
-    protected void internalHandle(DataOutputStream buffer, final T value) throws Exception {
-
-        BigDecimal tmpValue = getNumericAsBigDecimal(value);
-
-        BigInteger unscaledValue = tmpValue.unscaledValue();
-
-        int sign = tmpValue.signum();
-
-        if (sign == -1) {
-            unscaledValue = unscaledValue.negate();
-        }
+    protected void internalHandle(final DataOutputStream buffer, final T value) throws Exception {
+        final BigDecimal tmpValue = getNumericAsBigDecimal(value);
 
         // Number of fractional digits:
-        int fractionDigits = tmpValue.scale();
+        final int fractionDigits = tmpValue.scale();
 
         // Number of Fraction Groups:
-        int fractionGroups = (fractionDigits + 3) / 4;
-
-        List<Integer> digits = new ArrayList<>();
-
-        // The scale needs to be a multiple of 4:
-        int scaleRemainder = fractionDigits % 4;
-
-        // Scale the first value:
-        if(scaleRemainder != 0)
-        {
-            BigInteger[] result = unscaledValue.divideAndRemainder(TEN.pow(scaleRemainder));
-
-            int digit = result[1].intValue() * (int) Math.pow(10, DECIMAL_DIGITS - scaleRemainder);
-
-            digits.add(digit);
-
-            unscaledValue = result[0];
-        }
+        final int fractionGroups = (fractionDigits + 3) / 4;
 
-        while (!unscaledValue.equals(BigInteger.ZERO)) {
-            BigInteger[] result = unscaledValue.divideAndRemainder(TEN_THOUSAND);
-            digits.add(result[1].intValue());
-            unscaledValue = result[0];
-        }
+        final List<Integer> digits = digits(tmpValue);
 
         buffer.writeInt(8 + (2 * digits.size()));
         buffer.writeShort(digits.size());
         buffer.writeShort(digits.size() - fractionGroups - 1);
-        buffer.writeShort(sign == 1 ? 0x0000 : 0x4000);
+        buffer.writeShort(tmpValue.signum() == 1 ? 0x0000 : 0x4000);
         buffer.writeShort(fractionDigits);
 
         // Now write each digit:
         for (int pos = digits.size() - 1; pos >= 0; pos--) {
-            int valueToWrite = digits.get(pos);
+            final int valueToWrite = digits.get(pos);
             buffer.writeShort(valueToWrite);
         }
     }
 
-    private static BigDecimal getNumericAsBigDecimal(Number source) {
+    @Override
+    public int getLength(final T value) {
+        final List<Integer> digits = digits(getNumericAsBigDecimal(value));
+        return (8 + (2 * digits.size()));
+    }
 
+    private static BigDecimal getNumericAsBigDecimal(final Number source) {
         if (!(source instanceof BigDecimal)) {
             return BigDecimalUtils.toBigDecimal(source.doubleValue());
         }
 
         return (BigDecimal) source;
     }
 
-    @Override
-    public int getLength(T value) {
-        BigDecimal tmpValue = getNumericAsBigDecimal(value);
+    private List<Integer> digits(final BigDecimal value) {
+        BigInteger unscaledValue = value.unscaledValue();
 
-        BigInteger unscaledValue = tmpValue.unscaledValue();
-
-        int sign = tmpValue.signum();
-
-        if (sign == -1) {
+        if (value.signum() == -1) {
             unscaledValue = unscaledValue.negate();
         }
 
-        // Number of fractional digits:
-        int fractionDigits = tmpValue.scale();
-
-        List<Integer> digits = new ArrayList<>();
+        final List<Integer> digits = new ArrayList<>();
 
         // The scale needs to be a multiple of 4:
-        int scaleRemainder = fractionDigits % 4;
+        int scaleRemainder = value.scale() % 4;
 
         // Scale the first value:
-        if(scaleRemainder != 0)
-        {
-            BigInteger[] result = unscaledValue.divideAndRemainder(TEN.pow(scaleRemainder));
-
-            int digit = result[1].intValue() * (int) Math.pow(10, DECIMAL_DIGITS - scaleRemainder);
-
+        if (scaleRemainder != 0) {
+            final BigInteger[] result = unscaledValue.divideAndRemainder(BigInteger.TEN.pow(scaleRemainder));
+            final int digit = result[1].intValue() * (int) Math.pow(10, DECIMAL_DIGITS - scaleRemainder);
             digits.add(digit);
-
             unscaledValue = result[0];
         }
 
         while (!unscaledValue.equals(BigInteger.ZERO)) {
-            BigInteger[] result = unscaledValue.divideAndRemainder(TEN_THOUSAND);
+            final BigInteger[] result = unscaledValue.divideAndRemainder(TEN_THOUSAND);
             digits.add(result[1].intValue());
             unscaledValue = result[0];
         }
 
-        return (8 + (2 * digits.size()));
+        return digits;
     }
 }