MongoSQL 错误

说明：函数（例如，Sin、Abs、Round）的参数数量不正确。

常见原因：函数有多余的参数或缺少参数。 例如，在SELECT ROUND(a,1,5) FROM foo中，其中a是int ，ROUND 有一个额外参数。

解决步骤：错误消息会指示哪个函数的参数数量错误以及应有的参数数量。 使用此信息来更正您的查询。 更正了示例查询： SELECT ROUND(a,1) FROM foo 。

说明：指定的操作（例如 Sub、And、Substring）包含不正确类型（例如 string、int）的参数。

常见原因：在指定函数中错误地使用了错误类型的字段。 例如， SELECT ROUND(str,5) FROM foo会导致此错误，其中str是字符串类型。

解决步骤：该错误消息会指示哪个函数的参数类型错误以及预期的类型。 使用此信息来更正您的查询。 更正了示例查询： SELECT ROUND(a,5) FROM foo ，其中a是int 。

描述：为聚合提供的参数不是可与其自身进行比较的类型。

常见原因：您尝试聚合的列的类型为object或array ，它们自身不具有可比性。

例如， SELECT * FROM myCol GROUP BY a AGGREGATE MIN(obj) as min会导致此错误，其中obj是object 。

解决步骤：仅对适当类型的列使用 AGGREGATE 函数。 如果要对array或object内的值进行聚合，请使用 UNWIND 或 FLATTEN 数据源关键字。 更正了示例查询： SELECT * FROM myCol GROUP BY a AGGREGATE MIN(a) as min ，其中a是int 。

描述： COUNT(DISTINCT *) 不受支持。

常见原因：不支持对COUNT(DISTINCT *) ( SELECT COUNT(DISTINCT *) FROM foo ) 的任何使用。

解决步骤：从查询中删除对COUNT(DISTINCT *)的任何使用。

说明：由于操作数的类型不可比较，无法执行指定的比较操作（例如，Lte、Between）（即，将整数与字符串进行比较）。

常见原因：在指定的比较操作中使用了两种不同类型的字段。 例如， SELECT * FROM foo WHERE a <= b ，其中a是int ， b是string 。 此外，请注意， objects和arrays不是可比较类型，不能用于比较操作。

解决步骤：错误消息会指示哪个比较操作存在类型冲突。 使用此信息来更正您的查询。 更正了示例查询： SELECT * FROM foo WHERE a1 <= a2 ，其中a1和a2的类型都是int 。

说明：无法访问字段，因为找不到该字段（并且可能不存在）。

常见原因：您尝试访问不存在的字段，可能是由于拼写错误造成的。 例如， SELECT foo.f FROM foo会导致此错误，其中f是不存在的字段。

解决步骤：如果可能，错误消息会建议可能是预期输入的类似字段名称。 但是，如果未找到类似字段，MongoSQL 将不会提供字段名称建议。 使用此信息来更正您的查询。 更正了示例查询：SELECT foo.a FROM foo ，其中a 作为a 的foo 字段存在。

说明：标量子查询结果集的关联基数可能大于 1。 结果集的关联基数必须为 0 或 1。

常见原因：标量子查询可能会返回多个文档（或 SQL 中的行）。 例如， SELECT (SELECT a FROM foo) FROM bar会导致此错误，因为(SELECT a FROM foo)可能会返回 1 个以上的文档（或行）。

解决步骤：在子查询中添加LIMIT 1 ，以确保仅返回 1 个文档/行。 正确的示例查询： SELECT (SELECT a FROM foo LIMIT 1) FROM bar 。

说明：无法按指定键排序，因为该键的类型无法与自身进行比较。

常见原因：您尝试排序的列的类型为object或array ，这两种类型不是与自身具有可比性的类型。 例如， SELECT * FROM foo ORDER BY obj （其中obj是object会引发此错误。

解决步骤：仅对适当类型的列进行排序。 如果要对array或object内的值进行排序，请使用 UNWIND 或 FLATTEN 数据源关键字。 更正了示例查询： SELECT * FROM foo ORDER BY a ，其中a是int 。

