protected RelDataType uniquifyFields(RelDataType rowType) { return validator.getTypeFactory().createStructType( RelOptUtil.getFieldTypeList(rowType), SqlValidatorUtil.uniquify(rowType.getFieldNames())); }
public RelDataType apply(RelDataTypeFactory typeFactory) { final RelDataType type = typeFactory.createSqlType(typeName); return typeFactory.createTypeWithNullability(type, nullable); } };
public static RelDataType createMultisetType( RelDataTypeFactory typeFactory, RelDataType type, boolean nullable) { RelDataType ret = typeFactory.createMultisetType(type, -1); return typeFactory.createTypeWithNullability(ret, nullable); }
public static RelDataType createMapType( RelDataTypeFactory typeFactory, RelDataType keyType, RelDataType valueType, boolean nullable) { RelDataType ret = typeFactory.createMapType(keyType, valueType); return typeFactory.createTypeWithNullability(ret, nullable); }
} else { final RelDataType structType = typeFactory.createStructType( new RelDataType[] { type }, new String[] { validator.deriveAlias(child, 0) }); final RelDataType multisetType = typeFactory.createMultisetType(structType, -1); return typeFactory.createTypeWithNullability( multisetType, isNullable);
public static RelDataType deriveOneRowType(RelDataTypeFactory typeFactory) { return typeFactory.createStructType( new RelDataType[] { typeFactory.createSqlType( SqlTypeName.INTEGER) }, new String[] { "ZERO" }); } }
typeFactory.createSqlType(SqlTypeName.BOOLEAN); if (type.isNullable()) { indicatorType = typeFactory.createTypeWithNullability( indicatorType, true); typeFactory.createMultisetType( flattenRecordType( typeFactory,
@Test public void testTypeDump() { RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(); RelDataType t1 = typeFactory.createStructType( new RelDataType[] { typeFactory.createSqlType(SqlTypeName.DECIMAL, 5, 2), typeFactory.createSqlType(SqlTypeName.VARCHAR, 10), }, new String[] { typeFactory.createStructType( new RelDataType[] { t1, typeFactory.createMultisetType(t1, -1), }, new String[] {
if ((precision >= 0) && (scale >= 0)) { assert (sqlTypeName.allowsPrecScale(true, true)); type = typeFactory.createSqlType(sqlTypeName, precision, scale); } else if (precision >= 0) { assert (sqlTypeName.allowsPrecNoScale()); type = typeFactory.createSqlType(sqlTypeName, precision); } else { assert (sqlTypeName.allowsNoPrecNoScale()); type = typeFactory.createSqlType(sqlTypeName); charset = typeFactory.getDefaultCharset(); } else { String javaCharSetName = typeFactory.createTypeWithCharsetAndCollation( type, charset, type = typeFactory.createMultisetType(type, -1); break;
/** * Returns the type for a histogram function. It is either the actual * type or an an approximation to it. */ private RelDataType computeHistogramType(RelDataType type) { if (SqlTypeUtil.isExactNumeric(type) && type.getSqlTypeName() != SqlTypeName.BIGINT) { return typeFactory.createSqlType(SqlTypeName.BIGINT); } else if (SqlTypeUtil.isApproximateNumeric(type) && type.getSqlTypeName() != SqlTypeName.DOUBLE) { return typeFactory.createSqlType(SqlTypeName.DOUBLE); } else { return type; } } }
public RelDataType getRowType(RelDataTypeFactory typeFactory) { int columnCount = columnNames.length; final List<Pair<String, RelDataType>> columnDesc = new ArrayList<Pair<String, RelDataType>>(columnCount); for (int i = 0; i < columnCount; i++) { final RelDataType colType = typeFactory .createJavaType(columnTypes[i]); columnDesc.add(Pair.of(columnNames[i], colType)); } return typeFactory.createStructType(columnDesc); }
protected RelDataType convertToStruct(RelDataType type) { // "MULTISET [<expr>, ...]" needs to be wrapped in a record if // <expr> has a scalar type. // For example, "MULTISET [8, 9]" has type // "RECORD(INTEGER EXPR$0 NOT NULL) NOT NULL MULTISET NOT NULL". final RelDataType componentType = type.getComponentType(); if (componentType == null || componentType.isStruct()) { return type; } final RelDataTypeFactory typeFactory = validator.getTypeFactory(); final RelDataType structType = typeFactory.builder() .add(validator.deriveAlias(getNode(), 0), componentType) .build(); final RelDataType collectionType; switch (type.getSqlTypeName()) { case ARRAY: collectionType = typeFactory.createArrayType(structType, -1); break; case MULTISET: collectionType = typeFactory.createMultisetType(structType, -1); break; default: throw new AssertionError(type); } return typeFactory.createTypeWithNullability(collectionType, type.isNullable()); } }
public RelDataType inferReturnType( SqlOperatorBinding opBinding) { assert opBinding.getOperandCount() == 1; final RelDataType multisetType = opBinding.getOperandType(0); RelDataType componentType = multisetType.getComponentType(); assert componentType != null : "expected a multiset type: " + multisetType; return opBinding.getTypeFactory().createMultisetType( opBinding.getTypeFactory().createStructType( new RelDataType[] { componentType }, new String[] { SqlUtil.deriveAliasFromOrdinal(0) }), -1); } };
public RelDataType transformType( SqlOperatorBinding opBinding, RelDataType typeToTransform) { return opBinding.getTypeFactory().createTypeWithNullability( Preconditions.checkNotNull(typeToTransform), false); } };
RelDataType type = dataType.deriveType(typeFactory); if (arg.getType().isNullable()) { type = typeFactory.createTypeWithNullability(type, true); && !componentType.isStruct()) { RelDataType tt = typeFactory.builder() .add( argComponentType.getFieldList().get(0).getName(), componentType) .build(); tt = typeFactory.createTypeWithNullability( tt, componentType.isNullable()); boolean isn = type.isNullable(); type = typeFactory.createMultisetType(tt, -1); type = typeFactory.createTypeWithNullability(type, isn);
public static RelDataType createArrayType( RelDataTypeFactory typeFactory, RelDataType type, boolean nullable) { RelDataType ret = typeFactory.createArrayType(type, -1); return typeFactory.createTypeWithNullability(ret, nullable); }
private RelDataType sqlType(RelDataTypeFactory typeFactory, int dataType, int precision, int scale, String typeString) { SqlTypeName sqlTypeName = SqlTypeName.getNameForJdbcType(dataType); switch (sqlTypeName) { case ARRAY: RelDataType component = null; if (typeString != null && typeString.endsWith(" ARRAY")) { // E.g. hsqldb gives "INTEGER ARRAY", so we deduce the component type // "INTEGER". final String remaining = typeString.substring(0, typeString.length() - " ARRAY".length()); component = parseTypeString(typeFactory, remaining); } if (component == null) { component = typeFactory.createSqlType(SqlTypeName.ANY); } return typeFactory.createArrayType(component, -1); } if (precision >= 0 && scale >= 0 && sqlTypeName.allowsPrecScale(true, true)) { return typeFactory.createSqlType(sqlTypeName, precision, scale); } else if (precision >= 0 && sqlTypeName.allowsPrecNoScale()) { return typeFactory.createSqlType(sqlTypeName, precision); } else { assert sqlTypeName.allowsNoPrecNoScale(); return typeFactory.createSqlType(sqlTypeName); } }
public RelDataType getRowType(RelDataTypeFactory typeFactory) { final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder(); builder.add("row_name", typeFactory.createJavaType(String.class)); final RelDataType int_ = typeFactory.createJavaType(int.class); for (int i = 1; i <= ncol; i++) { builder.add("c" + i, int_); } return builder.build(); }
public RelDataType inferReturnType( SqlOperatorBinding opBinding) { assert opBinding.getOperandCount() == 1; final RelDataType multisetType = opBinding.getOperandType(0); RelDataType componentType = multisetType.getComponentType(); assert componentType != null : "expected a multiset type: " + multisetType; final RelDataTypeFactory typeFactory = opBinding.getTypeFactory(); final RelDataType type = typeFactory.builder() .add(SqlUtil.deriveAliasFromOrdinal(0), componentType).build(); return typeFactory.createMultisetType(type, -1); } };
/** * Derives the output type of a collect relational expression. * * @param rel relational expression * @param fieldName name of sole output field * @return output type of a collect relational expression */ public static RelDataType deriveCollectRowType( SingleRel rel, String fieldName) { RelDataType childType = rel.getChild().getRowType(); assert childType.isStruct(); final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); RelDataType ret = SqlTypeUtil.createMultisetType( typeFactory, childType, false); ret = typeFactory.builder().add(fieldName, ret).build(); return typeFactory.createTypeWithNullability(ret, false); } }