Moralis 查询

我们已经看到了带有 get 的 Moralis.Query 如何从 Moralis 中检索单个 Moralis.Object。还有许多其他方法可以使用 Moralis.Query 检索数据。您可以一次检索多个对象，对要检索的对象设置条件等等。

基本查询

在许多情况下，get 功能不足以指定要检索的对象。 Moralis.Query 提供了不同的方法来检索对象列表，而不仅仅是单个对象。

一般模式是创建一个 Moralis.Query，在其上设置条件，然后使用 find 检索匹配的 Moralis.Objects 数组。例如，要检索具有特定 ownerName 的monster，请使用 equalTo 方法来约束键的值。

你可以使用JS、React、Unity来实现

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);
query.equalTo("ownerName", "Aegon");
const results = await query.find();
alert("Successfully retrieved " + results.length + " monsters.");
// Do something with the returned Moralis.Object values
for (let i = 0; i < results.length; i++) {
  const object = results[i];
  alert(object.id + " - " + object.get("ownerName"));
}

import { useMoralisQuery } from "react-moralis";

export default function App() {
  const { fetch } = useMoralisQuery(
    "Monster",
    (query) => query.equalTo("ownerName", "Aegon"),
    [],
    { autoFetch: false }
  );

  const basicQuery = async () => {
    const results = await fetch();
    alert("Successfully retrieved " + results.length + " monsters.");
    // Do something with the returned Moralis.Object values
    for (let i = 0; i < results.length; i++) {
      const object = results[i];
      alert(object.id + " - " + object.get("ownerName"));
    }
  };

  return <button onClick={basicQuery}>Call The Code</button>;
}

using Moralis.Platform.Objects;
using MoralisWeb3ApiSdk;
using Newtonsoft.Json;

 public async void RetrieveObjectFromDB()
    {
        MoralisQuery<Monster> monster = MoralisInterface.GetClient().Query<Monster>().WhereEqualTo("ownerName", "Aegon");
        IEnumerable<Monster> result = await monster.FindAsync();
        foreach(Monster mon in result)
        {
            print("My strength is " + mon.strength + " and can i fly ? " + mon.canFly);
            // output : My strength is 1024 and can i fly ? true
        }
    }

使用主密钥

在某些情况下，查询需要主密钥，

例如，如果您想获取所有用户的列表，您只能使用主密钥在云功能中执行此操作 - 因为由于 ACL，用户无法读取其他用户的信息。

query.find({ useMasterKey: true });

查询约束

有几种方法可以对 Moralis.Query 找到的对象施加约束。您可以使用 notEqualTo 过滤掉具有特定键值对的对象：

query.notEqualTo("ownerName", "Daenerys");

您可以提供多个约束，并且对象只有在匹配所有约束时才会出现在结果中。换句话说，它就像约束的 AND。

query.notEqualTo("ownerName", "Daenerys");
query.greaterThan("ownerAge", 18);

您可以通过设置限制来限制结果的数量。默认情况下，结果限制为 100。在旧的 Moralis 托管后端中，最大限制为 1,000，但 Moralis Dapps 现在删除了该限制：

query.limit(10); // limit to at most 10 results

如果您只想要一个结果，更方便的替代方法可能是使用first而不是使用 find（可以通过JS、React实现）。

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);
query.equalTo("ownerEmail", "daenerys@housetargaryen.com");
const object = await query.first();

import { useMoralisQuery } from "react-moralis";

export default function App() {
  const { fetch } = useMoralisQuery(
    "Monster",
    (query) =>
      query.equalTo("ownerEmail", "daenerys@housetargaryen.com").first(),
    [],
    { autoFetch: false }
  );

  const singleQuery = () =>
    fetch({
      onSuccess: (result) => console.log(result),
    });

  return <button onClick={singleQuery}>Call The Code</button>;
}

您可以通过设置 skip 来跳过第一个结果。在旧的 Moralis 托管后端中，最大skip值为 10,000，但 Moralis Dapps 现在取消了该限制。这对于分页很有用：

query.skip(10); // skip the first 10 results

获取满足您查询的表中的总行数，例如分页目的 - 您可以使用 withCount。

注意：启用此标志将更改响应的结构，请参见下面的示例。

