Errores de MongoSQL

Descripción: Una función (por ejemplo, Sin, Abs, Round) tiene un número incorrecto de argumentos.

Causas comunes: Una función tiene un argumento extra o le falta uno. Por ejemplo, en,SELECT ROUND(a,1,5) FROM foo donde a es int un, ROUND tiene un argumento extra.

Pasos de resolución: El mensaje de error indica qué función tiene un número incorrecto de argumentos y cuántos debería tener. Utilice esta información para corregir su consulta. Consulta de ejemploSELECT ROUND(a,1) FROM foo corregida:.

Descripción: La operación especificada (por ejemplo, Sub, And, Substring) tiene un(os) argumento(s) del tipo incorrecto (por ejemplo, string, int).

Causas comunes: Se usó por error un campo de tipo incorrecto en la función especificada. Por ejemplo,, SELECT ROUND(str,5) FROM foo donde str es del tipo cadena, causa este error.

Pasos de resolución: El mensaje de error indica qué función tiene un argumento de tipo incorrecto y cuál es el tipo esperado. Utilice esta información para corregir su query. query de ejemplo corregida: SELECT ROUND(a,5) FROM foo en donde a es un(a) int.

Descripción: El argumento proporcionado a la agregación no es de un tipo comparable a sí mismo.

Causas comunes: La columna que intenta agregar es de tipo o,object array que no son comparables entre sí.

Por ejemplo, SELECT * FROM myCol GROUP BY a AGGREGATE MIN(obj) as min donde obj es un object provoca este error.

Pasos de resolución: Utilice las funciones de agregación solo en columnas del tipo adecuado. Si desea agregar un valor dentro array de object o, utilice las palabras clave de origen de datos UNWIND o FLATTEN. Consulta de ejemplo corregida: SELECT * FROM myCol GROUP BY a AGGREGATE MIN(a) as min donde a intes.

Descripción: COUNT(DISTINCT *) No es compatible.

Causas comunes: No se admite el uso de COUNT(DISTINCT *) ( ). SELECT COUNT(DISTINCT *) FROM foo

Pasos de resolución: elimine cualquier uso de COUNT(DISTINCT *) de sus consultas.

Descripción: La operación de comparación especificada (por ejemplo, Lte, Between) no se pudo ejecutar debido a que los tipos de sus operandos no son comparables (es decir, comparar un int con una cadena).

Causas comunes: Se utilizaron campos de dos tipos diferentes en la operación de comparación especificada. Por ejemplo,, SELECT * FROM foo WHERE a <= b donde a es un int y b es string un. Además, tenga en cuenta que objects y arrays no son tipos comparables y no se pueden utilizar en operaciones de comparación.

Pasos de resolución: El mensaje de error indica qué operación de comparación tiene tipos conflictivos. Utilice esta información para corregir su consulta. Consulta de ejemplo corregida:, SELECT * FROM foo WHERE a1 <= a2 donde a1 y a2 son del int tipo.

Descripción: No se puede acceder a un campo porque no se puede encontrar (y probablemente no existe).

Causas comunes: Intenta acceder a un campo inexistente, probablemente debido a un error tipográfico. Por ejemplo,, SELECT foo.f FROM foo donde f es un campo inexistente, causa este error.

Pasos para la resolución: Siempre que sea posible, el mensaje de error sugiere nombres de campo similares que podrían haber sido la entrada deseada. Sin embargo, si no se encuentra ninguno similar, MongoSQL no proporciona sugerencias de nombres de campo. Utilice esta información para corregir su consulta. Consulta de ejemplo corregida: SELECT foo.a FROM foo donde a existe como a campo foo de.

Descripción: La cardinalidad del conjunto de resultados de una subconsulta escalar puede ser mayor 1 que. El conjunto de resultados DEBE tener una cardinalidad de 0 1o.

Causas comunes: Su subconsulta escalar podría devolver más de 1 documentos (o filas en SQL). Por ejemplo, SELECT (SELECT a FROM foo) FROM bar causa este error porque (SELECT a FROM foo) podría devolver más de 1 documentos (o filas).

