qql_core/ast/
statement.rs

1use super::{FilterExpr, FormulaExpr, Value};
2use alloc::boxed::Box;
3use alloc::string::String;
4use alloc::vec::Vec;
5
6#[derive(Debug, Clone, PartialEq, Eq)]
7#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8pub enum PointId {
9    Number(u64),
10    String(String),
11}
12
13#[derive(Debug, Clone, PartialEq)]
14#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15pub enum VectorValue {
16    Dense(Vec<f32>),
17    Sparse { indices: Vec<u32>, values: Vec<f32> },
18    MultiDense(Vec<Vec<f32>>),
19}
20
21#[derive(Debug, Clone, PartialEq)]
22#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23pub enum PointVectors {
24    Unnamed(VectorValue),
25    Named(Vec<(String, VectorValue)>),
26}
27
28#[derive(Debug, Clone, PartialEq)]
29#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30pub enum QueryInput {
31    Text { text: String, model: Option<String> },
32    Vector(VectorValue),
33    Point(PointId),
34}
35
36#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
38pub enum VectorKind {
39    Dense,
40    Sparse,
41}
42
43#[derive(Debug, Clone, PartialEq, Eq)]
44#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
45pub struct VectorTarget {
46    pub name: String,
47    pub kind: Option<VectorKind>,
48}
49
50#[derive(Debug, Clone, PartialEq)]
51#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
52pub struct MmrConfig {
53    pub diversity: f64,
54    pub candidates: u64,
55}
56
57#[derive(Debug, Clone, PartialEq)]
58#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
59pub struct ContextPair {
60    pub positive: QueryInput,
61    pub negative: QueryInput,
62}
63
64#[derive(Debug, Clone, Copy, PartialEq, Eq)]
65#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
66pub enum RecommendStrategy {
67    AverageVector,
68    BestScore,
69    SumScores,
70}
71
72#[derive(Debug, Clone, PartialEq)]
73#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
74pub struct FeedbackItem {
75    pub example: QueryInput,
76    pub score: f64,
77}
78
79#[derive(Debug, Clone, Copy, PartialEq)]
80#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
81pub struct FeedbackStrategy {
82    pub a: f64,
83    pub b: f64,
84    pub c: f64,
85}
86
87#[derive(Debug, Clone, Copy, PartialEq, Eq)]
88#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
89pub enum OrderDirection {
90    Asc,
91    Desc,
92}
93
94#[derive(Debug, Clone, Copy, PartialEq, Eq)]
95#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
96pub enum FusionMethod {
97    Rrf,
98    Dbsf,
99}
100
101#[derive(Debug, Clone, PartialEq)]
102#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
103pub enum QueryCollection {
104    Explicit(String),
105    Inherited,
106}
107
108#[derive(Debug, Clone, PartialEq)]
109#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
110pub enum PrefetchSource {
111    Cte(String),
112    Query(Box<QueryStmt>),
113}
114
115#[derive(Debug, Clone, PartialEq)]
116#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
117pub struct LookupSpec {
118    pub collection: String,
119    pub vector: Option<String>,
120}
121
122#[derive(Debug, Clone, PartialEq)]
123#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
124pub struct Prefetch {
125    pub source: PrefetchSource,
126    pub filter: Option<Box<FilterExpr>>,
127    pub score_threshold: Option<f64>,
128    pub lookup: Option<LookupSpec>,
129}
130
131#[derive(Debug, Clone, PartialEq)]
132#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
133pub enum QueryExpr {
134    Points {
135        ids: Vec<PointId>,
136    },
137    Nearest {
138        input: QueryInput,
139        using: Option<VectorTarget>,
140        prefetch: Vec<Prefetch>,
141        mmr: Option<Box<MmrConfig>>,
142    },
143    Recommend {
144        positive: Vec<QueryInput>,
145        negative: Vec<QueryInput>,
146        strategy: Option<RecommendStrategy>,
147        using: Option<VectorTarget>,
148        prefetch: Vec<Prefetch>,
149    },
150    Context {
151        pairs: Vec<ContextPair>,
152        using: Option<VectorTarget>,
153        prefetch: Vec<Prefetch>,
154    },
155    Discover {
156        target: QueryInput,
157        context: Vec<ContextPair>,
158        using: Option<VectorTarget>,
159        prefetch: Vec<Prefetch>,
160    },
161    OrderBy {
162        field: String,
163        direction: OrderDirection,
164    },
165    SampleRandom,
166    Fusion {
167        method: FusionMethod,
168        prefetch: Vec<Prefetch>,
169    },
170    Formula {
171        expression: Box<FormulaExpr>,
172        defaults: Vec<(String, Value)>,
173        prefetch: Vec<Prefetch>,
174    },
175    RelevanceFeedback {
176        target: QueryInput,
177        feedback: Vec<FeedbackItem>,
178        strategy: FeedbackStrategy,
179        using: Option<VectorTarget>,
180        prefetch: Vec<Prefetch>,
181    },
182    Hybrid {
183        text: String,
184        model: Option<String>,
185        dense_vector: Option<String>,
186        sparse_vector: Option<String>,
187        fusion: FusionMethod,
188    },
189    Rerank {
190        input: QueryInput,
191        model: String,
192        using: Option<VectorTarget>,
193        prefetch: Vec<Prefetch>,
194    },
195}
196
197#[derive(Debug, Clone, PartialEq, Default)]
198#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
199pub struct QuantizationSearchParams {
200    pub ignore: Option<bool>,
201    pub rescore: Option<bool>,
202    pub oversampling: Option<f64>,
203}
204
205#[derive(Debug, Clone, PartialEq, Default)]
206#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
207pub struct SearchParams {
208    pub hnsw_ef: Option<u64>,
209    pub exact: Option<bool>,
210    pub acorn: Option<bool>,
211    pub indexed_only: Option<bool>,
212    pub quantization: Option<QuantizationSearchParams>,
213    pub rrf_k: Option<u64>,
214    pub rrf_weights: Option<Vec<f64>>,
215}
216
217#[derive(Debug, Clone, PartialEq)]
218#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
219pub enum PayloadSelector {
220    All,
221    None,
222    Include(Vec<String>),
223    Exclude(Vec<String>),
224}
225
226#[derive(Debug, Clone, PartialEq)]
227#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
228pub enum VectorSelector {
229    All,
230    None,
231    Names(Vec<String>),
232}
233
234#[derive(Debug, Clone, PartialEq, Default)]
235#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
236pub struct QueryOutput {
237    pub payload: Option<PayloadSelector>,
238    pub vectors: Option<VectorSelector>,
239}
240
241#[derive(Debug, Clone, PartialEq)]
242#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
243pub struct GroupSpec {
244    pub field: String,
245    pub size: Option<u64>,
246    pub lookup: Option<String>,
247}
248
249#[derive(Debug, Clone, PartialEq, Default)]
250#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
251pub struct PageSpec {
252    pub limit: Option<u64>,
253    pub offset: Option<u64>,
254}
255
256#[derive(Debug, Clone, PartialEq)]
257#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
258pub struct Cte {
259    pub name: String,
260    pub query: Box<QueryStmt>,
261}
262
263#[derive(Debug, Clone, PartialEq)]
264#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
265pub struct QueryStmt {
266    pub ctes: Vec<Cte>,
267    pub collection: QueryCollection,
268    pub expression: QueryExpr,
269    pub filter: Option<Box<FilterExpr>>,
270    pub params: Option<SearchParams>,
271    pub score_threshold: Option<f64>,
272    pub group: Option<GroupSpec>,
273    pub output: QueryOutput,
274    pub page: PageSpec,
275    pub shard_key: Option<String>,
276}
277
278#[derive(Debug, Clone, PartialEq)]
279#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
280pub struct ScrollStmt {
281    pub collection: String,
282    pub limit: u64,
283    pub filter: Option<Box<FilterExpr>>,
284    pub after: Option<PointId>,
285    pub shard_key: Option<String>,
286    /// Optional `WITH VECTOR` selector. Defaults to no vectors when `None`.
287    pub with_vector: Option<VectorSelector>,
288}
289
290#[derive(Debug, Clone, PartialEq)]
291#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
292pub enum EmbedKind {
293    Dense { model: Option<String> },
294    Sparse { model: Option<String> },
295}
296
297#[derive(Debug, Clone, PartialEq)]
298#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
299pub struct EmbedDirective {
300    pub source_field: String,
301    pub target_vector: String,
302    pub kind: EmbedKind,
303}
304
305#[derive(Debug, Clone, PartialEq)]
306#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
307pub enum EmbeddingSpec {
308    Dense {
309        model: Option<String>,
310        vector: Option<String>,
311        field: Option<String>,
312    },
313    Sparse {
314        model: Option<String>,
315        vector: Option<String>,
316        field: Option<String>,
317    },
318    Hybrid {
319        dense_model: Option<String>,
320        dense_vector: Option<String>,
321        dense_field: Option<String>,
322        sparse_model: Option<String>,
323        sparse_vector: Option<String>,
324        sparse_field: Option<String>,
325    },
326    Multi(Vec<EmbeddingSpec>),
327}
328
329#[derive(Debug, Clone, PartialEq)]
330#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
331pub struct UpsertPoint {
332    pub id: PointId,
333    pub vectors: Option<PointVectors>,
334    pub payload: Vec<(String, Value)>,
335}
336
337#[derive(Debug, Clone, PartialEq)]
338#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
339pub struct UpsertStmt {
340    pub collection: String,
341    pub points: Vec<UpsertPoint>,
342    pub embedding: Option<EmbeddingSpec>,
343    pub embed: Vec<EmbedDirective>,
344    pub shard_key: Option<String>,
345}
346
347#[derive(Debug, Clone, Copy, PartialEq, Eq)]
348#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
349pub enum VectorDistance {
350    Cosine,
351    Dot,
352    Euclid,
353    Manhattan,
354}
355
356#[derive(Debug, Clone, Copy, PartialEq, Eq)]
357#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
358pub enum MultivectorComparator {
359    MaxSim,
360}
361
362#[derive(Debug, Clone, PartialEq)]
363#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
364pub struct MultivectorConfig {
365    pub comparator: MultivectorComparator,
366}
367
368#[derive(Debug, Clone, PartialEq)]
369#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
370pub struct VectorDef {
371    pub name: String,
372    pub size: u64,
373    pub distance: VectorDistance,
374    pub hnsw: Option<Box<HnswRuntimeConfig>>,
375    pub quantization: Option<Box<QuantizationConfig>>,
376    pub multivector: Option<MultivectorConfig>,
377    pub vectors: Option<Box<VectorsConfig>>,
378}
379
380#[derive(Debug, Clone, PartialEq)]
381#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
382pub struct SparseIndexConfig {
383    pub full_scan_threshold: Option<u64>,
384    pub on_disk: Option<bool>,
385    pub datatype: Option<String>,
386}
387
388#[derive(Debug, Clone, PartialEq)]
389#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
390pub struct SparseVectorDef {
391    pub name: String,
392    pub index: Option<Box<SparseIndexConfig>>,
393    pub modifier: Option<String>,
394}
395
396#[derive(Debug, Clone, Copy, PartialEq, Eq)]
397#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
398pub enum QuantizationType {
399    Scalar,
400    Binary,
401    Product,
402    Turbo,
403}
404
405#[derive(Debug, Clone, PartialEq)]
406#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
407pub struct QuantizationConfig {
408    pub qtype: QuantizationType,
409    pub always_ram: bool,
410    pub quantile: Option<f64>,
411    pub bits: Option<f64>,
412    pub compression: Option<String>,
413    pub encoding: Option<String>,
414    pub query_encoding: Option<String>,
415}
416
417#[derive(Debug, Clone, PartialEq)]
418#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
419pub struct QuantizationUpdate {
420    pub disabled: bool,
421    pub config: Option<Box<QuantizationConfig>>,
422}
423
424#[derive(Debug, Clone, PartialEq)]
425#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
426pub struct HnswRuntimeConfig {
427    pub m: Option<u64>,
428    pub ef_construct: Option<u64>,
429    pub full_scan_threshold: Option<u64>,
430    pub max_indexing_threads: Option<u64>,
431    pub on_disk: Option<bool>,
432    pub payload_m: Option<u64>,
433    pub inline_storage: Option<bool>,
434}
435
436#[derive(Debug, Clone, PartialEq)]
437#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
438pub struct VectorsConfig {
439    pub on_disk: Option<bool>,
440}
441
442#[derive(Debug, Clone, Copy, PartialEq)]
443#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
444pub struct OptimizationThreads {
445    pub auto_: bool,
446    pub value: u64,
447}
448
449#[derive(Debug, Clone, PartialEq)]
450#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
451pub struct OptimizersRuntimeConfig {
452    pub deleted_threshold: Option<f64>,
453    pub vacuum_min_vector_number: Option<u64>,
454    pub default_segment_number: Option<u64>,
455    pub max_segment_size: Option<u64>,
456    pub memmap_threshold: Option<u64>,
457    pub indexing_threshold: Option<u64>,
458    pub flush_interval_sec: Option<u64>,
459    pub max_optimization_threads: Option<OptimizationThreads>,
460    pub prevent_unoptimized: Option<bool>,
461}
462
463#[derive(Debug, Clone, PartialEq)]
464#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
465pub struct CollectionParamsConfig {
466    pub replication_factor: Option<u64>,
467    pub write_consistency_factor: Option<u64>,
468    pub read_fan_out_factor: Option<u64>,
469    pub read_fan_out_delay_ms: Option<u64>,
470    pub on_disk_payload: Option<bool>,
471    pub shard_number: Option<u64>,
472    pub sharding_method: Option<String>,
473    pub shard_keys: Option<Vec<String>>,
474}
475
476#[derive(Debug, Clone, PartialEq)]
477#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
478pub struct CollectionConfig {
479    pub vectors: Option<Box<VectorsConfig>>,
480    pub hnsw: Option<Box<HnswRuntimeConfig>>,
481    pub optimizers: Option<Box<OptimizersRuntimeConfig>>,
482    pub params: Option<Box<CollectionParamsConfig>>,
483    pub quantization: Option<Box<QuantizationConfig>>,
484    pub quantization_update: Option<Box<QuantizationUpdate>>,
485}
486
487#[derive(Debug, Clone, PartialEq)]
488#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
489pub enum CollectionMode {
490    Dense {
491        model: Option<String>,
492    },
493    Hybrid {
494        dense_vector: Option<String>,
495        sparse_vector: Option<String>,
496    },
497    Rerank,
498}
499
500#[derive(Debug, Clone, PartialEq)]
501#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
502pub struct ClearPayloadStmt {
503    pub collection: String,
504    pub selector: PointSelector,
505}
506
507#[derive(Debug, Clone, PartialEq)]
508#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
509pub struct DeleteVectorStmt {
510    pub collection: String,
511    pub selector: PointSelector,
512    pub vector_names: Vec<String>,
513}
514
515#[derive(Debug, Clone, PartialEq)]
516#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
517pub struct CreateCollectionStmt {
518    pub collection: String,
519    pub mode: CollectionMode,
520    pub vectors: Vec<VectorDef>,
521    pub sparse_vectors: Vec<SparseVectorDef>,
522    pub config: Option<Box<CollectionConfig>>,
523}
524
525#[derive(Debug, Clone, PartialEq)]
526#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
527pub struct AlterCollectionStmt {
528    pub collection: String,
529    pub config: Option<Box<CollectionConfig>>,
530}
531
532#[derive(Debug, Clone, PartialEq)]
533#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
534pub struct DropCollectionStmt {
535    pub collection: String,
536}
537
538#[derive(Debug, Clone, PartialEq)]
539#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
540pub struct CreateIndexStmt {
541    pub collection: String,
542    pub field: String,
543    pub field_type: String,
544    pub options: Vec<(String, Value)>,
545}
546
547#[derive(Debug, Clone, PartialEq)]
548#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
549pub struct DropIndexStmt {
550    pub collection: String,
551    pub field: String,
552}
553
554#[derive(Debug, Clone, PartialEq)]
555#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
556pub struct CountStmt {
557    pub collection: String,
558    pub filter: Option<Box<FilterExpr>>,
559    pub shard_key: Option<String>,
560}
561
562#[derive(Debug, Clone, PartialEq)]
563#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
564pub struct CreateShardKeyStmt {
565    pub collection: String,
566    pub shard_key: String,
567    pub shards_number: Option<u64>,
568    pub replication_factor: Option<u64>,
569}
570
571#[derive(Debug, Clone, PartialEq)]
572#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
573pub struct DropShardKeyStmt {
574    pub collection: String,
575    pub shard_key: String,
576}
577
578#[derive(Debug, Clone, PartialEq)]
579#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
580pub enum PointSelector {
581    Id(PointId),
582    Ids(Vec<PointId>),
583    Filter(Box<FilterExpr>),
584}
585
586#[derive(Debug, Clone, PartialEq)]
587#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
588pub struct DeleteStmt {
589    pub collection: String,
590    pub selector: PointSelector,
591    pub shard_key: Option<String>,
592}
593
594#[derive(Debug, Clone, PartialEq)]
595#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
596pub struct UpdateVectorStmt {
597    pub collection: String,
598    pub point_id: PointId,
599    pub vector: VectorValue,
600    pub vector_name: Option<String>,
601}
602
603#[derive(Debug, Clone, PartialEq)]
604#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
605pub struct UpdatePayloadStmt {
606    pub collection: String,
607    pub selector: PointSelector,
608    pub payload: Vec<(String, Value)>,
609}
610
611#[derive(Debug, Clone, PartialEq)]
612#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
613pub enum Stmt {
614    Query(Box<QueryStmt>),
615    Scroll(Box<ScrollStmt>),
616    Upsert(Box<UpsertStmt>),
617    CreateCollection(Box<CreateCollectionStmt>),
618    CreateIndex(Box<CreateIndexStmt>),
619    DropIndex(Box<DropIndexStmt>),
620    CreateShardKey(Box<CreateShardKeyStmt>),
621    DropShardKey(Box<DropShardKeyStmt>),
622    AlterCollection(Box<AlterCollectionStmt>),
623    DropCollection(Box<DropCollectionStmt>),
624    ShowCollections,
625    ShowCollection(String),
626    ShowShardKeys(String),
627    Delete(Box<DeleteStmt>),
628    ClearPayload(Box<ClearPayloadStmt>),
629    DeleteVector(Box<DeleteVectorStmt>),
630    UpdateVector(Box<UpdateVectorStmt>),
631    UpdatePayload(Box<UpdatePayloadStmt>),
632    Count(Box<CountStmt>),
633}
qql_core/ast/statement.rs

qql_core/ast/
statement.rs