示例 - 假设您在名为 Monster 的表中有 200 行（可以通过JS、React实现）：

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);

query.limit(25);

const results = await query.find(); // [ Monster, Monster, ...]

// to include count:
query.withCount();
const response = await query.find(); // { results: [ Monster, ... ], count: 200 }

const limitQuery = useMoralisQuery("Monster", (query) => query.limit(25), [], {
  autoFetch: false,
});

const getLimitedQuery = () =>
  limitQuery.fetch({
    onSuccess: (result) => console.log(result), // [ Monster, Monster, ...]
  });

const queryCount = useMoralisQuery(
  "Monster",
  (query) => query.withCount(),
  [],
  {
    autoFetch: false,
  }
);

const getQueryWithCount = () =>
  queryCount.fetch({
    onSuccess: (result) => console.log(result), // { results: [ Monster, ... ], count: 200 }
  });

count 操作可能会很慢而且很昂贵。

如果您只想获取没有对象的计数 - 使用Counting Objects。

要对数字和字符串等可排序类型进行排序，您可以控制返回结果的顺序：

// Sorts the results in ascending order by the strength field
query.ascending("strength");

// Sorts the results in descending order by the strength field
query.descending("strength");

要在可排序类型的查询中进行比较：

// Restricts to wins < 50
query.lessThan("wins", 50);

// Restricts to wins <= 50
query.lessThanOrEqualTo("wins", 50);

// Restricts to wins > 50
query.greaterThan("wins", 50);

// Restricts to wins >= 50
query.greaterThanOrEqualTo("wins", 50);

要检索在值列表中匹配的对象，您可以使用 containsIn，提供可接受值的数组。这对于用单个查询替换多个查询通常很有用。

例如 - 如果您想检索特定列表中任何monster所有者拥有的monster：

// Finds monsters from any of Jonathan, Dario, or Shawn
query.containedIn("ownerName", [
  "Jonathan Walsh",
  "Dario Wunsch",
  "Shawn Simon",
]);

要检索与多个值中的任何一个都不匹配的对象，您可以使用 notContainedIn，提供一个可接受值的数组。

例如，如果您想从列表中的monster所有者那里检索monster：

// Finds monsters from anyone who is neither Jonathan, Dario, nor Shawn
query.notContainedIn("ownerName", [
  "Jonathan Walsh",
  "Dario Wunsch",
  "Shawn Simon",
]);

要检索具有特定键集的对象，您可以使用 exists。相反，如果要检索没有特定键集的对象，可以使用 doesNotExist。

// Finds objects that have the strength set
query.exists("strength");

// Finds objects that don't have the strength set
query.doesNotExist("strength");

获取键与另一个查询产生的一组对象中的键值匹配的对象。您可以使用matchesKeyInQuery 方法。

例如，如果您有一个包含运动队的类，并且您在用户类中存储了用户的家乡，则可以发出一次查询以查找家乡球队有获胜记录的用户列表。查询将如下所示：

const Team = Moralis.Object.extend("Team");
const teamQuery = new Moralis.Query(Team);
teamQuery.greaterThan("winPct", 0.5);
const userQuery = new Moralis.Query(Moralis.User);
userQuery.matchesKeyInQuery("hometown", "city", teamQuery);
// results has the list of users with a hometown team with a winning record
const results = await userQuery.find();

相反，要获取键与另一个查询产生的一组对象中的键值不匹配的对象，请使用 doesNotMatchKeyInQuery。例如，查找家乡球队有输球记录的用户：

const losingUserQuery = new Moralis.Query(Moralis.User);
losingUserQuery.doesNotMatchKeyInQuery("hometown", "city", teamQuery);
// results has the list of users with a hometown team with a losing record
const results = await losingUserQuery.find();

要根据 objectId 从第二个表中的指针过滤行，可以使用点表示法：

const rolesOfTypeX = new Moralis.Query("Role");
rolesOfTypeX.equalTo("type", "x");

const groupsWithRoleX = new Moralis.Query("Group");
groupsWithRoleX.matchesKeyInQuery(
  "objectId",
  "belongsTo.objectId",
  rolesOfTypeX
);
groupsWithRoleX.find().then(function (results) {
  // results has the list of groups with role x
});

通过使用键列表调用 select 来限制返回的字段。

