@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())); } } }
LOGGER.warn( "No converter found for column {}.{} of type {}. The column will not be part of change events for that table.", tableId, column.name(), column.typeName());
Column col = columns.get(i); LOGGER.error("Failed to properly convert data value for '{}.{}' of type {} for row {}:", tableId, col.name(), col.typeName(), row, e); } catch (final Exception e) { Column col = columns.get(i); LOGGER.error("Failed to properly convert data value for '{}.{}' of type {} for row {}:", tableId, col.name(), col.typeName(), row, e);
final int incomingType = message.getType().getOid(); if (localType != incomingType) { logger.info("detected new type for column '{}', old type was {} ({}), new type is {} ({}); refreshing table schema", columnName, localType, column.typeName(), incomingType, message.getType().getName()); return true;
Column col = columns.get(i); LOGGER.error("Failed to properly convert key value for '{}.{}' of type {} for row {}:", columnSetName, col.name(), col.typeName(), row, e);
@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; }
changedColumns.add(column.edit() .jdbcType(selectedColumn.jdbcType()) .type(selectedColumn.typeName(), selectedColumn.typeExpression()) .length(selectedColumn.length()) .scale(selectedColumn.scale().orElse(null))
@Test public void shouldUseFiltersForAlterTable() { parser = new MysqlDdlParserWithSimpleTestListener(listener, TableFilter.fromPredicate(x -> !x.table().contains("ignored"))); final String ddl = "CREATE TABLE ok (id int primary key, val smallint);" + System.lineSeparator() + "ALTER TABLE ignored ADD COLUMN(x tinyint)" + System.lineSeparator() + "ALTER TABLE ok ADD COLUMN(y tinyint)"; parser.parse(ddl, tables); assertThat(((MysqlDdlParserWithSimpleTestListener)parser).getParsingExceptionsFromWalker()).isEmpty(); assertThat(tables.size()).isEqualTo(1); final Table t1 = tables.forTable(null, null, "ok"); assertThat(t1.columns()).hasSize(3); final Column c1 = t1.columns().get(0); final Column c2 = t1.columns().get(1); final Column c3 = t1.columns().get(2); assertThat(c1.name()).isEqualTo("id"); assertThat(c1.typeName()).isEqualTo("INT"); assertThat(c2.name()).isEqualTo("val"); assertThat(c2.typeName()).isEqualTo("SMALLINT"); assertThat(c3.name()).isEqualTo("y"); assertThat(c3.typeName()).isEqualTo("TINYINT"); }
@Test @FixFor("DBZ-780") public void shouldRenameColumnWithoutDefinition() { parser = new MysqlDdlParserWithSimpleTestListener(listener, TableFilter.fromPredicate(x -> !x.table().contains("ignored"))); final String ddl = "CREATE TABLE foo (id int primary key, old INT);" + System.lineSeparator() + "ALTER TABLE foo RENAME COLUMN old to new "; parser.parse(ddl, tables); assertThat(((MysqlDdlParserWithSimpleTestListener)parser).getParsingExceptionsFromWalker()).isEmpty(); assertThat(tables.size()).isEqualTo(1); final Table t1 = tables.forTable(null, null, "foo"); assertThat(t1.columns()).hasSize(2); final Column c1 = t1.columns().get(0); final Column c2 = t1.columns().get(1); assertThat(c1.name()).isEqualTo("id"); assertThat(c1.typeName()).isEqualTo("INT"); assertThat(c2.name()).isEqualTo("new"); assertThat(c2.typeName()).isEqualTo("INT"); }
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; }
@Test @FixFor("DBZ-1028") public void shouldParseCommentWithEngineName() { final String ddl = "CREATE TABLE t1 (" + "`id` int(11) NOT NULL AUTO_INCREMENT, " + "`field_1` int(11) NOT NULL, " + "`field_2` int(11) NOT NULL, " + "`field_3` int(11) NOT NULL, " + "`field_4` int(11) NOT NULL, " + "`field_5` tinytext COLLATE utf8_unicode_ci NOT NULL, " + "`field_6` tinytext COLLATE utf8_unicode_ci NOT NULL, " + "`field_7` tinytext COLLATE utf8_unicode_ci NOT NULL COMMENT 'CSV'," + "primary key(id));"; parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(1); Column columnWithComment = tables.forTable(null, null, "t1").columnWithName("field_7"); assertThat(columnWithComment.typeName()).isEqualToIgnoringCase("tinytext"); }
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); }
@Override public SchemaBuilder schemaBuilder(Column column) { String typeName = column.typeName().toUpperCase(); if (matches(typeName, "JSON")) { return Json.builder();
@Override public ValueConverter converter(Column column, Field fieldDefn) { String typeName = column.typeName().toUpperCase(); if (matches(typeName, "JSON")) { return (data) -> convertJson(column, fieldDefn, data);
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(); }
assertThat(person.retrieveColumnNames()).containsExactly("name","birthdate","age","salary","bitStr"); assertThat(person.columnWithName("name").name()).isEqualTo("name"); assertThat(person.columnWithName("name").typeName()).isEqualTo("VARCHAR"); assertThat(person.columnWithName("name").jdbcType()).isEqualTo(Types.VARCHAR); assertThat(person.columnWithName("name").length()).isEqualTo(255); assertThat(person.columnWithName("name").isOptional()).isFalse(); assertThat(person.columnWithName("birthdate").name()).isEqualTo("birthdate"); assertThat(person.columnWithName("birthdate").typeName()).isEqualTo("DATE"); assertThat(person.columnWithName("birthdate").jdbcType()).isEqualTo(Types.DATE); assertThat(person.columnWithName("birthdate").length()).isEqualTo(10); assertThat(person.columnWithName("birthdate").isOptional()).isTrue(); assertThat(person.columnWithName("age").name()).isEqualTo("age"); assertThat(person.columnWithName("age").typeName()).isEqualTo("INT"); assertThat(person.columnWithName("age").jdbcType()).isEqualTo(Types.INTEGER); assertThat(person.columnWithName("age").length()).isEqualTo(10); assertThat(person.columnWithName("age").isOptional()).isTrue(); assertThat(person.columnWithName("salary").name()).isEqualTo("salary"); assertThat(person.columnWithName("salary").typeName()).isEqualTo("DECIMAL"); assertThat(person.columnWithName("salary").jdbcType()).isEqualTo(Types.DECIMAL); assertThat(person.columnWithName("salary").length()).isEqualTo(5); assertThat(person.columnWithName("salary").isOptional()).isTrue(); assertThat(person.columnWithName("bitStr").name()).isEqualTo("bitStr"); assertThat(person.columnWithName("bitStr").typeName()).isEqualTo("BIT"); assertThat(person.columnWithName("bitStr").jdbcType()).isEqualTo(Types.BIT); assertThat(person.columnWithName("bitStr").length()).isEqualTo(18);