/** * Time precision in SQL Server is defined in scale, the default one is 7 */ @Override protected int getTimePrecision(Column column) { return column.scale().get(); }
@Override protected int getTimePrecision(Column column) { return column.scale().orElse(-1); }
@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())); } } }
private SchemaBuilder numericSchema(Column column) { if (decimalMode == DecimalMode.PRECISE && isVariableScaleDecimal(column)) { return VariableScaleDecimal.builder(); } return SpecialValueDecimal.builder(decimalMode, column.length(), column.scale().get()); }
protected Object convertDecimal(Column column, Field fieldDefn, Object data, DecimalMode mode) { SpecialValueDecimal value; BigDecimal newDecimal; if (data instanceof SpecialValueDecimal) { value = (SpecialValueDecimal)data; if (!value.getDecimalValue().isPresent()) { return SpecialValueDecimal.fromLogical(value, mode, column.name()); } } else { final Object o = toBigDecimal(column, fieldDefn, data); if (o == null || !(o instanceof BigDecimal)) { return o; } value = new SpecialValueDecimal((BigDecimal)o); } newDecimal = value.getDecimalValue().get(); if (column.scale().get() > newDecimal.scale()) { newDecimal = newDecimal.setScale(column.scale().get()); } if (isVariableScaleDecimal(column) && mode == DecimalMode.PRECISE) { newDecimal = newDecimal.stripTrailingZeros(); if (newDecimal.scale() < 0) { newDecimal = newDecimal.setScale(0); } return VariableScaleDecimal.fromLogical(fieldDefn.schema(), new SpecialValueDecimal(newDecimal)); } return SpecialValueDecimal.fromLogical(new SpecialValueDecimal(newDecimal), mode, column.name()); }
@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); } }
return true; final int localScale = column.scale().get(); final int incomingScale = message.getTypeMetadata().getScale(); if (localScale != incomingScale) {
@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; }
.type(selectedColumn.typeName(), selectedColumn.typeExpression()) .length(selectedColumn.length()) .scale(selectedColumn.scale().orElse(null)) .autoIncremented(selectedColumn.isAutoIncremented()) .generated(selectedColumn.isGenerated())
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); }
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; }
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(); }
case Types.NUMERIC: case Types.DECIMAL: return SpecialValueDecimal.builder(decimalMode, column.length(), column.scale().get());
@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(); }
return Point.builder(); case PgOid.MONEY: return Decimal.builder(column.scale().get()); case PgOid.NUMERIC: return numericSchema(column);
assertThat(person.columnWithName("name").jdbcType()).isEqualTo(Types.VARCHAR); assertThat(person.columnWithName("name").length()).isEqualTo(255); assertFalse(person.columnWithName("name").scale().isPresent()); assertThat(person.columnWithName("name").position()).isEqualTo(1); assertThat(person.columnWithName("name").isAutoIncremented()).isFalse(); assertThat(person.columnWithName("birthdate").jdbcType()).isEqualTo(Types.DATE); assertThat(person.columnWithName("birthdate").length()).isEqualTo(10); assertFalse(person.columnWithName("birthdate").scale().isPresent()); assertThat(person.columnWithName("birthdate").position()).isEqualTo(2); assertThat(person.columnWithName("birthdate").isAutoIncremented()).isFalse(); assertThat(!person.columnWithName("age").scale().isPresent()); assertThat(person.columnWithName("age").position()).isEqualTo(3); assertThat(person.columnWithName("age").isAutoIncremented()).isFalse(); assertThat(person.columnWithName("salary").jdbcType()).isEqualTo(Types.DECIMAL); assertThat(person.columnWithName("salary").length()).isEqualTo(5); assertThat(person.columnWithName("salary").scale().get()).isEqualTo(2); assertThat(person.columnWithName("salary").position()).isEqualTo(4); assertThat(person.columnWithName("salary").isAutoIncremented()).isFalse(); assertThat(person.columnWithName("bitStr").jdbcType()).isEqualTo(Types.BIT); assertThat(person.columnWithName("bitStr").length()).isEqualTo(18); assertFalse(person.columnWithName("bitStr").scale().isPresent()); assertThat(person.columnWithName("bitStr").position()).isEqualTo(5); assertThat(person.columnWithName("bitStr").isAutoIncremented()).isFalse(); assertThat(product.columnWithName("id").jdbcType()).isEqualTo(Types.INTEGER);