说明：无法按指定键进行分组，因为该键的类型无法与其自身进行比较。

常见原因：您尝试分组的列的类型为object或array ，这两种类型不是与自身具有可比性的类型。 例如， SELECT * FROM foo GROUP BY obj （其中obj是object会引发此错误。

解决步骤：仅按相应类型的列进行分组。 如果要按array或object内的值进行分组，请使用 UNWIND 或 FLATTEN 数据源关键字。 更正了示例查询： SELECT * FROM foo ORDER BY a ，其中a是int 。

说明： UNWIND INDEX 名称与现有字段名称冲突。

常见原因： INDEX 名称与现有字段名称相同。 例如，如果collection foo具有字段b ，则查询SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b)会导致此错误。

解决步骤：将 INDEX 名称更改为不是现有字段的名称。 更正了示例查询： SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b2) ，其中b2不是现有的字段名称。

描述：在指定的数据库中找不到collection。

常见原因：您可能查找了错误的数据库，或者输入了错误，导致找不到该collection。例如，如果collection baz不存在，则查询SELECT * FROM baz会导致此错误。

解决步骤：确保所有内容拼写正确，并且您在正确的数据库中查找。 更正了示例查询： SELECT * FROM foo ，其中foo存在于当前数据库中。

说明：在比较操作中检测到扩展 JSON。 MongoSQL 不支持与扩展 JSON 进行直接比较。 请改用转换（有关示例，请参阅“解决方案步骤”）。

常见原因：在查询中使用扩展 JSON 并期望其隐式转换为正确的数据类型。 例如，有人编写查询select _id from customers where _id = '{"$oid":"5ca4bbcea2dd94ee58162a6a"}'可能是因为他们认为扩展 JSON 字符串隐式转换为ObjectID 。 然而，事实并非如此。

解决步骤：不要使用扩展 JSON 格式，并始终显式进行 CAST。 错误消息会尝试建议您应该执行的操作（类型转换）。 更正了示例查询： select _id from customers where _id = CAST('5ca4bbcea2dd94ee58162a6a' as ObjectID) 。 此查询会显式转换为ObjectID 。

描述：字段具有不支持的 BSON 类型。

常见原因： MongoSQL 不支持字段的 BSON 类型。 例如，如果collection foo具有类型为undefined的字段b ，则查询SELECT * FROM foo将导致此错误。

解决步骤：将 BSON 类型更改为 MongoSQL 支持的类型。 错误消息会说明BSON types 支持哪些 。更正了示例查询： SELECT * FROM foo ，其中foo存在于当前数据库中，且b的类型不是undefined 。

描述：二进制数据类型的字段具有不支持的 uuid old 子类型。

常见原因：从历史上看，不同的驱动程序使用不同的字节顺序写入 Uuid。 对于使用现在不支持的 uuid 类型的驱动程序写入的较旧数据，可能会出现这种情况。

解决步骤： Atlas SQL 不支持查询此数据。

描述：此错误涵盖除无法识别的词元之外的所有解析器错误。

常见原因：此错误可能是多种平均值，因为它是一个包罗万象的错误。但是，这通常意味着某些词元（关键字）使用不正确。

解决步骤：此错误可能会显示多条不同的消息，因此请务必注意这些消息。 此外，最好检查输入的查询，确保每个子句（以及整个 SQL 声明）都是按照指南的规定编写的。

描述：遇到意外或无法识别的令牌。

常见原因：某些内容可能拼写错误或顺序/格式错误。 例如， SELECT ** FROM foo AS f由于**类型而导致此错误。

解决步骤：确保所有内容拼写正确并以正确的顺序/格式排列。 此外，此错误还会建议您可能平均值放入的令牌列表。更正了示例查询： SELECT * FROM foo AS f 。

说明：具有多个值的 SELECT 列表不能包含非命名空间的* （即不支持SELECT a, *, b FROM myTable ）。 非命名空间的*必须单独使用。

常见原因：在同一查询中选择*和其他任何内容，如此查询SELECT *, a from foo所示。

