Erros do MongoSQL

Descrição: Uma função (por exemplo, Sin,Abs, Open) tem o número incorreto de argumentos.

Causas comuns: uma função tem um argumento extra ou não tem um. Por exemplo, em SELECT ROUND(a,1,5) FROM foo onde a é um int , ARRED tem um argumento extra.

Etapas de resolução: a mensagem de erro indica qual função tem o número errado de argumentos e quantos ela deve ter. Use estas informações para corrigir sua query. Query de exemplo corrigida: SELECT ROUND(a,1) FROM foo.

Descrição: A operação especificada (por exemplo, Sub, E, Substring) tem argumento(s) do tipo incorreto (por exemplo, string, int).

Causas comuns: um campo do tipo errado foi usado por engano na função especificada. Por exemplo, SELECT ROUND(str,5) FROM foo onde str é do tipo string causa esse erro.

Etapas de resolução: a mensagem de erro indica qual função tem um argumento do tipo errado e qual é o tipo esperado. Use estas informações para corrigir sua query. query de exemplo corrigida: SELECT ROUND(a,5) FROM foo onde a é um int.

Descrição: o argumento fornecido à agregação não é de um tipo comparável a si mesmo.

Causas comuns: a coluna na qual você está tentando agregar é do tipo object ou array , que não são comparáveis entre si.

Por exemplo, SELECT * FROM myCol GROUP BY a AGGREGATE MIN(obj) as min onde obj é um object causa esse erro.

Etapas de resolução: use somente as funções Agregação em colunas do tipo apropriado. Se você quiser Agregar em um valor dentro de um array ou object , use as palavras-chave do conjunto de dados Unwind ou Fluxo. query de exemplo corrigida: SELECT * FROM myCol GROUP BY a AGGREGATE MIN(a) as min onde a é um int.

Descrição: COUNT(DISTINCT *) não é suportado.

Causas comuns: qualquer uso do COUNT(DISTINCT *) ( SELECT COUNT(DISTINCT *) FROM foo ) não é suportado.

Etapas da resolução: remova qualquer uso de COUNT(DISTINCT *) da sua query.

Descrição: a operação de comparação especificada (por exemplo, Lte, Entre) não pôde ser executada devido aos tipos incomparáveis de seus operandos (ou seja, comparando um int com uma string).

Causas comuns: campos de dois tipos diferentes foram usados na operação de comparação especificada. Por exemplo, SELECT * FROM foo WHERE a <= b onde a é um int e b é um string. Além disso, observe que objects e arrays não são tipos comparáveis e não podem ser usados em operações de comparação.

Etapas de resolução: a mensagem de erro indica qual operação de comparação tem tipos conflitantes. Use estas informações para corrigir sua query. query de exemplo corrigida: SELECT * FROM foo WHERE a1 <= a2 onde a1 e a2 são ambos do tipo int.

Descrição: não é possível acessar um campo porque ele não pode ser encontrado (e provavelmente não existe).

Causas comuns: você está tentando acessar um campo que não existe, provavelmente devido a um erro de digitação. Por exemplo, SELECT foo.f FROM foo onde f é um campo inexistente causa esse erro.

Etapas de resolução: quando possível, a mensagem de erro sugere nomes de campo semelhantes que podem ter sido a entrada desejada. No entanto, se nada semelhante for encontrado, o MongoSQL não fornecerá sugestões de nomes de campos. Use estas informações para corrigir sua query. query de exemplo corrigida: SELECT foo.a FROM foo onde a existe como a campo de foo.

Descrição: a cardinalidade do conjunto de resultados de uma subquery escalar pode ser maior que 1. O conjunto de resultados DEVE ter uma cardinalidade de 0 ou 1.

Causas comuns: sua subquery escalar pode retornar mais de 1 documento (ou linha no SQL). Por exemplo, SELECT (SELECT a FROM foo) FROM bar causa esse erro porque (SELECT a FROM foo) pode retornar mais de 1 documento (ou linha).

