How to use

createStructType

method

in

org.apache.calcite.rel.type.RelDataTypeFactory

public RelDataType getParameterRowType(SqlNode sqlQuery) {
  // NOTE: We assume that bind variables occur in depth-first tree
  // traversal in the same order that they occurred in the SQL text.
  final List<RelDataType> types = new ArrayList<>();
  // NOTE: but parameters on fetch/offset would be counted twice
  // as they are counted in the SqlOrderBy call and the inner SqlSelect call
  final Set<SqlNode> alreadyVisited = new HashSet<>();
  sqlQuery.accept(
    new SqlShuttle() {
      @Override public SqlNode visit(SqlDynamicParam param) {
        if (alreadyVisited.add(param)) {
          RelDataType type = getValidatedNodeType(param);
          types.add(type);
        }
        return param;
      }
    });
  return typeFactory.createStructType(
    types,
    new AbstractList<String>() {
      @Override public String get(int index) {
        return "?" + index;
      }
      @Override public int size() {
        return types.size();
      }
    });
}

private RelDataType getRelDataType(StructTypeInfo structTypeInfo) {
 final List<String> fieldNames = structTypeInfo.getAllStructFieldNames();
 final List<RelDataType> relDataTypes = structTypeInfo.getAllStructFieldTypeInfos().stream()
   .map(this::convertToRelDataType)
   .collect(Collectors.toList());
 return typeFactory.createStructType(relDataTypes, fieldNames);
}

@Override
public RelDataType getRowType(RelDataTypeFactory typeFactory) {
 HiveToRelDataTypeConverter dataTypeConverter = new HiveToRelDataTypeConverter(typeFactory);
 final List<String> fieldNames = new ArrayList<>();
 final List<RelDataType> fieldTypes = Stream.of(hiveTable.getColumnListsCache().getTableSchemaColumns(), hiveTable.getPartitionKeys())
     .flatMap(Collection::stream)
     .peek(hiveField -> fieldNames.add(hiveField.getName()))
     .map(dataTypeConverter::convertToNullableRelDataType)
     .collect(Collectors.toList());
 return typeFactory.createStructType(fieldTypes, fieldNames);
}

public static RelDataType convert(StructTypeInfo structType,
 final RelDataTypeFactory dtFactory) throws CalciteSemanticException {
 List<RelDataType> fTypes = new ArrayList<RelDataType>(structType.getAllStructFieldTypeInfos().size());
 for (TypeInfo ti : structType.getAllStructFieldTypeInfos()) {
  fTypes.add(convert(ti,dtFactory));
 }
 return dtFactory.createStructType(fTypes, structType.getAllStructFieldNames());
}

@Override
public RelDataType getRowType(RelDataTypeFactory typeFactory) {
 ArrayList<RelDataType> typeList = new ArrayList<>();
 ArrayList<String> fieldNameList = new ArrayList<>();
 fieldNameList.add(ROW_KEY);
 typeList.add(typeFactory.createSqlType(SqlTypeName.ANY));
 Set<byte[]> families = tableDesc.getFamiliesKeys();
 for (byte[] family : families) {
  fieldNameList.add(Bytes.toString(family));
  typeList.add(typeFactory.createMapType(typeFactory.createSqlType(SqlTypeName.VARCHAR), typeFactory.createSqlType(SqlTypeName.ANY)));
 }
 return typeFactory.createStructType(typeList, fieldNameList);
}

/*********************** Convert Hive Types To Calcite Types ***********************/
public static RelDataType getType(RelOptCluster cluster,
 List<ColumnInfo> cInfoLst) throws CalciteSemanticException {
 RexBuilder rexBuilder = cluster.getRexBuilder();
 RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory();
 List<RelDataType> fieldTypes = new LinkedList<RelDataType>();
 List<String> fieldNames = new LinkedList<String>();
 for (ColumnInfo ci : cInfoLst) {
  fieldTypes.add(convert(ci.getType(), dtFactory));
  fieldNames.add(ci.getInternalName());
 }
 return dtFactory.createStructType(fieldTypes, fieldNames);
}

public static RelDataType convert(StructTypeInfo structType,
 final RelDataTypeFactory dtFactory) throws CalciteSemanticException {
 List<RelDataType> fTypes = new ArrayList<RelDataType>(structType.getAllStructFieldTypeInfos().size());
 for (TypeInfo ti : structType.getAllStructFieldTypeInfos()) {
  fTypes.add(convert(ti,dtFactory));
 }
 return dtFactory.createStructType(fTypes, structType.getAllStructFieldNames());
}

  typeList.add(type);
rowTypes.add(typeFactory.createStructType(typeList, aliasList));

