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.fasterxml.jackson.core.JsonFactory.Feature.CANONICALIZE_FIELD_NAMES;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 
 public final class TypeJsonUtils
 {
     private static final JsonFactory JSON_FACTORY = new JsonFactory().disable();
 
     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 %s fields for type %s"rowType.getFields().size(), type);
            return Collections.unmodifiableList(list);
        }
        Slice sliceValue = null;
        if (type.getJavaType() == Slice.class) {
            sliceValue = Slices.utf8Slice(parser.getValueAsString());
        }
        BlockBuilder blockBuilder;
        if (type instanceof FixedWidthType) {
            blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), 1);
        }
        else {
            blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), 1, checkNotNull(sliceValue"sliceValue is null").length());
        }
        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(blockBuildercheckNotNull(sliceValue"sliceValue is null"));
        }
        return type.getObjectValue(sessionblockBuilder.build(), 0);
    }
    private static Object mapKeyToObject(ConnectorSession sessionString jsonKeyType type)
    {
        BlockBuilder blockBuilder;
        if (type instanceof FixedWidthType) {
            blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), 1);
        }
        else {
            blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), 1, jsonKey.length());
        }
        if (type.getJavaType() == boolean.class) {
            type.writeBoolean(blockBuilder, Boolean.parseBoolean(jsonKey));
        }
        else if (type.getJavaType() == long.class) {
            type.writeLong(blockBuilder, Long.parseLong(jsonKey));
        }
        else if (type.getJavaType() == double.class) {
            type.writeDouble(blockBuilder, Double.parseDouble(jsonKey));
        }
        else if (type.getJavaType() == Slice.class) {
            type.writeSlice(blockBuilder, Slices.utf8Slice(jsonKey));
        }
        return type.getObjectValue(sessionblockBuilder.build(), 0);
    }
    private 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