Merge pull request #1856 from ClickHouse/v2_numbers_conversion

[client-v2] fixed number conversion in reader

Author: chernser

client-v2/src/main/java/com/clickhouse/client/api/data_formats/internal/AbstractBinaryFormatReader.java

@@ -2,6 +2,7 @@
 
 import com.clickhouse.client.api.ClientException;
 import com.clickhouse.client.api.data_formats.ClickHouseBinaryFormatReader;
+import com.clickhouse.client.api.internal.SerializerUtils;
 import com.clickhouse.client.api.metadata.TableSchema;
 import com.clickhouse.client.api.query.NullValueException;
 import com.clickhouse.client.api.query.POJOSetter;
@@ -37,6 +38,7 @@
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
 
 public abstract class AbstractBinaryFormatReader implements ClickHouseBinaryFormatReader {
 
@@ -52,6 +54,8 @@ public abstract class AbstractBinaryFormatReader implements ClickHouseBinaryForm
 
     private ClickHouseColumn[] columns;
 
+    private Map[] convertions;
+
     private volatile boolean hasNext = true;
 
 
@@ -61,14 +65,16 @@ protected AbstractBinaryFormatReader(InputStream inputStream, QuerySettings quer
                                          BinaryStreamReader.ByteBufferAllocator byteBufferAllocator) {
         this.input = inputStream;
         this.settings = querySettings == null ? Collections.emptyMap() : new HashMap<>(querySettings.getAllSettings());
-        boolean useServerTimeZone = (boolean) this.settings.get(ClickHouseClientOption.USE_SERVER_TIME_ZONE.getKey());
-        TimeZone timeZone = useServerTimeZone ? querySettings.getServerTimeZone() :
+        Boolean useServerTimeZone = (Boolean) this.settings.get(ClickHouseClientOption.USE_SERVER_TIME_ZONE.getKey());
+        TimeZone timeZone = useServerTimeZone == Boolean.TRUE && querySettings != null ? querySettings.getServerTimeZone() :
                 (TimeZone) this.settings.get(ClickHouseClientOption.USE_TIME_ZONE.getKey());
         if (timeZone == null) {
             throw new ClientException("Time zone is not set. (useServerTimezone:" + useServerTimeZone + ")");
         }
         this.binaryStreamReader = new BinaryStreamReader(inputStream, timeZone, LOG, byteBufferAllocator);
-        setSchema(schema);
+        if (schema != null) {
+            setSchema(schema);
+        }
     }
 
     protected Map<String, Object> currentRecord = new ConcurrentHashMap<>();
@@ -219,9 +225,49 @@ protected void endReached() {
 
     protected void setSchema(TableSchema schema) {
         this.schema = schema;
-        if (schema != null) {
-            columns = schema.getColumns().toArray(new ClickHouseColumn[0]);
+        this.columns = schema.getColumns().toArray(new ClickHouseColumn[0]);
+        this.convertions = new Map[columns.length];
+
+        for (int i = 0; i < columns.length; i++) {
+            ClickHouseColumn column = columns[i];
+
+            Map<NumberType, Function<Number, ?>> converters = new HashMap<>();
+            switch (column.getDataType()) {
+                case Int8:
+                case Int16:
+                case UInt8:
+                case Int32:
+                case UInt16:
+                case Int64:
+                case UInt32:
+                case Int128:
+                case UInt64:
+                case Int256:
+                case UInt128:
+                case UInt256:
+                case Float32:
+                case Float64:
+                case Decimal:
+                case Decimal32:
+                case Decimal64:
+                case Decimal128:
+                case Decimal256:
+                case Bool:
+                    converters.put(NumberType.Byte, SerializerUtils.NumberConverter::toByte);
+                    converters.put(NumberType.Short, SerializerUtils.NumberConverter::toShort);
+                    converters.put(NumberType.Int, SerializerUtils.NumberConverter::toInt);
+                    converters.put(NumberType.Long, SerializerUtils.NumberConverter::toLong);
+                    converters.put(NumberType.BigInteger, SerializerUtils.NumberConverter::toBigInteger);
+                    converters.put(NumberType.BigDecimal, SerializerUtils.NumberConverter::toBigDecimal);
+                    converters.put(NumberType.Float, SerializerUtils.NumberConverter::toFloat);
+                    converters.put(NumberType.Double, SerializerUtils.NumberConverter::toDouble);
+                    converters.put(NumberType.Boolean, SerializerUtils::convertToBoolean);
+                    break;
+            }
+
+            this.convertions[i] = converters;
         }
+
     }
 
     @Override
@@ -252,65 +298,65 @@ public String getString(int index) {
         return value.toString();
     }
 
-    private <T> T readPrimitiveValue(String colName, String typeName) {
-        Object value = readValue(colName);
-        if (value == null) {
-            throw new NullValueException("Column '" + colName + "' has null value and it cannot be cast to " + typeName);
-        }
-        return (T) value;
-    }
-
-    private <T> T readPrimitiveValue(int colIndex, String typeName) {
-        Object value = readValue(colIndex);
-        if (value == null) {
-            throw new NullValueException("Column at index = " + colIndex + " has null value and it cannot be cast to " + typeName);
+    private <T> T readNumberValue(String colName, NumberType targetType) {
+        int colIndex = schema.nameToIndex(colName);
+        Function<Number, Number> converter = (Function<Number, Number>) convertions[colIndex].get(targetType);
+        if (converter != null) {
+            Number value = readValue(colName);
+            if (value == null) {
+                throw new NullValueException("Column " + colName + " has null value and it cannot be cast to " +
+                        targetType.getTypeName());
+            }
+            return (T) converter.apply(value);
+        } else {
+            throw new ClientException("Column " + colName + " " + columns[colIndex].getDataType().name() +
+                    " cannot be converted to " + targetType.getTypeName());
         }
-        return (T) value;
     }
 
     @Override
     public byte getByte(String colName) {
-        return readPrimitiveValue(colName, "byte");
+        return readNumberValue(colName, NumberType.Byte);
     }
 
     @Override
     public short getShort(String colName) {
-        return readPrimitiveValue(colName, "short");
+        return readNumberValue(colName, NumberType.Short);
     }
 
     @Override
     public int getInteger(String colName) {
-        return readPrimitiveValue(colName, "int");
+        return readNumberValue(colName, NumberType.Int);
     }
 
     @Override
     public long getLong(String colName) {
-        return readPrimitiveValue(colName, "long");
+        return readNumberValue(colName, NumberType.Long);
     }
 
     @Override
     public float getFloat(String colName) {
-        return readPrimitiveValue(colName, "float");
+        return readNumberValue(colName, NumberType.Float);
     }
 
     @Override
     public double getDouble(String colName) {
-        return readPrimitiveValue(colName, "double");
+        return readNumberValue(colName, NumberType.Double);
     }
 
     @Override
     public boolean getBoolean(String colName) {
-        return readPrimitiveValue(colName, "boolean");
+        return readNumberValue(colName, NumberType.Boolean);
     }
 
     @Override
     public BigInteger getBigInteger(String colName) {
-        return readValue(colName);
+        return readNumberValue(colName, NumberType.BigInteger);
     }
 
     @Override
     public BigDecimal getBigDecimal(String colName) {
-        return readValue(colName);
+        return readNumberValue(colName, NumberType.BigDecimal);
     }
 
     @Override
@@ -471,47 +517,47 @@ public boolean hasValue(String colName) {
 
     @Override
     public byte getByte(int index) {
-        return readPrimitiveValue(index, "byte");
+        return getByte(schema.indexToName(index - 1 ));
     }
 
     @Override
     public short getShort(int index) {
-        return readPrimitiveValue(index, "short");
+        return getShort(schema.indexToName(index - 1));
     }
 
     @Override
     public int getInteger(int index) {
-        return readPrimitiveValue(index, "int");
+        return getInteger(schema.indexToName(index - 1));
     }
 
     @Override
     public long getLong(int index) {
-        return readPrimitiveValue(index, "long");
+        return getLong(schema.indexToName(index - 1));
     }
 
     @Override
     public float getFloat(int index) {
-        return readPrimitiveValue(index, "float");
+        return getFloat(schema.indexToName(index - 1));
     }
 
     @Override
     public double getDouble(int index) {
-        return readPrimitiveValue(index, "double");
+        return getDouble(schema.indexToName(index - 1));
     }
 
     @Override
     public boolean getBoolean(int index) {
-        return readPrimitiveValue(index, "boolean");
+        return getBoolean(schema.indexToName(index - 1));
     }
 
     @Override
     public BigInteger getBigInteger(int index) {
-        return readValue(index);
+        return getBigInteger(schema.indexToName(index - 1));
     }
 
     @Override
     public BigDecimal getBigDecimal(int index) {
-        return readValue(index);
+        return getBigDecimal(schema.indexToName(index - 1));
     }
 
     @Override
@@ -665,4 +711,19 @@ public LocalDateTime getLocalDateTime(int index) {
     public void close() throws Exception {
         input.close();
     }
+
+    private enum NumberType {
+        Byte("byte"), Short("short"), Int("int"), Long("long"), BigInteger("BigInteger"), Float("float"),
+        Double("double"), BigDecimal("BigDecimal"), Boolean("boolean");
+
+        private final String typeName;
+
+        NumberType(String typeName) {
+            this.typeName = typeName;
+        }
+
+        public String getTypeName() {
+            return typeName;
+        }
+    }
 }

client-v2/src/main/java/com/clickhouse/client/api/internal/SerializerUtils.java

@@ -259,6 +259,18 @@ public static BigInteger convertToBigInteger(Object value) {
         }
     }
 
+    public static BigDecimal convertToBigDecimal(Object value) {
+        if (value instanceof BigInteger) {
+            return new BigDecimal((BigInteger) value);
+        } else if (value instanceof Number) {
+            return BigDecimal.valueOf(((Number) value).doubleValue());
+        } else if (value instanceof String) {
+            return new BigDecimal((String) value);
+        } else {
+            throw new IllegalArgumentException("Cannot convert " + value + " to BigDecimal");
+        }
+    }
+
     public static String convertToString(Object value) {
         return java.lang.String.valueOf(value);
     }
@@ -271,11 +283,19 @@ public static <T extends Enum<T>> Set<T> parseEnumList(String value, Class<T> en
         return values;
     }
 
+    public static boolean numberToBoolean(Number value) {
+        return value.doubleValue() != 0;
+    }
+
     public static boolean convertToBoolean(Object value) {
         if (value instanceof Boolean) {
             return (Boolean) value;
+        } else if (value instanceof BigInteger) {
+            return ((BigInteger) value).compareTo(BigInteger.ZERO) != 0;
+        } else if (value instanceof BigDecimal) {
+            return ((BigDecimal) value).compareTo(BigDecimal.ZERO) != 0;
         } else if (value instanceof Number) {
-            return ((Number) value).intValue() != 0;
+            return ((Number) value).longValue() != 0;
         } else if (value instanceof String) {
             return Boolean.parseBoolean((String) value);
         } else {
@@ -527,4 +547,76 @@ public Class<?> defineClass(String name, byte[] code) throws ClassNotFoundExcept
             return super.defineClass(name, code, 0, code.length);
         }
     }
+
+    public static class NumberConverter {
+
+        public static byte toByte(Number value) {
+            if (value.byteValue() == value.shortValue()) {
+                return value.byteValue();
+            } else {
+                throw new ArithmeticException("integer overflow: " + value + " cannot be presented as byte");
+            }
+        }
+
+        public static short toShort(Number value) {
+            if (value.shortValue() == value.intValue()) {
+                return value.shortValue();
+            } else {
+                throw new ArithmeticException("integer overflow: " + value + " cannot be presented as short");
+            }
+        }
+
+        public static int toInt(Number value) {
+            if (value.intValue() == value.longValue()) {
+                return value.intValue();
+            } else {
+                throw new ArithmeticException("integer overflow: " + value + " cannot be presented as int");
+            }
+        }
+
+        public static long toLong(Number value) {
+            if (value.longValue() == value.doubleValue()) {
+                return value.longValue();
+            } else {
+                throw new ArithmeticException("integer overflow: " + value + " cannot be presented as long");
+            }
+        }
+
+
+        public static BigInteger toBigInteger(Number value) {
+            return value instanceof BigInteger ? (BigInteger) value : BigInteger.valueOf(value.longValue());
+        }
+
+        public static BigInteger toBigInteger(String value) {
+            return new BigInteger(value);
+        }
+
+        public static float toFloat(Number value) {
+            if (value instanceof Float) {
+                return (Float) value;
+            } else if (value.floatValue() == value.doubleValue()) {
+                return value.floatValue();
+            } else {
+                throw new ArithmeticException("float overflow: " + value + " cannot be presented as float");
+            }
+        }
+
+        public static double toDouble(Number value) {
+            if (value instanceof Double) {
+                return (Double) value;
+            } else if (value.doubleValue() == value.floatValue()) {
+                return value.doubleValue();
+            } else {
+                throw new ArithmeticException("double overflow: " + value + " cannot be presented as double");
+            }
+        }
+
+        public static BigDecimal toBigDecimal(Number value) {
+            return value instanceof BigDecimal ? (BigDecimal) value : BigDecimal.valueOf(value.doubleValue());
+        }
+
+        public static BigDecimal toBigDecimal(String value) {
+            return new BigDecimal(value);
+        }
+    }
 }

client-v2/src/main/java/com/clickhouse/client/api/query/QuerySettings.java

@@ -152,7 +152,7 @@ public QuerySettings setUseTimeZone(String timeZone) {
             throw new ValidationUtils.SettingsValidationException("use_time_zone",
                     "Cannot set both use_time_zone and use_server_time_zone");
         }
-        rawSettings.put("use_time_zone", timeZone);
+        rawSettings.put("use_time_zone", TimeZone.getTimeZone(timeZone));
         return this;
     }