dmlsink

type Appender[E TableEvent] interface {
	// Append appends the event to buffer.
	Append(buffer []E, rows ...*model.RowChangedEvent) []E
}

type CallbackFunc func()

type CallbackableEvent[E TableEvent] struct {
	Event     E
	Callback  CallbackFunc
	SinkState *state.TableSinkState
}

type EventSink[E TableEvent] interface {
	// WriteEvents writes events to the sink.
	// This is an asynchronously and thread-safe method.
	WriteEvents(events ...*CallbackableEvent[E]) error

	// Scheme returns the sink scheme.
	Scheme() string

	// Close closes the sink. Can be called with `WriteEvents` concurrently.
	Close()
	// The EventSink meets internal errors and has been dead already.
	Dead() <-chan struct{}
}

type RowChangeCallbackableEvent = CallbackableEvent[*model.RowChangedEvent]

type RowChangeEventAppender struct{}

type TableEvent interface {
	// GetCommitTs returns the commit timestamp of the event.
	GetCommitTs() uint64
	// TrySplitAndSortUpdateEvent split the update to delete and insert if the unique key is updated
	TrySplitAndSortUpdateEvent(scheme string) error
}

type TxnCallbackableEvent = CallbackableEvent[*model.SingleTableTxn]

type TxnEventAppender struct {
	// TableSinkStartTs is the startTs of the table sink.
	TableSinkStartTs model.Ts
	// IgnoreStartTs indicates whether to ignore the startTs of the row.
	// This is used by consumer to keep compatibility with the old version.
	// Most of our protocols are ignoring the startTs of the row, so we
	// can not use the startTs to identify a transaction.
	IgnoreStartTs bool
}