Azure Cosmos DB para MongoDB (versão 3.2): recursos e sintaxe suportados
APLICA-SE A: MongoDB
A Base de Dados Cosmos do Azure é um serviço de bases de dados com vários modelos da Microsoft distribuído globalmente. Você pode se comunicar com o Azure Cosmos DB para MongoDB usando qualquer um dos drivers de cliente MongoDB de código aberto. O Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes aderindo ao protocolo de fio MongoDB.
Usando o Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do MongoDB com os quais está acostumado, com todos os recursos corporativos que o Azure Cosmos DB oferece: distribuição global, fragmentação automática, garantias de disponibilidade e latência, indexação automática de todos os campos, criptografia em repouso, backups e muito mais.
Nota
A versão 3.2 do Azure Cosmos DB para MongoDB não tem planos atuais para o fim da vida útil (EOL). O pré-aviso mínimo para um futuro EOL é de três anos.
Suporte a protocolos
Todas as novas contas do Azure Cosmos DB para MongoDB são compatíveis com o servidor MongoDB versão 3.6. Este artigo aborda a versão 3.2 do MongoDB. Os operadores suportados e quaisquer limitações ou exceções são listadas abaixo. Qualquer driver de cliente que compreenda esses protocolos deve ser capaz de se conectar ao Azure Cosmos DB para MongoDB.
O Azure Cosmos DB para MongoDB também oferece uma experiência de atualização perfeita para contas qualificadas. Saiba mais no guia de atualização da versão do MongoDB.
Suporte à linguagem de consulta
O Azure Cosmos DB para MongoDB fornece suporte abrangente para construções de linguagem de consulta MongoDB. Abaixo você pode encontrar a lista detalhada de operações, operadores, estágios, comandos e opções atualmente suportados.
Comandos da base de dados
O Azure Cosmos DB para MongoDB suporta os seguintes comandos de banco de dados:
Nota
Este artigo lista apenas os comandos de servidor suportados e exclui as funções de wrapper do lado do cliente. Funções de wrapper do lado do cliente, como deleteMany()
e updateMany()
utilizam internamente os delete()
comandos e update()
servidor. As funções que utilizam comandos de servidor suportados são compatíveis com o Azure Cosmos DB para MongoDB.
Comandos de operação de consulta e de escrita
delete
find
findAndModify
getLastError
getMore
insert
update
Comandos de autenticação
logout
authenticate
getnonce
Comandos de administração
dropDatabase
listCollections
drop
create
filemd5
createIndexes
listIndexes
dropIndexes
connectionStatus
reIndex
Comandos de diagnóstico
buildInfo
collStats
dbStats
hostInfo
listDatabases
whatsmyuri
Pipeline de agregação
Comandos de agregação
aggregate
count
distinct
Fases de agregação
$project
$match
$limit
$skip
$unwind
$group
$sample
$sort
$lookup
$out
$count
$addFields
Expressões de agregação
Expressões booleanas
$and
$or
$not
Expressões de definição
$setEquals
$setIntersection
$setUnion
$setDifference
$setIsSubset
$anyElementTrue
$allElementsTrue
Expressões de comparação
$cmp
$eq
$gt
$gte
$lt
$lte
$ne
Expressões aritméticas
$abs
$add
$ceil
$divide
$exp
$floor
$ln
$log
$log10
$mod
$multiply
$pow
$sqrt
$subtract
$trunc
Expressões de cadeia
$concat
$indexOfBytes
$indexOfCP
$split
$strLenBytes
$strLenCP
$strcasecmp
$substr
$substrBytes
$substrCP
$toLower
$toUpper
Expressões de matriz
$arrayElemAt
$concatArrays
$filter
$indexOfArray
$isArray
$range
$reverseArray
$size
$slice
$in
Expressões de data
$dayOfYear
$dayOfMonth
$dayOfWeek
$year
$month
$week
$hour
$minute
$second
$millisecond
$isoDayOfWeek
$isoWeek
Expressões condicionais
$cond
$ifNull
Acumuladores de agregação
$sum
$avg
$first
$last
$max
$min
$push
$addToSet
Operadores
Os seguintes operadores são suportados com exemplos correspondentes da respetiva utilização. Considere este documento de exemplo utilizado nas consultas abaixo:
{
"Volcano Name": "Rainier",
"Country": "United States",
"Region": "US-Washington",
"Location": {
"type": "Point",
"coordinates": [
-121.758,
46.87
]
},
"Elevation": 4392,
"Type": "Stratovolcano",
"Status": "Dendrochronology",
"Last Known Eruption": "Last known eruption from 1800-1899, inclusive"
}
Operador | Exemplo |
---|---|
eq |
{ "Volcano Name": { $eq: "Rainier" } } |
gt |
{ "Elevation": { $gt: 4000 } } |
gte |
{ "Elevation": { $gte: 4392 } } |
lt |
{ "Elevation": { $lt: 5000 } } |
lte |
{ "Elevation": { $lte: 5000 } } |
ne |
{ "Elevation": { $ne: 1 } } |
in |
{ "Volcano Name": { $in: ["St. Helens", "Rainier", "Glacier Peak"] } } |
nin |
{ "Volcano Name": { $nin: ["Lassen Peak", "Hood", "Baker"] } } |
or |
{ $or: [ { Elevation: { $lt: 4000 } }, { "Volcano Name": "Rainier" } ] } |
and |
{ $and: [ { Elevation: { $gt: 4000 } }, { "Volcano Name": "Rainier" } ] } |
not |
{ "Elevation": { $not: { $gt: 5000 } } } |
nor |
{ $nor: [ { "Elevation": { $lt: 4000 } }, { "Volcano Name": "Baker" } ] } |
exists |
{ "Status": { $exists: true } } |
type |
{ "Status": { $type: "string" } } |
mod |
{ "Elevation": { $mod: [ 4, 0 ] } } |
regex |
{ "Volcano Name": { $regex: "^Rain"} } |
Notas
Nas consultas $regex, as expressões ancoradas à esquerda permitem uma pesquisa de índice. No entanto, utilizar o modificador "i" (não sensível a maiúsculas e minúsculas) e o modificador "m" (multinha) faz a análise de coleção em todas as expressões.
Quando houver necessidade de incluir '$' ou '|', é melhor criar duas (ou mais) consultas regex.
Por exemplo, dada a seguinte consulta original: find({x:{$regex: /^abc$/})
, tem de ser modificada como se segue: find({x:{$regex: /^abc/, x:{$regex:/^abc$/}})
.
A primeira parte irá utilizar o índice para restringir a pesquisa aos documentos que começam por ^abc e a segunda parte vai fazer a correspondência com as entradas exatas.
O operador barra "|" atua como uma função "or" – a consulta find({x:{$regex: /^abc|^def/})
faz a correspondência dos documentos cujo campo "x" tem valores que começam por "abc" ou "def". Para utilizar o índice, é recomendado dividir a consulta em duas consultas diferentes associadas pelo operador $or: find( {$or : [{x: $regex: /^abc/}, {$regex: /^def/}] })
.
Operadores de atualização
Operadores de atualização de campo
$inc
$mul
$rename
$setOnInsert
$set
$unset
$min
$max
$currentDate
Operadores de atualização de matriz
$addToSet
$pop
$pullAll
$pull
(Nota: $pull com condição não é suportada)$pushAll
$push
$each
$slice
$sort
$position
Operador de atualização bit a bit
$bit
Operadores geoespaciais
Operador | Exemplo | Suportado |
---|---|---|
$geoWithin |
{ "Location.coordinates": { $geoWithin: { $centerSphere: [ [ -121, 46 ], 5 ] } } } |
Sim |
$geoIntersects |
{ "Location.coordinates": { $geoIntersects: { $geometry: { type: "Polygon", coordinates: [ [ [ -121.9, 46.7 ], [ -121.5, 46.7 ], [ -121.5, 46.9 ], [ -121.9, 46.9 ], [ -121.9, 46.7 ] ] ] } } } } |
Sim |
$near |
{ "Location.coordinates": { $near: { $geometry: { type: "Polygon", coordinates: [ [ [ -121.9, 46.7 ], [ -121.5, 46.7 ], [ -121.5, 46.9 ], [ -121.9, 46.9 ], [ -121.9, 46.7 ] ] ] } } } } |
Sim |
$nearSphere |
{ "Location.coordinates": { $nearSphere : [ -121, 46 ], $maxDistance: 0.50 } } |
Sim |
$geometry |
{ "Location.coordinates": { $geoWithin: { $geometry: { type: "Polygon", coordinates: [ [ [ -121.9, 46.7 ], [ -121.5, 46.7 ], [ -121.5, 46.9 ], [ -121.9, 46.9 ], [ -121.9, 46.7 ] ] ] } } } } |
Sim |
$minDistance |
{ "Location.coordinates": { $nearSphere : { $geometry: {type: "Point", coordinates: [ -121, 46 ]}, $minDistance: 1000, $maxDistance: 1000000 } } } |
Sim |
$maxDistance |
{ "Location.coordinates": { $nearSphere : [ -121, 46 ], $maxDistance: 0.50 } } |
Sim |
$center |
{ "Location.coordinates": { $geoWithin: { $center: [ [-121, 46], 1 ] } } } |
Sim |
$centerSphere |
{ "Location.coordinates": { $geoWithin: { $centerSphere: [ [ -121, 46 ], 5 ] } } } |
Sim |
$box |
{ "Location.coordinates": { $geoWithin: { $box: [ [ 0, 0 ], [ -122, 47 ] ] } } } |
Sim |
$polygon |
{ "Location.coordinates": { $near: { $geometry: { type: "Polygon", coordinates: [ [ [ -121.9, 46.7 ], [ -121.5, 46.7 ], [ -121.5, 46.9 ], [ -121.9, 46.9 ], [ -121.9, 46.7 ] ] ] } } } } |
Sim |
Operações de classificação
Quando você usa a findOneAndUpdate
operação, as operações de classificação em um único campo são suportadas, mas as operações de classificação em vários campos não são suportadas.
Outros operadores
Operador | Exemplo | Notas |
---|---|---|
$all |
{ "Location.coordinates": { $all: [-121.758, 46.87] } } |
|
$elemMatch |
{ "Location.coordinates": { $elemMatch: { $lt: 0 } } } |
|
$size |
{ "Location.coordinates": { $size: 2 } } |
|
$comment |
{ "Location.coordinates": { $elemMatch: { $lt: 0 } }, $comment: "Negative values"} |
|
$text |
Não suportado. Em alternativa, utilize $regex. |
Operadores não suportados
Os $where
operadores e os $eval
operadores não são suportados pelo Azure Cosmos DB.
Métodos
São suportados os seguintes métodos:
Métodos de cursor
Método | Exemplo | Notas |
---|---|---|
cursor.sort() |
cursor.sort({ "Elevation": -1 }) |
Documentos sem chave de classificação não são devolvidos |
Índices exclusivos
O Azure Cosmos DB indexa cada campo nos documentos que são escritos na base de dados por predefinição. Índices exclusivos garantem que um campo específico não tenha valores duplicados em todos os documentos de uma coleção, semelhante à maneira como a exclusividade é preservada na chave padrão _id
. Você pode criar índices personalizados no Azure Cosmos DB usando o comando createIndex, incluindo a restrição 'exclusivo'.
Índices exclusivos estão disponíveis para todas as contas do Azure Cosmos DB usando o Azure Cosmos DB para MongoDB.
TTL
O Azure Cosmos DB suporta apenas um tempo de vida (TTL) no nível de coleção (_ts) na versão 3.2. Atualize para as versões 3.6+ para aproveitar outras formas de TTL.
Gestão de funções e utilizadores
O Azure Cosmos DB ainda não oferece suporte a usuários e funções. No entanto, o Azure Cosmos DB dá suporte ao controle de acesso baseado em função do Azure (Azure RBAC) e senhas/chaves de leitura-gravação e somente leitura que podem ser obtidas por meio do portal do Azure (página Cadeia de Conexão).
Replicação
O Azure Cosmos DB suporta a replicação nativa e automática nas camadas inferiores. Esta lógica é expandida para conseguir também a replicação global de latência baixa. O Azure Cosmos DB não oferece suporte a comandos de replicação manual.
Preocupação Escrita
Alguns aplicativos dependem de uma preocupação de gravação que especifica o número de respostas necessárias durante uma operação de gravação. Devido à forma como o Azure Cosmos DB lida com a replicação em segundo plano, todas as gravações são automaticamente Quorum por padrão. Qualquer problema de gravação especificado pelo código do cliente é ignorado. Saiba mais em Using consistency levels to maximize availability and performance (Utilizar níveis de consistência para maximizar a disponibilidade e desempenho).
Fragmentação
O Azure Cosmos DB suporta a fragmentação automática do lado do servidor. Ele gerencia a criação, colocação e balanceamento de estilhaços automaticamente. O Azure Cosmos DB não suporta comandos de fragmentação manual, o que significa que não tem de invocar comandos como shardCollection, addShard, balancerStart, moveChunk etc. Você só precisa especificar a chave de fragmento ao criar os contêineres ou consultar os dados.
Próximos passos
- Saiba como usar o Studio 3T com o Azure Cosmos DB para MongoDB.
- Saiba como usar o Robo 3T com o Azure Cosmos DB para MongoDB.
- Explore exemplos do MongoDB com o Azure Cosmos DB para MongoDB.