sqry-core 6.0.21

Core library for sqry - semantic code search engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

// Performance Optimization Benchmarks
// Phase 1: Classifier optimization benchmarks

use criterion::{Criterion, criterion_group, criterion_main};
use sqry_core::search::classifier::QueryClassifier;
use std::hint::black_box;

fn bench_classifier(c: &mut Criterion) {
    let mut group = c.benchmark_group("classifier");

    // Semantic queries with different patterns
    group.bench_function("semantic_single_field", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("kind:function"));
            black_box(ty)
        });
    });

    group.bench_function("semantic_relation_parentheses", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("callers(MyFunction)"));
            black_box(ty)
        });
    });

    group.bench_function("semantic_relation_colon", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("callees:bar"));
            black_box(ty)
        });
    });

    group.bench_function("semantic_complex", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box(
                "kind:function AND async:true OR visibility:public",
            ));
            black_box(ty)
        });
    });

    group.bench_function("semantic_ast_node", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("@function.def"));
            black_box(ty)
        });
    });

    group.bench_function("semantic_symbol_path", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("foo::bar::baz"));
            black_box(ty)
        });
    });

    // Text queries with different patterns
    group.bench_function("text_simple_marker", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("TODO: fix this"));
            black_box(ty)
        });
    });

    group.bench_function("text_regex_anchor", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("^fn main"));
            black_box(ty)
        });
    });

    group.bench_function("text_character_class", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("fn \\w+"));
            black_box(ty)
        });
    });

    // Hybrid/ambiguous queries
    group.bench_function("hybrid_simple_identifier", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("find_user"));
            black_box(ty)
        });
    });

    group.bench_function("hybrid_short_query", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("error"));
            black_box(ty)
        });
    });

    // Edge cases
    group.bench_function("empty_query", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box(""));
            black_box(ty)
        });
    });

    group.bench_function("long_query", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box(
                "kind:function AND async:true OR (callers(foo) AND callees(bar)) OR visibility:public AND scope:module::MyClass",
            ));
            black_box(ty)
      });
  });

    group.bench_function("unicode_query", |b| {
        b.iter(|| {
            let ty = QueryClassifier::classify(black_box("kind:函数 AND foo::バー::baz"));
            black_box(ty)
        });
    });

    group.finish();
}

criterion_group!(benches, bench_classifier);
criterion_main!(benches);