微信小程序雲開發雲函數 left join聯表查詢。與同個數據庫下的一個指定的集合做 left outer join(左外連接)

雲函數 left join聯表查詢

Aggregate.lookup

聚合階段。聯表查詢。與同個數據庫下的一個指定的集合做 left outer join(左外連接)。對該階段的每一個輸入記錄，lookup 會在該記錄中增加一個數組字段，該數組是被聯表中滿足匹配條件的記錄列表。lookup 會將連接後的結果輸出給下個階段。

API 定義

lookup 有兩種使用方式

1. 相等匹配

將輸入記錄的一個字段和被連接集合的一個字段進行相等匹配時，採用以下定義：

lookup({
  from: <要連接的集合名>,
  localField: <輸入記錄的要進行相等匹配的字段>,
  foreignField: <被連接集合的要進行相等匹配的字段>,
  as: <輸出的數組字段名>
})

參數詳細說明

參數字段	說明
from	要進行連接的另外一個集合的名字
localField	當前流水線的輸入記錄的字段名，該字段將被用於與 `from` 指定的集合的 `foreignField` 進行相等匹配。如果輸入記錄中沒有該字段，則該字段的值在匹配時會被視作 `null`
foreignField	被連接集合的字段名，該字段會被用於與 `localField` 進行相等匹配。如果被連接集合的記錄中沒有該字段，該字段的值將在匹配時被視作 `null`
as	指定連接匹配出的記錄列表要存放的字段名，這個數組包含的是匹配出的來自 `from` 集合的記錄。如果輸入記錄中本來就已有該字段，則該字段會被覆寫

這個操作等價於以下僞 SQL 操作：

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT *
                               FROM <collection to join>
                               WHERE <foreignField>= <collection.localField>);

例子：

2. 自定義連接條件、拼接子查詢

如果需要指定除相等匹配之外的連接條件，或指定多個相等匹配條件，或需要拼接被連接集合的子查詢結果，那可以使用如下定義：

lookup({
  from: <要連接的集合名>,
  let: { <變量1>: <表達式1>, ..., <變量n>: <表達式n> },
  pipeline: [ <在要連接的集合上進行的流水線操作> ],
  as: <輸出的數組字段名>
})

參數詳細說明

參數字段	說明
from	要進行連接的另外一個集合的名字
let	可選。指定在 `pipeline` 中可以使用的變量，變量的值可以引用輸入記錄的字段，比如 `let: { userName: '$name' }` 就代表將輸入記錄的 `name` 字段作爲變量 `userName` 的值。在 `pipeline` 中無法直接訪問輸入記錄的字段，必須通過 `let` 定義之後才能訪問，訪問的方式是在 `expr` 操作符中用 `$$變量名` 的方式訪問，比如 `$$userName`。
pipeline	指定要在被連接集合中運行的聚合操作。如果要返回整個集合，則該字段取值空數組 `[]`。在 `pipeline` 中無法直接訪問輸入記錄的字段，必須通過 `let` 定義之後才能訪問，訪問的方式是在 `expr` 操作符中用 `$$變量名` 的方式訪問，比如 `$$userName`。
as	指定連接匹配出的記錄列表要存放的字段名，這個數組包含的是匹配出的來自 `from` 集合的記錄。如果輸入記錄中本來就已有該字段，則該字段會被覆寫

該操作等價於以下僞 SQL 語句：

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT <documents as determined from the pipeline>
                               FROM <collection to join>
                               WHERE <pipeline> );

例子

示例

雲函數三表查詢

var $ = cloud.database().command.aggregate
// 雲函數入口函數
exports.main = async (event, context) => {
  return cloud.database().collection("tb_approval").aggregate()
    .lookup({
      from: "tb_user",
      localField: 'u_account',
      foreignField: 'u_account',
      as: 'uapproval'
    })
    .lookup({
      from: "tb_lab",
      localField: 'l_id',
      foreignField: '_id',
      as: 'lapproval'
    })
    .replaceRoot({
      newRoot: $.mergeObjects([$.arrayElemAt(['$uapproval', 0]), $.arrayElemAt(['$lapproval', 0]), '$$ROOT'])
    })
    .project({
      uapproval: 0,
      lapproval: 0
    })
    .end({
      success: function (res) {
        return res;
      },
      fail(error) {
        return error;
      }
    })
}

指定一個相等匹配條件

假設 orders 集合有以下記錄：

[
  {"_id":4,"book":"novel 1","price":30,"quantity":2},
  {"_id":5,"book":"science 1","price":20,"quantity":1},
  {"_id":6}
]

books 集合有以下記錄：

[
  {"_id":"book1","author":"author 1","category":"novel","stock":10,"time":1564456048486,"title":"novel 1"},
  {"_id":"book3","author":"author 3","category":"science","stock":30,"title":"science 1"},
  {"_id":"book4","author":"author 3","category":"science","stock":40,"title":"science 2"},
  {"_id":"book2","author":"author 2","category":"novel","stock":20,"title":"novel 2"},
  {"_id":"book5","author":"author 4","category":"science","stock":50,"title":null},
  {"_id":"book6","author":"author 5","category":"novel","stock":"60"}
]

