Recentemente, li o artigo sobre Scotch.io sobre o uso do Mongoose e do MongoDB. Pensei comigo mesmo: ei, o Couchbase pode fazer a mesma coisa se você usar o Ottoman em vez do Mongoose.
Este artigo fará as mesmas comparações que o artigo do Scotch.io, mas usará o Ottoman e o Couchbase em vez do Mongoose e do MongoDB.
O que é otomano
O Ottoman, para o Couchbase, é um mapeador de documentos de objetos (ODM) que permite que você crie a aparência do seu modelo de objeto e, em seguida, gere automaticamente toda a lógica padrão que o acompanha.
O Ottoman nos permite acessar facilmente os comandos CRUD do Couchbase Server usando o Node.js. Para usar o Ottoman, certifique-se de adicioná-lo ao seu projeto Node.js usando o seguinte comando:
|
1 2 3 |
npm install ottoman --save |
Agora que as bibliotecas foram baixadas para o nosso projeto, precisamos incluí-las em nosso código-fonte. Isso pode ser feito adicionando o seguinte a um de seus arquivos JavaScript:
|
1 2 3 |
var ottoman = require("ottoman"); |
Com as bibliotecas do Ottoman incluídas no projeto, precisamos agora dar acesso ao Ottoman a um de nossos buckets.
|
1 2 3 |
ottoman.bucket = (new couchbase.Cluster("https://localhost:8091")).openBucket("bucket-name-here"); |
Se você já usou o SDK do Node.js para o Couchbase antes, o procedimento acima lhe parecerá familiar. Estamos apenas nos conectando a um cluster, abrindo um bucket e, em seguida, atribuindo-o ao Ottoman.
Nesse ponto, podemos começar a usar o Ottoman para acelerar nosso processo de desenvolvimento.
Definição de um modelo
Antes de começarmos a fazer operações CRUD no Couchbase, precisamos definir nosso modelo Ottoman. Esses modelos representam documentos em nosso banco de dados.
Os modelos que criamos com o Ottoman podem ter propriedades e métodos. A parte dos métodos será abordada em breve, mas, por enquanto, veja modelos simples com propriedades.
Modelo de amostra para usuários
Vamos usar o seguinte modelo para novos usuários em nosso aplicativo (sim, é simples neste exemplo).
|
1 2 3 4 5 6 7 8 |
var UserModel = ottoman.model("User", { firstname: {type: "string"}, lastname: {type: "string"}, email: {type: "string"}, created_at: {type: "Date", default: Date.now} }); |
Agora temos um modelo que pode ser usado dessa forma:
|
1 2 3 4 5 6 7 |
var myUser = new UserModel({ firstname: "Nic", lastname: "Raboy", email: "test@example.com" }); |
Definimos o primeiro nome, sobrenomee e-mailmas não precisamos definir o created_at valor. Isso ocorre porque, por padrão, se não o definirmos, ele será definido como o registro de data e hora atual.
Métodos personalizados
Digamos que queremos que um método realize uma tarefa consistente em nosso modelo. Veja o exemplo a seguir, supondo que já tenhamos criado nosso objeto UserModel simples.
|
1 2 3 4 5 |
UserModel.prototype.printWhoDaBoss = function() { console.log(this.firstname + " " + this.lastname + " is Da Boss"); } |
Em teoria, isso imprimiria o primeiro e o último nome de um determinado modelo otomano.
Exemplo de uso de métodos personalizados
Para usar um método personalizado, podemos usar o printWhoDaBoss como visto anteriormente e fazer algo parecido com isso:
|
1 2 3 4 5 6 7 8 9 |
var myUser = new UserModel({ firstname: "Nic", lastname: "Raboy", email: "test@example.com" }); myUser.printWhoDaBoss(); |
O resultado acima seria impresso Nic Raboy is Da Boss. É claro que essa função específica é inútil, mas você pode usar sua imaginação para criar algo melhor com o conceito.
Execução de uma função antes de salvar
E se quisermos executar uma tarefa antes de um documento ser salvo no Couchbase? Isso pode ser feito usando a função pré método reservado que vem com o Ottoman. Por exemplo, digamos que queremos alterar o sobrenome de todos antes de serem salvos:
|
1 2 3 4 5 6 |
UserModel.pre("save", function(next) { this.lastname = "da Boss " + this.lastname; next(); }); |
Agora, quando alguém tentar salvar um documento, o que será demonstrado na próxima seção, seu sobrenome será prefixado. Por exemplo Raboy se tornaria da Boss Raboy. Não é particularmente útil nesse caso, mas você deve ter entendido a ideia.
Criação de um documento
Para criar documentos, precisamos usar o recurso integrado salvar do Ottoman. Com nosso modelo, podemos fazer algo assim:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
var myUser = new UserModel({ firstname: "Nic", lastname: "Raboy", email: "test@example.com" }); myUser.save(function(error) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } console.log("Save successful!"); }); |
Uma chave seria gerada e o documento seria salvo no banco de dados.
Leitura de documentos NoSQL
A leitura de documentos com o Ottoman é um pouco diferente porque há diferentes tipos de leitura que podemos fazer. Vamos detalhar alguns cenários de uso.
Localização de todos os documentos
Em geral, é difícil obter documentos no NoSQL quando você não sabe o ID do documento. Sem criar uma visualização ou usar a tecnologia N1QL do Couchbase, você estaria praticamente sem sorte. Aqui está uma alternativa.
|
1 2 3 4 5 6 7 8 |
UserModel.find({}, function(error, result) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } // Do something with the resulting Ottoman models }); |
O procedimento acima encontraria todos os documentos que foram criados usando o Ottoman UserModel.
Localização de um documento específico
Aqui está outro cenário. Digamos que você não queira todos os documentos e não saiba o ID do documento. Você pode fazer uma consulta com o Ottoman expandindo o encontrar comando.
|
1 2 3 4 5 6 7 8 |
UserModel.find({lastname: "Raboy"}, function(error, result) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } // Do something with the resulting Ottoman model }); |
Localizar um documento por ID
Digamos que você saiba o ID do documento que deseja. Você pode obter o modelo Ottoman executando:
|
1 2 3 4 5 6 7 8 |
UserModel.getById("document-id-here", function(error, result) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } // Do something with the resulting Ottoman model }); |
Isso é semelhante a usar apenas o obter do SDK do Node.js, no entanto, em vez de dados JSON, você terá um modelo Ottoman totalmente funcional.
Atualização de um documento existente
A atualização de documentos com o Ottoman pode ser um pouco complicada porque você precisa primeiro carregar o documento antes de tentar fazer uma manipulação nele. O que você pode fazer é localizar o documento específico pelo ID e, em seguida, executar o comando salvar da seguinte forma:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
UserModel.getById("document-id-here", function(error, result) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } result.firstname = "Nicolas", result.save(function(error) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } }); }); |
No exemplo acima, eu teria primeiro obtido meu modelo específico, alterado apenas o primeiro nome dele e, em seguida, chamado salvar. O salvar O comando criará ou atualizará, mas cabe a você conduzi-lo até esse ponto.
Remoção de um documento
A exclusão de um documento funcionará de forma semelhante à atualização de um documento com o Ottoman. Primeiro, você deve carregar o documento fazendo uma pesquisa e, em seguida, chamando a função remover função. Um exemplo simples disso pode ser visto abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
UserModel.getById("document-id-here", function(error, result) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } result.remove(function(error) { if(error) { console.log("An error happened -> " + JSON.stringify(error)); } console.log("Document was removed!"); }); }); |
Conclusão
O Ottoman é uma excelente ferramenta ODM para o Couchbase que modela nossos objetos e funciona bem para operações do tipo CRUD. O Mongoose para MongoDB tenta ser como o Ottoman, conforme demonstrado no artigo sobre Scotch.io sobre o Mongoose e o MongoDB. O objetivo deste artigo foi mostrar como o Ottoman é tão fácil, se não mais fácil, de usar.
