Examples with SqlArray io.confluent.ksql.schema.ksql.types.SqlArray used on opensource projects

Example 1 with SqlArray

use of io.confluent.ksql.schema.ksql.types.SqlArray in project ksql by confluentinc.

the class ExpressionFormatterTest method shouldFormatArray.

@Test
public void shouldFormatArray() {
    final SqlArray array = SqlTypes.array(SqlTypes.BOOLEAN);
    assertThat(ExpressionFormatter.formatExpression(new Type(array)), equalTo("ARRAY<BOOLEAN>"));
}

Example 2 with SqlArray

use of io.confluent.ksql.schema.ksql.types.SqlArray in project ksql by confluentinc.

the class CastInterpreter method castToArrayFunction.

public static CastFunction castToArrayFunction(final SqlType from, final SqlType to, final KsqlConfig config) {
    if (from.baseType() == SqlBaseType.ARRAY && to.baseType() == SqlBaseType.ARRAY) {
        final SqlArray fromArray = (SqlArray) from;
        final SqlArray toArray = (SqlArray) to;
        final CastFunction itemCastFunction = castFunction(fromArray.getItemType(), toArray.getItemType(), config);
        return o -> CastEvaluator.castArray((List<?>) o, itemCastFunction::cast);
    }
    throw new KsqlException(getErrorMessage(from, to));
}

Example 3 with SqlArray

use of io.confluent.ksql.schema.ksql.types.SqlArray in project ksql by confluentinc.

the class TermCompiler method visitSubscriptExpression.

@Override
public Term visitSubscriptExpression(final SubscriptExpression node, final Context context) {
    final SqlType internalSchema = expressionTypeManager.getExpressionSqlType(node.getBase(), context.getLambdaSqlTypeMapping());
    switch(internalSchema.baseType()) {
        case ARRAY:
            final SqlArray array = (SqlArray) internalSchema;
            final Term listTerm = process(node.getBase(), context);
            final Term indexTerm = process(node.getIndex(), context);
            return new SubscriptTerm(listTerm, indexTerm, (o, index) -> ArrayAccess.arrayAccess(((List<?>) o), (Integer) index), array.getItemType());
        case MAP:
            final SqlMap mapSchema = (SqlMap) internalSchema;
            final Term mapTerm = process(node.getBase(), context);
            final Term keyTerm = process(node.getIndex(), context);
            return new SubscriptTerm(mapTerm, keyTerm, (map, key) -> ((Map<?, ?>) map).get(key), mapSchema.getValueType());
        default:
            throw new UnsupportedOperationException();
    }
}

Example 4 with SqlArray

use of io.confluent.ksql.schema.ksql.types.SqlArray in project ksql by confluentinc.

the class CastEvaluator method castArrayToArray.

private static String castArrayToArray(final String innerCode, final SqlType from, final SqlType to, final KsqlConfig config) {
    final SqlArray fromArray = (SqlArray) from;
    final SqlArray toArray = (SqlArray) to;
    try {
        return "CastEvaluator.castArray(" + innerCode + ", " + mapperFunction(fromArray.getItemType(), toArray.getItemType(), config) + ")";
    } catch (final UnsupportedCastException e) {
        throw new UnsupportedCastException(from, to, e);
    }
}

Example 5 with SqlArray

use of io.confluent.ksql.schema.ksql.types.SqlArray in project ksql by confluentinc.

the class GenericsUtil method resolveGenerics.

/**
 * Identifies a mapping from generic type to concrete type based on a {@code schema} and
 * an {@code instance}, where the {@code instance} schema is expected to have no generic
 * types and have the same nested structure as {@code schema}. Any Generic type mapping
 * identified is added to the list passed in.
 *
 * @param mapping   a list of GenericType to SqlType mappings
 * @param schema    the schema that may contain generics
 * @param instance  a schema with the same structure as {@code schema} but with no generics
 *
 * @return whether we were able to resolve generics in the instance and schema
 */
// CHECKSTYLE_RULES.OFF: NPathComplexity
// CHECKSTYLE_RULES.OFF: CyclomaticComplexity
private static boolean resolveGenerics(final List<Entry<GenericType, SqlType>> mapping, final ParamType schema, final SqlArgument instance) {
    if (!isGeneric(schema) && !matches(schema, instance)) {
        // cannot identify from type mismatch
        return false;
    } else if (!hasGenerics(schema)) {
        // nothing left to identify
        return true;
    }
    KsqlPreconditions.checkArgument(isGeneric(schema) || (matches(schema, instance)), "Cannot resolve generics if the schema and instance have differing types: " + schema + " vs. " + instance);
    if (schema instanceof LambdaType) {
        final LambdaType lambdaType = (LambdaType) schema;
        final SqlLambda sqlLambda = instance.getSqlLambdaOrThrow();
        if (lambdaType.inputTypes().size() == sqlLambda.getNumInputs()) {
            if (sqlLambda instanceof SqlLambdaResolved) {
                final SqlLambdaResolved sqlLambdaResolved = (SqlLambdaResolved) sqlLambda;
                int i = 0;
                for (final ParamType paramType : lambdaType.inputTypes()) {
                    if (!resolveGenerics(mapping, paramType, SqlArgument.of(sqlLambdaResolved.getInputType().get(i)))) {
                        return false;
                    }
                    i++;
                }
                return resolveGenerics(mapping, lambdaType.returnType(), SqlArgument.of(sqlLambdaResolved.getReturnType()));
            } else {
                return true;
            }
        } else {
            return false;
        }
    }
    final SqlType sqlType = instance.getSqlTypeOrThrow();
    if (isGeneric(schema)) {
        mapping.add(new HashMap.SimpleEntry<>((GenericType) schema, sqlType));
    }
    if (schema instanceof ArrayType) {
        final SqlArray sqlArray = (SqlArray) sqlType;
        return resolveGenerics(mapping, ((ArrayType) schema).element(), SqlArgument.of(sqlArray.getItemType()));
    }
    if (schema instanceof MapType) {
        final SqlMap sqlMap = (SqlMap) sqlType;
        final MapType mapType = (MapType) schema;
        return resolveGenerics(mapping, mapType.key(), SqlArgument.of(sqlMap.getKeyType())) && resolveGenerics(mapping, mapType.value(), SqlArgument.of(sqlMap.getValueType()));
    }
    if (schema instanceof StructType) {
        throw new KsqlException("Generic STRUCT is not yet supported");
    }
    return true;
}