HBase和Phoenix的类型转换

最新推荐文章于 2024-09-01 13:12:54 发布
原创 最新推荐文章于 2024-09-01 13:12:54 发布 · 6k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

在Phoenix中字段的类型所保存的byte数组和HBase中用Bytes工具了转换的byte数组可能会对不上，比如Bytes.toBytes(1)的结果和Phoenix中定义为INTEGER类的byte[]就不一样。因为Phoenix中的INTEGER是带符号的，要用无符号的话需要定义UNSIGNED_INT类型，UNSIGENT_INT类型的byte[]值和Bytes.toBytes(1)是一样的，但是UNSIGENT_INT无法存负数。

所以如果直接定义INTEGER类型的话是不能直接简单地用Bytes.toBytes来转换得到的，由于这种情况的存在就不能直接操作HBase然后直接在Phoenix查看，反之亦然。

所一这里定义了一套将byte数组转换为Phoenix可以用的方法，具体准换的代码是从Phoenix的core包中抠出来的。

先定义一个类型枚举类：

/**
 * Phoenix中的类型
 */
public enum PhType {
    DEFAULT(-1, "DEFAULT"),
    UNSIGNED_INT(4, "UNSIGNED_INT"),
    UNSIGNED_BIGINT(8, "UNSIGNED_BIGINT"),
    UNSIGNED_TINYINT(1, "UNSIGNED_TINYINT"),
    UNSIGNED_SMAILLINT(2, "UNSIGNED_SMAILLINT"),
    UNSIGNED_FLOAT(4, "UNSIGNED_FLOAT"),
    UNSIGNED_DOUBLE(8, "UNSIGNED_DOUBLE"),
    INTEGER(4, "INTEGER"),
    BIGINT(8, "BIGINT"),
    TINYINT(1, "TINYINT"),
    SMAILLINT(2, "SMAILLINT"),
    FLOAT(4, "FLOAT"),
    DOUBLE(8, "DOUBLE"),
    DECIMAL(-1, "DECIMAL"),
    BOOLEAN(1, "BOOLEAN"),
    TIME(8, "TIME"),                       //对应Phoenix的UNSIGNED_TIME
    DATE(8, "DATE"),                       //对应Phoenix的UNSIGNED_DATE
    TIMESTAMP(12, "TIMESTAMP"),            //对应Phoenix的UNSIGNED_TIMESTAMP
    VARCHAR(-1, "VARCHAR"),
    VARBINARY(-1, "VARBINARY");

    /**
     * -1：长度可变
     */
    private int len;
    private String type;

    PhType(int len, String type) {
        this.len = len;
        this.type = type;
    }

    public int getLen() {
        return len;
    }

    public String getType() {
        return this.type;
    }

    public static PhType getType(String type) {
        if (type == null) return DEFAULT;
        PhType phType;
        if (type.equalsIgnoreCase(UNSIGNED_INT.type)) {
            phType = UNSIGNED_INT;
        } else if (type.equalsIgnoreCase(UNSIGNED_BIGINT.type)) {
            phType = UNSIGNED_BIGINT;
        } else if (type.equalsIgnoreCase(UNSIGNED_TINYINT.type)) {
            phType = UNSIGNED_TINYINT;
        } else if (type.equalsIgnoreCase(UNSIGNED_SMAILLINT.type)) {
            phType = UNSIGNED_SMAILLINT;
        } else if (type.equalsIgnoreCase(UNSIGNED_FLOAT.type)) {
            phType = UNSIGNED_FLOAT;
        } else if (type.equalsIgnoreCase(UNSIGNED_DOUBLE.type)) {
            phType = UNSIGNED_DOUBLE;
        } else if (type.equalsIgnoreCase(INTEGER.type)) {
            phType = INTEGER;
        } else if (type.equalsIgnoreCase(BIGINT.type)) {
            phType = BIGINT;
        } else if (type.equalsIgnoreCase(TINYINT.type)) {
            phType = TINYINT;
        } else if (type.equalsIgnoreCase(SMAILLINT.type)) {
            phType = SMAILLINT;
        } else if (type.equalsIgnoreCase(FLOAT.type)) {
            phType = FLOAT;
        } else if (type.equalsIgnoreCase(DOUBLE.type)) {
            phType = DOUBLE;
        } else if (type.equalsIgnoreCase(BOOLEAN.type)) {
            phType = BOOLEAN;
        } else if (type.equalsIgnoreCase(TIME.type)) {
            phType = TIME;
        } else if (type.equalsIgnoreCase(DATE.type)) {
            phType = DATE;
        } else if (type.equalsIgnoreCase(TIMESTAMP.type)) {
            phType = TIMESTAMP;
        } else if (type.equalsIgnoreCase(VARCHAR.type)) {
            phType = VARCHAR;
        } else if (type.equalsIgnoreCase(VARBINARY.type)) {
            phType = VARBINARY;
        } else if (type.equalsIgnoreCase(DECIMAL.type)) {
            phType = DECIMAL;
        } else {
            phType = DEFAULT;
        }
        return phType;
    }
}

