private Object maybeConvertLogicalType(final Schema connectSchema, final Object connectValue) { if (connectSchema.name() == null) { return connectValue; } switch (connectSchema.name()) { case Date.LOGICAL_NAME: return Date.fromLogical(connectSchema, (java.util.Date) connectValue); case Time.LOGICAL_NAME: return Time.fromLogical(connectSchema, (java.util.Date) connectValue); case Timestamp.LOGICAL_NAME: return Timestamp.fromLogical(connectSchema, (java.util.Date) connectValue); default: return connectValue; } }
private static String schemaName(Schema schema) { if (schema == null) return null; String name = schema.name(); if (name != null) name = name.trim(); return name == null || name.isEmpty() ? null : name; }
private static FunctionInfo getFunctionInfo( final List<Schema> argTypes, final Schema returnTypeSchema, final String description ) { final List<ArgumentInfo> args = argTypes.stream() .map(s -> new ArgumentInfo(s.name(), SchemaUtil.getSqlTypeName(s), s.doc())) .collect(Collectors.toList()); final String returnType = SchemaUtil.getSqlTypeName(returnTypeSchema); return new FunctionInfo(args, returnType, description); }
@Test public void shouldSetNameOnGetSchemaFromType() { assertThat(SchemaUtil.getSchemaFromType(Double.class, "name", "").name(), is("name")); }
@Test public void shouldDefaultToNoNameOnGetSchemaFromType() { assertThat(SchemaUtil.getSchemaFromType(Double.class).name(), is(nullValue())); }
public static Schema buildSchemaWithAlias(final Schema schema, final String alias) { final SchemaBuilder newSchema = SchemaBuilder.struct().name(schema.name()); for (final Field field : schema.fields()) { newSchema.field((alias + "." + field.name()), field.schema()); } return newSchema; }
protected static void validateSubSchemaNames(Schema parentSchema, Field field) { if (field == null) return; Schema subSchema = field.schema(); String subSchemaName = subSchema.name(); if (subSchemaName != null && !SchemaNameAdjuster.isValidFullname(subSchemaName)) { fail("Kafka schema '" + parentSchema.name() + "' contains a subschema for '" + field.name() + "' named '" + subSchema.name() + "' that is not a valid Avro schema name"); } if (subSchema.type() == Type.STRUCT) { subSchema.fields().forEach(child -> { validateSubSchemaNames(parentSchema, child); }); } }
protected static void validateSchemaNames(Schema schema) { if (schema == null) return; String schemaName = schema.name(); if (schemaName != null && !SchemaNameAdjuster.isValidFullname(schemaName)) { fail("Kafka schema '" + schemaName + "' is not a valid Avro schema name"); } if (schema.type() == Type.STRUCT) { schema.fields().forEach(field -> { validateSubSchemaNames(schema, field); }); } }
protected void assertTablesIncluded(String... fullyQualifiedTableNames) { Arrays.stream(fullyQualifiedTableNames).forEach(fullyQualifiedTableName -> { TableSchema tableSchema = schemaFor(fullyQualifiedTableName); assertNotNull(fullyQualifiedTableName + " not included", tableSchema); assertThat(tableSchema.keySchema().name()).isEqualTo(validFullName(fullyQualifiedTableName, ".Key")); assertThat(tableSchema.valueSchema().name()).isEqualTo(validFullName(fullyQualifiedTableName, ".Value")); }); }
@Test public void shouldUseExplicitSchemaName() { final Schema schema = SchemaBuilder.struct() .field("COLUMN_NAME", Schema.OPTIONAL_INT64_SCHEMA) .optional() .build(); String schemaFullName = "com.custom.schema"; final AvroDataTranslator dataTranslator = new AvroDataTranslator(schema, schemaFullName); final GenericRow ksqlRow = new GenericRow(Collections.singletonList(123L)); final Struct struct = dataTranslator.toConnectRow(ksqlRow); assertThat(struct.schema().name(), equalTo(schemaFullName)); } }
protected void assertTableIncluded(String fullyQualifiedTableName) { TableId tableId = TableId.parse(fullyQualifiedTableName); TableSchema tableSchema = mysql.schemaFor(tableId); assertThat(tableSchema).isNotNull(); assertThat(tableSchema.keySchema().name()).isEqualTo(SchemaNameAdjuster.validFullname(SERVER_NAME + "." + fullyQualifiedTableName + ".Key")); assertThat(tableSchema.valueSchema().name()).isEqualTo(SchemaNameAdjuster.validFullname(SERVER_NAME + "." + fullyQualifiedTableName + ".Value")); }
@Test public void shoudRenameSourceDereference() { final Schema schema = SchemaBuilder.struct() .field("STREAM_NAME.COLUMN_NAME", Schema.OPTIONAL_INT32_SCHEMA) .optional() .build(); final AvroDataTranslator dataTranslator = new AvroDataTranslator(schema, KsqlConstants.DEFAULT_AVRO_SCHEMA_FULL_NAME); final GenericRow ksqlRow = new GenericRow(ImmutableList.of(123)); final Struct struct = dataTranslator.toConnectRow(ksqlRow); assertThat( struct.schema(), equalTo( SchemaBuilder.struct() .name(struct.schema().name()) .field("STREAM_NAME_COLUMN_NAME", Schema.OPTIONAL_INT32_SCHEMA) .optional() .build() ) ); assertThat(struct.get("STREAM_NAME_COLUMN_NAME"), equalTo(123)); final GenericRow translatedRow = dataTranslator.toKsqlRow(struct.schema(), struct); assertThat(translatedRow, equalTo(ksqlRow)); }
.create(prefix, "sometopic", table, null, null); assertThat(schema).isNotNull(); assertThat(schema.keySchema().name()).isEqualTo("schema.table.Key"); assertThat(schema.valueSchema().name()).isEqualTo("schema.table.Value"); assertThat(schema.keySchema().name()).isEqualTo("testDb.testTable.Key"); assertThat(schema.valueSchema().name()).isEqualTo("testDb.testTable.Value"); assertThat(schema.keySchema().name()).isEqualTo("testSchema.testTable.Key"); assertThat(schema.valueSchema().name()).isEqualTo("testSchema.testTable.Value"); assertThat(schema.keySchema().name()).isEqualTo("testTable.Key"); assertThat(schema.valueSchema().name()).isEqualTo("testTable.Value");
assertThat(transformed1.topic()).isEqualTo(replacedTopic); assertThat(transformed1.keySchema().name()).isEqualTo(replacedTopic + ".Key"); assertThat(transformed1.keySchema().fields()).hasSize(2); assertThat(transformed1.keySchema().fields().get(0).name()).isEqualTo(keyFieldName); assertThat(transformed2.topic()).isEqualTo(replacedTopic); assertThat(transformed2.keySchema().name()).isEqualTo(replacedTopic + ".Key"); assertThat(transformed2.keySchema().fields()).hasSize(2); assertThat(transformed2.keySchema().fields().get(0).name()).isEqualTo(keyFieldName);
case STRUCT: schemaBuilder = SchemaBuilder.struct(); if (schema.name() == null) { schemaBuilder.name(typeNameGenerator.name());
protected void assertField(Field field, String fieldName, Schema expectedSchema, boolean optional) { assertThat(field.name()).isEqualTo(fieldName); Schema schema = field.schema(); assertThat(schema.name()).isEqualTo(expectedSchema.name()); assertThat(schema.doc()).isEqualTo(expectedSchema.doc()); assertThat(schema.parameters()).isEqualTo(expectedSchema.parameters()); assertThat(schema.version()).isEqualTo(expectedSchema.version()); assertThat(schema.isOptional()).isEqualTo(optional); switch (expectedSchema.type()) { case STRUCT: for (Field f : expectedSchema.fields()) { assertField(schema.field(f.name()),f.name(),f.schema(),f.schema().isOptional()); } break; default: } }
assertThat(insert.valueSchema().name()).endsWith("dbz_878_some_test_data.Envelope"); VerifyRecord.isValidInsert(insert, "id", 1);
@Test public void shouldBuildWithSimpleOptionalTypesForBeforeAndAfter() { Envelope env = Envelope.defineSchema() .withName("someName") .withRecord(Schema.OPTIONAL_STRING_SCHEMA) .withSource(Schema.OPTIONAL_INT64_SCHEMA) .build(); assertThat(env.schema()).isNotNull(); assertThat(env.schema().name()).isEqualTo("someName"); assertThat(env.schema().doc()).isNull(); assertThat(env.schema().version()).isNull(); assertOptionalField(env, Envelope.FieldName.AFTER, Schema.OPTIONAL_STRING_SCHEMA); assertOptionalField(env, Envelope.FieldName.BEFORE, Schema.OPTIONAL_STRING_SCHEMA); assertOptionalField(env, Envelope.FieldName.SOURCE, Schema.OPTIONAL_INT64_SCHEMA); assertRequiredField(env, Envelope.FieldName.OPERATION, Schema.STRING_SCHEMA); }
@Test public void shouldHaveSchemaForSource() { Schema schema = source.schema(); assertThat(schema.name()).isNotEmpty(); assertThat(schema.version()).isNotNull(); assertThat(schema.field(SourceInfo.SERVER_NAME).schema()).isEqualTo(Schema.STRING_SCHEMA); assertThat(schema.field(SourceInfo.REPLICA_SET_NAME).schema()).isEqualTo(Schema.STRING_SCHEMA); assertThat(schema.field(SourceInfo.NAMESPACE).schema()).isEqualTo(Schema.STRING_SCHEMA); assertThat(schema.field(SourceInfo.TIMESTAMP).schema()).isEqualTo(Schema.INT32_SCHEMA); assertThat(schema.field(SourceInfo.ORDER).schema()).isEqualTo(Schema.INT32_SCHEMA); assertThat(schema.field(SourceInfo.OPERATION_ID).schema()).isEqualTo(Schema.OPTIONAL_INT64_SCHEMA); assertThat(schema.field(SourceInfo.INITIAL_SYNC).schema()).isEqualTo(SchemaBuilder.bool().optional().defaultValue(false).build()); }