Anteriormente, escrevi sobre facilmente
Desenvolvimento de aplicativos Node.js e Couchbase usando o Ottoman para a ODM. Essa postagem foi apenas uma amostra do que a Ottoman pode fazer e de como você pode fazer isso.
pode ser comparado às coisas que o Mongoose pode fazer com o MongoDB.
Desta vez, vamos dar um passo adiante e ver alguns casos de uso que fazem o Ottoman brilhar.
O SDK do Node.js para o Couchbase tem muitas maneiras diferentes de trabalhar com documentos. Operações CRUD, consultas N1QL, visualizações do Couchbase, essas
são ótimas coisas para usar, mas o que acontece quando seus dados ficam realmente selvagens. Por selvagem, quero dizer que você tem documentos com referências
relacionamentos e estruturas complexas. Você poderia usar as visualizações do Couchbase e as operações CRUD, mas se os seus relacionamentos forem complexos, você terá que fazer o mesmo.
terá muito código Node.js para manipulação de dados. Você poderia usar consultas N1QL, mas, com relacionamentos complexos, você terá
para ficar com consultas enormes e complicadas com muitas junções. O que fazer?
Alguns exemplos de modelagem
Digamos que estejamos trabalhando com os seguintes modelos de documentos. Vamos supor que esse aplicativo seja algum tipo de gerenciamento de projetos
Aplicação.
Um modelo de projeto
Como estamos criando projetos, não precisaremos apenas de informações sobre o projeto em si, mas também sobre quem faz parte dele. Pegue o
seguindo o modelo otomano como exemplo:
|
1 2 3 4 5 6 7 8 9 10 |
var ProjetoMdl = otomano.modelo("Projeto", { nome: "string", descrição: "string", proprietário: { ref: "Usuário" }, usuários: [ { ref: "Usuário" } ] }); |
No modelo acima, o proprietário é um modelo otomano diferente chamado Usuário, mas o usuários é um
matriz desse Usuário modelo.
Um modelo de usuário
Com o modelo de projeto em vigor, precisamos definir o modelo de usuário no Ottoman. Ele pode ser parecido com o seguinte:
|
1 2 3 4 5 6 7 8 9 |
var UsuárioMdl = otomano.modelo("Usuário", { nome: { primeiro: "string", último: "string" }, e-mail: "string" }); |
O modelo de usuário acima é apenas um dado de string padrão. Não há referências a outros modelos, como vimos no modelo de projeto. Agora nós
precisa se preocupar em consultar esses dois modelos da melhor maneira possível.
Consulta de profundidade com otomano
Digamos que queremos consultar os projetos em nosso aplicativo. Normalmente, essa consulta seria parecida com a seguinte:
|
1 2 3 4 5 6 7 8 |
ProjetoMdl.getById("ID_HERE", função(erro, projeto) { se(erro) { retorno res.status(400).enviar(erro); } res.enviar(projeto); }); |
Os resultados dessa consulta podem ser parecidos com os seguintes:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
{ nome: "Meu projeto", descrição: "Esta é uma descrição do meu projeto", proprietário: { "_type": "usuário", "$ref": "1234" }, usuários: [ { "_type": "usuário", "$ref": "1234" }, { "_type": "usuário", "$ref": "4321" } ] } |
O que há de errado aqui? Bem, a consulta carregou apenas uma pequena quantidade de dados. Por exemplo, nenhuma das informações reais do usuário foi carregada,
apenas as referências a esses documentos do usuário.
Então, como podemos fazer uma consulta profunda dos outros documentos? Dê uma olhada nesta revisão da nossa consulta:
|
1 2 3 4 5 6 7 8 |
ProjetoMdl.getById("ID_HERE", {carregar: ["usuários"]}, função(erro, projeto) { se(erro) { retorno res.status(400).enviar(erro); } res.enviar(projeto); }); |
Observe o uso de {load: ["users"]} neste caso. Isso significa que queremos carregar todos os modelos de usuário na matriz
quando executamos nossa consulta. E se quiséssemos carregar também os documentos do proprietário? Faríamos algo como
{carregar: ["users", "owner"]} para carregá-los também.
Complicando o modelo otomano
Agora vamos alterar um pouco nosso modelo de dados. Digamos que o modelo Ottoman do nosso projeto agora tenha a seguinte aparência:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
var ProjetoMdl = otomano.modelo("Projeto", { nome: "string", descrição: "string", proprietário: { ref: "Usuário" }, comentários: [ { mensagem: "string", usuário: { ref: "Usuário" } } ] }); |
Em vez de uma matriz de modelos Ottoman, agora estamos trabalhando com uma matriz de objetos que, por acaso, contém um modelo Ottoman.
Alterando nossa consulta de otomana profunda
Com a mudança em nosso modelo de dados, vem uma mudança em nossa consulta. Não faz sentido fazer {load: ["comments"]} porque
comentários não é um modelo otomano. Não há nada para carregar. Em vez disso, temos que alterar nossa consulta para que fique assim:
|
1 2 3 4 5 6 7 8 |
ProjetoMdl.getById("ID_HERE", {carregar: ["proprietário", "comments[*].user"]}, função(erro, projeto) { se(erro) { retorno res.status(400).enviar(erro); } res.enviar(projeto); }); |
Observe o uso de comentários[*].usuário acima. Estamos carregando o modelo de usuário que existe em todos os elementos de objeto do
matriz.
Conclusão
Você acabou de ver como carregar modelos filhos em uma única consulta. Embora seja muito possível usar uma consulta N1QL, isso levaria alguns
JUNTAR declarações para realizar o trabalho. Tudo depende de sua preferência, mas se você gosta da abordagem ODM, a Ottoman
e o carregar é uma ótima opção.
Um exemplo funcional completo disso pode ser visto no projeto GitHub da compiance como
bem como em um série de webinars que eu fiz sobre desenvolvimento de pilha completa.