API do Azure Cosmos DB para MongoDB (versão 3.6): sintaxe e recursos compatíveisAzure Cosmos DB's API for MongoDB (3.6 version): supported features and syntax

O Azure Cosmos DB é o serviço de banco de dados multimodelo distribuído globalmente da Microsoft.Azure Cosmos DB is Microsoft's globally distributed multi-model database service. Você pode se comunicar com a API do Azure Cosmos DB para MongoDB usando qualquer um dos drivers de cliente de software livre do MongoDB.You can communicate with the Azure Cosmos DB's API for MongoDB using any of the open-source MongoDB client drivers. A API do Azure Cosmos DB para MongoDB permite o uso de drivers de cliente existentes ao aderir ao protocolo de transmissão do MongoDB.The Azure Cosmos DB's API for MongoDB enables the use of existing client drivers by adhering to the MongoDB wire protocol.

Usando a API do Azure Cosmos DB para MongoDB, você pode aproveitar os benefícios do MongoDB com os quais está acostumado, com todas as funcionalidades empresariais que o Cosmos DB oferece: distribuição global, fragmentação automática, garantias de disponibilidade e latência, criptografia em repouso, backups e muito mais.By using the Azure Cosmos DB's API for MongoDB, you can enjoy the benefits of the MongoDB you're used to, with all of the enterprise capabilities that Cosmos DB provides: global distribution, automatic sharding, availability and latency guarantees, encryption at rest, backups, and much more.

Suporte de protocoloProtocol Support

Por padrão, a API do Azure Cosmos DB para MongoDB é compatível com o servidor do MongoDB versão 3.6 em novas contas.The Azure Cosmos DB's API for MongoDB is compatible with MongoDB server version 3.6 by default for new accounts. Os operadores com suporte e qualquer limitação ou exceções estão listadas abaixo.The supported operators and any limitations or exceptions are listed below. Qualquer driver de cliente que entenda esses protocolos poderá conectar-se à API do Azure Cosmos DB para MongoDB.Any client driver that understands these protocols should be able to connect to Azure Cosmos DB's API for MongoDB. Observe que, ao usar a API do Azure Cosmos DB para contas do MongoDB, a versão 3.6 das contas tem o ponto de extremidade no formato *.mongo.cosmos.azure.com, enquanto a versão 3.2 das contas tem o ponto de extremidade no formato *.documents.azure.com.Note that when using Azure Cosmos DB's API for MongoDB accounts, the 3.6 version of accounts have the endpoint in the format *.mongo.cosmos.azure.com whereas the 3.2 version of accounts have the endpoint in the format *.documents.azure.com.

Suporte de linguagem de consultaQuery language support

A API do Azure Cosmos DB para MongoDB fornece um suporte abrangente para construções de linguagem de consulta do MongoDB.Azure Cosmos DB's API for MongoDB provides comprehensive support for MongoDB query language constructs. Abaixo, você encontrará uma lista detalhada de operações, operadores, estágios, comandos e opções atualmente compatíveis.Below you can find the detailed list of currently supported operations, operators, stages, commands, and options.

Comandos de banco de dadosDatabase commands

A API do Azure Cosmos DB para MongoDB é compatível com os seguintes comandos de banco de dados:Azure Cosmos DB's API for MongoDB supports the following database commands:

Comandos de operação de consulta e gravaçãoQuery and write operation commands

ComandoCommand Com suporteSupported
excluirdelete SimYes
localizarfind SimYes
findAndModifyfindAndModify SimYes
getLastErrorgetLastError SimYes
getMoregetMore SimYes
getPrevErrorgetPrevError NãoNo
insertinsert SimYes
parallelCollectionScanparallelCollectionScan SimYes
resetErrorresetError NãoNo
atualizarupdate SimYes
Alterar os fluxosChange streams SimYes
GridFSGridFS SimYes

Comandos de autenticaçãoAuthentication commands

ComandoCommand Com suporteSupported
authenticateauthenticate SimYes
logoutlogout SimYes
getnoncegetnonce SimYes

Comandos de administraçãoAdministration commands

