ghostferry

type AtomicBoolean int32

type BatchWriter struct {
	DB             *sql.DB
	InlineVerifier *InlineVerifier
	StateTracker   *StateTracker

	DatabaseRewrites map[string]string
	TableRewrites    map[string]string

	WriteRetries int
	// contains filtered or unexported fields
}

type BatchWriterVerificationFailed struct {
	// contains filtered or unexported fields
}

type BinlogDeleteEvent struct {
	*DMLEventBase
	// contains filtered or unexported fields
}

type BinlogInsertEvent struct {
	*DMLEventBase
	// contains filtered or unexported fields
}

type BinlogPosition struct {
	// A binlog position emitted by the binlog-streamer consists of two parts:
	// First, the last emitted event position, which refers to the event that
	// we received from the MySQL master and that we hand to clients. Second,
	// a position from which we can resume a binlog-streamer.
	// Ideally, these two values would be the same, but in reality they are
	// not, because some events are streamed in a series (e.g. DML events
	// require a table-map events to be seen before).
	// As a result, we always stream event positions as a pair - if a binlog
	// streamer is resumed from an event that is not safe to resume from, we
	// resume from the most recent (earlier) event from which we can safely
	// resume and simply suppress emitting these events up to the point of the
	// last event returned.
	//
	// the actual binlog position of an event emitted by the streamer
	EventPosition mysql.Position
	// the position from which one needs to point the streamer if we want to
	// resume from after this event
	ResumePosition mysql.Position
}

type BinlogSchemaChangeEvent struct {
	*DXLEventBase
	// contains filtered or unexported fields
}

type BinlogStreamer struct {
	DB           *sql.DB
	DBConfig     *DatabaseConfig
	MyServerId   uint32
	ErrorHandler ErrorHandler
	ReadRetries  int
	// contains filtered or unexported fields
}

type BinlogUpdateEvent struct {
	*DMLEventBase
	// contains filtered or unexported fields
}

type BinlogVerifyBatch struct {
	SchemaName     string
	TableName      string
	PaginationKeys []uint64
}

type BinlogVerifySerializedStore map[string]map[string]map[uint64]int

type BinlogVerifyStore struct {
	EmitLogPerRowsAdded uint64
	// contains filtered or unexported fields
}

type BinlogWriter struct {
	DB               *sql.DB
	DatabaseRewrites map[string]string
	TableRewrites    map[string]string
	Throttler        Throttler

	BatchSize          int
	WriteRetries       int
	ApplySchemaChanges bool
	LockStrategy       string

	ErrorHandler                ErrorHandler
	StateTracker                *StateTracker
	ForceResumeStateUpdatesToDB bool

	CopyFilter  CopyFilter
	TableFilter TableFilter
	TableSchema TableSchemaCache
	// contains filtered or unexported fields
}

type BinlogWriterState string

type CascadingPaginationColumnConfig struct {
	// PerTable has greatest specificity and takes precedence over the other options
	FullTableCopies map[string][]string // SchemaName => TableNames

	// PerTable has next greatest specificity and takes precedence over the other options
	PerTable map[string]map[string]string // SchemaName => TableName => ColumnName

	// FallbackColumn is a global default to fallback to and is less specific than the
	// default, which is the Primary Key
	FallbackColumn string
}

type ChecksumTableVerifier struct {
	Tables           []*TableSchema
	DatabaseRewrites map[string]string
	TableRewrites    map[string]string
	SourceDB         *sql.DB
	TargetDB         *sql.DB
	// contains filtered or unexported fields
}

type ColumnCompressionConfig map[string]map[string]map[string]string

type ColumnIgnoreConfig map[string]map[string]map[string]struct{}

type CompressionVerifier struct {
	// contains filtered or unexported fields
}

