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 un int , 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. Utiliza esta información para corregir tu query. query de ejemplo corregida: SELECT ROUND(a,1) FROM foo.

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 utilizó por error un campo del tipo incorrecto en la función especificada. Por ejemplo, SELECT ROUND(str,5) FROM foo donde str es del tipo string provoca 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: Utiliza solo funciones AGREGADAS en columnas del tipo apropiado. Si deseas AGREGAR un valor dentro de un array o object , utiliza las palabras clave de fuente de datos UNWIND o FLATTEN. query de ejemplo corregida: SELECT * FROM myCol GROUP BY a AGGREGATE MIN(a) as min donde a es un int.

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

Causas comunes: Cualquier uso de COUNT(DISTINCT *) ( SELECT COUNT(DISTINCT *) FROM foo ) no es compatible.

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 pudo ejecutarse debido a tipos incompatibles de sus operandos (es decir, comparar un int con un string).

Causas comunes: se usaron 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 un string. Además, ten en cuenta que objects y arrays no son tipos comparables y no pueden utilizarse en operaciones de comparación.

Pasos de resolución: El mensaje de error indica qué operación de comparación tiene tipos en conflicto. Utiliza esta información para corregir tu query. query de ejemplo corregida: SELECT * FROM foo WHERE a1 <= a2 donde a1 y a2 son ambos del tipo int.

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

Causas comunes: Estás intentando acceder a un campo que no existe, probablemente debido a un error tipográfico. Por ejemplo, SELECT foo.f FROM foo donde f es un campo inexistente provoca 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 de un conjunto de resultados de una subconsulta escalar puede ser mayor a 1. El conjunto de resultados DEBE tener una cardinalidad de 0 o 1.

Causas comunes: Su subconsulta escalar podría devolver más de un documento (o fila 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 un documento (o fila).

Pasos de resolución: Añade un LIMIT 1 a tu subconsulta para asegurarte de que solo se devuelva 1 documento/fila. query de ejemplo correcta: SELECT (SELECT a FROM foo LIMIT 1) FROM bar.

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 en la que se está intentando ordenar es de tipo object o array , los cuales no son tipos comparables entre sí. Por ejemplo, SELECT * FROM foo ORDER BY obj donde obj es un object arroja este error.

Pasos de resolución: Sólo clasifica columnas del tipo apropiado. Si deseas ordenar por un valor dentro de un array o object , utiliza los comandos clave de fuente de datos UNWIND o FLATTEN. query de ejemplo corregida: SELECT * FROM foo ORDER BY a donde a es un int.

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 intentas agrupar es de tipo object o array, que no son tipos autocomparables. Por ejemplo, SELECT * FROM foo GROUP BY obj donde obj es un object lanza este error.

Pasos de resolución: Solo agrupa por columnas del tipo adecuado. Si quieres agrupar por un valor dentro de un array o object , utiliza las palabras clave de fuente de datos UNWIND o FLATTEN. query de ejemplo corregida: SELECT * FROM foo ORDER BY a donde a es un int.

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

Causas comunes: El nombre índice es igual que el nombre de un campo existente. Por ejemplo, si la colección foo tiene un campo b , entonces la query SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b) provoca este error.

Pasos de resolución: Cambia el nombre del ÍNDICE por uno que no sea un campo existente. query 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 encuentra la colección en la base de datos especificada.

Causas comunes: Es posible que estés buscando en la base de datos equivocada o que hayas cometido un error tipográfico que impide que se encuentre la colección. Por ejemplo, si la colección baz no existe, la query SELECT * FROM baz causa 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. Utiliza casting en su lugar (consulta "Pasos de resolución" para un ejemplo).

Causas comunes: Utilizar JSON extendido en las queries y esperar que se convierta implícitamente al tipo de dato correcto. Por ejemplo, alguien podría guardar la query select _id from customers where _id = '{"$oid":"5ca4bbcea2dd94ee58162a6a"}' porque piensa que la string JSON extendida se convierte implícitamente en un ObjectID. Sin embargo, esto no es el caso.

