• Home
• com.clickhouse
• clickhouse-data
• 0.6.4
• source code
• ClickHouseRowBinaryProcessor.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.clickhouse.data.format.ClickHouseRowBinaryProcessor Maven / Gradle / Ivy

package com.clickhouse.data.format;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import com.clickhouse.config.ClickHouseRenameMethod;
import com.clickhouse.data.ClickHouseAggregateFunction;
import com.clickhouse.data.ClickHouseChecker;
import com.clickhouse.data.ClickHouseColumn;
import com.clickhouse.data.ClickHouseDataConfig;
import com.clickhouse.data.ClickHouseDataProcessor;
import com.clickhouse.data.ClickHouseDataType;
import com.clickhouse.data.ClickHouseDeserializer;
import com.clickhouse.data.ClickHouseFormat;
import com.clickhouse.data.ClickHouseInputStream;
import com.clickhouse.data.ClickHouseOutputStream;
import com.clickhouse.data.ClickHouseRecord;
import com.clickhouse.data.ClickHouseSerializer;
import com.clickhouse.data.ClickHouseUtils;
import com.clickhouse.data.ClickHouseValue;
import com.clickhouse.data.value.ClickHouseBitmap;
import com.clickhouse.data.value.ClickHouseBitmapValue;

/**
 * Data processor for handling {@link ClickHouseFormat#RowBinary} and
 * {@link ClickHouseFormat#RowBinaryWithNamesAndTypes} two formats.
 */
public class ClickHouseRowBinaryProcessor extends ClickHouseDataProcessor {
    public static class BitmapSerDe implements ClickHouseDeserializer, ClickHouseSerializer {
        private final ClickHouseDataType innerType;

        public BitmapSerDe(ClickHouseDataConfig config, ClickHouseColumn column) {
            this.innerType = column.getNestedColumns().get(0).getDataType();
        }

        @Override
        public ClickHouseValue deserialize(ClickHouseValue ref, ClickHouseInputStream input) throws IOException {
            return ref.update(ClickHouseBitmap.deserialize(input, innerType));
        }

        @Override
        public void serialize(ClickHouseValue value, ClickHouseOutputStream output) throws IOException {
            ClickHouseBitmapValue bitmapValue = (ClickHouseBitmapValue) value;
            output.write(bitmapValue.getValue().toBytes());
        }
    }

    public static class MapDeserializer extends ClickHouseDeserializer.CompositeDeserializer {
        private final ClickHouseValue keyValue;
        private final ClickHouseValue valValue;

        public MapDeserializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseDeserializer... deserializers) {
            super(deserializers);

            if (deserializers.length != 2) {
                throw new IllegalArgumentException("Expect 2 deserializers but got " + deserializers.length);
            }

            this.keyValue = column.getKeyInfo().newValue(config);
            this.valValue = column.getValueInfo().newValue(config);
        }

