case AVRO: result = new AvroLazyObjectInspector(structFieldNames, structFieldObjectInspectors, structFieldComments, separator, lazyParams); break;
return deserializeStruct(rowField, f.getFieldName()); lazyMap.getMap().put(_key, deserializeStruct(_value, f.getFieldName())); return toLazyObject(field, f.getFieldObjectInspector());
@Override public List<Object> getStructFieldsDataAsList(Object data) { if (data == null) { return null; } List<Object> result = new ArrayList<Object>(fields.size()); for (int i = 0; i < fields.size(); i++) { result.add(getStructFieldData(data, fields.get(i))); } return result; }
/** * Converts the given field to a lazy object * * @param field to be converted to a lazy object * @param fieldOI {@link ObjectInspector} for the given field * @return returns the converted lazy object * */ private Object toLazyObject(Object field, ObjectInspector fieldOI) { if (isPrimitive(field.getClass())) { return toLazyPrimitiveObject(field, fieldOI); } else if (fieldOI instanceof LazyListObjectInspector) { return toLazyListObject(field, fieldOI); } else if (field instanceof StandardUnion) { return toLazyUnionObject(field, fieldOI); } else if (fieldOI instanceof LazyMapObjectInspector) { return toLazyMapObject(field, fieldOI); } else { return field; } }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param objectInspector ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ @SuppressWarnings({ "rawtypes", "unchecked" }) private Object toLazyMapObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } // avro guarantees that the key will be of type string. So we just need to worry about // deserializing the value here LazyMap lazyMap = (LazyMap) LazyFactory.createLazyObject(objectInspector); Map map = lazyMap.getMap(); Map<Object, Object> origMap = (Map) obj; ObjectInspector keyObjectInspector = ((MapObjectInspector) objectInspector).getMapKeyObjectInspector(); ObjectInspector valueObjectInspector = ((MapObjectInspector) objectInspector).getMapValueObjectInspector(); for (Entry entry : origMap.entrySet()) { Object value = entry.getValue(); map.put(toLazyPrimitiveObject(entry.getKey(), keyObjectInspector), toLazyObject(value, valueObjectInspector)); } return lazyMap; }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param objectInspector ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ private Object toLazyListObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } List<?> listObj = (List<?>) obj; LazyArray retList = (LazyArray) LazyFactory.createLazyObject(objectInspector); List<Object> lazyList = retList.getList(); ObjectInspector listElementOI = ((ListObjectInspector) objectInspector).getListElementObjectInspector(); for (int i = 0; i < listObj.size(); i++) { lazyList.add(toLazyObject(listObj.get(i), listElementOI)); } return retList; }
ws = retrieveSchemaFromBytes(data);
/** * Converts the given field to a lazy object * * @param field to be converted to a lazy object * @param fieldOI {@link ObjectInspector} for the given field * @return returns the converted lazy object * */ private Object toLazyObject(Object field, ObjectInspector fieldOI) { if (isPrimitive(field.getClass())) { return toLazyPrimitiveObject(field, fieldOI); } else if (fieldOI instanceof LazyListObjectInspector) { return toLazyListObject(field, fieldOI); } else if (field instanceof StandardUnion) { return toLazyUnionObject(field, fieldOI); } else if (fieldOI instanceof LazyMapObjectInspector) { return toLazyMapObject(field, fieldOI); } else { return field; } }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param oi ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ @SuppressWarnings({ "rawtypes", "unchecked" }) private Object toLazyMapObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } // avro guarantees that the key will be of type string. So we just need to worry about // deserializing the value here LazyMap lazyMap = (LazyMap) LazyFactory.createLazyObject(objectInspector); Map map = lazyMap.getMap(); Map<Object, Object> origMap = (Map) obj; ObjectInspector keyObjectInspector = ((MapObjectInspector) objectInspector).getMapKeyObjectInspector(); ObjectInspector valueObjectInspector = ((MapObjectInspector) objectInspector).getMapValueObjectInspector(); for (Entry entry : origMap.entrySet()) { Object value = entry.getValue(); map.put(toLazyPrimitiveObject(entry.getKey(), keyObjectInspector), toLazyObject(value, valueObjectInspector)); } return lazyMap; }
convertedObj = toLazyObject(field, fieldOI);
/** * Converts the given field to a lazy object * * @param field to be converted to a lazy object * @param fieldOI {@link ObjectInspector} for the given field * @return returns the converted lazy object * */ private Object toLazyObject(Object field, ObjectInspector fieldOI) { if (isPrimitive(field.getClass())) { return toLazyPrimitiveObject(field, fieldOI); } else if (fieldOI instanceof LazyListObjectInspector) { return toLazyListObject(field, fieldOI); } else if (field instanceof StandardUnion) { return toLazyUnionObject(field, fieldOI); } else if (fieldOI instanceof LazyMapObjectInspector) { return toLazyMapObject(field, fieldOI); } else { return field; } }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param oi ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ @SuppressWarnings({ "rawtypes", "unchecked" }) private Object toLazyMapObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } // avro guarantees that the key will be of type string. So we just need to worry about // deserializing the value here LazyMap lazyMap = (LazyMap) LazyFactory.createLazyObject(objectInspector); Map map = lazyMap.getMap(); Map<Object, Object> origMap = (Map) obj; ObjectInspector keyObjectInspector = ((MapObjectInspector) objectInspector).getMapKeyObjectInspector(); ObjectInspector valueObjectInspector = ((MapObjectInspector) objectInspector).getMapValueObjectInspector(); for (Entry entry : origMap.entrySet()) { Object value = entry.getValue(); map.put(toLazyPrimitiveObject(entry.getKey(), keyObjectInspector), toLazyObject(value, valueObjectInspector)); } return lazyMap; }
return deserializeStruct(rowField, f.getFieldName()); lazyMap.getMap().put(_key, deserializeStruct(_value, f.getFieldName())); return toLazyObject(field, f.getFieldObjectInspector());
@Override public Object getStructFieldData(Object data, StructField fieldRef) { if (data == null) { return null; } StructObject struct = (StructObject) data; MyField f = (MyField) fieldRef; int fieldID = f.getFieldID(); assert (fieldID >= 0 && fieldID < fields.size()); ObjectInspector oi = f.getFieldObjectInspector(); if (oi instanceof AvroLazyObjectInspector) { return ((AvroLazyObjectInspector) oi).getStructFieldData(data, fieldRef); } if (oi instanceof MapObjectInspector) { ObjectInspector valueOI = ((MapObjectInspector) oi).getMapValueObjectInspector(); if (valueOI instanceof AvroLazyObjectInspector) { return ((AvroLazyObjectInspector) valueOI).getStructFieldData(data, fieldRef); } } return struct.getField(fieldID); }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param oi ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ private Object toLazyListObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } List<?> listObj = (List<?>) obj; LazyArray retList = (LazyArray) LazyFactory.createLazyObject(objectInspector); List<Object> lazyList = retList.getList(); ObjectInspector listElementOI = ((ListObjectInspector) objectInspector).getListElementObjectInspector(); for (int i = 0; i < listObj.size(); i++) { lazyList.add(toLazyObject(listObj.get(i), listElementOI)); } return retList; }
case AVRO: result = new AvroLazyObjectInspector(structFieldNames, structFieldObjectInspectors, structFieldComments, separator, lazyParams); break;
/** * Converts the given field to a lazy object * * @param field to be converted to a lazy object * @param fieldOI {@link ObjectInspector} for the given field * @return returns the converted lazy object * */ private Object toLazyObject(Object field, ObjectInspector fieldOI) { if (isPrimitive(field.getClass())) { return toLazyPrimitiveObject(field, fieldOI); } else if (fieldOI instanceof LazyListObjectInspector) { return toLazyListObject(field, fieldOI); } else if (field instanceof StandardUnion) { return toLazyUnionObject(field, fieldOI); } else if (fieldOI instanceof LazyMapObjectInspector) { return toLazyMapObject(field, fieldOI); } else { return field; } }
/** * Convert the given object to a lazy object using the given {@link ObjectInspector} * * @param obj Object to be converted to a {@link LazyObject} * @param oi ObjectInspector used for the conversion * @return the created {@link LazyObject lazy object} * */ @SuppressWarnings({ "rawtypes", "unchecked" }) private Object toLazyMapObject(Object obj, ObjectInspector objectInspector) { if (obj == null) { return null; } // avro guarantees that the key will be of type string. So we just need to worry about // deserializing the value here LazyMap lazyMap = (LazyMap) LazyFactory.createLazyObject(objectInspector); Map map = lazyMap.getMap(); Map<Object, Object> origMap = (Map) obj; ObjectInspector keyObjectInspector = ((MapObjectInspector) objectInspector).getMapKeyObjectInspector(); ObjectInspector valueObjectInspector = ((MapObjectInspector) objectInspector).getMapValueObjectInspector(); for (Entry entry : origMap.entrySet()) { Object value = entry.getValue(); map.put(toLazyPrimitiveObject(entry.getKey(), keyObjectInspector), toLazyObject(value, valueObjectInspector)); } return lazyMap; }