Pasos de resolución: Añada un LIMIT 1 a su subconsulta para garantizar que solo 1 se devuelva documento/fila. Ejemplo correcto deSELECT (SELECT a FROM foo LIMIT 1) FROM bar consulta:.

Descripción: No se puede ordenar por la clave especificada, porque es de un tipo que no se puede comparar consigo mismo.

Causas comunes: La columna que intenta ordenar es de tipo object arrayo, que no son tipos comparables entre sí. Por ejemplo, SELECT * FROM foo ORDER BY obj donde obj es un object genera este error.

Pasos de resolución: Ordene únicamente las columnas del tipo adecuado. Si desea ordenar por un valor dentro array de object o, utilice las palabras clave de origen de datos UNWIND o FLATTEN. Consulta de ejemplo corregida: SELECT * FROM foo ORDER BY a donde a intes.

Descripción: No se puede agrupar por la clave especificada, porque es de un tipo que no se puede comparar consigo mismo.

Causas comunes: La columna por la que intenta agrupar es de tipo o,object array que no son tipos comparables. Por ejemplo, SELECT * FROM foo GROUP BY obj donde obj es un object genera este error.

Pasos de resolución: Agrupe únicamente por columnas del tipo adecuado. Si desea agrupar por un valor dentro array de object o, utilice las palabras clave de origen de datos UNWIND o FLATTEN. Consulta de ejemplo corregida: SELECT * FROM foo ORDER BY a donde a intes.

Descripción: El nombre del ÍNDICE DESENROLLADO entra en conflicto con el nombre de campo existente.

Causas comunes: El nombre del índice coincide con el nombre foo de un campo existente. Por ejemplo, si la colección tiene un campo,b la consulta SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b) causa este error.

Pasos de resolución: Cambie el nombre de ÍNDICE por uno que no sea un campo existente. Consulta de ejemplo corregida: SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b2) donde b2 no es un nombre de campo existente.

Descripción: No se puede encontrar la colección en la base de datos especificada.

Causas comunes: Es posible que esté buscando en la base de datos incorrecta o que haya cometido un error tipográfico que impide encontrar la colección. Por ejemplo, si la colección baz no existe, la consulta SELECT * FROM baz genera este error.

Pasos para la resolución: Asegúrese de que todo esté escrito correctamente y de que esté buscando en la base de datos correcta. Consulta de ejemplo corregida: SELECT * FROM foo donde foo existe en la base de datos actual.

Descripción: Se detectó JSON extendido en la operación de comparación. MongoSQL no admite comparaciones directas con JSON extendido. Utilice la conversiónde datos (consulte "Pasos de resolución" para ver un ejemplo).

Causas comunes: Usar JSON extendido en consultas y esperar que se convierta implícitamente al tipo de dato correcto. Por ejemplo, alguien podría escribir la consulta select _id from customers where _id = '{"$oid":"5ca4bbcea2dd94ee58162a6a"}' porque cree que la cadena JSON extendida se convierte implícitamente ObjectID a. Sin embargo, esto no es así.

Pasos de resolución: No utilice el formato JSON extendido y utilice siempre la conversión CAST explícita. El mensaje de error intenta recomendar la conversión. Consulta de ejemploselect _id from customers where _id = CAST('5ca4bbcea2dd94ee58162a6a' as ObjectID) corregida:. Esta consulta convierte explícitamente ObjectID a.

Descripción: Un campo tiene un tipo BSON no admitido.

Causas comunes: Un campo tiene un tipo BSON no compatible con MongoSQL. Por ejemplo, si foo la colección tiene un campo b de tipo,undefined la consulta SELECT * FROM foo causaría este error.

Pasos para la resolución: Cambie el tipo BSON a uno compatible con MongoSQL. El mensaje de error indica qué tipos de BSON son compatibles.. Consulta de ejemplo corregida: SELECT * FROM foo donde foo existe en la base de datos actual y b no es del undefined tipo.

Descripción: Un campo de tipo de datos binarios tiene el subtipo no admitido de uuid old.

