开发者工具 IDE

沙盒环境

抖音云

产品介绍

快速开始

场景指南

操作指南

开发指南

调用服务

对象存储

本地调试

云数据库

服务端开发

客户端开发

小程序端如何使用云数据库SDK

SDK概览

云数据库客户端SDK(Database)

云数据库客户端SDK(Collection)

云数据库客户端SDK(Document)

云数据库客户端SDK(Command)

Unity小游戏SDK文档

云数据库客户端SDK(Aggregate Command)

WebSocket

直播间玩法指令走内网专线推送到抖音云

云函数如何调试

云函数Api

SDK参考

产品动态

产品计费

常见问题

OpenAPI调试台

云数据库客户端SDK(Aggregate Command)
收藏
我的收藏

AggregateCommand

数据库聚合操作符，通过 db.command.aggregate 获取。

方法

add

聚合操作符。将数字相加或将数字加在日期上。如果数组中的其中一个值是日期，那么其他值将被视为毫秒数加在该日期上。

参数

value: Expression[]

[<表达式1>, <表达式2>, ...]。

返回值

Object

API 说明

db.command.aggregate.add([<表达式1>, <表达式2>, ...])

表达式可以是形如 $ + 指定字段，也可以是普通字符串。

示例

假设有如下记录：

{
    "id": "xxx",
    "department": "x",
    "sales": 5,
    "engineer": 10
}

数字求和，可以用如下方式求得各个记录人数总数：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .project({
      department: 1,
      total: $.add(['$sales', '$engineer']),
    })
    .end();

返回结果如下：

{"_id":"xxx","department":"x","total":15}

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand add语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .project({
          department: 1,
          total: $.add(['$sales', '$engineer']),
        })
        .end(); 
 }

addToSet

聚合操作符。聚合运算符。向数组中添加值，如果数组中已存在该值，不执行任何操作。它只能在 group stage 中使用。

参数

value: Expression

表达式

返回值

Object

API 说明

addToSet 语法如下：

db.command.aggregate.addToSet(<表达式>)

表达式是形如 $ + 指定字段 的字符串。如果指定字段的值是数组，那么整个数组会被当作一个元素。

示例1：非数组字段

假设有如下记录：

{
    "_id":"xxx", 
    "category":"System", 
    "name":"demo",
    "tags":["C++","C"], 
    "title":"title2"
}

{
    "_id":"xxx",
    "name":"demo",
    "category":"web",
    "tags":["JavaScript","CSS"],
    "title":"title1"
}

每条记录的 category 对应值的类型是非数组，利用 addToSet 统计所有分类：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      categories: $.addToSet('$category'),
    })
    .end();

返回结果如下：

[{"_id":null,"categories":["web","System"]}]

示例2：数组字段

每条记录的 tags 对应值的类型是数组，数组不会被自动展开：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      tagsList: $.addToSet('$tags'),
    })
    .end();

返回结果如下：

[
    {
        "_id":null,
        "tagsList":[["JavaScript","CSS"],["C++","C"]]
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand addToSet语句 
  const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      categories: $.addToSet('$category'),
    })
    .end();
 }

avg

聚合操作符。返回一组集合中，指定字段对应数据的平均值。

参数

value: Expression<number>

number

返回值

Object

API 说明

avg 的语法如下：

db.command.aggregate.avg(<number>)

avg 传入的值除了数字常量外，也可以是任何最终解析成一个数字的表达式。它会忽略非数字值。

示例

假设有如下记录：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}
{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}
{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}
{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

借助 avg 可以计算所有记录的 score 的平均值：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      average: $.avg('$score'),
    })
    .end();

返回结果如下：

[ { "_id": null, "average": 90 } ]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand avg语句 
  const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      average: $.avg('$score'),
    })
    .end();
 }

first

聚合操作符。返回指定字段在一组集合的第一条记录对应的值。仅当这组集合是按照某种定义排序（ sort ）后，此操作才有意义。

参数

value: Expression

表达式

返回值

Object

API 说明

first 的语法如下：

db.command.aggregate.first(<表达式>)

表达式是形如 $ + 指定字段 的字符串。

first 只能在 group 阶段被使用，并且需要配合 sort 才有意义。

示例

假设有如下记录：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}