解决步骤：仅选择* （即SELECT * FROM ... ）或选择多个值但不包含* （即SELECT a, b FROM ... ）。

说明：数组数据源包含引用。 数组数据源必须是常量。

常见原因：访问数据源中的字段，如此查询所示： SELECT * FROM [{'a': foo.a}] AS arr 。

解决步骤：修改数组数据源，使其仅包含常量。 更正了示例查询： SELECT * FROM [{'a': 34}] AS arr 。

说明：不允许使用 SELECT DISTINCT。

常见原因： SELECT DISTINCT 用于查询。 例如，查询SELECT DISTINCT * from foo会导致此错误。

解决步骤：不要在查询中使用SELECT DISTINCT 。

说明：不允许使用不同的 UNION。 您只能执行UNION ALL （即必须始终允许重复值）。

常见原因：使用UNION而不是UNION ALL 。 例如，查询SELECT a FROM foo AS foo UNION SELECT b, c FROM bar AS bar会导致此错误。

解决步骤：仅在执行并集操作时使用UNION ALL 。 更正了示例查询： SELECT a FROM foo AS foo UNION ALL SELECT b, c FROM bar AS bar 。

说明：找不到 SELECT 列表中引用的数据源。

常见原因：执行类似SELECT <field>.* FROM ...的操作，其中<field>没有任何子字段。 例如，其中a为int的查询SELECT a.* FROM foo会导致此错误。

解决步骤：删除任何尝试访问不存在字段的字段访问。

描述：在任何数据源中均未找到字段。

常见原因：字段拼写错误或不存在，或者您在错误的collection中查找。例如，如果collectionfoo中不存在aa ， Select aa from foo就会导致此错误。

解决步骤：确保字段拼写正确，并且您在正确的集合中查找。 此外，错误消息还会建议您可能平均值写入的任何类似字段。

描述：一个字段存在于多个数据源中并且不明确。

常见原因：collection（或某些其他数据源）中两个或多个字段具有相同名称。例如，假设a是foo中的字段， SELECT a FROM foo AS coll JOIN foo AS coll2就会导致此错误，因为集合coll和coll2都有字段a ，导致a不明确。

解决步骤：限定引用（ <Collection>.<field>而不是field ）。 在上面的示例中， coll.a或coll2.a将修复此错误。

说明： * 参数仅在 COUNT 聚合函数中有效。

常见原因： COUNT 是唯一支持*参数（即COUNT(*) ）的聚合操作。 将*参数传递给任何其他操作（即SUM(*) ）都会导致此错误。 例如，查询SELECT * FROM foo AS arr GROUP BY a AS a AGGREGATE SUM(*) AS gsum 。

解决步骤：仅使用*作为COUNT的参数。

描述：在标量位置使用了聚合函数。

常见原因：使用了只能使用标量函数的聚合函数。 例如，查询SELECT VALUE {'suma': SUM(a)} FROM db.bar AS bar GROUP BY a AS a会导致此错误，因为SUM(a)是聚合函数。

解决步骤：删除只能使用标量函数的地方的聚合函数。

描述：在聚合位置使用了标量函数。

常见原因：使用了只能使用聚合函数的标量函数。 例如，查询SELECT * FROM foo GROUP BY a AGGREGATE round(a) AS round会导致此错误，因为round是标量函数。

解决步骤：删除只能使用聚合函数的位置中的标量函数。

描述：在 GROUP BY 聚合函数列表中找到非聚合表达式。

常见原因：将聚合或标量函数以外的任何内容放在应该聚合的位置。 （使用标量函数代替聚合会导致不同的错误：错误 3012）。 例如，查询SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) + 7 AS whatever会导致此错误，因为其中存在加法操作和聚合，而不仅仅是聚合。

解决步骤：仅在允许聚合的地方使用聚合。 更正了示例查询： SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) AS whatever 。

说明：聚合函数必须只有一个参数。

常见原因：聚合函数有多个参数。 例如，查询SELECT * FROM foo GROUP BY a AGGREGATE min(a,b) AS min会导致此错误，因为它为min聚合提供了两个参数。

