sqlplugin

type ActivityInfoMapsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	ScheduleID  *int64
}

type ActivityInfoMapsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	ScheduleID   int64
	Data         []byte
	DataEncoding string
}

type ActivityInfoMapsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type AdminCRUD interface {
	CreateSchemaVersionTables() error
	ReadSchemaVersion(database string) (string, error)
	UpdateSchemaVersion(database string, newVersion string, minCompatibleVersion string) error
	WriteSchemaUpdateLog(oldVersion string, newVersion string, manifestMD5 string, desc string) error
	ListTables(database string) ([]string, error)
	DropTable(table string) error
	DropAllTables(database string) error
	CreateDatabase(database string) error
	DropDatabase(database string) error
	Exec(stmt string, args ...interface{}) error
}

type AdminDB interface {
	AdminCRUD
	PluginName() string
	Close() error
}

type BufferedEventsFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type BufferedEventsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	Data         []byte
	DataEncoding string
}

type ChildExecutionInfoMapsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	InitiatedID *int64
}

type ChildExecutionInfoMapsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	InitiatedID  int64
	Data         []byte
	DataEncoding string
}

type ChildExecutionInfoMapsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type ClusterMembershipFilter struct {
	RPCAddressEquals    string
	HostIDEquals        []byte
	HostIDGreaterThan   []byte
	RoleEquals          persistence.ServiceType
	LastHeartbeatAfter  time.Time
	RecordExpiryAfter   time.Time
	SessionStartedAfter time.Time
	MaxRecordCount      int
}

type ClusterMembershipRow struct {
	Role           persistence.ServiceType
	HostID         []byte
	RPCAddress     string
	RPCPort        uint16
	SessionStart   time.Time
	LastHeartbeat  time.Time
	RecordExpiry   time.Time
	InsertionOrder uint64
}

type ClusterMetadata interface {
	SaveClusterMetadata(row *ClusterMetadataRow) (sql.Result, error)
	GetClusterMetadata() (*ClusterMetadataRow, error)
	WriteLockGetClusterMetadata() (*ClusterMetadataRow, error)
	GetClusterMembers(filter *ClusterMembershipFilter) ([]ClusterMembershipRow, error)
	UpsertClusterMembership(row *ClusterMembershipRow) (sql.Result, error)
	PruneClusterMembership(filter *PruneClusterMembershipFilter) (sql.Result, error)
}

type ClusterMetadataRow struct {
	Data         []byte
	DataEncoding string
	Version      int64
	// TODO(vitarb): immutable metadata is needed for backward compatibility only, remove after 1.1 release.
	ImmutableData         []byte
	ImmutableDataEncoding string
}

type Conn interface {
	Exec(query string, args ...interface{}) (sql.Result, error)
	NamedExec(query string, arg interface{}) (sql.Result, error)
	Get(dest interface{}, query string, args ...interface{}) error
	Select(dest interface{}, query string, args ...interface{}) error
}

type CurrentExecutionsFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type CurrentExecutionsRow struct {
	ShardID          int32
	NamespaceID      primitives.UUID
	WorkflowID       string
	RunID            primitives.UUID
	CreateRequestID  string
	StartVersion     int64
	LastWriteVersion int64
	State            enumsspb.WorkflowExecutionState
	Status           enumspb.WorkflowExecutionStatus
}

type DB interface {
	TableCRUD

	BeginTx() (Tx, error)
	PluginName() string
	IsDupEntryError(err error) bool
	Close() error
}

type ExecutionsFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type ExecutionsRow struct {
	ShardID          int32
	NamespaceID      primitives.UUID
	WorkflowID       string
	RunID            primitives.UUID
	NextEventID      int64
	LastWriteVersion int64
	Data             []byte
	DataEncoding     string
	State            []byte
	StateEncoding    string
}

