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 AdminDB interface {
	PluginName() string
	Close() error
	// contains filtered or unexported methods
}

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 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 {
	BeginTx() (Tx, error)
	PluginName() string
	IsDupEntryError(err error) bool
	Close() error
	// contains filtered or unexported methods
}

type EventsFilter struct {
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	FirstEventID *int64
	NextEventID  *int64
	PageSize     *int
}

type EventsRow struct {
	NamespaceID  primitives.UUID
	WorkflowID   string
	RunID        primitives.UUID
	FirstEventID int64
	BatchVersion int64
	RangeID      int64
	TxID         int64
	Data         []byte
	DataEncoding string
}

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 HistoryReplicationTask interface {
	InsertIntoReplicationTasks(rows []ReplicationTasksRow) (sql.Result, error)
	// SelectFromReplicationTasks returns one or more rows from replication_tasks table
	// Required filter params - {shardID, minTaskID, maxTaskID, pageSize}
	SelectFromReplicationTasks(filter *ReplicationTasksFilter) ([]ReplicationTasksRow, error)
	// DeleteFromReplicationTasks deletes a row from replication_tasks table
	// Required filter params - {shardID, inclusiveEndTaskID}
	DeleteFromReplicationTasks(filter *ReplicationTasksFilter) (sql.Result, error)
	// DeleteFromReplicationTasks deletes multi rows from replication_tasks table
	// Required filter params - {shardID, inclusiveEndTaskID}
	RangeDeleteFromReplicationTasks(filter *ReplicationTasksFilter) (sql.Result, error)

	// InsertIntoReplicationTasksDLQ puts the replication task into DLQ
	InsertIntoReplicationTasksDLQ(row *ReplicationTaskDLQRow) (sql.Result, error)
	// SelectFromReplicationTasksDLQ returns one or more rows from replication_tasks_dlq table
	// Required filter params - {sourceClusterName, shardID, minTaskID, pageSize}
	SelectFromReplicationTasksDLQ(filter *ReplicationTasksDLQFilter) ([]ReplicationTasksRow, error)
	// DeleteMessageFromReplicationTasksDLQ deletes one row from replication_tasks_dlq table
	// Required filter params - {sourceClusterName, shardID, taskID}
	DeleteMessageFromReplicationTasksDLQ(filter *ReplicationTasksDLQFilter) (sql.Result, error)
	// RangeDeleteMessageFromReplicationTasksDLQ deletes one or more rows from replication_tasks_dlq table
	// Required filter params - {sourceClusterName, shardID, taskID, inclusiveTaskID}
	RangeDeleteMessageFromReplicationTasksDLQ(filter *ReplicationTasksDLQFilter) (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 QueueMetadataRow struct {
	QueueType persistence.QueueType
	Data      []byte
}

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

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

type ReplicationTasksDLQFilter struct {
	ReplicationTasksFilter
	SourceClusterName string
}

type ReplicationTasksFilter struct {
	ShardID            int32
	TaskID             int64
	InclusiveEndTaskID int64
	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 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 {
	Commit() error
	Rollback() error
	// contains filtered or unexported methods
}

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
}