然后编写对以上枚举中所有类型的转换：

import com.google.common.math.LongMath;
import org.apache.hadoop.hbase.util.Bytes;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 针对Phoenix的类型转换
 */
public class PhTypeUtil {
    private static String dateFormatPattern = "yyyy-MM-dd";
    private static String timeFormatPattern = "HH:mm:ss";
    private static String datetimeFormatPattern = "yyyy-MM-dd HH:mm:ss";
    private static String timestampFormatPattern = "yyyy-MM-dd HH:mm:ss.SSS";

    public static byte[] toBytes(Object v, PhType phType) {
        if (v == null) return null;
        byte[] b = null;
        if (phType == PhType.INTEGER) {
            b = new byte[Bytes.SIZEOF_INT];
            encodeInt(((Number) v).intValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_INT) {
            b = new byte[Bytes.SIZEOF_INT];
            encodeUnsignedInt(((Number) v).intValue(), b, 0);
        } else if (phType == PhType.BIGINT) {
            b = new byte[Bytes.SIZEOF_LONG];
            encodeLong(((Number) v).longValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_BIGINT) {
            b = new byte[Bytes.SIZEOF_LONG];
            encodeUnsignedLong(((Number) v).longValue(), b, 0);
        } else if (phType == PhType.SMAILLINT) {
            b = new byte[Bytes.SIZEOF_SHORT];
            encodeShort(((Number) v).shortValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_SMAILLINT) {
            b = new byte[Bytes.SIZEOF_SHORT];
            encodeUnsignedShort(((Number) v).shortValue(), b, 0);
        } else if (phType == PhType.TINYINT) {
            b = new byte[Bytes.SIZEOF_BYTE];
            encodeByte(((Number) v).byteValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_TINYINT) {
            b = new byte[Bytes.SIZEOF_BYTE];
            encodeUnsignedByte(((Number) v).byteValue(), b, 0);
        } else if (phType == PhType.FLOAT) {
            b = new byte[Bytes.SIZEOF_FLOAT];
            encodeFloat(((Number) v).floatValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_FLOAT) {
            b = new byte[Bytes.SIZEOF_FLOAT];
            encodeUnsignedFloat(((Number) v).floatValue(), b, 0);
        } else if (phType == PhType.DOUBLE) {
            b = new byte[Bytes.SIZEOF_DOUBLE];
            encodeDouble(((Number) v).doubleValue(), b, 0);
        } else if (phType == PhType.UNSIGNED_DOUBLE) {
            b = new byte[Bytes.SIZEOF_DOUBLE];
            encodeUnsignedDouble(((Number) v).doubleValue(), b, 0);
        } else if (phType == PhType.BOOLEAN) {
            if ((Boolean) v) {
                b = new byte[]{1};
            } else {
                b = new byte[]{0};
            }
        } else if (phType == PhType.TIME || phType == PhType.DATE) {
            b = new byte[Bytes.SIZEOF_LONG];
            encodeDate(v, b, 0);
        } else if (phType == PhType.TIMESTAMP) {
            b = new byte[Bytes.SIZEOF_LONG + Bytes.SIZEOF_INT];
            encodeTimestamp(v, b, 0);
        } else if (phType == PhType.VARBINARY) {
            b = (byte[]) v;
        } else if (phType == PhType.VARCHAR || phType == PhType.DEFAULT) {
            b = Bytes.toBytes(v.toString());
        } else if (phType == PhType.DECIMAL) {
            b = encodeDecimal(v);
        }
        return b;
    }

    public static Object toObject(byte[] b, PhType phType) {
        if (b == null) return null;
        Object v = null;
        if (phType == PhType.INTEGER) {
            v = decodeInt(b, 0);
        } else if (phType == PhType.UNSIGNED_INT) {
            v = decodeUnsignedInt(b, 0);
        } else if (phType == PhType.BIGINT) {
            v = decodeLong(b, 0);
        } else if (phType == PhType.UNSIGNED_BIGINT) {
            v = decodeUnsignedLong(b, 0);
        } else if (phType == PhType.SMAILLINT) {
            v = decodeShort(b, 0);
        } else if (phType == PhType.UNSIGNED_SMAILLINT) {
            v = decodeUnsignedShort(b, 0);
        } else if (phType == PhType.TINYINT) {
            v = decodeByte(b, 0);
        } else if (phType == PhType.UNSIGNED_TINYINT) {
            v = decodeUnsignedByte(b, 0);
        } else if (phType == PhType.FLOAT) {
            v = decodeFloat(b, 0);
        } else if (phType == PhType.UNSIGNED_FLOAT) {
            v = decodeUnsignedFloat(b, 0);
        } else if (phType == PhType.DOUBLE) {
            v = decodeDouble(b, 0);
        } else if (phType == PhType.UNSIGNED_DOUBLE) {
            v = decodeUnsignedDouble(b, 0);
        } else if (phType == PhType.BOOLEAN) {
            checkForSufficientLength(b, 0, Bytes.SIZEOF_BOOLEAN);
            if (b[0] == 1) {
                v = true;
            } else if (b[0] == 0) {
                v = false;
            }
        } else if (phType == PhType.TIME || phType == PhType.DATE) {
            v = new Date(decodeUnsignedLong(b, 0));
        } else if (phType == PhType.TIMESTAMP) {
            long millisDeserialized = decodeUnsignedLong(b, 0);
            Timestamp ts = new Timestamp(millisDeserialized);
            int nanosDeserialized = decodeUnsignedInt(b, Bytes.SIZEOF_LONG);
            ts.setNanos(nanosDeserialized < 1000000 ? ts.getNanos() + nanosDeserialized : nanosDeserialized);
            v = ts;
        } else if (phType == PhType.VARBINARY) {
            v = b;
        } else if (phType == PhType.VARCHAR || phType == PhType.DEFAULT) {
            v = Bytes.toString(b);
        } else if (phType == PhType.DECIMAL) {
            v = decodeDecimal(b, 0, b.length);
        }

        return v;
    }


    public static int decodeInt(byte[] bytes, int o) {
        checkForSufficientLength(bytes, o, Bytes.SIZEOF_INT);
        int v;
        v = bytes[o] ^ 0x80; // Flip sign bit back
        for (int i = 1; i < Bytes.SIZEOF_INT; i++) {
            v = (v << 8) + (bytes[o + i] & 0xff);
        }
        return v;
    }

    public static int encodeInt(int v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_INT);
        b[o + 0] = (byte) ((v >> 24) ^ 0x80); // Flip sign bit so that INTEGER is binary comparable
        b[o + 1] = (byte) (v >> 16);
        b[o + 2] = (byte) (v >> 8);
        b[o + 3] = (byte) v;
        return Bytes.SIZEOF_INT;
    }

    public static int decodeUnsignedInt(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_INT);

        int v = Bytes.toInt(b, o);
        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedInt(int v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_INT);
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putInt(b, o, v);
        return Bytes.SIZEOF_INT;
    }

    public static long decodeLong(byte[] bytes, int o) {
        checkForSufficientLength(bytes, o, Bytes.SIZEOF_LONG);
        long v;
        byte b = bytes[o];
        v = b ^ 0x80; // Flip sign bit back
        for (int i = 1; i < Bytes.SIZEOF_LONG; i++) {
            b = bytes[o + i];
            v = (v << 8) + (b & 0xff);
        }
        return v;
    }

    public static int encodeLong(long v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_LONG);
        b[o + 0] = (byte) ((v >> 56) ^ 0x80); // Flip sign bit so that INTEGER is binary comparable
        b[o + 1] = (byte) (v >> 48);
        b[o + 2] = (byte) (v >> 40);
        b[o + 3] = (byte) (v >> 32);
        b[o + 4] = (byte) (v >> 24);
        b[o + 5] = (byte) (v >> 16);
        b[o + 6] = (byte) (v >> 8);
        b[o + 7] = (byte) v;
        return Bytes.SIZEOF_LONG;
    }

    public static long decodeUnsignedLong(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_LONG);
        long v = 0;
        for (int i = o; i < o + Bytes.SIZEOF_LONG; i++) {
            v <<= 8;
            v ^= b[i] & 0xFF;
        }

        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedLong(long v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_LONG);
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putLong(b, o, v);
        return Bytes.SIZEOF_LONG;
    }

    public static short decodeShort(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_SHORT);
        int v;
        v = b[o] ^ 0x80; // Flip sign bit back
        for (int i = 1; i < Bytes.SIZEOF_SHORT; i++) {
            v = (v << 8) + (b[o + i] & 0xff);
        }
        return (short) v;
    }