/*********************** Convert Hive Types To Calcite Types ***********************/
public static RelDataType getType(RelOptCluster cluster,
 List<ColumnInfo> cInfoLst) throws CalciteSemanticException {
 RexBuilder rexBuilder = cluster.getRexBuilder();
 RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory();
 List<RelDataType> fieldTypes = new LinkedList<RelDataType>();
 List<String> fieldNames = new LinkedList<String>();
 for (ColumnInfo ci : cInfoLst) {
  fieldTypes.add(convert(ci.getType(), dtFactory));
  fieldNames.add(ci.getInternalName());
 }
 return dtFactory.createStructType(fieldTypes, fieldNames);
}

@Override
public RelDataType getRowType(final RelDataTypeFactory typeFactory) {
 List<String> names = Lists.newArrayList();
 List<RelDataType> types = Lists.newArrayList();
 convertToRelDataType(typeFactory, names, types);
 return typeFactory.createStructType(types, names);
}

public static RelDataType getType(RelOptCluster cluster, RowResolver rr,
 List<String> neededCols) throws CalciteSemanticException {
 RexBuilder rexBuilder = cluster.getRexBuilder();
 RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory();
 RowSchema rs = rr.getRowSchema();
 List<RelDataType> fieldTypes = new LinkedList<RelDataType>();
 List<String> fieldNames = new LinkedList<String>();
 for (ColumnInfo ci : rs.getSignature()) {
  if (neededCols == null || neededCols.contains(ci.getInternalName())) {
   fieldTypes.add(convert(ci.getType(), dtFactory));
   fieldNames.add(ci.getInternalName());
  }
 }
 return dtFactory.createStructType(fieldTypes, fieldNames);
}

 private PlannerResult planExplanation(
   final RelNode rel,
   final SqlExplain explain,
   final Set<String> datasourceNames
 )
 {
  final String explanation = RelOptUtil.dumpPlan("", rel, explain.getFormat(), explain.getDetailLevel());
  final Supplier<Sequence<Object[]>> resultsSupplier = Suppliers.ofInstance(
    Sequences.simple(ImmutableList.of(new Object[]{explanation})));
  final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory();
  return new PlannerResult(
    resultsSupplier,
    typeFactory.createStructType(
      ImmutableList.of(Calcites.createSqlType(typeFactory, SqlTypeName.VARCHAR)),
      ImmutableList.of("PLAN")
    ),
    datasourceNames
  );
 }
}

public static RelDataType getType(RelOptCluster cluster, RowResolver rr,
 List<String> neededCols) throws CalciteSemanticException {
 RexBuilder rexBuilder = cluster.getRexBuilder();
 RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory();
 RowSchema rs = rr.getRowSchema();
 List<RelDataType> fieldTypes = new LinkedList<RelDataType>();
 List<String> fieldNames = new LinkedList<String>();
 for (ColumnInfo ci : rs.getSignature()) {
  if (neededCols == null || neededCols.contains(ci.getInternalName())) {
   fieldTypes.add(convert(ci.getType(), dtFactory));
   fieldNames.add(ci.getInternalName());
  }
 }
 return dtFactory.createStructType(fieldTypes, fieldNames);
}

@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 getRowType(RelDataTypeFactory typeFactory) {
 List<String> names = Lists.newArrayList();
 List<RelDataType> types = Lists.newArrayList();
 for (ColumnSchema column : schema.getColumns()) {
  names.add(column.getName());
  RelDataType type = getSqlTypeFromKuduType(typeFactory, column.getType());
  type = typeFactory.createTypeWithNullability(type, column.isNullable());
  types.add(type);
 }
 return typeFactory.createStructType(types, names);
}

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

return typeFactory.createStructType(fields);

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

protected RelDataType getLogicalTargetRowType(
  RelDataType targetRowType,
  SqlInsert insert) {
  if (insert.getTargetColumnList() == null
    && conformance.isInsertSubsetColumnsAllowed()) {
    // Target an implicit subset of columns.
    final SqlNode source = insert.getSource();
    final RelDataType sourceRowType = getNamespace(source).getRowType();
    final RelDataType logicalSourceRowType =
      getLogicalSourceRowType(sourceRowType, insert);
    final RelDataType implicitTargetRowType =
      typeFactory.createStructType(
        targetRowType.getFieldList()
          .subList(0, logicalSourceRowType.getFieldCount()));
    final SqlValidatorNamespace targetNamespace = getNamespace(insert);
    validateNamespace(targetNamespace, implicitTargetRowType);
    return implicitTargetRowType;
  } else {
    // Either the set of columns are explicitly targeted, or target the full
    // set of columns.
    return targetRowType;
  }
}

return typeFactory.createStructType(fieldList);