Function createTraceIterator

tempodb/encoding/vparquet5/block_traceql.go:2557–2667

(makeIter makeIterFn, resourceIter parquetquery.Iterator, conds []traceql.Condition, start, end uint64, allConditions bool, selectAll bool,
	sampler traceql.Sampler,
)

}

func createTraceIterator(makeIter makeIterFn, resourceIter parquetquery.Iterator, conds []traceql.Condition, start, end uint64, allConditions bool, selectAll bool,
	sampler traceql.Sampler,
) (parquetquery.Iterator, error) {
	iters := make([]parquetquery.Iterator, 0, 3)
	metaIters := make([]parquetquery.Iterator, 0)

	if selectAll {
		for intrins, entry := range intrinsicColumnLookups {
			if entry.scope != intrinsicScopeTrace {
				continue
			}
			// These intrinsics aren't included in select all because they are not
			// useful for filtering or grouping.
			switch intrins {
			case traceql.IntrinsicTraceStartTime,
				traceql.IntrinsicServiceStats:
				continue
			}
			iters = append(iters, makeIter(entry.columnPath, nil, entry.columnPath))
		}
	} else {
		// add conditional iterators first. this way if someone searches for { traceDuration > 1s && span.foo = "bar"} the query will
		// be sped up by searching for traceDuration first. note that we can only set the predicates if all conditions is true.
		// otherwise we just pass the info up to the engine to make a choice
		for _, cond := range conds {
			switch cond.Attribute.Intrinsic {
			case traceql.IntrinsicTraceID:
				if cond.Op == traceql.OpNone && cond.CallBack != nil {
					metaIters = append(metaIters, makeIter(columnPathTraceID, parquetquery.NewCallbackPredicate(cond.CallBack), columnPathTraceID))
				} else {
					pred, err := createBytesPredicate(cond.Op, cond.Operands, false)
					if err != nil {
						return nil, err
					}
					iters = append(iters, makeIter(columnPathTraceID, pred, columnPathTraceID))
				}
			case traceql.IntrinsicTraceDuration:
				pred, err := createDurationPredicate(cond.Op, cond.Operands)
				if err != nil {
					return nil, err
				}
				iters = append(iters, makeIter(columnPathDurationNanos, pred, columnPathDurationNanos))
			case traceql.IntrinsicTraceStartTime:
				if start == 0 && end == 0 {
					iters = append(iters, makeIter(columnPathStartTimeUnixNano, nil, columnPathStartTimeUnixNano))
				}
			case traceql.IntrinsicTraceRootSpan:
				pred, err := createStringPredicate(cond.Op, cond.Operands)
				if err != nil {
					return nil, err
				}
				iters = append(iters, makeIter(columnPathRootSpanName, pred, columnPathRootSpanName))
			case traceql.IntrinsicTraceRootService:
				pred, err := createStringPredicate(cond.Op, cond.Operands)
				if err != nil {
					return nil, err
				}
				iters = append(iters, makeIter(columnPathRootServiceName, pred, columnPathRootServiceName))