Transações de MongoDB

O MongoDB suporta transações para combinar e isolar as várias afirmações para processar em uma única operação. As operações de transação são agrupadas e processadas em um ambiente que é distinto de outras perguntas, em vez de ser executado uma a uma, como são fornecidas ao servidor. As propriedades da transação ajudam as coleções do MongoDB na manutenção da conformidade com ácido. A consistência do banco de dados é mantida e a durabilidade é obtida quando a modificação da transação não é salva até que sejam comprometidas.

Etapa 1: Criando os dados da amostra em MongoDB para a transação

Para realizar as transações em MongoDB, precisamos de uma coleção com os documentos. Aqui, estabelecemos a coleção “PublicBank” MongoDB e adicionamos três documentos a ela com a ajuda do método InsertMany. A estrutura de consulta para inserir o documento é a seguinte:

dB.PublicBank.InsertMany ([
Person_name: "Sam",
Person_city: "Los Angeles",
Account_number: "132309423",
Valor: 150000.400,
Person_name: "Emily",
Person_city: "Califórnia",
Account_number: "752889411",
Valor: 370000.400,
Person_name: "Maddy",
Person_city: "Houston",
Account_number: "34305909",
Valor: 560000.400
]))

A saída é exibida na imagem a seguir, indicando que os documentos são adicionados com sucesso à coleção "PublicBank". Agora, demonstramos como iniciar e concluir as transações usando os dados de amostra "PublicBank".

Além disso, criamos o índice como "Account_Number: 1" de cada documento na coleção "PublicBank" usando o método createIndex () para verificar se o valor do campo de nome de cada documento é diferente. Isso é muito útil para validar os requisitos de consistência ao processar as transações.

dB.PublicBank.CreateIndex ("Account_number": 1, "exclusivo": true)

Etapa 2: Crie a transação da coleção de amostras especificadas de MongoDB

Nesta seção, iniciamos a transação declarando a variável "sessão". Esta variável "sessão" armazena todos os objetos de sessão que são usados ​​para nossa transação. A consulta é fornecida no seguinte, onde definimos o “dB.getmongo ().Declaração () ”” depois de declarar a variável “Sessão”. O método getMongo () é usado para verificar se a conexão é estabelecida corretamente. O método startession () é chamado para iniciar a sessão para as operações de transação, pois a sessão ainda deve ser iniciada para executar uma série de operações em conjunto como uma transação.

sessão = dB.getmongo ().Startession ()

Quando executamos a consulta de sessão no shell, ela gera a sessão "ID", como mostrado na imagem a seguir:

Agora, definimos o parâmetro: o método startTransaction () com a variável "sessão" para a operação de leitura e gravação em nossa transação do MongoDB. A startsession é fornecida pela primeira vez com o parâmetro "readconcern". Em seguida, definimos a opção ReadConern com o "nível" de "Snapshot", que recupera os dados de um instantâneo da maioria dos dados comprometidos. A “maioria” está contra a opção “W” do parâmetro “WritEconcern”.

sessão.StartTransaction (
"ReadConcern": "nível": "Snapshot",
"WRITECONCERN": "W": "Maientity"

)

Observe que a consulta StartTransaction não retorna nada como uma saída, porque é executada com sucesso. Ele retorna a saída se algo deu errado com esta consulta ou ao iniciar a sessão. Depois de executar a consulta recente, estamos dentro de uma transação ativa e pode começar a executar as declarações que fazem parte da transação.

Etapa 3: Trabalhando dentro da sessão de transação em MongoDB

Em vez de obter as informações diretamente do objeto "DB" do banco de dados, declaramos outra variável que leva uma referência ao objeto de sessão. A variável é definida antes de trabalhar na transação ativa, que representa a coleção com a qual queremos trabalhar no contexto da sessão.

VAR Bank = sessão.getDatabase ('teste').getCollection ('PublicBank')

