How to use

builder

method

in

org.apache.calcite.rel.type.RelDataTypeFactory

@Override
public RelDataType getRowType(
    RelDataTypeFactory relDataTypeFactory) {
  RelDataTypeFactory.FieldInfoBuilder b = relDataTypeFactory.builder();
  for (FieldType f : fields) {
    b.add(f.name, f.relDataType);
  }
  return b.build();
}

@Override
public RelDataType deriveRowType() {
  final List<RelDataTypeField> fieldList = table.getRowType().getFieldList();
  final RelDataTypeFactory.FieldInfoBuilder builder = getCluster().getTypeFactory().builder();
  for (int field : fields) {
    builder.add(fieldList.get(field));
  }
  return builder.build();
}

final List<Integer> groupList = groupSet.asList();
assert groupList.size() == groupSet.cardinality();
final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
final List<RelDataTypeField> fieldList = inputRowType.getFieldList();
final Set<String> containedNames = Sets.newHashSet();

@Override
public void implementRewrite(RewriteImplementor implementor) {
  Map<String, RelDataType> rewriteFields = this.context.rewriteFields;
  for (Map.Entry<String, RelDataType> rewriteField : rewriteFields.entrySet()) {
    String fieldName = rewriteField.getKey();
    RelDataTypeField field = rowType.getField(fieldName, true, false);
    if (field != null) {
      RelDataType fieldType = field.getType();
      rewriteField.setValue(fieldType);
    }
  }
  // add dynamic field to the table scan if join not exist
  if (!this.context.hasJoin && !this.context.dynamicFields.isEmpty()) {
    Map<TblColRef, RelDataType> dynFields = this.context.dynamicFields;
    List<TblColRef> newCols = Lists.newArrayList(this.columnRowType.getAllColumns());
    List<RelDataTypeField> newFieldList = Lists.newArrayList(this.rowType.getFieldList());
    int paramIndex = this.rowType.getFieldList().size();
    for (TblColRef fieldCol : dynFields.keySet()) {
      newCols.add(fieldCol);
      RelDataType fieldType = dynFields.get(fieldCol);
      RelDataTypeField newField = new RelDataTypeFieldImpl(fieldCol.getName(), paramIndex++, fieldType);
      newFieldList.add(newField);
    }
    // rebuild row type
    RelDataTypeFactory.FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder();
    fieldInfo.addAll(newFieldList);
    this.rowType = getCluster().getTypeFactory().createStructType(fieldInfo);
    this.columnRowType = new ColumnRowType(newCols);
  }
}

@Override
public RelDataType deriveRowType() {
  final List<RelDataTypeField> fieldList = table.getRowType().getFieldList();
  final RelDataTypeFactory.FieldInfoBuilder builder = getCluster().getTypeFactory().builder();
  for (int field : fields) {
    builder.add(fieldList.get(field));
  }
  return getCluster().getTypeFactory().createStructType(builder);
}

final List<Integer> groupList = groupSet.asList();
assert groupList.size() == groupSet.cardinality();
final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
final List<RelDataTypeField> fieldList = inputRowType.getFieldList();
final Set<String> containedNames = Sets.newHashSet();

