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 shouldSetDocOnGetSchemaFromType() { assertThat(SchemaUtil.getSchemaFromType(Double.class, "", "doc").doc(), is("doc")); }
@Test public void shouldDefaultToNoDocOnGetSchemaFromType() { assertThat(SchemaUtil.getSchemaFromType(Double.class).doc(), is(nullValue())); }
private SchemaBuilder copySchemaExcludingName(Schema source, SchemaBuilder builder, boolean copyFields) { builder.version(source.version()); builder.doc(source.doc()); Map<String, String> params = source.parameters(); if (params != null) { builder.parameters(params); } if (source.isOptional()) { builder.optional(); } else { builder.required(); } if (copyFields) { for (org.apache.kafka.connect.data.Field field : source.fields()) { builder.field(field.name(), field.schema()); } } return builder; } }
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: } }
@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); }
public static List<FieldSchema> convertSchema(Schema schema) { List<FieldSchema> columns = new ArrayList<>(); if (Schema.Type.STRUCT.equals(schema.type())) { for (Field field: schema.fields()) { columns.add(new FieldSchema( field.name(), convert(field.schema()).getTypeName(), field.schema().doc())); } } return columns; }
TableInfo constructTableInfo(TableId table, Schema kafkaConnectSchema) { com.google.cloud.bigquery.Schema bigQuerySchema = schemaConverter.convertSchema(kafkaConnectSchema); StandardTableDefinition tableDefinition = StandardTableDefinition.newBuilder() .setSchema(bigQuerySchema) .setTimePartitioning(TimePartitioning.of(TimePartitioning.Type.DAY)) .build(); TableInfo.Builder tableInfoBuilder = TableInfo.newBuilder(table, tableDefinition); if (kafkaConnectSchema.doc() != null) { tableInfoBuilder.setDescription(kafkaConnectSchema.doc()); } return tableInfoBuilder.build(); } }
public static SchemaBuilder copySchemaBasics(Schema source, SchemaBuilder builder) { builder.name(source.name()); builder.version(source.version()); builder.doc(source.doc()); final Map<String, String> params = source.parameters(); if (params != null) { builder.parameters(params); } return builder; }
final SchemaBuilder outputSchemaBuilder = SchemaBuilder.struct(); outputSchemaBuilder.name(inputSchema.name()); outputSchemaBuilder.doc(inputSchema.doc()); if (null != inputSchema.defaultValue()) { outputSchemaBuilder.defaultValue(inputSchema.defaultValue());
Storage(Schema schema) { this.name = schema.name(); this.doc = schema.doc(); this.type = schema.type(); this.defaultValue = schema.defaultValue(); this.version = schema.version(); this.parameters = schema.parameters(); this.isOptional = schema.isOptional(); if (Schema.Type.MAP == this.type) { this.keySchema = schema.keySchema(); this.valueSchema = schema.valueSchema(); } else if (Schema.Type.ARRAY == this.type) { this.keySchema = null; this.valueSchema = schema.valueSchema(); } else if (Schema.Type.STRUCT == this.type) { this.fieldSchemas = new LinkedHashMap<>(); for (Field field : schema.fields()) { this.fieldSchemas.put(field.name(), field.schema()); } } }
public JsonConnectSchema(Schema schema) { this.name = schema.name(); this.doc = schema.doc(); this.type = schema.type(); this.defaultValue = schema.defaultValue(); this.version = schema.version(); this.parameters = schema.parameters(); this.isOptional = schema.isOptional(); if (Schema.Type.MAP == this.type) { this.keySchema = schema.keySchema(); this.valueSchema = schema.valueSchema(); } else if (Schema.Type.ARRAY == this.type) { this.keySchema = null; this.valueSchema = schema.valueSchema(); } else if (Schema.Type.STRUCT == this.type) { this.fieldSchemas = new LinkedHashMap<>(); for (Field field : schema.fields()) { this.fieldSchemas.put(field.name(), field.schema()); } } }
when(mockKafkaSchema.doc()).thenReturn(testDoc);
assertEquals(expected.defaultValue(), actual.defaultValue(), prefix + "schema.defaultValue() should match."); assertEquals(expected.isOptional(), actual.isOptional(), prefix + "schema.isOptional() should match."); assertEquals(expected.doc(), actual.doc(), prefix + "schema.doc() should match."); assertEquals(expected.version(), actual.version(), prefix + "schema.version() should match."); ChangeAssertions.assertMap(expected.parameters(), actual.parameters(), prefix + "schema.parameters() should match.");
private SchemaBuilder copySchemaExcludingName(Schema source, SchemaBuilder builder, boolean copyFields) { builder.version(source.version()); builder.doc(source.doc()); Map<String, String> params = source.parameters(); if (params != null) { builder.parameters(params); } if (source.isOptional()) { builder.optional(); } else { builder.required(); } if (copyFields) { for (org.apache.kafka.connect.data.Field field : source.fields()) { builder.field(field.name(), field.schema()); } } return builder; } }
@Override public R apply(R record) { final Schema schema = operatingSchema(record); requireSchema(schema, "updating schema metadata"); final boolean isArray = schema.type() == Schema.Type.ARRAY; final boolean isMap = schema.type() == Schema.Type.MAP; final Schema updatedSchema = new ConnectSchema( schema.type(), schema.isOptional(), schema.defaultValue(), schemaName != null ? schemaName : schema.name(), schemaVersion != null ? schemaVersion : schema.version(), schema.doc(), schema.parameters(), schema.fields(), isMap ? schema.keySchema() : null, isMap || isArray ? schema.valueSchema() : null ); return newRecord(record, updatedSchema); }