MongoDB - MQL Básico
Published: 2022-10-26 17:11:08

## MQL - MongoDB Query Language

Como em qualquer outro banco de dados, a manipulação dos dados também tem suas peculiaridades no MongoDB. Todos os bancos relacionais utilizam SQL para realizar consultas, mas a principal linguagem utilizada pelo MongoDB é a [MQL - MongoDB Query Language](https://www.mongodb.com/docs/manual/crud/). A instalação do MongoDB com fim de estudos é bem simples. Para usuários [Windows](https://www.mongodb.com/try/download/community), a instalação não foge do padrão “next - next - finish”. Já para usuário [Linux](https://www.mongodb.com/docs/manual/installation/), basta adicionar o repositório e utilizar o seu gerenciador de pacotes, assim como para o [MacOS](https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-os-x/). Quando instalamos o MongoDB, o banco vem sem segurança configurada, e o acesso é bem simples: basta digitar *mongosh* no cmd/shell. Feito isso, você já pode começar seus estudos! No entanto, lembre-se, com essas configurações, o MongoDB deve ser utilizado somente para estudos. A utilização do MongoDB sem segurança habilitada, e sem um replicaset não é recomendada principalmente para ambientes produtivos! Dito isso, vamos em frente: Quando nos conectamos no banco de dados sem passar parâmetros adicionais somos direcionados para o database *test*. Nossos primeiros comandos no MongoDB são bem parecidos com o de MySQL: ***show dbs***, ***show collections*** e ***use <database>***. Aqui também podemos trabalhar alguns conceitos básicos do MongoDB. Em um *de - para*, podemos dizer o seguinte ao compararmos o MongoDB com um banco relacional:

| MongoDB | Relacional |
| --- | --- |
| Database | Database |
| Tabela | Collection |
| Linha | Documento |

Ao executar o ***show dbs*** você vai perceber que o banco de dados test - em que estamos conectados - não existe, e isso é normal para o MongoDB. O MongoDB não exige comandos do tipo DDL (Data Definition Language). Assim, para criamos um banco de dados precisamos apenas nos conectar nele, ter permissão de escrita e inserir um documento. Para fazer o teste, execute os comandos a seguir depois de se conectar ao mongo pelo mongosh:

![Criando uma collection com insertOne](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yijzvf9zvn3x4dw9eqev.png)

No primeiro comando, nos conectamos no banco db01. Logo em seguida, ao listar os bancos, vemos que somente os bancos admin, local e config existem. Logo em seguida você vai executar seu primeiro comando MQL e inserir um documento no banco db01, e após verificar os bancos existentes de novo, verá que o banco db01 agora existe. Os comandos utilizados para CRUD no MongoDB seguem o seguinte padrão: db.<namespace>.<comando>({…}). Os comandos para CRUD são os seguintes: insertOne, insertMany, findOne, find, updateOne, updateMany, deleteOne e deleteMany. Todos eles recebem pelo menos um documento como parâmetro. Destes comandos, os que terminam com *Many* permitem trabalhar com operações do tipo *bulk* - que são bem mais performáticas ao se trabalhar com grandes massas de dados. Abaixo seguem algumas peculiaridades dos comandos acima: ## insertOne e insertMany

Estes comandos gravam dados em um *namespace* (banco.coleção). Quando o namespace não existe, ele é automaticamente criado. O insertOne recebe um documento, enquanto o insertMany recebe um array de documentos.

```
//insertOne
db.test.insertOne(
    {
        'comando': 'insertOne',
        'valor': 1
    }
)

//insertMany
db.test.insertMany(
    [
        {
            'comando': 'insertMany',
            'valor': 1
        },
        {
            'comando': 'insertMany',
            'valor': 2
        }
    ]
)
```

Após executar esses comandos no seu shell, você pode executar o bloco abaixo, de finds. Nos demais comandos, vou adicionar um find sem filtros para que vocês possam visualizar tudo que está acontecendo com os documentos do banco de vocês.

## findOne e find

Com estes comandos podemos selecionar documentos de uma coleção. Ambos recebem um documento com os campos e valores que queremos usar como filtro.

```
//findOne
db.test.findOne(
    {
        'valor': 1
    }
)

//find com filtro
db.test.find(
    {
        'valor': 1
    }
)

//find sem filtros para retornar tudo de uma coleção
db.test.find()
```

## updateOne e updateMany

O updateOne e updateMany são os únicos que precisam de dois documentos para funcionar, já que o primeiro será o filtro, e o segundo contém as alterações que devem ser realizadas. É bom lembrar que se não utilizarmos operadores como o $set, o documento anterior será totalmente substituído pelo conteúdo do segundo documento que estamos enviando nos comandos de update. No exemplo abaixo utilizamos o operador $set para alterar o valor somente de um campo do documento, e não o documento todo.

```
//updateOne
db.test.updateOne(
    {
        'insertOne': 1
    },
    {
        $set: {
            'comando': 'updateOne'
        }
    }
)

//find sem filtro
db.test.find()

//updateMany
db.test.updateMany(
    {
        'comando': 'insertMany'
    },
    {
        $set: {
            'comando': 'updateMany'
        }
    }
)

//find sem filtro
db.test.find()
```

Antes de seguirmos a diante, vamos executar um aggregate (abordaremos mais detalhes sobre esse tipo de comandos em outro posto) para poder criar um cenário legal para testarmos o delete:

```
db.test.aggregate(
    [
        {
            $project: {
                _id: 0
            }
        },{
            $set: {
                'aggregate': true
            }
        },{
            $merge: {
                into: 'test',
                whenNotMatched: 'insert'
            }
        }
    ]
)

//find sem filtro
db.test.find()
```

Observe que agora você terá 6 documentos, sendo que 3 deles possuem o campo *aggregate* com o valor *true*. Agora podemos seguir!

## deleteOne e deleteMany

Por último, temos os documentos de deleção do MongoDB: deleteOne e deleteMany

```
db.test.deleteOne(
    {
        aggregate: {
            $exists: false
        },
        valor: 2
    }
)

//find sem filtro
db.test.find()

db.test.deleteMany(
    {
        aggregate: {
            $exists: true
        },
        valor: 1
    }
)

//find sem filtro
db.test.find()
```

## Extra

O MongoDB também tem mais um comando que permite realizar inserções, deleções e atualizações: o bulkWrite. Ao invés de receber um filtro, ou um array de documentos, ele recebe um array de operações. Ou seja, podemos enviar ao banco vários comandos de escrita misturados. Mas vamos deixar isso para um papo futuro.

Agora você já pode começar a treinar CRUD com MongoDB!