例如，要检索仅包含 strength 和 ownerName 字段（以及特殊的内置字段，如 objectId、createdAt 和 updatedAt）的文档：

你可以通过JS、React来实现

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);
query.select("strength", "ownerName");
query.find().then(function (monsters) {
  // each of the monsters will only have the selected fields available.
});

import { useMoralisQuery } from "react-moralis";

export default function App() {
  const { fetch } = useMoralisQuery(
    "Monster",
    (query) => query.select("strength", "ownerName"),
    [],
    { autoFetch: false }
  );

  const getSelectedQuery = () =>
    fetch({
      onSuccess: (monster) => {
        // each of the monsters will only have the selected fields available.
      },
    });

  return <button onClick={getSelectedQuery}>Call The Code</button>;
}

同样，要在检索其余字段时删除不需要的字段，请使用 exclude（可以通过JS、React来实现）：

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);
query.exclude("ownerName");
query.find().then(function (monsters) {
  // Now each monster will have all fields except `ownerName`
});

import { useMoralisQuery } from "react-moralis";

export default function App() {
  const { fetch } = useMoralisQuery(
    "Monster",
    (query) => query.exclude("ownerName"),
    [],
    { autoFetch: false }
  );

  const queryExcludingParam = () =>
    fetch({
      onSuccess: (monsters) => {
        // Now each monster will have all fields except `ownerName`
      },
    });

  return <button onClick={queryExcludingParam}>Call The Code</button>;
}

稍后可以通过对返回的对象调用 fetch 来获取剩余的字段：

query
  .first()
  .then(function (result) {
    // only the selected fields of the object will now be available here.
    return result.fetch();
  })
  .then(function (result) {
    // all fields of the object will now be available here.
  });

请记住在对address列进行查询约束时确保addresses为小写。

数组值查询

对于数组类型的键，您可以通过以下方式找到键的数组值包含 2 的对象：

// Find objects where the array in arrayKey contains 2.
query.equalTo("arrayKey", 2);

您还可以找到键的数组值包含每个元素 2、3 和 4 的对象，其中包含以下内容：

// Find objects where the array in arrayKey contains all of the elements 2, 3, and 4.
query.containsAll("arrayKey", [2, 3, 4]);

仪表板中的查询测试

注意：可以直接在“Moralis Dashboard”中运行查询代码。可以通过导航到菜单中的“API 控制台 > JS 控制台”找到它。这是一个在首次构建查询时玩耍的好地方，因为它不需要任何设置或初始化。它的功能与浏览器中的 JavaScript 控制台完全相同，只是它可以直接访问 Moralis SDK 和主密钥。

完全按照您在客户端或云代码中的方式键入查询。包括一个 console.log() 来打印结果，然后按“运行”按钮。需要注意的一些差异：

需要使用 Parse 关键字而不是 Moralis

即新 Parse.Query("EthTokenTransfers")
这可能会在未来的版本中得到修复（Moralis 是 Parse 的一个分支）。

不要在查询中转义 $。
您可以使用主密钥 - const results = query.find({ useMasterKey: true })

可以通过单击“保存”在会话之间保存代码。

字符串值查询

从搜索开始

使用 startsWith 限制以特定字符串开头的字符串值。与 MySQL LIKE 运算符类似，这是索引的，因此对于大型数据集很有效：

// Finds barbecue sauces that start with "Big Daddy's".
const query = new Moralis.Query(BarbecueSauce);
query.startsWith("name", "Big Daddy's");

上面的示例将匹配“name”字符串键中的值以“Big Daddy's”开头的任何 BarbecueSauce 对象。例如，“Big Daddy's”和“Big Daddy's BBQ”都会匹配，但“big daddy's”或“BBQ Sauce: Big Daddy's”不匹配。

具有正则表达式约束的查询非常昂贵，尤其是对于超过 100,000 条记录的类。 Moralis 限制在任何给定时间可以在特定应用程序上运行的操作数。

全文检索

使用全文以获得高效的搜索功能。文本索引会自动为您创建。您的字符串将转换为标记以进行快速搜索。

注意：全文搜索可能是资源密集型的。确保使用索引的成本物有所值。

const query = new Moralis.Query(BarbecueSauce);
query.fullText("name", "bbq");

