netstorage

type BaseMessage struct {
	Typ  uint8
	Data codec.BinaryCodec
}

type ColumnKeys struct {
	Name string
	Keys []metaclient.FieldKey
}

type CreateDataBaseRequest struct {
	internal2.CreateDataBaseRequest
}

type CreateDataBaseResponse struct {
	internal2.CreateDataBaseResponse
}

type DDLBasePlans interface {
	Execute(mstKeys map[string][][]byte, condition influxql.Expr, tr util.TimeRange, limit int) (interface{}, error)
	AddPlan(plan interface{})
	Stop()
}

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

type DDLMessage struct {
	BaseMessage
}

type DeleteRequest struct {
	Database    string
	Rp          string
	Measurement string
	ShardIds    []uint64
	Type        DeleteType
	PtId        uint32
}

type DeleteResponse struct {
	Err error
}

type DeleteType int

type Engine interface {
	Open(durationInfos map[uint64]*meta.ShardDurationInfo, dbBriefInfos map[string]*meta.DatabaseBriefInfo, client metaclient.MetaClient) error
	Close() error
	ForceFlush()

	DeleteShard(db string, ptId uint32, shardID uint64) error
	DeleteIndex(db string, pt uint32, indexID uint64) error
	ClearIndexCache(db string, pt uint32, indexID uint64) error
	ExpiredShards(nilShardMap *map[uint64]*meta.ShardDurationInfo) []*meta.ShardIdentifier
	ExpiredIndexes(nilIndexMap *map[uint64]*meta.IndexDurationInfo) []*meta.IndexIdentifier
	ExpiredCacheIndexes() []*meta.IndexIdentifier
	FetchShardsNeedChangeStore() ([]*meta.ShardIdentifier, []*meta.ShardIdentifier)
	ChangeShardTierToWarm(db string, ptId uint32, shardID uint64) error

	CreateShard(db, rp string, ptId uint32, shardID uint64, timeRangeInfo *meta.ShardTimeRangeInfo, mstInfo *meta.MeasurementInfo) error
	WriteRows(db, rp string, ptId uint32, shardID uint64, points []influx.Row, binaryRows []byte, snp *raftlog.SnapShotter) error
	WriteRec(db, mst string, ptId uint32, shardID uint64, rec *record.Record, binaryRec []byte) error
	WriteToRaft(db, rp string, ptId uint32, tail []byte) error
	CreateDBPT(db string, pt uint32, enableTagArray bool)

	GetShardDownSampleLevel(db string, ptId uint32, shardID uint64) int

	GetShardSplitPoints(db string, ptId uint32, shardID uint64, idxes []int64) ([]string, error)

	DeleteDatabase(db string, ptId uint32) error

	DropRetentionPolicy(db string, rp string, ptId uint32) error

	DropMeasurement(db string, rp string, name string, shardIds []uint64) error

	TagKeys(db string, ptIDs []uint32, measurements [][]byte, condition influxql.Expr, tr influxql.TimeRange) ([]string, error)

	SeriesKeys(db string, ptIDs []uint32, measurements [][]byte, condition influxql.Expr, tr influxql.TimeRange) ([]string, error)
	SeriesCardinality(db string, ptIDs []uint32, measurements [][]byte, condition influxql.Expr, tr influxql.TimeRange) ([]meta.MeasurementCardinalityInfo, error)
	SeriesExactCardinality(db string, ptIDs []uint32, measurements [][]byte, condition influxql.Expr, tr influxql.TimeRange) (map[string]uint64, error)

	TagValues(db string, ptId []uint32, tagKeys map[string][][]byte, condition influxql.Expr, tr influxql.TimeRange) (TablesTagSets, error)
	TagValuesCardinality(db string, ptIDs []uint32, tagKeys map[string][][]byte, condition influxql.Expr, tr influxql.TimeRange) (map[string]uint64, error)
	DropSeries(database string, sources []influxql.Source, ptId []uint32, condition influxql.Expr) (int, error)

	DbPTRef(db string, ptId uint32) error
	DbPTUnref(db string, ptId uint32)
	CreateLogicalPlan(ctx context.Context, db string, ptId uint32, shardID []uint64, sources influxql.Sources, schema *executor.QuerySchema) (hybridqp.QueryNode, error)
	ScanWithSparseIndex(ctx context.Context, db string, ptId uint32, shardIDs []uint64, schema *executor.QuerySchema) (executor.ShardsFragments, error)
	GetIndexInfo(db string, ptId uint32, shardIDs uint64, schema *executor.QuerySchema) (*executor.AttachedIndexInfo, error)
	RowCount(db string, ptId uint32, shardIDs []uint64, schema *executor.QuerySchema) (int64, error)

	LogicalPlanCost(db string, ptId uint32, sources influxql.Sources, opt query.ProcessorOptions) (hybridqp.LogicalPlanCost, error)

	UpdateShardDurationInfo(info *meta.ShardDurationInfo, nilShardMap *map[uint64]*meta.ShardDurationInfo) error
	UpdateIndexDurationInfo(info *meta.IndexDurationInfo, nilIndexMap *map[uint64]*meta.IndexDurationInfo) error

	PreOffload(opId uint64, db string, ptId uint32) error
	RollbackPreOffload(opId uint64, db string, ptId uint32) error
	PreAssign(opId uint64, db string, ptId uint32, durationInfos map[uint64]*meta.ShardDurationInfo, dbBriefInfo *meta.DatabaseBriefInfo, client metaclient.MetaClient) error
	Offload(opId uint64, db string, ptId uint32) error
	Assign(opId uint64, nodeId uint64, db string, ptId uint32, ver uint64, durationInfos map[uint64]*meta.ShardDurationInfo, dbBriefInfo *meta.DatabaseBriefInfo, client metaclient.MetaClient, storage StorageService) error

	SysCtrl(req *SysCtrlRequest) (map[string]string, error)
	Statistics(buffer []byte) ([]byte, error)
	StatisticsOps() []opsStat.OpsStatistic

	GetShardDownSamplePolicyInfos(meta interface {
		UpdateShardDownSampleInfo(Ident *meta.ShardIdentifier) error
	}) ([]*meta.ShardDownSamplePolicyInfo, error)
	GetDownSamplePolicy(key string) *meta.StoreDownSamplePolicy
	StartDownSampleTask(info *meta.ShardDownSamplePolicyInfo, schema []hybridqp.Catalog, log *zap.Logger, meta interface {
		UpdateShardDownSampleInfo(Ident *meta.ShardIdentifier) error
	}) error
	UpdateDownSampleInfo(policies *meta.DownSamplePoliciesInfoWithDbRp)
	UpdateShardDownSampleInfo(infos *meta.ShardDownSampleUpdateInfos)
	CheckPtsRemovedDone() bool
	TransferLeadership(database string, nodeId uint64, oldMasterPtId, newMasterPtId uint32) error
	HierarchicalStorage(db string, ptId uint32, shardID uint64) bool

	RaftMessage
	CreateDDLBasePlans(planType hybridqp.DDLType, db string, ptIDs []uint32, tr *influxql.TimeRange) DDLBasePlans
	SetMetaClient(m metaclient.MetaClient)
}