type HistoryExecution interface {
	InsertIntoExecutions(row *ExecutionsRow) (sql.Result, error)
	UpdateExecutions(row *ExecutionsRow) (sql.Result, error)
	SelectFromExecutions(filter ExecutionsFilter) (*ExecutionsRow, error)
	DeleteFromExecutions(filter ExecutionsFilter) (sql.Result, error)
	ReadLockExecutions(filter ExecutionsFilter) (int64, error)
	WriteLockExecutions(filter ExecutionsFilter) (int64, error)

	LockCurrentExecutionsJoinExecutions(filter CurrentExecutionsFilter) ([]CurrentExecutionsRow, error)

	InsertIntoCurrentExecutions(row *CurrentExecutionsRow) (sql.Result, error)
	UpdateCurrentExecutions(row *CurrentExecutionsRow) (sql.Result, error)
	// SelectFromCurrentExecutions returns one or more rows from current_executions table
	// Required params - {shardID, namespaceID, workflowID}
	SelectFromCurrentExecutions(filter CurrentExecutionsFilter) (*CurrentExecutionsRow, error)
	// DeleteFromCurrentExecutions deletes a single row that matches the filter criteria
	// If a row exist, that row will be deleted and this method will return success
	// If there is no row matching the filter criteria, this method will still return success
	// Callers can check the output of Result.RowsAffected() to see if a row was deleted or not
	// Required params - {shardID, namespaceID, workflowID, runID}
	DeleteFromCurrentExecutions(filter CurrentExecutionsFilter) (sql.Result, error)
	LockCurrentExecutions(filter CurrentExecutionsFilter) (*CurrentExecutionsRow, error)
}

type HistoryExecutionActivity interface {
	ReplaceIntoActivityInfoMaps(rows []ActivityInfoMapsRow) (sql.Result, error)
	// SelectFromActivityInfoMaps returns one or more rows from activity_info_maps
	SelectFromActivityInfoMaps(filter ActivityInfoMapsSelectFilter) ([]ActivityInfoMapsRow, error)
	// DeleteFromActivityInfoMaps deletes a row from activity_info_maps table
	// Required filter params
	// - single row delete - {shardID, namespaceID, workflowID, runID, scheduleID}
	// - range delete - {shardID, namespaceID, workflowID, runID}
	DeleteFromActivityInfoMaps(filter ActivityInfoMapsDeleteFilter) (sql.Result, error)
}

type HistoryExecutionBuffer interface {
	InsertIntoBufferedEvents(rows []BufferedEventsRow) (sql.Result, error)
	SelectFromBufferedEvents(filter BufferedEventsFilter) ([]BufferedEventsRow, error)
	DeleteFromBufferedEvents(filter BufferedEventsFilter) (sql.Result, error)
}

type HistoryExecutionChildWorkflow interface {
	ReplaceIntoChildExecutionInfoMaps(rows []ChildExecutionInfoMapsRow) (sql.Result, error)
	// SelectFromChildExecutionInfoMaps returns one or more rows form child_execution_info_maps table
	SelectFromChildExecutionInfoMaps(filter ChildExecutionInfoMapsSelectFilter) ([]ChildExecutionInfoMapsRow, error)
	// DeleteFromChildExecutionInfoMaps deletes one or more rows from child_execution_info_maps
	// Required filter params
	// - single row - {shardID, namespaceID, workflowID, runID, initiatedID}
	// - multiple rows - {shardID, namespaceID, workflowID, runID}
	DeleteFromChildExecutionInfoMaps(filter ChildExecutionInfoMapsDeleteFilter) (sql.Result, error)
}

type HistoryExecutionRequestCancel interface {
	ReplaceIntoRequestCancelInfoMaps(rows []RequestCancelInfoMapsRow) (sql.Result, error)
	// SelectFromRequestCancelInfoMaps returns one or more rows form request_cancel_info_maps table
	SelectFromRequestCancelInfoMaps(filter RequestCancelInfoMapsSelectFilter) ([]RequestCancelInfoMapsRow, error)
	// DeleteFromRequestCancelInfoMaps deletes one or more rows from request_cancel_info_maps
	// Required filter params
	// - single row - {shardID, namespaceID, workflowID, runID, initiatedID}
	// - multiple rows - {shardID, namespaceID, workflowID, runID}
	DeleteFromRequestCancelInfoMaps(filter RequestCancelInfoMapsDeleteFilter) (sql.Result, error)
}

