This page ⧉Copy as Markdown M↓View Markdown ✦Open in ChatGPT ✧Open in Claude Hide panelsShow panels ⌘Ctrl \

Aggregate

g.sys.db.gen.aggregateGen calls the aggregate generated API from your code : no schema, the data as it is in the table.

Structure

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    aggregateQuery: [
        {
            "$match":
                {
                    "first_name": "JENNIFER"
                }
        }
    ]
});

MongoDB Simple aggregate

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[{
        "$limit": 2
    }]
});

MongoDB headers

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[{
        "$limit": 2
    }],
    headers: {
        "x-am-authorization": "TOKEN"
    }
});

MongoDB Basic aggregation

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[[
        {
            "$group": {
                "_id": "$_id",
                "total": {
                    "$sum": "$customer_id"
                }
            }
        },
        {
            "$match": {
                "total": {
                    "$gt": 1
                }
            }
        },
        {
            "$sort": {
                "total": -1
            }
        },
        {
            "$count": "CountValue"
        }
    ]]
});

MongoDB $project stage

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "full_name": {
                    "$toLower": "$first_name"
                }
            }
        }
    ]
});

MongoDB $addFields

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$addFields": {
                "full_name": {
                    "$concat": [
                        "$first_name",
                        " ",
                        "$last_name"
                    ]
                }
            }
        }
    ]
});

MongoDB $bucket

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$bucket": {
                "groupBy": "$price",
                "boundaries": [10000,20000,30000,40000,50000],
                "default": "Other",
                "output": {
                    "count": {
                        "$sum": 1
                    },
                    "product_details": {
                        "$push": {
                            "name": "$name",
                            "price": "$price"
                        }
                    }
                }
            }
        }
    ]
});

MongoDB $facet with multiple $bucket

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$facet": {
                "price": [
                    {
                        "$bucket": {
                            "groupBy": "$price",
                            "boundaries": [10000,20000,30000,40000,50000,60000,70000,80000],
                            "default": "Other",
                            "output": {
                                "count": {
                                    "$sum": 1
                                },
                                "product_details": {
                                    "$push": {
                                        "name": "$name",
                                        "price": "$price"
                                    }
                                }
                            }
                        }
                    }
                ],
                "categories": [
                    {
                        "$bucket": {
                            "groupBy": "$category_id",
                            "boundaries": [10000,20000,30000,40000,50000,60000,70000,80000],
                            "default": "Other",
                            "output": {
                                "count": {
                                    "$sum": 1
                                },
                                "product_details": {
                                    "$push": {
                                        "name": "$name",
                                        "id": "$id",
                                        "category_id": "$category_id"
                                    }
                                }
                            }
                        }
                    }
                ]
            }
        }
    ]
});

MongoDB $collStats, latencyStats > histograms, storageStats, count

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$collStats": {
                "latencyStats": {
                    "histograms": true
                },
                "storageStats": {},
                "count": {}
            }
        }
    ]
});

MongoDB $collStats, latencyStats > histograms, storageStats, count

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$collStats": {
                "latencyStats": {
                    "histograms": true
                },
                "storageStats": {},
                "count": {}
            }
        }
    ]
});

MongoDB $count

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$match": {
                "price": {
                    "$gt": 10000
                }
            }
        },
        {
            "$count": "price_gt_10000"
        }
    ]
});

MongoDB $limit

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$limit": 2
        }
    ]
});

MongoDB $lookup

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$lookup": {
                "from": "products",
                "localField": "customer_id",
                "foreignField": "owner_id",
                "as": "customer_data"
            }
        }
    ]
});

MongoDB $match

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$match": {
                "first_name": "Bob"
            }
        }
    ]
});

MongoDB $redact, $cond, if, then, else, $$DESCEND, $$PRUNE

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$redact": {
                "$cond": {
                    "if": {
                        "$eq": [
                            "$first_name",
                            "JOHNNY"
                        ]
                    },
                    "then": "$$DESCEND",
                    "else": "$$PRUNE"
                }
            }
        }
    ]
});

MongoDB $replaceRoot, newRoot

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$replaceRoot": {
                "newRoot": {
                    "full_name": {
                        "$concat": [
                            "$first_name",
                            " ",
                            "$last_name"
                        ]
                    }
                }
            }
        }
    ]
});

MongoDB $sample

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$sample": {
                "size": 2
            }
        }
    ]
});

MongoDB $skip

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$skip": 2
        }
    ]
});

MongoDB $sort

ascending

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$sort": {
                "customer_id": 1
            }
        }
    ]
});

descending

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$sort": {
                "customer_id": -1
            }
        }
    ]
});

MongoDB $unwind, $sortByCount

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$unwind": "$ages"
        },
        {
            "$sortByCount": "$ages"
        }
    ]
});

MongoDB $abs, $subtract

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "Grand_Total": {
                    "$abs": {
                        "$subtract": [
                            "$total",
                            "$tax"
                        ]
                    }
                }
            }
        }
    ]
});

MongoDB $add

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "Grand_Total": {
                    "$add": [
                        "$price",
                        "$category_id"
                    ]
                }
            }
        }
    ]
});

MongoDB $ceil, $floor

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "ceilingValue": {
                    "$ceil": "$price"
                },
                "floorValue": {
                    "$floor": "$price"
                },
                "id": 1
            }
        }
    ]
});

MongoDB $divide

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "pricePercentage": {
                    "$divide": [
                        "$price",
                        100
                    ]
                },
                "id": 1
            }
        }
    ]
});