type Config struct {
	// Source database connection configuration
	//
	// Required
	Source *DatabaseConfig

	// Target database connection configuration
	//
	// Required
	Target *DatabaseConfig

	// Map database name on the source database (key of the map) to a
	// different name on the target database (value of the associated key).
	// This allows one to move data and change the database name in the
	// process.
	//
	// Optional: defaults to empty map/no rewrites
	DatabaseRewrites map[string]string

	// Map the table name on the source database to a different name on
	// the target database. See DatabaseRewrite.
	//
	// Optional: defaults to empty map/no rewrites
	TableRewrites map[string]string

	// The maximum number of retries for writes if the writes failed on
	// the target database.
	//
	// Optional: defaults to 5.
	DBWriteRetries int

	// Filter out the databases/tables when detecting the source databases
	// and tables.
	//
	// Required
	TableFilter TableFilter

	// Filter out unwanted data/events from being copied.
	//
	// Optional: defaults to nil/no filter.
	CopyFilter CopyFilter

	// The server id used by Ghostferry to connect to MySQL as a replication
	// slave. This id must be unique on the MySQL server. If 0 is specified,
	// a random id will be generated upon connecting to the MySQL server.
	//
	// Optional: defaults to an automatically generated one
	MyServerId uint32

	// The maximum number of binlog events to write at once. Note this is a
	// maximum: if there are not a lot of binlog events, they will be written
	// one at a time such the binlog streamer lag is as low as possible. This
	// batch size will only be hit if there is a log of binlog at the same time.
	//
	// Optional: defaults to 100
	BinlogEventBatchSize int

	// The batch size used to iterate the data during data copy. This batch size
	// is always used: if this is specified to be 100, 100 rows will be copied
	// per iteration.
	//
	// With the current implementation of Ghostferry, we need to lock the rows
	// we select. This means, the larger this number is, the longer we need to
	// hold this lock. On the flip side, the smaller this number is, the slower
	// the copy will likely be.
	//
	// Optional: defaults to 200
	DataIterationBatchSize uint64

	// The maximum number of retries for reads if the reads fail on the source
	// database.
	//
	// Optional: defaults to 5
	DBReadRetries int

	// This specify the number of concurrent goroutines, each iterating over
	// a single table.
	//
	// At this point in time, parallelize iteration within a single table. This
	// may be possible to add to the future.
	//
	// Optional: defaults to 4
	DataIterationConcurrency int

	// If set to true, copy data by paginating in reverse order of the
	// pagination key.
	//
	// This can be useful if the pagination key is indicative of the time of
	// insert (higher key values indicate more recent data, such as auto-
	// increment IDs) and the target should receive more recent data before
	// older data.
	//
	// Optional: defaults to false
	IterateInDescendingOrder bool

	// This specifies if the data-iteration/copy should be delayed until the
	// binlog-writer shuts down. This is needed if one wishes to let replication
	// take care of temporary issues that may be preventing the data copy.
	//
	// For instance, if the source DB has schema changes that are not yet
	// applied on the target DB, copy will fail. Setting this to true allows
	// giving the binlog-writer time to catch up to then resume the copy at a
	// later time.
	//
	// This is only meaningful if we can expect an external trigger for shutting
	// down ghostferry at some point, as an automatic cutover will only happen
	// once the data copy is done (which would never happen if the binlog
	// writing is not interrupted).
	//
	// Optional: defaults to false
	DelayDataIterationUntilBinlogWriterShutdown bool

	// This specifies if the data-iteration should temporarily delay failing on
	// copy errors until all tables have at least been attempted to be copied.
	// Errors are still raised, we simply give the copy the opportunity to copy
	// all tables. Since the order of copy of tables is non-deterministic, this
	// simply ensures tables copied without errors are treated as if they were
	// copied first.
	//
	// Optional: defaults to false
	FailOnFirstTableCopyError bool

	// This specifies if Ghostferry will pause before cutover or not.
	//
	// Optional: defaults to false
	AutomaticCutover bool

	// This specifies if Ghostferry perform cutover at all or not
	//
	// Optional: defaults to false
	DisableCutover bool

	// If true, parse and propagate DB schema changes from the source
	// to the target. This is currently in alpha and does not support
	// all the features of ghostferry, such as
	// - table filters (we don't know if a newly created table should
	//   be generated), or
	// - database/table name rewrites
	//
	// Optional: defaults to false
	ReplicateSchemaChanges bool

	// For migrating data, it is crucial that we're either reading from a master
	// or from a slave that is up-to-date with its master. If we are just
	// continuously replicating/streaming data, it's OK to work on an outdated
	// upstream
	//
	// Optional: defaults to false
	AllowReplicationFromReplica bool

	// This specifies how to prevent races between the data copy and binlog
	// streaming. Possible values are:
	// - LockOnSourceDB: obtain a table lock on the source table while copying
	//   data, which will prevent any type of data modification on the source
	//   DB; this is the strictest method but may intervene with the
	//   application trying to insert data,
	// - LockInGhostferry: obtain a lock in ghostferry, preventing updates to
	//   the target DB while copying data; this should be sufficient in most
	//   scenarios, and
	// - None: do not perform locking, assume the application does not update
	//   or delete data in a way that races may occur.
	//
	// Optional: defaults to "LockOnSourceDB"
	LockStrategy string

	// This specifies whether or not Ferry.Run will handle SIGINT and SIGTERM
	// by dumping the current state to stdout and the error HTTP callback.
	// The dumped state can be used to resume Ghostferry.
	DumpStateOnSignal bool
	// When dumping state is enabled, the file to which to write the state. If
	// this is not set, use stdout.
	//
	// NOTE: Writing state to disk (rather than stdout) has the benefit that
	// ghostferry can control when is a good time to write state and when to
	// leave a previously existing state file intact
	StateFilename string

	// Config for the ControlServer
	ServerBindAddr string
	WebBasedir     string

	// Report progress via an HTTP callback. The Payload field of the callback
	// will be sent to the server as the CustomPayload field in the Progress
	// struct The unit of ProgressReportFrequency is in milliseconds.
	ProgressCallback        HTTPCallback
	ProgressReportFrequency int

	// The state to resume from as dumped by the PanicErrorHandler.
	// If this is null, a new Ghostferry run will be started. Otherwise, the
	// reconciliation process will start and Ghostferry will resume after that.
	StateToResumeFrom *SerializableState

	// If set (and no serialized state was provided), read the resume state from
	// the target system in this database.
	//
	// NOTE: To avoid collision between different instances of ghostferry, the
	// system will use the MyServerId to create unique table names within this
	// database
	ResumeStateFromDB string

	// Enforce writing binlog writer position updates into the "resume-state
	// DB" on every write to the DB (using a transaction). In most cases, this
	// is not required, as double-applying data updates is safe.
	// This is only applicable if ResumeStateFromDB is set.
	//
	// By default we write state only on shutdown, meaning that we may re-apply
	// large batches of updates multiple times if we crash before serializing.
	ForceResumeStateUpdatesToDB bool

	// The verifier to use during the run. Valid choices are:
	// ChecksumTable
	// Iterative
	// NoVerification
	//
	// If it is left blank, the Verifier member variable on the Ferry will be
	// used. If that member variable is nil, no verification will be done.
	VerifierType string

	// Only useful if VerifierType == Iterative.
	// This specifies the configurations to the IterativeVerifier.
	//
	// This option is in the process of being deprecated.
	IterativeVerifierConfig IterativeVerifierConfig

	// Only useful if VerifierType == Inline.
	// This specifies the configurations to the InlineVerifierConfig.
	InlineVerifierConfig InlineVerifierConfig

	// For old versions mysql<5.6.2, MariaDB<10.1.6 which has no related var
	// Make sure you have binlog_row_image=FULL when turning on this
	SkipBinlogRowImageCheck bool

	// This config is necessary for inline verification for a special case of
	// Ghostferry:
	//
	// - If you are copying a table where the data is already partially on the
	//   target through some other means.
	//   - Specifically, the VerifierPaginationKey of this row on both the source and the target are
	//     the same. Thus, INSERT IGNORE will skip copying this row, leaving the
	//     data on the target unchanged.
	//   - If the data on the target is already identical to the source, then
	//     verification will pass and all is well.
	// - However, if this data is compressed with a non-determinstic algorithm
	//   such as snappy, the compressed blob may not be equal even when the
	//   uncompressed data is equal.
	// - This column signals to the InlineVerifier that it needs to decompress
	//   the data to compare identity.
	//
	// Note: a similar option exists in IterativeVerifier. However, the
	// IterativeVerifier is being deprecated and this will be the correct place
	// to specify it if you don't need the IterativeVerifier.
	CompressedColumnsForVerification ColumnCompressionConfig

	// This config is also for inline verification for the same special case of
	// Ghostferry as documented with the CompressedColumnsForVerification option:
	//
	// - If you're copying a table where the data is partially already on the
	//   the target through some other means.
	// - A difference in a particular column could be acceptable.
	//   - An example would be a table with a data field and a created_at field.
	//     Maybe the created_at field is not important for data integrity as long
	//     as the data field is correct.
	// - Putting the column in this config will cause the InlineVerifier to skip
	//   this column for verification.
	IgnoredColumnsForVerification ColumnIgnoreConfig

	// Ghostferry requires a single numeric column to paginate over tables. Inferring that column is done in the following exact order:
	// 1. Find the table in the FullCopyTables list and perform non-paginated copies (only reasonable for small tables).
	// 2. Use the PerTable pagination column, if configured for a table. Fail if we cannot find this column in the table.
	// 3. Use the table's primary key column as the pagination column. Fail if the primary key is not numeric or is a composite key without a FallbackColumn specified.
	// 4. Use the FallbackColumn pagination column, if configured. Fail if we cannot find this column in the table.
	CascadingPaginationColumnConfig *CascadingPaginationColumnConfig
}

