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