以下聚合操作可以通過一個相等匹配條件連接 orders 和 books 集合，匹配的字段是 orders 集合的 book 字段和 books 集合的 title 字段：

const db = cloud.database()
db.collection('orders').aggregate()
  .lookup({
    from: 'books',
    localField: 'book',
    foreignField: 'title',
    as: 'bookList',
  })
  .end()
  .then(res => console.log(res))
  .catch(err => console.error(err))

結果：

[
  {
    "_id": 4,
    "book": "novel 1",
    "price": 30,
    "quantity": 2,
    "bookList": [
      {
        "_id": "book1",
        "title": "novel 1",
        "author": "author 1",
        "category": "novel",
        "stock": 10
      }
    ]
  },
  {
    "_id": 5,
    "book": "science 1",
    "price": 20,
    "quantity": 1,
    "bookList": [
      {
        "_id": "book3",
        "category": "science",
        "title": "science 1",
        "author": "author 3",
        "stock": 30
      }
    ]
  },
  {
    "_id": 6,
    "bookList": [
      {
        "_id": "book5",
        "category": "science",
        "author": "author 4",
        "stock": 50,
        "title": null
      },
      {
        "_id": "book6",
        "author": "author 5",
        "stock": "60",
        "category": "novel"
      }
    ]
  }
]

對數組字段應用相等匹配

假設 authors 集合有以下記錄：

[
  {"_id": 1, "name": "author 1", "intro": "Two-time best-selling sci-fiction novelist"},
  {"_id": 3, "name": "author 3", "intro": "UCB assistant professor"},
  {"_id": 4, "name": "author 4", "intro": "major in CS"}
]

books 集合有以下記錄：

[
  {"_id":"book1","authors":["author 1"],"category":"novel","stock":10,"time":1564456048486,"title":"novel 1"},
  {"_id":"book3","authors":["author 3", "author 4"],"category":"science","stock":30,"title":"science 1"},
  {"_id":"book4","authors":["author 3"],"category":"science","stock":40,"title":"science 2"}
]

以下操作獲取作者信息及他們分別發表的書籍，使用了 lookup 操作匹配 authors 集合的 name 字段和 books 集合的 authors 數組字段：

const db = cloud.database()
db.collection('authors').aggregate()
  .lookup({
    from: 'books',
    localField: 'name',
    foreignField: 'authors',
    as: 'publishedBooks',
  })
  .end()
  .then(res => console.log(res))
  .catch(err => console.error(err))

結果

[
  {
    "_id": 1,
    "intro": "Two-time best-selling sci-fiction novelist",
    "name": "author 1",
    "publishedBooks": [
      {
        "_id": "book1",
        "title": "novel 1",
        "category": "novel",
        "stock": 10,
        "authors": [
          "author 1"
        ]
      }
    ]
  },
  {
    "_id": 3,
    "name": "author 3",
    "intro": "UCB assistant professor",
    "publishedBooks": [
      {
        "_id": "book3",
        "category": "science",
        "title": "science 1",
        "stock": 30,
        "authors": [
          "author 3",
          "author 4"
        ]
      },
      {
        "_id": "book4",
        "title": "science 2",
        "category": "science",
        "stock": 40,
        "authors": [
          "author 3"
        ]
      }
    ]
  },
  {
    "_id": 4,
    "intro": "major in CS",
    "name": "author 4",
    "publishedBooks": [
      {
        "_id": "book3",
        "category": "science",
        "title": "science 1",
        "stock": 30,
        "authors": [
          "author 3",
          "author 4"
        ]
      }
    ]
  }
]

組合 mergeObjects 應用相等匹配

假設 orders 集合有以下記錄：

[
  {"_id":4,"book":"novel 1","price":30,"quantity":2},
  {"_id":5,"book":"science 1","price":20,"quantity":1},
  {"_id":6}
]

books 集合有以下記錄：

[
  {"_id":"book1","author":"author 1","category":"novel","stock":10,"time":1564456048486,"title":"novel 1"},
  {"_id":"book3","author":"author 3","category":"science","stock":30,"title":"science 1"},
  {"_id":"book4","author":"author 3","category":"science","stock":40,"title":"science 2"},
  {"_id":"book2","author":"author 2","category":"novel","stock":20,"title":"novel 2"},
  {"_id":"book5","author":"author 4","category":"science","stock":50,"title":null},
  {"_id":"book6","author":"author 5","category":"novel","stock":"60"}
]

以下操作匹配 orders 的 book 字段和 books 的 title 字段，並將 books 匹配結果直接 merge 到 orders 記錄中。

var db = cloud.database()
var $ = db.command.aggregate
db.collection('orders').aggregate()
  .lookup({
    from: "books",
    localField: "book",
    foreignField: "title",
    as: "bookList"
  })
  .replaceRoot({
    newRoot: $.mergeObjects([ $.arrayElemAt(['$bookList', 0]), '$$ROOT' ])
  })
  .project({
    bookList: 0
  })
  .end()
  .then(res => console.log(res))
  .catch(err => console.error(err))