type ControlServer struct {
	F        *Ferry
	Verifier Verifier
	Addr     string
	Basedir  string
	// contains filtered or unexported fields
}

type CopyFilter interface {
	// BuildSelect is used to set up the query used for batch data copying,
	// allowing for restricting copying to a subset of data. Returning an error
	// here will cause the query to be retried, until the retry limit is
	// reached, at which point the ferry will be aborted. BuildSelect is passed
	// the columns to be selected, table being copied, the last primary key value
	// from the previous batch, the batch size, and whether we iterate in
	// descending order. Call DefaultBuildSelect to generate the default query,
	// which may be used as a starting point.
	BuildSelect([]string, *TableSchema, *PaginationKeyData, uint64, bool) (sq.SelectBuilder, error)

	// ApplicableEvent is used to filter events for rows that have been
	// filtered in ConstrainSelect. ApplicableEvent should return true if the
	// event is for a row that would be selected by ConstrainSelect, and false
	// otherwise.
	// Returning an error here will cause the ferry to be aborted.
	ApplicableDMLEvent(DMLEvent) (bool, error)
}

type CountMetric struct {
	MetricBase
	Value int64
}

type CursorConfig struct {
	DB        *sql.DB
	Throttler Throttler

	ColumnsToSelect []string
	BuildSelect     func([]string, *TableSchema, *PaginationKeyData, uint64, bool) (squirrel.SelectBuilder, error)
	BatchSize       uint64
	ReadRetries     int

	IterateInDescendingOrder bool
}

type DDLEvent interface {
	DXLEvent
	SqlCommand() string
}

type DMLEvent interface {
	DXLEvent
	TableSchema() *TableSchema
	OldValues() RowData
	NewValues() RowData
	VerifierPaginationKey() (uint64, error)
}

type DMLEventBase struct {
	*DXLEventBase
	// contains filtered or unexported fields
}

type DXLEvent interface {
	Database() string
	Table() string
	AsSQLString(string, string) (string, error)
	BinlogPosition() BinlogPosition
	EventTime() time.Time
	IsAutoTransaction() bool
}

type DXLEventBase struct {
	// contains filtered or unexported fields
}

type DXLEventCallback interface {
	Notify() error
}

type DXLEventWrapper struct {
	DXLEvent
	*ReplicationEvent
	PostApplyCallback DXLEventCallback
}

type DataIterator struct {
	DB                *sql.DB
	Concurrency       int
	SelectFingerprint bool

	ErrorHandler ErrorHandler
	CursorConfig *CursorConfig
	StateTracker *StateTracker
	// contains filtered or unexported fields
}

type DataRowBatch struct {
	// contains filtered or unexported fields
}

type DatabaseConfig struct {
	Host      string
	Port      uint16
	User      string
	Pass      string
	Collation string
	Params    map[string]string
	// SQL query comments to differentiate Ghostferry's binlog events
	// Optional: defaults to empty string (no comments)
	Marginalia string

	TLS *TLSConfig
}