MongoDB $multiply

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "Grand_Total": {
                    "$multiply": [
                        "$price",
                        "$quantity"
                    ]
                },
                "id": 1
            }
        }
    ]
});

MongoDB $arrayElemAt

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
          "$project": {
            "first": {
              "$arrayElemAt": [
                "$attribuites.color",
                1
              ]
            }
          }
        }
    ]
});

MongoDB $filter

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
          "$project": {
            "ages": {
              "$filter": {
                "input": "$ages",
                "as": "age",
                "cond": {
                  "$gte": [
                    "$$age.age",
                    50
                  ]
                }
              }
            }
          }
        }
    ]
});

MongoDB $in

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "customer_id": "$customer_id",
                "TravelingHobby": {
                    "$in": [
                        "traveling",
                        "$hobbies"
                    ]
                }
            }
        }
    ]
});

MongoDB $indexOfArray

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "customer_id": "$customer_id",
                "index": {
                    "$indexOfArray": [
                        "$ages.birth_year",
                        1971
                    ]
                }
            }
        }
    ]
});

MongoDB $isArray

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "isHobbyCricket": {
                    "$cond": {
                        "if": {
                            "$isArray": "$hobbies"
                        },
                        "then": {
                            "$in": [
                                "traveling",
                                "$hobbies"
                            ]
                        },
                        "else": "One or more fields is not an array."
                    }
                }
            }
        }
    ]
});

MongoDB $map

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "integerValues": {
                    "$map": {
                        "input": "$distances",
                        "as": "decimalValue",
                        "in": {
                            "$trunc": "$$decimalValue"
                        }
                    }
                }
            }
        }
    ]
});

MongoDB $reverseArray

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "reverseDistances": {
                    "$reverseArray": "$distances"
                }
            }
        }
    ]
});

MongoDB $size

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "customer_id": 1,
                "address": 1,
                "numberOfHobbies": {
                    "$cond": {
                        "if": {
                            "$isArray": "$hobbies"
                        },
                        "then": {
                            "$size": "$hobbies"
                        },
                        "else": "NA"
                    }
                }
            }
        }
    ]
});

MongoDB $and

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": "$id",
                "result": {
                    "$and": [
                        {
                            "$gt": [
                                "$price",
                                60000
                            ]
                        },
                        {
                            "$lt": [
                                "$category_id",
                                45000
                            ]
                        }
                    ]
                }
            }
        }
    ]
});

MongoDB $not

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": "$id",
                "result": {
                    "$not": [
                        {
                            "$gt": [
                                "$price",
                                30000
                            ]
                        }
                    ]
                }
            }
        }
    ]
});

MongoDB $or

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": "$id",
                "result": {
                    "$or": [
                        {
                            "$gt": [
                                "$price",
                                60000
                            ]
                        },
                        {
                            "$lt": [
                                "$category_id",
                                1000
                            ]
                        }
                    ]
                }
            }
        }
    ]
});

MongoDB $cmp

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "comparePrice": {
                    "$cmp": [
                        "$price",
                        42187
                    ]
                },
                "_id": 1
            }
        }
    ]
});

MongoDB $eq

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "equalPrice": {
                    "$eq": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $gt

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "graterPrice": {
                    "$gt": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $gte

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "gePrice": {
                    "$gte": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $lt

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "graterPrice": {
                    "$lt": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $lte

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "gePrice": {
                    "$lte": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $ne

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "nePrice": {
                    "$ne": [
                        "$price",
                        42187
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $cond

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "price": 1,
                "discount": {
                    "$cond": {
                        "if": {
                            "$gt": [
                                "$price",
                                50000
                            ]
                        },
                        "then": 30,
                        "else": 10
                    }
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $ifNull

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "price": 1,
                "shipping": {
                    "$ifNull": [
                        "$shipping",
                        null
                    ]
                },
                "_id": 0
            }
        }
    ]
});

MongoDB $switch

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "price": 1,
                "priceSummary": {
                    "$switch": {
                        "branches": [
                            {
                                "case": {
                                    "$eq": [
                                        "$price",
                                        50000
                                    ]
                                },
                                "then": "equals"
                            },
                            {
                                "case": {
                                    "$gt": [
                                        "$price",
                                        50000
                                    ]
                                },
                                "then": "greater than"
                            },
                            {
                                "case": {
                                    "$lt": [
                                        "$price",
                                        50000
                                    ]
                                },
                                "then": "less than"
                            }
                        ]
                    }
                }
            }
        }
    ]
});

MongoDB $concat

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$project": {
                "id": 1,
                "name_Description": {
                    "$concat": [
                        "$name",
                        "_",
                        "$description"
                    ]
                }
            }
        }
    ]
});

MongoDB $max

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "mongodb",
    database: "inventory",
    collection: "customers",
    aggregateQuery:[
        {
            "$group": {
                "_id": "$price",
                "maxQuantity": {
                    "$max": "$quantity"
                }
            }
        }
    ]
});

Multi-tenant

• instance: "crm::acme" works on the database of the tenant acme of the multi-tenant instance crm.
• With instance: "crm", the call works on the database of the tenant of the request: a custom API called with the x-am-tenant-username header passes it on to the APIs it calls. A request without a tenant works on the structure database.

let aggregate = await g.sys.db.gen.aggregateGen({
    instance: "crm::acme", database: "crm", collection: "customers",
    aggregateQuery: [{
        "$group": {
            "_id": "$city",
            "customers": { "$sum": 1 }
        }
    }]
});

Related

• Aggregate generated API · Schema API from code · The global object g