Java DataMode.OPTIONAL屬性代碼示例

public static DataMode getLeastRestrictiveDataMode(List<DataMode> dataModes) {
  boolean hasOptional = false;
  for(DataMode dataMode : dataModes) {
    switch (dataMode) {
      case REPEATED:
        return dataMode;
      case OPTIONAL:
        hasOptional = true;
    }
  }

  if(hasOptional) {
    return DataMode.OPTIONAL;
  } else {
    return DataMode.REQUIRED;
  }
}
 

public static ObjectInspector getDrillObjectInspector(DataMode mode, MinorType minorType) {
  try {
    if (mode == DataMode.REQUIRED) {
      if (OIMAP_REQUIRED.containsKey(minorType)) {
        return (ObjectInspector) OIMAP_REQUIRED.get(minorType).newInstance();
      }
    } else if (mode == DataMode.OPTIONAL) {
      if (OIMAP_OPTIONAL.containsKey(minorType)) {
        return (ObjectInspector) OIMAP_OPTIONAL.get(minorType).newInstance();
      }
    } else {
      throw new UnsupportedOperationException("Repeated types are not supported as arguement to Hive UDFs");
    }
  } catch(InstantiationException | IllegalAccessException e) {
    throw new RuntimeException("Failed to instantiate ObjectInspector", e);
  }

  throw new UnsupportedOperationException(
      String.format("Type %s[%s] not supported as arguement to Hive UDFs", minorType.toString(), mode.toString()));
}
 

/**
 * Adds local variable declaration based on given name and type.
 *
 * @param t major type
 * @param name variable name
 * @param includeNewInstance whether to create new instance
 * @return holder instance
 */
public HoldingContainer declare(MajorType t, String name, boolean includeNewInstance) {
  JType holderType = getHolderType(t);
  JVar var;
  if (includeNewInstance) {
    var = getEvalBlock().decl(holderType, name + index, JExpr._new(holderType));
  } else {
    var = getEvalBlock().decl(holderType, name + index);
  }
  JFieldRef outputSet = null;
  if (t.getMode() == DataMode.OPTIONAL) {
    outputSet = var.ref("isSet");
  }
  index++;
  return new HoldingContainer(t, var, var.ref("value"), outputSet);
}
 

public MaterializedField getOtherNullableVersion(){
  MajorType mt = key.type;
  DataMode newDataMode = null;
  switch (mt.getMode()){
  case OPTIONAL:
    newDataMode = DataMode.REQUIRED;
    break;
  case REQUIRED:
    newDataMode = DataMode.OPTIONAL;
    break;
  default:
    throw new UnsupportedOperationException();
  }
  return new MaterializedField(key.path, mt.toBuilder().setMode(newDataMode).build());
}
 

public HoldingContainer declare(MajorType t, boolean includeNewInstance) {
  JType holderType = getHolderType(t);
  JVar var;
  if (includeNewInstance) {
    var = getEvalBlock().decl(holderType, "out" + index, JExpr._new(holderType));
  } else {
    var = getEvalBlock().decl(holderType, "out" + index);
  }
  JFieldRef outputSet = null;
  if (t.getMode() == DataMode.OPTIONAL) {
    outputSet = var.ref("isSet");
  }
  index++;
  return new HoldingContainer(t, var, var.ref("value"), outputSet);
}
 

@Override
public MajorType getMajorType() {
  // If any of argumgnet of a boolean "and"/"or" is nullable, the result is nullable bit.
  // Otherwise, it's non-nullable bit.
  for (LogicalExpression e : args) {
    if (e.getMajorType().getMode() == DataMode.OPTIONAL) {
      return Types.OPTIONAL_BIT;
    }
  }
  return Types.REQUIRED_BIT;

}
 

@Override
public Void visitIfExpression(IfExpression ifExpr, ErrorCollector errors) throws RuntimeException {
  // confirm that all conditions are required boolean values.
  IfCondition cond = ifExpr.ifCondition;
  MajorType majorType = cond.condition.getMajorType();
  if ( majorType
      .getMinorType() != MinorType.BIT) {
    errors
        .addGeneralError(
            cond.condition.getPosition(),
            String
                .format(
                    "Failure composing If Expression.  All conditions must return a boolean type.  Condition was of Type %s.",
                    majorType.getMinorType()));
  }

  // confirm that all outcomes are the same type.
  final MajorType mt = ifExpr.elseExpression.getMajorType();
  cond = ifExpr.ifCondition;
  MajorType innerT = cond.expression.getMajorType();
  if ((innerT.getMode() == DataMode.REPEATED && mt.getMode() != DataMode.REPEATED) || //
      ((innerT.getMinorType() != mt.getMinorType()) &&
      (innerT.getMode() != DataMode.OPTIONAL && mt.getMode() != DataMode.OPTIONAL &&
      (innerT.getMinorType() != MinorType.NULL && mt.getMinorType() != MinorType.NULL)))) {
    errors
        .addGeneralError(
            cond.condition.getPosition(),
            String
                .format(
                    "Failure composing If Expression.  All expressions must return the same MinorType as the else expression.  The if condition returned type type %s but the else expression was of type %s",
                    innerT, mt));
  }
  return null;
}
 

