Java DataMode.REQUIRED屬性代碼示例

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()));
}
 

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 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()));
}
 

@Override
public GroupScan clone(List<SchemaPath> columns) {
  if (columns.isEmpty()) {
    throw new IllegalArgumentException("No columns for mock scan");
  }
  List<MockColumn> mockCols = new ArrayList<>();
  Pattern p = Pattern.compile("(\\w+)_([isdb])(\\d*)");
  for (SchemaPath path : columns) {
    String col = path.getLastSegment().getNameSegment().getPath();
    if (col.equals("*")) {
      return this;
    }
    Matcher m = p.matcher(col);
    if (!m.matches()) {
      throw new IllegalArgumentException(
          "Badly formatted mock column name: " + col);
    }
    @SuppressWarnings("unused")
    String name = m.group(1);
    String type = m.group(2);
    String length = m.group(3);
    int width = 10;
    if (!length.isEmpty()) {
      width = Integer.parseInt(length);
    }
    MinorType minorType;
    switch (type) {
    case "i":
      minorType = MinorType.INT;
      break;
    case "s":
      minorType = MinorType.VARCHAR;
      break;
    case "d":
      minorType = MinorType.FLOAT8;
      break;
    case "b":
      minorType = MinorType.BIT;
      break;
    default:
      throw new IllegalArgumentException(
          "Unsupported field type " + type + " for mock column " + col);
    }
    MockTableDef.MockColumn mockCol = new MockColumn(
        col, minorType, DataMode.REQUIRED, width, 0, 0, null, 1, null);
    mockCols.add(mockCol);
  }
  MockScanEntry entry = readEntries.get(0);
  MockColumn types[] = new MockColumn[mockCols.size()];
  mockCols.toArray(types);
  MockScanEntry newEntry = new MockScanEntry(entry.records, true, 0, 1, types);
  List<MockScanEntry> newEntries = new ArrayList<>();
  newEntries.add(newEntry);
  return new MockGroupScanPOP(url, newEntries);
}
 

public RequiredVectorTester(OperatorFixture fixture) {
  super(fixture, DataMode.REQUIRED, "Required vector");
}
 

public RepeatedVectorTester(OperatorFixture fixture) {
  super(fixture, DataMode.REQUIRED, "Repeated vector");
}
 

public RequiredWriterTester(OperatorFixture fixture) {
  super(fixture, DataMode.REQUIRED, "Required writer");
}
 

public ArrayWriterTester(OperatorFixture fixture) {
  super(fixture, DataMode.REQUIRED, "Array writer");
}
 

/**
 * Add a map column. The returned schema builder is for the nested
 * map. Building that map, using {@link MapBuilder#buildMap()},
 * will return the original schema builder.
 *
 * @param pathName the name of the map column
 * @return a builder for the map
 */

public MapBuilder addMap(String pathName) {
  return new MapBuilder(this, pathName, DataMode.REQUIRED);
}