ComandoCommand Com suporteSupported
Coleções limitadasCapped Collections NãoNo
cloneCollectionAsCappedcloneCollectionAsCapped NãoNo
collModcollMod NãoNo
collMod: expireAfterSecondscollMod: expireAfterSeconds NãoNo
convertToCappedconvertToCapped NãoNo
copydbcopydb NãoNo
createcreate SimYes
createIndexescreateIndexes SimYes
currentOpcurrentOp SimYes
dropdrop SimYes
dropDatabasedropDatabase SimYes
dropIndexesdropIndexes SimYes
filemd5filemd5 SimYes
killCursorskillCursors SimYes
killOpkillOp NãoNo
listCollectionslistCollections SimYes
listDatabaseslistDatabases SimYes
listIndexeslistIndexes SimYes
reIndexreIndex SimYes
renameCollectionrenameCollection NãoNo
ConnectionStatusconnectionStatus NãoNo

Comandos de diagnósticoDiagnostics commands

ComandoCommand Com suporteSupported
buildInfobuildInfo SimYes
collStatscollStats SimYes
connPoolStatsconnPoolStats NãoNo
ConnectionStatusconnectionStatus NãoNo
dataSizedataSize NãoNo
dbHashdbHash NãoNo
dbStatsdbStats SimYes
explainexplain SimYes
explain: executionStatsexplain: executionStats SimYes
recursosfeatures NãoNo
hostInfohostInfo NãoNo
listDatabaseslistDatabases SimYes
listCommandslistCommands NãoNo
profilerprofiler NãoNo
serverStatusserverStatus NãoNo
toptop NãoNo
whatsmyuriwhatsmyuri SimYes

Pipeline de agregaçãoAggregation pipeline

Comandos de agregaçãoAggregation commands

ComandoCommand Com suporteSupported
aggregateaggregate SimYes
countcount SimYes
distinctdistinct SimYes
mapReducemapReduce NãoNo

Estágios de agregaçãoAggregation stages

ComandoCommand Com suporteSupported
$collStats$collStats NãoNo
$project$project SimYes
$match$match SimYes
$redact$redact SimYes
$limit$limit SimYes
$skip$skip SimYes
$unwind$unwind SimYes
$group$group SimYes
$sample$sample SimYes
$sort$sort SimYes
$geoNear$geoNear NãoNo
$lookup$lookup SimYes
$out$out SimYes
$indexStats$indexStats NãoNo
$facet$facet SimYes
$bucket$bucket NãoNo
$bucketAuto$bucketAuto NãoNo
$sortByCount$sortByCount SimYes
$addFields$addFields SimYes
$replaceRoot$replaceRoot SimYes
$count$count SimYes
$currentOp$currentOp NãoNo
$listLocalSessions$listLocalSessions NãoNo
$listSessions$listSessions NãoNo
$graphLookup$graphLookup NãoNo

Expressões boolianasBoolean expressions

ComandoCommand Com suporteSupported
$and$and SimYes
$or$or SimYes
$not$not SimYes

Expressões de definiçãoSet expressions

ComandoCommand Com suporteSupported
$setEquals$setEquals SimYes
$setIntersection$setIntersection SimYes
$setUnion$setUnion SimYes
$setDifference$setDifference SimYes
$setIsSubset$setIsSubset SimYes
$anyElementTrue$anyElementTrue SimYes
$allElementsTrue$allElementsTrue SimYes

Expressões de comparaçãoComparison expressions

ComandoCommand Com suporteSupported
$cmp$cmp SimYes
$eq$eq SimYes
$gt$gt SimYes
$gte$gte SimYes
$lt$lt SimYes
$lte$lte SimYes
$ne$ne SimYes
$in$in SimYes
$nin$nin SimYes

Expressões aritméticasArithmetic expressions

ComandoCommand Com suporteSupported
$abs$abs SimYes
$add$add SimYes
$ceil$ceil SimYes
$divide$divide SimYes
$exp$exp SimYes
$floor$floor SimYes
$ln$ln SimYes
$log$log SimYes
$log10$log10 SimYes
$mod$mod SimYes
$multiply$multiply SimYes
$pow$pow SimYes
$sqrt$sqrt SimYes
$subtract$subtract SimYes
$trunc$trunc SimYes

Expressões de cadeia de caracteresString expressions

ComandoCommand Com suporteSupported
$concat$concat SimYes
$indexOfBytes$indexOfBytes SimYes
$indexOfCP$indexOfCP SimYes
$split$split SimYes
$strLenBytes$strLenBytes SimYes
$strLenCP$strLenCP SimYes
$strcasecmp$strcasecmp SimYes
$substr$substr SimYes
$substrBytes$substrBytes SimYes
$substrCP$substrCP SimYes
$toLower$toLower SimYes
$toUpper$toUpper SimYes

Operador de pesquisa de textoText search operator

ComandoCommand Com suporteSupported
$meta$meta NãoNo

Expressões de matrizArray expressions

ComandoCommand Com suporteSupported
$arrayElemAt$arrayElemAt SimYes
$arrayToObject$arrayToObject SimYes
$concatArrays$concatArrays SimYes
$filter$filter SimYes
$indexOfArray$indexOfArray SimYes
$isArray$isArray SimYes
$objectToArray$objectToArray SimYes
$range$range SimYes
$reverseArray$reverseArray SimYes
$reduce$reduce SimYes
$size$size SimYes
$slice$slice SimYes
$zip$zip SimYes
$in$in SimYes

Operadores variáveisVariable operators

ComandoCommand Com suporteSupported
$map$map NãoNo
$let$let SimYes

Variáveis do sistemaSystem variables

ComandoCommand Com suporteSupported
$$CURRENT$$CURRENT SimYes
$$DESCEND$$DESCEND SimYes
$$KEEP$$KEEP SimYes
$$PRUNE$$PRUNE SimYes
$$REMOVE$$REMOVE SimYes
$$ROOT$$ROOT SimYes

Operador literalLiteral operator

ComandoCommand Com suporteSupported
$literal$literal SimYes

Expressões de dataDate expressions

ComandoCommand Com suporteSupported
$dayOfYear$dayOfYear SimYes
$dayOfMonth$dayOfMonth SimYes
$dayOfWeek$dayOfWeek SimYes
$year$year SimYes
$month$month SimYes
$week$week SimYes
$hour$hour SimYes
$minute$minute SimYes
$segundo$second SimYes
$millisecond$millisecond SimYes
$dateToString$dateToString SimYes
$isoDayOfWeek$isoDayOfWeek SimYes
$isoWeek$isoWeek SimYes
$dateFromParts$dateFromParts NãoNo
$dateToParts$dateToParts NãoNo
$dateFromString$dateFromString NãoNo
$isoWeekYear$isoWeekYear SimYes

Expressões condicionaisConditional expressions

ComandoCommand Com suporteSupported
$cond$cond SimYes
$ifNull$ifNull SimYes
$switch$switch SimYes

Operador de tipo de dadosData type operator

ComandoCommand Com suporteSupported
$type$type SimYes

Expressões do acumuladorAccumulator expressions

ComandoCommand Com suporteSupported
$sum$sum SimYes
$avg$avg SimYes
$first$first SimYes
$last$last SimYes
$max$max SimYes
$min$min SimYes
$push$push SimYes
$addToSet$addToSet SimYes
$stdDevPop$stdDevPop NãoNo
$stdDevSamp$stdDevSamp NãoNo

Operador de mesclagemMerge operator

ComandoCommand Com suporteSupported
$mergeObjects$mergeObjects SimYes

Tipos de dadosData types

ComandoCommand Com suporteSupported
DoubleDouble SimYes
StringString SimYes
ObjetoObject SimYes
ArrayArray SimYes
Binary DataBinary Data SimYes
ObjectIdObjectId SimYes
BooleanBoolean SimYes
DataDate SimYes
NuloNull SimYes
Inteiro de 32 bits (int)32-bit Integer (int) SimYes
TimestampTimestamp SimYes
Inteiro de 64 bits (longo)64-bit Integer (long) SimYes
MinKeyMinKey SimYes
MaxKeyMaxKey SimYes
Decimal128Decimal128 SimYes
Expressão regularRegular Expression SimYes
JavaScriptJavaScript SimYes
JavaScript (com escopo)JavaScript (with scope) SimYes
IndefinidoUndefined SimYes