Causas comunes: Históricamente, los distintos controladores han escrito UUID con diferentes órdenes de bytes. Esto puede ocurrir con datos antiguos escritos por un controlador que utiliza el tipo UUID, ahora incompatible.

Pasos de resolución: Atlas SQL no admite la consulta de estos datos.

Descripción: Este error es un comodín para todos los errores del analizador, excepto el token no reconocido.

Causas comunes: Este error puede tener diversos significados, ya que es un error general. Sin embargo, generalmente significa que se usó incorrectamente algún token (palabra clave).

Pasos de resolución: Este error puede generar varios mensajes diferentes, por lo que es importante prestar atención a esos mensajes. Además, es buena idea revisar la input query para garantizar que cada cláusula (así como la instrucción SQL en su conjunto) esté redactada según lo especificado por las directrices.

Descripción: Se encontró un token inesperado o no reconocido.

Causas más comunes: Algo podría haberse escrito mal o colocado en el orden/formato incorrecto. Por ejemplo, SELECT ** FROM foo AS f provoca este error debido al tipo **.

Pasos de resolución: Asegúrate de que todo esté escrito correctamente y en el orden/formato correcto. Además, este error sugiere una lista de tokens que quizás hayas pretendido colocar. Ejemplo de query corregido: SELECT * FROM foo AS f.

Descripción: Una lista SELECT con varios valores no puede contener un sin espacio de nombres * (es decir, SELECT a, *, b FROM myTable no se admite). Un sin espacio de nombres * debe usarse solo.

Causas comunes: seleccionar * y cualquier otra cosa en la misma consulta como se muestra en estaSELECT *, a from foo consulta:.

Pasos de resolución: seleccione solo * (esSELECT * FROM ... decir,) o seleccione valores múltiples y no incluya * (esSELECT a, b FROM ... decir,).

Descripción: La fuente de datos de la matriz contiene referencias. Las fuentes de datos de la matriz deben ser constantes.

Causas comunes: acceso a un campo en una fuente de datos de matriz como se muestra en estaSELECT * FROM [{'a': foo.a}] AS arr consulta:.

Pasos de resolución: Modifique la fuente de datos de la matriz para que solo contenga constantes. Consulta de ejemplo corregida:. SELECT * FROM [{'a': 34}] AS arr

Descripción: SELECT DISTINCT no está permitido.

Causas comunes: SELECT DISTINCT Se utilizó en una consulta. Por ejemplo, la consulta SELECT DISTINCT * from foo causa este error.

Pasos de resolución: No utilice SELECT DISTINCT en una consulta.

Descripción: No se permite una unión distinta. Solo se puede usar UNION ALL (es decir, siempre se deben permitir valores duplicados).

Causas comunes: Usar UNION en lugar de UNION ALL. Por ejemplo, la query SELECT a FROM foo AS foo UNION SELECT b, c FROM bar AS bar causa este error.

Pasos de resolución: Use solo UNION ALL al realizar uniones. Consulta de ejemplo corregida:. SELECT a FROM foo AS foo UNION ALL SELECT b, c FROM bar AS bar

Descripción: No se pudo encontrar una fuente de datos referenciada en la lista SELECT.

Causas comunes: Ejecutar algo SELECT <field>.* FROM ... como donde <field> no tiene subcampos. Por ejemplo, la consulta SELECT a.* FROM foo donde a es un int causa este error.

Pasos de resolución: elimine cualquier acceso de campo que intente acceder a un campo que no existe.

Descripción: No se pudo encontrar un campo en ninguna fuente de datos.

Causas comunes: El campo está mal escrito, no existe o se está buscando en la colección incorrecta. Por ejemplo, Select aa from foo causaría este error si aa no existe en la foo colección.

Pasos para la resolución: Asegúrese de que el campo esté escrito correctamente y de que esté buscando en la colección correcta. Además, el mensaje de error sugiere campos similares que quizás haya intentado escribir.

Descripción: Un campo existe en múltiples fuentes de datos y es ambiguo.