Etapas de resolução: adicione um LIMIT 1 à sua subquery para garantir que somente 1 documento/linha seja retornado. Query de exemplo correta: SELECT (SELECT a FROM foo LIMIT 1) FROM bar.

Descrição: não é possível classificar pela chave especificada, pois ela é de um tipo que não pode ser comparado entre si.

Causas comuns: a coluna que você está tentando classificar é do tipo object ou array , que não são tipos comparáveis a si mesmos. Por exemplo, SELECT * FROM foo ORDER BY obj onde obj é um object gera este erro.

Etapas de resolução: classifique somente em colunas do tipo apropriado. Se você quiser classificar um valor dentro de um array ou object , use as palavras-chave do conjunto de dados UNIwind ou Fluvial. query de exemplo corrigida: SELECT * FROM foo ORDER BY a onde a é um int.

Descrição: não é possível agrupar pela chave especificada, pois ela é de um tipo que não pode ser comparado entre si.

Causas comuns: a coluna pela qual você está tentando agrupar é do tipo object ou array , que não são tipos comparáveis entre si. Por exemplo, SELECT * FROM foo GROUP BY obj onde obj é um object gera este erro.

Etapas de resolução: agrupe apenas por colunas do tipo apropriado. Se você quiser agrupar por um valor dentro de um array ou object , use as palavras-chave do conjunto de dados Unwind ou Fluvial. query de exemplo corrigida: SELECT * FROM foo ORDER BY a onde a é um int.

Descrição: o nome do INDEX UNILL está em conflito com o nome do campo existente.

Causas comuns: o nome do INDEX é igual a um nome de campo existente. Por exemplo, se a collection foo tiver um campo b , a query SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b) causará esse erro.

Etapas da resolução: Altere o nome do INDEX para algo que não seja um campo existente. query de exemplo corrigida: SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b2) onde b2 não é um nome de campo existente.

Descrição: Não foi possível encontrar a collection no reconhecimento de data center especificado.

Causas comuns: você pode estar procurando no reconhecimento de data center errado ou cometeu um erro de digitação que está fazendo com que a collection não seja encontrada. Por exemplo, se a collection baz não existir, a query SELECT * FROM baz causará esse erro.

Etapas de resolução: certifique-se de que tudo esteja escrito corretamente e que você esteja procurando no reconhecimento de data center correto. Query de exemplo corrigida: SELECT * FROM foo onde foo existe no reconhecimento de data center atual.

Descrição: JSON estendido detectado na operação de comparação. O MongoSQL não suporta comparações diretas com JSON estendido. Em vez disso, use a conversão (veja um exemplo em "Etapas de resolução").

Causas comuns: usar JSON estendido em query e esperar que ele seja convertido implicitamente no tipo de dados correto. Por exemplo, alguém pode gravar a query select _id from customers where _id = '{"$oid":"5ca4bbcea2dd94ee58162a6a"}' porque acha que a string JSON estendida é implicitamente convertida em um ObjectID. No entanto, este não é o caso.

Etapas da resolução: não use o formato JSON estendido e sempre CAST explicitamente. A mensagem de erro tenta sugerir o que você deve fazer (transmissão). query de exemplo corrigida: select _id from customers where _id = CAST('5ca4bbcea2dd94ee58162a6a' as ObjectID). Esta query é convertida explicitamente para um ObjectID.

Descrição: um campo tem um tipo de BSON não suportado.

Causas comuns: um campo tem um tipo de BSON que não é suportado pelo MongoSQL. Por exemplo, se a collection foo tiver um campo b do tipo undefined , a query SELECT * FROM foo causará esse erro.

Etapas de resolução: altere o tipo de BSON para algo compatível com o MongoSQL. A mensagem de erro sugere quais BSON types são suportados. Query de exemplo corrigida: SELECT * FROM foo onde foo existe no banco de dados atual e b não é do tipo undefined.

Descrição: um campo do tipo Binary data tem o subtipo não suportado de uuid old.

