MongoDB聚合拼接嵌套地址字段时如何忽略空值？

The problem with your current pipeline is that $concat returns null if any of the input expressions is null (which happens when a nested field is missing). To only include existing fields in the final formatted string, we need to adjust the approach to filter out missing values before concatenation. Here's how to do it:

Updated Aggregation Pipeline #

aggregation_pipeline = [
    {
        "$project": {
            "address": {
                # Join filtered valid address components with ", "
                "$join": {
                    "array": {
                        # Remove null entries from the component list
                        "$filter": {
                            "input": [
                                # Format flatNo with leading # if it exists
                                {"$cond": ["$address.flatNo", {"$concat": ["#", "$address.flatNo"]}, None]},
                                # Include street only if present
                                {"$cond": ["$address.street", "$address.street", None]},
                                # Include city only if present
                                {"$cond": ["$address.city", "$address.city", None]},
                                # Include zip only if present
                                {"$cond": ["$address.zip", "$address.zip", None]},
                                # Include state only if present
                                {"$cond": ["$address.state", "$address.state", None]},
                                # Include country only if present
                                {"$cond": ["$address.country", "$address.country", None]}
                            ],
                            "cond": {"$ne": ["$$this", None]}
                        }
                    },
                    "delimiter": ", "
                }
            }
        }
    },
    { "$out": "mod_collection" }
]

cursor = db['level'].aggregate(aggregation_pipeline, allowDiskUse=True)
cursor.close()

Breakdown of the Solution #

1. Conditional Component Checks: For each nested address field, we use $cond to either return the formatted value (like adding # to flatNo) or null if the field is missing.
2. Filter Out Nulls: The $filter stage removes all null entries from the array of components, leaving only the fields that exist in the document.
3. Join Valid Components: The $join stage takes the filtered array and concatenates all elements with ", " to create the clean, final address string.

Compatibility Note #

If you're using a MongoDB version older than 4.4 (where $join was introduced), replace the $join block with a $reduce operation instead:

"$reduce": {
    "input": <filtered_array>,
    "initialValue": "",
    "in": {
        "$cond": [
            {"$eq": ["$$value", ""]},
            "$$this",
            {"$concat": ["$$value", ", ", "$$this"]}
        ]
    }
}

This approach ensures that missing fields are completely ignored, and your final address string only includes the existing components in the desired format.

内容的提问来源于stack exchange，提问作者Raghavendra Swaroop