Referência da linguagem MongoSQL

Tipos de dados

Os tipos de dados MongoSQL são o conjunto de tipos BSON. Todos esses tipos podem ser consultados no MongoSQL. São eles:

• string (STRING)

• Documento (DOCUMENT)

• Array (ARRAY)

• BinData (BINDATA)

• ObjectId (OBJECTID)

• Booleano (BOOL)

• Data (TIMESTAMP)

• Nulo (NULL)

• Regex (REGEX)

• Inteiro de INT bits ()

• Duplo (DOUBLE)

• Longo (LONG)

• Carimbo de data/hora (BSON_TIMESTAMP)

• Decimais (DECIMAL)

• MinKey (MINKEY)

• MaxKey (MAXKEY)

• DBPointer (DBPOINTER)

• Símbolo (SYMBOL)

• JavaScript com escopo (JAVASCRIPTWITHSCOPE)

• JavaScript (JAVASCRIPT)

Cada tipo no MongoSQL tem um nome (entre parênteses acima), que é uma palavra-chave que pode ser usada para fazer referência ao tipo quando necessário, como em uma expressão como CAST.

Conversões de tipo

As conversões de tipo explícitas são expressas por meio da função CAST ou do operador :: . Todos os tipos numéricos são mutuamente comparáveis; O MongoSQL permite operações entre os vários tipos numéricos sem converter os operandos para serem do mesmo tipo numérico.

Schemas

O MongoSQL converte os valores de documento flexíveis do MongoDB em tipos usando um esquema. Um esquema MongoSQL schema é uma coleção de dados sobre uma expressão ou coleção que são conhecidos como verdadeiros no momento da compilação.

Por exemplo, um esquema MongoSQL pode ditar que uma expressão é booleana ou um documento com subcampos, ou que uma expressão é uma array com comprimento de um ou um número inteiro positivo.

Se uma restrição de tipo estático não for satisfeita, a query não será compilada.

O gerenciamento de esquemas difere entre a ferramenta manual On-Premise e a ferramenta automatizada Atlas .

SELECT

SELECT inicia cada query do Atlas SQL . O MongoSQL permite que SELECT VALUE e SELECT VALUES sejam utilizados de forma intercambiável.

O MongoSQL exige que as declarações SELECT aninhadas tenham um alias.

SELECT foo FROM (SELECT bar FROM baz) as subSelect

SELECIONAR DISTINTO

Use SELECT DISTINCT para excluir linhas duplicadas do conjunto de resultados. A verificação duplicada segue a semântica de igualdade do MongoDB , em que a ordem dos campo é importante para a comparação de documento e a ordem e o valor dos elementos são importantes para a comparação de arrays.

SELECT DISTINCT bar FROM baz

SELECT * FROM table WHERE period_start_utc >= CAST('2023-01-01T00:00:00.000Z' AS TIMESTAMP)

de

FROM é a primeira cláusula avaliada em cada query MongoSQL.

FROM pode extrair dados de várias fontes, incluindo coleções (SELECT * FROM foo), arrays (SELECT * FROM [{'a': 1}]), junções (SELECT * FROM a JOIN b), tabelas derivadas (SELECT * FROM (SELECT a FROM foo) d) e FLATTEN e UNwind.

WHERE

A cláusula WHERE é um filtro para os dados recebidos. Sua expressão deve estaticamente ter tipo BOOL ou NULL e pode avaliar para MISSING.

AGRUPAR POR

GROUP BY fornece um meio para agrupar e agregar dados.

GROUP BY as chaves podem ser campos ou subcampos de nível superior. Se você agrupar por subcampos, eles deverão usar nomes alternativos na cláusula SELECT ou GROUP BY. Por exemplo, em uma coleção Sales, você tem documentos com a seguinte estrutura:

{"customer": {"age": <Integer>}}

Neste exemplo, as seguintes queries podem ser executadas para utilizar o subcampo age como uma chave de grupo:

"SELECT customerAge FROM Sales GROUP BY customer.age AS customerAge"
"SELECT customer.age as customerAge FROM Sales GROUP BY customerAge"

Mesmo que você PLATAFORMA seus dados, os subcampos anteriores devem ter nomes alternativos. Por exemplo, em uma coleção Orders, você tem documentos com a seguinte estrutura:

{"customer": {"address": {"city": <String>}}}

Após o nivelamento, a estrutura se torna {"customer_address_city": <String>} e você pode executar as seguintes queries para usar o subcampo city como uma chave de grupo:

"SELECT city FROM FLATTEN(orders) GROUP BY customer_address_city AS city"
"SELECT customer_address_city AS city FROM FLATTEN(orders) GROUP BY city"

HAVING

A cláusula HAVING opera da mesma forma que uma cláusula WHERE , mas após a cláusula GROUP BY . Como a cláusula WHERE , a cláusula HAVING usa uma expressão que deve ter estaticamente o tipo BOOL ou NULL e pode ser avaliada como MISSING. Ela pode fazer referência a aliases definidos no GROUP BY e pode conter expressões com funções de aggregation. Somente os aliases definidos na GROUP BY estão disponíveis para a cláusula HAVING .

