स्प्रिंग डेटा MongoDB एकत्रीकरण - परिकलित मान से मेल खाता है

आपको क्या चाहिए $redact एकत्रीकरण ढांचे में ऑपरेटर जो आपको उपरोक्त तार्किक स्थिति को $cond ऑपरेटर और विशेष संचालन का उपयोग करता है $$ रखें दस्तावेज़ को "रखने" के लिए जहाँ तार्किक स्थिति सही है या $$PRUNE उस दस्तावेज़ को "निकालने" के लिए जहां शर्त गलत थी।

यह ऑपरेशन एक $प्रोजेक्ट पाइपलाइन जो संग्रह में फ़ील्ड का चयन करती है और एक नया फ़ील्ड बनाती है जो तार्किक स्थिति क्वेरी से परिणाम रखती है और फिर बाद में $मिलान , सिवाय इसके कि $redact एकल पाइपलाइन चरण का उपयोग करता है जो अधिक कुशल है।

निम्नलिखित उदाहरण पर विचार करें जो उपरोक्त अवधारणा को प्रदर्शित करता है:

db.collection.aggregate([
    { 
        "$redact": {
            "$cond": [
                { 
                    "$gte": [
                        { "$divide": ["$Number1", "$Number2"] },
                        CONSTANT_VAR
                    ]
                },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

चूंकि $redact के लिए कोई समर्थन नहीं है ऑपरेटर अभी तक (लेखन के समय), एक समाधान यह होगा कि एक एग्रीगेशनऑपरेशन को लागू किया जाए इंटरफ़ेस जो एक DBObject . में लेने के लिए एक वर्ग के साथ एकत्रीकरण संचालन को लपेटता है :

public class RedactAggregationOperation implements AggregationOperation {
    private DBObject operation;

    public RedactAggregationOperation (DBObject operation) {
        this.operation = operation;
    }

    @Override
    public DBObject toDBObject(AggregationOperationContext context) {
        return context.getMappedObject(operation);
    }
}

जिसे आप TypeAggregation . में इस्तेमाल कर सकते हैं :

Aggregation agg = newAggregation(
    new RedactAggregationOperation(
        new BasicDBObject(
            "$redact",
            new BasicDBObject(
                "$cond", new BasicDBObject()
                    .append("if", new BasicDBObject(
                        "$gte", Arrays.asList(
                            new BasicDBObject(
                                "$divide", Arrays.asList( "$Number1", "$Number2" )
                            ), 
                            CONSTANT_VAR
                        )
                    )
                )
                .append("then", "$$KEEP")
                .append("else", "$$PRUNE")
            )
        )
    )
);

AggregationResults<Example> results = mongoTemplate.aggregate(
    (TypedAggregation<Example>) agg, Example.class);

--अद्यतन करें--

टिप्पणियों से अनुवर्ती, Number2 . पर शून्य या शून्य मानों की जांच करने के लिए क्षेत्र में, आपको एक $cond इसके बजाय तर्क के साथ अभिव्यक्ति।

निम्न उदाहरण मानता है कि आपके पास 1 का प्लेसहोल्डर मान है यदि या तो Number2 . है मौजूद नहीं है/शून्य है या शून्य का मान है:

db.collection.aggregate([
    { 
        "$redact": {
            "$cond": [
                { 
                    "$gte": [
                        { 
                            "$divide": [
                                "$Number1", {
                                    "$cond": [
                                        {
                                            "$or": [
                                                { "$eq": ["$Number2", 0] },
                                                { 
                                                    "$eq": [
                                                        { "$ifNull": ["$Number2", 0] }, 0
                                                    ]
                                                }
                                            ]
                                        },
                                        1,  // placeholder value if Number2 is 0
                                        "$Number2"                                          
                                    ]
                                }
                            ] 
                        },
                        CONSTANT_VAR
                    ]
                },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

समतुल्य स्प्रिंग डेटा एकत्रीकरण (परीक्षण नहीं किया गया)

Aggregation agg = newAggregation(
    new RedactAggregationOperation(
        new BasicDBObject(
            "$redact",
            new BasicDBObject(
                "$cond", Arrays.asList(
                    new BasicDBObject(
                        "$gte", Arrays.asList(
                            new BasicDBObject(
                                "$divide", Arrays.asList( 
                                    "$Number1", 
                                    new BasicDBObject(
                                        "$cond", Arrays.asList( 
                                            new BasicDBObject( "$or": Arrays.asList( 
                                                    new BasicDBObject("$eq", Arrays.asList("$Number2", 0)),
                                                    new BasicDBObject("$eq", Arrays.asList(
                                                            new BasicDBObject("$ifNull", Arrays.asList("$Number2", 0)), 0
                                                        )
                                                    )
                                                )
                                            ),
                                            1,  // placeholder value if Number2 is 0
                                            "$Number2"                                          
                                        )
                                    ) 
                                )
                            ), 
                            CONSTANT_VAR
                        )
                    ), "$$KEEP", "$$PRUNE"
                )
            )
        )
    )
);