Java tutorial
/* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.facebook.presto.accumulo.model; import com.facebook.presto.accumulo.Types; import com.facebook.presto.accumulo.serializers.AccumuloRowSerializer; import com.facebook.presto.spi.PrestoException; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.VarcharType; import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import org.apache.commons.lang.StringUtils; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; import org.joda.time.format.ISODateTimeFormat; import java.sql.Date; import java.sql.Time; import java.sql.Timestamp; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Objects; import java.util.stream.Collectors; import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT; import static com.facebook.presto.spi.StandardErrorCode.NOT_SUPPORTED; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DateType.DATE; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.IntegerType.INTEGER; import static com.facebook.presto.spi.type.RealType.REAL; import static com.facebook.presto.spi.type.SmallintType.SMALLINT; import static com.facebook.presto.spi.type.TimeType.TIME; import static com.facebook.presto.spi.type.TimestampType.TIMESTAMP; import static com.facebook.presto.spi.type.TinyintType.TINYINT; import static com.facebook.presto.spi.type.VarbinaryType.VARBINARY; import static com.google.common.base.Preconditions.checkArgument; import static java.lang.String.format; import static java.nio.charset.StandardCharsets.UTF_8; import static java.util.Objects.requireNonNull; public class Row { private static final DateTimeFormatter DATE_PARSER = ISODateTimeFormat.date(); private static final DateTimeFormatter TIME_PARSER = DateTimeFormat.forPattern("HH:mm:ss"); private static final DateTimeFormatter TIMESTAMP_PARSER = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.SSS"); private final List<Field> fields = new ArrayList<>(); public Row() { } public Row(Row row) { requireNonNull(row, "row is null"); fields.addAll(row.fields.stream().map(Field::new).collect(Collectors.toList())); } public Row addField(Field field) { requireNonNull(field, "field is null"); fields.add(field); return this; } public Row addField(Object value, Type type) { requireNonNull(type, "type is null"); fields.add(new Field(value, type)); return this; } public Field getField(int i) { return fields.get(i); } /** * Gets a list of all internal fields. Any changes to this list will affect this row. * * @return List of fields */ public List<Field> getFields() { return fields; } public int length() { return fields.size(); } @Override public int hashCode() { return Arrays.hashCode(fields.toArray()); } @Override public boolean equals(Object obj) { return obj instanceof Row && Objects.equals(this.fields, ((Row) obj).getFields()); } @Override public String toString() { if (fields.isEmpty()) { return "()"; } else { StringBuilder builder = new StringBuilder("("); for (Field f : fields) { builder.append(f).append(","); } builder.deleteCharAt(builder.length() - 1); return builder.append(')').toString(); } } /** * Creates a new {@link Row} from the given delimited string based on the given {@link RowSchema} * * @param schema Row's schema * @param str String to parse * @param delimiter Delimiter of the string * @return A new Row * @throws PrestoException If the length of the split string is not equal to the length of the schema * @throws PrestoException If the schema contains an unsupported type */ public static Row fromString(RowSchema schema, String str, char delimiter) { Row row = new Row(); ImmutableList.Builder<String> builder = ImmutableList.builder(); List<String> fields = builder.addAll(Splitter.on(delimiter).split(str)).build(); if (fields.size() != schema.getLength()) { throw new PrestoException(INVALID_FUNCTION_ARGUMENT, format( "Number of split tokens is not equal to schema length. Expected %s received %s. Schema: %s, fields {%s}, delimiter %s", schema.getLength(), fields.size(), schema, StringUtils.join(fields, ","), delimiter)); } for (int i = 0; i < fields.size(); ++i) { Type type = schema.getColumn(i).getType(); row.addField(valueFromString(fields.get(i), type), type); } return row; } /** * Converts the given String into a Java object based on the given Presto type * * @param str String to convert * @param type Presto Type * @return Java object * @throws PrestoException If the type is not supported by this function */ public static Object valueFromString(String str, Type type) { if (str == null || str.isEmpty()) { return null; } else if (Types.isArrayType(type)) { Type elementType = Types.getElementType(type); ImmutableList.Builder<Object> listBuilder = ImmutableList.builder(); for (String element : Splitter.on(',').split(str)) { listBuilder.add(valueFromString(element, elementType)); } return AccumuloRowSerializer.getBlockFromArray(elementType, listBuilder.build()); } else if (Types.isMapType(type)) { Type keyType = Types.getKeyType(type); Type valueType = Types.getValueType(type); ImmutableMap.Builder<Object, Object> mapBuilder = ImmutableMap.builder(); for (String element : Splitter.on(',').split(str)) { ImmutableList.Builder<String> builder = ImmutableList.builder(); List<String> keyValue = builder.addAll(Splitter.on("->").split(element)).build(); checkArgument(keyValue.size() == 2, format("Map element %s has %d entries, not 2", element, keyValue.size())); mapBuilder.put(valueFromString(keyValue.get(0), keyType), valueFromString(keyValue.get(1), valueType)); } return AccumuloRowSerializer.getBlockFromMap(type, mapBuilder.build()); } else if (type.equals(BIGINT)) { return Long.parseLong(str); } else if (type.equals(BOOLEAN)) { return Boolean.parseBoolean(str); } else if (type.equals(DATE)) { return new Date(DATE_PARSER.parseDateTime(str).getMillis()); } else if (type.equals(DOUBLE)) { return Double.parseDouble(str); } else if (type.equals(INTEGER)) { return Integer.parseInt(str); } else if (type.equals(REAL)) { return Float.parseFloat(str); } else if (type.equals(SMALLINT)) { return Short.parseShort(str); } else if (type.equals(TIME)) { return new Time(TIME_PARSER.parseDateTime(str).getMillis()); } else if (type.equals(TIMESTAMP)) { return new Timestamp(TIMESTAMP_PARSER.parseDateTime(str).getMillis()); } else if (type.equals(TINYINT)) { return Byte.valueOf(str); } else if (type.equals(VARBINARY)) { return str.getBytes(UTF_8); } else if (type instanceof VarcharType) { return str; } else { throw new PrestoException(NOT_SUPPORTED, "Unsupported type " + type); } } }