type EngineOptions struct {
	Version string
	// Limits the concurrent number of TSM files that can be loaded at once.
	OpenLimiter limiter.Fixed

	// WriteColdDuration is the length of time at which the engine will snapshot the mutable
	WriteColdDuration time.Duration

	// ForceSnapShotDuration is the length of time at which the engine must snapshot the mutable
	ForceSnapShotDuration time.Duration

	// ShardMutableSizeLimit is the maximum size a shard's cache can reach before it starts rejecting writes.
	ShardMutableSizeLimit int64

	// NodeMutableSizeLimit is the maximum size a node's cache can reach before it starts rejecting writes.
	NodeMutableSizeLimit int64

	// MaxWriteHangTime is the maximum time to hang for data write to store if node mem of mem is not enough
	MaxWriteHangTime time.Duration

	// Enable read from mem data, include mutable and snapshot table, default value is true
	MemDataReadEnabled bool

	FullCompactColdDuration      time.Duration
	MaxConcurrentCompactions     int
	MaxFullCompactions           int
	CompactThroughput            int64
	CompactThroughputBurst       int64
	CompactRecovery              bool
	CsCompactionEnabled          bool
	CsDetachedFlushEnabled       bool
	ShardMoveLayoutSwitchEnabled bool
	SnapshotThroughput           int64
	SnapshotThroughputBurst      int64
	SnapshotTblNum               int
	FragmentsNumPerFlush         int
	BackgroundReadThroughput     int

	// WalSyncInterval is the interval of wal file sync
	WalEnabled         bool
	WalSyncInterval    time.Duration
	WalReplayParallel  bool
	WalReplayAsync     bool
	WalReplayBatchSize int

	// Immutable config
	ReadPageSize       string
	ReadMetaPageSize   []string
	ReadMetaCacheLimit uint64
	ReadDataCacheLimit uint64
	EnableMmapRead     bool
	CompactionMethod   int // 0:auto, 1:stream, 2: non-stream

	OpenShardLimit int
	// lazy load shards
	LazyLoadShardEnable       bool
	ThermalShardStartDuration time.Duration
	ThermalShardEndDuration   time.Duration

	DownSampleWriteDrop          bool
	MaxDownSampleTaskConcurrency int

	MaxSeriesPerDatabase int
	MaxRowsPerSegment    int

	// for hierarchical storage
	SkipRegisterColdShard bool

	// for raftNode
	RaftEntrySyncInterval time.Duration
}