解决步骤：确保聚合只有一个参数。 删除所有其他参数。 更正了示例查询： SELECT * FROM foo GROUP BY a AGGREGATE min(b) AS min 。

说明：标量函数不支持 DISTINCT。

常见原因：在标量函数中使用DISTINCT 。 例如，查询SELECT ROUND(DISTINCT a,2) FROM foo会导致此错误。

解决步骤：不要在标量函数中使用DISTINCT 。 DISTINCT只应用于聚合函数。 更正了示例查询： SELECT ROUND(a,2) FROM foo 。

描述：派生数据源具有重叠字段。

常见原因：在给定子查询中包含多个数据源，每个数据源都具有相同名称的字段，从而导致此错误。 例如，假设集合bar和集合foo具有同名字段，则查询SELECT * FROM (SELECT * FROM foo AS foo, bar AS bar) AS derived会导致此错误。

解决步骤：更新公用字段名称，使其在数据源中具有唯一性。 实现此目的的一种简单方法是为具有相同名称的字段指定唯一的名称。 使用这种技术，以下是我们更正后的示例查询： SELECT * FROM (SELECT a, b, c, ..., z, FROM foo, a AS bar_a, b AS bar_b, c AS bar_c, ..., z AS bar_z FROM bar) AS derived 。

说明： OUTER JOIN 缺少 JOIN 条件。 OUTER JOIN 必须指定 JOIN 条件。

常见原因： OUTER JOIN 缺少 JOIN 条件。 例如，查询SELECT * FROM foo AS foo LEFT OUTER JOIN bar会导致此错误，因为它缺少查询中必需的ON <condition>部分。

解决步骤：添加 JOIN 条件（即ON <condition> ）。 更正了示例查询： SELECT * FROM foo AS foo LEFT OUTER JOIN bar ON a = a 。

描述：由于字段重复，无法创建模式环境。

常见原因：多个collection具有相同的别名。例如，查询SELECT * FROM foo AS alias, bar AS alias会导致此错误。

解决步骤：确保别名对于collection是唯一的。更正了示例查询： SELECT * from foo as foo_alias, bar as bar_alias 。

说明：标量子查询表达式的次数必须为 1。

常见原因：在标量子查询表达式中选择了多个字段（或 SQL 中的列）。 例如，查询SELECT (SELECT * FROM foo LIMIT 1) FROM bar AS bar会导致此错误，因为子查询在执行SELECT *时会选择多个字段。

解决步骤：修改子查询，以便仅选择一个字段。 更正的示例查询： SELECT (SELECT a FROM foo LIMIT 1) FROM bar AS bar

描述：一个文档有多个同名的字段。

常见原因：从collection中选择多个字段并为它们指定相同的别名，如以下查询所示： SELECT a AS alias, b AS alias FROM foo 。

解决步骤：将字段的重复别名更改为唯一名称。 更正了示例查询： SELECT a as a_alias, b as b_alias FROM foo 。

说明：同一 FLATTEN 选项被定义多次。

常见原因：同一选项被多次定义，如以下查询所示： SELECT * FROM FLATTEN(foo WITH depth => 1, depth => 2) 。

解决步骤：删除所有重复选项，确保每个选项仅使用一次。 更正了示例查询： SELECT * FROM FLATTEN(foo WITH depth => 1) 。

描述：模式信息不足，无法展平数据源。

常见原因：尝试展平没有足够模式信息的集合。 例如，假设您有一个名为noSchemaInfo的集合，但未定义模式，则查询SELECT * FROM FLATTEN(noSchemaInfo)会导致此错误。 另一个常见原因是尝试展平collection，其中的模式或模式中的某些字段将additional_properties设置为true 。

解决步骤：定义模式中的所有字段，以确保模式得到充分定义。 此外，尽量避免将additional_properties设置为true 。 相反，请完整定义模式。

描述：模式中的字段是多态对象类型（即，考虑可以是document或int的字段），因此无法展平。 允许null和missing对象多态性。 展平仅适用于对象（也称为文档）类型，因此如果某个字段可能不是文档（除非唯一的其他可能性是null或missing ），则无法对其进行展平。