    public static int encodeShort(short v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_SHORT);
        b[o + 0] = (byte) ((v >> 8) ^ 0x80); // Flip sign bit so that Short is binary comparable
        b[o + 1] = (byte) v;
        return Bytes.SIZEOF_SHORT;
    }

    public static short decodeUnsignedShort(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_SHORT);
        short v = Bytes.toShort(b, o);
        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedShort(short v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_SHORT);
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putShort(b, o, v);
        return Bytes.SIZEOF_SHORT;
    }

    public static byte decodeByte(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_BYTE);
        int v;
        v = b[o] ^ 0x80; // Flip sign bit back
        return (byte) v;
    }

    public static int encodeByte(byte v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_BYTE);
        b[o] = (byte) (v ^ 0x80); // Flip sign bit so that Short is binary comparable
        return Bytes.SIZEOF_BYTE;
    }

    public static byte decodeUnsignedByte(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_BYTE);
        byte v = b[o];
        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedByte(byte v, byte[] b, int o) {
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putByte(b, o, v);
        return Bytes.SIZEOF_BYTE;
    }

    public static float decodeFloat(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_INT);
        int value;
        value = Bytes.toInt(b, o);
        value--;
        value ^= (~value >> Integer.SIZE - 1) | Integer.MIN_VALUE;
        return Float.intBitsToFloat(value);
    }


    public static int encodeFloat(float v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_FLOAT);
        int i = Float.floatToIntBits(v);
        i = (i ^ ((i >> Integer.SIZE - 1) | Integer.MIN_VALUE)) + 1;
        Bytes.putInt(b, o, i);
        return Bytes.SIZEOF_FLOAT;
    }

    public static float decodeUnsignedFloat(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_FLOAT);
        float v = Bytes.toFloat(b, o);
        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedFloat(float v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_FLOAT);
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putFloat(b, o, v);
        return Bytes.SIZEOF_FLOAT;
    }

    public static double decodeDouble(byte[] bytes, int o) {
        checkForSufficientLength(bytes, o, Bytes.SIZEOF_LONG);
        long l;
        l = Bytes.toLong(bytes, o);
        l--;
        l ^= (~l >> Long.SIZE - 1) | Long.MIN_VALUE;
        return Double.longBitsToDouble(l);
    }


    public static int encodeDouble(double v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_LONG);
        long l = Double.doubleToLongBits(v);
        l = (l ^ ((l >> Long.SIZE - 1) | Long.MIN_VALUE)) + 1;
        Bytes.putLong(b, o, l);
        return Bytes.SIZEOF_LONG;
    }

    public static double decodeUnsignedDouble(byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_DOUBLE);
        double v = Bytes.toDouble(b, o);
        if (v < 0) {
            throw new RuntimeException();
        }
        return v;
    }

    public static int encodeUnsignedDouble(double v, byte[] b, int o) {
        checkForSufficientLength(b, o, Bytes.SIZEOF_DOUBLE);
        if (v < 0) {
            throw new RuntimeException();
        }
        Bytes.putDouble(b, o, v);
        return Bytes.SIZEOF_DOUBLE;
    }

    public static int encodeDate(Object v, byte[] b, int o) {
        if (v instanceof Date) {
            encodeUnsignedLong(((Date) v).getTime(), b, 0);
        } else if (v instanceof String) {
            String dateStr = (String) v;
            int len = dateStr.length();
            Date date = null;
            try {
                if (len == 10 && dateStr.charAt(4) == '-' && dateStr.charAt(7) == '-') {
                    SimpleDateFormat format = new SimpleDateFormat(dateFormatPattern);
                    date = format.parse(dateStr);
                } else if (len == 8 && dateStr.charAt(2) == ':' && dateStr.charAt(5) == ':') {
                    SimpleDateFormat format = new SimpleDateFormat(timeFormatPattern);
                    date = format.parse(dateStr);
                } else if (len == 19 && dateStr.charAt(4) == '-' && dateStr.charAt(7) == '-'
                        && dateStr.charAt(13) == ':' && dateStr.charAt(16) == ':') {
                    SimpleDateFormat format = new SimpleDateFormat(datetimeFormatPattern);
                    date = format.parse(dateStr);
                } else if (len == 23 && dateStr.charAt(4) == '-' && dateStr.charAt(7) == '-'
                        && dateStr.charAt(13) == ':' && dateStr.charAt(16) == ':'
                        && dateStr.charAt(19) == '.') {
                    SimpleDateFormat format = new SimpleDateFormat(timestampFormatPattern);
                    date = format.parse(dateStr);
                }
                if (date != null) {
                    encodeUnsignedLong(date.getTime(), b, 0);
                }
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
        }
        return Bytes.SIZEOF_LONG;
    }

    public static int encodeTimestamp(Object v, byte[] b, int o) {
        if (v instanceof Timestamp) {
            Timestamp ts = (Timestamp) v;
            encodeUnsignedLong(ts.getTime(), b, o);
            Bytes.putInt(b, Bytes.SIZEOF_LONG, ts.getNanos() % 1000000);
        } else {
            encodeDate(v, b, o);
        }
        return Bytes.SIZEOF_LONG + Bytes.SIZEOF_INT;
    }

    public static byte[] encodeDecimal(Object object) {
        if (object == null) {
            return new byte[0];
        }
        BigDecimal v = (BigDecimal) object;
        v = v.round(DEFAULT_MATH_CONTEXT).stripTrailingZeros();
        int len = getLength(v);
        byte[] result = new byte[Math.min(len, 21)];
        decimalToBytes(v, result, 0, len);
        return result;
    }


    public static BigDecimal decodeDecimal(byte[] bytes, int offset, int length) {
        if (length == 1 && bytes[offset] == ZERO_BYTE) {
            return BigDecimal.ZERO;
        }
        int signum = ((bytes[offset] & 0x80) == 0) ? -1 : 1;
        int scale;
        int index;
        int digitOffset;
        long multiplier = 100L;
        int begIndex = offset + 1;
        if (signum == 1) {
            scale = (byte) (((bytes[offset] & 0x7F) - 65) * -2);
            index = offset + length;
            digitOffset = POS_DIGIT_OFFSET;
        } else {
            scale = (byte) ((~bytes[offset] - 65 - 128) * -2);
            index = offset + length - (bytes[offset + length - 1] == NEG_TERMINAL_BYTE ? 1 : 0);
            digitOffset = -NEG_DIGIT_OFFSET;
        }
        length = index - offset;
        long l = signum * bytes[--index] - digitOffset;
        if (l % 10 == 0) { // trailing zero
            scale--; // drop trailing zero and compensate in the scale
            l /= 10;
            multiplier = 10;
        }
        // Use long arithmetic for as long as we can
        while (index > begIndex) {
            if (l >= MAX_LONG_FOR_DESERIALIZE || multiplier >= Long.MAX_VALUE / 100) {
                multiplier = LongMath.divide(multiplier, 100L, RoundingMode.UNNECESSARY);
                break; // Exit loop early so we don't overflow our multiplier
            }
            int digit100 = signum * bytes[--index] - digitOffset;
            l += digit100 * multiplier;
            multiplier = LongMath.checkedMultiply(multiplier, 100);
        }

        BigInteger bi;
        // If still more digits, switch to BigInteger arithmetic
        if (index > begIndex) {
            bi = BigInteger.valueOf(l);
            BigInteger biMultiplier = BigInteger.valueOf(multiplier).multiply(ONE_HUNDRED);
            do {
                int digit100 = signum * bytes[--index] - digitOffset;
                bi = bi.add(biMultiplier.multiply(BigInteger.valueOf(digit100)));
                biMultiplier = biMultiplier.multiply(ONE_HUNDRED);
            } while (index > begIndex);
            if (signum == -1) {
                bi = bi.negate();
            }
        } else {
            bi = BigInteger.valueOf(l * signum);
        }
        // Update the scale based on the precision
        scale += (length - 2) * 2;
        BigDecimal v = new BigDecimal(bi, scale);
        return v;
    }


    private static int getLength(BigDecimal v) {
        int signum = v.signum();
        if (signum == 0) { // Special case for zero
            return 1;
        }
        return (signum < 0 ? 2 : 1) + (v.precision() + 1 + (v.scale() % 2 == 0 ? 0 : 1)) / 2;
    }

    private static final int MAX_PRECISION = 38;
    private static final MathContext DEFAULT_MATH_CONTEXT = new MathContext(MAX_PRECISION, RoundingMode.HALF_UP);
    private static final Integer MAX_BIG_DECIMAL_BYTES = 21;
    private static final byte ZERO_BYTE = (byte) 0x80;
    private static final byte NEG_TERMINAL_BYTE = (byte) 102;
    private static final int EXP_BYTE_OFFSET = 65;
    private static final int POS_DIGIT_OFFSET = 1;
    private static final int NEG_DIGIT_OFFSET = 101;
    private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
    private static final BigInteger MIN_LONG = BigInteger.valueOf(Long.MIN_VALUE);
    private static final BigInteger ONE_HUNDRED = BigInteger.valueOf(100);
    private static final long MAX_LONG_FOR_DESERIALIZE = Long.MAX_VALUE / 1000;


    private static int decimalToBytes(BigDecimal v, byte[] result, final int offset, int length) {
        int signum = v.signum();
        if (signum == 0) {
            result[offset] = ZERO_BYTE;
            return 1;
        }
        int index = offset + length;
        int scale = v.scale();
        int expOffset = scale % 2 * (scale < 0 ? -1 : 1);
        int multiplyBy;
        BigInteger divideBy;
        if (expOffset == 0) {
            multiplyBy = 1;
            divideBy = ONE_HUNDRED;
        } else {
            multiplyBy = 10;
            divideBy = BigInteger.TEN;
        }
        // Normalize the scale based on what is necessary to end up with a base 100 decimal (i.e. 10.123e3)
        int digitOffset;
        BigInteger compareAgainst;
        if (signum == 1) {
            digitOffset = POS_DIGIT_OFFSET;
            compareAgainst = MAX_LONG;
            scale -= (length - 2) * 2;
            result[offset] = (byte) ((-(scale + expOffset) / 2 + EXP_BYTE_OFFSET) | 0x80);
        } else {
            digitOffset = NEG_DIGIT_OFFSET;
            compareAgainst = MIN_LONG;
            // Scale adjustment shouldn't include terminal byte in length
            scale -= (length - 2 - 1) * 2;
            result[offset] = (byte) (~(-(scale + expOffset) / 2 + EXP_BYTE_OFFSET + 128) & 0x7F);
            if (length <= MAX_BIG_DECIMAL_BYTES) {
                result[--index] = NEG_TERMINAL_BYTE;
            } else {
                // Adjust length and offset down because we don't have enough room
                length = MAX_BIG_DECIMAL_BYTES;
                index = offset + length;
            }
        }
        BigInteger bi = v.unscaledValue();
        // Use BigDecimal arithmetic until we can fit into a long
        while (bi.compareTo(compareAgainst) * signum > 0) {
            BigInteger[] dandr = bi.divideAndRemainder(divideBy);
            bi = dandr[0];
            int digit = dandr[1].intValue();
            result[--index] = (byte) (digit * multiplyBy + digitOffset);
            multiplyBy = 1;
            divideBy = ONE_HUNDRED;
        }
        long l = bi.longValue();
        do {
            long divBy = 100 / multiplyBy;
            long digit = l % divBy;
            l /= divBy;
            result[--index] = (byte) (digit * multiplyBy + digitOffset);
            multiplyBy = 1;
        } while (l != 0);

        return length;
    }

    private static void checkForSufficientLength(byte[] b, int offset, int requiredLength) {
        if (b.length < offset + requiredLength) {
            throw new RuntimeException
                    ("Expected length of at least " + requiredLength + " bytes, but had " + (b.length - offset));
        }
    }
}

