/** * Returns a {@link SchemaBuilder} for a {@link Date}. The builder will create a schema that describes a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the number of <em>days</em> since January 1, 1970, at 00:00:00Z. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
/** * Returns a {@link SchemaBuilder} for a {@link Time}. The resulting schema will describe a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the number of <em>milliseconds</em> past midnight. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
/** * Returns a {@link SchemaBuilder} for a {@link Year}. The builder will create a schema that describes a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the year number. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
return SchemaBuilder.int32();
case Types.INTEGER: return SchemaBuilder.int32(); case Types.BIGINT:
assertThat(values.field("C4").name()).isEqualTo("C4"); assertThat(values.field("C4").index()).isEqualTo(3); assertThat(values.field("C4").schema()).isEqualTo(SchemaBuilder.int32().optional().build()); // JDBC INTEGER = 32 bits assertThat(values.field("C5").index()).isEqualTo(4); assertThat(values.field("C5").schema()).isEqualTo(SchemaBuilder.bytes().build()); // JDBC BINARY = bytes
/** * Returns a SchemaBuilder for a Date. By returning a SchemaBuilder you can override additional schema settings such * as required/optional, default value, and documentation. * @return a SchemaBuilder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(LOGICAL_NAME) .version(1); }
/** * Returns a SchemaBuilder for a Time. By returning a SchemaBuilder you can override additional schema settings such * as required/optional, default value, and documentation. * @return a SchemaBuilder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(LOGICAL_NAME) .version(1); }
/** * Returns a {@link SchemaBuilder} for a {@link Time}. The resulting schema will describe a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the number of <em>milliseconds</em> past midnight. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
/** * Returns a {@link SchemaBuilder} for a {@link Date}. The builder will create a schema that describes a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the number of <em>days</em> since January 1, 1970, at 00:00:00Z. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
/** * Returns a {@link SchemaBuilder} for a {@link Year}. The builder will create a schema that describes a field * with the {@value #SCHEMA_NAME} as the {@link Schema#name() name} and {@link SchemaBuilder#int32() INT32} for the literal * type storing the year number. * <p> * You can use the resulting SchemaBuilder to set or override additional schema settings such as required/optional, default * value, and documentation. * * @return the schema builder */ public static SchemaBuilder builder() { return SchemaBuilder.int32() .name(SCHEMA_NAME) .version(1); }
static Schema schema(Class<?> logClass, String logFieldName) { final SchemaBuilder builder; if (LocalDate.class.equals(logClass)) { builder = Date.builder(); } else if (LocalTime.class.equals(logClass)) { builder = Time.builder(); } else if (Integer.class.equals(logClass)) { builder = SchemaBuilder.int32(); } else if (Long.class.equals(logClass)) { builder = SchemaBuilder.int64(); } else if (String.class.equals(logClass)) { builder = SchemaBuilder.string(); } else { throw new UnsupportedOperationException( String.format("%s is not a supported type.", logClass.getName()) ); } builder.optional(); return builder.build(); }
private SchemaBuilder getNumericSchema(Column column) { if (column.scale().isPresent()) { // return sufficiently sized int schema for non-floating point types Integer scale = column.scale().get(); // a negative scale means rounding, e.g. NUMBER(10, -2) would be rounded to hundreds if (scale <= 0) { int width = column.length() - scale; if (width < 3) { return SchemaBuilder.int8(); } else if (width < 5) { return SchemaBuilder.int16(); } else if (width < 10) { return SchemaBuilder.int32(); } else if (width < 19) { return SchemaBuilder.int64(); } } // larger non-floating point types and floating point types use Decimal return super.schemaBuilder(column); } else { return VariableScaleDecimal.builder(); } }
} else if (cls.isAssignableFrom(Integer.class)) { return new SchemaAndValue(SchemaBuilder.int32().optional(), value); } else if (cls.isAssignableFrom(Long.class)) { return new SchemaAndValue(SchemaBuilder.int8().optional(), value); } else if (cls.isAssignableFrom(Character.class)) { return new SchemaAndValue(SchemaBuilder.int32().optional(), value == null ? null : new Integer(((char) value))); } else if (cls.isAssignableFrom(Boolean.class)) { return new SchemaAndValue(SchemaBuilder.bool().optional(), value);
private SchemaBuilder convertFieldType(Schema.Type type) { switch (type) { case INT8: return SchemaBuilder.int8(); case INT16: return SchemaBuilder.int16(); case INT32: return SchemaBuilder.int32(); case INT64: return SchemaBuilder.int64(); case FLOAT32: return SchemaBuilder.float32(); case FLOAT64: return SchemaBuilder.float64(); case BOOLEAN: return SchemaBuilder.bool(); case STRING: return SchemaBuilder.string(); default: throw new DataException("Unexpected type in Cast transformation: " + type); } }
@TestFactory @DisplayName("tests for int32 field conversions") public List<DynamicTest> testInt32FieldConverter() { SinkFieldConverter converter = new Int32FieldConverter(); List<DynamicTest> tests = new ArrayList<>(); new ArrayList<>(Arrays.asList(Integer.MIN_VALUE,0,Integer.MAX_VALUE)).forEach( el -> tests.add(dynamicTest("conversion with " + converter.getClass().getSimpleName() + " for "+el, () -> assertEquals((int)el, ((BsonInt32)converter.toBson(el)).getValue()) )) ); tests.add(dynamicTest("optional type conversions", () -> { Schema valueOptionalDefault = SchemaBuilder.int32().optional().defaultValue(0); assertAll("checks", () -> assertThrows(DataException.class, () -> converter.toBson(null, Schema.INT32_SCHEMA)), () -> assertEquals(new BsonNull(), converter.toBson(null, Schema.OPTIONAL_INT32_SCHEMA)), () -> assertEquals(valueOptionalDefault.defaultValue(), ((BsonInt32)converter.toBson(null, valueOptionalDefault)).getValue()) ); })); return tests; }
converter = new LocalTimeLogFieldConverter(logFieldName, field); } else if (Integer.class.equals(logClass)) { fieldSchema = SchemaBuilder.int32() .optional() .parameter(LOGFIELD_PARAM, logFieldName)
@Test public void testNullable() { final String nullableFieldName = "nullable"; final String requiredFieldName = "required"; final Integer nullableFieldValue = null; final Integer requiredFieldValue = 42; Map<String, Object> bigQueryExpectedRecord = new HashMap<>(); bigQueryExpectedRecord.put(requiredFieldName, requiredFieldValue); Schema kafkaConnectSchema = SchemaBuilder .struct() .field(nullableFieldName, SchemaBuilder.int32().optional().build()) .field(requiredFieldName, SchemaBuilder.int32().required().build()) .build(); Struct kafkaConnectStruct = new Struct(kafkaConnectSchema); kafkaConnectStruct.put(nullableFieldName, nullableFieldValue); kafkaConnectStruct.put(requiredFieldName, requiredFieldValue); SinkRecord kafkaConnectRecord = spoofSinkRecord(kafkaConnectSchema, kafkaConnectStruct); Map<String, Object> bigQueryTestRecord = new BigQueryRecordConverter(SHOULD_CONVERT_DOUBLE).convertRecord(kafkaConnectRecord); assertEquals(bigQueryExpectedRecord, bigQueryTestRecord); }
@Test public void testNullable() { final String nullableFieldName = "Nullable"; final String requiredFieldName = "Required"; com.google.cloud.bigquery.Schema bigQueryExpectedSchema = com.google.cloud.bigquery.Schema.of( com.google.cloud.bigquery.Field.newBuilder( nullableFieldName, LegacySQLTypeName.INTEGER ).setMode( com.google.cloud.bigquery.Field.Mode.NULLABLE ).build(), com.google.cloud.bigquery.Field.newBuilder( requiredFieldName, LegacySQLTypeName.INTEGER ).setMode( com.google.cloud.bigquery.Field.Mode.REQUIRED ).build() ); Schema kafkaConnectTestSchema = SchemaBuilder .struct() .field(nullableFieldName, SchemaBuilder.int32().optional().build()) .field(requiredFieldName, SchemaBuilder.int32().required().build()) .build(); com.google.cloud.bigquery.Schema bigQueryTestSchema = new BigQuerySchemaConverter(false).convertSchema(kafkaConnectTestSchema); assertEquals(bigQueryExpectedSchema, bigQueryTestSchema); }
case SINT32: builder = SchemaBuilder.int32(); break;