Aqui, criamos a variável "banco" especificando o modificador "var". Em seguida, fazemos referência ao objeto "Sessão" que chama o método getDatabase () e o método getCollection (). O método getDatabase () pega o nome do banco de dados MongoDB "Test" e forma o banco de dados "teste". Fornecemos a coleção "PublicBank" no método getCollection ().

Insira o único documento dentro da sessão de transação

Agora, dentro da sessão ativa, realizamos a operação de transação da inserção de outro documento na coleção "PublicBank" usando o método insertone (). O método insertone () é chamado com o "banco" e insere o documento com os seguintes campos:

Banco.insertone (
"Person_name": "James",
"Person_city": "Nova York",
"Account_number": "99931001",
"Valor": 450000.900
)

O MongoDB retorna uma mensagem de sucesso que indica que a operação de transação é realizada. Como a sessão de transação ainda está ativa, o documento que é inserido anteriormente não será exibido na coleção original. Pode haver casos em que a transação inclui o novo registro ou resulta em uma reversão da condição inicial da sessão de transação.

Atualize o documento dentro da sessão de transação

Novamente, realizamos outra transação na mesma coleção "PublicBank", que é especificada com dois comandos. Primeiro, fazemos uma referência de sessão e depois damos um nome de coleção ao método getDatabase (). Depois disso, usamos a palavra -chave "transação" sobre a coleção. Atualize o valor do campo especificado com o método updateOne (). Aqui, o método updateOne () é atribuído com duas expressões - "Account_Number:" 132309423 "e" $ set: valor: 6700000.000 ”. Primeiro, encontramos o valor "Account_Number", que é igual ao valor "132309423". Quando esse valor é obtido, definimos o campo de documentos "Valor" com o novo valor de "670000.000 ”usando o operador $ set.

sessão.getDatabase ('PublicBank').transações.UpdateOne (Account_number: "132309423", $ set: valor: 6700000.000)

Agora, quando a consulta é executada, gera os resultados reconhecidos com o verdadeiro valor. Aqui, o MatchCount: 1 afirma que um documento é comparado, o que satisfaz a condição. O "ModifiedCount: 1" indica que um documento é atualizado com a condição que é aplicada a ele. Ainda não cometemos a transação, então a coleção fora da sessão de transação não é modificada.

Compromete a sessão de transação com o método CommitTransaction ()

Uma confirmação em uma transação de banco de dados refere -se à armazenamento permanente dos dados após uma série de atualizações tentativas. Usamos o seguinte comando em MongoDB para cometer a sessão de transação ativa:

sessão.CommitTransaction ()

Agora, todas as mudanças são armazenadas na coleção "PublicBank", executando o comando comando do MongoDB. Vimos as mudanças que fizemos dentro da transação. A seguir, é apresentado o documento que inserimos na coleção "PublicBank" quando a transação está ativa:

dB.PublicBank.encontre (Person_name: James ”)

Em seguida, temos uma transação de atualizar o documento com o novo valor do campo "Valor". O valor também é atualizado quando o comando de confirmação é aplicado à transação.

dB.PublicBank.encontre (Account_number: “132309423”)

Aborte a sessão de transação com o método aborttransaction ()

Às vezes, não queremos a operação de compromisso sobre a transação. Para isso, abortamos a transação que não afeta o valor da transação. A transação é restaurada ao seu estado anterior. A declaração a seguir deve ser executada ao abortar a transação:

sessão.aborttransaction ()

A sessão de transação termina aqui. Quaisquer alterações relevantes são descartadas. O banco de dados reverte as alterações e retorna ao seu estado inicial, em vez de criar um novo estado consistente.

Conclusão

Cobrimos conceitualmente a transação do MongoDB neste guia. Aprendemos a iniciar as transações em MongoDB. Também inserimos o novo documento e atualizamos o valor do documento fornecido dentro da transação. Em seguida, as declarações de confirmação são usadas para concluir as transações. Além disso, a maneira de reverter as mudanças feitas nas transações também é realizada através da declaração de aborto.