Examples with Type org.apache.kafka.connect.data.Schema.Type used on opensource projects

Example 1 with Type

use of org.apache.kafka.connect.data.Schema.Type in project apache-kafka-on-k8s by banzaicloud.

the class Values method commonSchemaFor.

protected static Schema commonSchemaFor(Schema previous, SchemaAndValue latest) {
    if (latest == null) {
        return previous;
    }
    if (previous == null) {
        return latest.schema();
    }
    Schema newSchema = latest.schema();
    Type previousType = previous.type();
    Type newType = newSchema.type();
    if (previousType != newType) {
        switch(previous.type()) {
            case INT8:
                if (newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT16:
                if (newType == Type.INT8) {
                    return previous;
                }
                if (newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT32:
                if (newType == Type.INT8 || newType == Type.INT16) {
                    return previous;
                }
                if (newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT64:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32) {
                    return previous;
                }
                if (newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case FLOAT32:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64) {
                    return previous;
                }
                if (newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case FLOAT64:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32) {
                    return previous;
                }
                break;
        }
        return null;
    }
    if (previous.isOptional() == newSchema.isOptional()) {
        // Use the optional one
        return previous.isOptional() ? previous : newSchema;
    }
    if (!previous.equals(newSchema)) {
        return null;
    }
    return previous;
}

Example 2 with Type

use of org.apache.kafka.connect.data.Schema.Type in project kafka by apache.

the class Cast method parseFieldTypes.

private static Map<String, Schema.Type> parseFieldTypes(List<String> mappings) {
    final Map<String, Schema.Type> m = new HashMap<>();
    boolean isWholeValueCast = false;
    for (String mapping : mappings) {
        final String[] parts = mapping.split(":");
        if (parts.length > 2) {
            throw new ConfigException(ReplaceField.ConfigName.RENAME, mappings, "Invalid rename mapping: " + mapping);
        }
        if (parts.length == 1) {
            Schema.Type targetType = Schema.Type.valueOf(parts[0].trim().toUpperCase(Locale.ROOT));
            m.put(WHOLE_VALUE_CAST, validCastType(targetType, FieldType.OUTPUT));
            isWholeValueCast = true;
        } else {
            Schema.Type type;
            try {
                type = Schema.Type.valueOf(parts[1].trim().toUpperCase(Locale.ROOT));
            } catch (IllegalArgumentException e) {
                throw new ConfigException("Invalid type found in casting spec: " + parts[1].trim(), e);
            }
            m.put(parts[0].trim(), validCastType(type, FieldType.OUTPUT));
        }
    }
    if (isWholeValueCast && mappings.size() > 1) {
        throw new ConfigException("Cast transformations that specify a type to cast the entire value to " + "may ony specify a single cast in their spec");
    }
    return m;
}

Example 3 with Type

use of org.apache.kafka.connect.data.Schema.Type in project ksql by confluentinc.

the class SchemaWalkerTest method shouldThrowOnUnknownType.

@Test
public void shouldThrowOnUnknownType() {
    // Given:
    final Type unknownType = mock(Type.class, "bob");
    final Schema schema = mock(Schema.class);
    when(schema.type()).thenReturn(unknownType);
    // When:
    final UnsupportedOperationException e = assertThrows(UnsupportedOperationException.class, () -> SchemaWalker.visit(schema, visitor));
    // Then:
    assertThat(e.getMessage(), containsString("Unsupported schema type: bob"));
}

Example 4 with Type

use of org.apache.kafka.connect.data.Schema.Type in project kafka by apache.

the class Cast method castValueToType.

private static Object castValueToType(Schema schema, Object value, Schema.Type targetType) {
    try {
        if (value == null)
            return null;
        Schema.Type inferredType = schema == null ? ConnectSchema.schemaType(value.getClass()) : schema.type();
        if (inferredType == null) {
            throw new DataException("Cast transformation was passed a value of type " + value.getClass() + " which is not supported by Connect's data API");
        }
        // Ensure the type we are trying to cast from is supported
        validCastType(inferredType, FieldType.INPUT);
        // Perform logical type encoding to their internal representation.
        if (schema != null && schema.name() != null && targetType != Type.STRING) {
            value = encodeLogicalType(schema, value);
        }
        switch(targetType) {
            case INT8:
                return castToInt8(value);
            case INT16:
                return castToInt16(value);
            case INT32:
                return castToInt32(value);
            case INT64:
                return castToInt64(value);
            case FLOAT32:
                return castToFloat32(value);
            case FLOAT64:
                return castToFloat64(value);
            case BOOLEAN:
                return castToBoolean(value);
            case STRING:
                return castToString(value);
            default:
                throw new DataException(targetType.toString() + " is not supported in the Cast transformation.");
        }
    } catch (NumberFormatException e) {
        throw new DataException("Value (" + value.toString() + ") was out of range for requested data type", e);
    }
}

Example 5 with Type

use of org.apache.kafka.connect.data.Schema.Type in project kafka by apache.

the class Values method commonSchemaFor.

protected static Schema commonSchemaFor(Schema previous, SchemaAndValue latest) {
    if (latest == null) {
        return previous;
    }
    if (previous == null) {
        return latest.schema();
    }
    Schema newSchema = latest.schema();
    Type previousType = previous.type();
    Type newType = newSchema.type();
    if (previousType != newType) {
        switch(previous.type()) {
            case INT8:
                if (newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT16:
                if (newType == Type.INT8) {
                    return previous;
                }
                if (newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT32:
                if (newType == Type.INT8 || newType == Type.INT16) {
                    return previous;
                }
                if (newType == Type.INT64 || newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case INT64:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32) {
                    return previous;
                }
                if (newType == Type.FLOAT32 || newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case FLOAT32:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64) {
                    return previous;
                }
                if (newType == Type.FLOAT64) {
                    return newSchema;
                }
                break;
            case FLOAT64:
                if (newType == Type.INT8 || newType == Type.INT16 || newType == Type.INT32 || newType == Type.INT64 || newType == Type.FLOAT32) {
                    return previous;
                }
                break;
        }
        return null;
    }
    if (previous.isOptional() == newSchema.isOptional()) {
        // Use the optional one
        return previous.isOptional() ? previous : newSchema;
    }
    if (!previous.equals(newSchema)) {
        return null;
    }
    return previous;
}