其中调用public static byte[] toBytes(Object v, PhType phType) 和

public static Object toObject(byte[] b, PhType phType)两个方法就可以实现java类型到Phoenix类型的换转。


                

        

    

    
  



    

      

        

            

              
                
                  rewerma
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
HBase(13) -- HBase之Phoenix使用

				
			

			

				

					erainm
				

				

					09-11
					
					332
					
				

			

		

		

			
				
1. 快速入门
1.1 创建表语法
在Phoenix中，我们可以使用类似于MySQL DDL的方式快速创建表。例如：
CREATE TABLE IF NOT EXISTS 表名 (
   ROWKEY名称 数据类型 PRIMARY KEY
	列族名.列名1 数据类型 NOT NULL,
	列族名.列名2 数据类型 NOT NULL,
	列族名.列名3 数据类型);

通过HBase的Web UI，我们可以看到Phoenix帮助我们自动在HBase中创建了一张名为 ORDER_DTL 的表格，可以看到里面添加

			
		

	



                

            
              



	

		

			

				
					
Phoenix学习笔记 --- phoenix支持的数据类型

				
			

			

				

					杨鑫newlife的专栏
				

				

					12-08
					
					2616
					
				

			

		

		

			
				
Phoenix学习笔记 --- phoenix支持的数据类型

			
		

	



              


  
              

                


	

		

			

				
					
