Function createResourceIterator

tempodb/encoding/vparquet3/block_traceql.go:1802–1942

createResourceIterator iterates through all resourcespans-level (batch-level) columns, groups them into rows representing one batch each. It builds on top of the span iterator, and turns the groups of spans and resource-level values into spansets. Spansets are returned that match any of the given co

(makeIter, makeNilIter makeIterFn, spanIterator parquetquery.Iterator, conditions []traceql.Condition, requireAtLeastOneMatchOverall, allConditions bool, dedicatedColumns backend.DedicatedColumns, selectAll bool)

// one batch each. It builds on top of the span iterator, and turns the groups of spans and resource-level values into
// spansets. Spansets are returned that match any of the given conditions.
func createResourceIterator(makeIter, makeNilIter makeIterFn, spanIterator parquetquery.Iterator, conditions []traceql.Condition, requireAtLeastOneMatchOverall, allConditions bool, dedicatedColumns backend.DedicatedColumns, selectAll bool) (parquetquery.Iterator, error) {
	var (
		columnSelectAs    = map[string]string{}
		columnPredicates  = map[string][]parquetquery.Predicate{}
		iters             = []parquetquery.Iterator{}
		genericConditions []traceql.Condition
		columnMapping     = dedicatedColumnsToColumnMapping(dedicatedColumns, backend.DedicatedColumnScopeResource)
	)

	addPredicate := func(columnPath string, p parquetquery.Predicate) {
		columnPredicates[columnPath] = append(columnPredicates[columnPath], p)
	}

	specialCase := func(cond traceql.Condition, columnPath string) (handled bool) {
		// Operands that need special handling.
		switch cond.Op {
		case traceql.OpNone:
			addPredicate(columnPath, nil) // No filtering
			columnSelectAs[columnPath] = cond.Attribute.Name
			return true
		case traceql.OpExists:
			addPredicate(columnPath, &parquetquery.SkipNilsPredicate{})
			columnSelectAs[columnPath] = cond.Attribute.Name
			return true
		case traceql.OpNotExists:
			iters = append(iters, makeIter(columnPath, parquetquery.NewNilValuePredicate(), cond.Attribute.Name))
			return true
		default:
			return false
		}
	}

	for _, cond := range conditions {
		isNotExistSearch := len(cond.Operands) == 0 && cond.Op == traceql.OpNotExists

		// Well-known selector?
		if entry, ok := wellKnownColumnLookups[cond.Attribute.Name]; ok && entry.level != traceql.AttributeScopeSpan {
			if specialCase(cond, entry.columnPath) {
				continue
			}

			// Compatible type?
			if isMatchingColumnType(entry.typ, operandType(cond.Operands)) {
				pred, err := createPredicate(cond.Op, cond.Operands)
				if err != nil {
					return nil, fmt.Errorf("creating predicate: %w", err)
				}
				iters = append(iters, makeIter(entry.columnPath, pred, cond.Attribute.Name))
				continue
			}
		}

		// Attributes stored in dedicated columns
		if c, ok := columnMapping.get(cond.Attribute.Name); ok {
			if specialCase(cond, c.ColumnPath) {
				continue
			}