type ExactCardinalityResponse struct {
	internal2.ExactCardinalityResponse
}

type ExecuteStatementMessage struct {
	StatementType string
	Result        []byte
	Filtered      []byte
}

type GetShardSplitPointsRequest struct {
	internal2.GetShardSplitPointsRequest
}

type GetShardSplitPointsResponse struct {
	internal2.GetShardSplitPointsResponse
}

type KillQueryRequest struct {
	internal2.KillQueryRequest
}

type KillQueryResponse struct {
	internal2.KillQueryResponse
}

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

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

type NewEngineFun func(dataPath, walPath string, options EngineOptions, ctx *metaclient.LoadCtx) (Engine, error)

type PartialWriteError struct {
	Reason  error
	Dropped int

	// A sorted slice of series keys that were dropped.
	DroppedKeys [][]byte
}

type PtRequest struct {
	netdata.PtRequest
}

type PtResponse struct {
	netdata.PtResponse
}

type QueryExeInfo struct {
	QueryID   uint64
	PtID      uint32
	Stmt      string
	Database  string
	BeginTime int64
	RunState  RunStateType
}

type RaftMessage interface {
	SendRaftMessage(database string, ptId uint64, msg raftpb.Message) error
}

type RaftMessagesRequest struct {
	Database    string
	PtId        uint32
	RaftMessage raftpb.Message
}

type RaftMessagesResponse struct {
	internal2.RaftMessagesResponse
}

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

type RaftMsgMessage struct {
	BaseMessage
}

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

type RunStateType int32

type SegregateNodeRequest struct {
	netdata.SegregateNodeRequest
}

type SegregateNodeResponse struct {
	netdata.SegregateNodeResponse
}

type SendRaftMessageToStorage interface {
	SendRaftMessages(nodeID uint64, database string, pt uint32, msgs raftpb.Message) error
	Client() meta.MetaClient
}

type SeriesCardinalityRequest struct {
	SeriesKeysRequest
}

type SeriesCardinalityResponse struct {
	meta.CardinalityResponse
}

type SeriesExactCardinalityRequest struct {
	SeriesKeysRequest
}

type SeriesExactCardinalityResponse struct {
	ExactCardinalityResponse
}

type SeriesKeysRequest struct {
	internal2.SeriesKeysRequest
}

type SeriesKeysResponse struct {
	internal2.SeriesKeysResponse
}

type ShowQueriesRequest struct {
}

type ShowQueriesResponse struct {
	QueryExeInfos []*QueryExeInfo
}

type ShowTagKeysRequest struct {
	internal2.ShowTagKeysRequest
}