Causas comuns: historicamente, drivers diferentes escreveram Uuids usando ordens de bytes diferentes. Isso pode ocorrer com dados mais antigos escritos por um driver usando o tipo uuid agora não suportado.

Etapas de resolução: A query desses dados não é suportada pelo Atlas SQL.

Descrição: este erro é um pega-tudo para cada erro do analisador, exceto token não reconhecido.

Causas comuns: esse erro pode média muitas coisas diferentes, pois é um erro catchall. No entanto, geralmente significa que algum token (palavra-chave) foi usado incorretamente.

Etapas de resolução: esse erro pode gerar várias mensagens diferentes, portanto, é importante pagar atenção a essas mensagens. Além disso, é uma boa ideia examinar a query de entrada para garantir que cada cláusula (bem como a declaração SQL como um todo) seja escrita conforme especificado pelas diretrizes.

Descrição: um token inesperado ou não reconhecido foi encontrado.

Causas comuns: algo pode ter sido escrito errado ou colocado na ordem/formato errado. Por exemplo, SELECT ** FROM foo AS f causa este erro devido ao tipo ** .

Etapas da resolução: certifique-se de que tudo esteja escrito corretamente e colocado na ordem/formato correto. Além disso, esse erro sugere uma lista de tokens que você pode ter média colocar. Query de exemplo corrigida: SELECT * FROM foo AS f.

Descrição: uma lista SELECT com vários valores não pode conter um * sem namespace (ou seja, SELECT a, *, b FROM myTable não é suportado). Um * sem namespace deve ser usado sozinho.

Causas comuns: selecionar * e qualquer outra coisa na mesma query que o mostrado por esta query: SELECT *, a from foo.

Etapas de resolução: selecione apenas * (ou seja, SELECT * FROM ... ) ou selecione múltiplos valores e não inclua * (ou seja, SELECT a, b FROM ... ).

Descrição: O conjunto de dados do array contém referências. O conjunto de dados da array deve ser constante.

Causas comuns: acessar um campo em um conjunto de dados de array, conforme mostrado por esta query: SELECT * FROM [{'a': foo.a}] AS arr.

Etapas da resolução: modifique o conjunto de dados da array para conter apenas constantes. Query de exemplo corrigida: SELECT * FROM [{'a': 34}] AS arr.

Descrição: SELECT DISTINCT não é permitido.

Causas comuns: SELECT DISTINCT foi usado em uma query. Por exemplo, a query SELECT DISTINCT * from foo causa este erro.

Etapas de resolução: não use SELECT DISTINCT em uma query.

Descrição: UNION distinto não é permitido. Você só pode fazer UNION ALL (ou seja, valores duplicados sempre devem ser permitidos).

Causas comuns: uso de UNION em vez de UNION ALL. Por exemplo, a query SELECT a FROM foo AS foo UNION SELECT b, c FROM bar AS bar causa esse erro.

Etapas de resolução: use UNION ALL somente ao fazer uniões. Query de exemplo corrigida: SELECT a FROM foo AS foo UNION ALL SELECT b, c FROM bar AS bar.

Descrição: não foi possível encontrar um conjunto de dados referenciado na lista SELECT.

Causas comuns: fazer algo como SELECT <field>.* FROM ... onde <field> não tem nenhum subcampo. Por exemplo, a query SELECT a.* FROM foo em que a é um int causa esse erro.

Etapas da resolução: remova todos os acessos de campo que estejam tentando acessar um campo que não existe.

Descrição: Não foi possível encontrar um campo em nenhuma fonte de dados.

Causas comuns: o campo está escrito incorretamente ou não existe, ou você está procurando na collection errada. Por exemplo, Select aa from foo causaria esse erro se aa não existir na collection foo.

Etapas de resolução: verifique se o campo está escrito corretamente e se você está procurando na collection correta. Além disso, a mensagem de erro sugere campo semelhantes que você pode média escrever.

Descrição: existe um campo em vários conjuntos de dados e é ambíguo.

