implment std and tests

Author: James Cor

enginetest/queries/script_queries.go

@@ -7887,6 +7887,57 @@ where
 			},
 		},
 	},
+	{
+		Name:    "std, stdev, stddev_pop tests",
+		Dialect: "mysql",
+		SetUpScript: []string{
+			"create table t (i int);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "select std(i), stddev(i), stddev_pop(i) from t;",
+				Expected: []sql.Row{
+					{nil, nil, nil},
+				},
+			},
+			{
+				Query: "insert into t values (1);",
+				Expected: []sql.Row{
+					{types.NewOkResult(1)},
+				},
+			},
+			{
+				Query: "select std(i), stddev(i), stddev_pop(i) from t;",
+				Expected: []sql.Row{
+					{0.0, 0.0, 0.0},
+				},
+			},
+			{
+				Query: "insert into t values (2);",
+				Expected: []sql.Row{
+					{types.NewOkResult(1)},
+				},
+			},
+			{
+				Query: "select std(i), stddev(i), stddev_pop(i) from t;",
+				Expected: []sql.Row{
+					{0.5, 0.5, 0.5},
+				},
+			},
+			{
+				Query: "insert into t values (3);",
+				Expected: []sql.Row{
+					{types.NewOkResult(1)},
+				},
+			},
+			{
+				Query: "select std(i), stddev(i), stddev_pop(i) from t;",
+				Expected: []sql.Row{
+					{0.816496580927726, 0.816496580927726, 0.816496580927726},
+				},
+			},
+		},
+	},
 }
 
 var SpatialScriptTests = []ScriptTest{

optgen/cmd/source/unary_aggs.yaml

@@ -31,4 +31,6 @@ unaryAggs:
   desc: "returns the minimum value of expr in all rows."
 - name:     "Sum"
   desc:     "returns the sum of expr in all rows"
-  nullable: false
+  nullable: false
+- name:     "StdDevPop"
+  desc:     "returns the population standard deviation of expr"

sql/expression/function/aggregation/common.go

@@ -125,11 +125,11 @@ func (a *unaryAggBase) WithChildren(children ...sql.Expression) (sql.Expression,
 	return &na, nil
 }
 
-func (a unaryAggBase) FunctionName() string {
+func (a *unaryAggBase) FunctionName() string {
 	return a.functionName
 }
 
-func (a unaryAggBase) Description() string {
+func (a *unaryAggBase) Description() string {
 	return a.description
 }
 

sql/expression/function/aggregation/std_test.go

@@ -0,0 +1,97 @@
+// Copyright 2025 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package aggregation
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/expression"
+)
+
+func TestStd(t *testing.T) {
+	sum := NewStdDevPop(expression.NewGetField(0, nil, "", false))
+
+	testCases := []struct {
+		name     string
+		rows     []sql.Row
+		expected interface{}
+	}{
+		{
+			"string int values",
+			[]sql.Row{{"1"}, {"2"}, {"3"}, {"4"}},
+			1.118033988749895,
+		},
+		{
+			"string float values",
+			[]sql.Row{{"1.5"}, {"2"}, {"3"}, {"4"}},
+			0.9601432184835761,
+		},
+		{
+			"string non-int values",
+			[]sql.Row{{"a"}, {"b"}, {"c"}, {"d"}},
+			float64(0),
+		},
+		{
+			"float values",
+			[]sql.Row{{1.}, {2.5}, {3.}, {4.}},
+			1.0825317547305484,
+		},
+		{
+			"no rows",
+			[]sql.Row{},
+			nil,
+		},
+		{
+			"nil values",
+			[]sql.Row{{nil}, {nil}},
+			nil,
+		},
+		{
+			"int64 values",
+			[]sql.Row{{int64(1)}, {int64(3)}},
+			1.0,
+		},
+		{
+			"int32 values",
+			[]sql.Row{{int32(1)}, {int32(3)}},
+			1.0,
+		},
+		{
+			"int32 and nil values",
+			[]sql.Row{{int32(1)}, {int32(3)}, {nil}},
+			1.0,
+		},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+
+			ctx := sql.NewEmptyContext()
+			buf, _ := sum.NewBuffer()
+			for _, row := range tt.rows {
+				require.NoError(buf.Update(ctx, row))
+			}
+
+			result, err := buf.Eval(sql.NewEmptyContext())
+			require.NoError(err)
+			require.Equal(tt.expected, result)
+		})
+	}
+}
+

