
O MongoDB é um tipo de banco de dados orientado a documentos, em vez de registros estritamente definidos e relacionamentos. Esse tipo de banco de dados foi apelidado de `NoSQL`(Not Only SQL). Um documento no MongoDb, agrupa objetos em coleções. Você pode pensar em uma coleção como uma tabela como você criaria em um banco relacional, mas a diferença é que não será forçado a definir um esquema para que possa armazenar alguma coisa.

Você pode incorporar um documento dentro de outro, o que é muito útil para os casos em que há uma relação de um para um. Em um típico banco de dados relacional, você precisa criar duas tabelas e ligá-los em conjunto com uma chave estrangeira para conseguir o mesmo resultado. NoSQL não suporta `joins`, mas se você organizar os dados corretamente, então você vai achar que você não precisa de um `join`.

Vale a pena mencionar o objetivo do MongoDB e do NoSQL não é acabar com o banco relacional. Bancos relacionais ainda são uma solução muito boa para a maioria das necessidades do mundo do desenvolvimento. Mas eles tem os seus pontos fracos, mais notadamente a necessidade de definir um esquema rígido para os seus dados, que o `NoSQL` tenta resolver.

O MongoDB tem como característica ser open source, possuir alta performance, não possuir esquemas, ser escrito em C++, multiplataforma e ser formado por um conjunto de aplicativos JSON. O mesmo foi concluído em 2009 lançando assim a primeira versão do MongoDB.

Comparação dos conceitos em SQL e MongoDB:

| SQL                          | MongoDB                         |
| ---------------------------- | ------------------------------- |
| Banco de dados (database)    | Banco de dados (database)       |
| Tabela (table)               | Coleção (colection)             |
| Linha (row)                  | documento ou documento BSON     |
| Coluna (column)              | Campo (field)                   |
| índice (index)               | índice (index)                  |
| Table joins                  | documentos embutidos e linkados |
| Chave Primária (primary key) | Chave Primária (primary key)    |

## Instalação