Causas comuns: dois ou mais campo têm o mesmo nome em uma collection (ou algum outro conjunto de dados). Por exemplo, supondo que a seja um campo em foo , SELECT a FROM foo AS coll JOIN foo AS coll2 causaria esse erro porque as collection coll e coll2 têm o campo a , fazendo com que a seja ambíguo.

Etapas da resolução: qualifique suas referências ( <Collection>.<field> em vez de field ). No exemplo acima, coll.a ou coll2.a corrigiriam esse erro.

Descrição: O argumento * só é válido na função agregada COUNT.

Causas comuns: a contagem é a única operação de agregação que suporta o argumento * , ou seja, COUNT(*). Passar o argumento * para qualquer outra operação, como SUM(*) , causa esse erro. Por exemplo, a query SELECT * FROM foo AS arr GROUP BY a AS a AGGREGATE SUM(*) AS gsum.

Etapas de resolução: use apenas * como argumento para COUNT.

Descrição: uma função de agregação foi usada em uma posição escalar.

Causas comuns: usar uma função de agregação onde somente uma função escalar pode ser usada. Por exemplo, a query SELECT VALUE {'suma': SUM(a)} FROM db.bar AS bar GROUP BY a AS a causa esse erro porque SUM(a) é uma função de agregação.

Etapas de resolução: remova funções de agregação em locais onde você só pode ter funções escalares.

Descrição: uma função escalar foi usada em uma posição de agregação.

Causas comuns: usar uma função escalar onde somente uma função de agregação pode ser usada. Por exemplo, a query SELECT * FROM foo GROUP BY a AGGREGATE round(a) AS round causa esse erro porque round é uma função escalar.

Etapas de resolução: remova funções escalares em locais onde você só pode ter funções de agregação.

Descrição: uma expressão não de agregação foi encontrada em uma lista de funções de agregação GROUP BY.

Causas comuns: colocar algo diferente de uma agregação ou função escalar onde uma agregação deveria estar. (Usar uma função escalar no lugar de uma agregação causa um erro diferente: Erro 3012). Por exemplo, a query SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) + 7 AS whatever causa esse erro, porque há uma operação de adição junto com uma agregação em vez de apenas uma agregação.

Etapas de resolução: use agregações apenas em locais onde as agregações são permitidas. Query de exemplo corrigida: SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) AS whatever.

Descrição: as funções de agregação devem ter exatamente um argumento.

Causas comuns: uma função de agregação tem mais de um argumento. Por exemplo, a query SELECT * FROM foo GROUP BY a AGGREGATE min(a,b) AS min causa esse erro porque fornece dois argumentos para a agregação min .

Etapas de resolução: certifique-se de que suas agregações tenham apenas um argumento. Remova quaisquer argumentos adicionais. Query de exemplo corrigida: SELECT * FROM foo GROUP BY a AGGREGATE min(b) AS min.

Descrição: as funções escalares não suportam DISTINCT.

Causas comuns: usar DISTINCT em uma função escalar. Por exemplo, a query SELECT ROUND(DISTINCT a,2) FROM foo causa esse erro.

Etapas de resolução: não use DISTINCT em funções escalares. DISTINCT só deve ser usado em funções de agregação. Query de exemplo corrigida: SELECT ROUND(a,2) FROM foo.

Descrição: um conjunto de dados derivado tem campo sobrepostos.

Causas comuns: a inclusão de vários conjunto de dados cada uma com campo com o mesmo nome em uma determinada subquery causa esse erro. Por exemplo, supondo que a coleta bar e a coleta foo tenham campos com o mesmo nome, a consulta SELECT * FROM (SELECT * FROM foo AS foo, bar AS bar) AS derived causará esse erro.

Etapas da resolução: atualize os nomes de campos para torná-los exclusivos entre os conjuntos de dados. Uma maneira simples de fazer isso é criando um nome alternativo para os campos com o mesmo nome. Usando esta técnica, aqui está nossa query de exemplo corrigida: 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.

Descrição: umOuter join não tem uma condição de join. Outer joins devem especificar uma condição de join.

