Here's a rough outline of one way you might proceed with your GoDB implementation; more details on the steps in this outline, including exercises, are given in Section 2 below.

Implement the operators Filter (filter_op.go) and Join (join_op.go) and verify that their corresponding tests work. The comments in these operators contain details about how they should work.

Implement CountAggState, SumAggState, AvgAggState, MinAggState, and MaxAggState in agg_state.go. Here, you will write the logic that actually maintains an aggregation state over a particular field across multiple groups over a running sequence of input tuples. Use integer division for computing the average, since GoDB only supports integers. Only CountAggState, MinAggState, and MaxAggState needs to support both strings and integers, since the other operations do not make sense for strings.

Implement the Aggregate (agg_op.go) operator. As with other operators, aggregates implement the Iterator method so that they can be placed in GoDB query plans. Note that the output of an Aggregate operator is an aggregate value of an entire group for each call to the iterator, and that the aggregate constructor takes the aggregation and grouping fields.

Implement the Insert (insert_op.go) and Delete (delete_op.go) operators. Like all operators, Insert and Delete implement Iterator, accepting a stream of tuples to insert or delete and outputting a single tuple with an integer field that indicates the number of tuples inserted or deleted. Check that the tests for inserting and deleting tuples work properly.

Implement the Project (project_op.go), OrderBy (order_by_op.go), and Limit (limit_op.go) operators.

type Filter[T constraints.Ordered] struct {
	op     BoolOp
	left   Expr
	right  Expr
	child  Operator
	getter func(DBValue) T
}   

_, t1, t2, hf, _, tid := makeTestVars()
	hf.insertTuple(&t1, tid)
	hf.insertTuple(&t2, tid)
	var f FieldType = FieldType{"name", "", StringType}
	filt, err := NewStringFilter(&ConstExpr{StringField{"sam"}, StringType}, OpEq, &FieldExpr{f}, hf)

func NewIntFilter(constExpr Expr, op BoolOp, field Expr, child Operator) (*Filter[int64], error) {
	if constExpr.GetExprType().Ftype != IntType || field.GetExprType().Ftype != IntType {
		return nil, GoDBError{IncompatibleTypesError, "cannot apply int filter to non int-types"}
	}
	f, err := newFilter[int64](constExpr, op, field, child, intFilterGetter)
	return f, err
}

// Return a TupleDescriptor for this filter op.
func (f *Filter[T]) Descriptor() *TupleDesc {
	// TODO: some code goes here
	return f.child.Descriptor()
}

func TestDescriptor(t *testing.T) {
	_, t1, t2, hf, _, tid := makeTestVars()
	hf.insertTuple(&t1, tid)
	hf.insertTuple(&t2, tid)
	var f FieldType = FieldType{"age", "", IntType}
	filt, err := NewIntFilter(&ConstExpr{IntField{25}, IntType}, OpGt, &FieldExpr{f}, hf)
	if err != nil {
		t.Errorf(err.Error())
	}
	desc := filt.Descriptor()
	fmt.Printf("filter desc: %v\n", desc)
}

// Filter operator implementation. This function should iterate over
// the results of the child iterator and return a tuple if it satisfies
// the predicate.
// HINT: you can use the evalPred function defined in types.go to compare two values
func (f *Filter[T]) Iterator(tid TransactionID) (func() (*Tuple, error), error) {
	// TODO: some code goes here
	
	return nil, nil
}

func (f *Filter[T]) Iterator(tid TransactionID) (func() (*Tuple, error), error) {
	// TODO: some code goes here
	return func() (*Tuple, error) {
		return nil, nil
	}, nil
}

func (f *Filter[T]) Iterator(tid TransactionID) (func() (*Tuple, error), error) {
	// TODO: some code goes here
	iter, err := f.child.Iterator(tid)
	if err != nil {
		return nil, err
	}
	return func() (*Tuple, error) {
		for {
			tuple, err := iter()
			if err != nil || tuple == nil {
				return nil, err
			}
			return tuple, nil
		}
	}, nil
}

// HINT: you can use the evalPred function defined in types.go to compare two values

func evalPred[T constraints.Ordered](i1 T, i2 T, op BoolOp) bool {
	switch op {
	case OpEq:
		return i1 == i2
	case OpNeq:
		return i1 != i2
	case OpGt:
		return i1 > i2
	case OpGe:
		return i1 >= i2
	case OpLt:
		return i1 < i2
	case OpLe:
		return i1 <= i2
	case OpLike:
		s1, ok := any(i1).(string)
		if !ok {
			return false
		}
		regex, ok := any(i2).(string)
		if !ok {
			return false
		}
		regex = "^" + regex + "$"
		regex = strings.Replace(regex, "%", ".*?", -1)
		match, _ := regexp.MatchString(regex, s1)
		return match
	}
	return false

}

func (f *Filter[T]) Iterator(tid TransactionID) (func() (*Tuple, error), error) {
	// TODO: some code goes here
	iter, err := f.child.Iterator(tid)
	if err != nil {
		return nil, err
	}
	return func() (*Tuple, error) {
		for {
			tuple, err := iter()
			if err != nil || tuple == nil {
				return nil, err
			}
			leftVal, _ := f.left.EvalExpr(tuple)
			rightVal, _ := f.right.EvalExpr(tuple)
			tmp := evalPred(f.getter(leftVal), f.getter(rightVal), f.op)
			_ = tmp
			if evalPred(f.getter(leftVal), f.getter(rightVal), f.op) {
				return tuple, nil
			}
		}
	}, nil
}