結果

[
  {
    "_id": 4,
    "title": "novel 1",
    "author": "author 1",
    "category": "novel",
    "stock": 10,
    "book": "novel 1",
    "price": 30,
    "quantity": 2
  },
  {
    "_id": 5,
    "category": "science",
    "title": "science 1",
    "author": "author 3",
    "stock": 30,
    "book": "science 1",
    "price": 20,
    "quantity": 1
  },
  {
    "_id": 6,
    "category": "science",
    "author": "author 4",
    "stock": 50,
    "title": null
  }
]

指定多個連接條件

假設 orders 集合有以下記錄：

[
  {"_id":4,"book":"novel 1","price":300,"quantity":20},
  {"_id":5,"book":"science 1","price":20,"quantity":1}
]

books 集合有以下記錄：

[
  {"_id":"book1","author":"author 1","category":"novel","stock":10,"time":1564456048486,"title":"novel 1"},
  {"_id":"book3","author":"author 3","category":"science","stock":30,"title":"science 1"}
]

以下操作連接 orders 和 books 集合，要求兩個條件：

orders 的 book 字段與 books 的 title 字段相等
orders 的 quantity 字段大於或等於 books 的 stock 字段

const db = cloud.database()
const $ = db.command.aggregate
db.collection('orders').aggregate()
  .lookup({
    from: 'books',
    let: {
      order_book: '$book',
      order_quantity: '$quantity'
    },
    pipeline: $.pipeline()
      .match(_.expr($.and([
        $.eq(['$title', '$$order_book']),
        $.gte(['$stock', '$$order_quantity'])
      ])))
      .project({
        _id: 0,
        title: 1,
        author: 1,
        stock: 1
      })
      .done(),
    as: 'bookList',
  })
  .end()
  .then(res => console.log(res))
  .catch(err => console.error(err))

結果：

[
  {
    "_id": 4,
    "book": "novel 1",
    "price": 300,
    "quantity": 20,
    "bookList": []
  },
  {
    "_id": 5,
    "book": "science 1",
    "price": 20,
    "quantity": 1,
    "bookList": [
      {
        "title": "science 1",
        "author": "author 3",
        "stock": 30
      }
    ]
  }
]

拼接被連接集合的子查詢

假設 orders 集合有以下記錄：

[
  {"_id":4,"book":"novel 1","price":30,"quantity":2},
  {"_id":5,"book":"science 1","price":20,"quantity":1}
]

books 集合有以下記錄：

[
  {"_id":"book1","author":"author 1","category":"novel","stock":10,"time":1564456048486,"title":"novel 1"},
  {"_id":"book3","author":"author 3","category":"science","stock":30,"title":"science 1"},
  {"_id":"book4","author":"author 3","category":"science","stock":40,"title":"science 2"}
]

在每條輸出記錄上加上一個數組字段，該數組字段的值是對 books 集合的一個查詢語句的結果：

const db = cloud.database()
const $ = db.command.aggregate
db.collection('orders').aggregate()
  .lookup({
    from: 'books',
    let: {
      order_book: '$book',
      order_quantity: '$quantity'
    },
    pipeline: $.pipeline()
      .match({
        author: 'author 3'
      })
      .project({
        _id: 0,
        title: 1,
        author: 1,
        stock: 1
      })
      .done(),
    as: 'bookList',
  })
  .end()
  .then(res => console.log(res))
  .catch(err => console.error(err))

結果

[
  {
    "_id": 4,
    "book": "novel 1",
    "price": 30,
    "quantity": 20,
    "bookList": [
      {
        "title": "science 1",
        "author": "author 3",
        "stock": 30
      },
      {
        "title": "science 2",
        "author": "author 3",
        "stock": 40
      }
    ]
  },
  {
    "_id": 5,
    "book": "science 1",
    "price": 20,
    "quantity": 1,
    "bookList": [
      {
        "title": "science 1",
        "author": "author 3",
        "stock": 30
      },
      {
        "title": "science 2",
        "author": "author 3",
        "stock": 40
      }
    ]
  }
]

微信小程序雲開發雲函數 left join聯表查詢。與同個數據庫下的一個指定的集合做 left outer join(左外連接)

雲函數 left join聯表查詢

Aggregate.lookup

API 定義

示例

微信小程序 json 數據添加新元素

微信小程序 json 數組push 不重複數據

微信小程序多項選擇選中或者取消方法

有寫字好看的人給點實用性技巧嗎？

微信小程序測試用例引用本地js的json data 數據

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

微信小程序 雲開發雲函數 left join聯表查詢。與同個數據庫下的一個指定的集合做 left outer join(左外連接)

雲函數 left join聯表查詢

Aggregate.lookup

API 定義

示例

微信小程序雲開發雲函數 left join聯表查詢。與同個數據庫下的一個指定的集合做 left outer join(左外連接)