type HistoryExecutionSignal interface {
	ReplaceIntoSignalInfoMaps(rows []SignalInfoMapsRow) (sql.Result, error)
	// SelectFromSignalInfoMaps returns one or more rows form signal_info_maps table
	SelectFromSignalInfoMaps(filter SignalInfoMapsSelectFilter) ([]SignalInfoMapsRow, error)
	// DeleteFromSignalInfoMaps deletes one or more rows from signal_info_maps table
	// Required filter params
	// - single row - {shardID, namespaceID, workflowID, runID, initiatedID}
	// - multiple rows - {shardID, namespaceID, workflowID, runID}
	DeleteFromSignalInfoMaps(filter SignalInfoMapsDeleteFilter) (sql.Result, error)
}

type HistoryExecutionSignalRequest interface {
	ReplaceIntoSignalsRequestedSets(rows []SignalsRequestedSetsRow) (sql.Result, error)
	// SelectFromSignalInfoMaps returns one or more rows form signals_requested_sets table
	SelectFromSignalsRequestedSets(filter SignalsRequestedSetsSelectFilter) ([]SignalsRequestedSetsRow, error)
	// DeleteFromSignalsRequestedSets deletes one or more rows from signals_requested_sets
	// Required filter params
	// - single row - {shardID, namespaceID, workflowID, runID, signalID}
	// - multiple rows - {shardID, namespaceID, workflowID, runID}
	DeleteFromSignalsRequestedSets(filter SignalsRequestedSetsDeleteFilter) (sql.Result, error)
}

type HistoryExecutionTimer interface {
	ReplaceIntoTimerInfoMaps(rows []TimerInfoMapsRow) (sql.Result, error)
	// SelectFromTimerInfoMaps returns one or more rows form timer_info_maps table
	SelectFromTimerInfoMaps(filter TimerInfoMapsSelectFilter) ([]TimerInfoMapsRow, error)
	// DeleteFromTimerInfoMaps deletes one or more rows from timer_info_maps
	// Required filter params
	// - single row - {shardID, namespaceID, workflowID, runID, timerID}
	// - multiple rows - {shardID, namespaceID, workflowID, runID}
	DeleteFromTimerInfoMaps(filter TimerInfoMapsDeleteFilter) (sql.Result, error)
}

type HistoryNode interface {
	InsertIntoHistoryNode(row *HistoryNodeRow) (sql.Result, error)
	SelectFromHistoryNode(filter HistoryNodeSelectFilter) ([]HistoryNodeRow, error)
	DeleteFromHistoryNode(filter HistoryNodeDeleteFilter) (sql.Result, error)
}

type HistoryNodeDeleteFilter struct {
	ShardID   int32
	TreeID    primitives.UUID
	BranchID  primitives.UUID
	MinNodeID int64
}

type HistoryNodeRow struct {
	ShardID      int32
	TreeID       primitives.UUID
	BranchID     primitives.UUID
	NodeID       int64
	TxnID        int64
	Data         []byte
	DataEncoding string
}

type HistoryNodeSelectFilter struct {
	ShardID   int32
	TreeID    primitives.UUID
	BranchID  primitives.UUID
	MinNodeID int64
	MaxNodeID int64
	PageSize  int
}