Phoenix的数据类型和操作符、函数

					
热门推荐

				
			

			

				

					u014353787的博客
				

				

					12-24
					
					2万+
					
				

			

		

		

			
				
其实官方文档已经有这些东西了，如下：
http://phoenix.apache.org/language/functions.html
http://phoenix.apache.org/language/index.html


不过官网的某些编排确实有点反人类的意味，比如为了拼接一个字符串，我硬是找了老半天最终才找到，所以还是稍微整理一下。


数据类型：

1、数字类型

			
		

	





	

		

			

				
					
hbase整合pheonix

				
			

			

				

					我的祖传代码
				

				

					07-01
					
					1118
					
				

			

		

		

			
				
Phoenix，由saleforce.com 开源的一个项目，后又捐给了Apache。它相当于一个Java 中间件，帮助开发者，像
使用jdbc 访问关系型数据库一样，访问NoSql 数据库HBase。
Apache Phoenix 与其他Hadoop 产品完全集成，如Spark，Hive，Pig，Flume 和MapReduce。

一.安装pheonix

1.1 下载pheonix

htt...

			
		

	



		

			
		



	

		

			

				
					
Phoenix 的数据类型

				
			

			

				

					weixin_30488085的博客
				

				

					11-05
					
					424
					
				

			

		

		

			
				
