aggexec

package
v1.2.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 10, 2024 License: Apache-2.0 Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// GroupNotMatched is a constant for the BatchFill method.
	// if the group is GroupNotMatched, the BatchFill method will ignore the row.
	GroupNotMatched = 0
)

Variables

View Source 
var (
	ErrInvalidLengthSerialize        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSerialize          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSerialize = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ClusterCentersSupportTypes = []types.T{
		types.T_array_float32, types.T_array_float64,
	}
)
View Source 
var (
	CountReturnType = func(_ []types.Type) types.Type {
		return types.T_int64.ToType()
	}
)
View Source 
var GroupConcatUnsupportedTypes = []types.T{
	types.T_tuple,
}
View Source 
var MedianSupportedType = []types.T{
	types.T_bit, types.T_int8, types.T_int16, types.T_int32, types.T_int64,
	types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64,
	types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128,
}

Functions

func ClusterCentersReturnType 

func ClusterCentersReturnType(argType []types.Type) types.Type

func FromD64ToD128 

func FromD64ToD128(v types.Decimal64) types.Decimal128

func GroupConcatReturnType 

func GroupConcatReturnType(args []types.Type) types.Type

func IsGroupConcatSupported 

func IsGroupConcatSupported(t types.Type) bool

func MarshalAggFuncExec 

func MarshalAggFuncExec(exec AggFuncExec) ([]byte, error)

func MedianReturnType 

func MedianReturnType(args []types.Type) types.Type

func RegisterAggFromBytesRetBytes added in v1.2.1 

func RegisterAggFromBytesRetBytes(
	basicInformation SingleColumnAggInformation,
	initCommonContext AggCommonContextInit,
	initGroupContext AggGroupContextInit,
	initResult SingleAggInitResultVar,
	fill SingleAggFill4NewVersion,
	fills SingleAggFills4NewVersion,
	merge SingleAggMerge4NewVersion,
	flush SingleAggFlush4NewVersion)

func RegisterAggFromBytesRetFixed added in v1.2.1 

func RegisterAggFromBytesRetFixed[to types.FixedSizeTExceptStrType](
	basicInformation SingleColumnAggInformation,
	initCommonContext AggCommonContextInit,
	initGroupContext AggGroupContextInit,
	initResult SingleAggInitResultFixed[to],
	fill SingleAggFill3NewVersion[to],
	fills SingleAggFills3NewVersion[to],
	merge SingleAggMerge3NewVersion[to],
	flush SingleAggFlush3NewVersion[to])

func RegisterAggFromFixedRetBytes added in v1.2.1 

func RegisterAggFromFixedRetBytes[from types.FixedSizeTExceptStrType](
	basicInformation SingleColumnAggInformation,
	initCommonContext AggCommonContextInit,
	initGroupContext AggGroupContextInit,
	initResult SingleAggInitResultVar,
	fill SingleAggFill2NewVersion[from],
	fills SingleAggFills2NewVersion[from],
	merge SingleAggMerge2NewVersion[from],
	flush SingleAggFlush2NewVersion[from])

func RegisterAggFromFixedRetFixed added in v1.2.1 

func RegisterAggFromFixedRetFixed[from, to types.FixedSizeTExceptStrType](
	basicInformation SingleColumnAggInformation,
	initCommonContext AggCommonContextInit,
	initGroupContext AggGroupContextInit,
	initResult SingleAggInitResultFixed[to],
	fill SingleAggFill1NewVersion[from, to],
	fills SingleAggFills1NewVersion[from, to],
	merge SingleAggMerge1NewVersion[from, to],
	flush SingleAggFlush1NewVersion[from, to])

func RegisterApproxCountAgg 

func RegisterApproxCountAgg(id int64)

func RegisterClusterCenters 

func RegisterClusterCenters(id int64)

func RegisterCountColumnAgg 

func RegisterCountColumnAgg(id int64)

func RegisterCountStarAgg 

func RegisterCountStarAgg(id int64)

