support pg binary protocol

Author: ShenFeng312

database/protocol/type/postgresql/src/main/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/PostgreSQLDataRowPacket.java

@@ -59,7 +59,10 @@ private void writeBinaryValue(final PostgreSQLPacketPayload payload, final Binar
             return;
         }
         PostgreSQLBinaryProtocolValue binaryProtocolValue = PostgreSQLBinaryProtocolValueFactory.getBinaryProtocolValue(each.getColumnType());
-        payload.writeInt4(binaryProtocolValue.getColumnLength(payload, value));
+        int columnLength = binaryProtocolValue.getColumnLength(payload, value);
+        if (columnLength > 0) {
+            payload.writeInt4(columnLength);
+        }
         binaryProtocolValue.write(payload, value);
     }
 

database/protocol/type/postgresql/src/main/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/PostgreSQLColumnType.java

@@ -197,7 +197,6 @@ public enum PostgreSQLColumnType implements BinaryColumnType {
         JDBC_TYPE_AND_COLUMN_TYPE_MAP.put(Types.BOOLEAN, BOOL);
         // TODO Temporary solution for https://github.com/apache/shardingsphere/issues/22522
         JDBC_TYPE_AND_COLUMN_TYPE_MAP.put(Types.STRUCT, VARCHAR);
-        JDBC_TYPE_AND_COLUMN_TYPE_MAP.put(Types.ARRAY, TEXT_ARRAY);
     }
 
     /**

database/protocol/type/postgresql/src/main/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/PostgreSQLArrayBinaryProtocolValue.java

@@ -0,0 +1,70 @@
+package org.apache.shardingsphere.database.protocol.postgresql.packet.command.query.extended.bind.protocol;
+
+import org.apache.shardingsphere.database.protocol.postgresql.payload.PostgreSQLPacketPayload;
+import org.apache.shardingsphere.database.protocol.postgresql.packet.command.query.extended.bind.protocol.util.codec.decoder.PgBinaryObj;
+import org.postgresql.core.Oid;
+import org.postgresql.jdbc.ShardingSpherePgArrayUtils;
+
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+public class PostgreSQLArrayBinaryProtocolValue implements PostgreSQLBinaryProtocolValue {
+
+    private static final Map<Integer, String> oidTypeName = new HashMap<>();
+
+    static {
+        oidTypeName.put(Oid.BOOL, "bool[]");
+        oidTypeName.put(Oid.BYTEA, "bytea[]");
+//        oidTypeName.put(Oid.CHAR_ARRAY, "char[]");
+//        oidTypeName.put(Oid.NAME_ARRAY, "name[]");
+        oidTypeName.put(Oid.INT2, "int2[]");
+        oidTypeName.put(Oid.INT4, "int4[]");
+        oidTypeName.put(Oid.INT8, "int8[]");
+        oidTypeName.put(Oid.FLOAT4, "float4[]");
+        oidTypeName.put(Oid.FLOAT8, "float8[]");
+        oidTypeName.put(Oid.TEXT, "text[]");
+        oidTypeName.put(Oid.VARCHAR, "varchar[]");
+        oidTypeName.put(Oid.DATE, "date[]");
+        oidTypeName.put(Oid.TIMESTAMP, "timestamp[]");
+//        oidTypeName.put(Oid.TIMESTAMPTZ_ARRAY, "timestamptz[]");
+        oidTypeName.put(Oid.TIME, "time[]");
+//        oidTypeName.put(Oid.TIMETZ_ARRAY, "timetz[]");
+        oidTypeName.put(Oid.NUMERIC, "numeric[]");
+//        oidTypeName.put(Oid.UUID_ARRAY, "uuid[]");
+    }
+
+    private PostgreSQLArrayBinaryProtocolValue(){
+
+    }
+    public static final PostgreSQLArrayBinaryProtocolValue instance = new PostgreSQLArrayBinaryProtocolValue();
+
+    @Override
+    public int getColumnLength(PostgreSQLPacketPayload payload, Object value) {
+        return -1;
+    }
+
+    @Override
+    public Object read(PostgreSQLPacketPayload payload, int parameterValueLength) {
+        byte[] bytes = new byte[parameterValueLength];
+        payload.getByteBuf().readBytes(bytes);
+        ByteBuffer buf = ByteBuffer.wrap(bytes);
+        int oid = buf.getInt(8);
+        String typeName = oidTypeName.get(oid);
+        PgBinaryObj pgBinaryObj = new PgBinaryObj(bytes);
+        pgBinaryObj.setType(typeName);
+        return pgBinaryObj;
+    }
+
+    @Override
+    public void write(PostgreSQLPacketPayload payload, Object value) {
+        try {
+            byte[] result = ShardingSpherePgArrayUtils.getBinaryBytes(value,payload.getCharset());
+            payload.writeInt4(result.length);
+            payload.writeBytes(result);
+        }catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+}

database/protocol/type/postgresql/src/main/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/PostgreSQLArrayParameterDecoder.java

@@ -20,12 +20,18 @@
 import com.google.common.base.Preconditions;
 import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
 import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.postgresql.core.Parser;
 
+
+import java.lang.reflect.Array;
+import java.math.BigDecimal;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Collection;
+import java.util.*;
 import java.util.stream.Collectors;
 
+import static org.postgresql.util.internal.Nullness.castNonNull;
+
 /**
  * PostgreSQL array parameter decoder.
  */
