Revert "Dev measure aggregate function"

banyand/measure/aggregate/aggregate_function.go

@@ -62,18 +62,8 @@ func NewFunction[A, B Input, R Output](kind modelv1.MeasureAggregate) (Function[
 	switch kind {
 	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_MIN:
 		function = &Min[A, B, R]{minimum: maxValue[R]()}
-	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_MAX:
-		function = &Max[A, B, R]{maximum: minValue[R]()}
-	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_COUNT:
-		function = &Count[A, B, R]{count: 0}
-	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_SUM:
-		function = &Sum[A, B, R]{summation: zeroValue[R]()}
 	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_AVG:
 		function = &Avg[A, B, R]{summation: zeroValue[R](), count: 0}
-	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_PERCENT:
-		function = &Percent[A, B, R]{total: 0, match: 0}
-	case modelv1.MeasureAggregate_MEASURE_AGGREGATE_RATE:
-		function = &Rate[A, B, R]{denominator: 0, numerator: 0}
 	default:
 		return nil, fmt.Errorf("MeasureAggregate unknown")
 	}
@@ -86,20 +76,6 @@ func zeroValue[R Output]() R {
 	return r
 }
 
-func minValue[R Output]() (r R) {
-	switch a := any(&r).(type) {
-	case *int64:
-		*a = math.MinInt64
-	case *float64:
-		*a = -math.MaxFloat64
-	case *string:
-		*a = ""
-	default:
-		panic("unreachable")
-	}
-	return
-}
-
 func maxValue[R Output]() (r R) {
 	switch a := any(&r).(type) {
 	case *int64:

banyand/measure/aggregate/avg.go

@@ -24,14 +24,14 @@ type Avg[A, B Input, R Output] struct {
 }
 
 // Combine takes elements to do the aggregation.
-// Avg uses type parameter A.
-func (f *Avg[A, B, R]) Combine(arguments Arguments[A, B]) error {
+// Avg uses type parameter A and B.
+func (a *Avg[A, B, R]) Combine(arguments Arguments[A, B]) error {
 	for _, arg0 := range arguments.arg0 {
 		switch arg0 := any(arg0).(type) {
 		case int64:
-			f.summation += R(arg0)
+			a.summation += R(arg0)
 		case float64:
-			f.summation += R(arg0)
+			a.summation += R(arg0)
 		default:
 			return errFieldValueType
 		}
@@ -40,7 +40,7 @@ func (f *Avg[A, B, R]) Combine(arguments Arguments[A, B]) error {
 	for _, arg1 := range arguments.arg1 {
 		switch arg1 := any(arg1).(type) {
 		case int64:
-			f.count += arg1
+			a.count += arg1
 		default:
 			return errFieldValueType
 		}
@@ -50,14 +50,14 @@ func (f *Avg[A, B, R]) Combine(arguments Arguments[A, B]) error {
 }
 
 // Result gives the result for the aggregation.
-func (f *Avg[A, B, R]) Result() R {
+func (a *Avg[A, B, R]) Result() R {
 	// In unusual situations it returns the zero value.
-	if f.count == 0 {
+	if a.count == 0 {
 		return zeroValue[R]()
 	}
 	// According to the semantics of GoLang, the division of one int by another int
-	// returns an int, instead of f float.
-	return f.summation / R(f.count)
+	// returns an int, instead of a float.
+	return a.summation / R(a.count)
 }
 
 // NewAvgArguments constructs arguments.

banyand/measure/aggregate/min.go

@@ -24,16 +24,16 @@ type Min[A, B Input, R Output] struct {
 
 // Combine takes elements to do the aggregation.
 // Min uses type parameter A.
-func (f *Min[A, B, R]) Combine(arguments Arguments[A, B]) error {
+func (m *Min[A, B, R]) Combine(arguments Arguments[A, B]) error {
 	for _, arg0 := range arguments.arg0 {
 		switch arg0 := any(arg0).(type) {
 		case int64:
-			if R(arg0) < f.minimum {
-				f.minimum = R(arg0)
+			if R(arg0) < m.minimum {
+				m.minimum = R(arg0)
 			}
 		case float64:
-			if R(arg0) < f.minimum {
-				f.minimum = R(arg0)
+			if R(arg0) < m.minimum {
+				m.minimum = R(arg0)
 			}
 		default:
 			return errFieldValueType
@@ -43,8 +43,8 @@ func (f *Min[A, B, R]) Combine(arguments Arguments[A, B]) error {
 }
 
 // Result gives the result for the aggregation.
-func (f *Min[A, B, R]) Result() R {
-	return f.minimum
+func (m *Min[A, B, R]) Result() R {
+	return m.minimum
 }
 
 // NewMinArguments constructs arguments.