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 de nível superior ou subcampos. Se você agrupar por subcampos, eles devem ser apelidados 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 query podem ser executadas para usar 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ê ACHATE seus dados, os antigos subcampos devem ser apelidados. Por exemplo, em uma coleção Orders, você tem documentos com a seguinte estrutura:

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

Após o achatamento, a estrutura torna-se {"customer_address_city": <String>} e você pode executar as seguintes query 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 um array e retorna o array transformado. MAP utiliza os seguintes argumentos:

• Expressão de array

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

Para se referir ao elemento que MAP processa, o segundo argumento deve usar a variável "this". Se o array estiver vazio, MAP retornará um array vazio.

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

• O primeiro argumento deve ter estaticamente o tipo ARRAY ou NULL e pode ser avaliado como MISSING. Se o primeiro argumento for NULL ou MISSING, MAP retornará NULL. O tipo dos elementos do 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 no array que MAP retorna.

A query a seguir multiplica cada elemento do array por 2:

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

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

Filtro

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

• Expressão de array

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

Para se referir ao elemento que FILTER processa, o segundo argumento deve usar a variável "this". Se o array estiver vazio, FILTER retornará um array vazio.

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

• O primeiro argumento deve ter estaticamente o tipo ARRAY ou NULL e pode ser avaliado como MISSING. Se o primeiro argumento for NULL ou MISSING, FILTER retornará NULL. O tipo dos elementos do 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 query a seguir retém apenas os elementos de valor ímpar do array:

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

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

reduzir

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

• Expressão de array

• Expressão de valor inicial

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

O resultado acumulado começa como o valor inicial. Para se referir ao elemento que REDUCE processa, o terceiro argumento deve usar a variável "this". Para se referir ao valor acumulado, o terceiro argumento deve usar a variável "value". Se o array estiver vazio, 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. Este pode ser qualquer tipo de MongoSQL, incluindo NULL. Os seguintes requisitos se aplicam aos argumentos:

• O primeiro argumento deve ter estaticamente o tipo ARRAY ou NULL e pode ser avaliado como MISSING. Se o primeiro argumento for NULL ou MISSING, REDUCE retornará NULL. O tipo dos elementos do 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 igual a, um superconjunto de 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 query a seguir soma os elementos do array, começando com 0:

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

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

Argumentos de função nomeados

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

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

Funções de array adicionais

O MongoSQL oferece suporte às seguintes funções de array, que são aliases sintáticos para usos comuns de MAP, FILTER e REDUCE: