com.facebook.presto.spi.type.DoubleType Java Examples

public void handleQuantity(Map<String, Quantity>  quantityMap, String prefix, Map<String, Object> data) {
    if (quantityMap != null){
        for (String key : quantityMap.keySet()) {
            String columnName = (prefix + key).toLowerCase();
            if (key.endsWith("cpu")) {
                data.put(columnName, quantityMap.get(key).getNumber().doubleValue());
                if (!getKubeColumn().containsKey(columnName)) {
                    UpdateColumns(columnName, new KubeColumn<Object>(columnName, DoubleType.DOUBLE, key));
                }
            } else {
                data.put(columnName, quantityMap.get(key).getNumber().longValue());
                if (!getKubeColumn().containsKey(columnName)) {
                    UpdateColumns(columnName, new KubeColumn<Object>(columnName, BigintType.BIGINT, key));
                }
            }

        }
    }
}
 

@Test
public void testNonExistent()
        throws Exception
{
    byte[] json = "{}".getBytes(StandardCharsets.UTF_8);

    JsonKinesisRowDecoder rowDecoder = new JsonKinesisRowDecoder(PROVIDER.get());
    KinesisColumnHandle row1 = new KinesisColumnHandle("", 0, "row1", VarcharType.VARCHAR, "very/deep/varchar", null, null, false, false);
    KinesisColumnHandle row2 = new KinesisColumnHandle("", 1, "row2", BigintType.BIGINT, "no_bigint", null, null, false, false);
    KinesisColumnHandle row3 = new KinesisColumnHandle("", 2, "row3", DoubleType.DOUBLE, "double/is_missing", null, null, false, false);
    KinesisColumnHandle row4 = new KinesisColumnHandle("", 3, "row4", BooleanType.BOOLEAN, "hello", null, null, false, false);

    List<KinesisColumnHandle> columns = ImmutableList.of(row1, row2, row3, row4);
    Set<KinesisFieldValueProvider> providers = new HashSet<>();

    boolean valid = rowDecoder.decodeRow(json, providers, columns, buildMap(columns));
    assertTrue(valid);

    assertEquals(providers.size(), columns.size());

    DecoderTestUtil.checkIsNull(providers, row1);
    DecoderTestUtil.checkIsNull(providers, row2);
    DecoderTestUtil.checkIsNull(providers, row3);
    DecoderTestUtil.checkIsNull(providers, row4);
}
 

public static org.apache.kudu.Type toKuduClientType(Type type) {
    if (type instanceof VarcharType) {
        return org.apache.kudu.Type.STRING;
    } else if (type == TimestampType.TIMESTAMP) {
        return org.apache.kudu.Type.UNIXTIME_MICROS;
    } else if (type == BigintType.BIGINT) {
        return org.apache.kudu.Type.INT64;
    } else if (type == IntegerType.INTEGER) {
        return org.apache.kudu.Type.INT32;
    } else if (type == SmallintType.SMALLINT) {
        return org.apache.kudu.Type.INT16;
    } else if (type == TinyintType.TINYINT) {
        return org.apache.kudu.Type.INT8;
    } else if (type == RealType.REAL) {
        return org.apache.kudu.Type.FLOAT;
    } else if (type == DoubleType.DOUBLE) {
        return org.apache.kudu.Type.DOUBLE;
    } else if (type == BooleanType.BOOLEAN) {
        return org.apache.kudu.Type.BOOL;
    } else if (type instanceof VarbinaryType) {
        return org.apache.kudu.Type.BINARY;
    } else if (type instanceof DecimalType) {
        return org.apache.kudu.Type.DECIMAL;
    } else if (type == DateType.DATE) {
        return org.apache.kudu.Type.STRING;
    } else if (type instanceof CharType) {
        return org.apache.kudu.Type.STRING;
    } else {
        throw new IllegalStateException("Type mapping implemented for Presto type: " + type);
    }
}
 

private static Type fromKuduClientType(org.apache.kudu.Type ktype, ColumnTypeAttributes attributes) {
    switch (ktype) {
        case STRING:
            return VarcharType.VARCHAR;
        case UNIXTIME_MICROS:
            return TimestampType.TIMESTAMP;
        case INT64:
            return BigintType.BIGINT;
        case INT32:
            return IntegerType.INTEGER;
        case INT16:
            return SmallintType.SMALLINT;
        case INT8:
            return TinyintType.TINYINT;
        case FLOAT:
            return RealType.REAL;
        case DOUBLE:
            return DoubleType.DOUBLE;
        case BOOL:
            return BooleanType.BOOLEAN;
        case BINARY:
            return VarbinaryType.VARBINARY;
        case DECIMAL:
            return DecimalType.createDecimalType(attributes.getPrecision(), attributes.getScale());
        default:
            throw new IllegalStateException("Kudu type not implemented for " + ktype);
    }
}
 

public static NullableValue getColumnValue(Type type, PartialRow row, int i) {
    if (row.isNull(i)) {
        return NullableValue.asNull(type);
    } else {
        if (type instanceof VarcharType) {
            return NullableValue.of(type, utf8Slice(row.getString(i)));
        } else if (type == TimestampType.TIMESTAMP) {
            return NullableValue.of(type, row.getLong(i) / 1000);
        } else if (type == BigintType.BIGINT) {
            return NullableValue.of(type, row.getLong(i));
        } else if (type == IntegerType.INTEGER) {
            return NullableValue.of(type, row.getInt(i));
        } else if (type == SmallintType.SMALLINT) {
            return NullableValue.of(type, row.getShort(i));
        } else if (type == TinyintType.TINYINT) {
            return NullableValue.of(type, row.getByte(i));
        } else if (type == DoubleType.DOUBLE) {
            return NullableValue.of(type, row.getDouble(i));
        } else if (type == RealType.REAL) {
            return NullableValue.of(type, (long) floatToRawIntBits(row.getFloat(i)));
        } else if (type == BooleanType.BOOLEAN) {
            return NullableValue.of(type, row.getBoolean(i));
        } else if (type instanceof VarbinaryType) {
            return NullableValue.of(type, wrappedBuffer(row.getBinary(i)));
        } else if (type instanceof DecimalType) {
            return NullableValue.of(type, row.getDecimal(i));
        } else {
            throw new IllegalStateException("Handling of type " + type + " is not implemented");
        }
    }
}
 

public static Object getJavaValue(Type type, Object nativeValue) {
    if (type instanceof VarcharType) {
        return ((Slice) nativeValue).toStringUtf8();
    } else if (type == TimestampType.TIMESTAMP) {
        return ((Long) nativeValue) * 1000;
    } else if (type == BigintType.BIGINT) {
        return nativeValue;
    } else if (type == IntegerType.INTEGER) {
        return ((Long) nativeValue).intValue();
    } else if (type == SmallintType.SMALLINT) {
        return ((Long) nativeValue).shortValue();
    } else if (type == TinyintType.TINYINT) {
        return ((Long) nativeValue).byteValue();
    } else if (type == DoubleType.DOUBLE) {
        return nativeValue;
    } else if (type == RealType.REAL) {
        // conversion can result in precision lost
        return intBitsToFloat(((Long) nativeValue).intValue());
    } else if (type == BooleanType.BOOLEAN) {
        return nativeValue;
    } else if (type instanceof VarbinaryType) {
        return ((Slice) nativeValue).toByteBuffer();
    } else if (type instanceof DecimalType) {
        return nativeValue;
    } else {
        throw new IllegalStateException("Back conversion not implemented for " + type);
    }
}
 

public static Object getObject(Type type, RowResult row, int field) {
    if (row.isNull(field)) {
        return null;
    } else {
        if (type instanceof VarcharType) {
            return row.getString(field);
        } else if (type == TimestampType.TIMESTAMP) {
            return row.getLong(field) / 1000;
        } else if (type == BigintType.BIGINT) {
            return row.getLong(field);
        } else if (type == IntegerType.INTEGER) {
            return row.getInt(field);
        } else if (type == SmallintType.SMALLINT) {
            return row.getShort(field);
        } else if (type == TinyintType.TINYINT) {
            return row.getByte(field);
        } else if (type == DoubleType.DOUBLE) {
            return row.getDouble(field);
        } else if (type == RealType.REAL) {
            return row.getFloat(field);
        } else if (type == BooleanType.BOOLEAN) {
            return row.getBoolean(field);
        } else if (type instanceof VarbinaryType) {
            return Slices.wrappedBuffer(row.getBinary(field));
        } else if (type instanceof DecimalType) {
            return row.getDecimal(field);
        } else {
            throw new IllegalStateException("getObject not implemented for " + type);
        }
    }
}
 

public static double getDouble(Type type, RowResult row, int field) {
    if (type == DoubleType.DOUBLE) {
        return row.getDouble(field);
    } else {
        throw new IllegalStateException("getDouble not implemented for " + type);
    }
}
 

@Test
public void testSimple()
{
    String csv = "\"row 1\",row2,\"row3\",100,\"200\",300,4.5";

    CsvKinesisRowDecoder rowDecoder = new CsvKinesisRowDecoder();
    KinesisColumnHandle row1 = new KinesisColumnHandle("", 0, "row1", VarcharType.VARCHAR, "0", null, null, false, false);
    KinesisColumnHandle row2 = new KinesisColumnHandle("", 1, "row2", VarcharType.VARCHAR, "1", null, null, false, false);
    KinesisColumnHandle row3 = new KinesisColumnHandle("", 2, "row3", VarcharType.VARCHAR, "2", null, null, false, false);
    KinesisColumnHandle row4 = new KinesisColumnHandle("", 3, "row4", BigintType.BIGINT, "3", null, null, false, false);
    KinesisColumnHandle row5 = new KinesisColumnHandle("", 4, "row5", BigintType.BIGINT, "4", null, null, false, false);
    KinesisColumnHandle row6 = new KinesisColumnHandle("", 5, "row6", BigintType.BIGINT, "5", null, null, false, false);
    KinesisColumnHandle row7 = new KinesisColumnHandle("", 6, "row7", DoubleType.DOUBLE, "6", null, null, false, false);

    List<KinesisColumnHandle> columns = ImmutableList.of(row1, row2, row3, row4, row5, row6, row7);
    Set<KinesisFieldValueProvider> providers = new HashSet<>();

    boolean valid = rowDecoder.decodeRow(csv.getBytes(StandardCharsets.UTF_8), providers, columns, buildMap(columns));
    assertTrue(valid);

    assertEquals(providers.size(), columns.size());

    DecoderTestUtil.checkValue(providers, row1, "row 1");
    DecoderTestUtil.checkValue(providers, row2, "row2");
    DecoderTestUtil.checkValue(providers, row3, "row3");
    DecoderTestUtil.checkValue(providers, row4, 100);
    DecoderTestUtil.checkValue(providers, row5, 200);
    DecoderTestUtil.checkValue(providers, row6, 300);
    DecoderTestUtil.checkValue(providers, row7, 4.5d);
}
 