上面的示例将匹配“name”字符串键中的值包含“bbq”的任何 BarbecueSauce 对象。例如，“Big Daddy's BBQ”、“Big Daddy's bbq”和“Big BBQ Daddy”都将匹配。

// You can sort by weight / rank. ascending() and select()
const query = new Moralis.Query(BarbecueSauce);
query.fullText("name", "bbq");
query.ascending("$score");
query.select("$score");
query
  .find()
  .then(function (results) {
    // results contains a weight / rank in result.get('score')
  })
  .catch(function (error) {
    // There was an error.
  });

关系查询

有几种方法可以发出对关系数据的查询。要检索字段与特定 Moralis.Object 匹配的对象，您可以使用 equalTo，就像其他数据类型一样。

例如，如果每个 Comment 在其 post 字段中都有一个 Post 对象，您可以获取特定 Post 的评论：

// Assume Moralis.Object myPost was previously created.
const query = new Moralis.Query(Comment);
query.equalTo("post", myPost);
// comments now contains the comments for myPost
const comments = await query.find();

要检索字段包含匹配不同查询的 Moralis.Object 的对象，您可以使用 matchesQuery。为了查找包含图片的帖子的评论，您可以执行以下操作：

const Post = Moralis.Object.extend("Post");
const Comment = Moralis.Object.extend("Comment");
const innerQuery = new Moralis.Query(Post);
innerQuery.exists("image");
const query = new Moralis.Query(Comment);
query.matchesQuery("post", innerQuery);
// comments now contains the comments for posts with images.
const comments = await query.find();

要检索字段包含不匹配不同查询的 Moralis.Object 的对象，您可以使用 doesNotMatchQuery。要查找没有图片的帖子的评论，您可以执行以下操作：

const Post = Moralis.Object.extend("Post");
const Comment = Moralis.Object.extend("Comment");
const innerQuery = new Moralis.Query(Post);
innerQuery.exists("image");
const query = new Moralis.Query(Comment);
query.doesNotMatchQuery("post", innerQuery);
// comments now contains the comments for posts without images.
const comments = await query.find();

您还可以通过 objectId 进行关系查询：

const post = new Post();
post.id = "1zEcyElZ80";
query.equalTo("post", post);

要在一个查询中返回多种类型的相关对象，请使用 include 方法。

例如，假设您正在检索最后 10 条评论，并且您想同时检索他们的相关帖子：

const query = new Moralis.Query(Comment);

// Retrieve the most recent ones
query.descending("createdAt");

// Only retrieve the last ten
query.limit(10);

// Include the post data with each comment
query.include("post");

// Comments now contains the last ten comments, and the "post" field
const comments = await query.find();
// has been populated. For example:
for (let i = 0; i < comments.length; i++) {
  // This does not require a network access.
  const post = comments[i].get("post");
}

做多级包括使用点符号。使用以下查询。

例如，如果您想包含评论的帖子和帖子的作者，您可以这样做：

query.include(["post.author"]);

您可以通过多次调用 include 来发出包含多个字段的查询。此功能也适用于 Moralis.Query 助手，例如 first 和 get。

计数对象

注意：在旧的 Moralis 托管后端中，计数查询的速率被限制为每分钟最多 160 个请求。他们还为包含 1,000 多个对象的类返回了不准确的结果。但是，Moralis Dapp 已经消除了这两个限制，并且可以计算远高于 1,000 个的对象。

要计算有多少对象与查询匹配，但您不需要检索所有匹配的对象，可以使用 count 而不是 find。

例如，要计算特定monster拥有者拥有的monster数量：

const Monster = Moralis.Object.extend("Monster");
const query = new Moralis.Query(Monster);
query.equalTo("ownerName", "Aegon");
const count = await query.count();
alert("Aegon has owned " + count + " monsters");

复合查询

对于更复杂的查询，您可能需要复合查询。复合查询是子查询的逻辑组合（例如“and”或“or”）。

注意：我们不支持复合查询的子查询中的 GeoPoint 或非过滤约束（例如 near、withinGeoBox、limit、skip、ascending/descending、include）。

OR-ed 查询约束

要查找与多个查询之一匹配的对象，您可以使用 Moralis.Query.or 方法构造一个查询，该查询是传入查询的 OR。