Causas comuns: um outer join não tem uma condição de join. Por exemplo, a query SELECT * FROM foo AS foo LEFT OUTER JOIN bar causa esse erro porque não tem a parte ON <condition> necessária da query.

Etapas da resolução: adicione uma condição de junção (ou seja, ON <condition> ). Query de exemplo corrigida: SELECT * FROM foo AS foo LEFT OUTER JOIN bar ON a = a.

Descrição: não foi possível criar um ambiente de esquema devido a um campo duplicado.

Causas comuns: várias collection têm o mesmo alias. Por exemplo, a query SELECT * FROM foo AS alias, bar AS alias causa este erro.

Etapas de resolução: certifique-se de que os aliases sejam exclusivos para a collection. Query de exemplo corrigida: SELECT * from foo as foo_alias, bar as bar_alias.

Descrição: as expressões da subquery escalar devem ter um grau de 1.

Causas comuns: seleção de mais de um campo (ou coluna no SQL) em uma expressão de subquery escalar. Por exemplo, a query SELECT (SELECT * FROM foo LIMIT 1) FROM bar AS bar causa esse erro, porque a subquery está executando SELECT * , portanto, está selecionando vários campos.

Etapas de resolução: modifique sua subquery para selecionar apenas um único campo. Query de exemplo corrigida: SELECT (SELECT a FROM foo LIMIT 1) FROM bar AS bar

Descrição: um documento tem vários campos com o mesmo nome.

Causas comuns: selecionar vários campo de uma collection e atribuir a eles os mesmos aliases, conforme mostrado pela seguinte query: SELECT a AS alias, b AS alias FROM foo.

Etapas da resolução: alterar os aliases duplicados dos campos para nomes únicos. Query de exemplo corrigida: SELECT a as a_alias, b as b_alias FROM foo.

Descrição: A mesma opção Fluxo é definida mais de uma vez.

Causas comuns: a mesma opção é definida mais de uma vez, conforme mostrado pela seguinte query: SELECT * FROM FLATTEN(foo WITH depth => 1, depth => 2).

Etapas da resolução: remova todas as opções duplicadas para garantir que cada opção seja usada apenas uma vez. query de exemplo corrigida: SELECT * FROM FLATTEN(foo WITH depth => 1).

Descrição: as informações do esquema são insuficientes para permitir o nivelamento da fonte de dados.

Causas comuns: Tentar nivelar uma collection que não tem informações de esquema suficientes. Por exemplo, supondo que você tenha uma coleção chamada noSchemaInfo que não tem esquema definido, a query SELECT * FROM FLATTEN(noSchemaInfo) causará esse erro. Outra causa comum é tentar nivelar uma collection com um esquema ou algum campo no esquema que tenha additional_properties definido como true.

Etapas de resolução: defina todos os campos no esquema para garantir que o esquema esteja suficientemente definido. Além disso, tente evitar definir additional_properties como true. Em vez disso, defina completamente o esquema.

Descrição: Um campo dentro do esquema é um tipo de objeto polimórfico (ou seja, considere um campo que pode ser document ou int ), portanto, não pode ser achatado. null e missing polimorfismo de objeto é permitido. O nivelamento só funciona com tipos de objeto ( documento AKA ), portanto, se houver a possibilidade de que algum campo não seja um documento (a menos que as únicas outras possibilidades sejam null ou missing ), ele não poderá ser achatado.

Causas comuns: Tentar nivelar uma collection que tem um esquema contendo um campo que é um Tipo de objeto de Realm. Por exemplo, supondo que uma coleção chamada coll tenha um campo que é um tipo de objeto polimórfico, a query SELECT * FROM FLATTEN(coll) causa esse erro.

Etapas de resolução: só é possível nivelar tipos de objeto. Se você quiser que um campo tenha a possibilidade de ser achatado, o esquema desse campo DEVE ser um tipo de objeto. A única exceção a esta regra são objetos que podem ser nulos ou ausentes; você ainda pode achatar esses objetos, apesar de ser polimórfico. Para corrigir esse erro, você deve parar de tentar nivelar coleções que tenham campos com tipos de objeto polimórficos ou deve alterar o esquema para que esses campos sejam apenas um tipo de objeto.