type ErrorHandler interface {
	// Usually called from Fatal. When called from Fatal, if this method returns
	// true, Fatal should panic, otherwise it should not.
	ReportError(from string, err error)
	Fatal(from string, err error)
}

type Ferry struct {
	*Config

	SourceDB *sql.DB
	TargetDB *sql.DB

	BinlogStreamer *BinlogStreamer
	BinlogWriter   *BinlogWriter

	DataIterator *DataIterator
	BatchWriter  *BatchWriter

	StateTracker                       *StateTracker
	ErrorHandler                       ErrorHandler
	MigrationThrottler                 Throttler
	ReplicationThrottler               Throttler
	WaitUntilReplicaIsCaughtUpToMaster *WaitUntilReplicaIsCaughtUpToMaster

	// This can be specified by the caller. If specified, do not specify
	// VerifierType in Config (or as an empty string) or an error will be
	// returned in Initialize.
	//
	// If VerifierType is specified and this is nil on Ferry initialization, a
	// Verifier will be created by Initialize. If an IterativeVerifier is to be
	// created, IterativeVerifierConfig will be used to create the verifier.
	Verifier Verifier

	Tables TableSchemaCache

	StartTime    time.Time
	DoneTime     time.Time
	OverallState string
	// contains filtered or unexported fields
}

type FinalizeTableCopyBatch struct {
	// contains filtered or unexported fields
}

type FullTableCursor struct {
	DB          *sql.DB
	Table       *TableSchema
	BatchSize   uint64
	ReadRetries int
	// contains filtered or unexported fields
}

type GaugeMetric struct {
	MetricBase
	Value float64
}

type HTTPCallback struct {
	URI     string
	Payload string
}

type IncompleteVerificationError struct{}

type InlineVerifier struct {
	SourceDB                   *sql.DB
	TargetDB                   *sql.DB
	DatabaseRewrites           map[string]string
	TableRewrites              map[string]string
	CopyFilter                 CopyFilter
	TableSchemaCache           TableSchemaCache
	BatchSize                  int
	VerifyBinlogEventsInterval time.Duration
	MaxExpectedDowntime        time.Duration

	StateTracker *StateTracker
	ErrorHandler ErrorHandler
	// contains filtered or unexported fields
}

type InlineVerifierConfig struct {
	// The maximum expected downtime during cutover, in the format of
	// time.ParseDuration. If nothing is specified, the InlineVerifier will not
	// try to estimate the downtime and will always allow cutover.
	MaxExpectedDowntime string

	// The interval at which the periodic binlog reverification occurs, in the
	// format of time.ParseDuration. Default: 1s.
	VerifyBinlogEventsInterval string
	// contains filtered or unexported fields
}

type InsertRowBatch interface {
	RowBatch
	Values() []RowData
	VerifierPaginationKey(int) (uint64, error)
	Fingerprints() map[uint64][]byte
}

type IterativeVerifier struct {
	CompressionVerifier *CompressionVerifier
	CursorConfig        *CursorConfig
	BinlogStreamer      *BinlogStreamer
	TableSchemaCache    TableSchemaCache
	SourceDB            *sql.DB
	TargetDB            *sql.DB

	Tables              []*TableSchema
	IgnoredTables       []string
	IgnoredColumns      map[string]map[string]struct{}
	DatabaseRewrites    map[string]string
	TableRewrites       map[string]string
	CopyFilter          CopyFilter
	Concurrency         int
	MaxExpectedDowntime time.Duration
	// contains filtered or unexported fields
}