Pasos para solucionar el problema: No utilices el formato Extended JSON y siempre usa CAST explícitamente. El mensaje de error intenta recomendarte qué deberías hacer (converter). Query de ejemplo corregida: select _id from customers where _id = CAST('5ca4bbcea2dd94ee58162a6a' as ObjectID). Esta consulta convierte explícitamente a un ObjectID.

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

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.. Ejemplo corregido de consulta: SELECT * FROM foo donde foo existe en la base de datos actual y b no es del tipo undefined.

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

Causas comunes: Históricamente, diferentes drivers han usado órdenes de bytes distintos para escribir los Uuids. Esto puede ocurrir con datos antiguos escritos por un controlador que utiliza el tipo uuid que ahora no se admite.

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

Descripción: Este error es un cajón de sastre 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 múltiples valores no puede contener un * sin espacio de nombres (es decir, SELECT a, *, b FROM myTable no es compatible). Un * sin espacio de nombres debe utilizarse por sí solo.

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

Pasos para la resolución: Selecciona solo * (es decir, SELECT * FROM ... ) o selecciona múltiples valores y no incluyas * (es decir, SELECT a, b FROM ... ).

Descripción: La fuente de datos del arreglo contiene referencias. Las fuentes de datos de arreglos deben ser constantes.

Causas comunes: Acceso a un campo en una fuente de datos de Array como se muestra en esta consulta: SELECT * FROM [{'a': foo.a}] AS arr.

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 query.

Descripción: No se permite DISTINCT UNION. Sólo puede hacer UNION ALL (es decir, siempre se permiten 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 puede encontrar una fuente de datos referenciada en la lista SELECT.

Causas Comunes: Realizar una acción como SELECT <field>.* FROM ... cuando <field> no tiene ningún subcampo. Por ejemplo, la query SELECT a.* FROM foo donde a es un int provoca 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 frecuentes: El campo está mal escrito o no existe, o buscas en la colección incorrecta. Por ejemplo, Select aa from foo provocaría este error si aa no existe en la colección foo.

Pasos de resolución: Asegurar que el campo esté escrito correctamente y que esté buscando en la colección adecuada. Además, el mensaje de error sugiere cualquier campo similar que pueda haber querido 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 (u otra fuente de datos). Por ejemplo, suponiendo que a sea un campo en foo , SELECT a FROM foo AS coll JOIN foo AS coll2 causaría este error porque las colecciones coll y coll2 tienen ambas el campo a , lo que hace que a sea ambiguo.

Pasos de resolución: Califica tus referencias ( <Collection>.<field> en lugar de field ). En el ejemplo anterior, coll.a o coll2.a corregirían este error.

Descripción: El argumento * solo es válido en la función agregada 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: Úsalo solo * como argumento para COUNT.

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

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

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

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

Causas comunes: Usar una función escalar donde solo se puede usar una función de agregación. Por ejemplo, la query SELECT * FROM foo GROUP BY a AGGREGATE round(a) AS round genera 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 que no es de 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: Solo utilice agregaciones en los lugares donde estén permitidas. query 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 query SELECT * FROM foo GROUP BY a AGGREGATE min(a,b) AS min provoca este error porque proporciona dos argumentos para la agregación min.

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 de DISTINCT en una función escalar. Por ejemplo, la query SELECT ROUND(DISTINCT a,2) FROM foo provoca 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 múltiples fuentes de datos, cada una con campos del mismo nombre dentro de una subconsulta dada, causa este error. Por ejemplo, suponiendo que la colección bar y la colección foo tengan campos del mismo nombre, entonces la query SELECT * FROM (SELECT * FROM foo AS foo, bar AS bar) AS derived provoca este error.

Pasos de la resolución: Actualiza los nombres de campos comunes para que sean únicos en todas las fuentes de datos. Una forma sencilla de lograr esto es creando un alias con un nombre exclusivo para los campos que tienen el mismo nombre. Usando esta técnica, aquí está nuestra query 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: Añadir una condición JOIN (ejemplo, ON <condition> ). query de ejemplo corregida: SELECT * FROM foo AS foo LEFT OUTER JOIN bar ON a = a.

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

Causas comunes: múltiples colecciones tienen el mismo alias. Por ejemplo, la query SELECT * FROM foo AS alias, bar AS alias provoca este error.

Pasos de resolución: Asegúrate de que los alias sean únicos para las colecciones. query de ejemplo corregida: SELECT * from foo as foo_alias, bar as bar_alias.

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

Causas comunes: Seleccionar más de un campo (o columna en sql) en una expresión de subconsulta escalar. Por ejemplo, la query SELECT (SELECT * FROM foo LIMIT 1) FROM bar AS bar provoca este error, porque la subconsulta se está ejecutando SELECT * , por lo que está seleccionando varios campos.

Resolución de problemas: Modifica tu subconsulta de modo que solo selecciones un único campo. query 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: Cambia los alias duplicados de los campos por nombres únicos. query de ejemplo corregida: SELECT a as a_alias, b as b_alias FROM foo.

Descripción: Se ha definido la misma opción FLATTEN 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 información de esquema suficiente. Por ejemplo, suponiendo que tienes una colección llamada noSchemaInfo que no tiene un esquema definido, la query SELECT * FROM FLATTEN(noSchemaInfo) ocasiona este error. Otra causa común es intentar aplanar una colección con un esquema o algún campo en el esquema que tenga additional_properties establecido en true.

Pasos para la resolución: Especifique todos los campos en el esquema para asegurarse de que el esquema esté suficientemente definido. Además, intenta evitar configurar additional_properties en true. En su lugar, defina completamente el esquema.

Descripción: En el esquema, un campo es un tipo de objeto Realm polimórfico (es decir, se debe considerar un campo que puede ser un document o un int ), por lo que no puede "aplanarse". Se permite el polimorfismo de objetos null y missing. El aplanamiento sólo funciona en tipos de objetos (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 o missing ), entonces 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 de resolución: Sólo se pueden aplanar tipos de objetos. Si quieres que un campo tenga la posibilidad de ser aplanado, el esquema para ese campo DEBE ser un tipo de objeto Realm. La única excepción a esta regla son los objetos que pueden ser nulos o estar ausentes; aún puedes aplanar estos objetos a pesar de ser polimórfico. Para corregir este error, debes dejar de intentar aplanar colecciones que tienen campos con tipos de objetos polimórficos, o debes cambiar el esquema de esos campos a solo un tipo de objeto Realm.

Descripción: La misma opción de UNWIND está definida 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: UNWIND carece de la opción PATH como lo muestra la siguiente consulta SELECT * FROM UNWIND(foo).

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: Cambia la opción UNWIND PATH por un identificador. query de ejemplo corregida: SELECT * FROM UNWIND(foo WITH PATH => a).

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: Cuando se hace una conversión a un tipo para el que MongoSQL no admite conversiones. Por ejemplo, la query 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 sus alias de tipo SQL-92 correspondientes: REAL, FLOAT, VARCHAR, CHAR, CHARACTER, CHAR VARYING, CHARACTER VARYING, DEC, NUMERIC, BIT, BOOLEAN, TIMESTAMP, INTEGER y SMALLINT. Consulta de ejemploSELECT CAST(a AS BSON_DATE) FROM foo corregida:.

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

Causas frecuentes: Intentar usar ORDER BY en expresiones complejas o en rutas de campos «impuras». Por ejemplo, la query SELECT * FROM foo ORDER BY CAST(d AS DOCUMENT).a

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

Pasos de resolución: asegúrate de ordenar solo por la ruta del 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: Configurar el campo $sql de agregación excludeNamespaces en true y consultar varias colecciones con los mismos nombres de campo causa este error. Como esta opción remueve los namespaces de la colección, los campos con el mismo nombre que pertenecen a diferentes colecciones dejan de ser únicos. Por ejemplo, considera las colecciones foo y bar, cada una con un campo a , y una query como SELECT foo.*, bar.a FROM foo, bar. Con los espacios de nombres de la colección en el conjunto de resultados, los dos campos a pueden diferenciarse entre foo y bar ; sin embargo, sin los espacios de nombres de la colección, no pueden distinguirse entre sí.

Pasos para la resolución: La mejor forma de solucionar este error es usar alias para hacer que los campos conflictuantes sean únicos. query de ejemplo corregida: SELECT foo.*, bar.a AS a_unique_alias from foo, bar.