Examples with MAP org.apache.flink.table.types.logical.LogicalTypeRoot.MAP used on opensource projects

Example 1 with MAP

use of org.apache.flink.table.types.logical.LogicalTypeRoot.MAP in project flink by apache.

the class ValuesOperationFactory method findCommonTypeAtPosition.

private DataType findCommonTypeAtPosition(List<List<ResolvedExpression>> resolvedRows, int i) {
    List<LogicalType> typesAtIPosition = extractLogicalTypesAtPosition(resolvedRows, i);
    LogicalType logicalType = LogicalTypeMerging.findCommonType(typesAtIPosition).orElseThrow(() -> {
        Set<DataType> columnTypes = resolvedRows.stream().map(row -> row.get(i).getOutputDataType()).collect(Collectors.toCollection(LinkedHashSet::new));
        return new ValidationException(String.format("Types in fromValues(...) must have a common super type. Could not find a common type" + " for all rows at column %d.\n" + "Could not find a common super type for types: %s", i, columnTypes));
    });
    return TypeConversions.fromLogicalToDataType(logicalType);
}

Example 2 with MAP

use of org.apache.flink.table.types.logical.LogicalTypeRoot.MAP in project flink by apache.

the class ValuesOperationFactory method create.

/**
 * Creates a valid {@link ValuesQueryOperation} operation.
 *
 * <p>It derives a row type based on {@link LogicalTypeMerging}. It flattens any row
 * constructors. It does not flatten ROWs which are a result of e.g. a function call.
 *
 * <p>The resulting schema can be provided manually. If it is not, the schema will be
 * automatically derived from the types of the expressions.
 */
QueryOperation create(@Nullable ResolvedSchema expectedSchema, List<ResolvedExpression> resolvedExpressions, ExpressionResolver.PostResolverFactory postResolverFactory) {
    List<List<ResolvedExpression>> resolvedRows = unwrapFromRowConstructor(resolvedExpressions);
    if (expectedSchema != null) {
        verifyAllSameSize(resolvedRows, expectedSchema.getColumnCount());
    }
    ResolvedSchema schema = Optional.ofNullable(expectedSchema).orElseGet(() -> extractSchema(resolvedRows));
    List<List<ResolvedExpression>> castedExpressions = resolvedRows.stream().map(row -> convertTopLevelExpressionToExpectedRowType(postResolverFactory, schema.getColumnDataTypes(), row)).collect(Collectors.toList());
    return new ValuesQueryOperation(castedExpressions, schema);
}

Example 3 with MAP

use of org.apache.flink.table.types.logical.LogicalTypeRoot.MAP in project flink by apache.

the class LogicalTypeMerging method findCommonType.

/**
 * Returns the most common, more general {@link LogicalType} for a given set of types. If such a
 * type exists, all given types can be casted to this more general type.
 *
 * <p>For example: {@code [INT, BIGINT, DECIMAL(2, 2)]} would lead to {@code DECIMAL(21, 2)}.
 *
 * <p>This class aims to be compatible with the SQL standard. It is inspired by Apache Calcite's
 * {@code SqlTypeFactoryImpl#leastRestrictive} method.
 */
public static Optional<LogicalType> findCommonType(List<LogicalType> types) {
    Preconditions.checkArgument(types.size() > 0, "List of types must not be empty.");
    // collect statistics first
    boolean hasRawType = false;
    boolean hasNullType = false;
    boolean hasNullableTypes = false;
    for (LogicalType type : types) {
        final LogicalTypeRoot typeRoot = type.getTypeRoot();
        if (typeRoot == RAW) {
            hasRawType = true;
        } else if (typeRoot == NULL) {
            hasNullType = true;
        }
        if (type.isNullable()) {
            hasNullableTypes = true;
        }
    }
    final List<LogicalType> normalizedTypes = types.stream().map(t -> t.copy(true)).collect(Collectors.toList());
    LogicalType foundType = findCommonNullableType(normalizedTypes, hasRawType, hasNullType);
    if (foundType == null) {
        foundType = findCommonCastableType(normalizedTypes);
    }
    if (foundType != null) {
        final LogicalType typeWithNullability = foundType.copy(hasNullableTypes);
        // NULL is reserved for untyped literals only
        if (typeWithNullability.is(NULL)) {
            return Optional.empty();
        }
        return Optional.of(typeWithNullability);
    }
    return Optional.empty();
}