All Classes and Interfaces
Class
Description
Abstract base class for
TableMappingStorage implementations that provides caching functionality.An abstract implementation of
ChangeRecordEmitter.Base class for building queries for reading incremental snapshot chunks from a table.
An incremental snapshot change event source that emits events from a DB log interleaved with snapshot events.
A class describing current state of incremental snapshot
An abstract implementation of
Partition which provides default facilities for logging.An abstract regex implementation of
TopicNamingStrategy.An abstract implementation of
SnapshotChangeEventSource that all implementations should extend
to inherit common functionality.Mutable context which is populated in the course of snapshotting
Common information provided by all connectors in either source field or offsets
Common information provided by all connectors in either source field or offsets.
An abstract implementation of
TopicNamingStrategy.An abstract unicode converter topic naming strategy implementation of
TopicNamingStrategy.Exposes advanced metrics used for monitoring DB activity.
Contains filtering information for snapshot
An array of
Values.Reads
Array instances from a variety of input forms.Writes
Array instances to a variety of output forms.An immutable attribute associated with a relational table.
An editor for
Attribute instances.Implementation of the
AttributeEditor contract.Relational model implementation of
Attribute.Base class for Debezium's CDC
SourceConnector implementations.Base class for Debezium's CDC
SourceTask implementations.Package-level implementation of
Array.Package-level implementation of
Document.Package-level implementation of
Array.Entry in an Array.Package-level implementation of a
Document.Field inside a Document.Represents a bean registry used to lookup components by name and type.
Allows the injection of the
BeanRegistry during service configuration.A specialization of
Value that represents a binary value.A set of bits of arbitrary length.
A variant of
Consumer that can be blocked and interrupted.A variant of
Function that can be blocked and interrupted.A variant of
Runnable that can be blocked and interrupted.A
BlockingConsumer that retains a maximum number of values in a buffer before sending them to
a delegate consumer.Functional interface for supplying collections of captured table identifiers.
Utility methods for building cascading-OR boundary conditions used in chunked SQL queries.
Contains contextual information and objects scoped to the lifecycle of Debezium's
SourceTask implementations.A queue which serves as handover point between producer threads (e.g.
Coordinates one or more
ChangeEventSources and executes them in order.A factory for creating
ChangeEventSources specific to one database.Common API for all change event source metrics regardless of the connector phase.
A factory for creating
SnapshotChangeEventSourceMetrics and StreamingChangeEventSourceMetrics.Metrics that are common for both snapshot and streaming change event sources
Represents a change applied to a source database and emits one or more corresponding change records.
Callback passed to
ChangeRecordEmitters, allowing them to produce one
or more change records.A logical representation of a change table containing changes for a given source table.
A wrapper around a JDBC
ResultSet for a change table for processing rows.Calculates chunk boundaries for chunked table snapshots.
Builds queries for reading incremental snapshot chunks from a table.
An abstract data model that represents a table or collection of a datastore in its hierarchy.
An immutable definition of a column.
An editor for
Column instances.Modes for column name filters, either including a catalog (database) or schema name.
Unique identifier for a column in a database table.
A factory for a function used to map values of a column.
A set of
ColumnMapper objects for columns.A builder of
Selectors.Configuration options common to all Debezium connectors.
The set of predefined BinaryHandlingMode options or aliases
The set of predefined modes for dealing with failures during event processing.
The set of predefined FieldNameAdjustmentMode options
The set of predefined GuardrailCollectionsLimitAction options
The set of predefined SchemaNameAdjustmentMode options
The set of predefined versions e.g. for source struct maker version
The set of predefined incremental snapshot watermarking strategies
Carries common event metrics.
Exposes common event metrics.
Composite Heartbeat solutions (Queue, Database...)
Default implementation of
TableMappingStorage using ConcurrentHashMap.Interface for components (connectors, transforms, converters) to expose their configuration fields.
Allows the service to request the connector configuration.
A special channel that is strictly connected to Kafka Connect API
An on-demand provider of a JDBC connection.
Carries connection metrics.
Exposes connection metrics.
A marker interface for an event with the connector that isn't dispatched to the change event stream but
instead is potentially of interest to other parts of the framework such as metrics.
Marks a class to be connector specific SPI implementation.
Ther serializer responsible for converting of
TableChanges into an array of Structs.Temporal conversion constants.
A read-only result of a counter.
Conflict-free Replicated Data Types (CRDT)s.
Contract for a factory that creates instance of
CustomConverterThe registry of all converters that were provided by the connector configuration.
Class binding together the schema of the conversion result and the converter code.
Implementation of the heartbeat feature that allows for a DB query to be executed with every heartbeat.
The schema of a database.
A class invoked by
EventDispatcher whenever an event is available for processing.A class describing CollectionId for incremental snapshot
Provides factory methods for obtaining
DataCollectionFilters.DataCollectionFilter instances as per the current connector configuration.An immutable representation of a data type
A utility for converting various Java temporal object representations into the signed
INT32
number of days since January 1, 1970, at 00:00:00UTC, and for defining a Kafka Connect Schema for date values
with no time or timezone information.A
DdlParserListener that accumulates changes, allowing them to be consumed in the same order by database.A parser interface for DDL statements.
An interface that can listen to various actions of a
DdlParser.An event describing the altering of a database.
An event describing the creation of a database.
An event describing the dropping of a database.
The base class for all table-related events.
An event describing the switching of a database.
The base class for all concrete events.
The type of concrete
DdlParserListener.Events.An event describing the setting of a variable.
An event describing the altering of a table.
An event describing the creation (or replacement) of a table.
An event describing the dropping of a table.
The base class for all table-related events.
An event describing the creation of an index on a table.
An event describing the dropping of an index on a table.
The abstract base class for all index-related events.
An event describing the truncating of a table.
A service implementation that produces Debezium-specific headers for CDC (Change Data Capture) events.
factory interface for creating the appropriate
Heartbeat implementation based on the connector
and contextA factory class for Debezium provided serializers/deserializers.
The default
BeanRegistry that supports looking up beans.Builds queries for reading incremental snapshot chunks from a table using ANSI standard SQL queries.
Default implementation of
QueueProvider using an ArrayDeque.Implement a regex expression strategy to determine data event topic names using
DataCollectionId.databaseParts().Default implementation of the
ServiceRegistry.The default implementation of metrics related to the snapshot phase of a connector.
The default implementation of metrics related to the streaming phase of a connector.
Determine data event topic names using
DataCollectionId.databaseParts().Implement a unicode converter strategy to determine data event topic names using
DataCollectionId.databaseParts().This interface is used to convert the string default value to a Java type
recognized by value converters for a subset of types.
Converts the raw JDBC default value expression for a column into an object.
A
Count that also tracks changes to the value within the last interval.A document contains multiple
Document.Fields, each with a name and possibly-null Value.Reads
Document instances from a variety of input forms.Writes
Document instances to a variety of output forms.A semantic type for a vector type with 8-byte elements.
A semantic type for an enumeration, where the string values are one of the enumeration's values.
A semantic type for a set of enumerated values, where the string values contain comma-separated values from an enumeration.
An immutable descriptor for the structure of Debezium message envelopes.
A builder of an envelope schema.
The constants for the names of the fields in the message envelope.
The constants for the values for the
operation field in the message envelope.Central dispatcher for data change and schema change events.
Reaction to an incoming change event for which schema is not found
Change record receiver used during snapshotting.
An interface implemented by each connector that enables metrics metadata to be extracted
from an event.
The action to trigger an ad-hoc snapshot.
Implementations return names for fields.
A field namer that caches names it has obtained from a delegate
Implementations determine the field name corresponding to a given column.
A field namer that replaces any characters invalid in a field with
_.A field name underscore replacement implementation of
ReplacementFunctionA field name unicode replacement inheritance of
UnicodeReplacementFunctionThe class responsible for processing of signals delivered to Debezium via a file.
Functional interface to provide the list of matching tables or collections with an anonymous function / lambda with lazy evaluation.
A semantic type for a vector type with 4-byte elemnents.
A read-only result of the state of a grow-only
GCounter.A simple grow-only counter that maintains a single changing value by tracking the positive changes to the value.
A semantic type for a Geography class.
A semantic type for an OGC Simple Features for SQL Geometry.
A simple geometry bytes helper class to handle operating on WKB (Well-Known Binary) and EWKB
(Extended Well-Known Binary) formats used to represent spatial geometry.
Utility visitor that checks if the
GEOMETRYCOLLECTION is empty.Constants used by the geometry spatial classes.
Swaps X/Y coordinates in geometry data.
Visitor implementation that writes the contents of an existing geometry byte array swapping x and y.
Converts a geometry's byte order (endianness).
Visitor implementation that writes to the output buffer the contents of an existing geometry
representation, but using the given target byte order.
Utility class for converting a
GeometryBytes between WKB and EWKB formats.A traversal algorithm that uses the visitor pattern,
GeometryVisitor, to perform
operations over an input byte buffer that represents a WKB or EWKB byte array.Helper class that changes the
ByteOrder of a ByteBuffer if the new order
differs, restoring the order after the scope closes automatically.Simple geometry utility class.
A visitor that is used by the
GeometryTraverser to traverse a WKB/EKB byte buffer.Validator for guardrail limits across different connector types.
A class that is able to emit heartbeat messages.
Returns the offset to be used when emitting a heartbeat event.
A class that is able to generate periodic heartbeat messages based on a pre-configured interval.
Defines a contract for providing a connection to the
DatabaseHeartbeatImpl.Default factory for creating the appropriate
Heartbeat implementation based on the connector
type and its configured properties in the Debezium context.Default implementation of Heartbeat
A database schema that is historized, i.e. it undergoes schema changes and can be recovered from a persistent schema
history.
Configuration options shared across the relational CDC connectors which use a persistent database schema history.
A
DatabaseSchema or a relational database which has a schema history, that can be recovered to the current
state when restarting a connector.Compares HistoryRecord instances to determine which came first.
A Contract t
Annotation allowing a service to request injection of other services.
Implementation of
SignalChannelReader that also implements SignalChannelWriter
used for sending signal from the same JVM processA utility representing a duration into a string value formatted using ISO string format.
A utility for converting various Java temporal object representations into a UTC ISO 8601 string representation,
specifically focusing on dates (without time or timezone information).
A utility for converting various Java time representations into a UTC ISO 8601 string representation
focusing on time (including fractional parts and offset from UTC), and for defining a Kafka Connect
Schema for time values in this format.A utility for converting various Java timestamp representations into a UTC ISO 8601 string representation
(including date, time, fractional parts, and offset from UTC), and for defining a Kafka Connect
Schema for timestamp values in this format.A
DocumentReader and ArrayReader that uses the Jackson library to read JSON.A
DocumentWriter and ArrayWriter that uses the Jackson library to write JSON.A specialized configuration for the Debezium driver.
The JDBC-specific builder used to construct and/or alter JDBC configuration instances.
A utility that simplifies using a JDBC connection and executing transactions composed of multiple statements.
Establishes JDBC connections.
Defines multiple JDBC operations.
Extracts a data of resultset..
A function to create a statement from a connection.
RuntimeException which is raised for various SQLException instances and which retains the error
code from the original exception.A provider of
ValueConverters and SchemaBuilders for various column types.A semantic type for a JSON string.
A
Serde that (de-)serializes JSON.A configuration for
JsonSerde serialize/deserializer.Ther serializer responsible for converting of
TableChanges into a JSON format.The class responsible for processing of signals delivered to Debezium via a dedicated Kafka topic.
An immutable definition of a table's key.
Custom Key mapper used to override or defining a custom
KeyDefault Key mapper using PK as key.
Provides the column(s) that should be used within the message key for a given table.
Carries over one single measurement of
LagBehindSourceMeasurement.Measurement of the lag between the time when a record was inserted into the source database and when it was processed by Debezium.
Legacy source info that does not enforce presence of the version and connector fields
A utility that provides a consistent set of properties for the Mapped Diagnostic Context (MDC) properties used by Debezium
components.
A snapshot of an MDC context that can be
LoggingContext.PreviousContext.restore().Functionality for dealing with logging.
Implementation of
MeasurementStatistics which is backed by DDSketch library.A custom implementation of
LRUCache that allows exposure
to the underlying delegate's key or values collections.An on-demand provider of a JDBC connection.
A
ColumnMapper implementation that ensures that string values are masked.V1 default and previous version.
General interface, which represents one measurement.
Single point for submitting all kind of measurements.
General interface, which represents one measurement event, i.e. carries over a
Measurement instance.Statistics of the
SingleValueMeasurements over some period of time.Factory providing an instance of
MeasurementStatistics implementation.A
SchemaHistory implementation that stores the schema history in memory.Base for metrics implementations.
Interface containing the attributes names for the metrics exposed via REST API
Base class for JSON payloads describing connector metrics
A utility representing a duration into a corresponding
INT64
number of microsecond, and for defining a Kafka Connect Schema for duration values.A utility for converting various Java time representations into the
INT64 number of
microseconds since midnight, and for defining a Kafka Connect Schema for time values with no date or timezone
information.A utility for converting various Java time representations into the signed
INT64 number of
microseconds past epoch, and for defining a Kafka Connect Schema for timestamp values with no timezone
information.A utility representing a duration into a corresponding
INT64
number of nanosecond, and for defining a Kafka Connect Schema for duration values.A utility for converting various Java time representations into the
INT64 number of
nanoseconds since midnight, and for defining a Kafka Connect Schema for time values with no date or timezone
information.A utility for converting various Java time representations into the signed
INT64 number of
nanoseconds past epoch, and for defining a Kafka Connect Schema for timestamp values with no timezone
information.Indicates that a bean lookup failed.
This interface is used to provide custom write channels for the Debezium notification feature:
Implementations must:
define the name of the channel in
NotificationChannel.name(),
initialize specific configuration/variables/connections in the NotificationChannel.init(CommonConnectorConfig connectorConfig) method,
implement send of the notification on the channel in the NotificationChannel.send(Notification notification) method.This service can be used to send notification to available and enabled channels
A specialization of
Value that represents a null value.Keeps track of the current offset within the source DB's change stream.
Implementations load a connector-specific offset context based on the offset values stored in Kafka.
Provides access to the partition offsets stored by connectors.
Keeps track the source partitions to be processed by the connector task and their respective offsets.
Indicates that the annotated element intentionally uses default visibility.
Describes the source partition to be processed by the connector in connector-specific terms
and provides its representation as a Kafka Connect source partition.
Implementations provide a set of connector-specific partitions based on the connector task configuration.
A representation of multiple name segments that together form a path within
Document.A package-level utility that implements useful operations to create paths.
Chunk query builder that injects a hidden physical row identifier (e.g.
Base for metrics implementations.
A read-only result of the state of a
PNCounter.A simple counter that maintains a single changing value by separately tracking the positive and negative changes.
A semantic type for a geometric Point, defined as a set of (x,y) coordinates.
A contract that defines a post-processing step that can be applied to any outgoing event
before it is added to the change event queue.
Registry of all post processors that are provided by the connector configuration.
An implementation of the
ServiceProvider contract for the PostProcessorRegistry.A column mapper that adds the
PropagateSourceMetadataToSchemaParameter.COLUMN_NAME_PARAMETER_KEY, PropagateSourceMetadataToSchemaParameter.TYPE_NAME_PARAMETER_KEY, PropagateSourceMetadataToSchemaParameter.TYPE_LENGTH_PARAMETER_KEY,
PropagateSourceMetadataToSchemaParameter.TYPE_SCALE_PARAMETER_KEY and PropagateSourceMetadataToSchemaParameter.COLUMN_COMMENT_PARAMETER_KEY schema parameter keys.Exposes queue metrics.
Provides queue operations for change events.
Service that provides the resolved
QueueProvider instance for buffering change events.An implementation of the
ServiceProvider contract for the QueueProviderService.Annotation that can be used to specify that the target field, method, constructor, package or type is read-only.
Base class for Debezium's relational CDC
BaseSourceConnector implementations.Base class for
ChangeRecordEmitter implementations based on a relational database.Configuration options shared across the relational CDC connectors.
The set of predefined DecimalHandlingMode options or aliases.
The set of predefined DecimalHandlingMode options or aliases.
A
DatabaseSchema of a relational database such as Postgres.A map of schemas by table id.
Base class for
SnapshotChangeEventSource for relational databases with or without a schema history.Functional interface for operations that may throw SQLException.
Functional interface for snapshot work that uses pooled resources.
Holds the prepared table information for snapshot processing.
Mutable context which is populated in the course of snapshotting.
Determines the appropriate SnapshotRecord marker based on record position.
Manages threaded execution of snapshot work using a thread pool.
An implementation of the Debezium
PostProcessor contract that allows for the re-selection of
columns that are populated with the unavailable value placeholder or that the user wishes to have
re-queried with the latest state if the column's value happens to be null.This interface allows the code to optionally pass a value between two parts of the application.
Builds queries for reading incremental snapshot chunks from a table using row value constructors.
Represents a structural change to a database schema.
Type describing the content of the event.
Emits one or more change records - specific to a given
DataCollectionSchema.A factory for creating
SchemaBuilder structs.A history of the database schema described by a
Tables.Listener receiving lifecycle and data events from
SchemaHistory.Implementation of
DatabaseSchema metrics.Metrics describing
SchemaHistory use.Exposes schema metrics.
A adjuster for the names of change data message schemas and for the names of the fiields in the schemas.
Function used to report that an original value was replaced with an Avro-compatible string.
Implement a regex expression strategy to determine data event topic names using
DataCollectionId.schemaParts().Determine data event topic names using
DataCollectionId.schemaParts().Implement a unicode converter strategy to determine data event topic names using
DataCollectionId.schemaParts().Utilities for obtaining JSON string representations of
Schema, Struct, and Field objects.Define predicates determines whether tables or columns should be used.
A builder of a database predicate.
Implementations convert given
TableIds to strings, so regular expressions can be applied to them for the
purpose of table filtering.A builder of a table predicate.
Contract that defines a service that can be registered with a
ServiceRegistry.Exception that identifies a service dependency injection failure.
A contract that defines how a service is provided to the
ServiceRegistry.Describes a registration for a specific service.
Registry of Debezium Services.
Allows the injection of the
ServiceRegistry during service configuration.This interface is used to provide custom signal actions:
Implementations must:
provide a map of signal action in the
SignalActionProvider.createActions(EventDispatcher, ChangeEventSourceCoordinator, CommonConnectorConfig) method.A class describing current state of incremental snapshot
This interface is used to provide custom read channels for the Debezium signaling feature:
Implementations must:
define the name of the reader in
SignalChannelReader.name(),
initialize specific configuration/variables/connections in the SignalChannelReader.init(CommonConnectorConfig connectorConfig) method,
implement reset logic for specific channel in the SignalChannelReader.reset(Object) method if you need to reset already processed signals,
provide a list of signal record in the SignalChannelReader.read() method.Interface for writing signals to a channel.
Signal metadata for the incremental snapshotting
This class permits to process signals coming from the different channels.
The class represent the signal sent on a channel:
id STRING - the unique identifier of the signal sent, usually UUID, can be used for deduplication
type STRING - the unique logical name of the code executing the signal
data STRING - the data in JSON format that are passed to the signal code
Denotes that the annotated element of a class that's meant for multi-threaded
usage is accessed only by single thread and thus doesn't need to be guarded
via synchronization or similar.
Measurement which tracks only a single variable.
SingleValueMeasurement whole measured variable type is Long typeSingleValueMeasurement of Long type, which provides support of more advanced statistics like quantiles.A measurement which measures only a single variable.
Calculates or estimates the size of the object
A change event source that emits events for taking a consistent snapshot of the captured tables, which may include
schema and data information.
Metrics related to the snapshot phase of a connector.
Emits change data based on a single row read via JDBC.
Represents a single chunk of a table to be snapshot in parallel with precomputed values.
Builds SQL queries for snapshot chunks with boundary conditions.
Contains information required for the snapshot
SnapshotLock is used to determine the table lock mode used during schema snapshotAn implementation of the
ServiceProvider contract for the SnapshotLock.Carries snapshot metrics.
Exposes snapshot metrics.
Thread-safe coordination for global snapshot progress across all tables.
Invoked whenever an important event or change of state happens during the snapshot phase.
SnapshotQuery is used to determine the query used during a data snapshotAn implementation of the
ServiceProvider contract for the SnapshotQuery.Describes whether the change record comes from snapshot and if it is the last one
Registry of all available snapshotters.
An implementation of the
ServiceProvider contract for the SnapshotterService.A configuration describing the task to be performed during snapshotting.
Describes the kind of snapshot in progress
Converts the connector SourceInfo into publicly visible source field of the message.
The class responsible for processing of signals delivered to Debezium via a dedicated signaling table.
A semantic type to represent a double-precision sparse vector.
Extension of plain a
BigDecimal type that adds support for new features
like special values handling - NaN, infinity;Special values for floating-point and numeric types
Contract that defines standard bean names.
A contract that defines that the service wishes to be started during service start-up phase.
The action to stop an ad-hoc snapshot.
A change event source that emits events from a DB log, such as MySQL's binlog or similar.
Metrics related to the streaming phase of a connector.
Metrics specific to streaming change event sources
Carries streaming metrics.
Exposes streaming metrics.
Invoked whenever an important event or change of state happens during the streaming phase.
Exposes statistics for streaming metrics.
A function that converts one change event row (from a snapshot select, or
from before/after state of a log event) into the corresponding Kafka Connect
key or value
Struct.Encapsulates a set of a database's system variables.
Interface that is used for enums defining the customized scope values for specific DBMSs.
An immutable definition of a table.
An abstract representation of one or more changes to the structure to the tables of a relational database.
The interface that defines conversion of
TableChanges into a serialized format for
persistent storage or delivering as a message.Thread-safe progress tracking for chunked table snapshots across all table chunks.
Unique identifier for a database table.
Parses identifiers into the corresponding parts of a
TableId.Collection of predicate methods used for parsing
TableId.Interface for storing mappings between
TableId and associated data.Enum representing the type of storage.
Structural definitions for a set of tables in a JDBC database.
A
Tables.TableFilter that caches the results of another filter.A filter for columns.
A filter for tables.
A set of table ids.
A map of tables by id.
Defines the Kafka Connect
Schema functionality associated with a given table definition, and which can
be used to send rows of data that match the table definition to Kafka Connect.Builder that constructs
TableSchema instances for Table definitions.The set of predefined TemporalPrecisionMode options.
Misc. functionality dealing with temporal data types.
A utility for converting various Java time representations into the
INT32 number of
milliseconds since midnight, and for defining a Kafka Connect Schema for time values with no date or timezone
information.A utility for converting various Java time representations into the signed
INT64 number of
milliseconds past epoch, and for defining a Kafka Connect Schema for timestamp values with no timezone
information.Deprecated.
Implementations determine the topic name corresponding to a given data collection.
A topic namer that caches names it has obtained from a delegate.
A topic namer that replaces any characters invalid in a topic name with
_.The context holds internal state necessary for book-keeping of events in active transaction.
An interface for containing all metadata needed to for
TransactionContext to
process the transaction.The class has externalized its state in
TransactionContext context class so it can be stored in and recovered from offsets.Describes the transition of transaction from start to end.
Interface to define how to make transaction structs, both when adding them to data change events
and when creating separate transaction metadata events (e.g., for begin/end)
A
ColumnMapper implementation that ensures that column values longer than a specified length will be truncated.An unicode replacement implementation of
ReplacementFunctionIndicates that a specific service was requested but was not found in the registry.
A semantic type for a Uuid string.
Taken from OpenLineage code base.
Invoked to convert incoming SQL column values into Kafka Connect values.
A function that converts from a column data value into another value.
A provider of
ValueConverter functions and the SchemaBuilder used to describe them.Provides the access to the original encapsulated value obtained for example from JDBC.
An arbitrary precision decimal value with variable scale.
A semantic type for an XML string.
A utility for defining a Kafka Connect
Schema that represents year values.A utility for converting various Java time representations into the
STRING representation of
the time in a particular time zone, and for defining a Kafka Connect Schema for zoned time values.A utility for converting various Java time representations into the
STRING representation of
the time and date in a particular time zone, and for defining a Kafka Connect Schema for zoned timestamp values.
TopicNamingStrategyinstead.