func RegisterDenseRankWin 

func RegisterDenseRankWin(id int64)

func RegisterGroupConcatAgg 

func RegisterGroupConcatAgg(id int64, sep string)

func RegisterMedian 

func RegisterMedian(id int64)

func RegisterMultiAggRetFixed 

func RegisterMultiAggRetFixed[to types.FixedSizeTExceptStrType](
	info MultiColumnAggRetFixedRegisteredInfo[to])

func RegisterRankWin 

func RegisterRankWin(id int64)

func RegisterRowNumberWin 

func RegisterRowNumberWin(id int64)

func SingleWindowReturnType 

func SingleWindowReturnType(_ []types.Type) types.Type

Types

type AggBytesGetter 

type AggBytesGetter func() []byte

the definition of functions to get and set the aggregation result.

type AggBytesSetter 

type AggBytesSetter func(value []byte) error

the definition of functions to get and set the aggregation result.

type AggCanMarshal 

type AggCanMarshal interface {
	Marshal() []byte
	Unmarshal([]byte)
}

AggCanMarshal interface is used for agg structures' multi-node communication. each context of aggregation should implement the AggCanMarshal interface.

todo: consider that change them to deliver []byte directly, and agg developer choose how to use the []byte. 

because the []byte can be set to one byte vector, and we can use the `mpool` to manage the memory easily.

type AggCommonContextInit added in v1.2.1 

type AggCommonContextInit func(resultType types.Type, parameters ...types.Type) AggCommonExecContext

type AggCommonExecContext 

type AggCommonExecContext interface {
	AggCanMarshal
}

AggCommonExecContext stores the common context for all the groups. like the type scale, timezone and so on.

type AggContext added in v1.2.1 

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

type AggFuncExec 

type AggFuncExec interface {
	AggID() int64
	IsDistinct() bool

	// TypesInfo return the argument types and return type of the function.
	TypesInfo() ([]types.Type, types.Type)

	// GroupGrow is used to increase the aggregation's group size.
	GroupGrow(more int) error
	// PreAllocateGroups is used to pre-extend the agg memory to reduce gc cost.
	PreAllocateGroups(more int) error

	// Fill BulkFill and BatchFill add the value to the aggregation.
	Fill(groupIndex int, row int, vectors []*vector.Vector) error
	BulkFill(groupIndex int, vectors []*vector.Vector) error
	BatchFill(offset int, groups []uint64, vectors []*vector.Vector) error

	// Merge merges the aggregation result of two groups.
	Merge(next AggFuncExec, groupIdx1, groupIdx2 int) error
	// BatchMerge merges the aggregation result of multiple groups.
	// merge work starts from the offset group of the next agg, end at the (offset + len(groups) - 1) group.
	// merges the (offset + i)th group with the (groups[i]-1) group of the current agg.
	BatchMerge(next AggFuncExec, offset int, groups []uint64) error

	// SetExtraInformation add an additional information to agg executor.
	// in most cases, it is used to set the partial result of the aggregation to speed up.
	//
	// but for the 'group_concat', it was a bad hack to use the method to set the separator.
	// and for the 'cluster_centers', it was used to set the fields of this agg.
	// todo: the old implementation is not good, we should use the vector.Vector to replace the any.
	//  and the hacks should be removed.
	//  but for first version, I will keep it.
	SetExtraInformation(partialResult any, groupIndex int) (err error)

	// Flush return the aggregation result.
	Flush() (*vector.Vector, error)

	// Free clean the resource and reuse the aggregation if possible.
	Free()
	// contains filtered or unexported methods
}

AggFuncExec is an interface to do execution for aggregation.

func CopyAggFuncExec 

func CopyAggFuncExec(mg AggMemoryManager, exec AggFuncExec) (AggFuncExec, error)

func MakeAgg 

func MakeAgg(
	mg AggMemoryManager,
	aggID int64, isDistinct bool,
	param ...types.Type) AggFuncExec

