| /* |
| * 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.camel.component.debezium.springboot; |
| |
| import java.util.Map; |
| import javax.annotation.Generated; |
| import org.apache.camel.component.debezium.configuration.PostgresConnectorEmbeddedDebeziumConfiguration; |
| import org.apache.camel.spring.boot.ComponentConfigurationPropertiesCommon; |
| import org.springframework.boot.context.properties.ConfigurationProperties; |
| |
| /** |
| * Capture changes from a PostgresSQL database. |
| * |
| * Generated by camel-package-maven-plugin - do not edit this file! |
| */ |
| @Generated("org.apache.camel.springboot.maven.SpringBootAutoConfigurationMojo") |
| @ConfigurationProperties(prefix = "camel.component.debezium-postgres") |
| public class DebeziumPostgresComponentConfiguration |
| extends |
| ComponentConfigurationPropertiesCommon { |
| |
| /** |
| * Whether to enable auto configuration of the debezium-postgres component. |
| * This is enabled by default. |
| */ |
| private Boolean enabled; |
| /** |
| * Additional properties for debezium components in case they can't be set |
| * directly on the camel configurations (e.g: setting Kafka Connect |
| * properties needed by Debezium engine, for example setting |
| * KafkaOffsetBackingStore), the properties have to be prefixed with |
| * additionalProperties.. E.g: |
| * additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=http://localhost:8811/avro |
| */ |
| private Map<String, Object> additionalProperties; |
| /** |
| * Allows for bridging the consumer to the Camel routing Error Handler, |
| * which mean any exceptions occurred while the consumer is trying to pickup |
| * incoming messages, or the likes, will now be processed as a message and |
| * handled by the routing Error Handler. By default the consumer will use |
| * the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that |
| * will be logged at WARN or ERROR level and ignored. |
| */ |
| private Boolean bridgeErrorHandler = false; |
| /** |
| * Allow pre-configured Configurations to be set. The option is a |
| * org.apache.camel.component.debezium.configuration.PostgresConnectorEmbeddedDebeziumConfiguration type. |
| */ |
| private PostgresConnectorEmbeddedDebeziumConfiguration configuration; |
| /** |
| * The Converter class that should be used to serialize and deserialize key |
| * data for offsets. The default is JSON converter. |
| */ |
| private String internalKeyConverter = "org.apache.kafka.connect.json.JsonConverter"; |
| /** |
| * The Converter class that should be used to serialize and deserialize |
| * value data for offsets. The default is JSON converter. |
| */ |
| private String internalValueConverter = "org.apache.kafka.connect.json.JsonConverter"; |
| /** |
| * The name of the Java class of the commit policy. It defines when offsets |
| * commit has to be triggered based on the number of events processed and |
| * the time elapsed since the last commit. This class must implement the |
| * interface 'OffsetCommitPolicy'. The default is a periodic commit policy |
| * based upon time intervals. |
| */ |
| private String offsetCommitPolicy = "io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy"; |
| /** |
| * Maximum number of milliseconds to wait for records to flush and partition |
| * offset data to be committed to offset storage before cancelling the |
| * process and restoring the offset data to be committed in a future |
| * attempt. The default is 5 seconds. The option is a long type. |
| */ |
| private Long offsetCommitTimeoutMs = 5000L; |
| /** |
| * Interval at which to try committing offsets. The default is 1 minute. The |
| * option is a long type. |
| */ |
| private Long offsetFlushIntervalMs = 60000L; |
| /** |
| * The name of the Java class that is responsible for persistence of |
| * connector offsets. |
| */ |
| private String offsetStorage = "org.apache.kafka.connect.storage.FileOffsetBackingStore"; |
| /** |
| * Path to file where offsets are to be stored. Required when offset.storage |
| * is set to the FileOffsetBackingStore. |
| */ |
| private String offsetStorageFileName; |
| /** |
| * The number of partitions used when creating the offset storage topic. |
| * Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |
| */ |
| private Integer offsetStoragePartitions; |
| /** |
| * Replication factor used when creating the offset storage topic. Required |
| * when offset.storage is set to the KafkaOffsetBackingStore |
| */ |
| private Integer offsetStorageReplicationFactor; |
| /** |
| * The name of the Kafka topic where offsets are to be stored. Required when |
| * offset.storage is set to the KafkaOffsetBackingStore. |
| */ |
| private String offsetStorageTopic; |
| /** |
| * Whether autowiring is enabled. This is used for automatic autowiring |
| * options (the option must be marked as autowired) by looking up in the |
| * registry to find if there is a single instance of matching type, which |
| * then gets configured on the component. This can be used for automatic |
| * configuring JDBC data sources, JMS connection factories, AWS Clients, |
| * etc. |
| */ |
| private Boolean autowiredEnabled = true; |
| /** |
| * Specify how binary (blob, binary, etc.) columns should be represented in |
| * change events, including:'bytes' represents binary data as byte array |
| * (default)'base64' represents binary data as base64-encoded string'hex' |
| * represents binary data as hex-encoded (base16) string |
| */ |
| private String binaryHandlingMode = "bytes"; |
| /** |
| * Regular expressions matching columns to exclude from change events |
| * (deprecated, use column.exclude.list instead) |
| */ |
| private String columnBlacklist; |
| /** |
| * Regular expressions matching columns to exclude from change events |
| */ |
| private String columnExcludeList; |
| /** |
| * Regular expressions matching columns to include in change events |
| */ |
| private String columnIncludeList; |
| /** |
| * A comma-separated list of regular expressions matching fully-qualified |
| * names of columns that adds the columns original type and original length |
| * as parameters to the corresponding field schemas in the emitted change |
| * records. |
| */ |
| private String columnPropagateSourceType; |
| /** |
| * Regular expressions matching columns to include in change events |
| * (deprecated, use column.include.list instead) |
| */ |
| private String columnWhitelist; |
| /** |
| * Optional list of custom converters that would be used instead of default |
| * ones. The converters are defined using '.type' config option and |
| * configured using options '.' |
| */ |
| private String converters; |
| /** |
| * The name of the database from which the connector should capture changes |
| */ |
| private String databaseDbname; |
| /** |
| * The path to the file that will be used to record the database history |
| */ |
| private String databaseHistoryFileFilename; |
| /** |
| * Resolvable hostname or IP address of the database server. |
| */ |
| private String databaseHostname; |
| /** |
| * A semicolon separated list of SQL statements to be executed when a JDBC |
| * connection to the database is established. Note that the connector may |
| * establish JDBC connections at its own discretion, so this should |
| * typically be used for configurationof session parameters only, but not |
| * for executing DML statements. Use doubled semicolon (';;') to use a |
| * semicolon as a character and not as a delimiter. |
| */ |
| private String databaseInitialStatements; |
| /** |
| * Password of the database user to be used when connecting to the database. |
| */ |
| private String databasePassword; |
| /** |
| * Port of the database server. |
| */ |
| private Integer databasePort = 5432; |
| /** |
| * Unique name that identifies the database server and all recorded offsets, |
| * and that is used as a prefix for all schemas and topics. Each distinct |
| * installation should have a separate namespace and be monitored by at most |
| * one Debezium connector. |
| */ |
| private String databaseServerName; |
| /** |
| * File containing the SSL Certificate for the client. See the Postgres SSL |
| * docs for further information |
| */ |
| private String databaseSslcert; |
| /** |
| * A name of class to that creates SSL Sockets. Use |
| * org.postgresql.ssl.NonValidatingFactory to disable SSL validation in |
| * development environments |
| */ |
| private String databaseSslfactory; |
| /** |
| * File containing the SSL private key for the client. See the Postgres SSL |
| * docs for further information |
| */ |
| private String databaseSslkey; |
| /** |
| * Whether to use an encrypted connection to Postgres. Options |
| * include'disable' (the default) to use an unencrypted connection; |
| * 'require' to use a secure (encrypted) connection, and fail if one cannot |
| * be established; 'verify-ca' like 'required' but additionally verify the |
| * server TLS certificate against the configured Certificate Authority (CA) |
| * certificates, or fail if no valid matching CA certificates are found; |
| * or'verify-full' like 'verify-ca' but additionally verify that the server |
| * certificate matches the host to which the connection is attempted. |
| */ |
| private String databaseSslmode = "disable"; |
| /** |
| * Password to access the client private key from the file specified by |
| * 'database.sslkey'. See the Postgres SSL docs for further information |
| */ |
| private String databaseSslpassword; |
| /** |
| * File containing the root certificate(s) against which the server is |
| * validated. See the Postgres JDBC SSL docs for further information |
| */ |
| private String databaseSslrootcert; |
| /** |
| * Enable or disable TCP keep-alive probe to avoid dropping TCP connection |
| */ |
| private Boolean databaseTcpkeepalive = true; |
| /** |
| * Name of the database user to be used when connecting to the database. |
| */ |
| private String databaseUser; |
| /** |
| * A comma-separated list of regular expressions matching the |
| * database-specific data type names that adds the data type's original type |
| * and original length as parameters to the corresponding field schemas in |
| * the emitted change records. |
| */ |
| private String datatypePropagateSourceType; |
| /** |
| * Specify how DECIMAL and NUMERIC columns should be represented in change |
| * events, including:'precise' (the default) uses java.math.BigDecimal to |
| * represent values, which are encoded in the change events using a binary |
| * representation and Kafka Connect's |
| * 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to |
| * represent values; 'double' represents values using Java's 'double', which |
| * may not offer the precision but will be far easier to use in consumers. |
| */ |
| private String decimalHandlingMode = "precise"; |
| /** |
| * Specify how failures during processing of events (i.e. when encountering |
| * a corrupted event) should be handled, including:'fail' (the default) an |
| * exception indicating the problematic event and its position is raised, |
| * causing the connector to be stopped; 'warn' the problematic event and its |
| * position will be logged and the event will be skipped;'ignore' the |
| * problematic event will be skipped. |
| */ |
| private String eventProcessingFailureHandlingMode = "fail"; |
| /** |
| * The query executed with every heartbeat. |
| */ |
| private String heartbeatActionQuery; |
| /** |
| * Length of an interval in milli-seconds in in which the connector |
| * periodically sends heartbeat messages to a heartbeat topic. Use 0 to |
| * disable heartbeat messages. Disabled by default. The option is a int |
| * type. |
| */ |
| private Integer heartbeatIntervalMs = 0; |
| /** |
| * The prefix that is used to name heartbeat topics.Defaults to |
| * __debezium-heartbeat. |
| */ |
| private String heartbeatTopicsPrefix = "__debezium-heartbeat"; |
| /** |
| * Specify how HSTORE columns should be represented in change events, |
| * including:'json' represents values as string-ified JSON (default)'map' |
| * represents values as a key/value map |
| */ |
| private String hstoreHandlingMode = "json"; |
| /** |
| * Whether the connector parse table and column's comment to metadata |
| * object.Note: Enable this option will bring the implications on memory |
| * usage. The number and size of ColumnImpl objects is what largely impacts |
| * how much memory is consumed by the Debezium connectors, and adding a |
| * String to each of them can potentially be quite heavy. The default is |
| * 'false'. |
| */ |
| private Boolean includeSchemaComments = false; |
| /** |
| * Specify whether the fields of data type not supported by Debezium should |
| * be processed:'false' (the default) omits the fields; 'true' converts the |
| * field into an implementation dependent binary representation. |
| */ |
| private Boolean includeUnknownDatatypes = false; |
| /** |
| * The maximum size of chunk for incremental snapshotting |
| */ |
| private Integer incrementalSnapshotChunkSize = 1024; |
| /** |
| * Specify how INTERVAL columns should be represented in change events, |
| * including:'string' represents values as an exact ISO formatted |
| * string'numeric' (default) represents values using the inexact conversion |
| * into microseconds |
| */ |
| private String intervalHandlingMode = "numeric"; |
| /** |
| * Maximum size of each batch of source records. Defaults to 2048. |
| */ |
| private Integer maxBatchSize = 2048; |
| /** |
| * Maximum size of the queue for change events read from the database log |
| * but not yet recorded or forwarded. Defaults to 8192, and should always be |
| * larger than the maximum batch size. |
| */ |
| private Integer maxQueueSize = 8192; |
| /** |
| * Maximum size of the queue in bytes for change events read from the |
| * database log but not yet recorded or forwarded. Defaults to 0. Mean the |
| * feature is not enabled |
| */ |
| private Long maxQueueSizeInBytes = 0L; |
| /** |
| * A semicolon-separated list of expressions that match fully-qualified |
| * tables and column(s) to be used as message key. Each expression must |
| * match the pattern ':',where the table names could be defined as |
| * (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the |
| * specific connector,and the key columns are a comma-separated list of |
| * columns representing the custom key. For any table without an explicit |
| * key configuration the table's primary key column(s) will be used as |
| * message key.Example: |
| * dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |
| */ |
| private String messageKeyColumns; |
| /** |
| * A comma-separated list of regular expressions that match the logical |
| * decoding message prefixes to be excluded from monitoring. |
| */ |
| private String messagePrefixExcludeList; |
| /** |
| * A comma-separated list of regular expressions that match the logical |
| * decoding message prefixes to be monitored. All prefixes are monitored by |
| * default. |
| */ |
| private String messagePrefixIncludeList; |
| /** |
| * The name of the Postgres logical decoding plugin installed on the server. |
| * Supported values are 'decoderbufs', 'wal2json', 'pgoutput', |
| * 'wal2json_streaming', 'wal2json_rds' and 'wal2json_rds_streaming'. |
| * Defaults to 'decoderbufs'. |
| */ |
| private String pluginName = "decoderbufs"; |
| /** |
| * Time to wait for new change events to appear after receiving no events, |
| * given in milliseconds. Defaults to 500 ms. The option is a long type. |
| */ |
| private Long pollIntervalMs = 500L; |
| /** |
| * Enables transaction metadata extraction together with event counting |
| */ |
| private Boolean provideTransactionMetadata = false; |
| /** |
| * Applies only when streaming changes using pgoutput.Determine how creation |
| * of a publication should work, the default is all_tables.DISABLED - The |
| * connector will not attempt to create a publication at all. The |
| * expectation is that the user has created the publication up-front. If the |
| * publication isn't found to exist upon startup, the connector will throw |
| * an exception and stop.ALL_TABLES - If no publication exists, the |
| * connector will create a new publication for all tables. Note this |
| * requires that the configured user has access. If the publication already |
| * exists, it will be used. i.e CREATE PUBLICATION FOR ALL TABLES;FILTERED - |
| * If no publication exists, the connector will create a new publication for |
| * all those tables matchingthe current filter configuration (see |
| * table/database include/exclude list properties). If the publication |
| * already exists, it will be used. i.e CREATE PUBLICATION FOR TABLE |
| */ |
| private String publicationAutocreateMode = "all_tables"; |
| /** |
| * The name of the Postgres 10 publication used for streaming changes from a |
| * plugin.Defaults to 'dbz_publication' |
| */ |
| private String publicationName = "dbz_publication"; |
| /** |
| * The maximum number of records that should be loaded into memory while |
| * streaming. A value of 0 uses the default JDBC fetch size. |
| */ |
| private Integer queryFetchSize = 0; |
| /** |
| * Time to wait before restarting connector after retriable exception |
| * occurs. Defaults to 10000ms. The option is a long type. |
| */ |
| private Long retriableRestartConnectorWaitMs = 10000L; |
| /** |
| * Whether field names will be sanitized to Avro naming conventions |
| */ |
| private Boolean sanitizeFieldNames = false; |
| /** |
| * The schemas for which events must not be captured (deprecated, use |
| * schema.exclude.list instead) |
| */ |
| private String schemaBlacklist; |
| /** |
| * The schemas for which events must not be captured |
| */ |
| private String schemaExcludeList; |
| /** |
| * The schemas for which events should be captured |
| */ |
| private String schemaIncludeList; |
| /** |
| * Specify the conditions that trigger a refresh of the in-memory schema for |
| * a table. 'columns_diff' (the default) is the safest mode, ensuring the |
| * in-memory schema stays in-sync with the database table's schema at all |
| * times. 'columns_diff_exclude_unchanged_toast' instructs the connector to |
| * refresh the in-memory schema cache if there is a discrepancy between it |
| * and the schema derived from the incoming message, unless unchanged |
| * TOASTable data fully accounts for the discrepancy. This setting can |
| * improve connector performance significantly if there are |
| * frequently-updated tables that have TOASTed data that are rarely part of |
| * these updates. However, it is possible for the in-memory schema to become |
| * outdated if TOASTable columns are dropped from the table. |
| */ |
| private String schemaRefreshMode = "columns_diff"; |
| /** |
| * The schemas for which events should be captured (deprecated, use |
| * schema.include.list instead) |
| */ |
| private String schemaWhitelist; |
| /** |
| * The name of the data collection that is used to send signals/commands to |
| * Debezium. Signaling is disabled when not set. |
| */ |
| private String signalDataCollection; |
| /** |
| * The comma-separated list of operations to skip during streaming, defined |
| * as: 'c' for inserts/create; 'u' for updates; 'd' for deletes. By default, |
| * no operations will be skipped. |
| */ |
| private String skippedOperations; |
| /** |
| * Whether or not to drop the logical replication slot when the connector |
| * finishes orderlyBy default the replication is kept so that on restart |
| * progress can resume from the last recorded location |
| */ |
| private Boolean slotDropOnStop = false; |
| /** |
| * How many times to retry connecting to a replication slot when an attempt |
| * fails. |
| */ |
| private Integer slotMaxRetries = 6; |
| /** |
| * The name of the Postgres logical decoding slot created for streaming |
| * changes from a plugin.Defaults to 'debezium |
| */ |
| private String slotName = "debezium"; |
| /** |
| * Time to wait between retry attempts when the connector fails to connect |
| * to a replication slot, given in milliseconds. Defaults to 10 seconds |
| * (10,000 ms). The option is a long type. |
| */ |
| private Long slotRetryDelayMs = 10000L; |
| /** |
| * Any optional parameters used by logical decoding plugin. Semi-colon |
| * separated. E.g. 'add-tables=public.table,public.table2;include-lsn=true' |
| */ |
| private String slotStreamParams; |
| /** |
| * When 'snapshot.mode' is set as custom, this setting must be set to |
| * specify a fully qualified class name to load (via the default class |
| * loader).This class must implement the 'Snapshotter' interface and is |
| * called on each app boot to determine whether to do a snapshot and how to |
| * build queries. |
| */ |
| private String snapshotCustomClass; |
| /** |
| * A delay period before a snapshot will begin, given in milliseconds. |
| * Defaults to 0 ms. The option is a long type. |
| */ |
| private Long snapshotDelayMs = 0L; |
| /** |
| * The maximum number of records that should be loaded into memory while |
| * performing a snapshot |
| */ |
| private Integer snapshotFetchSize; |
| /** |
| * this setting must be set to specify a list of tables/collections whose |
| * snapshot must be taken on creating or restarting the connector. |
| */ |
| private String snapshotIncludeCollectionList; |
| /** |
| * The maximum number of millis to wait for table locks at the beginning of |
| * a snapshot. If locks cannot be acquired in this time frame, the snapshot |
| * will be aborted. Defaults to 10 seconds. The option is a long type. |
| */ |
| private Long snapshotLockTimeoutMs = 10000L; |
| /** |
| * The maximum number of threads used to perform the snapshot. Defaults to |
| * 1. |
| */ |
| private Integer snapshotMaxThreads = 1; |
| /** |
| * The criteria for running a snapshot upon startup of the connector. |
| * Options include: 'always' to specify that the connector run a snapshot |
| * each time it starts up; 'initial' (the default) to specify the connector |
| * can run a snapshot only when no offsets are available for the logical |
| * server name; 'initial_only' same as 'initial' except the connector should |
| * stop after completing the snapshot and before it would normally start |
| * emitting changes;'never' to specify the connector should never run a |
| * snapshot and that upon first startup the connector should read from the |
| * last position (LSN) recorded by the server; and'exported' deprecated, use |
| * 'initial' instead; 'custom' to specify a custom class with |
| * 'snapshot.custom_class' which will be loaded and used to determine the |
| * snapshot, see docs for more details. |
| */ |
| private String snapshotMode = "initial"; |
| /** |
| * This property contains a comma-separated list of fully-qualified tables |
| * (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on |
| * thespecific connectors. Select statements for the individual tables are |
| * specified in further configuration properties, one for each table, |
| * identified by the id |
| * 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or |
| * 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', |
| * respectively. The value of those properties is the select statement to |
| * use when retrieving data from the specific table during snapshotting. A |
| * possible use case for large append-only tables is setting a specific |
| * point where to start (resume) snapshotting, in case a previous |
| * snapshotting was interrupted. |
| */ |
| private String snapshotSelectStatementOverrides; |
| /** |
| * A version of the format of the publicly visible source part in the |
| * message |
| */ |
| private String sourceStructVersion = "v2"; |
| /** |
| * Frequency for sending replication connection status updates to the |
| * server, given in milliseconds. Defaults to 10 seconds (10,000 ms). The |
| * option is a int type. |
| */ |
| private Integer statusUpdateIntervalMs = 10000; |
| /** |
| * A comma-separated list of regular expressions that match the |
| * fully-qualified names of tables to be excluded from monitoring |
| * (deprecated, use table.exclude.list instead) |
| */ |
| private String tableBlacklist; |
| /** |
| * A comma-separated list of regular expressions that match the |
| * fully-qualified names of tables to be excluded from monitoring |
| */ |
| private String tableExcludeList; |
| /** |
| * Flag specifying whether built-in tables should be ignored. |
| */ |
| private Boolean tableIgnoreBuiltin = true; |
| /** |
| * The tables for which changes are to be captured |
| */ |
| private String tableIncludeList; |
| /** |
| * The tables for which changes are to be captured (deprecated, use |
| * table.include.list instead) |
| */ |
| private String tableWhitelist; |
| /** |
| * Time, date, and timestamps can be represented with different kinds of |
| * precisions, including:'adaptive' (the default) bases the precision of |
| * time, date, and timestamp values on the database column's precision; |
| * 'adaptive_time_microseconds' like 'adaptive' mode, but TIME fields always |
| * use microseconds precision;'connect' always represents time, date, and |
| * timestamp values using Kafka Connect's built-in representations for Time, |
| * Date, and Timestamp, which uses millisecond precision regardless of the |
| * database columns' precision . |
| */ |
| private String timePrecisionMode = "adaptive"; |
| /** |
| * Whether delete operations should be represented by a delete event and a |
| * subsquenttombstone event (true) or only by a delete event (false). |
| * Emitting the tombstone event (the default behavior) allows Kafka to |
| * completely delete all events pertaining to the given key once the source |
| * record got deleted. |
| */ |
| private Boolean tombstonesOnDelete = false; |
| /** |
| * The name of the transaction metadata topic. The placeholder |
| * ${database.server.name} can be used for referring to the connector's |
| * logical name; defaults to ${database.server.name}.transaction. |
| */ |
| private String transactionTopic = "${database.server.name}.transaction"; |
| /** |
| * Specify how TRUNCATE operations are handled for change events (supported |
| * only on pg11 pgoutput plugin), including: 'skip' to skip / ignore |
| * TRUNCATE events (default), 'include' to handle and include TRUNCATE |
| * events |
| */ |
| private String truncateHandlingMode = "skip"; |
| /** |
| * Specify the constant that will be provided by Debezium to indicate that |
| * the original value is a toasted value not provided by the database. If |
| * starts with 'hex:' prefix it is expected that the rest of the string |
| * represents hexadecimal encoded octets. |
| */ |
| private String unavailableValuePlaceholder = "__debezium_unavailable_value"; |
| /** |
| * Specify how often (in ms) the xmin will be fetched from the replication |
| * slot. This xmin value is exposed by the slot which gives a lower bound of |
| * where a new replication slot could start from. The lower the value, the |
| * more likely this value is to be the current 'true' value, but the bigger |
| * the performance cost. The bigger the value, the less likely this value is |
| * to be the current 'true' value, but the lower the performance penalty. |
| * The default is set to 0 ms, which disables tracking xmin. The option is a |
| * long type. |
| */ |
| private Long xminFetchIntervalMs = 0L; |
| |
| public Map<String, Object> getAdditionalProperties() { |
| return additionalProperties; |
| } |
| |
| public void setAdditionalProperties(Map<String, Object> additionalProperties) { |
| this.additionalProperties = additionalProperties; |
| } |
| |
| public Boolean getBridgeErrorHandler() { |
| return bridgeErrorHandler; |
| } |
| |
| public void setBridgeErrorHandler(Boolean bridgeErrorHandler) { |
| this.bridgeErrorHandler = bridgeErrorHandler; |
| } |
| |
| public PostgresConnectorEmbeddedDebeziumConfiguration getConfiguration() { |
| return configuration; |
| } |
| |
| public void setConfiguration( |
| PostgresConnectorEmbeddedDebeziumConfiguration configuration) { |
| this.configuration = configuration; |
| } |
| |
| public String getInternalKeyConverter() { |
| return internalKeyConverter; |
| } |
| |
| public void setInternalKeyConverter(String internalKeyConverter) { |
| this.internalKeyConverter = internalKeyConverter; |
| } |
| |
| public String getInternalValueConverter() { |
| return internalValueConverter; |
| } |
| |
| public void setInternalValueConverter(String internalValueConverter) { |
| this.internalValueConverter = internalValueConverter; |
| } |
| |
| public String getOffsetCommitPolicy() { |
| return offsetCommitPolicy; |
| } |
| |
| public void setOffsetCommitPolicy(String offsetCommitPolicy) { |
| this.offsetCommitPolicy = offsetCommitPolicy; |
| } |
| |
| public Long getOffsetCommitTimeoutMs() { |
| return offsetCommitTimeoutMs; |
| } |
| |
| public void setOffsetCommitTimeoutMs(Long offsetCommitTimeoutMs) { |
| this.offsetCommitTimeoutMs = offsetCommitTimeoutMs; |
| } |
| |
| public Long getOffsetFlushIntervalMs() { |
| return offsetFlushIntervalMs; |
| } |
| |
| public void setOffsetFlushIntervalMs(Long offsetFlushIntervalMs) { |
| this.offsetFlushIntervalMs = offsetFlushIntervalMs; |
| } |
| |
| public String getOffsetStorage() { |
| return offsetStorage; |
| } |
| |
| public void setOffsetStorage(String offsetStorage) { |
| this.offsetStorage = offsetStorage; |
| } |
| |
| public String getOffsetStorageFileName() { |
| return offsetStorageFileName; |
| } |
| |
| public void setOffsetStorageFileName(String offsetStorageFileName) { |
| this.offsetStorageFileName = offsetStorageFileName; |
| } |
| |
| public Integer getOffsetStoragePartitions() { |
| return offsetStoragePartitions; |
| } |
| |
| public void setOffsetStoragePartitions(Integer offsetStoragePartitions) { |
| this.offsetStoragePartitions = offsetStoragePartitions; |
| } |
| |
| public Integer getOffsetStorageReplicationFactor() { |
| return offsetStorageReplicationFactor; |
| } |
| |
| public void setOffsetStorageReplicationFactor( |
| Integer offsetStorageReplicationFactor) { |
| this.offsetStorageReplicationFactor = offsetStorageReplicationFactor; |
| } |
| |
| public String getOffsetStorageTopic() { |
| return offsetStorageTopic; |
| } |
| |
| public void setOffsetStorageTopic(String offsetStorageTopic) { |
| this.offsetStorageTopic = offsetStorageTopic; |
| } |
| |
| public Boolean getAutowiredEnabled() { |
| return autowiredEnabled; |
| } |
| |
| public void setAutowiredEnabled(Boolean autowiredEnabled) { |
| this.autowiredEnabled = autowiredEnabled; |
| } |
| |
| public String getBinaryHandlingMode() { |
| return binaryHandlingMode; |
| } |
| |
| public void setBinaryHandlingMode(String binaryHandlingMode) { |
| this.binaryHandlingMode = binaryHandlingMode; |
| } |
| |
| public String getColumnBlacklist() { |
| return columnBlacklist; |
| } |
| |
| public void setColumnBlacklist(String columnBlacklist) { |
| this.columnBlacklist = columnBlacklist; |
| } |
| |
| public String getColumnExcludeList() { |
| return columnExcludeList; |
| } |
| |
| public void setColumnExcludeList(String columnExcludeList) { |
| this.columnExcludeList = columnExcludeList; |
| } |
| |
| public String getColumnIncludeList() { |
| return columnIncludeList; |
| } |
| |
| public void setColumnIncludeList(String columnIncludeList) { |
| this.columnIncludeList = columnIncludeList; |
| } |
| |
| public String getColumnPropagateSourceType() { |
| return columnPropagateSourceType; |
| } |
| |
| public void setColumnPropagateSourceType(String columnPropagateSourceType) { |
| this.columnPropagateSourceType = columnPropagateSourceType; |
| } |
| |
| public String getColumnWhitelist() { |
| return columnWhitelist; |
| } |
| |
| public void setColumnWhitelist(String columnWhitelist) { |
| this.columnWhitelist = columnWhitelist; |
| } |
| |
| public String getConverters() { |
| return converters; |
| } |
| |
| public void setConverters(String converters) { |
| this.converters = converters; |
| } |
| |
| public String getDatabaseDbname() { |
| return databaseDbname; |
| } |
| |
| public void setDatabaseDbname(String databaseDbname) { |
| this.databaseDbname = databaseDbname; |
| } |
| |
| public String getDatabaseHistoryFileFilename() { |
| return databaseHistoryFileFilename; |
| } |
| |
| public void setDatabaseHistoryFileFilename( |
| String databaseHistoryFileFilename) { |
| this.databaseHistoryFileFilename = databaseHistoryFileFilename; |
| } |
| |
| public String getDatabaseHostname() { |
| return databaseHostname; |
| } |
| |
| public void setDatabaseHostname(String databaseHostname) { |
| this.databaseHostname = databaseHostname; |
| } |
| |
| public String getDatabaseInitialStatements() { |
| return databaseInitialStatements; |
| } |
| |
| public void setDatabaseInitialStatements(String databaseInitialStatements) { |
| this.databaseInitialStatements = databaseInitialStatements; |
| } |
| |
| public String getDatabasePassword() { |
| return databasePassword; |
| } |
| |
| public void setDatabasePassword(String databasePassword) { |
| this.databasePassword = databasePassword; |
| } |
| |
| public Integer getDatabasePort() { |
| return databasePort; |
| } |
| |
| public void setDatabasePort(Integer databasePort) { |
| this.databasePort = databasePort; |
| } |
| |
| public String getDatabaseServerName() { |
| return databaseServerName; |
| } |
| |
| public void setDatabaseServerName(String databaseServerName) { |
| this.databaseServerName = databaseServerName; |
| } |
| |
| public String getDatabaseSslcert() { |
| return databaseSslcert; |
| } |
| |
| public void setDatabaseSslcert(String databaseSslcert) { |
| this.databaseSslcert = databaseSslcert; |
| } |
| |
| public String getDatabaseSslfactory() { |
| return databaseSslfactory; |
| } |
| |
| public void setDatabaseSslfactory(String databaseSslfactory) { |
| this.databaseSslfactory = databaseSslfactory; |
| } |
| |
| public String getDatabaseSslkey() { |
| return databaseSslkey; |
| } |
| |
| public void setDatabaseSslkey(String databaseSslkey) { |
| this.databaseSslkey = databaseSslkey; |
| } |
| |
| public String getDatabaseSslmode() { |
| return databaseSslmode; |
| } |
| |
| public void setDatabaseSslmode(String databaseSslmode) { |
| this.databaseSslmode = databaseSslmode; |
| } |
| |
| public String getDatabaseSslpassword() { |
| return databaseSslpassword; |
| } |
| |
| public void setDatabaseSslpassword(String databaseSslpassword) { |
| this.databaseSslpassword = databaseSslpassword; |
| } |
| |
| public String getDatabaseSslrootcert() { |
| return databaseSslrootcert; |
| } |
| |
| public void setDatabaseSslrootcert(String databaseSslrootcert) { |
| this.databaseSslrootcert = databaseSslrootcert; |
| } |
| |
| public Boolean getDatabaseTcpkeepalive() { |
| return databaseTcpkeepalive; |
| } |
| |
| public void setDatabaseTcpkeepalive(Boolean databaseTcpkeepalive) { |
| this.databaseTcpkeepalive = databaseTcpkeepalive; |
| } |
| |
| public String getDatabaseUser() { |
| return databaseUser; |
| } |
| |
| public void setDatabaseUser(String databaseUser) { |
| this.databaseUser = databaseUser; |
| } |
| |
| public String getDatatypePropagateSourceType() { |
| return datatypePropagateSourceType; |
| } |
| |
| public void setDatatypePropagateSourceType( |
| String datatypePropagateSourceType) { |
| this.datatypePropagateSourceType = datatypePropagateSourceType; |
| } |
| |
| public String getDecimalHandlingMode() { |
| return decimalHandlingMode; |
| } |
| |
| public void setDecimalHandlingMode(String decimalHandlingMode) { |
| this.decimalHandlingMode = decimalHandlingMode; |
| } |
| |
| public String getEventProcessingFailureHandlingMode() { |
| return eventProcessingFailureHandlingMode; |
| } |
| |
| public void setEventProcessingFailureHandlingMode( |
| String eventProcessingFailureHandlingMode) { |
| this.eventProcessingFailureHandlingMode = eventProcessingFailureHandlingMode; |
| } |
| |
| public String getHeartbeatActionQuery() { |
| return heartbeatActionQuery; |
| } |
| |
| public void setHeartbeatActionQuery(String heartbeatActionQuery) { |
| this.heartbeatActionQuery = heartbeatActionQuery; |
| } |
| |
| public Integer getHeartbeatIntervalMs() { |
| return heartbeatIntervalMs; |
| } |
| |
| public void setHeartbeatIntervalMs(Integer heartbeatIntervalMs) { |
| this.heartbeatIntervalMs = heartbeatIntervalMs; |
| } |
| |
| public String getHeartbeatTopicsPrefix() { |
| return heartbeatTopicsPrefix; |
| } |
| |
| public void setHeartbeatTopicsPrefix(String heartbeatTopicsPrefix) { |
| this.heartbeatTopicsPrefix = heartbeatTopicsPrefix; |
| } |
| |
| public String getHstoreHandlingMode() { |
| return hstoreHandlingMode; |
| } |
| |
| public void setHstoreHandlingMode(String hstoreHandlingMode) { |
| this.hstoreHandlingMode = hstoreHandlingMode; |
| } |
| |
| public Boolean getIncludeSchemaComments() { |
| return includeSchemaComments; |
| } |
| |
| public void setIncludeSchemaComments(Boolean includeSchemaComments) { |
| this.includeSchemaComments = includeSchemaComments; |
| } |
| |
| public Boolean getIncludeUnknownDatatypes() { |
| return includeUnknownDatatypes; |
| } |
| |
| public void setIncludeUnknownDatatypes(Boolean includeUnknownDatatypes) { |
| this.includeUnknownDatatypes = includeUnknownDatatypes; |
| } |
| |
| public Integer getIncrementalSnapshotChunkSize() { |
| return incrementalSnapshotChunkSize; |
| } |
| |
| public void setIncrementalSnapshotChunkSize( |
| Integer incrementalSnapshotChunkSize) { |
| this.incrementalSnapshotChunkSize = incrementalSnapshotChunkSize; |
| } |
| |
| public String getIntervalHandlingMode() { |
| return intervalHandlingMode; |
| } |
| |
| public void setIntervalHandlingMode(String intervalHandlingMode) { |
| this.intervalHandlingMode = intervalHandlingMode; |
| } |
| |
| public Integer getMaxBatchSize() { |
| return maxBatchSize; |
| } |
| |
| public void setMaxBatchSize(Integer maxBatchSize) { |
| this.maxBatchSize = maxBatchSize; |
| } |
| |
| public Integer getMaxQueueSize() { |
| return maxQueueSize; |
| } |
| |
| public void setMaxQueueSize(Integer maxQueueSize) { |
| this.maxQueueSize = maxQueueSize; |
| } |
| |
| public Long getMaxQueueSizeInBytes() { |
| return maxQueueSizeInBytes; |
| } |
| |
| public void setMaxQueueSizeInBytes(Long maxQueueSizeInBytes) { |
| this.maxQueueSizeInBytes = maxQueueSizeInBytes; |
| } |
| |
| public String getMessageKeyColumns() { |
| return messageKeyColumns; |
| } |
| |
| public void setMessageKeyColumns(String messageKeyColumns) { |
| this.messageKeyColumns = messageKeyColumns; |
| } |
| |
| public String getMessagePrefixExcludeList() { |
| return messagePrefixExcludeList; |
| } |
| |
| public void setMessagePrefixExcludeList(String messagePrefixExcludeList) { |
| this.messagePrefixExcludeList = messagePrefixExcludeList; |
| } |
| |
| public String getMessagePrefixIncludeList() { |
| return messagePrefixIncludeList; |
| } |
| |
| public void setMessagePrefixIncludeList(String messagePrefixIncludeList) { |
| this.messagePrefixIncludeList = messagePrefixIncludeList; |
| } |
| |
| public String getPluginName() { |
| return pluginName; |
| } |
| |
| public void setPluginName(String pluginName) { |
| this.pluginName = pluginName; |
| } |
| |
| public Long getPollIntervalMs() { |
| return pollIntervalMs; |
| } |
| |
| public void setPollIntervalMs(Long pollIntervalMs) { |
| this.pollIntervalMs = pollIntervalMs; |
| } |
| |
| public Boolean getProvideTransactionMetadata() { |
| return provideTransactionMetadata; |
| } |
| |
| public void setProvideTransactionMetadata(Boolean provideTransactionMetadata) { |
| this.provideTransactionMetadata = provideTransactionMetadata; |
| } |
| |
| public String getPublicationAutocreateMode() { |
| return publicationAutocreateMode; |
| } |
| |
| public void setPublicationAutocreateMode(String publicationAutocreateMode) { |
| this.publicationAutocreateMode = publicationAutocreateMode; |
| } |
| |
| public String getPublicationName() { |
| return publicationName; |
| } |
| |
| public void setPublicationName(String publicationName) { |
| this.publicationName = publicationName; |
| } |
| |
| public Integer getQueryFetchSize() { |
| return queryFetchSize; |
| } |
| |
| public void setQueryFetchSize(Integer queryFetchSize) { |
| this.queryFetchSize = queryFetchSize; |
| } |
| |
| public Long getRetriableRestartConnectorWaitMs() { |
| return retriableRestartConnectorWaitMs; |
| } |
| |
| public void setRetriableRestartConnectorWaitMs( |
| Long retriableRestartConnectorWaitMs) { |
| this.retriableRestartConnectorWaitMs = retriableRestartConnectorWaitMs; |
| } |
| |
| public Boolean getSanitizeFieldNames() { |
| return sanitizeFieldNames; |
| } |
| |
| public void setSanitizeFieldNames(Boolean sanitizeFieldNames) { |
| this.sanitizeFieldNames = sanitizeFieldNames; |
| } |
| |
| public String getSchemaBlacklist() { |
| return schemaBlacklist; |
| } |
| |
| public void setSchemaBlacklist(String schemaBlacklist) { |
| this.schemaBlacklist = schemaBlacklist; |
| } |
| |
| public String getSchemaExcludeList() { |
| return schemaExcludeList; |
| } |
| |
| public void setSchemaExcludeList(String schemaExcludeList) { |
| this.schemaExcludeList = schemaExcludeList; |
| } |
| |
| public String getSchemaIncludeList() { |
| return schemaIncludeList; |
| } |
| |
| public void setSchemaIncludeList(String schemaIncludeList) { |
| this.schemaIncludeList = schemaIncludeList; |
| } |
| |
| public String getSchemaRefreshMode() { |
| return schemaRefreshMode; |
| } |
| |
| public void setSchemaRefreshMode(String schemaRefreshMode) { |
| this.schemaRefreshMode = schemaRefreshMode; |
| } |
| |
| public String getSchemaWhitelist() { |
| return schemaWhitelist; |
| } |
| |
| public void setSchemaWhitelist(String schemaWhitelist) { |
| this.schemaWhitelist = schemaWhitelist; |
| } |
| |
| public String getSignalDataCollection() { |
| return signalDataCollection; |
| } |
| |
| public void setSignalDataCollection(String signalDataCollection) { |
| this.signalDataCollection = signalDataCollection; |
| } |
| |
| public String getSkippedOperations() { |
| return skippedOperations; |
| } |
| |
| public void setSkippedOperations(String skippedOperations) { |
| this.skippedOperations = skippedOperations; |
| } |
| |
| public Boolean getSlotDropOnStop() { |
| return slotDropOnStop; |
| } |
| |
| public void setSlotDropOnStop(Boolean slotDropOnStop) { |
| this.slotDropOnStop = slotDropOnStop; |
| } |
| |
| public Integer getSlotMaxRetries() { |
| return slotMaxRetries; |
| } |
| |
| public void setSlotMaxRetries(Integer slotMaxRetries) { |
| this.slotMaxRetries = slotMaxRetries; |
| } |
| |
| public String getSlotName() { |
| return slotName; |
| } |
| |
| public void setSlotName(String slotName) { |
| this.slotName = slotName; |
| } |
| |
| public Long getSlotRetryDelayMs() { |
| return slotRetryDelayMs; |
| } |
| |
| public void setSlotRetryDelayMs(Long slotRetryDelayMs) { |
| this.slotRetryDelayMs = slotRetryDelayMs; |
| } |
| |
| public String getSlotStreamParams() { |
| return slotStreamParams; |
| } |
| |
| public void setSlotStreamParams(String slotStreamParams) { |
| this.slotStreamParams = slotStreamParams; |
| } |
| |
| public String getSnapshotCustomClass() { |
| return snapshotCustomClass; |
| } |
| |
| public void setSnapshotCustomClass(String snapshotCustomClass) { |
| this.snapshotCustomClass = snapshotCustomClass; |
| } |
| |
| public Long getSnapshotDelayMs() { |
| return snapshotDelayMs; |
| } |
| |
| public void setSnapshotDelayMs(Long snapshotDelayMs) { |
| this.snapshotDelayMs = snapshotDelayMs; |
| } |
| |
| public Integer getSnapshotFetchSize() { |
| return snapshotFetchSize; |
| } |
| |
| public void setSnapshotFetchSize(Integer snapshotFetchSize) { |
| this.snapshotFetchSize = snapshotFetchSize; |
| } |
| |
| public String getSnapshotIncludeCollectionList() { |
| return snapshotIncludeCollectionList; |
| } |
| |
| public void setSnapshotIncludeCollectionList( |
| String snapshotIncludeCollectionList) { |
| this.snapshotIncludeCollectionList = snapshotIncludeCollectionList; |
| } |
| |
| public Long getSnapshotLockTimeoutMs() { |
| return snapshotLockTimeoutMs; |
| } |
| |
| public void setSnapshotLockTimeoutMs(Long snapshotLockTimeoutMs) { |
| this.snapshotLockTimeoutMs = snapshotLockTimeoutMs; |
| } |
| |
| public Integer getSnapshotMaxThreads() { |
| return snapshotMaxThreads; |
| } |
| |
| public void setSnapshotMaxThreads(Integer snapshotMaxThreads) { |
| this.snapshotMaxThreads = snapshotMaxThreads; |
| } |
| |
| public String getSnapshotMode() { |
| return snapshotMode; |
| } |
| |
| public void setSnapshotMode(String snapshotMode) { |
| this.snapshotMode = snapshotMode; |
| } |
| |
| public String getSnapshotSelectStatementOverrides() { |
| return snapshotSelectStatementOverrides; |
| } |
| |
| public void setSnapshotSelectStatementOverrides( |
| String snapshotSelectStatementOverrides) { |
| this.snapshotSelectStatementOverrides = snapshotSelectStatementOverrides; |
| } |
| |
| public String getSourceStructVersion() { |
| return sourceStructVersion; |
| } |
| |
| public void setSourceStructVersion(String sourceStructVersion) { |
| this.sourceStructVersion = sourceStructVersion; |
| } |
| |
| public Integer getStatusUpdateIntervalMs() { |
| return statusUpdateIntervalMs; |
| } |
| |
| public void setStatusUpdateIntervalMs(Integer statusUpdateIntervalMs) { |
| this.statusUpdateIntervalMs = statusUpdateIntervalMs; |
| } |
| |
| public String getTableBlacklist() { |
| return tableBlacklist; |
| } |
| |
| public void setTableBlacklist(String tableBlacklist) { |
| this.tableBlacklist = tableBlacklist; |
| } |
| |
| public String getTableExcludeList() { |
| return tableExcludeList; |
| } |
| |
| public void setTableExcludeList(String tableExcludeList) { |
| this.tableExcludeList = tableExcludeList; |
| } |
| |
| public Boolean getTableIgnoreBuiltin() { |
| return tableIgnoreBuiltin; |
| } |
| |
| public void setTableIgnoreBuiltin(Boolean tableIgnoreBuiltin) { |
| this.tableIgnoreBuiltin = tableIgnoreBuiltin; |
| } |
| |
| public String getTableIncludeList() { |
| return tableIncludeList; |
| } |
| |
| public void setTableIncludeList(String tableIncludeList) { |
| this.tableIncludeList = tableIncludeList; |
| } |
| |
| public String getTableWhitelist() { |
| return tableWhitelist; |
| } |
| |
| public void setTableWhitelist(String tableWhitelist) { |
| this.tableWhitelist = tableWhitelist; |
| } |
| |
| public String getTimePrecisionMode() { |
| return timePrecisionMode; |
| } |
| |
| public void setTimePrecisionMode(String timePrecisionMode) { |
| this.timePrecisionMode = timePrecisionMode; |
| } |
| |
| public Boolean getTombstonesOnDelete() { |
| return tombstonesOnDelete; |
| } |
| |
| public void setTombstonesOnDelete(Boolean tombstonesOnDelete) { |
| this.tombstonesOnDelete = tombstonesOnDelete; |
| } |
| |
| public String getTransactionTopic() { |
| return transactionTopic; |
| } |
| |
| public void setTransactionTopic(String transactionTopic) { |
| this.transactionTopic = transactionTopic; |
| } |
| |
| public String getTruncateHandlingMode() { |
| return truncateHandlingMode; |
| } |
| |
| public void setTruncateHandlingMode(String truncateHandlingMode) { |
| this.truncateHandlingMode = truncateHandlingMode; |
| } |
| |
| public String getUnavailableValuePlaceholder() { |
| return unavailableValuePlaceholder; |
| } |
| |
| public void setUnavailableValuePlaceholder( |
| String unavailableValuePlaceholder) { |
| this.unavailableValuePlaceholder = unavailableValuePlaceholder; |
| } |
| |
| public Long getXminFetchIntervalMs() { |
| return xminFetchIntervalMs; |
| } |
| |
| public void setXminFetchIntervalMs(Long xminFetchIntervalMs) { |
| this.xminFetchIntervalMs = xminFetchIntervalMs; |
| } |
| } |