type IterativeVerifierConfig struct {
	// List of tables that should be ignored by the IterativeVerifier.
	IgnoredTables []string

	// List of columns that should be ignored by the IterativeVerifier.
	// This is in the format of table_name -> [list of column names]
	IgnoredColumns map[string][]string

	// The number of concurrent verifiers. Note that a single table can only be
	// assigned to one goroutine and currently multiple goroutines per table
	// is not supported.
	Concurrency int

	// The maximum expected downtime during cutover, in the format of
	// time.ParseDuration.
	MaxExpectedDowntime string

	// Map of the table and column identifying the compression type
	// (if any) of the column. This is used during verification to ensure
	// the data was successfully copied as some compression algorithms can
	// output different compressed data with the same input data.
	//
	// The data structure is a map of table names to a map of column names
	// to the compression algorithm.
	// ex: {books: {contents: snappy}}
	//
	// Currently supported compression algorithms are:
	//	1. Snappy (https://google.github.io/snappy/) as "SNAPPY"
	//
	// Optional: defaults to empty map/no compression
	//
	// Note that the IterativeVerifier is in the process of being deprecated.
	// If this is specified, ColumnCompressionConfig should also be filled out in
	// the main Config.
	TableColumnCompression TableColumnCompressionConfig
}

type LagThrottler struct {
	ThrottlerBase
	PauserThrottler

	DB *sql.DB
	// contains filtered or unexported fields
}

type LagThrottlerConfig struct {
	Connection     *DatabaseConfig
	MaxLag         int
	Query          string
	UpdateInterval string
}

type MetricBase struct {
	Key        string
	Tags       []MetricTag
	SampleRate float64
}

type MetricTag struct {
	Name  string
	Value string
}

type Metrics struct {
	Prefix      string
	DefaultTags []MetricTag
	Sink        chan interface{}
	// contains filtered or unexported fields
}

type PaginatedCursor struct {
	CursorConfig

	Table            *TableSchema
	MaxPaginationKey *PaginationKeyData
	RowLock          bool
	// contains filtered or unexported fields
}

type PaginationKey struct {
	// The sorted list of columns
	Columns []*schema.TableColumn

	// The sorted indices of the columns as they appear in the table
	ColumnIndices []int

	// Optional index of the column that we consider most indicative of
	// progress. Such an entry may not exist and can be set to -1 to explicitly
	// indicating that it does not exist.
	// Used only for estimating the position of a particular value within the
	// range of the pagination
	MostSignificantColumnIndex int
}

type PaginationKeyData struct {
	// The Values is the subset of column values of a full row that makes up
	// the pagination key. The list is stored in the same way as the pagination
	// key column itself
	Values RowData
	// contains filtered or unexported fields
}

type PaginationKeyPositionLog struct {
	Position uint64
	At       time.Time
}

type PanicErrorHandler struct {
	Ferry             *Ferry
	ErrorCallback     HTTPCallback
	DumpState         bool
	DumpStateFilename string
	// contains filtered or unexported fields
}

type PauserThrottler struct {
	ThrottlerBase
	// contains filtered or unexported fields
}

type Progress struct {
	// Possible values are defined in ferry.go
	// Shows what the ferry is currently doing in one word.
	CurrentState string

	// The Payload field of the ProgressCallback config will be copied to here
	// verbatim.
	// Example usecase: you can be sending all the status to some aggregation
	// server and you want some sort of custom identification with this field.
	CustomPayload string

	Tables                  map[string]TableProgress
	LastSuccessfulBinlogPos mysql.Position
	BinlogStreamerLag       float64 // seconds
	Throttled               bool

	// The behaviour of Ghostferry varies with respect to the VerifierType.
	// For example: a long cutover is OK if
	VerifierType string

	// These are some variables that are only filled when CurrentState == done.
	FinalBinlogPos mysql.Position

	// A best estimate on the speed at which the copying is taking place. If
	// there are large gaps in the VerifierPaginationKey space, this probably will be inaccurate.
	PaginationKeysPerSecond uint64
	ETA                     float64 // seconds
	TimeTaken               float64 // seconds
}

type QualifiedTableName struct {
	SchemaName string
	TableName  string
}

type QueryAnalyzer struct {
	// contains filtered or unexported fields
}

type ReloadTableSchemasCallback struct {
	*BinlogWriter
	TableStructuresToReload []*QualifiedTableName
}

