@Override public int compare(Object o1, MapObjectInspector moi1, Object o2, MapObjectInspector moi2) { int mapsize1 = moi1.getMapSize(o1); int mapsize2 = moi2.getMapSize(o2); if (mapsize1 != mapsize2) { return mapsize1 - mapsize2; } ObjectInspector mvoi1 = moi1.getMapValueObjectInspector(); ObjectInspector mvoi2 = moi2.getMapValueObjectInspector(); Map<?, ?> map1 = moi1.getMap(o1); for (Object mk1: map1.keySet()) { int rc = ObjectInspectorUtils.compare(moi1.getMapValueElement(o1, mk1), mvoi1, moi2.getMapValueElement(o2, mk1), mvoi2, this); if (rc != 0) { return rc; } } return 0; } }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { retArray.clear(); Object mapObj = arguments[0].get(); Map<?, ?> map = mapOI.getMap(mapObj); if (map != null) { retArray.addAll(map.values()); } return retArray; }
/** * Helper method to return underlying Java Map from * an object-representation that is readable by a provided * MapObjectInspector */ private static Map<?, ?> serializeMap(Object f, MapObjectInspector moi) throws SerDeException { ObjectInspector koi = moi.getMapKeyObjectInspector(); ObjectInspector voi = moi.getMapValueObjectInspector(); Map<Object, Object> m = new LinkedHashMap<Object, Object>(); Map<?, ?> readMap = moi.getMap(f); if (readMap == null) { return null; } else { for (Map.Entry<?, ?> entry : readMap.entrySet()) { m.put(serializeField(entry.getKey(), koi), serializeField(entry.getValue(), voi)); } } return m; }
private static Block serializeMap(Type type, BlockBuilder builder, Object object, MapObjectInspector inspector, boolean filterNullMapKeys) Map<?, ?> map = inspector.getMap(object); if (map == null) { requireNonNull(builder, "parent builder is null").appendNull();
private void getMapObject(String parentName, MapObjectInspector mapObjectInspector, Object mapObject, Map<String, Object> parsedMap) { if (mapObjectInspector.getMapSize(mapObject) < 0) { return; } String mapChildFieldNameFormat = StringUtils.replace( StringUtils.format(mapParentFieldNameFormat, parentName), MAP_CHILD_TAG, "%s" ); Map objectMap = mapObjectInspector.getMap(mapObject); PrimitiveObjectInspector key = (PrimitiveObjectInspector) mapObjectInspector.getMapKeyObjectInspector(); PrimitiveObjectInspector value = (PrimitiveObjectInspector) mapObjectInspector.getMapValueObjectInspector(); objectMap.forEach((k, v) -> { String resolvedFieldName = StringUtils.format(mapChildFieldNameFormat, key.getPrimitiveJavaObject(k).toString()); parsedMap.put(resolvedFieldName, value.getPrimitiveJavaObject(v)); }); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { retArray.clear(); Object mapObj = arguments[0].get(); Map<?,?> mapVal = mapOI.getMap(mapObj); if (mapVal != null) { retArray.addAll(mapVal.keySet()); } return retArray; }
@Override public void serialize(Object o, ObjectInspector oi, TProtocol oprot) throws TException, SerDeException, NoSuchFieldException, IllegalAccessException { DynamicSerDeTypeBase keyType = getKeyType(); DynamicSerDeTypeBase valueType = getValueType(); WriteNullsProtocol nullProtocol = (oprot instanceof WriteNullsProtocol) ? (WriteNullsProtocol) oprot : null; assert (oi.getCategory() == ObjectInspector.Category.MAP); MapObjectInspector moi = (MapObjectInspector) oi; ObjectInspector koi = moi.getMapKeyObjectInspector(); ObjectInspector voi = moi.getMapValueObjectInspector(); Map<?, ?> map = moi.getMap(o); serializeMap = new TMap(keyType.getType(), valueType.getType(), map.size()); oprot.writeMapBegin(serializeMap); for (Object element : map.entrySet()) { Map.Entry it = (Map.Entry) element; Object key = it.getKey(); Object value = it.getValue(); keyType.serialize(key, koi, oprot); if (value == null) { assert (nullProtocol != null); nullProtocol.writeNull(); } else { valueType.serialize(value, voi, oprot); } } // in theory, the below call isn't needed in non thrift_mode, but let's not // get too crazy oprot.writeMapEnd(); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { retArray.clear(); Object mapObj = arguments[0].get(); Map<?, ?> map = mapOI.getMap(mapObj); if (map != null) { retArray.addAll(map.values()); } return retArray; }
Map<?, ?> map = moi.getMap(value); if (map == null) { return;
private Object serializeMap(MapTypeInfo typeInfo, MapObjectInspector fieldOI, Object structFieldData, Schema schema) throws AvroSerdeException { // Avro only allows maps with string keys if(!mapHasStringKey(fieldOI.getMapKeyObjectInspector())) { throw new AvroSerdeException("Avro only supports maps with keys as Strings. Current Map is: " + typeInfo.toString()); } ObjectInspector mapKeyObjectInspector = fieldOI.getMapKeyObjectInspector(); ObjectInspector mapValueObjectInspector = fieldOI.getMapValueObjectInspector(); TypeInfo mapKeyTypeInfo = typeInfo.getMapKeyTypeInfo(); TypeInfo mapValueTypeInfo = typeInfo.getMapValueTypeInfo(); Map<?,?> map = fieldOI.getMap(structFieldData); Schema valueType = schema.getValueType(); Map<Object, Object> deserialized = new LinkedHashMap<Object, Object>(fieldOI.getMapSize(structFieldData)); for (Map.Entry<?, ?> entry : map.entrySet()) { deserialized.put(serialize(mapKeyTypeInfo, mapKeyObjectInspector, entry.getKey(), STRING_SCHEMA), serialize(mapValueTypeInfo, mapValueObjectInspector, entry.getValue(), valueType)); } return deserialized; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { retArray.clear(); Object mapObj = arguments[0].get(); Map<?,?> mapVal = mapOI.getMap(mapObj); if (mapVal != null) { retArray.addAll(mapVal.keySet()); } return retArray; }
Map<?, ?> mapValues = inspector.getMap(value); if (mapValues != null && mapValues.size() > 0) { recordConsumer.startField(repeatedType.getName(), 0);
@Override void write(Object obj) throws IOException { super.write(obj); if (obj != null) { MapObjectInspector insp = (MapObjectInspector) inspector; // this sucks, but it will have to do until we can get a better // accessor in the MapObjectInspector. Map<?, ?> valueMap = insp.getMap(obj); lengths.write(valueMap.size()); if (createBloomFilter) { bloomFilter.addLong(valueMap.size()); } for (Map.Entry<?, ?> entry : valueMap.entrySet()) { childrenWriters[0].write(entry.getKey()); childrenWriters[1].write(entry.getValue()); } } }
Map<?, ?> map = inputOI.getMap(input); int size = map.size();
@Override public void process(Object[] o) throws HiveException { switch (inputOI.getCategory()) { case LIST: ListObjectInspector listOI = (ListObjectInspector)inputOI; List<?> list = listOI.getList(o[0]); if (list == null) { return; } for (Object r : list) { forwardListObj[0] = r; forward(forwardListObj); } break; case MAP: MapObjectInspector mapOI = (MapObjectInspector)inputOI; Map<?,?> map = mapOI.getMap(o[0]); if (map == null) { return; } for (Entry<?,?> r : map.entrySet()) { forwardMapObj[0] = r.getKey(); forwardMapObj[1] = r.getValue(); forward(forwardMapObj); } break; default: throw new TaskExecutionException("explode() can only operate on an array or a map"); } }
@Override public void process(Object[] o) throws HiveException { switch (inputOI.getCategory()) { case LIST: ListObjectInspector listOI = (ListObjectInspector)inputOI; List<?> list = listOI.getList(o[0]); if (list == null) { return; } for (Object r : list) { forwardListObj[0] = r; forward(forwardListObj); } break; case MAP: MapObjectInspector mapOI = (MapObjectInspector)inputOI; Map<?,?> map = mapOI.getMap(o[0]); if (map == null) { return; } for (Entry<?,?> r : map.entrySet()) { forwardMapObj[0] = r.getKey(); forwardMapObj[1] = r.getValue(); forward(forwardMapObj); } break; default: throw new TaskExecutionException("explode() can only operate on an array or a map"); } }
@Override public void write(Object value) { recordConsumer.startGroup(); Map<?, ?> mapValues = inspector.getMap(value); if (mapValues != null && mapValues.size() > 0) { recordConsumer.startField(repeatedGroupName, 0); for (Map.Entry<?, ?> keyValue : mapValues.entrySet()) { recordConsumer.startGroup(); if (keyValue != null) { // write key element Object keyElement = keyValue.getKey(); recordConsumer.startField(keyName, 0); keyWriter.write(keyElement); recordConsumer.endField(keyName, 0); // write value element Object valueElement = keyValue.getValue(); if (valueElement != null) { recordConsumer.startField(valueName, 1); valueWriter.write(valueElement); recordConsumer.endField(valueName, 1); } } recordConsumer.endGroup(); } recordConsumer.endField(repeatedGroupName, 0); } recordConsumer.endGroup(); } }
@Override public void write(Object value) { recordConsumer.startGroup(); Map<?, ?> mapValues = inspector.getMap(value); if (mapValues != null && mapValues.size() > 0) { recordConsumer.startField(repeatedGroupName, 0); for (Map.Entry<?, ?> keyValue : mapValues.entrySet()) { recordConsumer.startGroup(); if (keyValue != null) { // write key element Object keyElement = keyValue.getKey(); recordConsumer.startField(keyName, 0); keyWriter.write(keyElement); recordConsumer.endField(keyName, 0); // write value element Object valueElement = keyValue.getValue(); if (valueElement != null) { recordConsumer.startField(valueName, 1); valueWriter.write(valueElement); recordConsumer.endField(valueName, 1); } } recordConsumer.endGroup(); } recordConsumer.endField(repeatedGroupName, 0); } recordConsumer.endGroup(); } }