常见原因：尝试展平一个collection，该collection的模式包含属于多态Realm 对象类型的字段。例如，假设名为coll的collection有一个属于Realm 对象类型的字段，则查询SELECT * FROM FLATTEN(coll)会导致此错误。

解决步骤：只能展平对象类型。 如果希望字段能够被展平，则该字段的模式必须是对象类型。 此规则的唯一例外是可能为 null 或缺失的对象；尽管这些对象是多态的，但您仍然可以展平这些对象。 要修复此错误，必须停止尝试展平具有多态对象类型字段的集合，或者必须将这些字段的模式更改为仅适用于对象类型。

描述：同一 UNWIND 选项被多次定义。

常见原因：多次使用同一选项，如以下查询所示： SELECT * FROM UNWIND(foo WITH PATH => a, PATH => b) 。

解决步骤：删除所有重复选项，确保每个选项仅使用一次。 更正了示例查询： SELECT * FROM UNWIND(foo WITH PATH => a) 。

描述： UNWIND 缺少 PATH 选项。 UNWIND 必须指定 PATH 选项。

常见原因： UNWIND 缺少 PATH 选项，如以下查询SELECT * FROM UNWIND(foo)所示。

解决步骤：将 PATH 选项添加到 UNWIND。 更正了示例查询： SELECT * FROM UNWIND(foo WITH PATH => a) 。

说明： UNWIND PATH 选项不是标识符；而是标识符。但是，它必须是一个。

常见原因： UNWIND PATH 选项不是以下查询SELECT * FROM UNWIND(foo WITH PATH => {'a': []}.a)所示的标识符。

解决步骤：将 UNWIND PATH 选项更改为标识符。 更正了示例查询： SELECT * FROM UNWIND(foo WITH PATH => a) 。

描述： CAST 的目标类型是无效类型（即，它是未知类型或 MongoSQL 不支持转换的类型）。

常见原因：转换为 MongoSQL 不支持转换的类型。 例如，查询SELECT CAST(a AS DATE) FROM foo

会导致此错误，因为DATE不是受支持的目标类型。

解决步骤：仅转换为支持的目标类型。 有效的目标类型为 ARRAY、文档、DOUBLE、STRING、ObjectId、BOOL、BSON_DATE、INT、LONG 和 DECIMAL，或其任何相应的 SQL-92 类型别名：REAL、FLOAT、VARCHAR、CHAR、CHARACTER、CHAR VARYING、CHARACTER VARYING、DEC、NUMERIC、BIT、BOOLEAN、TIMESTAMP、INTEGER、SMALLINT。更正了示例查询： SELECT CAST(a AS BSON_DATE) FROM foo 。

描述：排序键无效，因为它使用了复杂的表达式（即ORDER BY {'a': b}.a无效）。

常见原因：尝试对复杂表达式或“不纯”字段路径进行 ORDER BY。 例如，查询SELECT * FROM foo ORDER BY CAST(d AS DOCUMENT).a

会导致此错误，因为CAST(d AS DOCUMENT)是一个复杂表达式。

解决步骤：确保仅按“纯”字段路径（Field Path）排序。一个"纯"字段路径（Field Path）仅包含

标识符，例如foo.d.a或a 。

说明：由于字段名称冲突，无法返回非命名空间结果集。

常见原因：将$sql聚合excludeNamespaces字段设置为true并查询具有相同字段名称的多个collection会导致此错误。 由于此选项会删除collection命名空间，因此属于不同collection的同名字段不再是唯一的。例如，考虑collection foo和bar ，每个collection都有一个字段a ，以及一个诸如SELECT foo.*, bar.a FROM foo, bar的查询。 通过结果集中的collection命名空间，可以区分foo和bar的两个a字段；但是，如果没有collection命名空间，就无法将它们彼此区分。

解决步骤：修复此错误的最佳方法是使用别名使冲突字段成为唯一字段。 更正了示例查询： SELECT foo.*, bar.a AS a_unique_alias from foo, bar 。