type ReplicatedMasterPositionFetcher interface {
	Current(*sql.DB) (mysql.Position, error)
}

type ReplicatedMasterPositionViaCustomQuery struct {
	// The custom query executing should return a single row with two values:
	// the string file and the integer position. For pt-heartbeat, this query
	// would be:
	//
	// "SELECT file, position FROM meta.ptheartbeat WHERE server_id = %d" % serverId
	//
	// where serverId is the master server id, and meta.ptheartbeat is the table
	// where pt-heartbeat writes to.
	//
	// For pt-heartbeat in particular, you should not use the
	// relay_master_log_file and exec_master_log_pos of the DB being replicated
	// as these values are not the master binlog positions.
	Query string
}

type ReplicationEvent struct {
	BinlogPosition BinlogPosition
	BinlogEvent    *replication.BinlogEvent
	EventTime      time.Time
}

type ReverifyBatch struct {
	PaginationKeys []uint64
	Table          TableIdentifier
}

type ReverifyEntry struct {
	PaginationKey uint64
	Table         *TableSchema
}

type ReverifyStore struct {
	MapStore map[TableIdentifier]map[uint64]struct{}

	BatchStore         []ReverifyBatch
	RowCount           uint64
	EmitLogPerRowCount uint64
	// contains filtered or unexported fields
}

type RowBatch interface {
	TableSchema() *TableSchema
	AsSQLQuery(schemaName, tableName string) (string, []interface{}, error)
	Size() int
	IsTableComplete() bool
}

type RowData []interface{}

type SchemaEvent struct {
	// The SQL statement of the event as returned by the SQL statement parser
	SchemaStatement string
	// Does this event modify the structure/schema of the DB? ALTER or CREATE table statements alter the schema,
	// but TRUNCATE does not. RENAME statements also alter the structure of which tables are available, and are
	// thus also considered schema changes
	IsSchemaChange bool
	// "affected" is always the table on which an event operates on (created, deleted, truncated, altered, etc.)
	// For the corner-case of a renamed table, it refers to the original table.
	// The idea is to have one field that exposes what tables existed previously and that are affected by an
	// it is *NOT* the deleted table
	AffectedTable *QualifiedTableName
	// the created table as part of a create/rename operation. This can overlap with "affected" tables
	CreatedTable *QualifiedTableName
	// the deleted table as part of a delete/rename operation. This can overlap with "affected" tables
	DeletedTable *QualifiedTableName
}

type SerializableState struct {
	GhostferryVersion         string
	LastKnownTableSchemaCache TableSchemaCache

	LastSuccessfulPaginationKeys              map[string]*PaginationKeyData
	CompletedTables                           map[string]bool
	LastWrittenBinlogPosition                 BinlogPosition
	LastStoredBinlogPositionForInlineVerifier BinlogPosition
	BinlogVerifyStore                         BinlogVerifySerializedStore
}

type SqlDBWithFakeRollback struct {
	*sql.DB
	// contains filtered or unexported fields
}

type SqlPreparer interface {
	Prepare(string) (*sqlorig.Stmt, error)
}

type SqlPreparerAndRollbacker interface {
	SqlPreparer
	Query(query string, args ...interface{}) (*sqlorig.Rows, error)
	Rollback() error
}

type StateTracker struct {
	BinlogRWMutex *sync.RWMutex
	CopyRWMutex   *sync.RWMutex
	// contains filtered or unexported fields
}

type StatusDeprecated struct {
	GhostferryVersion string

	SourceHostPort string
	TargetHostPort string

	OverallState            string
	StartTime               time.Time
	CurrentTime             time.Time
	TimeTaken               time.Duration
	ETA                     time.Duration
	BinlogStreamerLag       time.Duration
	PaginationKeysPerSecond uint64

	BinlogWriterState      BinlogWriterState
	BinlogWriterStateTs    time.Time
	BinlogWriterStateTsAge time.Duration

	AutomaticCutover            bool
	BinlogStreamerStopRequested bool
	LastSuccessfulBinlogPos     mysql.Position
	TargetBinlogPos             mysql.Position

	// for backwards compatibility, a union of the detailed stats below
	Throttled            bool
	MigrationThrottled   bool
	ReplicationThrottled bool

	CompletedTableCount int
	TotalTableCount     int
	TableStatuses       []*TableStatusDeprecated
	AllTableNames       []string
	AllDatabaseNames    []string

	VerifierSupport     bool
	VerifierAvailable   bool
	VerificationStarted bool
	VerificationDone    bool
	VerificationResult  VerificationResult
	VerificationErr     error
}

