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 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, shardID uint64) error
	ExpiredShards() []*meta.ShardIdentifier
	ExpiredIndexes() []*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) error
	WriteRec(db, mst string, ptId uint32, shardID uint64, rec *record.Record, binaryRec []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

	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)
	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) error

	PreOffload(db string, ptId uint32) error
	RollbackPreOffload(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(db string, ptId uint32) error
	Assign(opId uint64, db string, ptId uint32, ver uint64, durationInfos map[uint64]*meta.ShardDurationInfo, dbBriefInfo *meta.DatabaseBriefInfo, client metaclient.MetaClient) 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
}

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

	ImmTableMaxMemoryPercentage int

	// WriteColdDuration is the length of time at which the engine will snapshot the mutable
	WriteColdDuration 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
	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

	// Immutable config
	ReadCacheLimit   uint64
	CacheDataBlock   bool
	CacheMetaBlock   bool
	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
}

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
	Stmt      string
	Database  string
	BeginTime int64
	RunState  RunStateType
}

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

type RunStateType int32

type SegregateNodeRequest struct {
	netdata.SegregateNodeRequest
}

type SegregateNodeResponse struct {
	netdata.SegregateNodeResponse
}

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 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) (TablesTagSets, error)
	TagValuesCardinality(nodeID uint64, db string, ptIDs []uint32, tagKeys map[string]map[string]struct{}, cond influxql.Expr) (map[string]uint64, error)

	ShowSeries(nodeID uint64, db string, ptId []uint32, measurements []string, condition influxql.Expr) ([]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) (int, error)
}

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 WriteContext struct {
	Rows  []influx.Row
	Shard *meta2.ShardInfo

	StreamShards []uint64
	// contains filtered or unexported fields
}

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
}