{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

如果需要得到所有记录中 score 的最小值，可以先将所有记录按照 score 排序，然后取出第一条记录的 first。

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .sort({
      score: 1,
    })
    .group({
      _id: null,
      min: $.first('$score'),
    })
    .end();

返回结果如下：

[ { "_id": null, "min": 80 } ]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand first语句 
  const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .sort({
      score: 1,
    })
    .group({
      _id: null,
      min: $.first('$score'),
    })
    .end();
 }

last

聚合操作符。返回指定字段在一组集合的最后一条记录对应的值。仅当这组集合是按照某种定义排序（ sort ）后，此操作才有意义。

参数

value: Expression

表达式

返回值

Object

API 说明

last 的语法如下：

db.command.aggregate.last(<表达式>)

表达式是形如 $ + 指定字段 的字符串。

last 只能在 group 阶段被使用，并且需要配合 sort 才有意义。

示例

假设有如下记录：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}

{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

如果需要得到所有记录中 score 的最大值，可以先将所有记录按照 score 排序，然后取出最后一条记录的 last。

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .sort({
      score: 1,
    })
    .group({
      _id: null,
      max: $.last('$score'),
    })
    .end();

返回结果如下：

[ { "_id": null, "max": 100 } ]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand last语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .sort({
          score: 1,
        })
        .group({
          _id: null,
          max: $.last('$score'),
        })
        .end();
 }

max

聚合操作符。返回一组数值的最大值。

参数

value:Expression

表达式

返回值

Object

API 说明

max 的语法如下：

db.command.aggregate.max(<表达式>)

表达式是形如 $ + 指定字段 的字符串。

示例

假设有如下记录：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}

{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

借助 max 可以统计不同组（ group ）中成绩的最高值，代码如下：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: '$group',
      maxScore: $.max('$score'),
    })
    .end();

返回结果如下：

[
    {"_id": "b", "maxScore": 100},
    {"_id": "a", "maxScore": 96}
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand max语句  
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .group({
          _id: '$group',
          maxScore: $.max('$score'),
        })
        .end();
 }

mergeObject

聚合操作符。将多个文档合并为单个文档。

参数

value: Expression<document>

Document 表达式

返回值

Object

API 说明

使用形式如下：在 group() 中使用时：

mergeObjects(<document>)

在其它表达式中使用时：

mergeObjects([<document1>, <document2>, ...])

示例1：搭配 `group()` 使用

假设集合 command_todos 存在以下文档：

{
    "_id": "xxx",
    "id": 1,
    "name": "A",
    "temp": "demo",
    "volume": {
        "2018Q1": 500,
        "2018Q2": 500
    },
    "year": 2018
}

{
    "_id": "xxx",
    "id": 2,
    "name": "A",
    "temp": "demo",
    "volume": {
        "2017Q1": 400,
        "2017Q2": 300
    },
    "year": 2017
}

{
    "_id": "xxx",
    "id": 3,
    "name": "B",
    "temp": "demo",
    "volume": {
        "2018Q1": 100
    },
    "year": 2018
}

{
    "_id": "xxx",
    "id": 4,
    "name": "B",
    "temp": "demo",
    "volume": {
        "2017Q3": 100,
        "2017Q4": 250
    },
    "year": 2017
}

下面的代码使用 mergeObjects()，将用相同 name 的文档合并：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: '$name',
      mergedVolume: $.mergeObjects('$volume'),
    })
    .end();

返回结果如下：

[
    {
        "_id": "B",
        "mergedVolume": {
            "2018Q1": 100,
            "2017Q3": 100,
            "2017Q4": 250
        }
    },
    {
        "_id": "A",
        "mergedVolume": {
            "2018Q1": 500,
            "2018Q2": 500,
            "2017Q1": 400,
            "2017Q2": 300
        }
    }
]

示例2：一般用法

假设集合 command_todos 存在以下文档：

{"_id":"xxx","bar":{"b":2},"foo":{"a":1},"id":1}
{"_id":"xxx","bar":{"d":2},"foo":{"c":1},"id":2}
{"_id":"xxx","bar":{"f":2},"foo":{"e":1},"id":3}

下面的代码使用 mergeObjects()，将文档中的 foo 和 bar 字段合并为 foobar：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .project({
      foobar: $.mergeObjects(['$foo', '$bar']),
    })
    .end();

返回结果如下：