MakeAgg is the only exporting method to create an aggregation function executor. all the aggID should be registered before calling this function.

func UnmarshalAggFuncExec 

func UnmarshalAggFuncExec(
	mg AggMemoryManager,
	data []byte) (AggFuncExec, error)

type AggFuncExecExpression 

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

AggFuncExecExpression is the exporting structure for the aggregation information. it is used to indicate the information of the aggregation function for the operators like 'group' or 'merge group'.

func MakeAggFunctionExpression 

func MakeAggFunctionExpression(id int64, isDistinct bool, args []*plan.Expr, config []byte) AggFuncExecExpression

func (AggFuncExecExpression) GetAggID 

func (expr AggFuncExecExpression) GetAggID() int64

func (AggFuncExecExpression) GetArgExpressions 

func (expr AggFuncExecExpression) GetArgExpressions() []*plan.Expr

func (AggFuncExecExpression) GetExtraConfig 

func (expr AggFuncExecExpression) GetExtraConfig() []byte

func (AggFuncExecExpression) IsDistinct 

func (expr AggFuncExecExpression) IsDistinct() bool

type AggGetter 

type AggGetter[T types.FixedSizeTExceptStrType] func() T

the definition of functions to get and set the aggregation result.

type AggGroupContextInit added in v1.2.1 

type AggGroupContextInit func(resultType types.Type, parameters ...types.Type) AggGroupExecContext

type AggGroupExecContext 

type AggGroupExecContext interface {
	AggCanMarshal
}

AggGroupExecContext store the content of each group individually. like the row-count has been filled, the sum of the values and so on.

type AggMemoryManager 

type AggMemoryManager interface {
	Mp() *mpool.MPool
	GetVector(typ types.Type) *vector.Vector
	PutVector(v *vector.Vector)
}

func NewSimpleAggMemoryManager 

func NewSimpleAggMemoryManager(mp *mpool.MPool) AggMemoryManager

type AggSetter 

type AggSetter[T types.FixedSizeTExceptStrType] func(value T)

the definition of functions to get and set the aggregation result.

type EncodedAgg 

type EncodedAgg struct {
	Info                 *EncodedBasicInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	Result               []byte            `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	Groups               [][]byte          `protobuf:"bytes,3,rep,name=groups,proto3" json:"groups,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*EncodedAgg) Descriptor 

func (*EncodedAgg) Descriptor() ([]byte, []int)

func (*EncodedAgg) GetGroups 

func (m *EncodedAgg) GetGroups() [][]byte

func (*EncodedAgg) GetInfo 

func (m *EncodedAgg) GetInfo() *EncodedBasicInfo

func (*EncodedAgg) GetResult 

func (m *EncodedAgg) GetResult() []byte

func (*EncodedAgg) Marshal 

func (m *EncodedAgg) Marshal() (dAtA []byte, err error)

func (*EncodedAgg) MarshalTo 

func (m *EncodedAgg) MarshalTo(dAtA []byte) (int, error)

func (*EncodedAgg) MarshalToSizedBuffer 

func (m *EncodedAgg) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EncodedAgg) ProtoMessage 

func (*EncodedAgg) ProtoMessage()

func (*EncodedAgg) ProtoSize 

func (m *EncodedAgg) ProtoSize() (n int)

func (*EncodedAgg) Reset 

func (m *EncodedAgg) Reset()

func (*EncodedAgg) String 

func (m *EncodedAgg) String() string

func (*EncodedAgg) Unmarshal 

func (m *EncodedAgg) Unmarshal(dAtA []byte) error

func (*EncodedAgg) XXX_DiscardUnknown 

func (m *EncodedAgg) XXX_DiscardUnknown()

func (*EncodedAgg) XXX_Marshal 

func (m *EncodedAgg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EncodedAgg) XXX_Merge 

func (m *EncodedAgg) XXX_Merge(src proto.Message)

func (*EncodedAgg) XXX_Size 

func (m *EncodedAgg) XXX_Size() int

func (*EncodedAgg) XXX_Unmarshal 