例如，如果您想找到获得很多胜利或少数胜利的玩家，您可以执行以下操作：

const lotsOfWins = new Moralis.Query("Player");
lotsOfWins.greaterThan("wins", 150);

const fewWins = new Moralis.Query("Player");
fewWins.lessThan("wins", 5);

const mainQuery = Moralis.Query.or(lotsOfWins, fewWins);
mainQuery
  .find()
  .then(function (results) {
    // results contains a list of players that either have won a lot of games or won only a few games.
  })
  .catch(function (error) {
    // There was an error.
  });

AND-ed 查询约束

要查找符合所有条件的对象，通常只使用一个查询。您可以向新创建的 Moralis.Query 添加额外的约束，充当and运算符。

const query = new Moralis.Query("User");
query.greaterThan("age", 18);
query.greaterThan("friends", 0);
query
  .find()
  .then(function (results) {
    // results contains a list of users both older than 18 and having friends.
  })
  .catch(function (error) {
    // There was an error.
  });

有时比这个简单的示例更复杂，您可能需要子查询的复合查询。您可以使用 Moralis.Query.and 方法构造一个查询，该查询是传入查询的 AND。

例如，如果您想查找 16 岁或 18 岁且没有朋友或至少有两个朋友的用户，您可以执行以下操作：

const age16Query = new Moralis.Query("User");
age16Query.equalTo("age", 16);

const age18Query = new Moralis.Query("User");
age18Query.equalTo("age", 18);

const friends0Query = new Moralis.Query("User");
friends0Query.equalTo("friends", 0);

const friends2Query = new Moralis.Query("User");
friends2Query.greaterThan("friends", 2);

const mainQuery = Moralis.Query.and(
  Moralis.Query.or(age16Query, age18Query),
  Moralis.Query.or(friends0Query, friends2Query)
);
mainQuery
  .find()
  .then(function (results) {
    // results contains a list of users in the age of 16 or 18 who have either no friends or at least 2 friends
    // results: (age 16 or 18) and (0 or >2 friends)
  })
  .catch(function (error) {
    // There was an error.
  });

总计的

可以使用聚合进行查询，允许您通过一组输入值检索对象。结果不会是 Moralis.Objects，因为您将聚合自己的字段。

MasterKey 是必需的。

聚合使用阶段通过将结果从一个阶段传递到下一个阶段来过滤结果。前一阶段的输出成为下一阶段的输入。

您可以使用数组或对象创建管道。

const pipelineObject = {
  group: { objectId: "$name" },
};

const pipelineArray = [{ group: { objectId: "$name" } }];

有关可用阶段的列表，请参阅 Mongo 聚合文档。

注意：Mongo 聚合文档中的大多数操作都适用于 Moralis Server，但 _id 不存在。请替换为 objectId。

Match

Match管道类似于equalTo。

const pipeline = [{ match: { name: "BBQ" } }];

const query = new Moralis.Query("User");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains name that matches 'BBQ'
  })
  .catch(function (error) {
    // There was an error.
  });

您可以通过比较来匹配。

const pipeline = [{ match: { score: { $gt: 15 } } }];

const query = new Moralis.Query("User");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains score greater than 15
  })
  .catch(function (error) {
    // There was an error.
  });

您可以在 Mongo 查询运算符文档中阅读有关可用运算符的更多信息。

Lookup (Join)

lookup管道类似于 SQL 中的 LEFT OUTER JOIN。它将匹配另一个集合中的文档并将它们作为数组属性带入结果中。

例如，在投资组合应用程序中，您可能希望显示用户的所有代币交易。在 Moralis 中，这些存储在 EthTokenTransfers 集合中。除了令牌名称和小数位数之外，此集合包含所需的所有信息，这些信息是在前端以一种很好的方式显示此信息所必需的。额外的信息在 EthTokenBalance 集合中，为了得到它，我们需要查找。有关更多详细信息，请查看 Mongo lookup文档。

简单查找（单等式）

不幸的是，对于我们的用例，EthTokenBalance 集合不仅包含我们当前用户的信息，还包含所有用户的信息。这意味着每个持有该令牌的用户都会重复该令牌名称。这意味着加入多个属性，它需要不同的语法，下面将介绍。现在，假设我们有另一个名为 Token 的集合，它看起来像这样：