[
    {
        "_id": "xxx",
        "foobar": {
            "a": 1,
            "b": 2
        }
    },
    {
        "_id": "xxx",
        "foobar": {
            "c": 1,
            "d": 2
        }
    },
    {
        "_id": "xxx",
        "foobar": {
            "e": 1,
            "f": 2
        }
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand mergeObject语句
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .group({
          _id: '$name',
          mergedVolume: $.mergeObjects('$volume'),
        })
        .end(); 
 }

min

聚合操作符。返回一组数值的最小值。

参数

value: Expression

表达式

返回值

Object

API 说明

min 的语法如下：

db.command.aggregate.min(<表达式>)

表达式是形如 $ + 指定字段 的字符串。

示例

假设有如下记录：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}

{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

借助 min 可以统计不同组（ group ）中成绩的最低值，代码如下：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: '$group',
      minScore: $.min('$score'),
    })
    .end();

返回结果如下：

[
    {
        "_id": "b",
        "minScore": 80
    },
    {
        "_id": "a",
        "minScore": 84
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand min语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .group({
          _id: '$group',
          minScore: $.min('$score'),
        })
        .end();
 }

push

聚合操作符。在 group 阶段，返回一组中表达式指定列与对应的值，一起组成的数组。

参数

value: any

返回值

Object

API 说明

push 语法如下：

db.command.aggregate.push({<字段名1>: <指定字段1>,<字段名2>: <指定字段2>,...})

示例

假设集合 command_todos 的记录如下：

{
    "_id": "xxx",
    "group": "a",
    "name": "stu1",
    "score": 84
}

{
    "_id": "xxx",
    "group": "a",
    "name": "stu2",
    "score": 96
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu3",
    "score": 80
}

{
    "_id": "xxx",
    "group": "b",
    "name": "stu4",
    "score": 100
}

借助 push 操作，对不同分组( group )的所有记录，聚合所有数据并且将其放入一个新的字段中，进一步结构化和语义化数据。

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: '$group',
      students: $.push({
        name: '$name',
        score: '$score',
      }),
    })
    .end();

返回结果如下：

[
    {
        "_id": "b",
        "students": [
            {
                "name": "stu3",
                "score": 80
            },
            {
                "name": "stu4",
                "score": 100
            }
        ]
    },
    {
        "_id": "a",
        "students": [
            {
                "name": "stu1",
                "score": 84
            },
            {
                "name": "stu2",
                "score": 96
            }
        ]
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand push语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .group({
          _id: '$group',
          students: $.push({
            name: '$name',
            score: '$score',
          }),
        })
        .end();
 }

sum

聚合操作符。计算并且返回一组字段所有数值的总和。

参数

value: Expression

表达式

返回值

Object

API 说明

sum 的使用形式如下：

db.command.aggregate.sum(<表达式>)

表达式可以传入指定字段，也可以传入指定字段组成的列表。sum 会自动忽略非数字值。如果字段下的所有值均是非数字，那么结果返回 0。若传入数字常量，则当做所有记录该字段的值都给给定常量，在聚合时相加，最终值为输入记录数乘以常量。

示例1：单独字段

假设代表商品的集合 command_todos 的记录如下：price 代表商品销售额，cost 代表商品成本

{
    "_id": "xxx",
    "cost": -10,
    "price": 100
}

{
    "_id": "xxx",
    "cost": -15,
    "price": 1
}

{
    "_id": "xxx",
    "cost": -10,
    "price": 10
}

借助 sum 可以计算所有商品的销售总和，代码如下：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      totalPrice: $.sum('$price'),
    })
    .end();

返回结果如下：

[
    {
        "_id": null,
        "totalPrice": 111
    }
]

示例2：字段列表

如果需要计算所有商品的利润总额，那么需要将每条记录的 cost 和 price 相加得到此记录对应商品的利润。最后再计算所有商品的利润总额

借助 sum，代码如下：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .group({
      _id: null,
      totalProfit: $.sum($.sum(['$price', '$cost'])),
    })
    .end();

返回结果如下：