func (m *EncodedAgg) XXX_Unmarshal(b []byte) error

type EncodedBasicInfo 

type EncodedBasicInfo struct {
	Id                   int64                                                        `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	IsDistinct           bool                                                         `protobuf:"varint,2,opt,name=is_distinct,json=isDistinct,proto3" json:"is_distinct,omitempty"`
	NullEmpty            bool                                                         `protobuf:"varint,3,opt,name=null_empty,json=nullEmpty,proto3" json:"null_empty,omitempty"`
	Args                 []github_com_matrixorigin_matrixone_pkg_container_types.Type `protobuf:"bytes,4,rep,name=args,proto3,customtype=github.com/matrixorigin/matrixone/pkg/container/types.Type" json:"args"`
	Ret                  github_com_matrixorigin_matrixone_pkg_container_types.Type   `protobuf:"bytes,5,opt,name=ret,proto3,customtype=github.com/matrixorigin/matrixone/pkg/container/types.Type" json:"ret"`
	XXX_NoUnkeyedLiteral struct{}                                                     `json:"-"`
	XXX_unrecognized     []byte                                                       `json:"-"`
	XXX_sizecache        int32                                                        `json:"-"`
}

func (*EncodedBasicInfo) Descriptor 

func (*EncodedBasicInfo) Descriptor() ([]byte, []int)

func (*EncodedBasicInfo) GetId 

func (m *EncodedBasicInfo) GetId() int64

func (*EncodedBasicInfo) GetIsDistinct 

func (m *EncodedBasicInfo) GetIsDistinct() bool

func (*EncodedBasicInfo) GetNullEmpty 

func (m *EncodedBasicInfo) GetNullEmpty() bool

func (*EncodedBasicInfo) Marshal 

func (m *EncodedBasicInfo) Marshal() (dAtA []byte, err error)

func (*EncodedBasicInfo) MarshalTo 

func (m *EncodedBasicInfo) MarshalTo(dAtA []byte) (int, error)

func (*EncodedBasicInfo) MarshalToSizedBuffer 

func (m *EncodedBasicInfo) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EncodedBasicInfo) ProtoMessage 

func (*EncodedBasicInfo) ProtoMessage()

func (*EncodedBasicInfo) ProtoSize 

func (m *EncodedBasicInfo) ProtoSize() (n int)

func (*EncodedBasicInfo) Reset 

func (m *EncodedBasicInfo) Reset()

func (*EncodedBasicInfo) String 

func (m *EncodedBasicInfo) String() string

func (*EncodedBasicInfo) Unmarshal 

func (m *EncodedBasicInfo) Unmarshal(dAtA []byte) error

func (*EncodedBasicInfo) XXX_DiscardUnknown 

func (m *EncodedBasicInfo) XXX_DiscardUnknown()

func (*EncodedBasicInfo) XXX_Marshal 

func (m *EncodedBasicInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EncodedBasicInfo) XXX_Merge 

func (m *EncodedBasicInfo) XXX_Merge(src proto.Message)

func (*EncodedBasicInfo) XXX_Size 

func (m *EncodedBasicInfo) XXX_Size() int

func (*EncodedBasicInfo) XXX_Unmarshal 

func (m *EncodedBasicInfo) XXX_Unmarshal(b []byte) error

type MultiAggEval1 

type MultiAggEval1[to types.FixedSizeTExceptStrType] func(
	exec MultiAggRetFixed[to], getter AggGetter[to], setter AggSetter[to]) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggEval2 

type MultiAggEval2 func(
	exec MultiAggRetVar, getter AggBytesGetter, setter AggBytesSetter) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggFillNull1 

type MultiAggFillNull1[to types.FixedSizeTExceptStrType] func(
	exec MultiAggRetFixed[to]) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggFillNull2 

type MultiAggFillNull2 func(
	exec MultiAggRetVar) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggFlush1 

type MultiAggFlush1[to types.FixedSizeTExceptStrType] func(
	exec MultiAggRetFixed[to], getter AggGetter[to], setter AggSetter[to]) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggFlush2 

type MultiAggFlush2 func(
	exec MultiAggRetVar, getter AggBytesGetter, setter AggBytesSetter) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggInit1 

type MultiAggInit1[to types.FixedSizeTExceptStrType] func(
	exec MultiAggRetFixed[to], setter AggSetter[to], args []types.Type, ret types.Type)

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggInit2 

type MultiAggInit2 func(
	exec MultiAggRetVar, setter AggBytesSetter, args []types.Type, ret types.Type)

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggMerge1 

type MultiAggMerge1[to types.FixedSizeTExceptStrType] func(
	exec1, exec2 MultiAggRetFixed[to], getter1, getter2 AggGetter[to], setter AggSetter[to]) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggMerge2 

type MultiAggMerge2 func(
	exec1, exec2 MultiAggRetVar, getter1, getter2 AggBytesGetter, setter AggBytesSetter) error

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggRetFixed 

type MultiAggRetFixed[to types.FixedSizeTExceptStrType] interface{ AggCanMarshal }

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiAggRetVar 

type MultiAggRetVar interface{ AggCanMarshal }

the function definitions of multi-column aggregation. about the aggregation of multi-column, the result type can be fixed-length or variable-length. multiAgg1 for the fixed-length result type, multiAgg2 for the variable-length result type.

todo: should refactor these functions to be like the single aggregation functions. 

I kept them because there has no multi-column aggregation implemented yet.
and I don't want to make a big change in one PR.

type MultiColumnAggInformation 

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

func MakeMultiColumnAggInformation 

func MakeMultiColumnAggInformation(
	id int64, params []types.Type, getRetType func(p []types.Type) types.Type,
	setNullForEmptyGroup bool) MultiColumnAggInformation

type MultiColumnAggRetFixedRegisteredInfo 

type MultiColumnAggRetFixedRegisteredInfo[to types.FixedSizeTExceptStrType] struct {
	MultiColumnAggInformation
	// contains filtered or unexported fields
}

func MakeMultiAggRetFixedRegisteredInfo 

func MakeMultiAggRetFixedRegisteredInfo[to types.FixedSizeTExceptStrType](
	info MultiColumnAggInformation,
	impl func() MultiAggRetFixed[to],
	init MultiAggInit1[to],
	fillWhich []any,
	fillNullWhich []MultiAggFillNull1[to],
	rowValid rowValidForMultiAgg1[to],
	eval MultiAggEval1[to],
	merge MultiAggMerge1[to],
	flush MultiAggFlush1[to],
) MultiColumnAggRetFixedRegisteredInfo[to]

type SimpleAggMemoryManager 

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

func (SimpleAggMemoryManager) GetVector 

func (m SimpleAggMemoryManager) GetVector(typ types.Type) *vector.Vector

func (SimpleAggMemoryManager) Mp 

func (m SimpleAggMemoryManager) Mp() *mpool.MPool

func (SimpleAggMemoryManager) PutVector 

func (m SimpleAggMemoryManager) PutVector(v *vector.Vector)

type SingleAggFill1NewVersion added in v1.2.1 

type SingleAggFill1NewVersion[from, to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value from, aggIsEmpty bool,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

SingleAggFill1NewVersion ... SingleAggFlush1NewVersion : singleAgg1's function definitions.

type SingleAggFill2NewVersion added in v1.2.1 

type SingleAggFill2NewVersion[from types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value from, aggIsEmpty bool,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

SingleAggFill2NewVersion ... SingleAggFlush2NewVersion : singleAgg2's function definitions.

type SingleAggFill3NewVersion added in v1.2.1 

type SingleAggFill3NewVersion[to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value []byte, aggIsEmpty bool,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

SingleAggFill3NewVersion ... SingleAggFlush3NewVersion : singleAgg3's function definitions.

type SingleAggFill4NewVersion added in v1.2.1 

type SingleAggFill4NewVersion func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value []byte, aggIsEmpty bool,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

SingleAggFill4NewVersion ... SingleAggFlush4NewVersion : singleAgg4's function definitions.

type SingleAggFills1NewVersion added in v1.2.1 

type SingleAggFills1NewVersion[from, to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value from, count int, aggIsEmpty bool,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFills2NewVersion added in v1.2.1 

type SingleAggFills2NewVersion[from types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value from, count int, aggIsEmpty bool,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFills3NewVersion added in v1.2.1 

type SingleAggFills3NewVersion[to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value []byte, count int, aggIsEmpty bool,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFills4NewVersion added in v1.2.1 

type SingleAggFills4NewVersion func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	value []byte, count int, aggIsEmpty bool,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFlush1NewVersion added in v1.2.1 

type SingleAggFlush1NewVersion[from, to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFlush2NewVersion added in v1.2.1 

type SingleAggFlush2NewVersion[from types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFlush3NewVersion added in v1.2.1 

type SingleAggFlush3NewVersion[to types.FixedSizeTExceptStrType] func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	resultGetter AggGetter[to], resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggFlush4NewVersion added in v1.2.1 

type SingleAggFlush4NewVersion func(
	execContext AggGroupExecContext, commonContext AggCommonExecContext,
	resultGetter AggBytesGetter, resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggInitResultFixed added in v1.2.1 

type SingleAggInitResultFixed[to types.FixedSizeTExceptStrType] func(
	resultType types.Type, parameters ...types.Type) to

SingleAggInitResultFixed and SingleAggInitResultVar return the original result of a new aggregation group.

type SingleAggInitResultVar added in v1.2.1 

type SingleAggInitResultVar func(
	resultType types.Type, parameters ...types.Type) []byte

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggMerge1NewVersion added in v1.2.1 

type SingleAggMerge1NewVersion[from, to types.FixedSizeTExceptStrType] func(
	ctx1, ctx2 AggGroupExecContext,
	commonContext AggCommonExecContext,
	aggIsEmpty1, aggIsEmpty2 bool,
	resultGetter1, resultGetter2 AggGetter[to],
	resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggMerge2NewVersion added in v1.2.1 

type SingleAggMerge2NewVersion[from types.FixedSizeTExceptStrType] func(
	ctx1, ctx2 AggGroupExecContext,
	commonContext AggCommonExecContext,
	aggIsEmpty1, aggIsEmpty2 bool,
	resultGetter1, resultGetter2 AggBytesGetter,
	resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggMerge3NewVersion added in v1.2.1 

type SingleAggMerge3NewVersion[to types.FixedSizeTExceptStrType] func(
	ctx1, ctx2 AggGroupExecContext,
	commonContext AggCommonExecContext,
	aggIsEmpty1, aggIsEmpty2 bool,
	resultGetter1, resultGetter2 AggGetter[to],
	resultSetter AggSetter[to]) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleAggMerge4NewVersion added in v1.2.1 

type SingleAggMerge4NewVersion func(
	ctx1, ctx2 AggGroupExecContext,
	commonContext AggCommonExecContext,
	aggIsEmpty1, aggIsEmpty2 bool,
	resultGetter1, resultGetter2 AggBytesGetter,
	resultSetter AggBytesSetter) error

the function definitions of single-column aggregation. singleAgg1 for the fixed-length input type and fixed-length result type. singleAgg2 for the fixed-length input type and variable-length result type. singleAgg3 for the variable-length input type and fixed-length result type. singleAgg4 for the variable-length input type and variable-length result type.

type SingleColumnAggInformation 

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

func MakeSingleColumnAggInformation 

func MakeSingleColumnAggInformation(
	id int64, paramType types.Type, getRetType func(p []types.Type) types.Type,
	setNullForEmptyGroup bool) SingleColumnAggInformation

Source Files

View all Source files

Directories

Path Synopsis
algos
kmeans
kmeans/elkans

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.