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.operator.aggregation;
 
 
 import java.util.Map;
 
 import static com.facebook.presto.type.MapType.toStackRepresentation;
 import static com.facebook.presto.type.TypeJsonUtils.getValue;
 import static com.facebook.presto.type.TypeJsonUtils.stackRepresentationToObject;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class KeyValuePairs
 {
     private static final int INSTANCE_SIZE = ClassLayout.parseClass(KeyValuePairs.class).instanceSize();
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapperProvider().get().registerModule(new SimpleModule().addSerializer(Slice.classnew SliceSerializer()));
     public static final int EXPECTED_HASH_SIZE = 10_000;
 
     private final GroupByHash keysHash;
     private final PageBuilder keyPageBuilder;
     private final Type keyType;
 
     private final PageBuilder valuePageBuilder;
     private final Type valueType;
 
     public KeyValuePairs(Type keyTypeType valueType)
     {
         checkNotNull(keyType"keyType is null");
         checkNotNull(valueType"valueType is null");
 
         this. = keyType;
         this. = valueType;
          = new GroupByHash(ImmutableList.of(keyType), new int[] {0}, Optional.empty(), );
          = new PageBuilder(ImmutableList.of(this.));
          = new PageBuilder(ImmutableList.of(this.));
     }
 
     public KeyValuePairs(Slice serializedType keyTypeType valueType)
     {
         checkNotNull(serialized"serialized is null");
         checkNotNull(keyType"keyType is null");
         checkNotNull(valueType"valueType is null");
 
         this. = keyType;
         this. = valueType;
          = new GroupByHash(ImmutableList.of(keyType), new int[] {0}, Optional.empty(), 10_000);
          = new PageBuilder(ImmutableList.of(this.));
          = new PageBuilder(ImmutableList.of(this.));
         deserialize(serialized);
     }
 
     public Block getKeys()
     {
         return .getBlockBuilder(0).build();
     }
 
     public Block getValues()
     {
         return .getBlockBuilder(0).build();
     }
 
     // Once we move to Page for the native container type for Maps we will get rid of the auto-boxing/unboxing here
     private void deserialize(Slice serialized)
     {
         Map<ObjectObjectmap = (Map<ObjectObject>) stackRepresentationToObject(nullserializednew MapType());
        for (Map.Entry<ObjectObjectentry : map.entrySet()) {
            add(createBlock(entry.getKey(), ), createBlock(entry.getValue(), ), 0);
        }
    }
    // Once we move to Page for the native container type for Maps we will get rid of the auto-boxing/unboxing here
    public Slice serialize()
    {
        Map<ObjectObjectnewMap = new LinkedHashMap<>();
        Block values = .getBlockBuilder(0).build();
        Block keys = .getBlockBuilder(0).build();
        for (int i = 0; i < keys.getPositionCount(); i++) {
            newMap.put(getValue(keysi), getValue(valuesi));
        }
        return toStackRepresentation(newMap);
    }
    public long estimatedInMemorySize()
    {
    }
    public void add(Block keyBlock valueint position)
    {
        Page page = new Page(key);
        if (!.contains(positionpage)) {
            int groupId = .putIfAbsent(positionpagenew Block[] { key });
            .appendValuesTo(groupId, 0);
            if (value.isNull(position)) {
                .getBlockBuilder(0).appendNull();
            }
            else {
                .appendTo(valueposition.getBlockBuilder(0));
            }
        }
    }
    private static Block createBlock(Object objType type)
    {
        BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus());
        try {
            if (obj == null) {
                return blockBuilder.appendNull().build();
            }
            else if (type.getJavaType() == double.class) {
                type.writeDouble(blockBuilder, ((Numberobj).doubleValue());
            }
            else if (type.getJavaType() == long.class) {
                type.writeLong(blockBuilder, ((Numberobj).longValue());
            }
            else if (type.getJavaType() == Slice.class) {
                //TODO is there a simpler way to handle these types?
                if (type instanceof VarcharType) {
                    type.writeSlice(blockBuilder, Slices.utf8Slice((Stringobj));
                }
                else if (type instanceof ArrayType || type instanceof MapType || type instanceof RowType) {
                    type.writeSlice(blockBuilder, Slices.utf8Slice(.writeValueAsString(obj)));
                }
                else {
                    type.writeSlice(blockBuilder, (Sliceobj);
                }
            }
            else if (type.getJavaType() == boolean.class) {
                type.writeBoolean(blockBuilder, (Booleanobj);
            }
            else {
                throw new IllegalArgumentException("Unsupported type: " + type.getJavaType().getSimpleName());
            }
        }
        catch (IOException ioe) {
            Throwables.propagate(ioe);
        }
        return blockBuilder.build();
    }
New to GrepCode? Check out our FAQ X