Method propagateSortKeyOp

compiler/optimizer/optimizer.go:316–396

(op dag.Op, parents []order.SortKeys)

}

func (o *Optimizer) propagateSortKeyOp(op dag.Op, parents []order.SortKeys) ([]order.SortKeys, error) {
	switch op.(type) {
	case *dag.HashJoinOp, *dag.JoinOp:
		return []order.SortKeys{nil}, nil
	}
	// If the op is not a join then condense sort order into a single parent,
	// since all the ops only care about the sort order of multiple parents if
	// the SortKey of all parents is unified.
	var parent order.SortKeys
	for k, p := range parents {
		if k == 0 {
			parent = p
		} else if !parent.Equal(p) {
			parent = nil
			break
		}
	}
	switch op := op.(type) {
	case *dag.AggregateOp:
		if parent.IsNil() {
			return []order.SortKeys{nil}, nil
		}
		//XXX handle only primary sortKey for now
		sortKey := parent.Primary()
		for _, k := range op.Keys {
			if groupingKey := fieldOf(k.LHS); groupingKey.Equal(sortKey.Key) {
				rhsExpr := k.RHS
				rhs := fieldOf(rhsExpr)
				if rhs.Equal(sortKey.Key) || orderPreservingCall(rhsExpr, groupingKey) {
					op.InputSortDir = int(sortKey.Order.Direction())
					// Currently, the aggregate operator will sort its
					// output according to the primary key, but we
					// should relax this and do an analysis here as
					// to whether the sort is necessary for the
					// downstream consumer.
					return []order.SortKeys{parent}, nil
				}
			}
		}
		// We'll leave this as unknown for now in spite of the aggregate
		// and not try to optimize downstream of the first aggregate
		// unless there is an excplicit sort encountered.
		return []order.SortKeys{nil}, nil
	case *dag.ForkOp:
		var keys []order.SortKeys
		for _, seq := range op.Paths {
			out, err := o.propagateSortKey(seq, []order.SortKeys{parent})
			if err != nil {
				return nil, err
			}
			keys = append(keys, out...)
		}
		return keys, nil
	case *dag.ScatterOp:
		var keys []order.SortKeys
		for _, seq := range op.Paths {
			out, err := o.propagateSortKey(seq, []order.SortKeys{parent})
			if err != nil {