This is an automated email from the ASF dual-hosted git repository. github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/dev/pr-13212-c812d79ce156e98b3dc6f77861211b117025cedb in repository https://gitbox.apache.org/repos/asf/seatunnel.git
commit 9fd5128cc1e46bd20e0c436cc4f9147031451f4a Author: zhiweiniu <[email protected]> AuthorDate: Tue Nov 17 11:46:23 2026 +0000 [Test][Benchmark] Add a CDC record emitter benchmark (#13212) --- .github/workflows/benchmarks.yml | 1 + seatunnel-benchmarks/README.md | 9 + seatunnel-benchmarks/pom.xml | 10 + .../IncrementalSourceRecordEmitterBenchmark.java | 93 ++++ .../cdc/IncrementalSourceRecordEmitterFixture.java | 523 +++++++++++++++++++++ .../IncrementalSourceStreamFetcherBridge.java | 30 ++ 6 files changed, 666 insertions(+) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index a314ac4d97..2028af5167 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -38,6 +38,7 @@ on: - 'IntermediateQueueBenchmark' - 'MultiTableSinkBenchmark' - 'DebeziumJsonFormatBenchmark' + - 'IncrementalSourceRecordEmitterBenchmark' - 'ProtoStuffSerializerBenchmark' - 'SeaTunnelPipelineBenchmark' - 'CheckpointingTimeBenchmark' diff --git a/seatunnel-benchmarks/README.md b/seatunnel-benchmarks/README.md index 15d15829bf..e335475f4b 100644 --- a/seatunnel-benchmarks/README.md +++ b/seatunnel-benchmarks/README.md @@ -47,6 +47,15 @@ Run only the `ProtoStuffSerializer` benchmarks: java -jar seatunnel-benchmarks/target/benchmarks.jar ProtoStuffSerializerBenchmark ``` +Run only the `IncrementalSourceRecordEmitter` benchmark. + +```bash +java -jar seatunnel-benchmarks/target/benchmarks.jar IncrementalSourceRecordEmitterBenchmark +``` + +The default uses 20 columns and covers INSERT/UPDATE with exactly-once disabled/enabled (4 cases). +Override the row width with `-p columns=40`. + Run the `MultiTableSink` record handoff benchmark without starting an engine or database: ```bash diff --git a/seatunnel-benchmarks/pom.xml b/seatunnel-benchmarks/pom.xml index 6f13a9dcca..66b029c19a 100644 --- a/seatunnel-benchmarks/pom.xml +++ b/seatunnel-benchmarks/pom.xml @@ -43,6 +43,16 @@ <artifactId>seatunnel-format-json</artifactId> <version>${project.version}</version> </dependency> + <dependency> + <groupId>org.apache.seatunnel</groupId> + <artifactId>connector-cdc-base</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>org.apache.seatunnel</groupId> + <artifactId>connector-cdc-mysql</artifactId> + <version>${project.version}</version> + </dependency> <dependency> <groupId>org.apache.seatunnel</groupId> <artifactId>connector-jdbc</artifactId> diff --git a/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/IncrementalSourceRecordEmitterBenchmark.java b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/IncrementalSourceRecordEmitterBenchmark.java new file mode 100644 index 0000000000..bd267cffec --- /dev/null +++ b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/IncrementalSourceRecordEmitterBenchmark.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.benchmark; + +import org.apache.seatunnel.benchmark.cdc.IncrementalSourceRecordEmitterFixture; + +import org.openjdk.jmh.Main; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.OperationsPerInvocation; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Threads; + +import java.io.IOException; +import java.util.concurrent.TimeUnit; + +/** Measures the incremental CDC stream filter and record emitter with prepared events. */ +@Threads(1) +@Fork( + value = 3, + jvmArgsAppend = { + "-Xms4g", + "-Xmx4g", + "-XX:+UseG1GC", + "-XX:+AlwaysPreTouch", + "-XX:+DisableExplicitGC", + "-XX:ActiveProcessorCount=4", + "-Djava.net.preferIPv4Stack=true" + }) +public class IncrementalSourceRecordEmitterBenchmark extends BenchmarkBase { + + @Param({"20"}) + private int columns; + + @Param({"INSERT", "UPDATE"}) + private IncrementalSourceRecordEmitterFixture.Operation operation; + + @Param({"false", "true"}) + private boolean exactlyOnce; + + private IncrementalSourceRecordEmitterFixture fixture; + + public static void main(String[] args) throws IOException { + String[] options = new String[args.length + 1]; + options[0] = IncrementalSourceRecordEmitterBenchmark.class.getCanonicalName(); + System.arraycopy(args, 0, options, 1, args.length); + Main.main(options); + } + + @Setup(Level.Trial) + public void setUp() throws Exception { + fixture = new IncrementalSourceRecordEmitterFixture(columns, operation, exactlyOnce); + fixture.setUp(); + } + + @Benchmark + @OutputTimeUnit(TimeUnit.SECONDS) + @OperationsPerInvocation(IncrementalSourceRecordEmitterFixture.BATCH_EVENTS) + public int filterAndEmit() throws Exception { + return fixture.filterAndEmit(); + } + + @TearDown(Level.Iteration) + public void verifyIteration() { + fixture.verifyBatch(); + } + + @TearDown(Level.Trial) + public void tearDown() { + if (fixture != null) { + fixture.close(); + } + } +} diff --git a/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/cdc/IncrementalSourceRecordEmitterFixture.java b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/cdc/IncrementalSourceRecordEmitterFixture.java new file mode 100644 index 0000000000..364844f8a3 --- /dev/null +++ b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/benchmark/cdc/IncrementalSourceRecordEmitterFixture.java @@ -0,0 +1,523 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.benchmark.cdc; + +import org.apache.seatunnel.api.common.metrics.AbstractMetricsContext; +import org.apache.seatunnel.api.common.metrics.MetricsContext; +import org.apache.seatunnel.api.event.EventListener; +import org.apache.seatunnel.api.source.Boundedness; +import org.apache.seatunnel.api.source.Collector; +import org.apache.seatunnel.api.source.SourceEvent; +import org.apache.seatunnel.api.source.SourceReader; +import org.apache.seatunnel.api.table.catalog.CatalogTable; +import org.apache.seatunnel.api.table.catalog.PhysicalColumn; +import org.apache.seatunnel.api.table.catalog.TableIdentifier; +import org.apache.seatunnel.api.table.catalog.TableSchema; +import org.apache.seatunnel.api.table.type.BasicType; +import org.apache.seatunnel.api.table.type.CommonOptions; +import org.apache.seatunnel.api.table.type.RowKind; +import org.apache.seatunnel.api.table.type.SeaTunnelRow; +import org.apache.seatunnel.connectors.cdc.base.source.offset.Offset; +import org.apache.seatunnel.connectors.cdc.base.source.offset.OffsetFactory; +import org.apache.seatunnel.connectors.cdc.base.source.reader.IncrementalSourceRecordEmitter; +import org.apache.seatunnel.connectors.cdc.base.source.reader.external.FetchTask; +import org.apache.seatunnel.connectors.cdc.base.source.reader.external.IncrementalSourceStreamFetcher; +import org.apache.seatunnel.connectors.cdc.base.source.reader.external.IncrementalSourceStreamFetcherBridge; +import org.apache.seatunnel.connectors.cdc.base.source.split.IncrementalSplit; +import org.apache.seatunnel.connectors.cdc.base.source.split.SourceRecords; +import org.apache.seatunnel.connectors.cdc.base.source.split.SourceSplitBase; +import org.apache.seatunnel.connectors.cdc.base.source.split.state.IncrementalSplitState; +import org.apache.seatunnel.connectors.cdc.base.utils.SourceRecordUtils; +import org.apache.seatunnel.connectors.cdc.debezium.row.SeaTunnelRowDebeziumDeserializeSchema; +import org.apache.seatunnel.connectors.seatunnel.cdc.mysql.source.offset.BinlogOffset; +import org.apache.seatunnel.connectors.seatunnel.cdc.mysql.utils.MySqlUtils; + +import org.apache.kafka.connect.data.Schema; +import org.apache.kafka.connect.data.SchemaBuilder; +import org.apache.kafka.connect.data.Struct; +import org.apache.kafka.connect.source.SourceRecord; + +import io.debezium.connector.base.ChangeEventQueue; +import io.debezium.data.Envelope; +import io.debezium.pipeline.DataChangeEvent; +import io.debezium.relational.TableId; +import io.debezium.relational.Tables; +import io.debezium.util.LoggingContext; + +import java.time.Duration; +import java.time.Instant; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** Supplies in-memory binlog events to the package-private stream filter and record emitter. */ +public final class IncrementalSourceRecordEmitterFixture implements AutoCloseable { + + public enum Operation { + INSERT, + UPDATE + } + + public static final int BATCH_EVENTS = 256; + + private static final String DATABASE = "inventory"; + private static final String TABLE = "customers"; + private static final String TABLE_ID = DATABASE + "." + TABLE; + private static final String BINLOG_FILE = "mysql-bin.000001"; + private static final Map<String, String> SOURCE_PARTITION = Map.of("server", "mysql"); + private static final long FIRST_POSITION = 4096L; + private static final long FETCH_DELAY_MS = 20L; + private static final long TIMESTAMP_REFRESH_MS = 500L; + + private final int columns; + private final Operation operation; + private final boolean exactlyOnce; + private final int rowsPerEvent; + private final List<SourceRecord> records = new ArrayList<>(BATCH_EVENTS); + private final RowCollector output; + + private IncrementalSourceStreamFetcher fetcher; + private IncrementalSourceRecordEmitter<SeaTunnelRow> emitter; + private IncrementalSplitState splitState; + private Offset expectedLastOffset; + private long refreshTimestampsAt; + + public IncrementalSourceRecordEmitterFixture( + int columns, Operation operation, boolean exactlyOnce) { + if (columns < 2) { + throw new IllegalArgumentException("Expected an ID and at least one data column"); + } + this.columns = columns; + this.operation = Objects.requireNonNull(operation, "operation"); + this.exactlyOnce = exactlyOnce; + this.rowsPerEvent = operation == Operation.UPDATE ? 2 : 1; + this.output = new RowCollector(BATCH_EVENTS * rowsPerEvent); + } + + public void setUp() throws Exception { + TableSchema.Builder tableSchema = + TableSchema.builder() + .column(PhysicalColumn.of("id", BasicType.LONG_TYPE, 20L, false, null, "")); + SchemaBuilder rowSchema = + SchemaBuilder.struct() + .name(TABLE_ID + ".Value") + .optional() + .field("id", Schema.INT64_SCHEMA); + for (int column = 1; column < columns; column++) { + String name = "field_" + column; + boolean numeric = column % 2 == 0; + tableSchema.column( + PhysicalColumn.of( + name, + numeric ? BasicType.LONG_TYPE : BasicType.STRING_TYPE, + numeric ? 20L : 64L, + true, + null, + "")); + rowSchema.field( + name, numeric ? Schema.OPTIONAL_INT64_SCHEMA : Schema.OPTIONAL_STRING_SCHEMA); + } + CatalogTable table = + CatalogTable.of( + TableIdentifier.of("mysql", DATABASE, TABLE), + tableSchema.build(), + Map.of(), + List.of(), + ""); + List<CatalogTable> tables = List.of(table); + + SourceContext sourceContext = new SourceContext(); + emitter = + new IncrementalSourceRecordEmitter<>( + SeaTunnelRowDebeziumDeserializeSchema.builder() + .setTables(tables) + .setServerTimeZone(ZoneOffset.UTC) + .build(), + new InMemoryOffsetFactory(), + sourceContext); + + TableId tableId = new TableId(DATABASE, null, TABLE); + SourceRecord precedingRecord = prepareRecords(rowSchema.build()); + IncrementalSplit split = + new IncrementalSplit( + "benchmark-binlog", + List.of(tableId), + MySqlUtils.getBinlogPosition(records.get(0)), + BinlogOffset.NO_STOPPING_OFFSET, + List.of()); + splitState = new IncrementalSplitState(split); + expectedLastOffset = MySqlUtils.getBinlogPosition(records.get(BATCH_EVENTS - 1)); + fetcher = + new IncrementalSourceStreamFetcher(new InMemoryFetchContext(exactlyOnce), 0, null); + try { + fetcher.submitTask(new PreparedFetchTask(split)); + if (IncrementalSourceStreamFetcherBridge.shouldEmit(fetcher, precedingRecord) + || !IncrementalSourceStreamFetcherBridge.shouldEmit(fetcher, records.get(0))) { + throw new IllegalStateException( + "Unexpected filtering at the starting binlog offset"); + } + filterAndEmit(); + verifyBatch(); + if (sourceContext.getMetricsContext().counter("CDCRecordFetchDelay").getCount() + != FETCH_DELAY_MS) { + throw new IllegalStateException("Unexpected CDC fetch delay"); + } + } catch (Exception | Error failure) { + close(); + throw failure; + } + } + + private SourceRecord prepareRecords(Schema rowSchema) { + Schema keySchema = + SchemaBuilder.struct() + .name(TABLE_ID + ".Key") + .field("id", Schema.INT64_SCHEMA) + .build(); + Schema sourceSchema = + SchemaBuilder.struct() + .name("io.debezium.connector.mysql.Source") + .field("db", Schema.STRING_SCHEMA) + .field("table", Schema.STRING_SCHEMA) + .field("ts_ms", Schema.INT64_SCHEMA) + .field("file", Schema.STRING_SCHEMA) + .field("pos", Schema.INT64_SCHEMA) + .field("row", Schema.INT32_SCHEMA) + .field("gtid", Schema.OPTIONAL_STRING_SCHEMA) + .build(); + Envelope envelope = + Envelope.defineSchema() + .withName(TABLE_ID + ".Envelope") + .withRecord(rowSchema) + .withSource(sourceSchema) + .build(); + Instant now = Instant.now(); + SourceRecord precedingRecord = + createRecord(envelope, rowSchema, keySchema, sourceSchema, now, -1); + for (int index = 0; index < BATCH_EVENTS; index++) { + records.add(createRecord(envelope, rowSchema, keySchema, sourceSchema, now, index)); + } + return precedingRecord; + } + + private SourceRecord createRecord( + Envelope envelope, + Schema rowSchema, + Schema keySchema, + Schema sourceSchema, + Instant now, + long index) { + long position = FIRST_POSITION + index; + Instant sourceTime = now.minusMillis(FETCH_DELAY_MS); + Struct source = + new Struct(sourceSchema) + .put("db", DATABASE) + .put("table", TABLE) + .put("ts_ms", sourceTime.toEpochMilli()) + .put("file", BINLOG_FILE) + .put("pos", position) + .put("row", 0); + Map<String, Object> offset = new HashMap<>(); + offset.put(BinlogOffset.SERVER_ID_KEY, 1L); + offset.put(BinlogOffset.BINLOG_FILENAME_OFFSET_KEY, BINLOG_FILE); + offset.put(BinlogOffset.BINLOG_POSITION_OFFSET_KEY, position); + offset.put(BinlogOffset.TIMESTAMP_KEY, sourceTime.getEpochSecond()); + Struct after = createRow(rowSchema, index, "after"); + Struct value = + operation == Operation.UPDATE + ? envelope.update(createRow(rowSchema, index, "before"), after, source, now) + : envelope.create(after, source, now); + return new SourceRecord( + SOURCE_PARTITION, + offset, + "mysql." + TABLE_ID, + null, + keySchema, + new Struct(keySchema).put("id", index), + envelope.schema(), + value); + } + + private Struct createRow(Schema rowSchema, long id, String value) { + Struct row = new Struct(rowSchema).put("id", id); + for (int column = 1; column < columns; column++) { + row.put(rowSchema.fields().get(column), column % 2 == 0 ? id + column : value); + } + return row; + } + + /** Keeps lag metrics active while the prepared records are replayed across iterations. */ + private void refreshTimestampsIfNeeded() { + long now = System.currentTimeMillis(); + if (now < refreshTimestampsAt) { + return; + } + Long fetchedAt = now; + Long createdAt = now - FETCH_DELAY_MS; + for (SourceRecord record : records) { + Struct value = (Struct) record.value(); + value.put(Envelope.FieldName.TIMESTAMP, fetchedAt); + value.getStruct(Envelope.FieldName.SOURCE).put(Envelope.FieldName.TIMESTAMP, createdAt); + } + refreshTimestampsAt = now + TIMESTAMP_REFRESH_MS; + } + + public int filterAndEmit() throws Exception { + refreshTimestampsIfNeeded(); + List<SourceRecord> accepted = new ArrayList<>(BATCH_EVENTS); + for (SourceRecord record : records) { + if (IncrementalSourceStreamFetcherBridge.shouldEmit(fetcher, record)) { + accepted.add(record); + } + } + output.size = 0; + emitter.emitRecord(new SourceRecords(accepted), output, splitState); + return output.size; + } + + public void verifyBatch() { + if (output.size != BATCH_EVENTS * rowsPerEvent) { + throw new IllegalStateException("Unexpected number of CDC rows: " + output.size); + } + for (int index = 0; index < BATCH_EVENTS; index++) { + int firstRow = index * rowsPerEvent; + if (operation == Operation.UPDATE) { + verifyRow(index, output.rows[firstRow], RowKind.UPDATE_BEFORE, "before"); + verifyRow(index, output.rows[firstRow + 1], RowKind.UPDATE_AFTER, "after"); + } else { + verifyRow(index, output.rows[firstRow], RowKind.INSERT, "after"); + } + } + Offset checkpointOffset = splitState.toSourceSplit().getStartupOffset(); + if (!expectedLastOffset.equals(checkpointOffset)) { + throw new IllegalStateException("Unexpected checkpoint offset: " + checkpointOffset); + } + } + + private void verifyRow(int index, SeaTunnelRow row, RowKind kind, String value) { + int lastColumn = columns - 1; + Object expectedLastField = lastColumn % 2 == 0 ? (long) index + lastColumn : value; + if (row.getArity() != columns + || row.getRowKind() != kind + || !TABLE_ID.equals(row.getTableId()) + || (Long) row.getField(0) != index + || !value.equals(row.getField(1)) + || !expectedLastField.equals(row.getField(lastColumn)) + || (Long) row.getOptions().get(CommonOptions.BINLOG_POS.getName()) + != FIRST_POSITION + index) { + throw new IllegalStateException("Unexpected CDC row for event " + index); + } + } + + @Override + public void close() { + if (fetcher != null) { + fetcher.close(); + fetcher = null; + } + } + + /** Supplies the production filter with MySQL offsets and an in-memory split. */ + private static final class InMemoryFetchContext implements FetchTask.Context { + + private final boolean exactlyOnce; + private final ChangeEventQueue<DataChangeEvent> queue = + new ChangeEventQueue.Builder<DataChangeEvent>() + .maxQueueSize(BATCH_EVENTS) + .maxBatchSize(BATCH_EVENTS) + .pollInterval(Duration.ofMillis(1)) + .loggingContextSupplier( + () -> LoggingContext.forConnector("mysql", "benchmark", "filter")) + .build(); + + private InMemoryFetchContext(boolean exactlyOnce) { + this.exactlyOnce = exactlyOnce; + } + + @Override + public void configure(SourceSplitBase split) {} + + @Override + public ChangeEventQueue<DataChangeEvent> getQueue() { + return queue; + } + + @Override + public Offset getStreamOffset(SourceRecord record) { + return MySqlUtils.getBinlogPosition(record); + } + + @Override + public boolean isExactlyOnce() { + return exactlyOnce; + } + + @Override + public boolean isDataChangeRecord(SourceRecord record) { + return SourceRecordUtils.isDataChangeRecord(record); + } + + @Override + public TableId getTableId(SourceRecord record) { + return SourceRecordUtils.getTableId(record); + } + + @Override + public Tables.TableFilter getTableFilter() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isRecordBetween(SourceRecord record, Object[] start, Object[] end) { + throw new UnsupportedOperationException(); + } + + @Override + public void rewriteOutputBuffer(Map<Struct, SourceRecord> buffer, SourceRecord record) { + throw new UnsupportedOperationException(); + } + + @Override + public List<SourceRecord> formatMessageTimestamp(Collection<SourceRecord> records) { + throw new UnsupportedOperationException(); + } + + @Override + public void close() {} + } + + /** Provides the same binlog offset representation used by the MySQL emitter. */ + private static final class InMemoryOffsetFactory extends OffsetFactory { + + @Override + public Offset specific(Map<String, String> offset) { + return new BinlogOffset(offset); + } + + @Override + public Offset specific(String filename, Long position) { + return new BinlogOffset(filename, position); + } + + @Override + public Offset neverStop() { + return BinlogOffset.NO_STOPPING_OFFSET; + } + + @Override + public Offset timestamp(long timestamp) { + throw new UnsupportedOperationException(); + } + + @Override + public Offset earliest() { + throw new UnsupportedOperationException(); + } + + @Override + public Offset latest() { + throw new UnsupportedOperationException(); + } + } + + /** Lets the fetcher initialize its filter through the regular split submission lifecycle. */ + private static final class PreparedFetchTask implements FetchTask<SourceSplitBase> { + + private final IncrementalSplit split; + + private PreparedFetchTask(IncrementalSplit split) { + this.split = split; + } + + @Override + public void execute(Context context) {} + + @Override + public boolean isRunning() { + return false; + } + + @Override + public void shutdown() {} + + @Override + public SourceSplitBase getSplit() { + return split; + } + } + + private static final class RowCollector implements Collector<SeaTunnelRow> { + + private final SeaTunnelRow[] rows; + private int size; + + private RowCollector(int rowCount) { + this.rows = new SeaTunnelRow[rowCount]; + } + + @Override + public void collect(SeaTunnelRow row) { + rows[size++] = row; + } + + @Override + public Object getCheckpointLock() { + return this; + } + } + + private static final class SourceContext implements SourceReader.Context { + + private final MetricsContext metrics = new AbstractMetricsContext() {}; + + @Override + public int getIndexOfSubtask() { + return 0; + } + + @Override + public Boundedness getBoundedness() { + return Boundedness.UNBOUNDED; + } + + @Override + public void signalNoMoreElement() {} + + @Override + public void sendSplitRequest() {} + + @Override + public void sendSourceEventToEnumerator(SourceEvent event) { + throw new IllegalStateException("Expected steady incremental phase"); + } + + @Override + public MetricsContext getMetricsContext() { + return metrics; + } + + @Override + public EventListener getEventListener() { + return event -> {}; + } + } +} diff --git a/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/connectors/cdc/base/source/reader/external/IncrementalSourceStreamFetcherBridge.java b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/connectors/cdc/base/source/reader/external/IncrementalSourceStreamFetcherBridge.java new file mode 100644 index 0000000000..433299bf38 --- /dev/null +++ b/seatunnel-benchmarks/src/main/java/org/apache/seatunnel/connectors/cdc/base/source/reader/external/IncrementalSourceStreamFetcherBridge.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.connectors.cdc.base.source.reader.external; + +import org.apache.kafka.connect.source.SourceRecord; + +/** Gives the CDC benchmark direct access to the stream fetcher's package-private filter. */ +public final class IncrementalSourceStreamFetcherBridge { + + private IncrementalSourceStreamFetcherBridge() {} + + public static boolean shouldEmit(IncrementalSourceStreamFetcher fetcher, SourceRecord record) { + return fetcher.shouldEmit(record); + } +}