        @Override
        public ClickHouseValue deserialize(ClickHouseValue ref, ClickHouseInputStream input) throws IOException {
            int len = input.readVarInt();
            if (len == 0) {
                return ref.resetToNullOrEmpty();
            }

            Map map = new LinkedHashMap<>(len * 4 / 3 + 1);
            ClickHouseDeserializer kd = deserializers[0];
            ClickHouseDeserializer vd = deserializers[1];
            for (int i = 0; i < len; i++) {
                map.put(kd.deserialize(keyValue, input).asObject(),
                        vd.deserialize(valValue, input).asObject());
            }
            return ref.update(map);
        }
    }

    public static class MapSerializer extends ClickHouseSerializer.CompositeSerializer {
        private final ClickHouseValue keyValue;
        private final ClickHouseValue valValue;

        public MapSerializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseSerializer... serializers) {
            super(serializers);

            if (serializers.length != 2) {
                throw new IllegalArgumentException("Expect 2 serializers but got " + serializers.length);
            }

            this.keyValue = column.getKeyInfo().newValue(config);
            this.valValue = column.getValueInfo().newValue(config);
        }

        @Override
        public void serialize(ClickHouseValue value, ClickHouseOutputStream output) throws IOException {
            Map map = value.asMap();
            output.writeVarInt(map.size());
            if (!map.isEmpty()) {
                ClickHouseSerializer ks = serializers[0];
                ClickHouseSerializer vs = serializers[1];
                for (Entry e : map.entrySet()) {
                    ks.serialize(keyValue.update(e.getKey()), output);
                    vs.serialize(valValue.update(e.getValue()), output);
                }
            }
        }
    }

    public static class NestedDeserializer extends ClickHouseDeserializer.CompositeDeserializer {
        protected final ClickHouseValue[] values;

        public NestedDeserializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseDeserializer... deserializers) {
            super(deserializers);

            List nestedCols = column.getNestedColumns();
            int len = nestedCols.size();
            if (deserializers.length != len) {
                throw new IllegalArgumentException(
                        ClickHouseUtils.format("Expect %d deserializers but got %d", len, deserializers.length));
            }
            values = new ClickHouseValue[len];
            for (int i = 0; i < len; i++) {
                values[i] = nestedCols.get(i).newValue(config);
            }
        }

        @Override
        public ClickHouseValue deserialize(ClickHouseValue ref, ClickHouseInputStream input) throws IOException {
            int size = input.readVarInt();
            int len = values.length;
            Object[][] vals = new Object[size][];
            for (int i = 0; i < size; i++) {
                Object[] objs = new Object[len];
                for (int j = 0; j < len; j++) {
                    ClickHouseDeserializer d = deserializers[j];
                    objs[j] = d.deserialize(values[j], input).asObject();
                }
                vals[i] = objs;
            }
            // ClickHouseNestedValue.of(r, c.getNestedColumns(), values)
            return ref.update(vals);
        }
    }

    public static class NestedSerializer extends ClickHouseSerializer.CompositeSerializer {
        private final ClickHouseValue[] values;

        public NestedSerializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseSerializer... serializers) {
            super(serializers);

            List nestedCols = column.getNestedColumns();
            int len = nestedCols.size();
            if (serializers.length != len) {
                throw new IllegalArgumentException(
                        ClickHouseUtils.format("Expect %d serializers but got %d", len, serializers.length));
            }
            values = new ClickHouseValue[len];
            for (int i = 0; i < len; i++) {
                values[i] = nestedCols.get(i).newValue(config);
            }
        }

        @Override
        public void serialize(ClickHouseValue value, ClickHouseOutputStream output) throws IOException {
            Object[][] vals = (Object[][]) value.asObject();
            int size = vals.length;
            int len = values.length;
            output.writeVarInt(size);
            for (int i = 0; i < size; i++) {
                Object[] objs = vals[i];
                for (int j = 0; j < len; j++) {
                    serializers[j].serialize(values[j].update(objs[j]), output);
                }
            }
        }
    }

    public static class TupleDeserializer extends ClickHouseDeserializer.CompositeDeserializer {
        private final ClickHouseValue[] values;

        public TupleDeserializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseDeserializer... deserializers) {
            super(deserializers);

            List nestedCols = column.getNestedColumns();
            int len = nestedCols.size();
            if (deserializers.length != len) {
                throw new IllegalArgumentException(
                        ClickHouseUtils.format("Expect %d deserializers but got %d", len, deserializers.length));
            }
            values = new ClickHouseValue[len];
            for (int i = 0; i < len; i++) {
                values[i] = nestedCols.get(i).newValue(config);
            }
        }

        @Override
        public ClickHouseValue deserialize(ClickHouseValue ref, ClickHouseInputStream input) throws IOException {
            int len = values.length;
            Object[] tupleValues = new Object[len];
            for (int i = 0; i < len; i++) {
                tupleValues[i] = deserializers[i].deserialize(values[i], input).asObject();
            }
            return ref.update(tupleValues);
        }
    }

    public static class TupleSerializer extends ClickHouseSerializer.CompositeSerializer {
        private final ClickHouseValue[] values;

        public TupleSerializer(ClickHouseDataConfig config, ClickHouseColumn column,
                ClickHouseSerializer... serializers) {
            super(serializers);

            List nestedCols = column.getNestedColumns();
            int len = nestedCols.size();
            if (serializers.length != len) {
                throw new IllegalArgumentException(
                        ClickHouseUtils.format("Expect %d serializers but got %d", len, serializers.length));
            }
            values = new ClickHouseValue[len];
            for (int i = 0; i < len; i++) {
                values[i] = nestedCols.get(i).newValue(config);
            }
        }

        @Override
        public void serialize(ClickHouseValue value, ClickHouseOutputStream output) throws IOException {
            List