@@ -187,4 +193,202 @@ private static String decodeElementText(final String element) {
         }
         return result;
     }
+
+
+
+    public Object decodeNumberArray(String parameterValue) {
+
+        PgDimensionsArrayList list = decodeFromString(parameterValue, ',');
+        int dims = list.dimensionsCount;
+        final int[] dimensionLengths = new int[dims];
+        dimensionLengths[0] = list.size();
+
+//            find first non-null list
+
+        for (int i = 1; i < dims; i++) {
+            List tmpList = (List) list.get(0);
+            dimensionLengths[i] = castNonNull(tmpList, "first element of adjustedList is null").size();
+            if (i != dims - 1) {
+                tmpList = (List) tmpList.get(0);
+            }
+        }
+        Object[] array = (Object[]) Array.newInstance(Number.class, dimensionLengths);
+        if (array instanceof Number[]){
+            parserNumber((Number[]) array,list);
+        }else {
+            storeStringValues(array,list,dimensionLengths,0);
+        }
+        return array;
+    }
+
+    private static void storeStringValues(Object[] array, List list, int [] dimensionLengths,
+                                                                      int dim) {
+
+        for (int i = 0; i < dimensionLengths[dim]; i++) {
+            Object element = castNonNull(list.get(i), "list.get(i)");
+            if (dim == dimensionLengths.length - 2) {
+                parserNumber((Number[]) array[i],(List) element);
+            } else {
+                storeStringValues((Object[]) array[i], (List) element, dimensionLengths, dim + 1);
+            }
+        }
+    }
+
+    private static void parserNumber(Number[] target, List source) {
+        for (int i = 0; i < target.length; i++) {
+            Object o = source.get(i);
+            if (o== null){
+                continue;
+            }
+            target[i] = parseNumber(o.toString());
+        }
+    }
+
+
+    private static Number parseNumber(String each) {
+        if (each.startsWith("\"") && each.endsWith("\"") && each.length() > 2) {
+            each = each.substring(1, each.length() - 1);
+        }
+        if (Double.toString(Double.NaN).equals(each)) {
+            return Double.NaN;
+        }
+        if (Double.toString(Double.POSITIVE_INFINITY).equals(each)) {
+            return Double.POSITIVE_INFINITY;
+        }
+        if (Double.toString(Double.NEGATIVE_INFINITY).equals(each)) {
+            return Double.POSITIVE_INFINITY;
+        }
+        return new BigDecimal(each);
+    }
+
+    static final class PgDimensionsArrayList extends ArrayList<@Nullable Object> {
+
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * How many dimensions.
+         */
+        int dimensionsCount = 1;
+
+    }
+
+    public PgDimensionsArrayList decodeFromString(String fieldString, char delim) {
+
+        final PgDimensionsArrayList arrayList = new PgDimensionsArrayList();
+
+        if (fieldString == null) {
+            return arrayList;
+        }
+
+        final char[] chars = fieldString.toCharArray();
+        StringBuilder buffer = null;
+        boolean insideString = false;
+
+        // needed for checking if NULL value occurred
+        boolean wasInsideString = false;
+
+        // array dimension arrays
+        final List<PgDimensionsArrayList> dims = new ArrayList<>();
+
+        // currently processed array
+        PgDimensionsArrayList curArray = arrayList;
+
+        // 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 =
+            }
+        }
+
+        for (int i = startOffset; i < chars.length; i++) {
+
+            // escape character that we need to skip
+            if (chars[i] == '\\') {
+                i++;
+            } else if (!insideString && chars[i] == '{') {
+                // subarray start
+                if (dims.isEmpty()) {
+                    dims.add(arrayList);
+                } else {
+                    PgDimensionsArrayList a = new PgDimensionsArrayList();
+                    PgDimensionsArrayList p = dims.get(dims.size() - 1);
+                    p.add(a);
+                    dims.add(a);
+                }
+                curArray = 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 StringBuilder();
+                continue;
+            } else if (chars[i] == '"') {
+                // quoted element
+                insideString = !insideString;
+                wasInsideString = true;
+                continue;
+            } else if (!insideString && Parser.isArrayWhiteSpace(chars[i])) {
+                // white space
+                continue;
+            } else if ((!insideString && (chars[i] == delim || chars[i] == '}')) || i == chars.length - 1) {
+                // array end or element end
+                // 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.isEmpty() || wasInsideString)) {
+                    curArray.add(!wasInsideString && "NULL".equals(b) ? null : b);
+                }
+
+                wasInsideString = false;
+                buffer = new StringBuilder();
+
+                // when end of an array
+                if (chars[i] == '}') {
+                    dims.remove(dims.size() - 1);
+
+                    // when multi-dimension
+                    if (!dims.isEmpty()) {
+                        curArray = dims.get(dims.size() - 1);
+                    }
+
+                    buffer = null;
+                }
+
+                continue;
+            }
+
+            if (buffer != null) {
+                buffer.append(chars[i]);
+            }
+        }
+        return arrayList;
+    }
 }

database/protocol/type/postgresql/src/main/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/PostgreSQLBinaryProtocolValue.java

@@ -26,6 +26,7 @@ public interface PostgreSQLBinaryProtocolValue {
 
     /**
      * Get column length.
+     * return -1 if we cant get column length quickly
      *
      * @param payload payload operation for PostgreSQL packet
      * @param value value of column