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 instalar otomano --salvar |
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 otomano = exigir("ottoman"); |
Com as bibliotecas do Ottoman incluídas no projeto, precisamos agora dar acesso ao Ottoman a um de nossos buckets.
|
1 2 3 |
otomano.balde = (novo couchbase.Aglomerado("http://localhost:8091")).openBucket("bucket-name-here" (nome do balde aqui)); |
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 = otomano.modelo("Usuário", { primeiro nome: {tipo: "string"}, sobrenome: {tipo: "string"}, e-mail: {tipo: "string"}, created_at: {tipo: "Data", padrão: Data.agora} }); |
Agora temos um modelo que pode ser usado dessa forma:
|
1 2 3 4 5 6 7 |
var meuUsuário = novo UserModel({ primeiro nome: "Nic", sobrenome: "Raboy", e-mail: "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.protótipo.printWhoDaBoss = função() { console.registro(este.primeiro nome + " " + este.sobrenome + " is Da Boss" (é o chefe)); } |
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 meuUsuário = novo UserModel({ primeiro nome: "Nic", sobrenome: "Raboy", e-mail: "test@example.com" }); meuUsuário.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.pré("salvar", função(próxima) { este.sobrenome = "da Boss" + este.sobrenome; próxima(); }); |
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 meuUsuário = novo UserModel({ primeiro nome: "Nic", sobrenome: "Raboy", e-mail: "test@example.com" }); meuUsuário.salvar(função(erro) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } console.registro("Salve o sucesso!"); }); |
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.encontrar({}, função(erro, resultado) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } // Faça algo com os modelos otomanos resultantes }); |
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.encontrar({sobrenome: "Raboy"}, função(erro, resultado) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } // Faça algo com o modelo otomano resultante }); |
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", função(erro, resultado) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } // Faça algo com o modelo otomano resultante }); |
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", função(erro, resultado) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } resultado.primeiro nome = "Nicolas", resultado.salvar(função(erro) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } }); }); |
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", função(erro, resultado) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } resultado.remover(função(erro) { se(erro) { console.registro("Ocorreu um erro -> " + JSON.stringify(erro)); } console.registro("O documento foi removido!"); }); }); |
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.
