mongosh 0.9.0

A high-performance MongoDB Shell implementation in Rust
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

//! Options parsing for MongoDB operations

use crate::error::{ParseError, Result};
use crate::parser::command::{AggregateOptions, FindAndModifyOptions, UpdateOptions};
use crate::parser::mongo_ast::*;
use crate::parser::mongo_converter::ExpressionConverter;

/// Options parsing utilities
pub struct OptionsParser;

impl OptionsParser {
    /// Parse find and modify options from expression
    pub fn parse_find_and_modify_options(expr: &Expr) -> Result<FindAndModifyOptions> {
        let doc = if let Expr::Object(obj) = expr {
            ExpressionConverter::object_to_bson(obj)?
        } else {
            return Err(ParseError::InvalidQuery("Options must be an object".to_string()).into());
        };

        let mut options = FindAndModifyOptions::default();

        if let Ok(sort) = doc.get_document("sort") {
            options.sort = Some(sort.clone());
        }

        if let Ok(projection) = doc.get_document("projection") {
            options.projection = Some(projection.clone());
        }

        if let Ok(return_new) = doc.get_bool("returnNew") {
            options.return_new = return_new;
        } else if let Ok(return_document) = doc.get_str("returnDocument") {
            options.return_new = match return_document {
                "after" => true,
                "before" => false,
                _ => {
                    return Err(ParseError::InvalidQuery(
                        "returnDocument must be 'before' or 'after'".to_string(),
                    )
                    .into());
                }
            };
        }

        if let Ok(upsert) = doc.get_bool("upsert") {
            options.upsert = upsert;
        }

        Ok(options)
    }

    /// Parse update options from expression
    pub fn parse_update_options(expr: &Expr) -> Result<UpdateOptions> {
        let doc = if let Expr::Object(obj) = expr {
            ExpressionConverter::object_to_bson(obj)?
        } else {
            return Err(ParseError::InvalidQuery("Options must be an object".to_string()).into());
        };

        let mut options = UpdateOptions::default();

        if let Ok(upsert) = doc.get_bool("upsert") {
            options.upsert = upsert;
        }

        if let Ok(array_filters) = doc.get_array("arrayFilters") {
            let mut filters = Vec::new();
            for filter in array_filters {
                if let mongodb::bson::Bson::Document(doc) = filter {
                    filters.push(doc.clone());
                }
            }
            options.array_filters = Some(filters);
        }

        Ok(options)
    }

    /// Parse aggregate options from expression
    pub fn parse_aggregate_options(expr: &Expr) -> Result<AggregateOptions> {
        let doc = if let Expr::Object(obj) = expr {
            ExpressionConverter::object_to_bson(obj)?
        } else {
            return Err(ParseError::InvalidQuery("Options must be an object".to_string()).into());
        };

        let mut options = AggregateOptions::default();

        if let Ok(batch_size) = doc.get_i32("batchSize") {
            if batch_size <= 0 {
                return Err(ParseError::InvalidQuery(
                    "batchSize must be a positive integer".to_string(),
                )
                .into());
            }
            options.batch_size = Some(batch_size as u32);
        } else if let Ok(batch_size) = doc.get_i64("batchSize") {
            if batch_size <= 0 {
                return Err(ParseError::InvalidQuery(
                    "batchSize must be a positive integer".to_string(),
                )
                .into());
            }
            options.batch_size = Some(batch_size as u32);
        }

        if let Ok(allow_disk_use) = doc.get_bool("allowDiskUse") {
            options.allow_disk_use = allow_disk_use;
        }

        if let Ok(max_time_ms) = doc.get_i64("maxTimeMS") {
            options.max_time_ms = Some(max_time_ms as u64);
        } else if let Ok(max_time_ms) = doc.get_i32("maxTimeMS") {
            options.max_time_ms = Some(max_time_ms as u64);
        }

        Ok(options)
    }
}