Function evalDo

engine/transformer.go:69–127

evalDo evaluates a do statement (currently: only "|> do fn::group_by") A do-transform acts on a whole result relation.

(
	head ast.Atom,
	transform ast.Transform,
	input []ast.ConstSubstList,
	emit func(atom ast.Atom) bool)

// evalDo evaluates a do statement (currently: only "|> do fn::group_by")
// A do-transform acts on a whole result relation.
func evalDo(
	head ast.Atom,
	transform ast.Transform,
	input []ast.ConstSubstList,
	emit func(atom ast.Atom) bool) error {

	doStmt := transform.Statements[0]
	switch doStmt.Fn.Function.Symbol {
	case symbols.GroupBy.Symbol:
		keyToGroup := make(map[uint32]grouped)

		for _, subst := range input {
			keyLen := len(doStmt.Fn.Args)
			key := make([]ast.Constant, keyLen)
			b := make([]byte, 8*keyLen)
			for i, v := range doStmt.Fn.Args {
				value := subst.Get(v.(ast.Variable)).(ast.Constant)
				binary.LittleEndian.PutUint64(b[i*8:], value.Hash())
				key[i] = value
			}
			hasher := fnv.New32()
			hasher.Write(b)
			h := hasher.Sum32()
			group, ok := keyToGroup[h]
			if !ok {
				group = grouped{key, nil}
			}
			group.values = append(group.values, subst)
			keyToGroup[h] = group
		}
		// Now apply reductions.
		for _, group := range keyToGroup {
			var subst ast.ConstSubstList
			for i, v := range group.key {
				subst = subst.Extend(doStmt.Fn.Args[i].(ast.Variable), v)
			}
			for _, stmt := range transform.Statements[1:] {
				if builtin.IsReducerFunction(stmt.Fn.Function) {
					con, err := functional.EvalReduceFn(stmt.Fn, group.values)
					if err != nil {
						return err
					}
					subst = subst.Extend(*stmt.Var, con)
				} else {
					// Do a "map" of rows (substitutions set).
					// First, copy over bindings from subst
					con, err := functional.EvalApplyFn(stmt.Fn, subst)
					if err != nil {
						return err
					}
					subst = subst.Extend(*stmt.Var, con)
				}
			}
			emit(head.ApplySubst(subst).(ast.Atom))
		}
	default:
	}
	return nil