func BuildLocalFilter()

in pkg/query/logical/index_filter.go [50:117]
68 lines of code
20 McCabe index (conditional complexity)

func BuildLocalFilter(criteria *modelv1.Criteria, schema Schema, entityDict map[string]int, entity tsdb.Entity) (index.Filter, []tsdb.Entity, error) {
	if criteria == nil {
		return nil, []tsdb.Entity{entity}, nil
	}
	switch criteria.GetExp().(type) {
	case *modelv1.Criteria_Condition:
		cond := criteria.GetCondition()
		expr, parsedEntity, err := parseExprOrEntity(entityDict, entity, cond)
		if err != nil {
			return nil, nil, err
		}
		if parsedEntity != nil {
			return nil, parsedEntity, nil
		}
		if ok, indexRule := schema.IndexDefined(cond.Name); ok {
			if indexRule.Location == databasev1.IndexRule_LOCATION_GLOBAL {
				switch cond.Op {
				case modelv1.Condition_BINARY_OP_EQ, modelv1.Condition_BINARY_OP_IN:
					return nil, nil, GlobalIndexError{
						IndexRule: indexRule,
						Expr:      expr,
					}
				default:
					return nil, nil, errors.Wrapf(errUnsupportedConditionOp, "gobal index conf:%s", cond)
				}
			}
			return parseCondition(cond, indexRule, expr, entity)
		}
		return eNode, []tsdb.Entity{entity}, nil
	case *modelv1.Criteria_Le:
		le := criteria.GetLe()
		if le.GetLeft() == nil && le.GetRight() == nil {
			return nil, nil, errors.WithMessagef(errInvalidLogicalExpression, "both sides(left and right) of [%v] are empty", criteria)
		}
		if le.GetLeft() == nil {
			return BuildLocalFilter(le.Right, schema, entityDict, entity)
		}
		if le.GetRight() == nil {
			return BuildLocalFilter(le.Left, schema, entityDict, entity)
		}
		left, leftEntities, err := BuildLocalFilter(le.Left, schema, entityDict, entity)
		if err != nil {
			return nil, nil, err
		}
		right, rightEntities, err := BuildLocalFilter(le.Right, schema, entityDict, entity)
		if err != nil {
			return nil, nil, err
		}
		entities := parseEntities(le.Op, entity, leftEntities, rightEntities)
		if entities == nil {
			return nil, nil, nil
		}
		if left == nil && right == nil {
			return nil, entities, nil
		}
		switch le.Op {
		case modelv1.LogicalExpression_LOGICAL_OP_AND:
			and := newAnd(2)
			and.append(left).append(right)
			return and, entities, nil
		case modelv1.LogicalExpression_LOGICAL_OP_OR:
			or := newOr(2)
			or.append(left).append(right)
			return or, entities, nil
		}
	}
	return nil, nil, errInvalidCriteriaType
}