Token {
  objectId: string,
  token_address: string,
  symbol: string,
  name: string,
  decimals: number
}

然后你会定义一个这样的云函数（聚合查询必须在云代码中运行）。

记住要像 \$ 一样转义 $ 以防止解析错误（现在已修复！）。

// this goes in the Moralis server Cloud Functions section
Moralis.Cloud.define("getUserTokenTransfers", function (request) {
  const userAddress = request.params.userAddress;
  const query = new Moralis.Query("EthTokenTransfers");

  const pipeline = [
    // only transfers to or from userAddress
    {
      match: {
        $expr: {
          $or: [
            { $eq: ["$from_address", userAddress] },
            { $eq: ["$to_address", userAddress] },
          ],
        },
      },
    },

    // join to Token collection on token_address
    {
      lookup: {
        from: "Token",
        localField: "token_address",
        foreignField: "token_address",
        as: "token",
      },
    },
  ];

  return query.aggregate(pipeline);
});

输出如下所示： “token”指定 Token 表中匹配文档的输出数组的名称。如果连接是一对多而不是一对一，则此数组的长度将大于 1。

[
  {
    // EthTokenTransfer collection attributes
    "block_timestamp":{...}
    "token_address": "0x8762db106b2c2a0bccb3a80d1ed41273552616e8"
    "from_address": "0xba65016890709dbc9491ca7bf5de395b8441dc8b"
    "to_address": "0x29781d9fca70165cbc952b8c558d528b85541f0b"
    "value": "29803465370630263212090"
    "transaction_hash": "0xfc611dbae7c67cd938fca58a0cc2fe46d224f71b91472d4c9241e997e6440ac1"
    "token": [
      {
        // Token collection attributes from lookup
        "_id": "HKA8dzHG1A"
        "token_address": "0x8762db106b2c2a0bccb3a80d1ed41273552616e8"
        "symbol": "RSR"
        "name": "Reserve Rights"
        "decimals": 18
      }
    ]
  }
]

复杂连接（多重相等）

连接多个属性需要在查找中使用嵌套管道，但在定义集合应如何连接时提供了更大的灵活性。上面的查询可以重写以加入 EthTokenTranfers 和 EthTokenBalance。

// this goes in the Moralis server Cloud Functions section
Moralis.Cloud.define("getUserTokenTransfers", function(request) {
  const userAddress = request.params.userAddress;
  const query = new Moralis.Query("EthTokenTransfers");

  const pipeline = [
    // only transfers to or from userAddress
    {match: {$expr: {$or: [
      {$eq: ["$from_address", userAddress]},
      {$eq: ["$to_address", userAddress]},
    ]}}},

      // join to EthTokenBalance on token_address and userAddress
    {lookup: {
      from: "EthTokenBalance",
      let: { tokenAddress: "$token_address", userAddress: userAddress},
      pipeline: [
        {$match: {$expr: {$and: [
          { $eq: ["$token_address", "$tokenAddress"] },
          { $eq: ["$address", "$userAddress"] },
      ]}}],
      as: "EthTokenBalance",
    }}
  ];

  return query.aggregate(pipeline);
});

lookup管道使用匹配阶段来指定其他连接条件。另外，请注意 let 定义了查找管道要使用的变量。这是必需的，因为查找管道无法直接访问原始集合中的属性。有关详细信息，请参阅 MongoDB $lookup 文档中的“使用 $lookup 指定多个连接条件”部分。

项目（选择）

项目管道类似于键或选择、添加或删除现有字段。

const pipeline = [{ project: { name: 1 } }];

const query = new Moralis.Query("User");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains only name field
  })
  .catch(function (error) {
    // There was an error.
  });

Group

组管道类似于不同的。

您可以按字段分组：

// score is the field. $ before score lets the database know this is a field
const pipeline = [{ group: { objectId: "$score" } }];

const query = new Moralis.Query("User");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains unique score values
  })
  .catch(function (error) {
    // There was an error.
  });

您可以应用集体计算，如 $sum、$avg、$max、$min。

// total will be a newly created field to hold the sum of score field
const pipeline = [{ group: { objectId: null, total: { $sum: "$score" } } }];