Causas comunes: Dos o más campos tienen el mismo nombre en una colección (o en otra fuente de datos). Por ejemplo, si se supone que a es un campo foo en, SELECT a FROM foo AS coll JOIN foo AS coll2 causaría este error porque las colecciones coll y coll2 tienen el a campo, lo que hace a que sea ambiguo.

Pasos para la resolución: Califique sus referencias ( <Collection>.<field> en lugar field de). En el ejemplo anterior, coll.a o coll2.a solucionarían este error.

Descripción: El argumento * solo es válido en la función de agregación COUNT.

Causas comunes: COUNT es la única operación de agregación que admite el argumento *, es decir, COUNT(*). El paso del argumento * a cualquier otra operación, es decir SUM(*) , provoca este error. Por ejemplo, la consulta SELECT * FROM foo AS arr GROUP BY a AS a AGGREGATE SUM(*) AS gsum.

Pasos de resolución: Utilice únicamente * como argumento COUNT para.

Descripción: Se utilizó una función de agregación en una posición escalar.

Causas comunes: Uso de una función de agregación donde solo se puede usar una función escalar. Por ejemplo, la consulta SELECT VALUE {'suma': SUM(a)} FROM db.bar AS bar GROUP BY a AS a causa este error porque SUM(a) es una función de agregación.

Pasos de resolución: elimine las funciones de agregación en lugares donde solo puede tener funciones escalares.

Descripción: Se utilizó una función escalar en una posición de agregación.

Causas comunes: Uso de una función escalar donde solo se puede usar una función de agregación. Por ejemplo, la consulta SELECT * FROM foo GROUP BY a AGGREGATE round(a) AS round causa este error porque round es una función escalar.

Pasos de resolución: elimine las funciones escalares en lugares donde solo pueda tener funciones de agregación.

Descripción: Se encontró una expresión de no agregación en una lista de funciones de agregación GROUP BY.

Causas comunes: Colocar cualquier cosa que no sea una función de agregación o escalar donde debería haber una agregación. (Utilizar una función escalar en lugar de una agregación provoca un error diferente: Error 3012) Por ejemplo, la query SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) + 7 AS whatever provoca este error, ya que hay una operación de suma junto con una agregación en lugar de solo una agregación.

Pasos de resolución: Utilice agregaciones solo donde estén permitidas. Consulta de ejemplo corregida:. SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) AS whatever

Descripción: Las funciones de agregación deben tener exactamente un argumento.

Causas comunes: Una función de agregación tiene más de un argumento. Por ejemplo, la consulta SELECT * FROM foo GROUP BY a AGGREGATE min(a,b) AS min causa este error porque proporciona dos argumentos para la min agregación.

Pasos de resolución: Asegúrese de que sus agregaciones solo tengan un argumento. Elimine cualquier argumento adicional. Consulta de ejemploSELECT * FROM foo GROUP BY a AGGREGATE min(b) AS min corregida:.

Descripción: Las funciones escalares no admiten DISTINCT.

Causas comunes: Uso DISTINCT de en una función escalar. Por ejemplo, la consulta SELECT ROUND(DISTINCT a,2) FROM foo causa este error.

Pasos de resolución: No utilices DISTINCT en funciones escalares. DISTINCT solo debe usarse en funciones de agregación. query de ejemplo corregida: SELECT ROUND(a,2) FROM foo.

Descripción: Una fuente de datos derivada tiene campos superpuestos.

Causas comunes: Incluir varias fuentes de datos con campos con el mismo nombre en una subconsulta provoca este error. Por ejemplo, si bar las colecciones y foo tienen campos con el mismo nombre, la consulta SELECT * FROM (SELECT * FROM foo AS foo, bar AS bar) AS derived provoca este error.

Pasos de la resolución: Actualice los nombres de los campos comunes para que sean únicos en las distintas fuentes de datos. Una forma sencilla de lograrlo es crear un alias con un nombre único para los campos con el mismo nombre. Con esta técnica, aquí está nuestra consulta de ejemplo corregida:. 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

Descripción: A una unión externa le falta una condición de unión. Las uniones externas deben especificar una condición de unión.

Causas comunes: A un OUTER JOIN le falta una condición JOIN. Por ejemplo, la query SELECT * FROM foo AS foo LEFT OUTER JOIN bar genera este error, porque le falta la sección ON <condition> requerida en la query.

Pasos de resolución: Agregar una condición JOIN (esON <condition> decir,). Consulta de ejemploSELECT * FROM foo AS foo LEFT OUTER JOIN bar ON a = a corregida:.

Descripción: No se pudo crear un entorno esquema debido a un campo duplicado.

Causas comunes: Varias colecciones tienen el mismo alias. Por ejemplo, la consulta SELECT * FROM foo AS alias, bar AS alias causa este error.

Pasos de resolución: Asegúrese de que los alias sean únicos para las colecciones. Consulta de ejemploSELECT * from foo as foo_alias, bar as bar_alias corregida:.

Descripción: Las expresiones de subconsulta escalares deben tener un grado 1 de.

Causas comunes: Selección de más de un campo (o columna en SQL) en una expresión de subconsulta escalar. Por ejemplo, la consulta SELECT (SELECT * FROM foo LIMIT 1) FROM bar AS bar causa este error porque la subconsulta ejecuta y, por lo tanto,SELECT * selecciona varios campos.

Pasos de resolución: Modifique su subconsulta para seleccionar solo un campo. Consulta de ejemplo corregida: SELECT (SELECT a FROM foo LIMIT 1) FROM bar AS bar

Descripción: Un documento tiene varios campos con el mismo nombre.

Causas comunes: seleccionar varios campos de una colección y darles los mismos alias como se muestra en la siguienteSELECT a AS alias, b AS alias FROM foo consulta:.

Pasos de resolución: Cambiar los alias duplicados de los campos por nombres únicos. Consulta de ejemploSELECT a as a_alias, b as b_alias FROM foo corregida:.

Descripción: La misma opción FLATTEN se define más de una vez.

Causas comunes: La misma opción se define más de una vez como lo muestra la siguiente consulta: SELECT * FROM FLATTEN(foo WITH depth => 1, depth => 2).

Pasos de resolución: Remueve cualquier opción duplicada para garantizar que cada opción solo se utilice una vez. query de ejemplo corregida: SELECT * FROM FLATTEN(foo WITH depth => 1).

Descripción: La información del esquema es insuficiente para permitir el aplanamiento de la fuente de datos.

Causas comunes: Intentar aplanar una colección que no tiene suficiente información de esquema. Por ejemplo, suponiendo que tiene una colección llamada noSchemaInfo sin esquema definido, la consulta SELECT * FROM FLATTEN(noSchemaInfo) causa este error. Otra causa común es intentar aplanar una colección con un esquema o algún campo del esquema que tenga additional_properties establecido true en.

Pasos de resolución: Defina todos los campos del esquema para garantizar que esté suficientemente definido. Además, evite additional_properties establecer true en. En su lugar, defina el esquema por completo.

Descripción: Un campo dentro del esquema es un tipo de objeto polimórfico (es decir, considere un campo que podría ser document into), por lo que no se puedenull missing aplanar. Se permite el polimorfismo de objetos y. El aplanamiento solo funciona con tipos de objeto (también conocidos como documentos), por lo que si existe la posibilidad de que algún campo no sea un documento (a menos que las únicas otras posibilidades sean null missingo), no se puede aplanar.

Causas comunes: Intentar aplanar una colección que tiene un esquema que contiene un campo que es de un tipo de objeto Realm polimórfico. Por ejemplo, suponiendo que una colección denominada coll tiene un campo que es un tipo de objeto Realm polimórfico, entonces la consulta SELECT * FROM FLATTEN(coll) produce este error.

Pasos para la resolución: Solo se pueden aplanar tipos de objeto. Para que un campo pueda aplanarse, su esquema DEBE ser un tipo de objeto. La única excepción a esta regla son los objetos que pueden ser nulos o faltantes; aún se pueden aplanar estos objetos a pesar de ser polimórficos. Para corregir este error, debe dejar de intentar aplanar colecciones que tengan campos con tipos de objeto polimórficos o cambiar el esquema de esos campos para que sean solo un tipo de objeto.

