@Test @FixFor("DBZ-910") public void shouldParseConstraintCheck() { parser = new MysqlDdlParserWithSimpleTestListener(listener, true); final String ddl = "CREATE TABLE t1 (c1 INTEGER NOT NULL,c2 VARCHAR(22),CHECK (c2 IN ('A', 'B', 'C')));" + "CREATE TABLE t2 (c1 INTEGER NOT NULL,c2 VARCHAR(22),CONSTRAINT c1 CHECK (c2 IN ('A', 'B', 'C')));" + "CREATE TABLE t3 (c1 INTEGER NOT NULL,c2 VARCHAR(22),CONSTRAINT CHECK (c2 IN ('A', 'B', 'C')));" + "ALTER TABLE t1 ADD CONSTRAINT CHECK (c1 IN (1, 2, 3, 4));" + "ALTER TABLE t1 ADD CONSTRAINT c2 CHECK (c1 IN (1, 2, 3, 4))" + "ALTER TABLE t1 ADD CHECK (c1 IN (1, 2, 3, 4))"; parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(3); assertThat(tables.forTable(null, null, "t1").columns()).hasSize(2); assertThat(tables.forTable(null, null, "t2").columns()).hasSize(2); assertThat(tables.forTable(null, null, "t3").columns()).hasSize(2); }
@Test public void shouldParseCreateTableStatementWithCharacterSetForColumns() { String ddl = "CREATE TABLE t ( col1 VARCHAR(25) CHARACTER SET greek ); "; parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(1); Table t = tables.forTable(new TableId(null, null, "t")); assertThat(t).isNotNull(); assertThat(t.retrieveColumnNames()).containsExactly("col1"); assertThat(t.primaryKeyColumnNames()).isEmpty(); assertColumn(t, "col1", "VARCHAR", Types.VARCHAR, 25, -1, true, false, false); }
private void validateFieldDef(Field expected) { ConfigDef configDef = connector.config(); assertThat(configDef.names()).contains(expected.name()); ConfigDef.ConfigKey key = configDef.configKeys().get(expected.name()); assertThat(key).isNotNull(); assertThat(key.name).isEqualTo(expected.name()); assertThat(key.displayName).isEqualTo(expected.displayName()); assertThat(key.importance).isEqualTo(expected.importance()); assertThat(key.documentation).isEqualTo(expected.description()); assertThat(key.type).isEqualTo(expected.type()); assertThat(key.defaultValue).isEqualTo(expected.defaultValue()); assertThat(key.dependents).isEqualTo(expected.dependents()); assertThat(key.width).isNotNull(); assertThat(key.group).isNotNull(); assertThat(key.orderInGroup).isGreaterThan(0); assertThat(key.validator).isNull(); assertThat(key.recommender).isNull(); } }
Assertions.assertThat(content.get(fieldName)).as(fieldName + " is present in the actual content").isNull(); return; Assertions.assertThat(actualValue).as(fieldName + " is not present in the actual content").isNotNull(); Assertions.assertThat(value).as("Incorrect value type for " + fieldName).isInstanceOf(List.class); final List<?> actualValueList = (List<?>)actualValue; final List<?> valueList = (List<?>)value; Assertions.assertThat(actualValueList).as("List size don't match for " + fieldName).hasSize(valueList.size()); if (!valueList.isEmpty() && valueList.iterator().next() instanceof Struct) { for (int i = 0; i < valueList.size(); i++) {
@Test public void parseTableWithPageChecksum() { String ddl = "CREATE TABLE t (id INT NOT NULL, PRIMARY KEY (`id`)) PAGE_CHECKSUM=1;" + "ALTER TABLE t PAGE_CHECKSUM=0;"; parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(1); Table t = tables.forTable(new TableId(null, null, "t")); assertThat(t).isNotNull(); assertThat(t.retrieveColumnNames()).containsExactly("id"); assertThat(t.primaryKeyColumnNames()).hasSize(1); assertColumn(t, "id", "INT", Types.INTEGER, -1, -1, false, false, false); }
@Test public void testMulitpleRequiredness() { ThriftStructMetadataBuilder builder = new ThriftStructMetadataBuilder(new ThriftCatalog(), MultipleRequiredness.class); MetadataErrors metadataErrors = builder.getMetadataErrors(); assertThat(metadataErrors.getErrors()) .as("metadata errors") .hasSize(1); assertThat(metadataErrors.getWarnings()) .as("metadata warnings") .isEmpty(); assertThat(metadataErrors.getErrors().get(0).getMessage()) .as("error message") .containsIgnoringCase("multiple requiredness"); }
@Test public void shouldParseHostStringWithAddressForOneReplicaSet() { sets = ReplicaSets.parse("myReplicaSet/localhost:27017"); assertThat(sets.replicaSetCount()).isEqualTo(1); assertThat(sets.hosts()).isEqualTo("myReplicaSet/localhost:27017"); rs = sets.all().get(0); assertThat(rs.hasReplicaSetName()).isTrue(); assertThat(rs.isStandaloneServer()).isFalse(); assertThat(rs.replicaSetName()).isEqualTo("myReplicaSet"); assertThat(rs.shardName()).isNull(); ServerAddress expected = new ServerAddress("localhost", 27017); assertThat(rs.addresses().size()).isEqualTo(1); assertThat(rs.addresses()).containsOnly(expected); }
assertThat(transformed1).isNotNull(); assertThat(transformed1.topic()).isEqualTo(replacedTopic); assertThat(transformed1.keySchema().name()).isEqualTo(replacedTopic + ".Key"); assertThat(transformed1.keySchema().fields()).hasSize(2); assertThat(transformed1.keySchema().fields().get(0).name()).isEqualTo(keyFieldName); assertThat(transformed1.keySchema().fields().get(1).name()).isEqualTo(keyOriginalKeyTopic); assertThat(((Struct) transformed1.key()).get(keyFieldName)).isEqualTo("test_server_name_db"); assertThat(((Struct) transformed1.key()).get(keyOriginalKeyTopic)).isEqualTo("__debezium-heartbeat.test_server_name_db"); assertThat(transformed1.value()).isNull(); assertThat(transformed2.keySchema().name()).isEqualTo(replacedTopic + ".Key"); assertThat(transformed2.keySchema().fields()).hasSize(2); assertThat(transformed2.keySchema().fields().get(0).name()).isEqualTo(keyFieldName); assertThat(transformed2.keySchema().fields().get(1).name()).isEqualTo(keyOriginalKeyTopic);
RecordsForCollection records = recordMakers.forCollection(collectionId); records.recordEvent(event, 1002); assertThat(produced.size()).isEqualTo(1); SourceRecord record = produced.get(0); assertThat((operationHeader).hasNext()).isTrue(); assertThat(operationHeader.next().value().toString()).isEqualTo(Envelope.Operation.UPDATE.code()); assertThat(key.schema()).isSameAs(transformed.keySchema()); assertThat(key.schema().field("id").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(key.get("id")).isEqualTo(objId.toString()); assertThat(value.schema().field("id").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(value.schema().field("name").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(value.schema().fields()).hasSize(2);
SourceRecords records = consumeRecordsByTopic(numCreateDatabase + numCreateTables + numInserts); stopConnector(); assertThat(records).isNotNull(); records.forEach(this::validate); assertThat(dmls).hasSize(1); assertThat(insert.valueSchema().name()).endsWith("dbz_878_some_test_data.Envelope"); VerifyRecord.isValidInsert(insert, "id", 1); assertThat(sourceTable).isEqualTo("dbz_878_some|test@data");
@Test public void shouldFilterAndMergeGtidSet() throws Exception { String gtidStr = "036d85a9-64e5-11e6-9b48-42010af0000c:1-2," + "7c1de3f2-3fd2-11e6-9cdc-42010af000bc:5-41"; String availableServerGtidStr = "036d85a9-64e5-11e6-9b48-42010af0000c:1-20," + "7145bf69-d1ca-11e5-a588-0242ac110004:1-3200," + "123e4567-e89b-12d3-a456-426655440000:1-41"; String purgedServerGtidStr = ""; config = simpleConfig().with(MySqlConnectorConfig.GTID_SOURCE_INCLUDES, "036d85a9-64e5-11e6-9b48-42010af0000c") .build(); context = new MySqlTaskContext(config, new Filters.Builder(config).build(), false, null); context.start(); context.source().setCompletedGtidSet(gtidStr); GtidSet mergedGtidSet = context.filterGtidSet(new GtidSet(availableServerGtidStr), new GtidSet(purgedServerGtidStr)); assertThat(mergedGtidSet).isNotNull(); GtidSet.UUIDSet uuidSet1 = mergedGtidSet.forServerWithId("036d85a9-64e5-11e6-9b48-42010af0000c"); GtidSet.UUIDSet uuidSet2 = mergedGtidSet.forServerWithId("7145bf69-d1ca-11e5-a588-0242ac110004"); GtidSet.UUIDSet uuidSet3 = mergedGtidSet.forServerWithId("123e4567-e89b-12d3-a456-426655440000"); GtidSet.UUIDSet uuidSet4 = mergedGtidSet.forServerWithId("7c1de3f2-3fd2-11e6-9cdc-42010af000bc"); assertThat(uuidSet1.getIntervals()).isEqualTo(Arrays.asList(new GtidSet.Interval(1, 2))); assertThat(uuidSet2.getIntervals()).isEqualTo(Arrays.asList(new GtidSet.Interval(1, 3200))); assertThat(uuidSet3.getIntervals()).isEqualTo(Arrays.asList(new GtidSet.Interval(1, 41))); assertThat(uuidSet4).isNull(); }
@Test public void shouldParseHostStringWithAddressesForOneShard() { sets = ReplicaSets.parse("shard1=myReplicaSet/localhost:27017,1.2.3.4:27017,localhost:28017,[fe80::601:9bff:feab:ec01]:27017"); assertThat(sets.replicaSetCount()).isEqualTo(1); assertThat(sets.hosts()).isEqualTo("shard1=myReplicaSet/1.2.3.4:27017,[fe80::601:9bff:feab:ec01]:27017,localhost:27017,localhost:28017"); rs = sets.all().get(0); assertThat(rs.hasReplicaSetName()).isTrue(); assertThat(rs.isStandaloneServer()).isFalse(); assertThat(rs.replicaSetName()).isEqualTo("myReplicaSet"); assertThat(rs.shardName()).isEqualTo("shard1"); ServerAddress expected1 = new ServerAddress("1.2.3.4", 27017); ServerAddress expected2 = new ServerAddress("[fe80::601:9bff:feab:ec01]", 27017); ServerAddress expected3 = new ServerAddress("localhost", 27017); ServerAddress expected4 = new ServerAddress("localhost", 28017); assertThat(rs.addresses().size()).isEqualTo(4); assertThat(rs.addresses()).containsOnly(expected1, expected2, expected3, expected4); }
conn.readSchema(tables, DATABASE.getDatabaseName(), null, null, null, true); assertThat(tables.size()).isEqualTo(1); Table person = tables.forTable(DATABASE.getDatabaseName(), null, "person"); assertThat(person).isNotNull(); assertThat(person.filterColumns(col->col.isAutoIncremented())).isEmpty(); assertThat(person.primaryKeyColumnNames()).containsOnly("name"); 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("birthdate").name()).isEqualTo("birthdate"); assertThat(product).isNotNull(); assertThat(product.filterColumnNames(Column::isAutoIncremented)).containsOnly("id"); assertThat(product.primaryKeyColumnNames()).containsOnly("id"); assertThat(product.retrieveColumnNames()).containsExactly("id","createdByDate","modifiedDate"); assertThat(purchased).isNotNull(); assertThat(person.filterColumns(col->col.isAutoIncremented())).isEmpty(); assertThat(purchased.primaryKeyColumnNames()).containsOnly("productId","purchaser"); assertThat(purchased.retrieveColumnNames()).containsExactly("purchaser","productId","purchaseDate");
@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"); }
private static void verifyIssue(TestIssue expected, Issue actual, File file) { if (line(actual) > expected.line()) { fail("Missing issue at line " + expected.line() + " in file " + file.getAbsolutePath()); } if (line(actual) < expected.line()) { fail("Unexpected issue at line " + line(actual) + ": \"" + message(actual) + "\"" + " in file " + file.getAbsolutePath()); } if (expected.message() != null) { assertThat(message(actual)).as("Bad message at line " + expected.line()).isEqualTo(expected.message()); } if (expected.effortToFix() != null) { assertThat(actual.cost()).as("Bad effortToFix at line " + expected.line()).isEqualTo(expected.effortToFix()); } if (expected.startColumn() != null) { assertThat(((PreciseIssue) actual).primaryLocation().startLineOffset() + 1).as("Bad start column at line " + expected.line()).isEqualTo(expected.startColumn()); } if (expected.endColumn() != null) { assertThat(((PreciseIssue) actual).primaryLocation().endLineOffset() + 1).as("Bad end column at line " + expected.line()).isEqualTo(expected.endColumn()); } if (expected.endLine() != null) { assertThat(((PreciseIssue) actual).primaryLocation().endLine()).as("Bad end line at line " + expected.line()).isEqualTo(expected.endLine()); } if (expected.secondaryLines() != null) { assertThat(secondary(actual)).as("Bad secondary locations at line " + expected.line()).isEqualTo(expected.secondaryLines()); } }
/** * Insert 1 Record into tablenuma with {@code DecimalHandlingMode.STRING} * mode Assertions: - Connector is running - 1 Record are streamed out of * cdc - Assert cola, colb, colc, cold are exactly equal to the input * values. * * @throws Exception */ @Test public void decimalModeConfigString() throws Exception { final Configuration config = TestHelper.defaultConfig() .with(SqlServerConnectorConfig.SNAPSHOT_MODE, SnapshotMode.INITIAL) .with(SqlServerConnectorConfig.TABLE_WHITELIST, "dbo.tablenuma") .with(SqlServerConnectorConfig.DECIMAL_HANDLING_MODE, DecimalHandlingMode.STRING).build(); start(SqlServerConnector.class, config); assertConnectorIsRunning(); TestHelper.waitForSnapshotToBeCompleted(); connection.execute("INSERT INTO tablenuma VALUES (111.1111, 1111111, 1111111.1, 1111111 );"); final SourceRecords records = consumeRecordsByTopic(1); final List<SourceRecord> tableA = records.recordsForTopic("server1.dbo.tablenuma"); Assertions.assertThat(tableA).hasSize(1); final Struct valueA = (Struct) tableA.get(0).value(); assertSchema(valueA, Schema.OPTIONAL_STRING_SCHEMA); Assertions.assertThat(((Struct) valueA.get("after")).get("cola")).isEqualTo("111.1111"); Assertions.assertThat(((Struct) valueA.get("after")).get("colb")).isEqualTo("1111111"); Assertions.assertThat(((Struct) valueA.get("after")).get("colc")).isEqualTo("1111111.1"); Assertions.assertThat(((Struct) valueA.get("after")).get("cold")).isEqualTo("1111111"); stopConnector(); }
@Test public void testOrderedList() throws Exception { father.getOrderedChildren().add( luke ); father.getOrderedChildren().add( null ); father.getOrderedChildren().add( leia ); inTransaction( session -> { session.persist( luke ); session.persist( leia ); session.persist( father ); } ); inTransaction( session -> { father = (Father) session.get( Father.class, father.getId() ); assertThat( father.getOrderedChildren() ) .as( "List should have 3 elements" ) .hasSize( 3 ); assertThat( father.getOrderedChildren().get( 0 ).getName() ) .as( "Luke should be first" ) .isEqualTo( luke.getName() ); assertThat( father.getOrderedChildren().get( 1 ) ) .as( "Second born should be null" ) .isNull(); assertThat( father.getOrderedChildren().get( 2 ).getName() ) .as( "Leia should be third" ) .isEqualTo( leia.getName() ); } ); }
@Test public void shouldHaveColumns() { assertThat(table.retrieveColumnNames()).containsExactly("C1", "C2", "C3", "C4"); assertThat(table.columns()).containsExactly(c1, c2, c3, c4); }
@Test @FixFor("DBZ-1059") public void shouldParseAlterTableRename() { final String ddl = "USE db;" + "CREATE TABLE db.t1 (ID INTEGER PRIMARY KEY);" + "ALTER TABLE `t1` RENAME TO `t2`;" + "ALTER TABLE `db`.`t2` RENAME TO `db`.`t3`;"; parser = new MysqlDdlParserWithSimpleTestListener(listener, true); parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(1); final Table table = tables.forTable(new TableId(null, "db", "t3")); assertThat(table).isNotNull(); assertThat(table.columns()).hasSize(1); }
@Test public void shouldParseCreateTableStatementWithSingleGeneratedAndPrimaryKeyColumn() { String ddl = "CREATE TABLE foo ( " + System.lineSeparator() + " c1 INTEGER GENERATED ALWAYS AS IDENTITY NOT NULL PRIMARY KEY, " + System.lineSeparator() + " c2 VARCHAR(22) " + System.lineSeparator() + "); " + System.lineSeparator(); parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(1); Table foo = tables.forTable(new TableId(null,null,"foo")); assertThat(foo).isNotNull(); assertThat(foo.retrieveColumnNames()).containsExactly("c1","c2"); assertThat(foo.primaryKeyColumnNames()).containsExactly("c1"); assertColumn(foo,"c1","INTEGER",Types.INTEGER,-1,-1,false,true,true); assertColumn(foo,"c2","VARCHAR",Types.VARCHAR,22,-1,true,false,false); }