func parseConditionToQuery()

in pkg/index/inverted/query.go [269:385]
117 lines of code
28 McCabe index (conditional complexity)

func parseConditionToQuery(cond *modelv1.Condition, indexRule *databasev1.IndexRule,
	expr logical.LiteralExpr, fieldKey string,
) (*queryNode, error) {
	str := expr.String()
	switch cond.Op {
	case modelv1.Condition_BINARY_OP_GT:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query := bluge.NewTermRangeInclusiveQuery(convert.BytesToString(bb[0]), maxTerm, false, false).SetField(fieldKey)
		node := newTermRangeInclusiveNode(str, maxInf, false, false, indexRule, false)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_GE:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query := bluge.NewTermRangeInclusiveQuery(convert.BytesToString(bb[0]), maxTerm, true, false).SetField(fieldKey)
		node := newTermRangeInclusiveNode(str, maxInf, true, false, indexRule, false)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_LT:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query := bluge.NewTermRangeInclusiveQuery(minTerm, convert.BytesToString(bb[0]), false, false).SetField(fieldKey)
		node := newTermRangeInclusiveNode(minInf, str, false, false, indexRule, false)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_LE:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query := bluge.NewTermRangeInclusiveQuery(minTerm, convert.BytesToString(bb[0]), false, true).SetField(fieldKey)
		node := newTermRangeInclusiveNode(minInf, str, false, true, indexRule, false)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_EQ:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query := bluge.NewTermQuery(convert.BytesToString(bb[0])).SetField(fieldKey)
		node := newTermNode(str, indexRule)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_MATCH:
		if indexRule == nil {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "index rule is mandatory for match operation: %s", cond)
		}
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		analyzer, operator := getMatchOptions(indexRule.Analyzer, cond.MatchOption)
		query := bluge.NewMatchQuery(convert.BytesToString(bb[0])).SetField(fieldKey).SetAnalyzer(analyzer).SetOperator(operator)
		node := newMatchNode(str, indexRule)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_NE:
		bb := expr.Bytes()
		if len(bb) != 1 {
			return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "don't support multiple or null value: %s", cond)
		}
		query, node := bluge.NewBooleanQuery(), newMustNotNode()
		query.AddMustNot(bluge.NewTermQuery(convert.BytesToString(bb[0])).SetField(fieldKey))
		node.SetSubNode(newTermNode(str, indexRule))
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_HAVING:
		bb, elements := expr.Bytes(), expr.Elements()
		query, node := bluge.NewBooleanQuery(), newMustNode()
		for _, b := range bb {
			query.AddMust(bluge.NewTermQuery(string(b)).SetField(fieldKey))
		}
		for _, e := range elements {
			node.Append(newTermNode(e, indexRule))
		}
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_NOT_HAVING:
		bb, elements := expr.Bytes(), expr.Elements()
		subQuery, subNode := bluge.NewBooleanQuery(), newMustNode()
		for _, b := range bb {
			subQuery.AddMust(bluge.NewTermQuery(string(b)).SetField(fieldKey))
		}
		for _, e := range elements {
			subNode.Append(newTermNode(e, indexRule))
		}
		query, node := bluge.NewBooleanQuery(), newMustNotNode()
		query.AddMustNot(subQuery)
		node.SetSubNode(node)
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_IN:
		bb, elements := expr.Bytes(), expr.Elements()
		query, node := bluge.NewBooleanQuery(), newShouldNode()
		query.SetMinShould(1)
		for _, b := range bb {
			query.AddShould(bluge.NewTermQuery(string(b)).SetField(fieldKey))
		}
		for _, e := range elements {
			node.Append(newTermNode(e, indexRule))
		}
		return &queryNode{query, node}, nil
	case modelv1.Condition_BINARY_OP_NOT_IN:
		bb, elements := expr.Bytes(), expr.Elements()
		subQuery, subNode := bluge.NewBooleanQuery(), newShouldNode()
		subQuery.SetMinShould(1)
		for _, b := range bb {
			subQuery.AddShould(bluge.NewTermQuery(string(b)).SetField(fieldKey))
		}
		for _, e := range elements {
			subNode.Append(newTermNode(e, indexRule))
		}
		query, node := bluge.NewBooleanQuery(), newMustNotNode()
		query.AddMustNot(subQuery)
		node.SetSubNode(subNode)
		return &queryNode{query, node}, nil
	}
	return nil, errors.WithMessagef(logical.ErrUnsupportedConditionOp, "index filter parses %v", cond)
}