Support complex array parameters.

Author: alaisi

src/main/java/com/github/pgasync/impl/PgConnectionPool.java

@@ -136,8 +136,14 @@ public void getConnection(final Consumer<Connection> onConnection, final Consume
         if (connection == null) {
             new PgConnection(openStream(address), dataConverter)
                     .connect(username, password, database, onConnection, onError);
-        } else {
+            return;
+        }
+
+        try {
             onConnection.accept(connection);
+        } catch (Throwable t) {
+            release(connection);
+            onError.accept(t);
         }
     }
 

src/main/java/com/github/pgasync/impl/conversion/ArrayConversions.java

@@ -2,224 +2,189 @@
 
 import com.github.pgasync.impl.Oid;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+// TODO: change internal value format from byte[] to PgValue(TEXT|BINARY)
+@SuppressWarnings({"unchecked","rawtypes"})
 enum ArrayConversions  {
     ;
 
-    protected static Oid getElementOid(final Oid oid) {
-        try {
-            return Oid.valueOf(oid.name().replaceFirst("_ARRAY", ""));
-        } catch (IllegalArgumentException e) {
-            return Oid.UNSPECIFIED;
-        }
+    public static byte[] fromArray(final Object[] elements, final Function<Object,byte[]> printFn) {
+        return appendArray(new StringBuilder(), elements, printFn).toString().getBytes(UTF_8);
     }
 
-    protected static Class getElementType(Class arrayType) {
-        while(arrayType.getComponentType() != null) {
-            arrayType = arrayType.getComponentType();
+    static StringBuilder appendArray(StringBuilder sb, final Object elements, final Function<Object,byte[]> printFn) {
+        sb.append('{');
+
+        int nElements = Array.getLength(elements);
+        for (int i = 0; i < nElements; i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+
+            Object o = Array.get(elements, i);
+            if (o == null) {
+                sb.append("NULL");
+            } else if (o.getClass().isArray()) {
+                sb = appendArray(sb, o, printFn);
+            } else {
+                sb = appendEscaped(sb, new String(printFn.apply(o), UTF_8));
+            }
         }
-        return arrayType;
+
+        return sb.append('}');
     }
 
-    @SuppressWarnings("unchecked")
-    public static <TArray> TArray toArray(
-        Class<TArray> arrayType, Oid oid, byte[] value, BiFunction<Oid, byte[], Object> parse) {
+    static StringBuilder appendEscaped(final StringBuilder b, final String s) {
+        b.append('"');
+        for (int j = 0; j < s.length(); j++) {
+            char c = s.charAt(j);
+            if (c == '"' || c == '\\') {
+                b.append('\\');
+            }
 
-        Oid elementOid = getElementOid(oid);
-        return (TArray)buildArray(
-            getElementType(arrayType), buildArrayList(value), 0, -1, (s) -> parse.apply(elementOid, s));
+            b.append(c);
+        }
+        return b.append('"');
     }
 
-    protected static Object[] buildArray(
-        Class elementType, PgArrayList input, int index, int count, Function<byte[], Object> parse) {
-
-        if (count < 0)
-            count = input.size();
+    public static <T> T toArray(Class<T> type, Oid oid, byte[] value, BiFunction<Oid,byte[],Object> parse) {
+        char[] text = new String(value, UTF_8).toCharArray();
+        List<List<Object>> holder = new ArrayList<>(1);
 
-        int dimensionCount = input.dimensionsCount;
-        int[] dimensions = new int[dimensionCount];
-        for (int i = 0; i < dimensionCount; i++) {
-            dimensions[i] = (i == 0 ? count : 0);
+        if(readArray(text, skipBounds(text, 0), (List) holder) != text.length) {
+            throw new IllegalStateException("Failed to read array");
         }
 
-        Object[] ret = (Object[])java.lang.reflect.Array.newInstance(elementType, dimensions);
+        return (T) toNestedArrays(holder.get(0), getElementType(type), getElementOid(oid), parse);
+    }
 
-        for (int length = 0; length < count; length++) {
-            Object o = input.get(index++);
-            if (o != null) {
-                if (1 < dimensionCount) {
-                    o = buildArray(elementType, (PgArrayList) o, 0, -1,  parse);
-                } else {
-                    o = parse.apply(((String) o).getBytes(UTF_8));
-                }
+    static int skipBounds(final char[] text, final int start) {
+        if(text[start] != '[') {
+            return start;
+        }
+        for(int end = start + 1;;) {
+            if(text[end++] == '=') {
+                return end;
             }
-            ret[length] = o;
         }
-        return ret;
     }
 
-    // TODO: split and simplify
-    @SuppressWarnings("unchecked")
-    protected static PgArrayList buildArrayList(byte[] byteValue) {
-        PgArrayList arrayList = new PgArrayList();
-
-        char delim = ',';
-
-        if (byteValue != null) {
-            char[] chars = new String(byteValue).toCharArray();
-            StringBuffer buffer = null;
-            boolean insideString = false;
-            boolean wasInsideString = false; // needed for checking if NULL
-            // value occurred
-            List dims = new ArrayList(); // array dimension arrays
-            PgArrayList curArray = arrayList; // currently processed array
-
-            // Starting with 8.0 non-standard (beginning index
-            // isn't 1) bounds the dimensions are returned in the
-            // data formatted like so "[0:3]={0,1,2,3,4}".
-            // Older versions simply do not return the bounds.
-            //
-            // Right now we ignore these bounds, but we could
-            // consider allowing these index values to be used
-            // even though the JDBC spec says 1 is the first
-            // index. I'm not sure what a client would like
-            // to see, so we just retain the old behavior.
-            int startOffset = 0;
-
-            if (chars[0] == '[') {
-                while (chars[startOffset] != '=') {
-                    startOffset++;
-                }
-                startOffset++; // skip =
+    static int readArray(final char[] text, final int start, List<Object> result) {
+        List<Object> values = new ArrayList<>();
+        for(int i = start + 1;;) {
+            final char c = text[i];
+            if(c == '}') {
+                result.add(values);
+                return i + 1;
+            } else if(c == ',' || Character.isWhitespace(c)) {
+                i++;
+            } else if(c == '"') {
+                i = readString(text, i, values);
+            } else if(c == '{') {
+                i = readArray(text, i, values);
+            } else if (c == 'N') {
+                i = readNull(i, values);
+            } else {
+                i = readValue(text, i, values);
             }
+        }
+    }
 
-            for (int i = startOffset; i < chars.length; i++) {
-                // escape character that we need to skip
-                if (chars[i] == '\\')
-                    i++;
-
-                    // subarray start
-                else if (!insideString && chars[i] == '{') {
-                    if (dims.size() == 0) {
-                        dims.add(arrayList);
-                    } else {
-                        PgArrayList a = new PgArrayList();
-                        PgArrayList p = ((PgArrayList) dims.get(dims.size() - 1));
-                        p.add(a);
-                        dims.add(a);
-                    }
-                    curArray = (PgArrayList) dims.get(dims.size() - 1);
-
-                    // number of dimensions
-                    for (int t = i + 1; t < chars.length; t++) {
-                        if (Character.isWhitespace(chars[t]))
-                            continue;
-                        else if (chars[t] == '{')
-                            curArray.dimensionsCount++;
-                        else break;
-                    }
-
-                    buffer = new StringBuffer();
-                    continue;
-                }
-                // quoted element
-                else if (chars[i] == '"') {
-                    insideString = !insideString;
-                    wasInsideString = true;
-                    continue;
-                }
-                // white space
-                else if (!insideString && Character.isWhitespace(chars[i])) {
-                    continue;
-                }
-                // array end or element end
-                else if ((!insideString && (chars[i] == delim || chars[i] == '}')) || i == chars.length - 1) {
-                    // when character that is a part of array element
-                    if (chars[i] != '"' && chars[i] != '}' && chars[i] != delim && buffer != null) {
-                        buffer.append(chars[i]);
-                    }
-
-                    String b = buffer == null ? null : buffer.toString();
-
-                    // add element to current array
-                    if (b != null && (b.length() > 0 || wasInsideString)) {
-                        curArray.add(!wasInsideString && b.equals("NULL") ? null : b);
-                    }
-
-                    wasInsideString = false;
-                    buffer = new StringBuffer();
-
-                    // when end of an array
-                    if (chars[i] == '}') {
-                        dims.remove(dims.size() - 1);
-
-                        // when multi-dimension
-                        if (dims.size() > 0) {
-                            curArray = (PgArrayList) dims.get(dims.size() - 1);
-                        }
-
-                        buffer = null;
-                    }
-                    continue;
-                }
-
-                if (buffer != null)
-                    buffer.append(chars[i]);
+    static int readValue(final char[] text, final int start, List<Object> result) {
+        StringBuilder str = new StringBuilder();
+        for(int i = start;; i++) {
+            char c = text[i];
+            if(c == ',' || c == '}' || Character.isWhitespace(c)) {
+                result.add(str.toString());
+                return i;
             }
+            str.append(c);
         }
-        return arrayList;
     }
 
-    public static byte[] fromArray(final Object[] elements) {
-        StringBuffer sb = new StringBuffer();
-        appendArray(sb, elements);
-        return sb.toString().getBytes(UTF_8);
+    static int readNull(final int i, final List<Object> result) {
+        result.add(null);
+        return i + 4;
     }
 
-    protected static void appendArray(final StringBuffer sb, final Object elements) {
-        sb.append('{');
-
-        int nElements = java.lang.reflect.Array.getLength(elements);
-        for (int i = 0; i < nElements; i++) {
-            if (i > 0) {
-                sb.append(',');
+    static int readString(final char[] text, final int start, final List<Object> result) {
+        StringBuilder str = new StringBuilder();
+        for(int i = start + 1;;) {
+            char c = text[i++];
+            if(c == '"') {
+                result.add(str.toString());
+                return i;
             }
+            if(c == '\\') {
+                c = text[i++];
+            }
+            str.append(c);
+        }
+    }
 
-            Object o = java.lang.reflect.Array.get(elements, i);
-            if (o == null) {
-                sb.append("NULL");
-            } else if (o.getClass().isArray()) {
-                appendArray(sb, o);
+    static Oid getElementOid(final Oid oid) {
+        try {
+            return Oid.valueOf(oid.name().replaceFirst("_ARRAY", ""));
+        } catch (IllegalArgumentException e) {
+            return Oid.UNSPECIFIED;
+        }
+    }
+
+    static Class getElementType(Class arrayType) {
+        while(arrayType.getComponentType() != null) {
+            arrayType = arrayType.getComponentType();
+        }
+        return arrayType;
+    }
+
+    static <T> T[] toNestedArrays(List<Object> result, Class<?> type, Oid oid, BiFunction<Oid, byte[], Object> parse) {
+        Object[] arr = (Object[]) Array.newInstance(type, getNestedDimensions(result));
+        for(int i = 0; i < result.size(); i++) {
+            Object elem = result.get(i);
+            if(elem == null) {
+                arr[i] = null;
+            } else if(elem.getClass().equals(String.class)) {
+                arr[i] = parse.apply(oid, ((String) elem).getBytes(UTF_8));
             } else {
-                String s = o.toString();
-                escapeArrayElement(sb, s);
+                arr[i] = toNestedArrays((List<Object>) elem, type, oid, parse);
             }
         }
-        sb.append('}');
+        return (T[]) arr;
     }
 
-    protected static void escapeArrayElement(final StringBuffer b, final String s) {
-        b.append('"');
-        for (int j = 0; j < s.length(); j++) {
-            char c = s.charAt(j);
-            if (c == '"' || c == '\\') {
-                b.append('\\');
-            }
+    static int[] getNestedDimensions(List<Object> result) {
+        if(result.isEmpty()) {
+            return new int[]{0};
+        }
+        if(!(result.get(0) instanceof List)) {
+            return new int[]{ result.size() };
+        }
 
-            b.append(c);
+        List<Integer> dimensions = new ArrayList<>();
+        dimensions.add(result.size());
+
+        Object value = result.get(0);
+        while(value instanceof List) {
+            List nested = (List) value;
+            dimensions.add(nested.size());
+            value = nested.isEmpty() ? null : nested.get(0);
         }
-        b.append('"');
-    }
 
-    private static class PgArrayList extends ArrayList {
-        private static final long serialVersionUID = 2052783752654562677L;
+        return toIntArray(dimensions);
+    }
 
-        int dimensionsCount = 1;
+    static int[] toIntArray(List<Integer> list) {
+        int[] arr = new int[list.size()];
+        for(int i = 0; i < arr.length; i++) {
+            arr[i] = list.get(i);
+        }
+        return arr;
     }
-}
+}