Descripción: La misma opción UNWIND se define más de una vez.

Causas comunes: Se utiliza la misma opción más de una vez como se muestra en la siguiente query: SELECT * FROM UNWIND(foo WITH PATH => a, PATH => b).

Pasos de resolución: Remueve cualquier opción duplicada para garantizar que cada opción solo se utilice una vez. query de ejemplo corregida: SELECT * FROM UNWIND(foo WITH PATH => a).

Descripción: A UNWIND le falta la opción PATH. UNWIND debe especificar una opción PATH.

Causas comunes: A UNWIND le falta la opción PATH como lo muestra la siguiente SELECT * FROM UNWIND(foo) consulta.

Pasos de resolución: Agregar la opción PATH a la consulta UNWIND. Consulta de ejemplo corregida:. SELECT * FROM UNWIND(foo WITH PATH => a)

Descripción: La opción UNWIND PATH no es un identificador; sin embargo, debe serlo.

Causas comunes: La opción UNWIND PATH no es un identificador como se muestra en la siguiente consulta SELECT * FROM UNWIND(foo WITH PATH => {'a': []}.a).

Pasos de resolución: Cambiar la opción UNWIND PATH por un identificador. Consulta de ejemploSELECT * FROM UNWIND(foo WITH PATH => a) corregida:.

Descripción: El tipo de destino del CAST es un tipo no válido (es decir, es un tipo desconocido o un tipo para el cual MongoSQL no admite la conversión).

Causas comunes: Conversión a un tipo que MongoSQL no admite. Por ejemplo, la consulta SELECT CAST(a AS DATE) FROM foo

Provoca este error porque DATE no es un tipo de destino compatible.

Pasos de resolución: Convertir solo a tipos de destino compatibles. Los tipos de destino válidos son ARRAY, DOCUMENT, DOUBLE, STRING, OBJECTID, BOOL, BSON_DATE, INT, LONG y DECIMAL, o cualquiera de sus92 alias de tipo SQL- correspondientes: REAL, FLOAT, VARCHAR, CHAR, CHARACTER, CHAR VARYING, CHARACTER VARYING, DEC, NUMERIC, BIT, BOOLEAN, TIMESTAMP, INTEGER, SMALLINT. Consulta de ejemploSELECT CAST(a AS BSON_DATE) FROM foo corregida:.

Descripción: Una clave de clasificación no es válida porque utiliza expresiones complejas (es decir, ORDER BY {'a': b}.a no es válido).

Causas comunes: Intentar ordenar por expresiones complejas o rutas de campo impuras. Por ejemplo, la consulta SELECT * FROM foo ORDER BY CAST(d AS DOCUMENT).a

Provoca este error porque CAST(d AS DOCUMENT) es una expresión compleja.

Pasos de resolución: Asegúrese de ordenar únicamente por la ruta de campo "pura". Una ruta de campo "pura" consta únicamente de

identificadores, como foo.d.a o a.

Descripción: El conjunto de resultados sin espacio de nombres no se puede devolver debido a conflictos de nombres de campo.

Causas comunes: Al configurar el $sql excludeNamespaces campo de agregación como true y consultar varias colecciones con los mismos nombres de campo, se produce este error. Dado que esta opción elimina los espacios de nombres de colección, los campos con el mismo nombre que pertenecen a diferentes colecciones dejan de ser únicos. Por ejemplo, considere las colecciones foo y,bar cada una con un a campo, y una consulta SELECT foo.*, bar.a FROM foo, bar como. Con espacios de nombres de colección en el conjunto de resultados, los dos a campos se pueden diferenciar entre foo bary; sin embargo, sin espacios de nombres de colección, no se pueden distinguir entre sí.

Pasos para la resolución: La mejor manera de corregir este error es usar alias para que los campos conflictivos sean únicos. Consulta de ejemploSELECT foo.*, bar.a AS a_unique_alias from foo, bar corregida:.