与一般数据库一样。


INTEGER                java.lang.Integer       -2147483648 to 2147483647  (4 byte )
UNSIGNED_INT          java.lang.Integer       0 to 214748364...

			
		

	





	

		

			

				
					
[Phoenix] 二、数据类型

				
			

			

				

					weixin_33892359的博客
				

				

					03-27
					
					215
					
				

			

		

		

			
				
目前Phoenix支持24种简单数据类型和1个一维Array的复杂类型。以下是对支持数据类型的说明:
1.INTEGER
2.UNSIGNED_INT
3.BIGINT
4.UNSIGNED_LONG
5.TINYINT
6.UNSIGNED_TINYINT
7.SMALLINT
8.UNSIGNED_SMALLINT
9.FLOAT
10.UNSIGNED...

			
		

	





	

		

			

				
					
【Hbase】hbase和phoenix的整合（6）

				
			

			

				

					hx1156477702的博客
				

				

					10-03
					
					1498
					
				

			

		

		

			
				
hbase和phoenix的整合，phoenix安装部署，phoenix的使用，HBase的命名空间，列簇设计，版本设计，数据压缩，ROWKEY设计原则，设置预分区，Phoenix的视图，二级索引。

			
		

	





	

		

			

				
					
大数据技术之HBase整合 Phoenix(6)

				
			

			

				

					qq_45115959的博客
				

				

					09-01
					
					1561
					
				

			

		

		

			
				
