@Override public StructObjectInspector initialize(ObjectInspector[] args) throws UDFArgumentException { if (args.length != 1) { throw new UDFArgumentException("posexplode() takes only one argument"); } if (args[0].getCategory() != ObjectInspector.Category.LIST) { throw new UDFArgumentException("posexplode() takes an array as a parameter"); } listOI = (ListObjectInspector) args[0]; ArrayList<String> fieldNames = new ArrayList<String>(); ArrayList<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>(); fieldNames.add("pos"); fieldNames.add("val"); fieldOIs.add(PrimitiveObjectInspectorFactory .getPrimitiveJavaObjectInspector(PrimitiveCategory.INT)); fieldOIs.add(listOI.getListElementObjectInspector()); return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs); }
if (arguments[0].getCategory() != Category.PRIMITIVE) { throw new UDFArgumentException( "ABS only takes primitive types, got " + arguments[0].getTypeName()); inputType = argumentOI.getPrimitiveCategory(); ObjectInspector outputOI = null; switch (inputType) { case STRING: case DOUBLE: inputConverter = ObjectInspectorConverters.getConverter(arguments[0], PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); outputOI = PrimitiveObjectInspectorFactory.writableDoubleObjectInspector; break; case DECIMAL: outputOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( ((PrimitiveObjectInspector) arguments[0]).getTypeInfo()); break; default: throw new UDFArgumentException( "ABS only takes SHORT/BYTE/INT/LONG/DOUBLE/FLOAT/STRING/DECIMAL types, got " + inputType);
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { return PrimitiveObjectInspectorFactory.getPrimitiveWritableConstantObjectInspector( TypeInfoFactory.stringTypeInfo, new Text(SessionState.get().getCurrentCatalog())); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length != 1) { throw new UDFArgumentException(opName + " requires one argument."); } Category category = arguments[0].getCategory(); if (category != Category.PRIMITIVE) { throw new UDFArgumentTypeException(0, "The " + GenericUDFUtils.getOrdinal(1) + " argument of " + opName + " is expected to a " + Category.PRIMITIVE.toString().toLowerCase() + " type, but " + category.toString().toLowerCase() + " is found"); } inputOI = (PrimitiveObjectInspector) arguments[0]; if (!FunctionRegistry.isNumericType(inputOI.getTypeInfo()) && (inputOI.getTypeInfo() != TypeInfoFactory.intervalDayTimeTypeInfo) && (inputOI.getTypeInfo() != TypeInfoFactory.intervalYearMonthTypeInfo)) { throw new UDFArgumentTypeException(0, "The " + GenericUDFUtils.getOrdinal(1) + " argument of " + opName + " is expected to be a " + "numeric or interval type, but " + inputOI.getTypeName() + " is found"); } PrimitiveTypeInfo resultTypeInfo = deriveResultTypeInfo(inputOI.getTypeInfo()); resultOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(resultTypeInfo); converter = ObjectInspectorConverters.getConverter(inputOI, resultOI); return resultOI; }
return getPrimitiveJavaObjectInspector(new DecimalTypeInfo(decimalType.getPrecision(), decimalType.getScale())); return ObjectInspectorFactory.getStandardListObjectInspector(getJavaObjectInspector(type.getTypeParameters().get(0))); return ObjectInspectorFactory.getStandardMapObjectInspector(keyObjectInspector, valueObjectInspector); return ObjectInspectorFactory.getStandardStructObjectInspector( type.getTypeSignature().getParameters().stream() .map(parameter -> parameter.getNamedTypeSignature().getName().get())
if (arguments[0].getCategory() != Category.PRIMITIVE) { throw new UDFArgumentException( "LOWER only takes primitive types, got " + arguments[0].getTypeName()); PrimitiveCategory inputType = argumentOI.getPrimitiveCategory(); ObjectInspector outputOI = null; BaseCharTypeInfo typeInfo; typeInfo = TypeInfoFactory.getCharTypeInfo( GenericUDFUtils.StringHelper.getFixedStringSizeForType(argumentOI)); outputOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(typeInfo); break; case VARCHAR: typeInfo = TypeInfoFactory.getVarcharTypeInfo( GenericUDFUtils.StringHelper.getFixedStringSizeForType(argumentOI)); outputOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(typeInfo); break; default:
switch (outputOI.getCategory()) { case PRIMITIVE: return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( primOutputOI.getTypeInfo()); case STRUCT: StructObjectInspector structOutputOI = (StructObjectInspector) outputOI; structFieldObjectInspectors.add(getConvertedOI(listField.getFieldObjectInspector(), listField.getFieldObjectInspector(), oiSettableProperties, false)); return ObjectInspectorFactory.getStandardStructObjectInspector( structFieldNames, structFieldObjectInspectors); ListObjectInspector listOutputOI = (ListObjectInspector) outputOI; return ObjectInspectorFactory.getStandardMapObjectInspector( getConvertedOI(mapOutputOI.getMapKeyObjectInspector(), mapOutputOI.getMapKeyObjectInspector(), oiSettableProperties, false), getConvertedOI(mapOutputOI.getMapValueObjectInspector(), + inputOI.getTypeName() + " to " + outputOI.getTypeName() + " not supported yet.");
private void prunePartitionSingleSource(SourceInfo info, MapWork work) throws HiveException { Set<Object> values = info.values; String columnName = info.columnName; ObjectInspector oi = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(TypeInfoFactory .getPrimitiveTypeInfo(info.fieldInspector.getTypeName())); ObjectInspectorConverters.Converter converter = ObjectInspectorConverters.getConverter( PrimitiveObjectInspectorFactory.javaStringObjectInspector, oi); StructObjectInspector soi = ObjectInspectorFactory.getStandardStructObjectInspector( Collections.singletonList(columnName), Collections.singletonList(oi)); @SuppressWarnings("rawtypes") ExprNodeEvaluator eval = ExprNodeEvaluatorFactory.get(info.partKey); eval.initialize(soi); applyFilterToPartitions(work, converter, eval, columnName, values); }
if (arguments[0].getCategory() != Category.PRIMITIVE) { throw new UDFArgumentException( "LOWER only takes primitive types, got " + argumentOI.getTypeName()); PrimitiveCategory inputType = argumentOI.getPrimitiveCategory(); ObjectInspector outputOI = null; BaseCharTypeInfo typeInfo; typeInfo = TypeInfoFactory.getCharTypeInfo( GenericUDFUtils.StringHelper.getFixedStringSizeForType(argumentOI)); outputOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(typeInfo); break; case VARCHAR: typeInfo = TypeInfoFactory.getVarcharTypeInfo( GenericUDFUtils.StringHelper.getFixedStringSizeForType(argumentOI)); outputOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(typeInfo); break; default:
+ " accepts 2 or more arguments."); if (arguments[0].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(1, "The target instance should be a primitive type."); throw new UDFArgumentTypeException(1, "The method name should be string type."); throw new UDFArgumentTypeException(1, "The method name should be a constant."); targetOI.getPrimitiveCategory()).primitiveJavaClass; returnOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( typeEntry.primitiveCategory); returnObj = (Writable) returnOI.getPrimitiveWritableClass().newInstance(); } catch (Exception e) { throw new UDFArgumentException(e);
for (Map.Entry<String, String> entry : partSpec.entrySet()) { partNames.add(entry.getKey()); ObjectInspector oi = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector (TypeInfoFactory.getPrimitiveTypeInfo(partKeyTypes[i++])); partValues.add(ObjectInspectorConverters.getConverter( PrimitiveObjectInspectorFactory.javaStringObjectInspector, oi) .convert(entry.getValue())); .getStandardStructObjectInspector(partNames, partObjectInspectors); .getUnionStructObjectInspector(ois); .getPrimitiveJavaObject(evaluateResultO);
throw new UDFArgumentTypeException(0, getFuncName() + ": may only accept constant as first argument"); throw new UDFArgumentTypeException(0, "must supply operationmode"); throw new UDFArgumentTypeException(0, getFuncName() + ": unsupported operationMode: " + operationMode); if (arguments[1].getCategory() != Category.PRIMITIVE) { throw new UDFArgumentTypeException(1, "The first argument to " + getFuncName() + " must be primitive"); PrimitiveCategory inputCategory = inputOI.getPrimitiveCategory(); return PrimitiveObjectInspectorFactory.getPrimitiveWritableConstantObjectInspector( processor.getTypeInfo(), processor.evaluate(getConstantStringValue(arguments, 1))); } else { return PrimitiveObjectInspectorFactory .getPrimitiveWritableObjectInspector(processor.getTypeInfo());
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length != 1) { throw new UDFArgumentLengthException(String.format("%s needs 1 argument, got %d", udfName, arguments.length)); } if (arguments[0].getCategory() != Category.PRIMITIVE || ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory() != inputType) { String actual = arguments[0].getCategory() + (arguments[0].getCategory() == Category.PRIMITIVE ? "[" + ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory() + "]" : ""); throw new UDFArgumentException( String.format("%s only takes primitive type %s, got %s", udfName, inputType, actual)); } argumentOI = arguments[0]; return PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(outputType); }
private StructObjectInspector getPartitionKeyOI(TableDesc tableDesc) throws Exception { String pcols = tableDesc.getProperties().getProperty( org.apache.hadoop.hive.metastore.api.hive_metastoreConstants.META_TABLE_PARTITION_COLUMNS); String pcolTypes = tableDesc.getProperties().getProperty( org.apache.hadoop.hive.metastore.api.hive_metastoreConstants.META_TABLE_PARTITION_COLUMN_TYPES); String[] partKeys = pcols.trim().split("/"); String[] partKeyTypes = pcolTypes.trim().split(":"); ObjectInspector[] inspectors = new ObjectInspector[partKeys.length]; for (int i = 0; i < partKeys.length; i++) { inspectors[i] = PrimitiveObjectInspectorFactory .getPrimitiveWritableObjectInspector(TypeInfoFactory .getPrimitiveTypeInfo(partKeyTypes[i])); } return ObjectInspectorFactory.getStandardStructObjectInspector( Arrays.asList(partKeys), Arrays.asList(inspectors)); }
ObjectInspectorConverters.getConverter(oi, writableOI).convert(value); switch (writableOI.getCategory()) { case PRIMITIVE: PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; return PrimitiveObjectInspectorFactory.getPrimitiveWritableConstantObjectInspector( poi.getTypeInfo(), writableValue); case LIST: ListObjectInspector loi = (ListObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantListObjectInspector( getStandardObjectInspector( loi.getListElementObjectInspector(), case MAP: MapObjectInspector moi = (MapObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantMapObjectInspector( getStandardObjectInspector( moi.getMapKeyObjectInspector(), writableValue = java.util.Arrays.asList((Object[])writableValue); return ObjectInspectorFactory.getStandardConstantStructObjectInspector( fieldNames, fieldObjectInspectors, default: throw new IllegalArgumentException( writableOI.getCategory() + " not yet supported for constant OI");
bs.clear(); PrimitiveObjectInspector bucketOI = (PrimitiveObjectInspector)bucketField.getFieldObjectInspector(); PrimitiveObjectInspector constOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(bucketOI.getPrimitiveCategory()); PrimitiveObjectInspector origOI = PrimitiveObjectInspectorFactory.getPrimitiveObjectInspectorFromClass(literal.getClass()); Converter conv = ObjectInspectorConverters.getConverter(origOI, constOI);
private void testDecimalDivisionResultType(int prec1, int scale1, int prec2, int scale2, int prec3, int scale3) throws HiveException { GenericUDFOPDivide udf = new GenericUDFOPDivide(); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(TypeInfoFactory.getDecimalTypeInfo(prec1, scale1)), PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(TypeInfoFactory.getDecimalTypeInfo(prec2, scale2)) }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(TypeInfoFactory.getDecimalTypeInfo(prec3, scale3), oi.getTypeInfo()); }
/** * Ensures that an ObjectInspector is Writable. */ public static ObjectInspector getWritableObjectInspector(ObjectInspector oi) { // All non-primitive OIs are writable so we need only check this case. if (oi.getCategory() == Category.PRIMITIVE) { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; if (!(poi instanceof AbstractPrimitiveWritableObjectInspector)) { return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( poi.getTypeInfo()); } } return oi; }
if (!PrimitiveObjectInspectorUtils.getPrimitiveGrouping(originTsOI.getPrimitiveCategory()) .equals(PrimitiveObjectInspectorUtils.PrimitiveGrouping.DATE_GROUP)) { throw new UDFArgumentException("Third arg has to be timestamp got " + originTsOI.getTypeInfo().toString()); if (!PrimitiveObjectInspectorUtils.getPrimitiveGrouping(timestampOI.getPrimitiveCategory()) .equals(PrimitiveObjectInspectorUtils.PrimitiveGrouping.DATE_GROUP)) { throw new UDFArgumentException("First arg has to be timestamp got " + timestampOI.getTypeInfo().toString()); if (!intervalOI.getPrimitiveCategory().equals(PrimitiveObjectInspector.PrimitiveCategory.INTERVAL_DAY_TIME)) { throw new UDFArgumentException("Second arg has to be interval got " + intervalOI.getTypeInfo().toString()); return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(TypeInfoFactory.timestampTypeInfo);
static synchronized public ObjectPair<PrimitiveObjectInspector, ExprNodeEvaluator> prepareExpr( ExprNodeGenericFuncDesc expr, List<String> partColumnNames, List<PrimitiveTypeInfo> partColumnTypeInfos) throws HiveException { // Create the row object List<ObjectInspector> partObjectInspectors = new ArrayList<ObjectInspector>(); for (int i = 0; i < partColumnNames.size(); i++) { partObjectInspectors.add(PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector( partColumnTypeInfos.get(i))); } StructObjectInspector objectInspector = ObjectInspectorFactory .getStandardStructObjectInspector(partColumnNames, partObjectInspectors); ExprNodeEvaluator evaluator = ExprNodeEvaluatorFactory.get(expr); ObjectInspector evaluateResultOI = evaluator.initialize(objectInspector); return ObjectPair.create((PrimitiveObjectInspector)evaluateResultOI, evaluator); }