type HistoryReplicationDLQTask interface {
	// InsertIntoReplicationDLQTasks puts the replication task into DLQ
	InsertIntoReplicationDLQTasks(row []ReplicationDLQTasksRow) (sql.Result, error)
	// SelectFromReplicationDLQTasks returns one or more rows from replication_tasks_dlq table
	SelectFromReplicationDLQTasks(filter ReplicationDLQTasksFilter) ([]ReplicationDLQTasksRow, error)
	// RangeSelectFromReplicationDLQTasks returns one or more rows from replication_tasks_dlq table
	RangeSelectFromReplicationDLQTasks(filter ReplicationDLQTasksRangeFilter) ([]ReplicationDLQTasksRow, error)
	// DeleteFromReplicationDLQTasks deletes one row from replication_tasks_dlq table
	DeleteFromReplicationDLQTasks(filter ReplicationDLQTasksFilter) (sql.Result, error)
	// RangeDeleteFromReplicationDLQTasks deletes one or more rows from replication_tasks_dlq table
	//  ReplicationDLQTasksRangeFilter - {PageSize} will be ignored
	RangeDeleteFromReplicationDLQTasks(filter ReplicationDLQTasksRangeFilter) (sql.Result, error)
}

type HistoryReplicationTask interface {
	InsertIntoReplicationTasks(rows []ReplicationTasksRow) (sql.Result, error)
	// SelectFromReplicationTasks returns one or more rows from replication_tasks table
	SelectFromReplicationTasks(filter ReplicationTasksFilter) ([]ReplicationTasksRow, error)
	// RangeSelectFromReplicationTasks returns one or more rows from replication_tasks table
	RangeSelectFromReplicationTasks(filter ReplicationTasksRangeFilter) ([]ReplicationTasksRow, error)
	// DeleteFromReplicationTasks deletes a row from replication_tasks table
	DeleteFromReplicationTasks(filter ReplicationTasksFilter) (sql.Result, error)
	// DeleteFromReplicationTasks deletes multi rows from replication_tasks table
	//  ReplicationTasksRangeFilter - {PageSize} will be ignored
	RangeDeleteFromReplicationTasks(filter ReplicationTasksRangeFilter) (sql.Result, error)
}

type HistoryShard interface {
	InsertIntoShards(rows *ShardsRow) (sql.Result, error)
	UpdateShards(row *ShardsRow) (sql.Result, error)
	SelectFromShards(filter ShardsFilter) (*ShardsRow, error)
	ReadLockShards(filter ShardsFilter) (int64, error)
	WriteLockShards(filter ShardsFilter) (int64, error)
}

type HistoryTimerTask interface {
	InsertIntoTimerTasks(rows []TimerTasksRow) (sql.Result, error)
	// SelectFromTimerTasks returns one or more rows from timer_tasks table
	SelectFromTimerTasks(filter TimerTasksFilter) ([]TimerTasksRow, error)
	// RangeSelectFromTimerTasks returns one or more rows from timer_tasks table
	RangeSelectFromTimerTasks(filter TimerTasksRangeFilter) ([]TimerTasksRow, error)
	// DeleteFromTimerTasks deletes one or more rows from timer_tasks table
	DeleteFromTimerTasks(filter TimerTasksFilter) (sql.Result, error)
	// RangeDeleteFromTimerTasks deletes one or more rows from timer_tasks table
	//  TimerTasksRangeFilter - {TaskID, PageSize} will be ignored
	RangeDeleteFromTimerTasks(filter TimerTasksRangeFilter) (sql.Result, error)
}

type HistoryTransferTask interface {
	InsertIntoTransferTasks(rows []TransferTasksRow) (sql.Result, error)
	// SelectFromTransferTasks returns rows that match filter criteria from transfer_tasks table.
	SelectFromTransferTasks(filter TransferTasksFilter) ([]TransferTasksRow, error)
	// RangeSelectFromTransferTasks returns rows that match filter criteria from transfer_tasks table.
	RangeSelectFromTransferTasks(filter TransferTasksRangeFilter) ([]TransferTasksRow, error)
	// DeleteFromTransferTasks deletes one rows from transfer_tasks table.
	DeleteFromTransferTasks(filter TransferTasksFilter) (sql.Result, error)
	// RangeDeleteFromTransferTasks deletes one or more rows from transfer_tasks table.
	RangeDeleteFromTransferTasks(filter TransferTasksRangeFilter) (sql.Result, error)
}