[
    {
        "_id": null,
        "totalPrice": 76
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand sum语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .group({
          _id: null,
          totalPrice: $.sum('$price'),
        })
        .end();
 }

arrayElemAt

聚合操作符。返回在指定数组下标的元素。

参数

value: Expression[]

[<array>, <index>]

返回值

Object

API 说明

语法如下：

db.command.aggregate.arrayElemAt([<array>, <index>])

<array> 可以是任意解析为数字的表达式。

<index> 可以是任意解析为整形的表达式。如果是正数，arrayElemAt 返回在 index 位置的元素，如果是负数，arrayElemAt 返回从数组尾部算起的 index 位置的元素。

示例

假设集合 command_todos 有如下记录：

{
    "_id": "xxx",
    "id": 1,
    "scores": [ 80, 60, 65, 90 ]
}

{
    "_id": "xxx",
    "id": 2,
    "scores": [ 78]
}

{
    "_id": "xxx",
    "id": 3,
    "scores": [ 95, 88, 92 ]
}

各个第一次考试的分数和和最后一次的分数：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .project({
      first: $.arrayElemAt(['$scores', 0]),
      last: $.arrayElemAt(['$scores', -1]),
    })
    .end();

返回结果如下：

[
    {
        "_id": "xxx",
        "first": 80,
        "last": 90
    },
    {
        "_id": "xxx",
        "first": 78,
        "last": 78
    },
    {
        "_id": "xxx",
        "first": 95,
        "last": 92
    }
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand arratElemAt语句 
      const $ = db.command.aggregate;
      const res = await db
        .collection('command_todos')
        .aggregate()
        .project({
          first: $.arrayElemAt(['$scores', 0]),
          last: $.arrayElemAt(['$scores', -1]),
        })
        .end(); 
 }

concat

聚合操作符。连接字符串，返回拼接后的字符串。

参数

value: Expression[]

[<表达式1>, <表达式2>, ...]

返回值

Object

API 说明

concat 的语法如下：

db.command.aggregate.concat([<表达式1>, <表达式2>, ...])

表达式可以是形如 $ + 指定字段，也可以是普通字符串。只要能够被解析成字符串即可。

示例

假设有如下记录：

{
    "_id": "xxx",
    "firstName": "Yuanxin",
    "group": "a",
    "lastName": "Dong",
    "score": 84
}

{
    "_id": "xxx",
    "firstName": "Weijia",
    "group": "a",
    "lastName": "Wang",
    "score": 96
}

{
    "_id": "xxx",
    "firstName": "Chengxi",
    "group": "b",
    "lastName": "Li",
    "score": 80
}

借助 concat 可以拼接 lastName 和 firstName 字段，得到每位学生的名字全称：

const $ = db.command.aggregate;
  const res = await db
    .collection('command_todos')
    .aggregate()
    .project({
      _id: 0,
      fullName: $.concat(['$firstName', ' ', '$lastName']),
    })
    .end();

返回结果如下：

[
    { "fullName": "Yuanxin Dong"},
    { "fullName": "Weijia Wang"},
    { "fullName": "Chengxi Li"}
]

兼容说明

// 版本比较
  canUseCommand(version1) {
    const compareVersion = '3.39.0.0';
    const v1 = version1.split('.').map(Number);
    const v2 = compareVersion.split('.').map(Number);

    for (let i = 0; i < v1.length; i++) {
        if (v1[i] > v2[i]) {
            return  true;
        } else if (v1[i] < v2[i]) {
            return false;
        }
    }
    return true;
  };
 const systemInfo = tt.getSystemInfoSync()
 if(canUseCommand(res.SDKUpdateVersion) {
     // 附实际aggregateCommand concat语句 
      const res = await db
        .collection('command_todos')
        .aggregate()
        .project({
          _id: 0,
          fullName: db.command.aggregate.concat(['$firstName', ' ', '$lastName']),
        })
        .end();
 }

云数据库客户端SDK(Aggregate Command)收藏我的收藏

AggregateCommand

方法

add

参数

返回值

API 说明

示例

兼容说明

addToSet

参数

返回值

API 说明

示例1： 非数组字段

示例2： 数组字段

兼容说明

avg

参数

返回值

API 说明

示例

兼容说明

first

参数

返回值

API 说明

示例

兼容说明

last

参数

返回值

API 说明

示例

兼容说明

max

参数

返回值

API 说明

示例

兼容说明

mergeObject

参数

返回值

API 说明

示例1：搭配 group() 使用

示例2：一般用法

兼容说明

min

参数

返回值

API 说明

示例

兼容说明

push

参数

返回值

API 说明

示例

兼容说明

sum

参数

返回值

API 说明

示例1：单独字段

示例2：字段列表

兼容说明

arrayElemAt

参数

返回值

API 说明

示例

兼容说明

concat

参数

返回值

API 说明

示例

兼容说明

云数据库客户端SDK(Aggregate Command)
收藏
我的收藏

示例1：非数组字段

示例2：数组字段

示例1：搭配 `group()` 使用