const query = new Moralis.Query("User");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains sum of score field and stores it in results[0].total
  })
  .catch(function (error) {
    // There was an error.
  });

如果要对包含数值但它们作为字符串存储在数据库中的列执行计算，则必须将值转换为数值数据类型。例如，存储在字符串列中的 uint256 应使用 $toLong 进行转换。

 { group: { objectId: '$nftItem',  priceOfAllNfts: { $sum: {$toLong : '$price'} } } },

可以使用 $$ROOT 访问与分组字段匹配的文档集合，并且可以使用 $push 累加器将其推送到数组中。

// games will be an array of all the games played by each unique player
const pipeline = [
  { group: { objectId: "$playerId", games: { $push: "$ROOT" } } },
];

const query = new Moralis.Query("GameRound");

query
  .aggregate(pipeline)
  .then(function (results) {
    // results contains a collection of players with their respective games played
  })
  .catch(function (error) {
    // There was an error.
  });

您可以使用点表示法按子文档的列进行分组。但是，您必须将其括在引号中。

 { group: { objectId: '$player.username',  games: { $push: "$ROOT" } } },

Sort

排序阶段用于按给定列按特定顺序对结果进行排序。

指定排序顺序，1 用于升序排序，-1 用于降序排序。

// This will sort the rows in ascending order based on the username field
{
  sort: {
    username: 1;
  }
}

您可以按给定顺序按几列排序。

 // This will sort the rows in ascending order based on the country field,
 // and then in descending order on the city field
 { sort : { country: 1, city: -1 } }

skip

跳过阶段跳过传递到该阶段的指定行数。这通常在实现分页功能时使用。

// This stage will skip the first 5 rows passed into this stage
{
  skip: 5;
}

Limit

限制阶段仅包括传入该阶段的前 n 行。

// This stage will throw away all rows except the first 5
{
  limit: 5;
}

Count

count 阶段返回传递到分配给变量名称的阶段的行数。

// This stage will return the number of rows passed into the stage
// and store it in the variable numberOfNfts
{
  count: "numberOfNfts";
}

Distinct

可以使用 distinct 进行查询，允许您找到指定字段的唯一值。

MasterKey 是必需的。

const query = new Moralis.Query("User");

query
  .distinct("age")
  .then(function (results) {
    // results contains unique age
  })
  .catch(function (error) {
    // There was an error.
  });

您还可以使用 equalTo 限制结果。

const query = new Moralis.Query("User");
query.equalTo("name", "foo");
query
  .distinct("age")
  .then(function (results) {
    // results contains unique age where name is foo
  })
  .catch(function (error) {
    // There was an error.
  });

阅读偏好

使用 MongoDB 副本集时，您可以使用 query.readPreference(readPreference, includeReadPreference, subqueryReadPreference) 函数来选择将从哪个副本中检索对象。 includeReadPreference 参数选择从哪个副本中检索包含的指针，而 subqueryReadPreference 参数选择子查询将在哪个副本中运行。可能的值为 PRIMARY（默认）、PRIMARY_PREFERRED、SECONDARY、SECONDARY_PREFERRED 或 NEAREST。如果未传递 includeReadPreference 参数，则为 readPreference 选择的相同副本也将用于包含。相同的规则适用于 subqueryReadPreference 参数。

query.readPreference("SECONDARY", "SECONDARY_PREFERRED", "NEAREST");

w3cschool 编程狮，随时随地学编程

Moralis 查询

基本查询

使用主密钥

查询约束

数组值查询

仪表板中的查询测试

字符串值查询

从搜索开始

全文检索

关系查询

计数对象

复合查询

OR-ed 查询约束

AND-ed 查询约束

总计的

Match

Lookup (Join)

简单查找（单等式）

复杂连接（多重相等）

项目（选择）

Group

Sort

skip

Limit

Count

Distinct

阅读偏好

Moralis 连接SDK

Moralis 用户

Moralis Web3身份验证

Moralis 电子邮件

Moralis 转移资产

Moralis Web3 API

Moralis Solana API

Moralis 自动同步

Moralis 数据库

Moralis 云代码

Moralis Web3

Moralis 文件

Moralis 工具

Moralis 连接RPC节点