MongoDB를 사용하지 않고 페이지를 열 수 있습니다.

오늘 나는 배웠다 — 2022년 2월 5일

MongoDB는 Kafka의 주제에 대해 MongoDB를 유용하게 사용할 수 있으며, Mongo에 대한 주제는 새로운 콜레시오나에서 사용할 수 있습니다. Quando queremos resgatar as mensagens de um tópico precisamos fazer uma busca paginada no mongo, mas e se as mensagen do tópico forem atualizadas? 예를 들어: um pagamento que estava aguardando ser Confirmado e agora foi concluído? eu vou ter duas mensagens para a mesma transação, devo trazer as duas mensagens na busca paginada ou somente quando eu for buscar o histórico do pagamento que vou querer a mensagem anterior?

De um cenário parecido com esse surgiu a necessidade de uma busca paginada no MongoDB onde eu pudesse agrupar as the mensagens pela mais lateste e fazer buscas com filtragem e ordenação.

Para começar vamos precisar criar uma Aggregation que é uma operação que processa múltiplos documentos e retorna o resultado, ele pode receber uma pipeline de operações como a documentação do mongo fornece de example:



Dentro da nossa aggregation vamos precisar de apenas um $facet na pipeline, como a documentação define um facet é uma forma de processar múltiplos processos em um único estagio da da pipeline do aggregation e também podemos definir como vai ser retornado o resultado:



Nosso facet vamos precisar de dois output fields (podem ser mais se necessário mas para o meu caso só precisioni de dois), o data, que contem os documents e o total, que vai retornar o total de documents para determinado filtro.

데이터:

O data vai ser uma pipeline que primeiramente vai conter um $group que funciona como um order by em um banco relacional, nesse group vamos dizer que

{$group: {
 _id: '$key',
 data: {$last: '$$ROOT'}
}}

o campo que ele vai usar para juntar os 문서 é o key, e ele vai inserir esses 문서 agrupados dentro do data, pegando o ultimo documento do grupo, que vai ser o mais lateste

추신: A ordem das operações importa, primeiro fazemos o grupo para que ele consiga separar o ultimo como de fato o ultimo valor a entrar no mongo

다음은 $sort 또는 $sort입니다.

{ $sort: { 'data.createdAt': 1 } },

Onde pegamos o campo createdAt do data que foi criado pelo group e dizemos se queremos ele de forma ascendente ou descendente,

1 파라 승천 e -1 파라 후손

em seguida o $skip e o $limit

{ $skip: 0},
{ $limit: 10},

O 건너뛰기 para informarmos quantos documento desejamos pular na paginação eo limit para quantos queremos trazer. Novamente a ordem é muito Importante pois se fizermos o contrario em uma collection que só tenham 2 documents e colocarmos o limit antes do skip e no skip informamos que queremos pular 1 document, o que vai acontecer é, o mongo vai buscar apenas 1 document e o 건너뛰기 vai pular ele, retornando assim zero, enquanto o comportamento esperado é ele pular o primeiro document e trazer o segundo.

세다:

{
$group: {
_id: '$key',
},

No count precisamos novamente formar o grupo para que a nossa contagem não venha com mais valores do que realmente vamos ter de dados e em seguida vamos passar um count que recebe como argumento o nome que queremos q ele devolva na query

{ $count: 'total' }

Nesse caso ele vai contar quantas entradas foram retornadas e devolver isso como um total.

No final o nosso código vai ficar mais ou menos assim, sendo que se quisermos fazer algum filtro podemos utilizar o operator de $match

 $facet: {
          data: [
            {
              $group: {
                _id: '$key',
                data: {
                  $last: '$$ROOT',
                },
              },
            },
            { $sort: { 'data.createdAt': 1 } },
            { $skip: 0 },
            { $limit: 10 },
          ],
          count: [
            {
              $group: {
                _id: '$key',
              },
            },
            { $count: 'total' },
          ],
        },

E o retorno que o mongo vai fornecer é o seguinte onde data contem o document mais lateste

PS: limit e skip não é a melhor forma de fazer uma busca paginada esse artigo explora um pouco mais esse assunto https://scalegrid.io/blog/fast-paging-with-mongodb/