Function parseSrcFn

worker/task.go:1922–2209

(ctx context.Context, q *pb.Query)

}

func parseSrcFn(ctx context.Context, q *pb.Query) (*functionContext, error) {
	fnType, f := parseFuncType(q.SrcFunc)
	attr := q.Attr
	fc := &functionContext{fnType: fnType, fname: f}
	isIndexedAttr := schema.State().IsIndexed(ctx, attr)
	var err error

	t, err := schema.State().TypeOf(attr)
	if err == nil && fnType != notAFunction && t.Name() == types.StringID.Name() {
		fc.isStringFn = true
	}

	switch fnType {
	case notAFunction:
		fc.n = len(q.UidList.Uids)
	case aggregatorFn:
		// confirm aggregator could apply on the attributes
		typ, err := schema.State().TypeOf(attr)
		if err != nil {
			return nil, errors.Errorf("Attribute %q is not scalar-type", x.ParseAttr(attr))
		}
		if !couldApplyAggregatorOn(f, typ) {
			return nil, errors.Errorf("Aggregator %q could not apply on %v",
				f, x.ParseAttr(attr))
		}
		fc.n = len(q.UidList.Uids)
	case compareAttrFn:
		args := q.SrcFunc.Args
		if fc.fname == eq { // Only eq can have multiple args. It should have atleast one.
			if len(args) < 1 {
				return nil, errors.Errorf("eq expects atleast 1 argument.")
			}
		} else if fc.fname == between { // between should have exactly 2 arguments.
			if len(args) != 2 {
				return nil, errors.Errorf("between expects exactly 2 argument.")
			}
		} else { // Others can have only 1 arg.
			if len(args) != 1 {
				return nil, errors.Errorf("%+v expects only 1 argument. Got: %+v",
					fc.fname, args)
			}
		}

		generateIneqTokens := true
		if fc.fname != eq && q.UidList != nil && uint64(len(q.UidList.Uids)) < Config.TypeFilterUidLimit {
			if !checkUidZero(q.UidList.Uids) {
				fc.n = len(q.UidList.Uids)
				generateIneqTokens = false
			}
		}

		var tokens []string
		var ineqValues []types.Val
		// eq can have multiple args.
		for idx := 0; idx < len(args); idx++ {
			arg := args[idx]
			ineqValues = ineqValues[:0]
			ineqValue1, err := convertValue(attr, arg)