final List<ImmutableIntList> sources = new ArrayList<>();
final Set<ImmutableIntList> sourceSet = new HashSet<>();
final RelDataTypeFactory.Builder b = typeFactory.builder();
if (names != null) {
  for (String name : names) {

@SuppressWarnings("deprecation")
private RelDataType deriveRowType(RelDataTypeFactory typeFactory) {
  RelDataTypeFactory.FieldInfoBuilder fieldInfo = typeFactory.builder();
  for (ColumnDesc column : sourceColumns) {
    RelDataType sqlType = createSqlType(typeFactory, column.getUpgradedType(), column.isNullable());
    sqlType = SqlTypeUtil.addCharsetAndCollation(sqlType, typeFactory);
    fieldInfo.add(column.getName(), sqlType);
  }
  return typeFactory.createStructType(fieldInfo);
}

FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder();
fieldInfo.addAll(this.rowType.getFieldList());
fieldInfo.addAll(newFieldList);
RelDataTypeFactory.FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder();
fieldInfo.addAll(this.rowType.getFieldList());
fieldInfo.addAll(newFieldList);

FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder();
fieldInfo.addAll(newFields);
fieldInfo.addAll(newFieldList);

  tupleList(fieldNames.length, values);
final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder =
  cluster.getTypeFactory().builder();
for (final Ord<String> fieldName : Ord.zip(fieldNames)) {
 final String name =

final RelDataTypeFactory.Builder builder = typeFactory.builder();
for (final String columnName : columnNames) {
 final ValueType columnType = getColumnType(columnName);

    tupleList(fieldNames.length, values);
final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder =
    cluster.getTypeFactory().builder();
for (final Ord<String> fieldName : Ord.zip(fieldNames)) {
 final String name =

 public void onMatch(RelOptRuleCall call) {
  final Filter filter = call.rel(0);
  final Project project = call.rel(1);
  final List<RexNode> newProjects = new ArrayList<>(project.getProjects());
  newProjects.add(filter.getCondition());
  final RelOptCluster cluster = filter.getCluster();
  RelDataType newRowType =
    cluster.getTypeFactory().builder()
      .addAll(project.getRowType().getFieldList())
      .add("condition", Util.last(newProjects).getType())
      .build();
  final RelNode newProject =
    project.copy(project.getTraitSet(),
      project.getInput(),
      newProjects,
      newRowType);
  final RexInputRef newCondition =
    cluster.getRexBuilder().makeInputRef(newProject,
      newProjects.size() - 1);
  call.transformTo(filter.copy(filter.getTraitSet(), newProject, newCondition));
 }
}

  == SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS;
final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();

private static RelDataType makeStruct(
  RelDataTypeFactory typeFactory,
  RelDataType type) {
 if (type.isStruct()) {
  return type;
 }
 return typeFactory.builder().add("$0", type).build();
}

@Override public RelDataType deriveRowType() {
 final List<RelDataTypeField> fieldList = table.getRowType().getFieldList();
 final RelDataTypeFactory.Builder builder =
   getCluster().getTypeFactory().builder();
 for (int field : fields) {
  builder.add(fieldList.get(field));
 }
 return builder.build();
}

public static TranslatableTable str(Object o, Object p) {
 assertThat(RexLiteral.validConstant(o, Litmus.THROW), is(true));
 assertThat(RexLiteral.validConstant(p, Litmus.THROW), is(true));
 return new ViewTable(Object.class, typeFactory ->
   typeFactory.builder().add("c", SqlTypeName.VARCHAR, 100).build(),
   "values " + CalciteSqlDialect.DEFAULT.quoteStringLiteral(o.toString())
     + ", " + CalciteSqlDialect.DEFAULT.quoteStringLiteral(p.toString()),
   ImmutableList.of(), Arrays.asList("view"));
}

public RelDataType getRowType(RelDataTypeFactory typeFactory) {
 return typeFactory.builder()
   .add("ID", SqlTypeName.INTEGER)
   .add("MAPFIELD", SqlTypeName.ANY)
   .add("NESTEDMAPFIELD", SqlTypeName.ANY)
   .add("ARRAYFIELD", SqlTypeName.ANY)
   .add("STRINGARRAYFIELD", SqlTypeName.ANY)
   .build();
}

public RelDataType getRowType(RelDataTypeFactory typeFactory) {
 return typeFactory.builder()
   .add("country", SqlTypeName.VARCHAR)
   .add("latitude", SqlTypeName.DECIMAL).nullable(true)
   .add("longitude", SqlTypeName.DECIMAL).nullable(true)
   .add("name", SqlTypeName.VARCHAR)
   .build();
}