Java PrimitiveCategory.DOUBLE属性代码示例

@Override
public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
    if (arguments.length != 1) {
        throw new UDFArgumentLengthException(
            "add_feature_index() has an single arguments: array<double> features");
    }

    switch (arguments[0].getCategory()) {
        case LIST:
            argumentOI = (ListObjectInspector) arguments[0];
            ObjectInspector elmOI = argumentOI.getListElementObjectInspector();
            if (elmOI.getCategory().equals(Category.PRIMITIVE)) {
                if (((PrimitiveObjectInspector) elmOI).getPrimitiveCategory() == PrimitiveCategory.DOUBLE) {
                    break;
                }
            }
        default:
            throw new UDFArgumentTypeException(0, "Type mismatch: features");
    }

    return ObjectInspectorFactory.getStandardListObjectInspector(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
}
 

@Override
public GenericUDAFEvaluator getEvaluator(final GenericUDAFParameterInfo info) throws SemanticException {
  final ObjectInspector[] inspectors = info.getParameterObjectInspectors();

  if (inspectors.length < 2) {
    throw new UDFArgumentException("Expected at least 2 arguments");
  }
  ObjectInspectorValidator.validateCategoryPrimitive(inspectors[0], 0);

  // No validation of the value inspector since it can be anything.
  // Override this method to validate if needed.

  // nominal number of entries
  if (inspectors.length > 2) {
    ObjectInspectorValidator.validateIntegralParameter(inspectors[2], 2);
  }

  // sampling probability
  if (inspectors.length > 3) {
    ObjectInspectorValidator.validateCategoryPrimitive(inspectors[3], 3);
    final PrimitiveObjectInspector primitiveInspector = (PrimitiveObjectInspector) inspectors[3];
    if (primitiveInspector.getPrimitiveCategory() != PrimitiveCategory.FLOAT
        && primitiveInspector.getPrimitiveCategory() != PrimitiveCategory.DOUBLE) {
      throw new UDFArgumentTypeException(3, "float or double value expected as parameter 4 but "
          + primitiveInspector.getPrimitiveCategory().name() + " was received");
    }
  }

  checkExtraArguments(inspectors);

  return createEvaluator();
}
 

@Override
public GenericUDAFEvaluator getEvaluator(final GenericUDAFParameterInfo info) throws SemanticException {
  final ObjectInspector[] inspectors = info.getParameterObjectInspectors();

  if (inspectors.length < 2) {
    throw new UDFArgumentException("Expected at least 2 arguments");
  }
  ObjectInspectorValidator.validateCategoryPrimitive(inspectors[0], 0);

  int numValues = 0;
  while (numValues + 1 < inspectors.length) {
    ObjectInspectorValidator.validateCategoryPrimitive(inspectors[numValues + 1], numValues + 1);
    final PrimitiveObjectInspector primitiveInspector =
        (PrimitiveObjectInspector) inspectors[numValues + 1];
    if (primitiveInspector.getPrimitiveCategory() != PrimitiveCategory.DOUBLE) { break; }
    numValues++;
  }
  if (numValues == 0) {
    throw new UDFArgumentException("Expected at least 1 double value");
  }

  // nominal number of entries
  if (inspectors.length > numValues + 1) {
    ObjectInspectorValidator.validateIntegralParameter(inspectors[numValues + 1], numValues + 1);
  }

  // sampling probability
  if (inspectors.length > numValues + 2) {
    ObjectInspectorValidator.validateGivenPrimitiveCategory(inspectors[numValues + 2],
        numValues + 2, PrimitiveCategory.FLOAT);
  }

  // there must be nothing after sampling probability
  if (inspectors.length > numValues + 3) {
    throw new UDFArgumentException("Unexpected argument " + (numValues + 4));
  }

  return new DataToArrayOfDoublesSketchEvaluator();
}
 

public GenericUDFTestDOUBLE() {
  super("testHiveUDFDOUBLE", PrimitiveCategory.DOUBLE);
}
 

@Override
public ObjectInspector init(final Mode mode, final ObjectInspector[] parameters) throws HiveException {
  super.init(mode, parameters);
  mode_ = mode;
  if (mode == Mode.PARTIAL1 || mode == Mode.COMPLETE) {
    // input is original data
    keyInspector_ = (PrimitiveObjectInspector) parameters[0];
    numValues_ = 0;
    while (numValues_ + 1 < parameters.length) {
      if (((PrimitiveObjectInspector) parameters[numValues_ + 1]).getPrimitiveCategory()
          != PrimitiveCategory.DOUBLE) {
        break;
      }
      numValues_++;
    }
    valuesInspectors_ = new PrimitiveObjectInspector[numValues_];
    for (int i = 0; i < numValues_; i++) {
      valuesInspectors_[i] = (PrimitiveObjectInspector) parameters[i + 1];
    }
    if (parameters.length > numValues_ + 1) {
      nominalNumEntriesInspector_ = (PrimitiveObjectInspector) parameters[numValues_ + 1];
    }
    if (parameters.length > numValues_ + 2) {
      samplingProbabilityInspector_ = (PrimitiveObjectInspector) parameters[numValues_ + 2];
    }
  } else {
    // input for PARTIAL2 and FINAL is the output from PARTIAL1
    intermediateInspector_ = (StructObjectInspector) parameters[0];
  }

  if (mode == Mode.PARTIAL1 || mode == Mode.PARTIAL2) {
    // intermediate results need to include the the nominal number of entries and number of values
    return ObjectInspectorFactory.getStandardStructObjectInspector(
      Arrays.asList(NOMINAL_NUM_ENTRIES_FIELD, NUM_VALUES_FIELD, SKETCH_FIELD),
      Arrays.asList(
        PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(PrimitiveCategory.INT),
        PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(PrimitiveCategory.INT),
        PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(PrimitiveCategory.BINARY)
      )
    );
  }
  // final results include just the sketch
  return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(PrimitiveCategory.BINARY);
}