Descrição: A mesma opção Unwind é definida mais de uma vez.

Causas comuns: a mesma opção é usada mais de uma vez, conforme mostrado pela seguinte query: SELECT * FROM UNWIND(foo WITH PATH => a, PATH => b).

Etapas da resolução: remova todas as opções duplicadas para garantir que cada opção seja usada apenas uma vez. query de exemplo corrigida: SELECT * FROM UNWIND(foo WITH PATH => a).

Descrição: O Unwind não tem a opção PATH. O Unwind deve especificar uma opção PATH.

Causas comuns: o Unwind não tem a opção PATH, conforme mostrado pela seguinte query SELECT * FROM UNWIND(foo).

Etapas da resolução: adicione a opção PATH ao unwind. query de exemplo corrigida: SELECT * FROM UNWIND(foo WITH PATH => a).

Descrição: A opção UnwindPath não é um identificador; no entanto, deve ser um.

Causas comuns: a opção UnwindPath não é um identificador, como mostrado pela seguinte query SELECT * FROM UNWIND(foo WITH PATH => {'a': []}.a).

Etapas da resolução: Altere a opção Unwind PATH para um identificador. query de exemplo corrigida: SELECT * FROM UNWIND(foo WITH PATH => a).

Descrição: o tipo de destino do CAST é um tipo inválido (ou seja, é um tipo desconhecido ou um tipo para o qual o MongoSQL não suporta conversão).

Causas comuns: conversão para um tipo para o qual o MongoSQL não é compatível com a conversão. Por exemplo, a query SELECT CAST(a AS DATE) FROM foo

causa esse erro porque DATE não é um tipo de destino suportado.

Etapas da resolução: transmita apenas para tipos de destino compatíveis. Os tipos de destino válidos são Array, documento, Double, String, ObjectId, bool, BSON, INT, Long e DECIMAL, ou qualquer um de seus aliases do tipo SQL correspondentes: Real, FLOAT, VARCHAR, CHARACTER, CHAR VRYING, CHARACTER VARYING, DEC, NUMERIC, BIT, boolean, carimbos de data/hora, inteiro, SMILLINT. Query de exemplo corrigida: SELECT CAST(a AS BSON_DATE) FROM foo.

Descrição: uma chave de classificação é inválida porque utiliza expressões complexas (ou seja, ORDER BY {'a': b}.a é inválida).

Causas comuns: tentativa de ORDER BY expressão complexas ou caminho do campo "impuros". Por exemplo, a query SELECT * FROM foo ORDER BY CAST(d AS DOCUMENT).a

causa este erro, pois CAST(d AS DOCUMENT) é uma expressão complexa.

Etapas da resolução: Certifique-se de classificar apenas pelo caminho do campo "pura". Um caminho do campo "pura" consiste apenas em

identificadores, como foo.d.a ou a.

Descrição: o conjunto de resultados sem namespace não pode ser retornado devido a conflitos de nome de campo.

Causas comuns: definir o $sql excludeNamespaces campo de agregação como true e consultar várias collection com os mesmos nomes de campo causa esse erro. Como essa opção remove o namespace da collection, o campo com o mesmo nome que pertence a different collection não é mais exclusivo. Por exemplo, considere as collection foo e bar cada uma com um campo a e uma query como SELECT foo.*, bar.a FROM foo, bar. Com namespace de collection no conjunto de resultados, os dois campo a podem ser diferenciados entre foo e bar ; no entanto, sem namespace de collection, eles não podem ser distinguidos um do outro.

Etapas de resolução: a melhor maneira de corrigir esse erro é usar nomes alternativos para tornar os campos conflitantes exclusivos. Query de exemplo corrigida: SELECT foo.*, bar.a AS a_unique_alias from foo, bar.