Perguntas[mongodb](dba)

Normalmente não faço perguntas, mas estou quase no meu limite e prevejo que vou ter dificuldades com isso por um tempo. Para os revisores de perguntas, não encontrei nenhuma pergunta referente às versões do Mongo com as quais estou tendo problemas, nem meu erro específico para o nó arbiter.

Resumo:

O árbitro está falhando em uma atualização da v6 para a v7 por causa de um inválido featureCompabilityVersionque li e que ele não deveria se importar ou usar.

Estou esquecendo de algo óbvio relacionado à configuração/atualização do nó do árbitro?

Versão longa:

Estou usando o Docker Compose para gerenciar um conjunto de réplicas de bancos de dados Mongo consistindo de 1 primário, 1 secundário e 1 árbitro. Todos eles usam a docker.io/bitnami/mongodbimagem e têm volumes para persistir quaisquer dados que precisem gravar. Minha tarefa é atualizar suas imagens de v5 para v7 usando as instruções do Mongo .

A atualização da v5 para a v6 foi tranquila, pois a v6 é compatível com versões anteriores e só exigiu a atualização da versão da imagem. Para atualizar para a v7, entrei no banco de dados de administração do nó primário e executei db.adminCommand( { setFeatureCompatibilityVersion: "6.0" } )seguido por db.adminCommand( { getParameter: 1, featureCompatibilityVersion: 1})para confirmar que a alteração foi feita.

Atualizei as versões de imagem no arquivo compose de v6 para v7 e reiniciei. Os nós primário/secundário estão bem, mas o arbiter emite esse erro antes de desligar,