ORDENAR POR

A cláusula ORDER BY fornece uma maneira de ordenar um conjunto de resultados por uma ou mais chaves de classificação. Cada chave de classificação pode ser uma referência de coluna ou um literal inteiro referente a uma expressão SELECT por sua posição na lista de expressão selecionadas. As chaves de classificação que são referências de coluna podem ser identificadores compostos. Esses identificadores compostos podem ser qualificados com nomes de fontes de dados ou referir-se a subcampos de documento .

O MongoSQL classifica MISSING antes de NULL e NULL antes de todos os outros valores. A cláusula ORDER BY exige que todos os valores possíveis em uma expressão de chave de classificação possam ser estaticamente verificados como comparáveis por meio dos operadores > (maior que) e < (menor que).

LIMIT e offset

As cláusulas LIMIT e OFFSET permitem aos usuários recuperar apenas algumas das linhas retornadas por uma query. Se um número LIMIT for fornecido, não mais do que esse número de linhas será retornado. Se um número OFFSET for fornecido, esse número de linhas será ignorado antes de retornar as linhas.

Os números LIMIT e OFFSET devem ser inteiros positivos. Utilizar LIMIT ou OFFSET sem ORDER BY não garante o mesmo resultado.

Quando LIMIT e OFFSET estiverem definidos, as linhas OFFSET serão ignoradas antes de retornar o restante dos resultados, que não devem conter mais do que o número de linhas LIMIT .

LIMIT i, j é uma forma mais curta de LIMIT i OFFSET j.

LIMIT e OFFSET pode ser utilizado em subqueries.

Identificadores

Identificadores no MongoSQL referem-se a bancos de dados, tabelas e colunas. Os identificadores MongoSQL suportam todos os caracteres UTF-8, exceto o caractere nulo \x00.

No MongoSQL, alguns identificadores são restritos para evitar conflitos com caracteres que têm outro significado semântica; para que um identificador inclua tal caractere, ele deve ser delimitado, ou seja, entre aspas duplas ou backtiques. Por exemplo, um identificador deve ser delimitado se começar com um dígito ou se entrar em conflito com uma palavra-chave reservada (por exemplo "10cent"). Os identificadores diferenciam maiúsculas de minúsculas, delimitados ou não.

Aliases

Identificadores são usados para todos os aliases no MongoSQL. Na maioria dos casos, o MongoSQL retorna um erro se um alias for usado mais de uma vez na mesma cláusula. A exceção a isso é que os aliases podem ser repetidos em ambos os lados de um UNION ALL. Isso também se aplica a aliases gerados automaticamente.

Palavras-chave

As palavras-chave MongoSQL (como SELECT, FROM, JOIN etc.) não podem ser usadas como identificadores não delimitados.

Literais

O MongoSQL suporta literais para booleanos, nulos, números e strings. As strings estão entre aspas simples. Para incluir um caractere de aspas simples em uma string literal, dobre-o ('o''clock').

Os inteiros literais são digitados como INT quando estão dentro do intervalo de inteiros com sinal 32bits e LONG caso contrário. Números de ponto flutuante literais ou números de notação científica têm tipo DOUBLE.

Expressões entre parênteses

Uma expressão entre parênteses é uma expressão agrupada por parênteses. Sempre que os operadores infixos estiverem presentes, a necessidade de parênteses (ou de um mecanismo semelhante) para distinguir a ordem das operações pode ser necessária. O MongoSQL tem vários operadores infixos, como + e ::. Por exemplo, o valor de 1 + 2 * 3 é 7, enquanto o valor de (1 + 2) * 3 é 9.

Operadores

O MongoSQL é compatível com os seguintes operadores básicos:

• +

• -

• *

• /

• ||

• <

• <=

• !=

• ==

• >

• >=

• BETWEEN

• AND

• OR

• NOT

Expressões de Subquery

Uma subquery é uma query SQL dentro de uma query. Você pode usar uma subquery em qualquer lugar que uma expressão possa ser usada.

O MongoSQL suporta subquery escalar e subquery de tabela. Uma subquery escalar retorna um conjunto de resultados com zero ou uma linha e uma coluna. Pode ser usado na maioria dos locais em que um valor literal ou de coluna única é válido. Uma subquery de tabela retorna zero ou mais linhas e uma ou mais colunas.

Expressões de acesso a documentos e campos

Documentos podem ser representados com uma sintaxe semelhante à dos objetos JSON. As chaves devem ser strings e os valores podem ter qualquer um dos tipos suportados. Para acessar campos de documento , o MongoSQL oferece duas opções: notação de "ponto" e notação de "colchete".

A notação de ponto é semelhante ao acesso de campo na agregação MongoDB. Por exemplo, se um documento doc contiver um campo f, a expressão doc.f será usada para acessar o valor desse campo. A notação de colchetes usa colchetes ([ e ]) em torno de um nome de campo para acessar o campo com esse nome. Por exemplo, considere o mesmo documento descrito antes: doc["f"] é usado para acessar o valor desse campo.

Nulo e Ausente

