private String describeOi(String desc, ObjectInspector keyOi) { for (StructField field : ((StructObjectInspector)keyOi).getAllStructFieldRefs()) { ObjectInspector oi = field.getFieldObjectInspector(); String cat = oi.getCategory().toString(); if (oi.getCategory() == Category.PRIMITIVE) { cat = ((PrimitiveObjectInspector)oi).getPrimitiveCategory().toString(); } desc += field.getFieldName() + ":" + cat + ", "; } return desc; } }
@Override public int computeBucketId(Object record) { Object[] bucketFieldValues = new Object[bucketFields.length]; ObjectInspector[] bucketFiledInspectors = new ObjectInspector[bucketFields.length]; for (int columnIndex = 0; columnIndex < bucketFields.length; columnIndex++) { bucketFieldValues[columnIndex] = structObjectInspector.getStructFieldData(record, bucketFields[columnIndex]); bucketFiledInspectors[columnIndex] = bucketFields[columnIndex].getFieldObjectInspector(); } return ObjectInspectorUtils.getBucketNumber(bucketFieldValues, bucketFiledInspectors, totalBuckets); }
private boolean mapHasStringKey(ObjectInspector mapKeyObjectInspector) { return mapKeyObjectInspector instanceof PrimitiveObjectInspector && ((PrimitiveObjectInspector) mapKeyObjectInspector) .getPrimitiveCategory() .equals(PrimitiveObjectInspector.PrimitiveCategory.STRING); }
private void parseBooleanColumn(int column) { loaded[column] = true; Object fieldData = rowInspector.getStructFieldData(rowData, structFields[column]); if (fieldData == null) { nulls[column] = true; } else { Object fieldValue = ((PrimitiveObjectInspector) fieldInspectors[column]).getPrimitiveJavaObject(fieldData); checkState(fieldValue != null, "fieldValue should not be null"); booleans[column] = (Boolean) fieldValue; nulls[column] = false; } }
protected void obtainStringConverter(ObjectInspector[] arguments, int i, PrimitiveCategory[] inputTypes, Converter[] converters) throws UDFArgumentTypeException { PrimitiveObjectInspector inOi = (PrimitiveObjectInspector) arguments[i]; PrimitiveCategory inputType = inOi.getPrimitiveCategory(); Converter converter = ObjectInspectorConverters.getConverter( arguments[i], PrimitiveObjectInspectorFactory.writableStringObjectInspector); converters[i] = converter; inputTypes[i] = inputType; }
/** * Checks that an inspector matches the category indicated as a parameter. * * @param inspector The object inspector to check * @param category The category to match * @throws IllegalArgumentException if inspector does not match the category */ private void checkInspectorCategory(ObjectInspector inspector, ObjectInspector.Category category) { if (!inspector.getCategory().equals(category)) { throw new IllegalArgumentException("Invalid data type: expected " + category + " type, but found: " + inspector.getCategory()); } }
public String getType() { return objectInspector.getTypeName(); }
private void parseObjectColumn(int column) { loaded[column] = true; Object fieldData = rowInspector.getStructFieldData(rowData, structFields[column]); if (fieldData == null) { nulls[column] = true; } else { objects[column] = getBlockObject(types[column], fieldData, fieldInspectors[column]); nulls[column] = false; } }
private static SettableStructObjectInspector createSettableStructObjectInspector(String name, ObjectInspector objectInspector) { return getStandardStructObjectInspector(ImmutableList.of(name), ImmutableList.of(objectInspector)); }
@Override public void merge(AggregationBuffer agg, Object partial) throws HiveException { if (partial != null) { MinAgg myagg = (MinAgg) agg; int r = ObjectInspectorUtils.compare(myagg.o, outputOI, partial, inputOI, new FullMapEqualComparer(), NullValueOption.MAXVALUE); if (myagg.o == null || r > 0) { myagg.o = ObjectInspectorUtils.copyToStandardObject(partial, inputOI, ObjectInspectorCopyOption.JAVA); } } }
private static synchronized ObjectInspector getInspector(Type type) { // ObjectInspectorFactory.getReflectionObjectInspector is not thread-safe although it // gives people a first impression that it is. This may have been fixed in HIVE-11586. // Presto only uses getReflectionObjectInspector here, in a test method. Therefore, we // choose to work around this issue by synchronizing this method. Before synchronizing // this method, test in this class fails approximately 1 out of 10 runs on Travis. return getReflectionObjectInspector(type, ObjectInspectorOptions.JAVA); }
@Override public void setField(Block block, int position) { value.set(getHiveDecimal(decimalType, block, position)); rowInspector.setStructFieldData(row, field, value); } }
/** * Compare two objects with their respective ObjectInspectors. */ public static int compare(Object o1, ObjectInspector oi1, Object o2, ObjectInspector oi2) { return compare(o1, oi1, o2, oi2, new FullMapEqualComparer()); }
/** * Get the corresponding standard ObjectInspector for an ObjectInspector. * * The returned ObjectInspector can be used to inspect the standard object. */ public static ObjectInspector getStandardObjectInspector(ObjectInspector oi) { return getStandardObjectInspector(oi, ObjectInspectorCopyOption.DEFAULT); }
private String describeOi(String desc, ObjectInspector keyOi) { for (StructField field : ((StructObjectInspector)keyOi).getAllStructFieldRefs()) { ObjectInspector oi = field.getFieldObjectInspector(); String cat = oi.getCategory().toString(); if (oi.getCategory() == Category.PRIMITIVE) { cat = ((PrimitiveObjectInspector)oi).getPrimitiveCategory().toString(); } desc += field.getFieldName() + ":" + cat + ", "; } return desc; } }
private void parseDoubleColumn(int column) { loaded[column] = true; Object fieldData = rowInspector.getStructFieldData(rowData, structFields[column]); if (fieldData == null) { nulls[column] = true; } else { Object fieldValue = ((PrimitiveObjectInspector) fieldInspectors[column]).getPrimitiveJavaObject(fieldData); checkState(fieldValue != null, "fieldValue should not be null"); doubles[column] = ((Number) fieldValue).doubleValue(); nulls[column] = false; } }
protected void obtainDoubleConverter(ObjectInspector[] arguments, int i, PrimitiveCategory[] inputTypes, Converter[] converters) throws UDFArgumentTypeException { PrimitiveObjectInspector inOi = (PrimitiveObjectInspector) arguments[i]; PrimitiveCategory inputType = inOi.getPrimitiveCategory(); Converter converter = ObjectInspectorConverters.getConverter( arguments[i], PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); converters[i] = converter; inputTypes[i] = inputType; }
public String getType() { return objectInspector.getTypeName(); }
private void parseLongColumn(int column) { loaded[column] = true; Object fieldData = rowInspector.getStructFieldData(rowData, structFields[column]); if (fieldData == null) { nulls[column] = true; } else { Object fieldValue = ((PrimitiveObjectInspector) fieldInspectors[column]).getPrimitiveJavaObject(fieldData); checkState(fieldValue != null, "fieldValue should not be null"); longs[column] = getLongExpressedValue(fieldValue, hiveStorageTimeZone); nulls[column] = false; } }
public static void obtainBinaryConverter(ObjectInspector[] arguments, int i, PrimitiveCategory[] inputTypes, Converter[] converters) throws UDFArgumentTypeException { PrimitiveObjectInspector inOi = (PrimitiveObjectInspector) arguments[i]; PrimitiveCategory inputType = inOi.getPrimitiveCategory(); Converter converter = ObjectInspectorConverters.getConverter(arguments[i], PrimitiveObjectInspectorFactory.writableBinaryObjectInspector); converters[i] = converter; inputTypes[i] = inputType; }