Execute um comando

Nesta página

Visão geral

Executar um comando
Opções de comando
Resposta
Exemplo
Informações adicionais

Visão geral

Neste guia, você pode aprender como executar um comando de banco de dados usando o driver Kotlin Sync. Você pode usar comandos de banco de dados para executar uma variedade de tarefas administrativas e de diagnóstico, como buscar estatísticas do servidor , inicializar um conjunto de réplicas ou executar um pipeline de agregação .

Importante

Preferir métodos de driver em vez de reconhecimento de data center

O driver fornece métodos wrapper para muitos comandos de banco de dados. Recomendamos usar métodos de driver em vez de executar comandos de banco de dados quando possível.

Para executar tarefas administrativas, use o MongoDB Shell em vez do driver Kotlin Sync. Chamar o método db.runCommand() dentro do shell é o método preferido para emitir comandos do banco de dados, pois ele fornece uma interface consistente entre o shell e os drivers.

Executar um comando

Para executar um comando de banco de dados, especifique o comando e quaisquer parâmetros relevantes em um documento e, em seguida, passe o documento para o método runCommand().

O código a seguir mostra como você pode usar o método runCommand() para executar o comando explain, que retorna uma descrição de como o comando find será executado se você chamá-lo:

val commandToExplain = Document("find", "restaurants")
val explanation = database.runCommand(Document("explain", commandToExplain))

Para obter uma lista completa de comandos de banco de dados e os parâmetros correspondentes, consulte o guia Comandos de banco de dados.

Opções de comando

Você pode especificar o comportamento de comando opcional para o método runCommand() incluindo um parâmetro readPreference. O exemplo a seguir mostra como especificar uma preferência de leitura e passá-la como uma opção para o método runCommand():

val command = Document("hello", 1)
val commandReadPreference = Document("readPreference", "secondary")
val commandResult = database.runCommand(command, commandReadPreference)

Para obter mais informações sobre as opções de read preference, consulte Read preference no manual do servidor MongoDB.

Observação

O método runCommand() ignora a configuração de preferência de leitura que você pode ter definido em seu objeto database. Se nenhuma preferência de leitura for especificada, esse método usará a preferência de leitura primary.

Resposta

O método runCommand() retorna um objeto Document que contém a resposta do banco de dados após a execução do comando. Cada comando de banco de dados executa uma função diferente, portanto, o conteúdo da resposta pode variar entre comandos. No entanto, cada resposta contém documentos com os seguintes campos:

Campo	Descrição
<command result>	Fornece campo específicos para o reconhecimento de data center do banco de dados. Por exemplo, `count` retorna o campo `n` e `explain` retorna o campo `queryPlanner` .
`ok`	Indica se o comando foi bem-sucedido (`1`) ou falhou (`0`).
`operationTime`	Indica a hora lógica da operação. O MongoDB usa o tempo lógico para solicitar operações. Para saber mais sobre o tempo lógico, consulte nossa publicação no blog sobre o Relógio Lógico Global.
`$clusterTime`	Fornece um documento que retorna a hora do cluster assinado. O tempo de cluster é um tempo lógico usado para ordenar operações. O documento contém os seguintes campos: `clusterTime`, que é o carimbo de data/hora do cluster mais alto conhecido para o nó. `signature`, que é um documento que contém o hash da hora do cluster e o ID da chave usada para assinar a hora do cluster.

Exemplo

O exemplo seguinte mostra como executar o comando buildInfo e o resultado que ele produz:

import com.mongodb.MongoException
import com.mongodb.kotlin.client.MongoClient
import org.bson.Document
import org.bson.BsonInt64
import org.bson.json.JsonWriterSettings
fun main() {
    // Replace the placeholder with your MongoDB deployment's connection string
    val uri = "<connection string uri>"
    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    try {
        val command = Document("buildInfo", BsonInt64(1))
        val commandResult = database.runCommand(command)
        println(commandResult.toJson(JsonWriterSettings.builder().indent(true).build()))
    } catch (me: MongoException) {
        System.err.println("An error occurred: $me")
    }
    mongoClient.close()
}

{
  version: '8.0.4',
   ...<other command results>...
  ok: 1,
  '$clusterTime': {
      clusterTime: Timestamp({ ... }),
      signature: {
         ...
      }
  },
  operationTime: Timestamp({ ... })
}

Informações adicionais

Para obter mais informações sobre os conceitos deste guia, consulte a seguinte documentação:

Voltar

Construtores e classes de dados

Monitoramento