sql/expression/function/aggregation/unary_agg_buffers.go

@@ -2,7 +2,8 @@ package aggregation
 
 import (
 	"fmt"
-	"reflect"
+	"math"
+"reflect"
 
 	"github.com/cespare/xxhash/v2"
 	"github.com/shopspring/decimal"
@@ -666,3 +667,66 @@ func (j *jsonArrayBuffer) Eval(ctx *sql.Context) (interface{}, error) {
 // Dispose implements the Disposable interface.
 func (j *jsonArrayBuffer) Dispose() {
 }
+
+type stdDevPopBuffer struct {
+	vals []interface{}
+	expr sql.Expression
+
+	count   int64
+	oldMean float64
+	newMean float64
+	oldVar  float64
+	newVar  float64
+}
+
+func NewStdDevPopBuffer(child sql.Expression) *stdDevPopBuffer {
+	return &stdDevPopBuffer{
+		vals: nil,
+		expr: child,
+	}
+}
+
+// Update implements the AggregationBuffer interface.
+func (s *stdDevPopBuffer) Update(ctx *sql.Context, row sql.Row) error {
+	v, err := s.expr.Eval(ctx, row)
+	if err != nil {
+		return err
+	}
+
+	// TODO: convert val to appropriate type
+	v, _, err = types.Float64.Convert(ctx, v)
+	if err != nil {
+		v = 0.0
+		ctx.Warn(1292, "Truncated incorrect DOUBLE value: %s", v)
+	}
+	if v == nil {
+		return nil
+	}
+	val := v.(float64)
+
+	s.count += 1
+	if s.count == 1 {
+		s.oldMean = val
+		s.newMean = val
+		return nil
+	}
+
+	s.newMean = s.oldMean + (val - s.oldMean) / float64(s.count)
+	s.newVar  = s.oldVar  + (val - s.oldMean) * (val - s.newMean)
+	s.oldVar  = s.newVar
+	s.oldMean = s.newMean
+
+	return nil
+}
+
+// Eval implements the AggregationBuffer interface.
+func (s *stdDevPopBuffer) Eval(ctx *sql.Context) (interface{}, error) {
+	if s.count == 0 {
+		return nil, nil
+	}
+	return math.Sqrt(s.newVar / float64(s.count)), nil // TODO: sqrt?
+}
+
+// Dispose implements the Disposable interface.
+func (s *stdDevPopBuffer) Dispose() {
+}

sql/expression/function/aggregation/unary_aggs.og.go

@@ -1408,3 +1408,55 @@ func (a *leadLagBase) Compute(ctx *sql.Context, interval sql.WindowInterval, buf
 	a.pos++
 	return res
 }
+
+type StdDevPopAgg struct {
+	expr   sql.Expression
+	framer sql.WindowFramer
+}
+
+func NewStdDevPopAgg(e sql.Expression) *StdDevPopAgg {
+	return &StdDevPopAgg{
+		expr: e,
+	}
+}
+
+func (s *StdDevPopAgg) WithWindow(w *sql.WindowDefinition) (sql.WindowFunction, error) {
+	ns := *s
+	if w.Frame != nil {
+		framer, err := w.Frame.NewFramer(w)
+		if err != nil {
+			return nil, err
+		}
+		ns.framer = framer
+	}
+	return &ns, nil
+}
+
+func (s *StdDevPopAgg) Dispose() {
+	expression.Dispose(s.expr)
+}
+
+// DefaultFramer returns a NewUnboundedPrecedingToCurrentRowFramer
+func (s *StdDevPopAgg) DefaultFramer() sql.WindowFramer {
+	if s.framer != nil {
+		return s.framer
+	}
+	return NewUnboundedPrecedingToCurrentRowFramer()
+}
+
+func (s *StdDevPopAgg) StartPartition(ctx *sql.Context, interval sql.WindowInterval, buf sql.WindowBuffer) error {
+	s.Dispose()
+	return nil
+}
+
+func (s *StdDevPopAgg) Compute(ctx *sql.Context, interval sql.WindowInterval, buf sql.WindowBuffer) interface{} {
+	for i := interval.Start; i < interval.End; i++ {
+		row := buf[i]
+		v, err := s.expr.Eval(ctx, row)
+		if err != nil {
+			return err
+		}
+		return v
+	}
+	return nil
+}