Phoenix 是 HBase 的开源 SQL 皮肤。可以使用标准 JDBC API 代替 HBase 客户端 API 来创建表，插入数据和查询 HBase 数据。

			
		

	





	

		

			

				
					
HBase SQL Phoenix

				
			

			

				

					08-04
				

			

		

		

			
				
4. **HBase与Phoenix的配合**：Phoenix创建的表和索引会存储在HBase中，通过Phoenix执行SQL时，会自动转换为HBase的操作，然后由HBase执行数据读写。  5. **性能调优**：`performance.sh`可能是一个性能测试脚本，...

			
		

	





	

		

			

				
					
Apache Phoenix数据类型

				
			

			

				

					DataFlow范式
				

				

					09-01
					
					4003
					
				

			

		

		

			
				
数据类型  Java  Map  占用大小  (byte)  范围    INTEGER  java.lang.Integer  4  -2147483648  to 2147483647    UNSIGNED_INT  java.lang.Integer  4  0  to 2147483647    BIGINT  java.lang.Long  8  -922337203685477580

			
		

	





	

		

			

				
					
Phoenix表数据类型修改

				
			

			

				

					稼轩
				

				

					09-05
					
					9750
					
				

			

		

		

			
				
截止最新的Phoenix-4.14.0, alter table 并没有修改 现有表 现有字段 数据类型的功能, 因此, 想要实现修改数据类型的功能需要另辟蹊径, 或者使用简单粗暴的删表建表, 但是生产上显然这是不可取的.

