Java SchemaBuilder.defaultValue方法代码示例

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
private Schema getOrBuildSchema(Schema valueSchema) {
    Schema updatedSchema = schemaUpdateCache.get(valueSchema);
    if (updatedSchema != null)
        return updatedSchema;

    final SchemaBuilder builder;
    if (wholeValueCastType != null) {
        builder = SchemaUtil.copySchemaBasics(valueSchema, convertFieldType(wholeValueCastType));
    } else {
        builder = SchemaUtil.copySchemaBasics(valueSchema, SchemaBuilder.struct());
        for (Field field : valueSchema.fields()) {
            SchemaBuilder fieldBuilder =
                    convertFieldType(casts.containsKey(field.name()) ? casts.get(field.name()) : field.schema().type());
            if (field.schema().isOptional())
                fieldBuilder.optional();
            if (field.schema().defaultValue() != null)
                fieldBuilder.defaultValue(castValueToType(field.schema().defaultValue(), fieldBuilder.type()));
            builder.field(field.name(), fieldBuilder.build());
        }
    }

    if (valueSchema.isOptional())
        builder.optional();
    if (valueSchema.defaultValue() != null)
        builder.defaultValue(castValueToType(valueSchema.defaultValue(), builder.type()));

    updatedSchema = builder.build();
    schemaUpdateCache.put(valueSchema, updatedSchema);
    return updatedSchema;
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
/**
 * Convert the schema for a field of a Struct with a primitive schema to the schema to be used for the flattened
 * version, taking into account that we may need to override optionality and default values in the flattened version
 * to take into account the optionality and default values of parent/ancestor schemas
 * @param orig the original schema for the field
 * @param optional whether the new flattened field should be optional
 * @param defaultFromParent the default value either taken from the existing field or provided by the parent
 */
private Schema convertFieldSchema(Schema orig, boolean optional, Object defaultFromParent) {
    // Note that we don't use the schema translation cache here. It might save us a bit of effort, but we really
    // only care about caching top-level schema translations.

    final SchemaBuilder builder = SchemaUtil.copySchemaBasics(orig);
    if (optional)
        builder.optional();
    if (defaultFromParent != null)
        builder.defaultValue(defaultFromParent);
    return builder.build();
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
@Test
public void testOptionalAndDefaultValuesNested() {
    // If we have a nested structure where an entire sub-Struct is optional, all flattened fields generated from its
    // children should also be optional. Similarly, if the parent Struct has a default value, the default value for
    // the flattened field

    final Flatten<SourceRecord> xform = new Flatten.Value<>();
    xform.configure(Collections.<String, String>emptyMap());

    SchemaBuilder builder = SchemaBuilder.struct().optional();
    builder.field("req_field", Schema.STRING_SCHEMA);
    builder.field("opt_field", SchemaBuilder.string().optional().defaultValue("child_default").build());
    Struct childDefaultValue = new Struct(builder);
    childDefaultValue.put("req_field", "req_default");
    builder.defaultValue(childDefaultValue);
    Schema schema = builder.build();
    // Intentionally leave this entire value empty since it is optional
    Struct value = new Struct(schema);

    SourceRecord transformed = xform.apply(new SourceRecord(null, null, "topic", 0, schema, value));

    assertNotNull(transformed);
    Schema transformedSchema = transformed.valueSchema();
    assertEquals(Schema.Type.STRUCT, transformedSchema.type());
    assertEquals(2, transformedSchema.fields().size());
    // Required field should pick up both being optional and the default value from the parent
    Schema transformedReqFieldSchema = SchemaBuilder.string().optional().defaultValue("req_default").build();
    assertEquals(transformedReqFieldSchema, transformedSchema.field("req_field").schema());
    // The optional field should still be optional but should have picked up the default value. However, since
    // the parent didn't specify the default explicitly, we should still be using the field's normal default
    Schema transformedOptFieldSchema = SchemaBuilder.string().optional().defaultValue("child_default").build();
    assertEquals(transformedOptFieldSchema, transformedSchema.field("opt_field").schema());
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
private static SchemaBuilder copySchemaBasics(Schema source, SchemaBuilder target) {
  if (source.isOptional()) {
    target.optional();
  }
  if (source.defaultValue() != null && source.type() != Schema.Type.STRUCT) {
    final Object preProcessedDefaultValue = preProcessValue(source.defaultValue(), source, target);
    target.defaultValue(preProcessedDefaultValue);
  }
  return target;
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
/**
 * Build Kafka string schema definition
 * 
 * @param optional  Whether or not the field is optional
 * @param backwards Whether or not this field needs to be backwards
 *                  compatible
 * 
 * @return Kafka string schema
 */
private Schema buildStringSchema (boolean optional, boolean backwards) {
    SchemaBuilder fieldBuilder = SchemaBuilder.string();
    if (optional) {
        fieldBuilder.optional();
    }
    if (backwards) {
        /* add empty string default for missing values */
        fieldBuilder.defaultValue(new String(""));
    }
    
    return fieldBuilder.build();
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
/**
 * Build Kafka timestamp schema definition
 * 
 * @param optional  Whether or not the field is optional
 * @param backwards Whether or not this field needs to be backwards
 *                  compatible
 * 
 * @return Kafka timestamp schema
 */
private Schema buildTimestampSchema (boolean optional, boolean backwards) {
    SchemaBuilder fieldBuilder = Timestamp.builder();
    if (optional) {
        fieldBuilder.optional();
    }
    if (backwards) {
        /* add epoch start as default for missing values */
        fieldBuilder.defaultValue(new Date(0));
    }
    return fieldBuilder.build();
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
/**
 * Build Kafka raw bytes schema definition
 * 
 * @param optional  Whether or not the field is nullable
 * @param backwards Whether or not this field needs to be backwards
 *                  compatible
 * 
 * @return Kafka bytes schema
 */
private Schema buildBytesSchema (boolean optional, boolean backwards) {
    SchemaBuilder fieldBuilder = SchemaBuilder.bytes();
    if (optional) {
        fieldBuilder.optional();
    }
    if (backwards) {
        /* add empty byte as default for missing values */
        fieldBuilder.defaultValue(new byte[] {});
    }
    
    return fieldBuilder.build();
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
private SchemaBuilder copySchemaBasics(Schema source, SchemaBuilder target) {
  if (source.isOptional()) {
    target.optional();
  }
  if (source.defaultValue() != null && source.type() != Schema.Type.STRUCT) {
    final Object defaultVal = preProcessValue(source.defaultValue(), source, target);
    target.defaultValue(defaultVal);
  }
  return target;
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
public Schema build() {
  log.trace(this.toString());
  SchemaBuilder builder;

  switch (this.type) {
    case MAP:
      Preconditions.checkNotNull(this.keySchema, "keySchema cannot be null.");
      Preconditions.checkNotNull(this.valueSchema, "valueSchema cannot be null.");
      builder = SchemaBuilder.map(this.keySchema, this.valueSchema);
      break;
    case ARRAY:
      Preconditions.checkNotNull(this.valueSchema, "valueSchema cannot be null.");
      builder = SchemaBuilder.array(this.valueSchema);
      break;
    default:
      builder = SchemaBuilder.type(this.type);
      break;
  }

  if (Schema.Type.STRUCT == this.type) {
    for (Map.Entry<String, Schema> kvp : this.fieldSchemas.entrySet()) {
      builder.field(kvp.getKey(), kvp.getValue());
    }
  }

  if (!Strings.isNullOrEmpty(this.name)) {
    builder.name(this.name);
  }

  if (!Strings.isNullOrEmpty(this.doc)) {
    builder.doc(this.doc);
  }

  if (null != this.defaultValue) {
    Object value;
    switch (this.type) {
      case INT8:
        value = ((Number) this.defaultValue).byteValue();
        break;
      case INT16:
        value = ((Number) this.defaultValue).shortValue();
        break;
      case INT32:
        value = ((Number) this.defaultValue).intValue();
        break;
      case INT64:
        value = ((Number) this.defaultValue).longValue();
        break;
      case FLOAT32:
        value = ((Number) this.defaultValue).floatValue();
        break;
      case FLOAT64:
        value = ((Number) this.defaultValue).doubleValue();
        break;
      default:
        value = this.defaultValue;
        break;
    }
    builder.defaultValue(value);
  }

  if (null != this.parameters) {
    builder.parameters(this.parameters);
  }

  if (this.isOptional) {
    builder.optional();
  }

  if (null != this.version) {
    builder.version(this.version);
  }

  return builder.build();
}
 

import org.apache.kafka.connect.data.SchemaBuilder; //导入方法依赖的package包/类
/**
 * Build decimal schema from scale and precision
 * 
 * @param scale     The numeric scale
 * @param precision The numeric precision
 * @param optional  Whether or not the field is optional
 * @param backwards Whether or not this field needs to be backwards
 *                  compatible
 * 
 * @return Kafka decimal schema
 */
private Schema buildDecimalSchema (
    int     scale,
    int     precision,
    boolean optional,
    boolean backwards
) {
    SchemaBuilder fieldBuilder = null;
    if (
        scale > 0 ||
        precision <= 0 ||
        precision - scale >= ColumnDataDecoder.NUMBER_LONG_MAX_PRECISION
    ) {
        /* decimal type */
        fieldBuilder = Decimal.builder(scale);
        if (optional) {
            fieldBuilder.optional();
        }
        if (backwards) {
            /* add zero default for missing values */
            fieldBuilder.defaultValue(BigDecimal.ZERO.setScale(scale));
        }
    }
    else if (
        scale <= 0 && 
        precision - Math.abs (scale) < 
            ColumnDataDecoder.NUMBER_INTEGER_MAX_PRECISION
    ) {
        /* integer data type */
        fieldBuilder = SchemaBuilder.int32();
        if (optional) {
            fieldBuilder.optional();
        }
        if (backwards) {
            /* add zero default for missing values */
            fieldBuilder.defaultValue(0);
        }
    }
    else {
        /* long data type */
        fieldBuilder = SchemaBuilder.int64();
        if (optional) {
            fieldBuilder.optional();
        }
        if (backwards) {
            /* add zero default for missing values */
            fieldBuilder.defaultValue(0L);
        }
    }
    return fieldBuilder.build();
}