Índices e propriedades de índiceIndexes and index properties

ÍndicesIndexes

ComandoCommand Com suporteSupported
Índice de campo únicoSingle Field Index SimYes
Índice compostoCompound Index SimYes
Índice de várias chavesMultikey Index SimYes
Índice de textoText Index NãoNo
2dsphere2dsphere SimYes
Índice 2D2d Index NãoNo
Índice de hashHashed Index SimYes

Propriedades de índiceIndex properties

ComandoCommand Com suporteSupported
TTLTTL SimYes
ExclusivoUnique SimYes
ParcialPartial NãoNo
Não diferencia maiúsculas de minúsculasCase Insensitive NãoNo
EsparsosSparse NãoNo
Segundo planoBackground SimYes

OperadoresOperators

Operadores lógicosLogical operators

ComandoCommand Com suporteSupported
$or$or SimYes
$and$and SimYes
$not$not SimYes
$nor$nor SimYes

Operadores de elementoElement operators

ComandoCommand Com suporteSupported
$exists$exists SimYes
$type$type SimYes

Operadores de consulta de avaliaçãoEvaluation query operators

ComandoCommand Com suporteSupported
$expr$expr NãoNo
$jsonSchema$jsonSchema NãoNo
$mod$mod SimYes
$regex$regex SimYes
$text$text Não (Sem suporte.No (Not supported. Use $regex.)Use $regex instead.)
$where$where NãoNo

Em consultas de $regex, as expressões ancoradas à esquerda permitem a pesquisa de índice.In the $regex queries, left-anchored expressions allow index search. No entanto, usar o modiciador 'i' (não sensível a maiúsculas e minúsculas) e o modificador 'm' (várias linhas) faz com que a coleção verifique todas as expressões.However, using 'i' modifier (case-insensitivity) and 'm' modifier (multiline) causes the collection scan in all expressions.

Quando houver a necessidade de se incluir '$' ou '|', é melhor criar duas (ou mais) consultas regex.When there's a need to include '$' or '|', it is best to create two (or more) regex queries. Por exemplo, considerando a seguinte consulta original find({x:{$regex: /^abc$/}), ela deve ser modificada da seguinte maneira:For example, given the following original query: find({x:{$regex: /^abc$/}), it has to be modified as follows:

find({x:{$regex: /^abc/, x:{$regex:/^abc$/}}).find({x:{$regex: /^abc/, x:{$regex:/^abc$/}}).

A primeira parte usará o índice para restringir a pesquisa a esses documentos começando com ^abc e a segunda parte corresponderá às entradas exatas.The first part will use the index to restrict the search to those documents beginning with ^abc and the second part will match the exact entries. O operador de barra '|' atua como uma função "or" – a consulta find({x:{$regex: /^abc|^def/}) faz a correspondência dos documentos em que o campo 'x' tem valores que começam com "abc" ou "def".The bar operator '|' acts as an "or" function - the query find({x:{$regex: /^abc|^def/}) matches the documents in which field 'x' has values that begin with "abc" or "def". Para utilizar o índice, é recomendável dividir a consulta em duas consultas diferentes unidas pelo operador $or: find( {$or : [{x: $regex: /^abc/}, {$regex: /^def/}] }).To utilize the index, it's recommended to break the query into two different queries joined by the $or operator: find( {$or : [{x: $regex: /^abc/}, {$regex: /^def/}] }).

Operadores de matrizArray operators

ComandoCommand Com suporteSupported
$all$all SimYes
$elemMatch$elemMatch SimYes
$size$size SimYes

Operador de comentárioComment operator

ComandoCommand Com suporteSupported
$comment$comment SimYes

Operadores de projeçãoProjection operators

ComandoCommand Com suporteSupported
$elemMatch$elemMatch SimYes
$meta$meta NãoNo
$slice$slice SimYes

Operadores de atualizaçãoUpdate operators

Operadores de atualização de campoField update operators

ComandoCommand Com suporteSupported
$inc$inc SimYes
$mul$mul SimYes
$rename$rename SimYes
$setOnInsert$setOnInsert SimYes
$set$set SimYes
$unset$unset SimYes
$min$min SimYes
$max$max SimYes
$currentDate$currentDate SimYes

Operadores de atualização de matrizArray update operators

ComandoCommand Com suporteSupported
$ SimYes
$[]$[] SimYes
$[]$[] SimYes
$addToSet$addToSet SimYes
$pop$pop SimYes
$pullAll$pullAll SimYes
$pull$pull SimYes
$push$push SimYes
$pushAll$pushAll SimYes

Atualizar modificadoresUpdate modifiers

ComandoCommand Com suporteSupported
$each$each SimYes
$slice$slice SimYes
$sort$sort SimYes
$position$position SimYes

Operador de atualização bit a bitBitwise update operator

ComandoCommand Com suporteSupported
$bit$bit SimYes
$bitsAllSet$bitsAllSet NãoNo
$bitsAnySet$bitsAnySet NãoNo
$bitsAllClear$bitsAllClear NãoNo
$bitsAnyClear$bitsAnyClear NãoNo

Operadores geoespaciaisGeospatial operators

OperadorOperator Com suporteSupported
$geoWithin$geoWithin SimYes
$geoIntersects$geoIntersects SimYes
$near$near SimYes
$nearSphere$nearSphere SimYes
$geometry$geometry SimYes
$minDistance$minDistance SimYes
$maxDistance$maxDistance SimYes
$center$center NãoNo
$centerSphere$centerSphere NãoNo
$box$box NãoNo
$polygon$polygon NãoNo

Métodos de cursorCursor methods

ComandoCommand Com suporteSupported
cursor.batchSize()cursor.batchSize() SimYes
cursor.close()cursor.close() SimYes
cursor.isClosed()cursor.isClosed() SimYes
cursor.collation()cursor.collation() NãoNo
cursor.comment()cursor.comment() SimYes
cursor.count()cursor.count() SimYes
cursor.explain()cursor.explain() NãoNo
cursor.forEach()cursor.forEach() SimYes
cursor.hasNext()cursor.hasNext() SimYes
cursor.hint()cursor.hint() SimYes
cursor.isExhausted()cursor.isExhausted() SimYes
cursor.itcount()cursor.itcount() SimYes
cursor.limit()cursor.limit() SimYes
cursor.map()cursor.map() SimYes
cursor.maxScan()cursor.maxScan() SimYes
cursor.maxTimeMS()cursor.maxTimeMS() SimYes
cursor.max()cursor.max() SimYes
cursor.min()cursor.min() SimYes
cursor.next()cursor.next() SimYes
cursor.noCursorTimeout()cursor.noCursorTimeout() NãoNo
cursor.objsLeftInBatch()cursor.objsLeftInBatch() SimYes
cursor.pretty()cursor.pretty() SimYes
cursor.readConcern()cursor.readConcern() SimYes
cursor.readPref()cursor.readPref() SimYes
cursor.returnKey()cursor.returnKey() NãoNo
cursor.showRecordId()cursor.showRecordId() NãoNo
cursor.size()cursor.size() SimYes
cursor.skip()cursor.skip() SimYes
cursor.Sort()cursor.sort() SimYes
cursor.tailable()cursor.tailable() NãoNo
cursor.toArray()cursor.toArray() SimYes

Classificar operaçõesSort operations

Ao usar a operação findOneAndUpdate, há suporte para operações de classificação em um único campo, mas não há para operações em vários campos.When using the findOneAndUpdate operation, sort operations on a single field are supported but sort operations on multiple fields are not supported.

Índices exclusivosUnique indexes

Índices exclusivos verificam se um campo específico não tem valores duplicados em todos os documentos em uma coleção, de modo semelhante à maneira como a exclusividade é preservada na chave "_id" padrão.Unique indexes ensure that a specific field doesn't have duplicate values across all documents in a collection, similar to the way uniqueness is preserved on the default "_id" key. Você pode criar índices exclusivos no Cosmos DB usando o comando createIndex com o parâmetro de restrição unique:You can create unique indexes in Cosmos DB by using the createIndex command with the unique constraint parameter:

globaldb:PRIMARY> db.coll.createIndex( { "amount" : 1 }, {unique:true} )
{
        "_t" : "CreateIndexesResponse",
        "ok" : 1,
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 4
}

Índice compostoCompound indexes

Índices compostos fornecem uma forma de criar um índice para grupos de campos para até oito campos.Compound indexes provide a way to create an index for groups of fields for up to 8 fields. Esse tipo de índice difere dos índices compostos nativos do MongoDB.This type of index differs from the native MongoDB compound indexes. No Azure Cosmos DB, os índices compostos são usados para operações de classificação aplicadas a vários campos.In Azure Cosmos DB, compound indexes are used for sorting operations that are applied to multiple fields. Para criar um índice composto, você precisa especificar mais de uma propriedade como o parâmetro:To create a compound index you need to specify more than one property as the parameter:

globaldb:PRIMARY> db.coll.createIndex({"amount": 1, "other":1})
{
        "createdCollectionAutomatically" : false, 
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

Vida útil (TTL)Time-to-live (TTL)

O Cosmos DB é compatível com uma TTL (vida útil) com base no carimbo de data/hora do documento.Cosmos DB supports a time-to-live (TTL) based on the timestamp of the document. A TTL pode ser habilitada para coleções acessando o portal do Azure.TTL can be enabled for collections by going to the Azure portal.

Gerenciamento de usuários e funçõesUser and role management

O Cosmos DB ainda não dá suporte a usuários e funções.Cosmos DB does not yet support users and roles. No entanto, o Cosmos DB dá suporte ao RBAC (controle de acesso baseado em função) e a 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).However, Cosmos DB supports role-based access control (RBAC) and read-write and read-only passwords/keys that can be obtained through the Azure portal (Connection String page).

ReplicaçãoReplication

O Cosmos DB é compatível com a replicação automática nativa em camadas mais baixas.Cosmos DB supports automatic, native replication at the lowest layers. Essa lógica é estendida para atingir também réplica global e baixa.This logic is extended out to achieve low-latency, global replication as well. O Cosmos DB não dá suporte a comandos de replicação manual.Cosmos DB does not support manual replication commands.

Problema de GravaçãoWrite Concern

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.Some applications rely on a Write Concern which specifies the number of responses required during a write operation. Devido à forma como o Cosmos DB lida com a replicação em segundo plano, todas as gravações são automaticamente Quorum, por padrão.Due to how Cosmos DB handles replication in the background all writes are all automatically Quorum by default. Toda preocupação de gravação especificada pelo código do cliente é ignorada.Any write concern specified by the client code is ignored. Saiba mais em Como usar níveis de consistência para maximizar a disponibilidade e o desempenho.Learn more in Using consistency levels to maximize availability and performance.

FragmentaçãoSharding

O Azure Cosmos DB oferece suporte à fragmentação automática, do lado do servidor.Azure Cosmos DB supports automatic, server-side sharding. Ele gerencia a criação, o posicionamento e o balanceamento de fragmentos automaticamente.It manages shard creation, placement, and balancing automatically. O Azure Cosmos DB não dá suporte a comandos de fragmentação manual, o que significa que você não precisa invocar comandos como addShard, balancerStart, moveChunk etc. Você só precisa especificar a chave de fragmentação ao criar os contêineres ou consultar os dados.Azure Cosmos DB does not support manual sharding commands, which means you don't have to invoke commands such as addShard, balancerStart, moveChunk etc. You only need to specify the shard key while creating the containers or querying the data.

SessõesSessions

O Azure Cosmos DB ainda não dá suporte a comandos de sessões do lado do servidor.Azure Cosmos DB does not yet support server side sessions commands.

Próximas etapasNext steps

Observação: este artigo descreve um recurso do Azure Cosmos DB que fornece a compatibilidade de protocolo de transmissão com bancos de dados MongoDB. A Microsoft não executa bancos de dados MongoDB para fornecer esse serviço. O Azure Cosmos DB não está afiliado à MongoDB, Inc.Note: This article describes a feature of Azure Cosmos DB that provides wire protocol compatibility with MongoDB databases. Microsoft does not run MongoDB databases to provide this service. Azure Cosmos DB is not affiliated with MongoDB, Inc.