Method handleHasFunction

worker/task.go:2679–2770

(ctx context.Context, q *pb.Query, out *pb.Result,
	srcFn *functionContext)

}

func (qs *queryState) handleHasFunction(ctx context.Context, q *pb.Query, out *pb.Result,
	srcFn *functionContext) error {
	span := trace.SpanFromContext(ctx)
	stop := x.SpanTimer(span, "handleHasFunction")
	defer stop()
	if glog.V(3) {
		glog.Infof("handleHasFunction query: %+v\n", q)
	}

	hasOrders := q.Order != nil && len(q.Order.Order) > 0

	sch, ok := schema.State().Get(ctx, q.Attr)
	isSortablePred := false
	if ok {
		isSortablePred = (sch.ValueType == pb.Posting_INT || sch.ValueType == pb.Posting_FLOAT || sch.ValueType == pb.Posting_DATETIME)
	}

	isIndexed := schema.State().IsIndexed(ctx, q.Attr)
	if isIndexed && ok && isSortablePred && hasOrders {
		var order *pb.Order
		for _, i := range q.Order.Order {
			if i.Attr == q.Attr {
				order = i
				break
			}
		}
		if order != nil {
			return qs.handleHasWithOrderFunction(ctx, q, out, order.Desc, int(q.Order.Offset), int(q.Order.Count), srcFn)
		}
	}

	initKey := x.ParsedKey{
		Attr: q.Attr,
	}
	startKey := x.DataKey(q.Attr, q.AfterUid+1)
	prefix := initKey.DataPrefix()
	if q.Reverse {
		// Reverse does not mean reverse iteration. It means we're looking for
		// the reverse index.
		startKey = x.ReverseKey(q.Attr, q.AfterUid+1)
		prefix = initKey.ReversePrefix()
	}

	result := &pb.List{}

	lang := langForFunc(q.Langs)
	needFiltering := needsStringFiltering(srcFn, q.Langs, q.Attr)

	// This function checks if we should include uid in result or not when has is queried with
	// @lang(eg: has(name@en)). We need to do this inside this function to return correct result
	// for first.
	checkInclusion := func(uid uint64) error {
		if !needFiltering {
			return nil
		}

		_, err := qs.getValsForUID(q.Attr, lang, uid, q.ReadTs)
		return err