PROBLEMA DE ATUALIZAÇÃO: Foi encontrado um documento featureCompatibilityVersion inválido (ERRO: Location4926900: Documento featureCompatibilityVersion inválido em admin.system.version: { _id: "featureCompatibilityVersion", versão: "5.0" }. Consulte https://docs.mongodb.com/master/release-notes/6.0-compatibility/#feature-compatibility . :: causado por :: Valor de versão de compatibilidade de recurso inválido '5.0'; esperado '6.0' ou '6.3' ou '7.0'. Consulte https://docs.mongodb.com/master/release-notes/6.0-compatibility/#feature-compatibility. ). Se o featureCompatibilityVersion atual for inferior a 6.0, consulte a documentação sobre atualização em https://docs.mongodb.com/master/release-notes/6.0/#upgrade-procedures .

Agora eu li que o árbitro não deve conter dados e que o árbitro ignora o FCV em favor da compatibilidade com versões anteriores relatada pelos binários, que se for verdade, deve ser v6, não v5 como o erro declara. Eu tentei autenticar no árbitro para definir o FCV lá, mas eu recebo command setFeatureCompatibilityVersion requires authentication.

Estou esquecendo de algo óbvio relacionado à configuração/atualização do nó do árbitro?

Sou muito novo no MongoDB e comecei a aprender e trabalhar com ele agora. Tenho uma pergunta sobre uma consulta. Esta é a consulta:

db.getCollection("user_plates").count(
    {
        "plates": {
            $elemMatch: {
                registerDate: {
                    $gt: new Date("2024-03-20T00:00:00.000Z"),
                    $lt: new Date("2024-03-21T00:00:00.000Z")
                }
            }
        }
    }
);

Como você sabe, se a consulta encontrar pelo menos um elemento no array que satisfaça ambas as condições, ela retornará todos os elementos daquele documento. Agora, preciso ter apenas os elementos do array daquele documento, que o campo "registerDate"satisfaça ambas as condições. Não quero ver outros elementos do array daquele documento. Como devo modificar a consulta acima para conseguir isso?

desde já, obrigado

Tenho um banco de dados cheio de documentos, cada um contendo uma coleção de transações:

[
  {
    "key": 1,
    "data": [
      {
        "trans": 1,
        "uid": 1
      },
      {
        "trans": 2,
        "uid": 1
      }
    ]
  },
  {
    "key": 2,
    "data": [
      {
        "trans": 3,
        "uid": 1
      },
      {
        "trans": 4,
        "uid": 2
      }
    ]
  }
]

Quero criar um novo campo em cada um dos documentos principais, que tenha os valores exclusivos do uidcampo. Posso chegar a um ponto em que isso acontece usando $map:

db.collection.aggregate([
  {
    "$set": {
      "uid": {
        "$map": {
          "input": "$data",
          "as": "trans",
          "in": "$$trans.uid"
        }
      }
    }
  }
])

Isso me dá:

[
  {
    "key": 1,
    "uid": [1,1],
    "data": [
      {
        "trans": 1,
        "uid": 1
      },
      {
        "trans": 2,
        "uid": 1
      }
    ]
  },
  {
    "key": 2,
    "uid": [1, 2],
    "data": [
      {
        "trans": 3,
        "uid": 1
      },
      {
        "trans": 4,
        "uid": 2
      }
    ]
  }
]

Isso está próximo, mas não consigo descobrir o último passo. Quero usar apenas os valores exclusivos, então o uidpara o primeiro documento deve ser [1], não [1, 1].

A distinct()função funciona em coleções, não em documentos individuais.

Eu acho que isso $addToSetfuncionaria, mas não funciona em arrays, apenas na saída de $group. Também tentei criar uma $reduceespecificação usando $setUnion, mas não sei como promover meu valor numérico em um array.

Posso usar o $unwindestágio com agrupamento _idpara obter os valores corretos para o novo campo, mas não consigo descobrir como anexá-los de volta aos objetos originais.

Conforme sugerido neste post, proponho aqui minha pergunta.

Tenho um MongoDB collections spots que tem documentos que representam a amizade entre dois usuários

{
  "_id":  "64a337de4538a04610900f0c",
  "user1": "6468022102781d442b82afd7",
  "user2": "648c7b6b75231cd99e43d7ab",
  "areFriends": true
}

Meu objetivo é escrever uma agregação que, dados dois IDs de usuários, retorne o grau de separação deles. Para ser claro, algo assim:

• 1 = amigos diretos
• 2 = amigos de amigos
• 3+ etc..

Me deparei com o exemplo acima de $graphLookup e agora estou pensando em como implementar algo semelhante.

A diferença entre meu caso e o outro post é que meus documentos não têm uma relação unidirecional (de-para), mas bidirecional (usuário1, usuário2); portanto, não há garantia de que o usuário desejado seja armazenado como usuário1 ou usuário2.

Em outras seções do meu código, resolvo esse problema ordenando os IDs de entrada ou usando condições como esta:

  $cond: {
              if: { $eq: ['$user1', userId] },
              then: '$user2',
              else: '$user1',
          },

No entanto, entendi que as condições não são suportadas conforme arquivadas (como connectFromField ) em $graphLookup

Alguém tem alguma pista sobre como enfrentar esse problema em particular? Ficaria muito agradecido. Obrigado.

EDIT esta é uma versão revisada do pipeline de agregação proposto por Ray

      { $match: { user1: id1 } },
      {
        $graphLookup: {
          from: 'spots',
          startWith: '$user1',
          connectFromField: 'user2',
          connectToField: 'user1',
          as: 'friendshipsViewLookup',
          depthField: 'degree',
          maxDepth: 2,
        },
      },
      {
        $unwind: {
          path: '$friendshipsViewLookup',
          preserveNullAndEmptyArrays: true,
        },
      },
      { $match: { 'friendshipsViewLookup.user2': id2 } },
      {
        $project: {
          user1: 1,
          user2: '$friendshipsViewLookup.user2',
          degree: {
            $add: ['$friendshipsViewLookup.degree', 1],
          },
        },
      },
      {
        $group: {
          _id: { user1: '$user1', user2: '$user2' },
          minDegree: { $min: '$degree' },
        },
      },
      {
        $project: {
          user1: '$_id.user1',
          user2: '$_id.user2',
          degree: '$minDegree',
        },
      }

Estou trabalhando com MongoDB em um aplicativo Node.js usando Mongoose. Quando recupero um documento do banco de dados e registro o campo _id, espero que ele seja do tipo ObjectId, pois esse é o tipo padrão para _id no MongoDB. No entanto, quando registro o tipo de response._id usando typeof, ele mostra object:

console.log(typeof response._id); // Output: "object"

O valor real de response._id é algo como:

new ObjectId('66f68edc89d2d956b7a2fe7d')

Minhas perguntas são: ObjectId no MongoDB é considerado um objeto em JavaScript? O tipo de response._id não deveria ser ObjectId em vez de object? Como posso garantir que o tipo seja tratado corretamente como ObjectId no meu código TypeScript? Detalhes adicionais: Estou usando Mongoose em um ambiente Node.js. A recuperação de documentos e todo o resto funcionam bem, mas estou confuso sobre o resultado typeof.

Estou tentando copiar o registro mais recente para cada valor de número de certificado. Temos vários documentos para cada certificado e estamos tentando obter o registro mais recente para cada certificado e copiá-lo para uma nova coleção.

aqui estão os dados:

{ "_id": ..., "certnumber":"123456", "createtime": "2024-02-03T16:42:20.324Z", "company": "A" ,.....}
{ "_id": ..., "certnumber":"123456", "createtime": "2024-02-03T16:32:20.324Z", "company": "A" ,.....}
{ "_id": ..., "certnumber":"123456", "createtime": "2024-02-02T14:28:20.324Z", "company": "A" ,.....}
{ "_id": ..., "certnumber":"123456", "createtime": "2024-02-02T13:22:20.324Z", "company": "A" ,.....}
{ "_id": ..., "certnumber":"654321", "createtime": "2024-02-05T17:42:20.324Z", "company": "B" ,.....}
{ "_id": ..., "certnumber":"654321", "createtime": "2024-02-05T16:42:20.324Z", "company": "B" ,.....}
{ "_id": ..., "certnumber":"654321", "createtime": "2024-02-03T15:32:20.324Z", "company": "B" ,.....}
{ "_id": ..., "certnumber":"654321", "createtime": "2024-02-03T14:22:20.324Z", "company": "B" ,.....}

Tentei reunir os últimos registros usando o comando abaixo e funciona, mas ele retorna apenas 2 campos. Como faço para extrair o documento inteiro em vez de apenas 2 campos?

db.collectionname.aggregate(
   [
     { $sort: { certnumber: 1, createtime: 1} },
     {
       $group:
         {
           _id: {certnumber : "$certnumber" },
           updatedDate: { $last: "$createtime" }
         }
     },
   ],
)

Eu preciso excluir todas as coisas do mongoDB no meu mac.

eu segui o guia de desinstalação no guia oficial de desinstalação do mongoDB

mas na etapa 2 , que é

`launchctl unload ~/Library/LaunchAgents/homebrew.mxcl.mongodb-community.plist
rm -f ~/Library/LaunchAgents/homebrew.mxcl.mongodb-community.plist
launchctl remove homebrew.mxcl.mongodb-community`

eu recebi este erro: Unload failed: 5: Input/output error Try running "launchctl bootout" as root for richer errors.

Durante a instalação do MongoDB Community 7.0, o instalador solicita os caminhos para o banco de dados e eu os aponto para a unidade E: dedicada de 50 GB vazia, que foi criada especialmente para o MongoDB.

A próxima etapa indica que a unidade de destino C: não tem espaço suficiente. E a lista de unidades abaixo mostra C: e E:, mas E: não pode ser selecionado.

O MongoDB não pode ser instalado em nenhuma unidade diferente de C:?

Pelo que eu sei, quando criamos um índice clusterizado, ele reestrutura a tabela no formato B-Tree e usa pesquisa binária quando tentamos encontrar uma linha específica. SSTable também é classificado por chave. Por que precisamos do Sparse Index como tabela de referência para este caso? Como isso difere do B-Tree em relação à pesquisa se eles são ordenados por chave? Por que aplicar a pesquisa binária não é suficiente?

Tentei encontrar o uso exato do índice esparso e tentei entender por que ele é necessário como tabela de referência se não precisamos desse tipo de coisa para índice clusterizado e não encontrei nenhuma resposta para essa pergunta.

Estou tentando instalar dois nós do mongo, cada um localizado em um local diferente com baixa latência. A arquitetura deve ser:

• Um nó em DC e o outro nó em DR. Supõe-se que apenas um nó seja o primário por vez (nó no DC); se o DC estiver inativo, o nó no DR pode ser o mestre (pode propô-lo manualmente como primário).

• Quando o nó no DR é alterado manualmente para ser primário, posso ter tempo para trazer novamente o nó no DC, esperar que os dados sejam sincronizados com o DC e, em seguida, diminuir o nó no DR, alterar o nó no DC para ser primário novamente.

Não tenho certeza se o conjunto de réplicas pode ser aplicado a isso. Por favor me ajude com uma solução para isso.

Obrigado.