type StmtCache struct {
	// contains filtered or unexported fields
}

type TLSConfig struct {
	CertPath   string
	ServerName string
	// contains filtered or unexported fields
}

type TableColumnCompressionConfig map[string]map[string]string

type TableFilter interface {
	ApplicableTables([]*TableSchema) ([]*TableSchema, error)
	ApplicableDatabases([]string) ([]string, error)
}

type TableForeignKeys map[QualifiedTableName]bool

type TableIdentifier struct {
	SchemaName string
	TableName  string
}

type TableProgress struct {
	LastSuccessfulPaginationKey string
	TargetPaginationKey         string
	CurrentAction               string // Possible values are defined via the constants TableAction*
}

type TableSchema struct {
	*schema.Table

	CompressedColumnsForVerification map[string]string   // Map of column name => compression type
	IgnoredColumnsForVerification    map[string]struct{} // Set of column name
	PaginationKey                    *PaginationKey
	// contains filtered or unexported fields
}

type TableSchemaCache map[string]*TableSchema

type TableStatusDeprecated struct {
	TableName                   string
	PaginationKeyName           string
	Status                      string
	LastSuccessfulPaginationKey string
	TargetPaginationKey         string
}

type Throttler interface {
	Throttled() bool
	Disabled() bool
	SetDisabled(bool)
	SetPaused(bool)
	Run(context.Context) error
}

type ThrottlerBase struct {
	// contains filtered or unexported fields
}

type TimerMetric struct {
	MetricBase
	Value time.Duration
}

type TruncateTableBatch struct {
	// contains filtered or unexported fields
}

type UnsupportedCompressionError struct {
	// contains filtered or unexported fields
}

type VerificationResult struct {
	DataCorrect     bool
	Message         string
	IncorrectTables []string
}

type VerificationResultAndStatus struct {
	VerificationResult

	StartTime time.Time
	DoneTime  time.Time
}

type Verifier interface {
	// If the Verifier needs to do anything immediately after the DataIterator
	// finishes copying data and before cutover occurs, implement this function.
	VerifyBeforeCutover() error

	// This is called during cutover and should give the result of the
	// verification.
	VerifyDuringCutover() (VerificationResult, error)

	// Start the verifier in the background during the cutover phase.
	// Traditionally, this is called from within the ControlServer.
	//
	// This method maybe called multiple times and it's up to the verifier
	// to decide if it is possible to re-run the verification.
	StartInBackground() error

	// Wait for the verifier until it finishes verification after it was
	// started with the StartInBackground.
	//
	// A verification is "done" when it verified the dbs (either
	// correct or incorrect) OR when it experiences an error.
	Wait()

	// Returns the result and the status of the verification.
	// To check the status, call IsStarted() and IsDone() on
	// VerificationResultAndStatus.
	//
	// If the verification has been completed successfully (without errors) and
	// the data checks out to be "correct", the result will be
	// VerificationResult{true, ""}, with error = nil.
	// Otherwise, the result will be VerificationResult{false, "message"}, with
	// error = nil.
	//
	// If the verification is "done" but experienced an error during the check,
	// the result will be VerificationResult{}, with err = yourErr.
	Result() (VerificationResultAndStatus, error)
}

type WaitUntilReplicaIsCaughtUpToMaster struct {
	MasterDB                        *sql.DB
	ReplicatedMasterPositionFetcher ReplicatedMasterPositionFetcher
	Timeout                         time.Duration

	ReplicaDB *sql.DB
	// contains filtered or unexported fields
}

type WorkerPool struct {
	Concurrency int
	Process     func(int) (interface{}, error)
}