En la lección anterior,
aprendimos sobre el controlador MongoDB.
Esto permite a nuestra aplicación de nodo comunicarse con un servidor MongoDB,
y también almacenar y recuperar documentos del servidor MongoDB.
También vimos que el controlador MongoDB nos proporciona
muchos métodos que nos permiten crear colecciones dentro de una base de datos,
agregar documentos a las colecciones
y luego realizar varias operaciones en los documentos dentro de una colección.
Ahora, cuando los documentos se almacenan en la base de datos,
el controlador MongoDB no impone estructura a los documentos.
Si necesitamos tener una estructura específica para los documentos y hacer cumplir esa estructura,
entonces necesitamos hacer uso del módulo de nodo Mangoose que nos permite definir
un esquema y una estructura para nuestros documentos que se almacenan en nuestra base de datos MongoDB,
y aplica estrictamente la estructura.
Veamos más detalles en esta conferencia y los ejercicios que siguen a esta conferencia.
Como ya hemos aprendido,
MongoDB almacena datos en colecciones en una base de datos.
Estas colecciones consisten en una colección de documentos.
Los propios documentos almacenados en
una base de datos MongoDB no tienen una estructura específica impuesta al documento.
Cualquier documento se puede almacenar en cualquier colección.
MongoDB confía en el desarrollador para hacer cumplir la estructura de los documentos,
y le da la responsabilidad completa al desarrollador para asegurarse de que los documentos
de la estructura correcta se agregan y mantienen en las diversas colecciones.
Ahora, es muy fácil violar esto.
Así, por ejemplo, aunque puede comenzar con la suposición de
que una conexión particular tendrá documentos de cierta estructura,
puede insertar fácilmente documentos que no necesariamente cumplan con la estructura.
Si usted es muy particular que la estructura de los documentos en
una colección siempre tiene una estructura especificada,
y siempre tendrá el conjunto específico de campos,
entonces el MongoDB en sí no impone que
tampoco el controlador MongoDB nodo que hemos visto en la lección anterior.
Aquí es donde necesitaremos una forma más formal de imponer
estructura a los documentos que se almacenan en una colección en una base de datos MongoDB.
Aquí es donde el módulo de nodo de mangosta viene a nuestra ayuda.
El módulo de nodo de mangosta impone
una estructura estandarizada para los documentos que se almacenan en una colección particular. Por
lo tanto, es por eso que a menudo escuchamos a la gente referirse a esto como el ODM de la mangosta.
El ODM en sí es interpretado por algunas personas para referirse al
Modelo de Datos de Objetos o a veces referido como Object Document Mapping,
o algunas personas se refieren a él como ORM o Object Relational Mapping.
Ahora, cuando hablamos de relacional que se aplica mucho más a las bases de datos relacionales,
pero luego con las bases de datos SQL necesitábamos explícitamente el objeto al
mapeo relacional para colocarlo entre la base de datos y nuestra propia aplicación.
Porque dentro de la aplicación estaríamos buscando
objetos, pero su almacenamiento en una base de datos SQL estará en forma de registros,
por lo que necesita una asignación explícita.
Como vimos con la base de datos NoSQL,
esto no era explícitamente requerido.
Pero si necesita imponer estructura a sus documentos que se almacenan en una colección
, entonces el uso de Mangosta para imponer esta estructura es muy, muy útil.
La forma en que Mangosta va alrededor
imponiendo estructura en los documentos es a través del uso de esquema.
Esquema, define la estructura de sus documentos.
Hablemos de eso con un poco más de detalle.
Entonces, ¿qué es exactamente el esquema de mangosta
y qué trae a la mesa?
Esquema de mangosta, implica una estructura en
los datos que se almacenan en un documento en su base de datos. Por
lo tanto, define todos los campos de su documento,
y también especifica los tipos de los campos,
y también puede proporcionarnos
características adicionales que pueden habilitar la validación en estos campos.
Así, por ejemplo, los diversos tipos de esquema que se admiten en Mongoose incluyen: String,
Number, Date, Buffer, Boolean,
Mixed, Id. de objeto y Array.
En particular, vamos a ver el número de cadena,
y una fecha, y Boolean en el ejercicio que sigue.
Vamos a ver algunos de los otros en ejercicios posteriores.
En particular, observe el uso del tipo de esquema de matriz.
Por lo tanto, un tipo de esquema de matriz le permitiría
crear una matriz de sub-documentos dentro del documento.
Hablaré de eso en poco tiempo.
Una vez definido un esquema,
el esquema se utiliza en Mangosta para crear una función de modelo,
y eso es lo que permite definir la estructura de los documentos en la base de datos.
Los esquemas en sí pueden tener anidamiento.
Por lo tanto, lo que significa que puede tener un subdocumento que están encerrados dentro de un documento.
Normalmente, los subdocumentos se
acomodan mediante la especificación de un esquema adicional
y, a continuación, la definición de uno de los campos del esquema para que esté fuera del tipo del otro esquema.
O incluso puede ir con una matriz de
otro tipo de esquema dentro de un segundo esquema que defina.
Veamos un ejemplo para aclarar algunos de estos con más detalle.
Este ejemplo será del ejercicio que usted hará justo después de esta conferencia.
Antes de que pueda hablar de esquemas y modelos en Mongoose,
comprendamos por qué necesitaríamos eso.
Si ha tomado el
curso anterior angular, o el iónico, o el guión nativo,
ha visto que representamos
varios datos que utilizamos en nuestras aplicaciones en forma de cadenas JSON.
Por lo tanto, en nuestra aplicación definimos una colección llamada como platos.
En una colección de platos,
cada plato contendrá un cierto conjunto de propiedades definidas en forma de cadena JSON,
como se ve en este ejemplo aquí.
Por lo tanto, los platos son una variedad de tipo de
plato, y cada plato en sí contendrá
un nombre, una imagen,
una categoría, una etiqueta, etc.
Además, dentro del documento de plato en sí,
tendría comentarios que se almacenan como una matriz de nuevo, -
documentos JSON que contienen campos específicos paso. Por
lo tanto, cada comentario, por ejemplo,
contiene un autor de comentario de calificación y un campo de fecha como se ve en este ejemplo aquí.
Por lo tanto, usted ve que hay una estructura clara en
cada documento que define un plato que se almacena en nuestra base de datos.
Múltiples platos, obviamente, se almacenarán en forma de colección en nuestra base de datos,
y podrían ser agrupados y enviados como una variedad de
platos a nuestra aplicación cliente para ser utilizados.
Ahora que hemos entendido cómo se define esto, ahora,
¿cómo se relaciona esto con el esquema de Mangosta y el modelo que definimos en Mangosta?
Ahora, tenga en cuenta la estructura de un documento de plato típico aquí.
Por lo tanto, esto podría ser fácilmente mapeado en un documento MongoDB en una colección,
tal vez llamado la colección de platos.
Por lo tanto, vemos que hay una estructura clara en el documento mismo.
Ahora, ¿cómo reflejamos esto en un esquema en nuestra aplicación Mangoose?
Como aprenderás en el ejercicio,
veremos que definiríamos esquemas en Mangosta.
Entonces, el esquema se define como un esquema de mangosta aquí.
A modo de ejemplo, aquí se muestra un CommentSchema.
El CommentSchema, como puede ver,
contiene tres campos diferentes: la calificación, el comentario
y el campo autor,
y también marcas de hora aquí.
Las marcas de tiempo le permiten tener dos campos diferentes en
el documento: el campo creado en y el campo actualizado en,
ambos de los cuales son marcas de tiempo almacenadas en forma de cadena de fecha ISO en el documento.
Ahora, la calificación en sí sería un valor entero.
Por lo tanto, en la terminología de Mangosta,
se almacenará como un número,
el tipo sería un número.
Incluso puede especificar el valor mínimo y el máximo.
También puede especificar que este campo en particular es obligatorio, lo
que significa que cada documento del tipo de comentario debe contener un campo de calificación.
Del mismo modo, también puede definir un campo de comentario,
que es de la cadena de tipo.
Por lo tanto, obviamente, un comentario no es más que una cadena que contiene cierta información,
y esto también se puede definir como un campo obligatorio,
lo que significa que cada documento debe contener un comentario,
y también un campo de autor,
que también es de la cadena de tipo.
Por lo tanto, se ve que definiendo este esquema en este formato.
Como aprendimos en la discusión un poco antes,
esquema se define mediante el uso de los diversos tipos que tenemos en nuestra aplicación Mangoose.
Por lo tanto, en el esquema, de nuevo,
se ven tres campos diferentes aquí,
calificación, comentario y autor aquí,
y cada uno de los cuales tiene un tipo específico dado,
y luego si esto es obligatorio o no. Por
lo tanto, está imponiendo una estructura estricta
en los documentos de comentarios que se almacenarán en su aplicación.
Ahora que hemos definido un esquema de comentarios, podemos entonces,
como notó en el ejemplo del tipo de datos que necesitamos en nuestra aplicación,
tenemos un documento de plato en sí.
El documento del plato contiene varios campos.
Aquí, en el ejercicio,
primero introduciremos solo dos campos en el documento del plato,
el nombre y la descripción.
En la siguiente lección,
vamos a introducir los campos restantes para el DishSchema.
Ahora, entonces el nombre,
como en este caso,
es del tipo string.
También podemos especificar que se trata de un campo obligatorio,
lo que significa que cada documento debe contener el campo de nombre.
También podemos especificar que el campo de nombre es único,
lo que significa que no hay dos documentos que tengan exactamente el mismo valor de nombre en el documento.
Por lo tanto, eso asegura que cada documento tendrá
un campo de nombre único en él y un campo de descripción,
que es de nuevo de la cadena de tipo,
pero también especificado según sea necesario.
Ahora, como vimos en el ejemplo,
un documento de plato contiene varios comentarios encerrados dentro del documento.
Ahora, en Mangosta, esto es apoyado por el uso de sub-documentos. Por
lo tanto, si define un esquema anteriormente,
por ejemplo, ya hemos definido aquí un CommentSchema,
también puede definir un campo en otro esquema que defina y, a
continuación, especificar que ese campo será
del tipo del esquema anterior que haya definido.
Entonces, en este caso,
el campo de comentarios, lo estoy definiendo como una matriz,
por lo que ve el uso de un tipo de matriz en su esquema que está definiendo aquí,
y luego matriz del tipo CommentSchema.
Por lo tanto, esta es una serie de comentarios que se incluirán en cada documento de plato. Por
lo tanto, puede tener
más de un subdocumento de comentario adjunto dentro de un documento de plato.
Por lo tanto, definir la estructura como esta nos permite apoyar
la estructura de cadena JSON correspondiente que hemos definido
para un documento de plato o que hemos visto en el ejemplo anterior.
Ahora, una vez que definamos el esquema,
para hacer uso de esto en nuestra aplicación,
necesitamos crear un modelo a partir de ese esquema que acabamos de definir.
Por lo tanto, dentro de nuestra aplicación,
vamos a definir un modelo de mangosta y especificar que el modelo
está fuera del tipo dishSchema en este ejemplo.
No solo eso, también le dará un nombre al modelo aquí.
Por lo tanto, cuando le das un nombre al modelo aquí,
estamos especificando el nombre como plato.
Ahora, cuando use este modelo de plato en
nuestra aplicación de nodo donde estamos haciendo uso de Mangoose,
entonces esto se transformará y mapeará en una colección en mi base de datos MongoDB.
La colección en sí será nombrada como platos.
Por lo tanto, Mongoose sabe automáticamente que cuando especifica un nombre aquí,
construirá automáticamente el plural
de ese nombre y luego le dará a la colección el nombre,
que es el plural del nombre del modelo que especifique en este ejemplo aquí.
Entonces, cuando digo plato aquí,
entonces Mongoose automáticamente asignará esto a la
colección de platos en la base de datos de MongoDB.
¿ Cómo sabe convertir este nombre singular en plural?
Mangoose tiene automáticamente un mecanismo incorporado que
le permite construir los plurales de palabras estándar en inglés.
Entonces, si dices plato,
construirá platos.
Si dices líder, construirá el plural de él como líderes, y así sucesivamente.
Por lo tanto, esto ya está integrado en el módulo de nodo de mangosta.
Entonces, es por eso que cuando especifico esto como un tipo de modelo de plato,
entonces Mangoose construirá la colección de platos en mi base de datos MongoDB,
y luego esa colección de platos almacenará
los diversos documentos del tipo de plato allí.
Una vez que hemos creado eso, normalmente,
cuando declaramos modelos en nuestra aplicación,
los almacenaríamos en una subcarpeta llamada modelos, sólo por conveniencia.
No es necesario hacer eso,
pero solo para organizar su aplicación,
normalmente lo almacenaríamos en una carpeta llamada modelos.
Entonces el esquema y el modelo se
definirían en un archivo como este como se ve en el ejemplo aquí,
esto llamado dishes.js, y luego esto se exportaría porque se trata de un módulo de nodo.
Esto se exportará desde este archivo para que pueda ser incluido en la aplicación de nodo,
donde vamos a hacer uso de
este esquema y del modelo que acabamos de definir aquí.
Con esta rápida comprensión del esquema y el modelo y
su uso en la definición de la estructura de un documento que almacenamos en un MongoDB,
vamos a volver atrás y entender un poco más acerca de lo que Mangoose proporciona para nosotros.
Además, Mangoose nos permite establecer la conexión con el servidor MongoDB.
Mangosta hace uso internamente
del controlador MongoDB que habíamos utilizado en el ejercicio anterior.
Por lo tanto, Mangoose depende del controlador MongoDB, por lo
que, lo que significa que desde su aplicación de nodo basada en Mongoose,
puede usar todos los métodos que ya están
disponibles desde el controlador MongoDB también si lo desea,
pero Mangoose tiene su propia colección de métodos que
podemos hacer de para interactuar con la base de datos MongoDB,
como veremos en el ejercicio que sigue.
Permítanme mostrarles brevemente cómo estableceríamos una conexión con la base de datos,
y lo harán en el ejercicio que sigue.
Por lo tanto, al igual que declaramos la URL en
el caso de la aplicación del nodo MongoDB en la lección anterior,
todavía declararemos la URL de nuestra aplicación.
Luego usaremos el método de conexión de mangosta
y proporcionaremos la URL para el método de conexión de mangosta,
y esto establecerá la conexión a la base de datos.
Con esta rápida comprensión de Mangosta y el papel que
juega Mangoose en el apoyo a la inserción estructurada
, el almacenamiento y la recuperación de documentos de nuestro MongoDB,
pasemos al ejercicio donde
obtendremos alguna experiencia práctica usando el módulo Mangoose.