void updateRank(List<Object> oRow) { int r = (Integer) fnOutOI.getPrimitiveJavaObject(oRow.get(rankFnIdx)); if ( r > currentRank ) { currentRank = r; } }
void updateRank(List<Object> oRow) { int r = (Integer) fnOutOI.getPrimitiveJavaObject(oRow.get(rankFnIdx)); if ( r > currentRank ) { currentRank = r; } }
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; } }
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; } }
Object[] setupParameters(DeferredObject[] arguments, int start) throws HiveException { // Get the parameter values for (int i = 0; i < parameterOIs.length; i++) { Object argument = arguments[i + start].get(); parameterJavaValues[i] = parameterOIs[i].getPrimitiveJavaObject(argument); } return parameterJavaValues; }
static Object convertPrimitive(Object val, PrimitiveObjectInspector poi) { switch (poi.getPrimitiveCategory()) { // Save char/varchar as string case CHAR: return ((HiveChar) poi.getPrimitiveJavaObject(val)).getPaddedValue(); case VARCHAR: return ((HiveVarchar) poi.getPrimitiveJavaObject(val)).toString(); case DECIMAL: return ((HiveDecimal) poi.getPrimitiveJavaObject(val)).bigDecimalValue(); default: return poi.getPrimitiveJavaObject(val); } }
private static Object coercePrimitiveObject(final PrimitiveObjectInspector inspector, final Object object) { if (object instanceof HiveDecimalWritable) { // inspector on HiveDecimal rounds off to integer for some reason. return ((HiveDecimalWritable) object).getHiveDecimal().doubleValue(); } else if (object instanceof DateWritable) { return object.toString(); } else { return inspector.getPrimitiveJavaObject(object); } }
public Object getJavaValue() { return objectInspector.getPrimitiveJavaObject(getValue()); }
Object[] setupParameters(DeferredObject[] arguments, int start) throws HiveException { // Get the parameter values for (int i = 0; i < parameterOIs.length; i++) { Object argument = arguments[i + start].get(); parameterJavaValues[i] = parameterOIs[i].getPrimitiveJavaObject(argument); } return parameterJavaValues; }
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; } }
private static ExprNodeConstantDesc toMapConstDesc(ColumnInfo colInfo, ObjectInspector inspector, ObjectInspector keyOI, ObjectInspector valueOI) { PrimitiveObjectInspector keyPoi = (PrimitiveObjectInspector)keyOI; PrimitiveObjectInspector valuePoi = (PrimitiveObjectInspector)valueOI; Map<?,?> values = (Map<?,?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); Map<Object, Object> constant = new LinkedHashMap<Object, Object>(); for (Map.Entry<?, ?> e : values.entrySet()) { constant.put(keyPoi.getPrimitiveJavaObject(e.getKey()), valuePoi.getPrimitiveJavaObject(e.getValue())); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
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)); }); }
private static ExprNodeConstantDesc toStructConstDesc(ColumnInfo colInfo, ObjectInspector inspector, List<? extends StructField> fields) { List<?> values = (List<?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); List<Object> constant = new ArrayList<Object>(); for (int i = 0; i < values.size(); i++) { Object value = values.get(i); PrimitiveObjectInspector fieldPoi = (PrimitiveObjectInspector) fields.get(i).getFieldObjectInspector(); constant.add(fieldPoi.getPrimitiveJavaObject(value)); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
private void prepareInSet(DeferredObject[] arguments) throws HiveException { constantInSet = new HashSet<Object>(); if (compareOI.getCategory().equals(ObjectInspector.Category.PRIMITIVE)) { for (int i = 1; i < arguments.length; ++i) { constantInSet.add(((PrimitiveObjectInspector) compareOI) .getPrimitiveJavaObject(conversionHelper .convertIfNecessary(arguments[i].get(), argumentOIs[i]))); } } else { for (int i = 1; i < arguments.length; ++i) { constantInSet.add(((ConstantObjectInspector) argumentOIs[i]).getWritableConstantValue()); } } }
static synchronized public Object evaluateExprOnPart( ObjectPair<PrimitiveObjectInspector, ExprNodeEvaluator> pair, Object partColValues) throws HiveException { return pair.getFirst().getPrimitiveJavaObject(pair.getSecond().evaluate(partColValues)); } }
private static ExprNodeConstantDesc toListConstDesc(ColumnInfo colInfo, ObjectInspector inspector, ObjectInspector listElementOI) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector)listElementOI; List<?> values = (List<?>)((ConstantObjectInspector) inspector).getWritableConstantValue(); List<Object> constant = new ArrayList<Object>(); for (Object o : values) { constant.add(poi.getPrimitiveJavaObject(o)); } ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), constant); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
static synchronized public Object evaluateExprOnPart( ObjectPair<PrimitiveObjectInspector, ExprNodeEvaluator> pair, Object partColValues) throws HiveException { return pair.getFirst().getPrimitiveJavaObject(pair.getSecond().evaluate(partColValues)); } }
private void parseDecimalColumn(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"); HiveDecimal decimal = (HiveDecimal) fieldValue; DecimalType columnType = (DecimalType) types[column]; BigInteger unscaledDecimal = rescale(decimal.unscaledValue(), decimal.scale(), columnType.getScale()); if (columnType.isShort()) { longs[column] = unscaledDecimal.longValue(); } else { slices[column] = Decimals.encodeUnscaledValue(unscaledDecimal); } nulls[column] = false; } }
private static ExprNodeConstantDesc toPrimitiveConstDesc(ColumnInfo colInfo, ObjectInspector inspector) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) inspector; Object constant = ((ConstantObjectInspector) inspector).getWritableConstantValue(); ExprNodeConstantDesc constantExpr = new ExprNodeConstantDesc(colInfo.getType(), poi.getPrimitiveJavaObject(constant)); constantExpr.setFoldedFromCol(colInfo.getInternalName()); return constantExpr; }
private static ExprNodeDesc toExprNodeDesc(ColumnInfo colInfo) { ObjectInspector inspector = colInfo.getObjectInspector(); if (inspector instanceof ConstantObjectInspector && inspector instanceof PrimitiveObjectInspector) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) inspector; Object constant = ((ConstantObjectInspector) inspector).getWritableConstantValue(); return new ExprNodeConstantDesc(colInfo.getType(), poi.getPrimitiveJavaObject(constant)); } // non-constant or non-primitive constants ExprNodeColumnDesc column = new ExprNodeColumnDesc(colInfo); column.setSkewedCol(colInfo.isSkewedCol()); return column; }