@Override
public MajorType getOutputType(List<LogicalExpression> expressions) {
  for(LogicalExpression e : expressions){
    if(e.getMajorType().getMode() == DataMode.OPTIONAL){
      return e.getMajorType();
    }
  }
  return expressions.get(0).getMajorType();
}
 

/**
 * Add a single vector initializer to a collection for the entire batch.
 * Uses the observed column size information to predict the size needed
 * when allocating a new vector for the same data. Adds a hint only for
 * variable-width or repeated types; no extra information is needed for
 * fixed width, non-repeated columns.
 *
 * @param initializer the vector initializer to hold the hints
 * for this column
 */

private void buildVectorInitializer(VectorInitializer initializer) {
  int width = 0;
  switch(metadata.getType().getMinorType()) {
  case VAR16CHAR:
  case VARBINARY:
  case VARCHAR:

    // Subtract out the offset vector width
    width = estSize - 4;

    // Subtract out the bits (is-set) vector width
    if (metadata.getDataMode() == DataMode.OPTIONAL) {
      width -= 1;
    }
    break;
  default:
    break;
  }
  String name = prefix + metadata.getName();
  if (metadata.getDataMode() == DataMode.REPEATED) {
    if (width > 0) {
      // Estimated width is width of entire column. Divide
      // by element count to get per-element size.
      initializer.variableWidthArray(name, width / estElementCountPerArray, estElementCountPerArray);
    } else {
      initializer.fixedWidthArray(name, estElementCountPerArray);
    }
  }
  else if (width > 0) {
    initializer.variableWidth(name, width);
  }
}
 

public MaterializedField getOtherNullableVersion() {
  MajorType mt = type;
  DataMode newDataMode;
  switch (mt.getMode()){
  case OPTIONAL:
    newDataMode = DataMode.REQUIRED;
    break;
  case REQUIRED:
    newDataMode = DataMode.OPTIONAL;
    break;
  default:
    throw new UnsupportedOperationException();
  }
  return new MaterializedField(name, mt.toBuilder().setMode(newDataMode).build(), children);
}
 

/**
* Get a replacing cast function for the original function, based on the specified data mode
* @param originalCastFunction original cast function
* @param dataMode data mode of the input data
* @param inputType input (minor) type for cast
* @return the name of replaced cast function
*/
public static String getReplacingCastFunction(String originalCastFunction, DataMode dataMode, MinorType inputType) {
  if(dataMode == DataMode.OPTIONAL) {
    return getReplacingCastFunctionFromNullable(originalCastFunction, inputType);
  }

  if(dataMode == DataMode.REQUIRED) {
    return getReplacingCastFunctionFromNonNullable(originalCastFunction, inputType);
  }

  throw new RuntimeException(
     String.format("replacing cast function for datatype %s is not defined", dataMode));
}
 

public static ObjectInspector getDrillObjectInspector(DataMode mode, MinorType minorType, boolean varCharToStringReplacement) {
  try {
    if (mode == DataMode.REQUIRED) {
      if (OIMAP_REQUIRED.containsKey(minorType)) {
        if (varCharToStringReplacement && minorType == MinorType.VARCHAR) {
          return (ObjectInspector) ((Class) OIMAP_REQUIRED.get(minorType).toArray()[1]).newInstance();
        } else {
          return (ObjectInspector) ((Class) OIMAP_REQUIRED.get(minorType).toArray()[0]).newInstance();
        }
      }
    } else if (mode == DataMode.OPTIONAL) {
      if (OIMAP_OPTIONAL.containsKey(minorType)) {
        if (varCharToStringReplacement && minorType == MinorType.VARCHAR) {
          return (ObjectInspector) ((Class) OIMAP_OPTIONAL.get(minorType).toArray()[1]).newInstance();
        } else {
          return (ObjectInspector) ((Class) OIMAP_OPTIONAL.get(minorType).toArray()[0]).newInstance();
        }
      }
    } else {
      throw new UnsupportedOperationException("Repeated types are not supported as arguement to Hive UDFs");
    }
  } catch(InstantiationException | IllegalAccessException e) {
    throw new RuntimeException("Failed to instantiate ObjectInspector", e);
  }

  throw new UnsupportedOperationException(
      String.format("Type %s[%s] not supported as arguement to Hive UDFs", minorType.toString(), mode.toString()));
}
 

public boolean isNullable() {
  return key.type.getMode() == DataMode.OPTIONAL;
}
 

public boolean isOptional() {
  return type.getMode() == DataMode.OPTIONAL;
}
 

@Override
public boolean isNullable() { return mode() == DataMode.OPTIONAL; }