type HistoryTree interface {
	InsertIntoHistoryTree(row *HistoryTreeRow) (sql.Result, error)
	SelectFromHistoryTree(filter HistoryTreeSelectFilter) ([]HistoryTreeRow, error)
	DeleteFromHistoryTree(filter HistoryTreeDeleteFilter) (sql.Result, error)
}

type HistoryTreeDeleteFilter struct {
	ShardID  int32
	TreeID   primitives.UUID
	BranchID primitives.UUID
}

type HistoryTreeRow struct {
	ShardID      int32
	TreeID       primitives.UUID
	BranchID     primitives.UUID
	Data         []byte
	DataEncoding string
}

type HistoryTreeSelectFilter struct {
	ShardID int32
	TreeID  primitives.UUID
}

type MatchingTask interface {
	InsertIntoTasks(rows []TasksRow) (sql.Result, error)
	// SelectFromTasks retrieves one or more rows from the tasks table
	// Required filter params - {namespaceID, taskqueueName, taskType, minTaskID, maxTaskID, pageSize}
	SelectFromTasks(filter *TasksFilter) ([]TasksRow, error)
	// DeleteFromTasks deletes a row from tasks table
	// Required filter params:
	//  to delete single row
	//     - {namespaceID, taskqueueName, taskType, taskID}
	//  to delete multiple rows
	//    - {namespaceID, taskqueueName, taskType, taskIDLessThanEquals, limit }
	//    - this will delete upto limit number of tasks less than or equal to the given task id
	DeleteFromTasks(filter *TasksFilter) (sql.Result, error)
}

type MatchingTaskQueue interface {
	InsertIntoTaskQueues(row *TaskQueuesRow) (sql.Result, error)
	ReplaceIntoTaskQueues(row *TaskQueuesRow) (sql.Result, error)
	UpdateTaskQueues(row *TaskQueuesRow) (sql.Result, error)
	// SelectFromTaskQueues returns one or more rows from task_queues table
	// Required Filter params:
	//  to read a single row: {shardID, namespaceID, name, taskType}
	//  to range read multiple rows: {shardID, namespaceIDGreaterThan, nameGreaterThan, taskTypeGreaterThan, pageSize}
	SelectFromTaskQueues(filter *TaskQueuesFilter) ([]TaskQueuesRow, error)
	DeleteFromTaskQueues(filter *TaskQueuesFilter) (sql.Result, error)
	LockTaskQueues(filter *TaskQueuesFilter) (int64, error)
}

type Namespace interface {
	InsertIntoNamespace(rows *NamespaceRow) (sql.Result, error)
	UpdateNamespace(row *NamespaceRow) (sql.Result, error)
	// SelectFromNamespace returns namespaces that match filter criteria. Either ID or
	// Name can be specified to filter results. If both are not specified, all rows
	// will be returned
	SelectFromNamespace(filter NamespaceFilter) ([]NamespaceRow, error)
	// DeleteNamespace deletes a single row. One of ID or Name MUST be specified
	DeleteFromNamespace(filter NamespaceFilter) (sql.Result, error)

	LockNamespaceMetadata() (*NamespaceMetadataRow, error)
	UpdateNamespaceMetadata(row *NamespaceMetadataRow) (sql.Result, error)
	SelectFromNamespaceMetadata() (*NamespaceMetadataRow, error)
}

type NamespaceFilter struct {
	ID            *primitives.UUID
	Name          *string
	GreaterThanID *primitives.UUID
	PageSize      *int
}

type NamespaceMetadataRow struct {
	NotificationVersion int64
}

type NamespaceRow struct {
	ID                  primitives.UUID
	Name                string
	Data                []byte
	DataEncoding        string
	IsGlobal            bool
	NotificationVersion int64
}

