mirror of
https://github.com/SigNoz/signoz.git
synced 2026-09-21 10:50:41 +01:00
9c886be120
The semantic convention family as first call citizen revealed that the
current state of the query builder needs a bit refactoring for long term
maintenance.
The `FieldMapper` and `ConditionBuilder` are now one abstraction
`Storage`.
A storage now answers
- what the compiler cannot know i.e one read per field key (the bare
SQL, the membership present or absent, what an absent row reads, and
whether the read keeps its type or filters only).
- the fallback for a key metadata does not report
- its traits
- and one Condition compilation part.
And we introduce a new type to use in the system, `Resolved`
```
// Resolved is what resolution produces for one key: its meanings, and how
// they came to be. It is the only thing the compilers receive. Compile it
// with the operator and value it was resolved with.
type Resolved struct {
Key *telemetrytypes.TelemetryFieldKey
Fields []*telemetrytypes.LogicalField
// FromFallback: the fields came from the storage's fallback, not from
// metadata matches.
FromFallback bool
// Ambiguous: the matches held several interpretations.
Ambiguous bool
// Skipped: the storage contributes nothing for this key.
Skipped bool
Warnings []string
}
```
The prepared SQL has no changes, where it changed, it specifically made
the expression better by removing the redundant part.
- The prepared SQL remains identical with this refactoring
- No changes to integration tests
Assisted-by: Claude Fable 5.1
48 lines
1.8 KiB
Go
48 lines
1.8 KiB
Go
package scopedtracesstatementbuilder
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/SigNoz/signoz/pkg/querybuilder"
|
|
qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
|
|
"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
|
|
"github.com/huandu/go-sqlbuilder"
|
|
)
|
|
|
|
// predicateResolver resolves key + operator + value to boolean predicates through the
|
|
// shared storage. Args bind into sb as $n markers, so returned predicates can be
|
|
// embedded anywhere in sb; maskExpr is set by the builder after resolveMask
|
|
// (Scoped* aggregates embed it).
|
|
type predicateResolver struct {
|
|
storage qbtypes.Storage
|
|
keys map[string][]*telemetrytypes.TelemetryFieldKey
|
|
sb *sqlbuilder.SelectBuilder
|
|
maskExpr string
|
|
}
|
|
|
|
func newPredicateResolver(storage qbtypes.Storage, keys map[string][]*telemetrytypes.TelemetryFieldKey, sb *sqlbuilder.SelectBuilder) *predicateResolver {
|
|
return &predicateResolver{storage: storage, keys: keys, sb: sb}
|
|
}
|
|
|
|
// ConditionFor returns a boolean predicate for key (materialized column when
|
|
// present, else map access), args bound into sb.
|
|
func (r *predicateResolver) ConditionFor(ctx context.Context, q qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) (string, error) {
|
|
conds, _, err := querybuilder.Conditions(ctx, q, r.storage, key, op, value, r.keys, false, r.sb)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(conds) == 0 {
|
|
return "", nil
|
|
}
|
|
// one condition per data-type variant of the key; OR them all
|
|
if len(conds) == 1 {
|
|
return conds[0], nil
|
|
}
|
|
return r.sb.Or(conds...), nil
|
|
}
|
|
|
|
// ExistsFor returns the EXISTS predicate for key.
|
|
func (r *predicateResolver) ExistsFor(ctx context.Context, q qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (string, error) {
|
|
return r.ConditionFor(ctx, q, key, qbtypes.FilterOperatorExists, nil)
|
|
}
|