type ShowTagKeysResponse struct {
	internal2.ShowTagKeysResponse
}

type ShowTagValuesCardinalityRequest struct {
	ShowTagValuesRequest
}

type ShowTagValuesCardinalityResponse struct {
	ExactCardinalityResponse
}

type ShowTagValuesRequest struct {
	internal2.ShowTagValuesRequest
}

type ShowTagValuesResponse struct {
	internal2.ShowTagValuesResponse
}

type Storage interface {
	WriteRows(ctx *WriteContext, nodeID uint64, pt uint32, database, rpName string, timeout time.Duration) error
	DropShard(nodeID uint64, database, rpName string, dbPts []uint32, shardID uint64) error

	TagValues(nodeID uint64, db string, ptIDs []uint32, tagKeys map[string]map[string]struct{}, cond influxql.Expr, limit int, exact bool) (TablesTagSets, error)
	TagValuesCardinality(nodeID uint64, db string, ptIDs []uint32, tagKeys map[string]map[string]struct{}, cond influxql.Expr) (map[string]uint64, error)

	ShowTagKeys(nodeID uint64, db string, ptId []uint32, measurements []string, condition influxql.Expr) ([]string, error)

	ShowSeries(nodeID uint64, db string, ptId []uint32, measurements []string, condition influxql.Expr, exact bool) ([]string, error)
	SeriesCardinality(nodeID uint64, db string, dbPts []uint32, measurements []string, condition influxql.Expr) ([]meta2.MeasurementCardinalityInfo, error)
	SeriesExactCardinality(nodeID uint64, db string, dbPts []uint32, measurements []string, condition influxql.Expr) (map[string]uint64, error)

	SendQueryRequestOnNode(nodeID uint64, req SysCtrlRequest) (map[string]string, error)
	SendSysCtrlOnNode(nodID uint64, req SysCtrlRequest) (map[string]string, error)

	GetShardSplitPoints(node *meta2.DataNode, database string, pt uint32,
		shardId uint64, idxes []int64) ([]string, error)
	DeleteDatabase(node *meta2.DataNode, database string, pt uint32) error
	DeleteRetentionPolicy(node *meta2.DataNode, db string, rp string, pt uint32) error
	DeleteMeasurement(node *meta2.DataNode, db string, rp string, name string, shardIds []uint64) error
	MigratePt(nodeID uint64, data transport.Codec, cb transport.Callback) error

	GetQueriesOnNode(nodeID uint64) ([]*QueryExeInfo, error)
	KillQueryOnNode(nodeID, queryID uint64) error
	SendSegregateNodeCmds(nodeIDs []uint64, address []string) (int, error)
	TransferLeadership(database string, nodeId uint64, oldMasterPtId, newMasterPtId uint32) error

	SendRaftMessageToStorage
}

type StorageService interface {
	Write(db, rp, mst string, ptId uint32, shardID uint64, writeData func() error) error
	WriteDataFunc(db, rp string, ptId uint32, shardID uint64, rows []influx.Row, binaryRows []byte, index *raftlog.SnapShotter) error
	GetNodeId() uint64
}

type StreamVar struct {
	Only bool
	Id   []uint64
}

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

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

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

type TableColumnKeys []ColumnKeys

type TableTagKeys []TagKeys

type TableTagSets struct {
	Name   string
	Values TagSets
}

type TablesTagSets []TableTagSets

type TagKeys struct {
	Name string
	Keys []string
}

type TagSet struct {
	Key, Value string
}

type TagSets []TagSet

type TransferLeadershipRequest struct {
	netdata.TransferLeadershipRequest
}

type TransferLeadershipResponse struct {
	netdata.TransferLeadershipResponse
}

type WriteContext struct {
	Rows         []influx.Row
	Shard        *meta2.ShardInfo
	Buf          []byte
	StreamShards []uint64
}

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

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

type WritePointsResponse struct {
	Code    uint8
	ErrCode errno.Errno
	Message string
}

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

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

type WriteStreamPointsResponse struct {
	Code    uint8
	ErrCode errno.Errno
	Message string
}