type Plugin interface {
	CreateDB(cfg *config.SQL) (DB, error)
	CreateAdminDB(cfg *config.SQL) (AdminDB, error)
}

type PruneClusterMembershipFilter struct {
	PruneRecordsBefore time.Time
	MaxRecordsAffected int
}

type Queue interface {
	InsertIntoQueue(row *QueueRow) (sql.Result, error)
	GetLastEnqueuedMessageIDForUpdate(queueType persistence.QueueType) (int64, error)
	GetMessagesFromQueue(queueType persistence.QueueType, lastMessageID int64, maxRows int) ([]QueueRow, error)
	GetMessagesBetween(queueType persistence.QueueType, firstMessageID int64, lastMessageID int64, maxRows int) ([]QueueRow, error)
	DeleteMessagesBefore(queueType persistence.QueueType, messageID int64) (sql.Result, error)
	RangeDeleteMessages(queueType persistence.QueueType, exclusiveBeginMessageID int64, inclusiveEndMessageID int64) (sql.Result, error)
	DeleteMessage(queueType persistence.QueueType, messageID int64) (sql.Result, error)
	InsertAckLevel(queueType persistence.QueueType, messageID int64, clusterName string) error
	UpdateAckLevels(queueType persistence.QueueType, clusterAckLevels map[string]int64) error
	GetAckLevels(queueType persistence.QueueType, forUpdate bool) (map[string]int64, error)
}

type QueueMetadataRow struct {
	QueueType persistence.QueueType
	Data      []byte
}

type QueueRow struct {
	QueueType      persistence.QueueType
	MessageID      int64
	MessagePayload []byte
}

type ReplicationDLQTasksFilter struct {
	ShardID           int32
	SourceClusterName string
	TaskID            int64
}

type ReplicationDLQTasksRangeFilter struct {
	ShardID           int32
	SourceClusterName string
	MinTaskID         int64
	MaxTaskID         int64
	PageSize          int
}

type ReplicationDLQTasksRow struct {
	SourceClusterName string
	ShardID           int32
	TaskID            int64
	Data              []byte
	DataEncoding      string
}

type ReplicationTasksFilter struct {
	ShardID int32
	TaskID  int64
}

type ReplicationTasksRangeFilter struct {
	ShardID   int32
	MinTaskID int64
	MaxTaskID int64
	PageSize  int
}

type ReplicationTasksRow struct {
	ShardID      int32
	TaskID       int64
	Data         []byte
	DataEncoding string
}

type RequestCancelInfoMapsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	InitiatedID *int64
}

type RequestCancelInfoMapsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	InitiatedID  int64
	Data         []byte
	DataEncoding string
}

type RequestCancelInfoMapsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type ShardsFilter struct {
	ShardID int32
}

type ShardsRow struct {
	ShardID      int32
	RangeID      int64
	Data         []byte
	DataEncoding string
}

type SignalInfoMapsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	InitiatedID *int64
}

type SignalInfoMapsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	InitiatedID  int64
	Data         []byte
	DataEncoding string
}

type SignalInfoMapsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type SignalsRequestedSetsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	SignalID    *string
}

type SignalsRequestedSetsRow struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	SignalID    string
}

type SignalsRequestedSetsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type TableCRUD interface {
	ClusterMetadata
	Namespace
	Visibility
	Queue

	MatchingTask
	MatchingTaskQueue

	HistoryNode
	HistoryTree

	HistoryShard

	HistoryExecution
	HistoryExecutionBuffer
	HistoryExecutionActivity
	HistoryExecutionChildWorkflow
	HistoryExecutionTimer
	HistoryExecutionRequestCancel
	HistoryExecutionSignal
	HistoryExecutionSignalRequest

	HistoryTransferTask
	HistoryTimerTask
	HistoryReplicationTask
	HistoryReplicationDLQTask
}

