protected int getTimePrecision(Column column) { return column.length(); }
protected ValueConverter convertBits(Column column, Field fieldDefn) { if (column.length() > 1) { int numBits = column.length(); int numBytes = numBits / Byte.SIZE + (numBits % Byte.SIZE == 0 ? 0 : 1); return (data) -> convertBits(column, fieldDefn, data, numBytes); } return (data) -> convertBit(column, fieldDefn, data); }
@Override protected ByteBuffer convertByteArray(Column column, byte[] data) { // DBZ-254 right-pad fixed-length binary column values with 0x00 (zero byte) if (column.jdbcType() == Types.BINARY && data.length < column.length()) { data = Arrays.copyOf(data, column.length()); } return super.convertByteArray(column, data); }
/** * Converts a string object for an object type of {@link Duration}. * * @param column the column definition describing the {@code data} value; never null * @param value the string object to be converted into a {@link Duration} type; * @return the converted value; */ private Object convertToDuration(Column column, String value) { return Duration.between(LocalTime.MIN, LocalTime.from(timeFormat(column.length()).parse(value))); }
@Override public void alterFieldSchema(Column column, SchemaBuilder schemaBuilder) { // upper-casing type names to be consistent across connectors schemaBuilder.parameter(TYPE_NAME_PARAMETER_KEY, column.typeName().toUpperCase(Locale.ENGLISH)); if (column.length() != Column.UNSET_INT_VALUE) { schemaBuilder.parameter(TYPE_LENGTH_PARAMETER_KEY, String.valueOf(column.length())); } if (column.scale().isPresent()) { schemaBuilder.parameter(TYPE_SCALE_PARAMETER_KEY, String.valueOf(column.scale().get())); } } }
/** * Converts a string object for an expected JDBC type of {@link Types#BIT}. * * @param column the column definition describing the {@code data} value; never null * @param value the string object to be converted into a {@link Types#BIT} type; * @return the converted value; */ private Object convertToBits(Column column, String value) { if (column.length() > 1) { return convertToBits(value); } return convertToBit(value); }
/** * Converts a string object for an object type of {@link LocalDateTime}. * If the column definition allows null and default value is 0000-00-00 00:00:00, we need return null, * else 0000-00-00 00:00:00 will be replaced with 1970-01-01 00:00:00; * * @param column the column definition describing the {@code data} value; never null * @param value the string object to be converted into a {@link LocalDateTime} type; * @return the converted value; */ private Object convertToLocalDateTime(Column column, String value) { final boolean matches = EPOCH_EQUIVALENT_TIMESTAMP.matcher(value).matches() || "0".equals(value); if (matches) { if (column.isOptional()) { return null; } value = EPOCH_TIMESTAMP; } return LocalDateTime.from(timestampFormat(column.length()).parse(value)); }
private SchemaBuilder numericSchema(Column column) { if (decimalMode == DecimalMode.PRECISE && isVariableScaleDecimal(column)) { return VariableScaleDecimal.builder(); } return SpecialValueDecimal.builder(decimalMode, column.length(), column.scale().get()); }
@Override public SchemaBuilder schemaBuilder(Column column) { switch (column.jdbcType()) { // Numeric integers case Types.TINYINT: // values are an 8-bit unsigned integer value between 0 and 255, we thus need to store it in short int return SchemaBuilder.int16(); // Floating point case microsoft.sql.Types.SMALLMONEY: case microsoft.sql.Types.MONEY: return SpecialValueDecimal.builder(decimalMode, column.length(), column.scale().get()); case microsoft.sql.Types.DATETIMEOFFSET: return ZonedTimestamp.builder(); default: return super.schemaBuilder(column); } }
final int localLength = column.length(); final int incomingLength = message.getTypeMetadata().getLength(); if (localLength != incomingLength) {
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Column) { Column that = (Column) obj; return this.name().equalsIgnoreCase(that.name()) && this.typeExpression().equalsIgnoreCase(that.typeExpression()) && this.typeName().equalsIgnoreCase(that.typeName()) && this.jdbcType() == that.jdbcType() && Strings.equalsIgnoreCase(this.charsetName(),that.charsetName()) && this.position() == that.position() && this.length() == that.length() && this.scale().equals(that.scale()) && this.isOptional() == that.isOptional() && this.isAutoIncremented() == that.isAutoIncremented() && this.isGenerated() == that.isGenerated() && Objects.equals(this.defaultValue(), that.defaultValue()) && this.hasDefaultValue() == that.hasDefaultValue(); } return false; }
private Document toDocument(Column column) { Document document = Document.create(); document.setString("name", column.name()); document.setNumber("jdbcType", column.jdbcType()); if (column.nativeType() != Column.UNSET_INT_VALUE) { document.setNumber("nativeType", column.nativeType()); } document.setString("typeName", column.typeName()); document.setString("typeExpression", column.typeExpression()); document.setString("charsetName", column.charsetName()); if (column.length() != Column.UNSET_INT_VALUE) { document.setNumber("length", column.length()); } column.scale().ifPresent(s -> document.setNumber("scale", s)); document.setNumber("position", column.position()); document.setBoolean("optional", column.isOptional()); document.setBoolean("autoIncremented", column.isAutoIncremented()); document.setBoolean("generated", column.isGenerated()); return document; }
private ValueConverter createArrayConverter(Column column, Field fieldDefn) { PostgresType arrayType = typeRegistry.get(column.nativeType()); PostgresType elementType = arrayType.getElementType(); final String elementTypeName = elementType.getName(); final String elementColumnName = column.name() + "-element"; final Column elementColumn = Column.editor() .name(elementColumnName) .jdbcType(elementType.getJdbcId()) .nativeType(elementType.getOid()) .type(elementTypeName) .optional(true) .scale(column.scale().orElse(null)) .length(column.length()) .create(); Schema elementSchema = schemaBuilder(elementColumn) .optional() .build(); final Field elementField = new Field(elementColumnName, 0, elementSchema); final ValueConverter elementConverter = converter(elementColumn, elementField); return data -> convertArray(column, fieldDefn, elementConverter, data); }
protected void assertColumn(Table table, String name, String typeName, int jdbcType, int length, int scale, boolean optional, boolean generated, boolean autoIncremented ) { Column column = table.columnWithName(name); assertThat(column.name()).isEqualTo(name); assertThat(column.typeName()).isEqualTo(typeName); assertThat(column.jdbcType()).isEqualTo(jdbcType); assertThat(column.length()).isEqualTo(length); if (scale == Column.UNSET_INT_VALUE) { assertFalse(column.scale().isPresent()); } else { assertThat(column.scale().get()).isEqualTo(scale); } assertThat(column.isOptional()).isEqualTo(optional); assertThat(column.isGenerated()).isEqualTo(generated); assertThat(column.isAutoIncremented()).isEqualTo(autoIncremented); }
protected void assertColumn(Table table, String name, String typeName, int jdbcType, int length, int scale, boolean optional, boolean generated, boolean autoIncremented) { Column column = table.columnWithName(name); assertThat(column.name()).isEqualTo(name); assertThat(column.typeName()).isEqualTo(typeName); assertThat(column.jdbcType()).isEqualTo(jdbcType); assertThat(column.length()).isEqualTo(length); if (scale == Column.UNSET_INT_VALUE) { assertFalse(column.scale().isPresent()); } else { assertThat(column.scale().get()).isEqualTo(scale); } assertThat(column.isOptional()).isEqualTo(optional); assertThat(column.isGenerated()).isEqualTo(generated); assertThat(column.isAutoIncremented()).isEqualTo(autoIncremented); }
protected void assertColumn(Table table, String name, String typeName, int jdbcType, int length, String charsetName, boolean optional) { Column column = table.columnWithName(name); assertThat(column.name()).isEqualTo(name); assertThat(column.typeName()).isEqualTo(typeName); assertThat(column.jdbcType()).isEqualTo(jdbcType); assertThat(column.length()).isEqualTo(length); assertThat(column.charsetName()).isEqualTo(charsetName); assertFalse(column.scale().isPresent()); assertThat(column.isOptional()).isEqualTo(optional); assertThat(column.isGenerated()).isFalse(); assertThat(column.isAutoIncremented()).isFalse(); }
@Test public void shouldCreateColumnWithAllFieldsSetToNonDefaults() { createColumnWithAllFieldsSetToNonDefaults(); assertThat(column.name()).isEqualTo("price"); assertThat(column.typeName()).isEqualTo("NUMBER"); assertThat(column.jdbcType()).isEqualTo(Types.DOUBLE); assertThat(column.length()).isEqualTo(5); assertThat(column.scale().get()).isEqualTo(2); assertThat(column.position()).isEqualTo(4); assertThat(column.isOptional()).isTrue(); assertThat(column.isAutoIncremented()).isTrue(); assertThat(column.isGenerated()).isTrue(); }
@Test public void shouldCreateColumnWithAllFieldsSetToDefaults() { Column column = editor.create(); assertThat(column.name()).isNull(); assertThat(column.typeName()).isNull(); assertThat(column.jdbcType()).isEqualTo(Types.INTEGER); assertThat(column.length()).isEqualTo(-1); Assert.assertFalse(column.scale().isPresent()); assertThat(column.position()).isEqualTo(1); assertThat(column.isOptional()).isTrue(); assertThat(column.isAutoIncremented()).isFalse(); assertThat(column.isGenerated()).isFalse(); }