private static XContentBuilder buildFieldType(XContentBuilder fieldBuilder, Type type)
        throws IOException
{
    final String dateTimeFormat = "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis";
    //Type mapping
    // see:https://www.elastic.co/guide/en/elasticsearch/reference/6.3/mapping-types.html
    if (type.equals(BooleanType.BOOLEAN)) {
        return fieldBuilder.field("type", "boolean");
    }
    if (type.equals(BigintType.BIGINT)) {
        return fieldBuilder.field("type", "long");
    }
    if (type.equals(IntegerType.INTEGER)) {
        return fieldBuilder.field("type", "integer");
    }
    if (type.equals(SmallintType.SMALLINT)) {
        return fieldBuilder.field("type", "short");
    }
    if (type.equals(TinyintType.TINYINT)) {
        return fieldBuilder.field("type", "byte");
    }
    if (type.equals(DoubleType.DOUBLE)) {
        return fieldBuilder.field("type", "double");
    }
    if (type.equals(DateType.DATE)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimeType.TIME)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampType.TIMESTAMP)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampWithTimeZoneType.TIMESTAMP_WITH_TIME_ZONE)) {
        //TODO: TIMESTAMP_WITH_TIME_ZONE
        return fieldBuilder.field("type", "date")
                .field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis");
    }
    if (type instanceof DecimalType) {
        return fieldBuilder.field("type", "double");
    }
    if (isVarcharType(type)) {
        //es 2.4.x
        // .field("index", "not_analyzed")
        return fieldBuilder.field("type", "string");
    }
    if (type.equals(VarbinaryType.VARBINARY)) {
        return fieldBuilder.field("type", "binary");
    }
    if (isArrayType(type)) {
        Type elementType = type.getTypeParameters().get(0);
        if (isArrayType(elementType) || isMapType(elementType) || isRowType(elementType)) {
            throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
        }
        return buildFieldType(fieldBuilder, elementType);
    }
    if (isMapType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }
    if (isRowType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }

    throw new PrestoException(NOT_SUPPORTED, "unsupported type: " + type);
}
 

private static XContentBuilder buildFieldType(XContentBuilder fieldBuilder, Type type)
        throws IOException
{
    final String dateTimeFormat = "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis";
    //Type mapping
    // see:https://www.elastic.co/guide/en/elasticsearch/reference/6.3/mapping-types.html
    if (type.equals(BooleanType.BOOLEAN)) {
        return fieldBuilder.field("type", "boolean");
    }
    if (type.equals(BigintType.BIGINT)) {
        return fieldBuilder.field("type", "long");
    }
    if (type.equals(IntegerType.INTEGER)) {
        return fieldBuilder.field("type", "integer");
    }
    if (type.equals(SmallintType.SMALLINT)) {
        return fieldBuilder.field("type", "short");
    }
    if (type.equals(TinyintType.TINYINT)) {
        return fieldBuilder.field("type", "byte");
    }
    if (type.equals(DoubleType.DOUBLE)) {
        return fieldBuilder.field("type", "double");
    }
    if (type.equals(DateType.DATE)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimeType.TIME)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampType.TIMESTAMP)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampWithTimeZoneType.TIMESTAMP_WITH_TIME_ZONE)) {
        //TODO: TIMESTAMP_WITH_TIME_ZONE
        return fieldBuilder.field("type", "date")
                .field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis");
    }
    if (type instanceof DecimalType) {
        return fieldBuilder.field("type", "double");
    }
    if (isVarcharType(type)) {
        //TODO: text or keyword ?
        return fieldBuilder.field("type", "text");
    }
    if (type.equals(VarbinaryType.VARBINARY)) {
        return fieldBuilder.field("type", "binary");
    }
    if (isArrayType(type)) {
        Type elementType = type.getTypeParameters().get(0);
        if (isArrayType(elementType) || isMapType(elementType) || isRowType(elementType)) {
            throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
        }
        return buildFieldType(fieldBuilder, elementType);
    }
    if (isMapType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }
    if (isRowType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }

    throw new PrestoException(NOT_SUPPORTED, "unsupported type: " + type);
}
 