type TaskQueuesFilter struct {
	RangeHash                   uint32
	RangeHashGreaterThanEqualTo uint32
	RangeHashLessThanEqualTo    uint32
	TaskQueueID                 []byte
	TaskQueueIDGreaterThan      []byte
	RangeID                     *int64
	PageSize                    *int
}

type TaskQueuesRow struct {
	RangeHash    uint32
	TaskQueueID  []byte
	RangeID      int64
	Data         []byte
	DataEncoding string
}

type TasksFilter struct {
	RangeHash            uint32
	TaskQueueID          []byte
	TaskID               *int64
	MinTaskID            *int64
	MaxTaskID            *int64
	TaskIDLessThanEquals *int64
	Limit                *int
	PageSize             *int
}

type TasksRow struct {
	RangeHash    uint32
	TaskQueueID  []byte
	TaskID       int64
	Data         []byte
	DataEncoding string
}

type TimerInfoMapsDeleteFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
	TimerID     *string
}

type TimerInfoMapsRow struct {
	ShardID      int32
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	TimerID      string
	Data         []byte
	DataEncoding string
}

type TimerInfoMapsSelectFilter struct {
	ShardID     int32
	NamespaceID primitives.UUID
	WorkflowID  string
	RunID       primitives.UUID
}

type TimerTasksFilter struct {
	ShardID             int32
	TaskID              int64
	VisibilityTimestamp time.Time
}

type TimerTasksRangeFilter struct {
	ShardID                int32
	TaskID                 int64
	MinVisibilityTimestamp time.Time
	MaxVisibilityTimestamp time.Time
	PageSize               int
}

type TimerTasksRow struct {
	ShardID             int32
	VisibilityTimestamp time.Time
	TaskID              int64
	Data                []byte
	DataEncoding        string
}

type TransferTasksFilter struct {
	ShardID int32
	TaskID  int64
}

type TransferTasksRangeFilter struct {
	ShardID   int32
	MinTaskID int64
	MaxTaskID int64
}

type TransferTasksRow struct {
	ShardID      int32
	TaskID       int64
	Data         []byte
	DataEncoding string
}

type Tx interface {
	TableCRUD
	Commit() error
	Rollback() error
}

type Visibility interface {
	// InsertIntoVisibility inserts a row into visibility table. If a row already exist,
	// no changes will be made by this API
	InsertIntoVisibility(row *VisibilityRow) (sql.Result, error)
	// ReplaceIntoVisibility deletes old row (if it exist) and inserts new row into visibility table
	ReplaceIntoVisibility(row *VisibilityRow) (sql.Result, error)
	// SelectFromVisibility returns one or more rows from visibility table
	// Required filter params:
	// - getClosedWorkflowExecution - retrieves single row - {namespaceID, runID, closed=true}
	// - All other queries retrieve multiple rows (range):
	//   - MUST specify following required params:
	//     - namespaceID, minStartTime, maxStartTime, runID and pageSize where some or all of these may come from previous page token
	//   - OPTIONALLY specify one of following params
	//     - workflowID, workflowTypeName, status (along with closed=true)
	SelectFromVisibility(filter VisibilitySelectFilter) ([]VisibilityRow, error)
	DeleteFromVisibility(filter VisibilityDeleteFilter) (sql.Result, error)
}

type VisibilityDeleteFilter struct {
	NamespaceID string
	RunID       string
}

type VisibilityRow struct {
	NamespaceID      string
	RunID            string
	WorkflowTypeName string
	WorkflowID       string
	StartTime        time.Time
	ExecutionTime    time.Time
	Status           int32
	CloseTime        *time.Time
	HistoryLength    *int64
	Memo             []byte
	Encoding         string
}

type VisibilitySelectFilter struct {
	NamespaceID      string
	RunID            *string
	WorkflowID       *string
	WorkflowTypeName *string
	Status           int32
	MinTime          *time.Time
	MaxTime          *time.Time
	PageSize         *int
}