Para instalar o MongoDB precisamos fazer o [download](http://www.mongodb.org/downloads) no site oficial.

Para mais detalhes sobre a instalação para as plaaformas, você pode ver nos links abaixo:

- [Windows](https://docs.mongodb.org/master/tutorial/install-mongodb-on-windows/)
- [OS X](https://docs.mongodb.org/master/tutorial/install-mongodb-on-os-x/)
- [Linux](https://docs.mongodb.org/master/administration/install-on-linux/)

É necessário que esteja adicionado o caminho da pasta `bin` do mesmo no **Path** do sistema. Se não já estiver adicionado, pode fazê-lo pela interface do sistema operacional ou pelo comando:

```bash
# ex: C:\Program Files\MongoDB\Server\3.2\bin no windows
export PATH="$PATH:[caminho onde foi instalado]/bin"
```

Com isso, podemos usar o comando `mongod` de qualquer lugar. O mesmo é usado para iniciar o servidor do MongoDB. Por default o MongoDB armazena seus bancos de dados no diretório `/data/db` (Linux e OS X) e `C:\data\db` (Windows). No Windows, `C:` é a unidade onde está executando o comando, se estiver por exemplo usando uma outra unidade como `E:`, a pasta deverá estar na mesma. Portanto, se iniciar o servidor do MongoDB e não tiver essa pasta, terá um erro no terminal.

Se você quiser usar outra pasta, basta usar a flag `dbpath`, ao inciar o servidor:

```bash
# ex: mongod -dbpath=/home/tecnologia/mongodb
mongod -dbpath=[caminho da pasta]
```

## Utilização

Além de iniciar o servidor como o comando `mongod`, também temos o comando `mongo`, para termos acesso ao shell. Ao iniciar o servidor, por padrão o mongo procura por uma base de dados na porta 27107, no seu localhost.

Ao iniciar o shell, por padrão ele utilizará o banco `test`:

```bash
$ mongo
MongoDB shell version: 3.2.4
connecting to: test
```

Para selecionar ou criar uma base de dados, basta usar o comando `use [nome_da_base]`. Sempre que precisar checar em qual base está trabalhando, basta usar o comando `db`. Já para checar quais são as bases existentes, utilize o comando `show dbs` ou `show databases`.

## Inserindo

Para que a base seja criada com o comando `use`, é necessário utilizar o comando `INSERT`:

```bash
use myTest
#switched to db myTest
user = { name : 'Hemerson Vianna', description: 'Testando' }
db.users.insert(user)
#WriteResult({ "nInserted" : 1 })
```

O mesmo também pode ser feito com o comando `SAVE`:

```bash
use myTest
#switched to db myTest
user = { name : 'Hemerson Vianna', description: 'Testando' }
db.users.save(user)
#WriteResult({ "nInserted" : 1 })
```

Usamos o objeto `db`, que aponta para o banco de dados atualmente selecionado. Incluindo o documento `user` dentro da coleção `users`

### A diferença entre `insert` e `save`.

O comando `insert` apenas insere um documento. O comando `save` insere um documento, mas se o registro já tiver um `_id`, o comando faz a função de atualização.

## Consultando

Podemos consultar o que foi inserido com o comando `find` e podemos usar um filtro com o mesmo.

```bash
# O mesmo que SELECT * FROM list
db.list.find()
# { "_id" : ObjectId("571f6bdd891bf653d4cc709d"), "name" : "Hemerson Vianna", "description" : "Testando" }

# Com filtro
# O mesmo que SELECT * FROM list WHERE name="Hemerson Vianna"
db.list.find({"name": "Hemerson Vianna"})
# { "_id" : ObjectId("571f6bdd891bf653d4cc709d"), "name" : "Hemerson Vianna", "description" : "Testando" }

# Especificando os campos
# O campo _id vem por padrão
# O mesmo que SELECT _id, name FROM list
db.list.find({},{"name": 1})

# Removendo o campo _id
# O mesmo que SELECT name FROM list
db.list.find({},{"name": 1, "_id": 0})
```

Acrescentando o método `pretty()`, podemos exibir os resultados de um modo mais apresentável.

```bash
db.list.find().pretty()
```

Além do método `find()` há também o método `findOne()`, que retorna apenas o primeiro resultado da consulta.

```bash
db.list.findOne({"description": "Testando"})
```

Operadores de comparação:

- **equal** - `$eq` é o mesmo que `==`
- **greather** - `$gt` é o mesmo que `>`
- **greather than equal** - `$gte` é o mesmo que `>=`
- **less than** - `$lt` é o mesmo que `<`
- **less than equal** - `$lte` é o mesmo que `<=`
- **not equal** - `$ne` é o mesmo que `!=`
- **in** - `$in` é o mesmo que `IN()`
- **not in** - `$nin` é o mesmo que `NOT IN()`

Operadores lógicos:

- **or** - `$or` é o mesmo que `OR`
- **and** - `$and` é o mesmo que `AND`
- **not** - `$not` é o mesmo que `NOT`
- **nor** - `$nor` é o mesmo que `NOR`

Exemplos:

```bash
db.users.find({"age":{"gte":29, "lte":31}});

db.users.find({"name":{"ne":"Hemerson Vianna"}});
```

## Atualizando

Você pode usar os métodos `update()` e `save()` para atualizar documentos dentro da coleção. Sendo que, o método `update()` atualiza valores em um documento existente, enquanto o método `save()` substitui o documento existente em si pelo documento passado dentro do método `save()`.

```bash
# Update
db.list.update({name: "Hemerson Vianna"}, {$set: {description: "Testando 2"}})
```

Se não utilizar o `$set` todos os dados do usuário como, nome e descrição, serão substituidos pela descrição "Testando 2", ou seja, o `$set` faz com que seja mantido todos os dados, e alterado apenas a descrição.

```bash
# save
db.list.save({"_id" : ObjectId("571f6bdd891bf653d4cc709d"), description: "Testando 2"}})
```

## Removendo

O método `remove()` é usado para remover um documento da coleção. Este método permite 2 parâmetros. O primeiro é o critério de exclusão e o segundo é a flag `justOne`. Se a flag estiver setada como true ou 1, o método removerá apenas um documento.

```bash
# Remove o registro com o valor informado
db.list.remove({name: "Hemerson Vianna"})

# Remove todos os dados da coleção list
db.list.remove()
```

## Mais alguns comandos

- **show collections** - mostra as coleções do banco
- **db.createCollection("[nome da coleção]")** - cria uma coleção
- **db.[coleção].drop()** - deleta a coleção
- **db.dropDatabase()** - deleta o banco atual

## Conclusão

Querendo conhecer mais sobre um banco `NoSQL`, o MongoDB é uma das melhores opções. Nos próximos artigos, entraremos mais no assunto.


Começando com MongoDB


Meu primeiro contato com banco de dados, foi em 2009, e foi com o MySQL. Um SGBD (Sistema Gerenciador de Banco de Dados) relacional e orientado a objetos, que pelo nome, já dá a pista que utiliza a linguagem SQL (Structured Query Language).

Criado na Suécia e em 2008, a MySQL AB, desenvolvedora do MySQL, foi adquirida pela Sun Microsystems por US$ 1 bilhão. No dia 20 de Abril de 2009, foi anunciado que a Oracle compraria a Sun Microsystems e todos os seus produtos, incluindo o MySQL.

MySQL é robusto, multiusuário, multitarefa e inicialmente desenvolvido para projetos de pequeno e médio porte. Alguns dos grandes motivos por ser muito utlizado, é por ser **open source** e a fácil integração com o PHP incluído. Tem compatibilidade com a maioria dos sistemas operacionais, por ter sido desenvolvido em C e C++.

## Características do MySQL

Como já foi citado, compatibilidade com várias plataformas como: Windows, Linux, Unix e outros. Suporte a várias linguagens como PHP, C, C++, Java, Python, Ruby e mais. Um bom sistema de senhas criptografadas flexível e segura. Suporte a ODBC (Open Database Connectivity), padrão que define um conjunto de interfaces que permitem o uso de linguagens de programação como Visual Basic, Delphi, Visual C++, Java, entre outras capazes de utilizar estas interfaces, para ter acesso a uma vasta gama de bases de dados distintas sem a necessidade de codificar métodos de acesso especializados.

Algumas outras características:

- Excelente desempenho e estabilidade;
- Pouco exigente quanto a recursos de novos hardware;
- Facilidade no manuseio;
- Contempla a utilização de vários Storage Engines como MyISAM, InnoDB, Falcon, BDB, Archive, Federated, CSV, Solid…
- Suporta controle transacional;
- Suporta Triggers;
- Suporta Cursors (Non-Scrollable e Non-Updatable);
- Suporta Stored Procedures e Functions;
- Replicação facilmente configurável;
- Interfaces gráficas (MySQL Toolkit) de fácil utilização.

## Instalação

### Windows/ OS X

Pode ser feito via [download](https://dev.mysql.com/downloads/mysql/) do instalador no site oficial.

### Linux

No Linux, além de poder ser feito o download como no windows/OS X, podemos fazê-lo pelo comando:

```bash
# Debian/Ubuntu
apt-get install mysql-server

# Fedora/CentOS
yum install mysql-server
```

## MySQL Client

O servidor é o responsável por armazenar os dados, responder às requisições, controlar a consistência dos dados, entre outras coisas. Aém disso, precisamos da comunicação com o servidor através da SQL. Para isso, temos algumas ferramentas como: [MySQL Workbench](http://www.mysql.com/products/workbench/), [Sequel Pro](http://www.sequelpro.com/), [HeidiSQL](http://www.heidisql.com/), [phpMyAdmin](http://phpmyadmin.net/), [Toad for MySQL](http://www.quest.com/toad-for-mysql/), [MySQL-Front](http://www.mysqlfront.de/), [Neor Profile SQL](http://www.profilesql.com/) e mais.

Para os usuários que preferem a linha de comando. Podemos instalar o `mysql-client`, no Linux, via linha de comando:

```bash
# Debian/Ubuntu
apt-get install mysql-client

# Fedora/CentOS
yum install mysql-client
```

Que permite você se conectar a um servidor MySQL. Ele lhe dará a possibilidade de utilizar na linha de comando o `mysql`.

Mesmo gostando muito da linha de comando, o meu preferido e o que mais utilizo é o **Workbench**.

### Workbench

O MySQL Workbench é uma ferramenta gráfica que permite fazer modelagem de dados, desenvolvimento em SQL e administração do servidor MySQL.

O [download](https://dev.mysql.com/downloads/workbench/) pode ser feito no site oficial. Por linha de comando no linux, pode ser feito com o comando:

```bash
# Debian/Ubuntu
apt-get install mysql-workbench

# Fedora/CentOS
yum install mysql-workbench
```

## Conclusão

Para não ficar muito extenso o artigo, veremos a continuação em um próximo artigo. Onde daremos continuidade com a configuração do mesmo.


UI2CodeGo to Home Page

Database

Compartilhar

Compartilhar