修改思路

  Phoenix表是映射的hbase表, hbase存储的数据都是字节数组, 因此, 限制数据类型的只能是Phoenix自己, 所以, 我们就可以...

			
		

	





	

		

			

				
					
phoenix映射hbase中数据类型问题

				
			

			

				

					qq_32961283的博客
				

				

					10-10
					
					1992
					
				

			

		

		

			
				
关于Phoenix映射Hbase数据字段类型Demo
一. 原理


注意：1.在hbase中必须将value值进行Bytes.toBytes(),才能在phoenix中映射出你所需要的字段值
​      2.在Phoenix映射表的时候必须使用unsigned_*类型
二. 使用Hbase Shell
2.1 Hbase中操作
2.1.1 创建表
create 'jinshan' ,'info','info1'


2.1.2 插入数据
put 'jinshan','1001','info:create

			
		

	





	

		

			

				
					
phoenix 修改表字段

				
			

			

				

					Millton0518的专栏
				

				

					11-06
					
					820
					
				

			

		

		

			
				
主要记录下apache phoenix修改表字段的一种变通方式,仅供参考




 CREATE TABLE IF NOT EXISTS t_appversion (
  f_region_id VARCHAR,
  f_province_id VARCHAR,
  f_province_name VARCHAR,
  f_terminal INTEGER ,
  f_phone_model ...

			
		

	





	

		

			

				
					
 hbase里插入big int数据用Phoenix查看的报错问题

				
			

			

				

					weixin_34355715的博客
				

				

					01-22
					
					627
					
				

			

		

		

			
				
Phoenix建表
create table "test_big_int"("ROW" varchar primary key,"ci"."column1" bigint)

在hbase里put数据
hbase 里面进行put: put 'test_big_int','001','ci:column1',1'
在Phoenix里进行查看...

			
		

	





	

		

			

				
					
phoenix表结构修改（新增字段，字段类型修改）

				
			

			

				

					fuyun6363的博客
				

				

					04-13
					
					9162
					
				

			

		

		

			
				
文章目录修改思路开始操作创建模拟表**插入数据添加字段将新增的字段数据补齐删除字段查看元数据查看表的主键修改元数据举一反三查看表信息

计划总是赶不上变化，在实际开发中，需求总会不断变更，比如需求开始只需要在phoenix中创建5个字段就可以，但随着业务的变化，需要新增一个字段，某个字段的数据类型也需要改变，这时简单粗暴的方式就是删表重建，再重跑数据。是否可以在phoenix中修改字段类型和添加字...

			
		

	





	

		

			

				
					
数据应用流水线-数据应用

				
			

			

				

					loki的博客
				

				

					09-29
					
					1156
					
				

			

		

		

			
				
软件系统主要包括：算法与数据。

一切的根源都来源于数据，抛开业务流程，软件全生命周期只考虑一件事--数据存储于应用。

上图就是一个数据应用的全流程结构图。

数据源：代表着底层的数据存储。

数据接入：数据总线，支持对底层各类数据源的读写。

数据计算：支持数据的分布式批量加工计算。

数据服务：支持对数据加工后的数据提供API接口服务。

数据消费：实现数据的应用。
...

			
		

	





	

		

			

				
					
hbase访问phoenix数据

					
最新发布

				
			

			

				

					05-30
				

			

		

		

			
				
好的，用户的问题是如何通过HBase访问Phoenix数据，需要配置方法和示例代码。首先，我需要回忆HBase和Phoenix的关系。Phoenix是构建在HBase之上的SQL层，提供SQL查询功能。用户可能已经知道Phoenix可以通过SQL操作...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值