private static XContentBuilder buildFieldType(XContentBuilder fieldBuilder, Type type)
        throws IOException
{
    final String dateTimeFormat = "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis";
    //Type mapping
    // see:https://www.elastic.co/guide/en/elasticsearch/reference/6.3/mapping-types.html
    if (type.equals(BooleanType.BOOLEAN)) {
        return fieldBuilder.field("type", "boolean");
    }
    if (type.equals(BigintType.BIGINT)) {
        return fieldBuilder.field("type", "long");
    }
    if (type.equals(IntegerType.INTEGER)) {
        return fieldBuilder.field("type", "integer");
    }
    if (type.equals(SmallintType.SMALLINT)) {
        return fieldBuilder.field("type", "short");
    }
    if (type.equals(TinyintType.TINYINT)) {
        return fieldBuilder.field("type", "byte");
    }
    if (type.equals(DoubleType.DOUBLE)) {
        return fieldBuilder.field("type", "double");
    }
    if (type.equals(DateType.DATE)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimeType.TIME)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampType.TIMESTAMP)) {
        return fieldBuilder.field("type", "date")
                .field("format", dateTimeFormat);
    }
    if (type.equals(TimestampWithTimeZoneType.TIMESTAMP_WITH_TIME_ZONE)) {
        //TODO: TIMESTAMP_WITH_TIME_ZONE
        return fieldBuilder.field("type", "date")
                .field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis");
    }
    if (type instanceof DecimalType) {
        return fieldBuilder.field("type", "double");
    }
    if (isVarcharType(type)) {
        //TODO: text or keyword ?
        return fieldBuilder.field("type", "text");
    }
    if (type.equals(VarbinaryType.VARBINARY)) {
        return fieldBuilder.field("type", "binary");
    }
    if (isArrayType(type)) {
        Type elementType = type.getTypeParameters().get(0);
        if (isArrayType(elementType) || isMapType(elementType) || isRowType(elementType)) {
            throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
        }
        return buildFieldType(fieldBuilder, elementType);
    }
    if (isMapType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }
    if (isRowType(type)) {
        throw new PrestoException(NOT_SUPPORTED, "sorry unsupported type: " + type);
    }

    throw new PrestoException(NOT_SUPPORTED, "unsupported type: " + type);
}
 

private Type getType(String typeName)
{
    log.debug("Get type " + typeName);
    typeName = typeName.toLowerCase();
    // check if type is varchar(xx)
    Pattern vcpattern = Pattern.compile("varchar\\(\\s*(\\d+)\\s*\\)");
    Matcher vcmatcher = vcpattern.matcher(typeName);
    if (vcmatcher.find()) {
        String vlen = vcmatcher.group(1);
        if (!vlen.isEmpty()) {
            return VarcharType.createVarcharType(Integer.parseInt(vlen));
        }
        return UnknownType.UNKNOWN;
    }
    // check if type is char(xx)
    Pattern cpattern = Pattern.compile("char\\(\\s*(\\d+)\\s*\\)");
    Matcher cmatcher = cpattern.matcher(typeName);
    if (cmatcher.find()) {
        String clen = cmatcher.group(1);
        if (!clen.isEmpty()) {
            return CharType.createCharType(Integer.parseInt(clen));
        }
        return UnknownType.UNKNOWN;
    }
    // check if type is decimal(precision, scale)
    Pattern dpattern = Pattern.compile("decimal\\((\\d+)\\s*,?\\s*(\\d*)\\)");
    Matcher dmatcher = dpattern.matcher(typeName);
    if (dmatcher.find()) {
        String dprecision = dmatcher.group(1);
        String dscale = dmatcher.group(2);
        if (dprecision.isEmpty()) {
            return UnknownType.UNKNOWN;
        }
        if (dscale.isEmpty()) {
            return DecimalType.createDecimalType(Integer.parseInt(dprecision));
        }
        return DecimalType.createDecimalType(Integer.parseInt(dprecision), Integer.parseInt(dscale));
    }
    switch (typeName) {
        case "boolean":
            return BooleanType.BOOLEAN;
        case "tinyint":
            return TinyintType.TINYINT;
        case "smallint":
            return SmallintType.SMALLINT;
        case "integer":
            return IntegerType.INTEGER;
        case "bigint":
            return BigintType.BIGINT;
        case "real":
            return RealType.REAL;
        case "double":
            return DoubleType.DOUBLE;
        case "date":
            return DateType.DATE;
        case "time":
            return TimeType.TIME;
        case "timestamp":
            return TimestampType.TIMESTAMP;
        default:
            return UnknownType.UNKNOWN;
    }
}
 

