29806785540

Committed 21 Jul 2026 06:21AM UTC coverage: 52.837% (+0.2%) from 52.66%

Build # 29806785540

Build Type

Pull #99

github

Committed by

web-flow

Commit Message

Merge 28252dedf into 06bc84ec9

Pull Request Pull Request #99: Support CM time_metric (NS/MS/SEC/US) across reader and viz

Coverage Stats

41074 of 100799 branches covered (40.75%)

Branch coverage included in aggregate %.

1063 of 1183 new or added lines in 30 files covered. (89.86%)

32 existing lines in 7 files now uncovered.

36302 of 45643 relevant lines covered (79.53%)

23461.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.83

/src/dftracer/utils/utilities/common/query/ast.cpp

#include <dftracer/utils/utilities/common/query/ast.h>

#include <sstream>
#include <string>

namespace dftracer::utils::utilities::common::query {

const char* compare_op_str(CompareOp op) {
    switch (op) {
        case CompareOp::EQ:
            return "==";
        case CompareOp::NE:
            return "!=";
        case CompareOp::GT:
            return ">";
        case CompareOp::LT:
            return "<";
        case CompareOp::GE:
            return ">=";
        case CompareOp::LE:
            return "<=";
    }
    return "??";
}

namespace {

// Operator keyword for a like/regex MatchNode ("in" is handled separately
// since its serialization is literal-first).
const char* match_op_str(MatchOp op, bool negated) {
    switch (op) {
        case MatchOp::LIKE:
            return negated ? "not like" : "like";
        case MatchOp::ILIKE:
            return negated ? "not ilike" : "ilike";
        case MatchOp::REGEX:
            return negated ? "!~" : "~";
        case MatchOp::IREGEX:
            return negated ? "!~*" : "~*";
        case MatchOp::ICONTAINS:
            break;
    }
    return "??";
}

void literal_to_string(std::ostringstream& os, const LiteralNode& lit) {
    std::visit(
        [&os](auto&& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::string>) {
                os << '"' << v << '"';
            } else if constexpr (std::is_same_v<T, bool>) {
                os << (v ? "true" : "false");
            } else if constexpr (std::is_same_v<T, int64_t>) {
                os << v;
            } else if constexpr (std::is_same_v<T, uint64_t>) {
                os << v;
            } else if constexpr (std::is_same_v<T, double>) {
                os << v;
            }
        },
        lit.value);
}

void array_to_string(std::ostringstream& os, const ArrayNode& arr) {
    os << '[';
    for (std::size_t i = 0; i < arr.elements.size(); ++i) {
        if (i > 0) os << ", ";
        literal_to_string(os, arr.elements[i]);
    }
    os << ']';
}

void node_to_string(std::ostringstream& os, const QueryNode& node) {
    std::visit(
        [&os](auto&& n) {
            using T = std::decay_t<decltype(n)>;
            if constexpr (std::is_same_v<T, CompareNode>) {
                os << n.field.path << ' ' << compare_op_str(n.op) << ' ';
                literal_to_string(os, n.value);
            } else if constexpr (std::is_same_v<T, InNode>) {
                os << n.field.path << " in ";
                array_to_string(os, n.values);
            } else if constexpr (std::is_same_v<T, NotInNode>) {
                os << n.field.path << " not in ";
                array_to_string(os, n.values);
            } else if constexpr (std::is_same_v<T, MatchNode>) {
                if (n.op == MatchOp::ICONTAINS) {
                    os << '"' << n.pattern
                       << (n.negated ? "\" not in " : "\" in ") << n.field.path;
                } else {
                    os << n.field.path << ' ' << match_op_str(n.op, n.negated)
                       << " \"" << n.pattern << '"';
                }
            } else if constexpr (std::is_same_v<T, AndNode>) {
                os << '(';
                node_to_string(os, *n.left);
                os << " and ";
                node_to_string(os, *n.right);
                os << ')';
            } else if constexpr (std::is_same_v<T, OrNode>) {
                os << '(';
                node_to_string(os, *n.left);
                os << " or ";
                node_to_string(os, *n.right);
                os << ')';
            } else if constexpr (std::is_same_v<T, NotNode>) {
                os << "not (";
                node_to_string(os, *n.operand);
                os << ')';
            }
        },
        node.data);
}

void collect_fields_impl(const QueryNode& node,
                         dftracer::utils::StringViewSet& out) {
    std::visit(
        [&out](auto&& n) {
            using T = std::decay_t<decltype(n)>;
            if constexpr (std::is_same_v<T, CompareNode>) {
                out.insert(n.field.path);
            } else if constexpr (std::is_same_v<T, InNode>) {
                out.insert(n.field.path);
            } else if constexpr (std::is_same_v<T, NotInNode>) {
                out.insert(n.field.path);
            } else if constexpr (std::is_same_v<T, MatchNode>) {
                out.insert(n.field.path);
            } else if constexpr (std::is_same_v<T, AndNode>) {
                collect_fields_impl(*n.left, out);
                collect_fields_impl(*n.right, out);
            } else if constexpr (std::is_same_v<T, OrNode>) {
                collect_fields_impl(*n.left, out);
                collect_fields_impl(*n.right, out);
            } else if constexpr (std::is_same_v<T, NotNode>) {
                collect_fields_impl(*n.operand, out);
            }
        },
        node.data);
}

}  // namespace

