public Column getColumn() { return columnEditor.create(); }
@Override public Table create() { if (id == null) throw new IllegalStateException("Unable to create a table from an editor that has no table ID"); List<Column> columns = new ArrayList<>(); sortedColumns.values().forEach(column->{ column = column.edit().charsetNameOfTable(defaultCharsetName).create(); columns.add(column); }); return new TableImpl(id, columns, primaryKeyColumnNames(), defaultCharsetName); } }
@Override public void exitAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) { parser.runIfNotNull(() -> { columnEditors.forEach(columnEditor -> tableEditor.addColumn(columnEditor.create())); listeners.remove(columnDefinitionListener); }, tableEditor, columnEditors); super.exitAlterByAddColumns(ctx); }
protected void updatePositions() { AtomicInteger position = new AtomicInteger(1); sortedColumns.replaceAll((name, defn) -> { // Decrement the position ... int nextPosition = position.getAndIncrement(); if (defn.position() != nextPosition) { return defn.edit().position(nextPosition).create(); } return defn; }); }
protected void add(Column defn) { if (defn != null) { Column existing = columnWithName(defn.name()); int position = existing != null ? existing.position() : sortedColumns.size() + 1; sortedColumns.put(defn.name().toLowerCase(), defn.edit().position(position).create()); } assert positionsAreValid(); }
private void addColumnFromTable(TableEditor table, String columnName, String newColumnName, Table selectedTable) { for (Column column : selectedTable.columns()) { if (column.name().equals(columnName)) { table.addColumn(column.edit().name(newColumnName).create()); break; } } } }
@Override public void enterUniqueKeyColumnConstraint(MySqlParser.UniqueKeyColumnConstraintContext ctx) { if (!tableEditor.hasPrimaryKey()) { // take the first unique constrain if no primary key is set tableEditor.addColumn(columnEditor.create()); tableEditor.setPrimaryKeyNames(columnEditor.name()); } super.enterUniqueKeyColumnConstraint(ctx); }
@Override public void enterPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx) { // this rule will be parsed only if no primary key is set in a table // otherwise the statement can't be executed due to multiple primary key error columnEditor.optional(false); tableEditor.addColumn(columnEditor.create()); tableEditor.setPrimaryKeyNames(columnEditor.name()); super.enterPrimaryKeyColumnConstraint(ctx); }
@Override public void enterCreateView(MySqlParser.CreateViewContext ctx) { if (!parser.skipViews()) { tableEditor = parser.databaseTables().editOrCreateTable(parser.parseQualifiedTableId(ctx.fullId())); // create new columns just with specified name for now if (ctx.uidList() != null) { ctx.uidList().uid().stream().map(parser::parseName).forEach(columnName -> { tableEditor.addColumn(Column.editor().name(columnName).create()); }); } selectColumnsListener = new ViewSelectedColumnsParserListener(tableEditor, parser); listeners.add(selectColumnsListener); } super.enterCreateView(ctx); }
@Test(expected = IllegalArgumentException.class) public void shouldNotAllowAddingPrimaryKeyColumnWhenNotFound() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).position(1).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).position(1).create(); editor.addColumns(c1, c2, c3); editor.setPrimaryKeyNames("C1", "WOOPS"); }
@Before public void beforeEach() { column = Column.editor().name("firstName").jdbcType(Types.VARCHAR).type("VARCHAR").position(1).create(); column2 = Column.editor().name("lastName").jdbcType(Types.VARCHAR).type("VARCHAR").position(2).create(); column3 = Column.editor().name("otherColumn").jdbcType(Types.VARCHAR).type("VARCHAR").position(3).create(); fullyQualifiedNames = tableId + "." + column.name() + "," + tableId + "." + column3.name() + ","; }
@Test(expected = IllegalArgumentException.class) public void shouldNotReorderColumnIfNameDoesNotMatch() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).autoIncremented(true).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).autoIncremented(true).create(); editor.addColumns(c1, c2, c3); editor.reorderColumn("WOOPS", "C2"); assertValidPositions(editor); }
@Test @FixFor("DBZ-644") public void shouldAddTypeInformation() { int length = 255; Column column = Column.editor() .name("col") .type("VARCHAR") .jdbcType(Types.VARCHAR) .length(length) .create(); SchemaBuilder schemaBuilder = SchemaBuilder.string(); new PropagateSourceTypeToSchemaParameter().alterFieldSchema(column, schemaBuilder); assertThat(schemaBuilder.parameters().get("__debezium.source.column.type")).isEqualTo("VARCHAR"); assertThat(schemaBuilder.parameters().get("__debezium.source.column.length")).isEqualTo(String.valueOf(length)); }
@Test public void shouldRemoveColumnByName() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).autoIncremented(true).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).autoIncremented(true).create(); editor.addColumns(c1, c2, c3); editor.removeColumn("C2"); assertThat(editor.columns()).containsExactly(editor.columnWithName("C1"), editor.columnWithName("C3")); assertValidPositions(editor); }
@Test @FixFor("DBZ-1073") public void shouldAddColumnScale() { int length = 5; int scale = 2; Column column = Column.editor() .name("col") .type("NUMERIC") .jdbcType(Types.NUMERIC) .length(length) .scale(scale) .create(); SchemaBuilder schemaBuilder = SchemaBuilder.string(); new PropagateSourceTypeToSchemaParameter().alterFieldSchema(column, schemaBuilder); assertThat(schemaBuilder.parameters().get("__debezium.source.column.type")).isEqualTo("NUMERIC"); assertThat(schemaBuilder.parameters().get("__debezium.source.column.length")).isEqualTo(String.valueOf(length)); assertThat(schemaBuilder.parameters().get("__debezium.source.column.scale")).isEqualTo(String.valueOf(scale)); } }
@Test public void shouldFindNonExistingColumnByNameIndependentOfCase() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).position(1).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).position(1).create(); editor.addColumns(c1, c2, c3); editor.columns().forEach(col -> { assertThat(editor.columnWithName(col.name())).isNotNull(); assertThat(editor.columnWithName(col.name().toUpperCase())).isNotNull(); assertThat(editor.columnWithName(col.name().toLowerCase())).isNotNull(); }); assertThat(editor.columnWithName("WOOPS")).isNull(); }
protected void createColumnWithAllFieldsSetToNonDefaults() { column = editor.name("price") .type("NUMBER") .jdbcType(Types.DOUBLE) .length(5) .scale(2) .position(4) .optional(true) .autoIncremented(true) .generated(true) .create(); }
@Test public void shouldFindGeneratedColumns() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).generated(true).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).generated(true).create(); editor.addColumns(c1, c2, c3); editor.setPrimaryKeyNames("C1"); table = editor.create(); assertThat(table.retrieveColumnNames()).containsExactly("C1", "C2", "C3"); table.columns().forEach(col -> { assertThat(table.isGenerated(col.name())).isEqualTo(col.isGenerated()); }); assertValidPositions(editor); }
@Test public void shouldFindAutoIncrementedColumns() { editor.tableId(id); Column c1 = columnEditor.name("C1").type("VARCHAR").jdbcType(Types.VARCHAR).length(10).position(1).create(); Column c2 = columnEditor.name("C2").type("NUMBER").jdbcType(Types.NUMERIC).length(5).autoIncremented(true).create(); Column c3 = columnEditor.name("C3").type("DATE").jdbcType(Types.DATE).autoIncremented(true).create(); editor.addColumns(c1, c2, c3); editor.setPrimaryKeyNames("C1"); table = editor.create(); assertThat(table.retrieveColumnNames()).containsExactly("C1", "C2", "C3"); table.columns().forEach(col -> { assertThat(table.isAutoIncremented(col.name())).isEqualTo(col.isAutoIncremented()); }); assertValidPositions(editor); }
@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(); }