@SuppressWarnings("ValueOfIncrementOrDecrementUsed")
@Override
public Map<String, ColumnHandle> getColumnHandles(ConnectorSession session, ConnectorTableHandle tableHandle) {
    EthereumTableHandle ethereumTableHandle = convertTableHandle(tableHandle);
    String tableName = ethereumTableHandle.getTableName();

    ImmutableMap.Builder<String, ColumnHandle> columnHandles = ImmutableMap.builder();
    int index = 0;
    if (EthereumTable.BLOCK.getName().equals(tableName)) {
        columnHandles.put("block_number", new EthereumColumnHandle(connectorId, index++, "block_number", BigintType.BIGINT));
        columnHandles.put("block_hash", new EthereumColumnHandle(connectorId, index++, "block_hash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_parentHash", new EthereumColumnHandle(connectorId, index++, "block_parentHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_nonce", new EthereumColumnHandle(connectorId, index++, "block_nonce", VarcharType.createVarcharType(H8_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_sha3Uncles", new EthereumColumnHandle(connectorId, index++, "block_sha3Uncles", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_logsBloom", new EthereumColumnHandle(connectorId, index++, "block_logsBloom", VarcharType.createVarcharType(H256_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_transactionsRoot", new EthereumColumnHandle(connectorId, index++, "block_transactionsRoot", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_stateRoot", new EthereumColumnHandle(connectorId, index++, "block_stateRoot", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_miner", new EthereumColumnHandle(connectorId, index++, "block_miner", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("block_difficulty", new EthereumColumnHandle(connectorId, index++, "block_difficulty", BigintType.BIGINT));
        columnHandles.put("block_totalDifficulty", new EthereumColumnHandle(connectorId, index++, "block_totalDifficulty", BigintType.BIGINT));
        columnHandles.put("block_size", new EthereumColumnHandle(connectorId, index++, "block_size", IntegerType.INTEGER));
        columnHandles.put("block_extraData", new EthereumColumnHandle(connectorId, index++, "block_extraData", VarcharType.VARCHAR));
        columnHandles.put("block_gasLimit", new EthereumColumnHandle(connectorId, index++, "block_gasLimit", DoubleType.DOUBLE));
        columnHandles.put("block_gasUsed", new EthereumColumnHandle(connectorId, index++, "block_gasUsed", DoubleType.DOUBLE));
        columnHandles.put("block_timestamp", new EthereumColumnHandle(connectorId, index++, "block_timestamp", BigintType.BIGINT));
        columnHandles.put("block_transactions", new EthereumColumnHandle(connectorId, index++, "block_transactions", new ArrayType(VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH))));
        columnHandles.put("block_uncles", new EthereumColumnHandle(connectorId, index++, "block_uncles", new ArrayType(VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH))));
    } else if (EthereumTable.TRANSACTION.getName().equals(tableName)) {
        columnHandles.put("tx_hash", new EthereumColumnHandle(connectorId, index++, "tx_hash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("tx_nonce", new EthereumColumnHandle(connectorId, index++, "tx_nonce", BigintType.BIGINT));
        columnHandles.put("tx_blockHash", new EthereumColumnHandle(connectorId, index++, "tx_blockHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("tx_blockNumber", new EthereumColumnHandle(connectorId, index++, "tx_blockNumber", BigintType.BIGINT));
        columnHandles.put("tx_transactionIndex", new EthereumColumnHandle(connectorId, index++, "tx_transactionIndex", IntegerType.INTEGER));
        columnHandles.put("tx_from", new EthereumColumnHandle(connectorId, index++, "tx_from", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("tx_to", new EthereumColumnHandle(connectorId, index++, "tx_to", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("tx_value", new EthereumColumnHandle(connectorId, index++, "tx_value", DoubleType.DOUBLE));
        columnHandles.put("tx_gas", new EthereumColumnHandle(connectorId, index++, "tx_gas", DoubleType.DOUBLE));
        columnHandles.put("tx_gasPrice", new EthereumColumnHandle(connectorId, index++, "tx_gasPrice", DoubleType.DOUBLE));
        columnHandles.put("tx_input", new EthereumColumnHandle(connectorId, index++, "tx_input", VarcharType.VARCHAR));
    } else if (EthereumTable.ERC20.getName().equals(tableName)) {
        columnHandles.put("erc20_token", new EthereumColumnHandle(connectorId, index++, "erc20_token", VarcharType.createUnboundedVarcharType()));
        columnHandles.put("erc20_from", new EthereumColumnHandle(connectorId, index++, "erc20_from", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("erc20_to", new EthereumColumnHandle(connectorId, index++, "erc20_to", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("erc20_value", new EthereumColumnHandle(connectorId, index++, "erc20_value", DoubleType.DOUBLE));
        columnHandles.put("erc20_txHash", new EthereumColumnHandle(connectorId, index++, "erc20_txHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        columnHandles.put("erc20_blockNumber", new EthereumColumnHandle(connectorId, index++, "erc20_blockNumber", BigintType.BIGINT));
    } else {
        throw new IllegalArgumentException("Unknown Table Name " + tableName);
    }

    return columnHandles.build();
}
 

@SuppressWarnings("ValueOfIncrementOrDecrementUsed")
private ConnectorTableMetadata getTableMetadata(SchemaTableName schemaTableName) {
    ImmutableList.Builder<ColumnMetadata> builder = ImmutableList.builder();

    if (EthereumTable.BLOCK.getName().equals(schemaTableName.getTableName())) {
        builder.add(new ColumnMetadata("block_number", BigintType.BIGINT));
        builder.add(new ColumnMetadata("block_hash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_parentHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_nonce", VarcharType.createVarcharType(H8_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_sha3Uncles", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_logsBloom", VarcharType.createVarcharType(H256_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_transactionsRoot", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_stateRoot", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_miner", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("block_difficulty", BigintType.BIGINT));
        builder.add(new ColumnMetadata("block_totalDifficulty", BigintType.BIGINT));
        builder.add(new ColumnMetadata("block_size", IntegerType.INTEGER));
        builder.add(new ColumnMetadata("block_extraData", VarcharType.VARCHAR));
        builder.add(new ColumnMetadata("block_gasLimit", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("block_gasUsed", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("block_timestamp", BigintType.BIGINT));
        builder.add(new ColumnMetadata("block_transactions", new ArrayType(VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH))));
        builder.add(new ColumnMetadata("block_uncles", new ArrayType(VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH))));
    } else if (EthereumTable.TRANSACTION.getName().equals(schemaTableName.getTableName())) {
        builder.add(new ColumnMetadata("tx_hash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("tx_nonce", BigintType.BIGINT));
        builder.add(new ColumnMetadata("tx_blockHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("tx_blockNumber", BigintType.BIGINT));
        builder.add(new ColumnMetadata("tx_transactionIndex", IntegerType.INTEGER));
        builder.add(new ColumnMetadata("tx_from", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("tx_to", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("tx_value", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("tx_gas", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("tx_gasPrice", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("tx_input", VarcharType.VARCHAR));
    } else if (EthereumTable.ERC20.getName().equals(schemaTableName.getTableName())) {
        builder.add(new ColumnMetadata("erc20_token", VarcharType.createUnboundedVarcharType()));
        builder.add(new ColumnMetadata("erc20_from", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("erc20_to", VarcharType.createVarcharType(H20_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("erc20_value", DoubleType.DOUBLE));
        builder.add(new ColumnMetadata("erc20_txHash", VarcharType.createVarcharType(H32_BYTE_HASH_STRING_LENGTH)));
        builder.add(new ColumnMetadata("erc20_blockNumber", BigintType.BIGINT));
    } else {
        throw new IllegalArgumentException("Unknown Table Name " + schemaTableName.getTableName());
    }

    return new ConnectorTableMetadata(schemaTableName, builder.build());
}