Na lição anterior,
aprendemos sobre o driver do MongoDB.
Isso permite que nosso aplicativo nó para se comunicar com um servidor MongoDB,
e também armazenar e recuperar documentos do servidor MongoDB.
Também vimos que o driver MongoDB nos fornece
muitos métodos que nos permitem criar coleções dentro de um banco de dados,
adicionar documentos às coleções
e, em seguida, executar várias operações nos documentos dentro de uma coleção.
Agora, quando os documentos são armazenados no banco de dados,
o próprio driver MongoDB não impõe nenhuma estrutura sobre os documentos.
Se precisamos ter estrutura específica para os documentos e impor essa estrutura,
então precisamos fazer uso do módulo nó Mangusto que nos permite definir
um esquema e uma estrutura para os nossos documentos que são armazenados em nosso banco de dados MongoDB,
e rigorosamente impõe a estrutura.
Vejamos mais detalhes nesta palestra e os exercícios que se seguem a esta palestra.
Como já aprendemos,
MongoDB armazena dados em coleções em um banco de dados.
Estas coleções consistem em uma coleção de documentos.
Os próprios documentos armazenados em
um banco de dados MongoDB não têm nenhuma estrutura específica imposta ao documento.
Qualquer documento pode ser armazenado em qualquer coleção.
MongoDB depende do desenvolvedor para impor a estrutura sobre os documentos,
e dá a responsabilidade completa para o desenvolvedor para se certificar de que os documentos
da estrutura correta são adicionados e mantidos nas várias coleções.
Agora, é muito fácil violar isso.
Assim, por exemplo, mesmo que você possa começar com a suposição de
que uma conexão específica terá documentos de uma determinada estrutura,
você pode facilmente inserir documentos que não necessariamente estejam em conformidade com a estrutura.
Se você é muito particular que a estrutura dos documentos em
uma coleção sempre tem uma estrutura especificada,
e sempre terá o conjunto específico de campos,
então o próprio MongoDB não impõe que nem
o nó MongoDB driver que vimos na lição anterior.
Aqui é onde vamos precisar de uma maneira mais formal de impor
estrutura sobre os documentos que são armazenados em uma coleção em um banco de dados MongoDB.
É aqui que o módulo do nó Mangusto vem em nossa ajuda.
O módulo do nó Mangusto impõe
uma estrutura padronizada para os documentos que são armazenados em uma coleção específica.
Então, é por isso que muitas vezes ouvimos pessoas se referindo a isso como o ODM Mangusto.
O próprio ODM é interpretado por algumas pessoas para significar
Modelo de Dados de Objeto ou às vezes referido como Mapeamento de Documento de Objeto,
ou algumas pessoas se referem a ele como ORM ou Mapeamento Relacional de Objeto.
Agora, quando falamos sobre relacional que se aplica muito mais a bancos de dados relacionais,
mas então com bancos de dados SQL precisávamos explicitamente do objeto para
mapeamento relacional para ser colocado entre o banco de dados e nosso próprio aplicativo.
Porque dentro do aplicativo estaríamos olhando para
objetos, mas seu armazenamento em um banco de dados SQL será na forma de registros,
e assim você precisa de um mapeamento explícito.
Como vimos com o banco de dados NoSQL,
isso não era explicitamente necessário.
Mas se você precisa impor estrutura em seus documentos que são armazenados em uma coleção
, então o uso de Mangusto para impor essa estrutura é muito, muito útil.
A maneira como Mangusto vai ao redor
impondo estrutura sobre os documentos é através do uso de esquema.
Esquema, define a estrutura de seus documentos.
Vamos falar sobre isso com um pouco mais de detalhes.
Então, o que exatamente é esquema de mangusto,
e o que ele traz para a mesa?
esquema Mangusto, implica uma estrutura sobre
os dados que é armazenado em um documento em seu banco de dados.
Então, ele define todos os campos de seu documento,
e também especifica os tipos de campos,
e também pode nos fornecer
recursos adicionais que podem habilitar a validação nesses campos.
Assim, por exemplo, os vários tipos de esquema suportados no Mangusto incluem: String,
Number, Date, Buffer, Boolean,
Misto, ID de objeto e Array.
Em particular, vamos olhar para o número de string,
e uma data, e booleano no exercício que se segue.
Vamos olhar para alguns dos outros em exercícios posteriores.
Em particular, observe o uso do tipo de esquema de matriz.
Então, um tipo de esquema de matriz permitiria que você
crie uma matriz de sub-documentos dentro do documento.
Falarei sobre isso daqui a pouco.
Depois de definir um esquema,
o esquema é usado em Mangusto para criar uma função de modelo,
e é isso que permite que você defina a estrutura para seus documentos no banco de dados.
Esquemas em si podem ter aninhamento.
Então, o que significa que você pode ter subdocumento que estão incluídos dentro de um documento.
Os subdocumentos normalmente são acomodados
através da especificação de um esquema adicional
e, em seguida, definindo um dos campos do esquema para estar fora do tipo do outro esquema.
Ou você pode até mesmo usar uma matriz de
outro tipo de esquema dentro de um segundo esquema que você definir.
Vejamos um exemplo para esclarecer alguns deles com mais detalhes.
Este exemplo será do exercício que você fará logo após esta palestra.
Antes que eu possa falar sobre esquemas e modelos em Mangusto,
vamos entender por que precisaríamos disso.
Se você tomou o angular anterior,
ou o iônico, ou o curso de script nativo,
você viu que representamos
vários dados que usamos em nossas aplicações na forma de strings JSON.
Então, em nossa aplicação, definimos uma coleção chamada como pratos.
Em uma coleção de pratos,
cada prato irá conter um certo conjunto de propriedades definidas na forma de string JSON,
como você vê neste exemplo aqui.
Então, os pratos são uma matriz de tipo prato,
e cada prato em si conterá um nome,
uma imagem, uma categoria,
um rótulo, e assim por diante.
Além disso, dentro do próprio documento prato,
você teria comentários que são armazenados como uma matriz de novamente, -
documentos JSON que contêm campos específicos passo.
Então, cada comentário, por exemplo,
contém um autor de comentário de classificação e um campo de data como você vê neste exemplo aqui.
Então, você vê que há uma estrutura clara para
cada documento que define um prato que é armazenado em nosso banco de dados.
Múltiplos pratos, obviamente, serão armazenados na forma de uma coleção em nosso banco de dados,
e podem ser agrupados e enviados como uma variedade de
pratos para o nosso aplicativo cliente a ser usado.
Agora que entendemos como isso é definido, agora,
como isso se relaciona com o esquema Mangusto e o modelo que definimos em Mangusto?
Agora, observe a estrutura de um documento típico prato aqui.
Então, isso poderia ser facilmente mapeado em um documento MongoDB em uma coleção,
talvez chamado a coleção de pratos.
Então, vemos que há uma estrutura clara para o próprio documento.
Agora, como espelhamos isso em um esquema em nosso aplicativo Mangusto?
Como você aprenderá no exercício,
veremos que definiríamos esquemas em Mangusto.
Então, o esquema é definido como um esquema Mangusto aqui.
Como exemplo, um CommentSchema é mostrado aqui.
O CommentSchema, como você pode ver,
contém três campos diferentes: a classificação, comentário
e o campo autor,
e também carimbos de data/hora aqui.
Os carimbos de data/hora permitem que você tenha dois campos diferentes no
documento: o campo criado em e o campo atualizado em,
ambos os quais são carimbos de data/hora armazenados na forma de uma string de data ISO no documento.
Agora, a classificação em si seria um valor inteiro.
Então, na terminologia Mangusto,
ele será armazenado como um número,
o tipo seria um número.
Você pode até especificar o valor mínimo e máximo.
Você também pode especificar que esse campo específico é obrigatório, portanto,
o que significa que cada documento do tipo de comentário deve conter um campo de classificação.
Da mesma forma, você também pode definir um campo de comentário,
que é do tipo string.
Então, obviamente, um comentário não é nada além de uma string que contém algumas informações,
e isso também pode ser definido como um campo obrigatório, o
que significa que cada documento deve conter um comentário,
e também um campo de autor,
que também é do tipo string.
Então, você vê que definindo este esquema neste formato.
Como aprendemos na discussão um pouco mais cedo,
esquema é definido usando os vários tipos que temos em nossa aplicação Mangusto.
Então, no esquema, novamente,
você vê três campos diferentes aqui,
classificação, comentário e autor aqui,
e cada um dos quais tem um tipo específico dado,
e então se isso é necessário ou não.
Então, assim, você está impondo uma estrutura rigorosa
sobre os documentos de comentários que serão armazenados em seu aplicativo.
Agora que definimos um esquema de comentário, podemos então,
como você notou a partir do exemplo do tipo de dados que exigimos em nossa aplicação,
temos um documento prato em si.
O documento prato contém vários campos.
Aqui, no exercício,
vamos primeiro introduzir apenas dois campos no documento prato,
o nome e a descrição.
Na próxima lição,
apresentaremos os campos restantes para o DishSchema.
Agora, então o nome,
como neste caso,
é do tipo string.
Também podemos especificar que este é um campo obrigatório, o
que significa que cada documento deve conter o campo de nome.
Também podemos especificar que o campo de nome é exclusivo, o
que significa que nenhum documento pode ter exatamente o mesmo valor de nome no documento.
Então, isso garante que cada documento terá
um campo de nome exclusivo nele e um campo de descrição,
que é novamente da cadeia de caracteres de tipo,
mas também especificado conforme necessário.
Agora, como vimos no exemplo,
um documento prato contém vários comentários incluídos dentro do documento.
Agora, em Mangusto, isso é suportado através do uso de sub-documentos.
Então, se você definir um esquema anteriormente,
então, por exemplo, já definimos um CommentSchema aqui,
você também pode definir um campo em outro esquema que você definir e, em
seguida, especificar que esse campo será
do tipo do esquema anterior que você definiu.
Então, neste caso,
o campo de comentários, eu estou definindo-o como uma matriz,
para que você veja o uso de um tipo de matriz em seu esquema que você está definindo aqui
e, em seguida, matriz do tipo CommentSchema.
Então, esta é uma série de comentários que serão incluídos em cada documento prato.
Então, assim, você pode ter
mais de um subdocumento comentário fechado dentro de um documento prato.
Então, definir a estrutura como esta nos permite suportar
a estrutura string JSON correspondente que definimos
para um documento prato ou que vimos no exemplo anteriormente.
Agora, uma vez que definimos o esquema,
para fazer uso disso em nossa aplicação,
precisamos criar um modelo a partir desse esquema que acabamos de definir.
Então, dentro da nossa aplicação,
vamos definir um modelo Mangusto e especificar que o modelo
está fora do tipo DishSchema neste exemplo.
Não só isso, você também dará um nome ao modelo aqui.
Então, quando você dá um nome para o modelo aqui,
estamos especificando o nome como prato.
Agora, quando você usa este modelo prato em
nosso aplicativo nó onde estamos fazendo uso de Mangusto,
então este será transformado e mapeado em uma coleção no meu banco de dados MongoDB.
A coleção em si será nomeada como pratos.
Então, Mangusto sabe automaticamente que quando você especificar um nome aqui,
ele irá automaticamente construir o plural
desse nome e, em seguida, dar a coleção o nome,
que é o plural do nome do modelo que você especificar neste exemplo aqui.
Então, quando eu disser prato aqui,
então Mangusto automaticamente irá mapear isso
na coleção de pratos no banco de dados MongoDB.
Como é que ele sabe converter este nome singular para um plural?
Mangusto tem automaticamente um mecanismo embutido
que lhe permite construir os plurais de palavras padrão em inglês.
Então, se você disser prato,
ele construirá pratos.
Se você diz líder, ele vai construir o plural dele como líderes, e assim por diante.
Então, isso já está embutido no módulo do nó Mangusto.
Então, é por isso que quando eu especificar isso como um tipo de modelo de prato,
então Mangusto vai construir a coleção de pratos no meu banco de dados MongoDB,
e então essa coleção de pratos irá armazenar
os vários documentos do tipo de prato lá.
Uma vez que tenhamos criado que, tipicamente,
quando declaramos modelos em nossa aplicação,
nós os armazenaríamos em uma sub-pasta denominada models, apenas por conveniência.
Você não precisa fazer isso,
mas apenas para organizar seu aplicativo,
nós normalmente armazenamos isso em uma pasta chamada models.
Em seguida, o esquema e o modelo seriam
definidos em um arquivo como este como você vê no exemplo aqui,
este chamado dishes.js, e então isso seria exportado porque este é um módulo de nó.
Isto será exportado a partir deste arquivo para que ele possa ser incluído no aplicativo nó,
onde vamos fazer uso
deste esquema e do modelo que acabamos de definir aqui.
Com este rápido entendimento de esquema e modelo e
seu uso na definição da estrutura de um documento que armazenamos em um
MongoDB, vamos voltar e entender um pouco mais sobre o que Mangusto nos fornece.
Além disso, Mangusto nos permite estabelecer a conexão com o servidor MongoDB.
Mangusto internamente fazer uso
do driver MongoDB que tínhamos usado no exercício anterior.
Então, Mangusto depende do driver MongoDB, então, o
que significa que a partir de seu aplicativo de nó baseado em Mongoose,
você pode usar todos os métodos que já estão
disponíveis a partir do driver MongoDB também se você escolher,
mas o próprio Mongoose tem sua própria coleção de métodos que
podemos fazer uso de para interagir com o banco de dados MongoDB,
como veremos no exercício que se segue.
Permitam-me que lhes mostre brevemente como estabeleceríamos uma ligação à base de dados,
e o senhor fará isso no exercício que se segue.
Então, assim como declaramos o URL no caso
do aplicativo nó MongoDB na lição anterior,
ainda vamos declarar o URL para a nossa aplicação.
Em seguida, vamos usar o método de conexão Mangusto
e fornecer a URL para o método de conexão Mongoose,
e isso irá estabelecer a conexão com o banco de dados.
Com esta rápida compreensão de Mangusto e qual o papel que o Mangusto
desempenha no suporte à inserção estruturada
, armazenamento e recuperação de documentos do nosso
Mongoose, vamos passar para o exercício onde teremos alguma experiência prática usando o módulo Mangusto.