std::string to_string(const QueryNode& node) {
    std::ostringstream os;
    node_to_string(os, node);
    return os.str();
}

dftracer::utils::StringViewSet collect_fields(const QueryNode& node) {
    dftracer::utils::StringViewSet fields;
    collect_fields_impl(node, fields);
    return fields;
}

}  // namespace dftracer::utils::utilities::common::query

1	#include <dftracer/utils/utilities/common/query/ast.h>
2
3	#include <sstream>
4	#include <string>
5
6	namespace dftracer::utils::utilities::common::query {
7
8	const char* compare_op_str(CompareOp op) {	8✔
9	switch (op) {	8!
10	case CompareOp::EQ:	3✔
11	return "==";	6✔
12	case CompareOp::NE:
13	return "!=";	×
14	case CompareOp::GT:	1✔
15	return ">";	2✔
16	case CompareOp::LT:
17	return "<";	×
18	case CompareOp::GE:
19	return ">=";	×
20	case CompareOp::LE:
21	return "<=";	×
22	}
23	return "??";	×
24	}	4✔
25
26	namespace {
27
28	// Operator keyword for a like/regex MatchNode ("in" is handled separately
29	// since its serialization is literal-first).
30	const char* match_op_str(MatchOp op, bool negated) {	12✔
31	switch (op) {	12!
32	case MatchOp::LIKE:	2✔
33	return negated ? "not like" : "like";	4✔
34	case MatchOp::ILIKE:	1✔
35	return negated ? "not ilike" : "ilike";	2!
36	case MatchOp::REGEX:	2✔
37	return negated ? "!~" : "~";	4✔
38	case MatchOp::IREGEX:	1✔
39	return negated ? "!~" : "~";	2!
40	case MatchOp::ICONTAINS:
NEW 41	break;	×
42	}
NEW 43	return "??";	×
44	}	6✔
45
46	void literal_to_string(std::ostringstream& os, const LiteralNode& lit) {	34✔
47	std::visit(	51✔
48	[&os](auto&& v) {	51✔
49	using T = std::decay_t<decltype(v)>;
50	if constexpr (std::is_same_v<T, std::string>) {
51	os << '"' << v << '"';	32✔
52	} else if constexpr (std::is_same_v<T, bool>) {
53	os << (v ? "true" : "false");	×
54	} else if constexpr (std::is_same_v<T, int64_t>) {
55	os << v;	×
56	} else if constexpr (std::is_same_v<T, uint64_t>) {
57	os << v;	2✔
58	} else if constexpr (std::is_same_v<T, double>) {
59	os << v;	×
60	}
61	},	34✔
62	lit.value);	34!
63	}	34✔
64
65	void array_to_string(std::ostringstream& os, const ArrayNode& arr) {	20✔
66	os << '[';	20✔
67	for (std::size_t i = 0; i < arr.elements.size(); ++i) {	46✔
68	if (i > 0) os << ", ";	26✔
69	literal_to_string(os, arr.elements[i]);	26✔
70	}	13✔
71	os << ']';	20✔
72	}	20✔
73
74	void node_to_string(std::ostringstream& os, const QueryNode& node) {	48✔
75	std::visit(	72✔
76	[&os](auto&& n) {	102✔
77	using T = std::decay_t<decltype(n)>;
78	if constexpr (std::is_same_v<T, CompareNode>) {
79	os << n.field.path << ' ' << compare_op_str(n.op) << ' ';	8✔
80	literal_to_string(os, n.value);	8✔
81	} else if constexpr (std::is_same_v<T, InNode>) {
82	os << n.field.path << " in ";	16✔
83	array_to_string(os, n.values);	16✔
84	} else if constexpr (std::is_same_v<T, NotInNode>) {
85	os << n.field.path << " not in ";	4✔
86	array_to_string(os, n.values);	4✔
87	} else if constexpr (std::is_same_v<T, MatchNode>) {
88	if (n.op == MatchOp::ICONTAINS) {	16✔
89	os << '"' << n.pattern	4✔
90	<< (n.negated ? "\" not in " : "\" in ") << n.field.path;	4✔
91	} else {	2✔
92	os << n.field.path << ' ' << match_op_str(n.op, n.negated)	18✔
93	<< " \"" << n.pattern << '"';	12✔
94	}
95	} else if constexpr (std::is_same_v<T, AndNode>) {
96	os << '(';	4✔
97	node_to_string(os, *n.left);	4✔
98	os << " and ";	4✔
99	node_to_string(os, *n.right);	4✔
100	os << ')';	4✔
101	} else if constexpr (std::is_same_v<T, OrNode>) {
102	os << '(';	×
103	node_to_string(os, *n.left);	×
104	os << " or ";	×
105	node_to_string(os, *n.right);	×
106	os << ')';	×
107	} else if constexpr (std::is_same_v<T, NotNode>) {
108	os << "not (";	×
109	node_to_string(os, *n.operand);	×
110	os << ')';	×
111	}
112	},	48✔
113	node.data);	48!
114	}	48✔
115
116	void collect_fields_impl(const QueryNode& node,	978✔
117	dftracer::utils::StringViewSet& out) {
118	std::visit(	1,467✔
119	[&out](auto&& n) {	1,566✔
120	using T = std::decay_t<decltype(n)>;
121	if constexpr (std::is_same_v<T, CompareNode>) {
122	out.insert(n.field.path);	680✔
123	} else if constexpr (std::is_same_v<T, InNode>) {
124	out.insert(n.field.path);	48✔
125	} else if constexpr (std::is_same_v<T, NotInNode>) {
126	out.insert(n.field.path);	8✔
127	} else if constexpr (std::is_same_v<T, MatchNode>) {
128	out.insert(n.field.path);	40✔
129	} else if constexpr (std::is_same_v<T, AndNode>) {
130	collect_fields_impl(*n.left, out);	98✔
131	collect_fields_impl(*n.right, out);	98✔
132	} else if constexpr (std::is_same_v<T, OrNode>) {
133	collect_fields_impl(*n.left, out);	100✔
134	collect_fields_impl(*n.right, out);	100✔
135	} else if constexpr (std::is_same_v<T, NotNode>) {
136	collect_fields_impl(*n.operand, out);	4✔
137	}
138	},	978✔
139	node.data);	978!
140	}	978✔
141
142	} // namespace
143
144	std::string to_string(const QueryNode& node) {	40✔
145	std::ostringstream os;	40!
146	node_to_string(os, node);	40!
147	return os.str();	60!
148	}	40✔
149
150	dftracer::utils::StringViewSet collect_fields(const QueryNode& node) {	578✔
151	dftracer::utils::StringViewSet fields;	578✔
152	collect_fields_impl(node, fields);	578!
153	return fields;	578✔
154	}	289!
155
156	} // namespace dftracer::utils::utilities::common::query

llnl / dftracer-utils / 29806785540

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous