Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.type;
 
 
 import java.util.List;
 import java.util.Map;
 
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.fasterxml.jackson.core.JsonFactory.Feature.CANONICALIZE_FIELD_NAMES;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
 import static java.lang.String.format;
 
 public final class TypeJsonUtils
 {
     private static final JsonFactory JSON_FACTORY = new JsonFactory().disable();
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapperProvider().get();
     private static final CollectionType COLLECTION_TYPE = .getTypeFactory().constructCollectionType(List.classObject.class);
     private static final com.fasterxml.jackson.databind.type.MapType MAP_TYPE = .getTypeFactory().constructMapType(Map.classString.classObject.class);
 
     private TypeJsonUtils() {}
 
     public static Object stackRepresentationToObject(ConnectorSession sessionSlice valueType type)
     {
         if (value == null) {
             return null;
         }
 
         try (JsonParser jsonParser = .createJsonParser(value.getInput())) {
             jsonParser.nextToken();
             return stackRepresentationToObjectHelper(sessionjsonParsertype);
         }
         catch (IOException e) {
             throw Throwables.propagate(e);
         }
     }
 
     private static Object stackRepresentationToObjectHelper(ConnectorSession sessionJsonParser parserType type)
             throws IOException
     {
         if (parser.getCurrentToken() == .) {
             return null;
         }
 
         if (type instanceof ArrayType) {
             List<Objectlist = new ArrayList<>();
             checkState(parser.getCurrentToken() == ."Expected a json array");
             while (parser.nextToken() != .) {
                 list.add(stackRepresentationToObjectHelper(sessionparser, ((ArrayTypetype).getElementType()));
             }
 
             return Collections.unmodifiableList(list);
         }
 
         if (type instanceof MapType) {
             Map<ObjectObjectmap = new LinkedHashMap<>();
             checkState(parser.getCurrentToken() == ."Expected a json object");
             while (parser.nextValue() != .) {
                 Object key = mapKeyToObject(sessionparser.getCurrentName(), ((MapTypetype).getKeyType());
                 Object value = stackRepresentationToObjectHelper(sessionparser, ((MapTypetype).getValueType());
                 map.put(keyvalue);
             }
 
             return Collections.unmodifiableMap(map);
         }
 
        if (type instanceof RowType) {
            List<Objectlist = new ArrayList<>();
            checkState(parser.getCurrentToken() == ."Expected a json array");
            int field = 0;
            RowType rowType = (RowTypetype;
            while (parser.nextValue() != .) {
                checkArgument(field < rowType.getFields().size(), "Unexpected field for type %s"type);
                Object value = stackRepresentationToObjectHelper(sessionparserrowType.getFields().get(field).getType());
                list.add(value);
                field++;
            }
            checkArgument(field == rowType.getFields().size(), "Expected %d fields for type %s"rowType.getFields().size(), type);
            return Collections.unmodifiableList(list);
        }
        BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus());
        if (type.getJavaType() == boolean.class) {
            type.writeBoolean(blockBuilderparser.getBooleanValue());
        }
        else if (type.getJavaType() == long.class) {
            type.writeLong(blockBuilderparser.getLongValue());
        }
        else if (type.getJavaType() == double.class) {
            type.writeDouble(blockBuildergetDoubleValue(parser));
        }
        else if (type.getJavaType() == Slice.class) {
            type.writeSlice(blockBuilder, Slices.utf8Slice(parser.getValueAsString()));
        }
        return type.getObjectValue(sessionblockBuilder.build(), 0);
    }
    private static Object mapKeyToObject(ConnectorSession sessionString jsonKeyType type)
    {
        BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus());
        if (type.getJavaType() == boolean.class) {
            type.writeBoolean(blockBuilder, Boolean.valueOf(jsonKey));
        }
        else if (type.getJavaType() == long.class) {
            type.writeLong(blockBuilder, Long.valueOf(jsonKey));
        }
        else if (type.getJavaType() == double.class) {
            type.writeDouble(blockBuilder, Double.valueOf(jsonKey));
        }
        else if (type.getJavaType() == Slice.class) {
            type.writeSlice(blockBuilder, Slices.utf8Slice(jsonKey));
        }
        return type.getObjectValue(sessionblockBuilder.build(), 0);
    }
    public static List<ObjectgetObjectList(Slice slice)
    {
        try {
            return .readValue(slice.getInput(), );
        }
        catch (IOException e) {
            throw new PrestoException(e);
        }
    }
    public static Map<StringObjectgetObjectMap(Slice slice)
    {
        try {
            return .readValue(slice.getInput(), );
        }
        catch (IOException e) {
            throw new PrestoException(e);
        }
    }
    public static Block createBlock(Type typeObject element)
    {
        BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus());
        Class<?> javaType = type.getJavaType();
        if (element == null) {
            blockBuilder.appendNull();
        }
        else if (javaType == boolean.class) {
            type.writeBoolean(blockBuilder, (Booleanelement);
        }
        else if (javaType == long.class) {
            type.writeLong(blockBuilder, ((Numberelement).longValue());
        }
        else if (javaType == double.class) {
            type.writeDouble(blockBuilder, (Doubleelement);
        }
        else if (javaType == Slice.class) {
            type.writeSlice(blockBuilder, Slices.utf8Slice(element.toString()));
        }
        else {
            throw new PrestoException(format("Unexpected type %s"javaType.getName()));
        }
        return blockBuilder.build();
    }
    public static Object castKey(Type typeString key)
    {
        Class<?> javaType = type.getJavaType();
        if (key == null) {
            return null;
        }
        else if (javaType == boolean.class) {
           return Boolean.valueOf(key);
        }
        else if (javaType == long.class) {
            return Long.parseLong(key);
        }
        else if (javaType == double.class) {
           return Double.parseDouble(key);
        }
        else if (javaType == Slice.class) {
            return Slices.utf8Slice(key);
        }
        else {
            throw new PrestoException(format("Unexpected type %s"javaType.getName()));
        }
    }
    public static Object castValue(Type typeObject value)
    {
        Class<?> javaType = type.getJavaType();
        if (value == null) {
            return null;
        }
        else if (javaType == boolean.class || javaType == double.class) {
            return value;
        }
        else if (javaType == long.class) {
            return ((Numbervalue).longValue();
        }
        else if (javaType == Slice.class) {
            return Slices.utf8Slice(value.toString());
        }
        else {
            throw new PrestoException(format("Unexpected type %s"javaType.getName()));
        }
    }
    public static Object getValue(Block inputType typeint position)
    {
        if (input.isNull(position)) {
            return null;
        }
        if (type.getJavaType() == long.class) {
            return type.getLong(inputposition);
        }
        else if (type.getJavaType() == double.class) {
            return type.getDouble(inputposition);
        }
        else if (type.getJavaType() == Slice.class) {
            return type.getObjectValue(nullinputposition);
        }
        else if (type.getJavaType() == boolean.class) {
            return type.getBoolean(inputposition);
        }
        else {
            throw new IllegalArgumentException("Unsupported type: " + type.getJavaType().getSimpleName());
        }
    }
    public static double getDoubleValue(JsonParser parserthrows IOException
    {
        double value;
        try {
            value = parser.getDoubleValue();
        }
        catch (JsonParseException e) {
            //handle non-numeric numbers (inf/nan)
            value = Double.parseDouble(parser.getValueAsString());
        }
        return value;
    }
    public static boolean canCastFromJson(Type type)
    {
        String baseType = type.getTypeSignature().getBase();
        if (baseType.equals(.) ||
                baseType.equals(.) ||
                baseType.equals(.) ||
                baseType.equals(.)) {
            return true;
        }
        if (type instanceof ArrayType) {
            return canCastFromJson(((ArrayTypetype).getElementType());
        }
        if (type instanceof MapType) {
            return canCastFromJson(((MapTypetype).getKeyType()) && canCastFromJson(((MapTypetype).getValueType());
        }
        return false;
    }
New to GrepCode? Check out our FAQ X