BSON distingue entre NULL e MISSING. No caso de NULL há um campo com o valor literal NULL, enquanto no caso de MISSING, o campo não existe.

Map

MAP(array, function) aplica uma função a cada elemento em uma array e retorna a array transformada. MAP recebe os seguintes argumentos:

• expressão de array

• Expressão que especifica como transformar cada elemento da array

Para fazer referência ao elemento que MAP processa, o segundo argumento deve usar a variável "this". Se a array estiver vazia, MAP retornará uma array vazia.

MAP pode retornar um ARRAY ou NULL. Os seguintes requisitos se aplicam aos argumentos:

• O primeiro argumento deve estaticamente ter o tipo ARRAY ou NULL e pode avaliar como MISSING. Se o primeiro argumento for NULL ou MISSING, MAP retornará NULL. O tipo dos elementos de array deve satisfazer os usos de "this" no segundo argumento.

• O segundo argumento pode ser qualquer expressão que seja estaticamente semanticamente válida. O tipo que o segundo argumento retorna é o tipo dos elementos na array que MAP retorna.

A seguinte query multiplica cada elemento da array por 2:

SELECT MAP([1, 2, 3], "this" * 2) AS doubled_values

{ '': { 'doubled_values': [2, 4, 6] } }

Filtrar

FILTER(array, function) aplica uma condição a cada elemento em uma array e retorna uma array que contém apenas os elementos para os quais a condição avalia para true, em sua ordem original. FILTER recebe os seguintes argumentos:

• expressão de array

• Expressão que especifica a condição a ser testada em cada elemento da array

Para fazer referência ao elemento que FILTER processa, o segundo argumento deve usar a variável "this". Se a array estiver vazia, FILTER retornará uma array vazia.

FILTER pode retornar um ARRAY ou NULL. Como FILTER não transforma elementos, os elementos na array que FILTER retorna têm o mesmo tipo que os elementos na array de entrada. Os seguintes requisitos se aplicam aos argumentos:

• O primeiro argumento deve estaticamente ter o tipo ARRAY ou NULL e pode avaliar como MISSING. Se o primeiro argumento for NULL ou MISSING, FILTER retornará NULL. O tipo dos elementos de array deve satisfazer os usos de "this" no segundo argumento.

• O segundo argumento pode ser qualquer expressão que seja estaticamente semanticamente válida e que retorne BOOL ou NULL.

A seguinte query retém apenas os elementos com valor ímpar da array:

SELECT FILTER([1, 2, 3], MOD("this", 2) = 1) AS odd_values

{ '': { 'odd_values': [1, 3] } }

reduzir

REDUCE(array, initialValue, function) aplica uma função a cada elemento em uma array e combina os elementos em um único valor, começando com um valor inicial. REDUCE recebe os seguintes argumentos:

• expressão de array

• expressão de valor inicial

• Expressão que especifica como combinar cada elemento da array com o resultado acumulado dos elementos anteriores

O resultado acumulado começa como o valor inicial. Para fazer referência ao elemento que REDUCE processa, o terceiro argumento deve usar a variável "this". Para fazer referência ao valor acumulado, o terceiro argumento deve usar a variável "value". Se a array estiver vazia, REDUCE retornará o valor inicial.

REDUCE retorna um valor do mesmo tipo que o terceiro argumento retorna, um valor do tipo do valor inicial ou ambos. Pode ser qualquer tipo MongoSQL, incluindo NULL. Os seguintes requisitos se aplicam aos argumentos:

• O primeiro argumento deve estaticamente ter o tipo ARRAY ou NULL e pode avaliar como MISSING. Se o primeiro argumento for NULL ou MISSING, REDUCE retornará NULL. O tipo dos elementos da array deve satisfazer os usos de "this" no terceiro argumento.

• O segundo argumento deve satisfazer os usos de "value" no terceiro argumento.

• O terceiro argumento pode ser qualquer expressão que seja estaticamente semanticamente válida e que satisfaça seus próprios usos de "value". O tipo que o terceiro argumento retorna deve ser o mesmo, um superconjunto ou um subconjunto do segundo argumento. Os dois tipos podem diferir se o MongoSQL não detectar conflitos de esquema entre os usos de "value" no terceiro argumento e o tipo do segundo argumento.

A seguinte query adiciona os elementos da array juntos, começando com 0:

SELECT REDUCE([1, 2, 3], 0, "value" + "this") AS summed_value

{ '': { 'summed_value': 6 } }

Argumentos de Função Nomeada

Em vez de uma expressão, você pode passar uma função nomeada como argumento final para MAP, FILTER e REDUCE. Funções nomeadas são abreviaturas para expressões que usam uma única função ou operador interno. Por exemplo, em vez de MAP("array", LOWER("this")), você pode escrever MAP("array", LOWER). Em vez de REDUCE("array", 0, "value" + "this"), você pode escrever REDUCE("array", 0, +).

Você pode usar um argumento de função nomeada com qualquer operador unário ou binário e com qualquer função escalar que aceite um ou dois argumentos.

Funções adicionais de array

O MongoSQL permite as seguintes funções de array, que são apelidos sintáticos para usos comuns de MAP, FILTER e REDUCE: