Conceptos previos

⇓

  Conceptos previos

• SQL
• NO-SQL — Not Only SQL
• Clave-Valor
• Arquivo JSON: {} e []

  Escalados

Habitualmente necesario en SQL ^*

Scale up — Escalado vertical — Mellorar a máquina

Habitualmente en NO-SQL

Scale out — Escalado horizontal — Meter máquinas

  SQL — Structured Query Language

  No-SQL — Not Only SQL

Basically Available Soft State Eventually Consistent

  Características NO-SQL

• Flexibles
• Non-Relacionales
• Distribuídos
• Escalables
• Con capacidade de particionamento (Partition-Tolerant)
• Altamente dispoñibles

  Teorema de CAP

Anteriormente chamada: Conxetura de Brewer

• Consistency — Calquer lectura debe recibir como resposta a escritura máis recente ou un erro.
• Availability — Calquer petición recibe alomenos unha resposta non errónea (sen garantía da escritura máis recente).
• Partition Tolerance — O sistema segue funcionando de retrasarse ou descartarse mensaxes entre nodos da rede.

Sólo dous de tres

  SXBD NO-SQL

• BBDD columnares son útiles para gran volume de datos (Y-column).
• Rápidas en lecturas, máis lentas en escritura.

• Amazon Redshift
• MariaDB — ColumnStore
• SAP HANA
• MonetDB
• Apache Cassandra
• Redis
• DynamoDB

  Tipos de SXBD

C&P (Consistency & Partition Tolerance)

• MongoDB
• Kafka

A&P (Availability & Partition Tolerance)

• Apache Cassandra

  Apache Cassandra

  Clave-Valor

Tamén chamados arrays asociativos

  JSON

JavaScript Object Notation

                            {
                                nome: 'Juan', 
                                apelidos: 'Sánchez',
                                idade: 19,
                                titor: {
                                    nome: 'Jose Sánchez', 
                                    email: 'jose@local'
                                }, 
                                modulos: [
                                    'Big Data Aplicado',
                                    'Sistemas de Big Data',
                                    ]
                            }
                        

  Organización en MongoDB

  Equivalencias no mundo relacional?

Non hai traducción directa correcta

Asumamos esta mentira para entendernos:

• Bases de datos ⇒ Bases de Datos
• Coleccións ⇒ Táboas
• Claves ⇒ Columnas/Atributos
• Tuplas ⇒ ~"Documentos"

  Instalación de MongoDB

⇓

  Modos de funcionamento

• Standalone server: Desenvolvemento e probas.
• Replica sets: Produción. Engade redundancia e dispoñibilidade.
• Sharded clusters: Produción. Datos particionados. Alto volume de datos e operacións.

  Versións

• Community: Gratuita.
• Enterprise: Versión comercial con soporte e optimizacións. Gratuita para desenvolvemento.
• Atlas: Versión na nube. Gratuita ata 512MB.

  Clientes

mongosh

Compass

Exercicio

• Rexístrate en https://www.mongodb.com/atlas/database
• Crea unha BBDD gratuita
• Conecta dende mongosh
• Instala compass
• Conecta dende compass

  Instalación con dockers

docker run --name mongo \ 
    -e MONGO_INITDB_ROOT_USERNAME=mongoadmin \
    -e MONGO_INITDB_ROOT_PASSWORD=abc123Secret \
    -v /root/mongo:/data/db \
    -p 27017:27017 \
    mongo
                        

  Instalación desde repositorio

• https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-debian/
• https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-red-hat/

Instalación con vagrant (antigo)

1. Clonar (ou pull) repositorio: https://github.com/jfsanchez/SBD/
2. Ir ao directorio: escenarios/mongodb
3. Despregar co comando:

vagrant up

Máis información (comandos e explicacións):
https://github.com/jfsanchez/SBD/tree/main/escenarios/mongodb

  Conexión

⇓

  MongoSH — Conexión

Conectar a localhost

vagrant@ubuntu-focal:~$ mongosh [--host localhost]

Saír de mongosh

test> quit

  Conexión cunha URL

                        mongosh "mongodb+srv://host-ou-servidor/BBDD" \
                            --apiVersion 1 --username O-MEU-USUARIO

                        mongodb://usuario:contrasinal@host:27017/?authMechanism=DEFAULT

  MongoSH — Bases de Datos

Seleccionar a base de datos database1

test> use database1

Indicar a base de datos actual

database1> db

Amosar as bases de datos

database1> show dbs

Borrar BBDD actual

database1> db.dropDatabase()

  Creación explícita

Crear colección

database1> db.createCollection("laColeccionEjemplo")

Ver as coleccións

database1> show collections

Borrar a coleción

database1> db.laColeccionEjemplo.drop()

  Creación implícita

                            test> use holamundo
                            holamundo> db.holamundo.insertOne({'hola': 'mundo'})
                            holamundo> show collections
                            holamundo> show databases
                        

Unha base de datos e unha colección créanse automáticamente ao crear un documento

  CRUD: Inserción / INSERT

⇓

  Inserción de rexistros (INSERT)

                        db.estudantes.insertOne( {
                            nome: 'Juan', 
                            apelidos: 'Sánchez',
                            idade: 19,
                            titor: 'Jose Sánchez', 
                            modulos: ['Big Data Aplicado', 'Sistemas de Big Data']
	                    })
                        

                            db.estudantes.countDocuments()
                        

  INSERT (múltiple)

                        db.estudantes.insertMany([
                            {...},
                            {...}
                        ])
                        

                            db.estudantes.countDocuments()
                        

  Exercicio

                            db.docentes.insertMany( [
                                {nome: "Jose Sánchez", email: 'jose@local'},
                                {nome: "Juan Torre", email: 'juan@local'} ])
                        

  CRUD: Busca / Find

"SELECT"

⇓

  Busca de rexistros

                            db.estudantes.find()
                        

                            db.estudantes.find({})
                        

  _id: ObjectId("123456789abc")

É un campo composto por 12 bytes:

• 4 bytes: Timestamp (UNIX EPOCH).
• 3 bytes: Identificador único da máquina.
• 2 bytes: Identificador do proceso.
• 3 bytes: Campo incremental.

Ademáis:

• Obrigatorio: Se non existe, créase.
• Único.

  Límites

covid> db.coviditalia.find({})

covid> db.coviditalia.find({}).limit(3)

Por defecto mongosh limita a 20 e podemos pedir mais co comando it (iterar).

  Ordeamento de documentos

                            covid> db.coviditalia.find().sort({data:1})
                            covid> db.coviditalia.find().sort({data:-1})
                        

• 1 indica de menor a maior (< ⇒ >).
• -1 de maior a menor (> ⇒ <).

  Exercicio

                                db.estudantes.find().sort({idade: 1})
                            

                            db.estudantes.find().sort({idade:-1})
                            

  Proxeccións

Útiles para obter só algúns atributos.

Opción 1: Amosar

                            db.estudantes.find( {}, 
                                {nome: 1, 
                                apelidos: 1, 
                                idade: 1, 
                                titor: 1})
                        

Opción 2: Ocultar

                            db.estudantes.find({}, {modulos: 0})
                        

  Filtrado

• A operación find pode recibir dous parámetros:
• • db.coleción.find( {filtro}, {proxección} )
• No filtro podemos especificar varias condicións:
• • Coincidencia exacta:

    db.estudantes.find({idade:19})

  • Operador de filtrado:

    db.estudantes.find( {idade: {$lte: 19} } )

  Filtrado: $in

                            db.estudantes.find({ titor: 
                                {$in : ["Jose Sánchez", "Juan Torre"] } })
                        

  Filtrado en arrays

Tamén podemos querer filtrar por un elemento dun array, para iso empregamos .X (onde X é un índice que comeza en 0)

                            db.estudantes.find( 
                                {"modulos.0": "Sistemas de Big Data"}).pretty()
                        

  Filtrado en arrays: $elemMatch

Que conteña o módulo (exacto) sexa ou non array

                        db.estudantes.find({modulos: 'Sistemas de Aprendizaxe'})
                        

Que sexa array (ou subdocumento) e teña o elemento

                        db.estudantes.find({modulos: 
                            {$elemMatch: {$eq: 'Sistemas de Aprendizaxe'}}})
                        
                        $elemMatch admite varias condicións
                        

  Filtrado en arrays: $all

                            { : { $all: [  ,  ... ] } }
                        O array debe ter todos os elementos

Exemplo:

                            db.estudantes.find({modulos : {$all: ['Sistemas de Big Data',
                            'Big Data Aplicado',
                            'Modelos de Intelixencia Artificial',
                            'Programación de Intelixencia Artificial',
                            'Sistemas de Aprendizaxe'] }})
                        

  Operadores para filtrado

  Operadores lóxicos

AND

{ {key1: 'value1', key2: 'value2'} }

OR

                        {
                            $or: [
                                {key1: 'value1'}, {key2: 'value2'}
                            ]
                        }

  Composición de operadores

Exemplo AND+OR

                        {
                            atributo1: 'valor1',
                            $or: [
                                {atributo2: 'valor2'}, {atributo3: {$gte: valor3} }
                            ]
                        }

  Contando documentos

Opción 1: Cunha query

db.estudantes.countDocuments({QUERY}, {opcións})

Opción 2: Empregando os metadatos

db.estudantes.estimatedDocumentCount()

  Contando documentos con countDocuments

db.estudantes.countDocuments({idade: 19}, {opcións})

• limit: Cantos documentos contar como máximo.
• skip: Cantos documentos saltar antes de comezar a conta.
• hint: Un índice ou a súa especificación para acelerar a conta.
• maxTimeMS: Máximo tempo en milisegundos para a operación de conta.

Exercicio 1: Filtra os estudantes que sexan do titor Jose Sánchez e teñan máis de 20 anos

db.estudantes.find( {titor: "Jose Sánchez", idade: {$gt: 20}})

Exercicio 2: Filtra os estudantes que sexan do titor Juan Torre e teñan menos de 21 anos

db.estudantes.find( {titor: "Juan Torre", idade: {$lt: 21}})

Exercicio 3: Filtra os estudantes que sexan do titor Jose Sánchez ou teñan 23 anos ou máis anos

                            db.estudantes.find( {
                                $or: [
                                    {titor: "Jose Sánchez"}, {idade: {$gte: 23}}] })
                        

  CRUD: Actualización / UPDATE

⇓

  Método: updateOne

db.estudantes.updateOne(filtro, actualizacion, opcións)

https://www.mongodb.com/docs/manual/reference/method/db.collection.updateOne/

  Operador: $set

{$set: {...} }
                    Muda ou engade valores

Exemplo $set: Engadir curso actual

                        db.estudantes.updateOne({nome: 'Luis'},
                            {$set: {'Curso': '2022/2023'}})
                    

  Operador: $push

{$push: {...} }
                    Engade un elemento a un array (ou crea o array co elemento)

Exemplo $push: Engadir un módulo

                        db.estudantes.updateMany({nome: 'Luis'}, 
                            {$push: {'modulos': 'FOL'}})
                    

  Operador: $pop

Quita un elemento dun array por posición

                        db.estudantes.updateMany( { },
                            { $pop: { modulos: 1 } }) 
                    

• 1 ⇒ O último elemento do array.
• -1 ⇒ O primeiro elemento do array.

  Operador: $pull

Borra dun array tódolos valores que cumplen unha condición.

Sintaxe

                        { $pull: { campo1: ,
                             campo2: , ... } }
                    

Exemplo

Borra "FOL" e "Matemáticas" dos módulos.
Quita "Titor de proba" do array (se hai) de titores legais.
                        db.estudantes.updateMany(
                            { },
                            { $pull: { modulos: { 
                                $in: [ "FOL", "Matemáticas" ] },
                             titores_legais: "Titor de proba" } }
                        )
                    

  Operador: $unset

Quita un campo dos documentos.

                        db.estudantes.updateMany(
                            { },
                            { $unset: { curso_academico: "" } }
                        )
                    

  Opción: upsert

db.estudantes.updateOne(
                        {nome: 'Alumno de Proba'}, 
                        {$set: {email: 'noreply@local'}}, 
                        {upsert:true} )

  Método: findAndModify()

Evita a Race Condition típica. Actualiza e devolve o rexistro

Sumar un caso de COVID
                    use covid
                    db.coviditalia.findAndModify({
                        query: {
                        data: '2020-02-24T18:00:00',
                        stato: 'ITA',
                        codice_regione: 13,
                        denominazione_regione: 'Abruzzo',
                        codice_provincia: 66,
                        denominazione_provincia: "L'Aquila",
                        sigla_provincia: 'AQ',},
                        update: {$inc: {totale_casi: 1}},
                        create:true})
                    

  Método: updateMany()

                        use alumnado
                        db.estudantes.updateMany({},
                            {$set: {'curso_academico': '2022/2023'}})
                    

• Se updateMany falla, debemos executalo de novo para que acabe porque non desfai os cambios (rollback).
• Non cumpre o principio de illamento (os cambios son visibles a medida que se actualizan)

  Mudando documentos de sitio

                        db.colecion.replaceOne(filtro, reemplazo, opcións)
                    Útil xa que mantén o mesmo _id mudando o resto de datos dunha vez

  CRUD: Borrado / DELETE

⇓

  Borrado (DELETE)

                        db.coleccion.deleteOne/deleteMany(filtro, opcións)
                        db.collection.findOneAndDelete()
                        db.collection.bulkWrite()
                    

  Método: deleteOne()

                        db.estudantes.deleteOne({nome: 'Luis'})
                    

  Método: deleteMany()

                        db.estudantes.deleteMany({curso_academico: '2022/2023'})
                    

  Aggregate ("JOIN")

⇓

  Consultas con aggregate

A través dunha serie de procesos conectados entre si (agregation pipeline) os datos poden pasar por operacións (unha cada vez) que:

• Filtren
• Ordeen
• Agrupen
• Transformen

  Sintaxe aggregate()

                    db.colecion.aggregate( [
                        {$stage_name: { expresión } },
                        {$stage_name: { expresión } }
                    ])

  Exemplo

Da rexión 15, cantos datos ten de cada provincia?

                        db.coviditalia.aggregate( [
                            { $match: {"codice_regione": 15}},
                            { $group: { 
                                _id: "$codice_provincia", 
                                total_provincias: {$count:{}} }
                            }
                        ])
                    

  Exemplo

Da rexión 15, cantos datos ten de cada provincia?

                        db.coviditalia.aggregate( [
                            { $match: {"codice_regione": 15}},
                            { $group: { 
                                _id: "$codice_provincia", 
                                total_provincias: { $count:{} } }
                            }, 
                            { $limit: 5 }
                        ])
                    

  Operadores (hai moitos...)

• $match — Filtra os datos (sintaxe de find).
• $group — Agrupa os documentos.
• $sort — Ordea según criterio.
• $project — Campos a amosar (última fase).
• $set —
• $count —
• $out — Mete elementos resultante nunha colección nova.
• $concat —
• $lookup —
• $unwind —

  Exemplo

Amosar as claves:
data, estado, idrexion e nomerexion da rexión 15:

                        db.coviditalia.aggregate( [
                            { $match : {"codice_regione": 15}},
                            { $project : {
                                data: 1, 
                                estado: "$stato", 
                                idrexion: "$codice_regione", 
                                nomerexion: "$denominazione_regione"}}
                        ])
                    

  Operador: $out

Almacena os resultados nunha colección

                    db.coviditalia.aggregate( [
                        { $match : {"codice_regione": 15}},
                        { $project : {
                            data: 1, 
                            estado: "$stato", 
                            idrexion: "$codice_regione", 
                            nomerexion: "$denominazione_regione"}}, 
                        {$out: "rexions_en_galego"}
                    ])

  Exercicio proposto

  Boas prácticas

• Filtrar canto antes $match) para reducir o número de documentos a procesar.
• Tratar de empregar $project o máis tarde posible.
• Cando empreguemos $out, poñelo ao final.

  Subdocumentos

⇓

• Notación punto: Documentos uns dentro doutros
• Exemplos

  Transaccións

⇓

  Transacción clásica ACID

updateOne() é transacción ACID?

                        db.alumnado.updateOne(
                            {_id: 1234},
                            {
                                {$set: {
                                    nome: 'Felipe',
                                    modulos: ['FOL', 'Programación I'],
                                    titor: 'Outro profe'
                                } }
                            }
                        )
                    

Podería ser considerada ACID, posto que hay 3 actualizacións e se executan ou todas ou ningunha. Pode afectar tamén a subdocumentos.

  Ollo coas transaccións!

• Estamos a bloquear os documentos implicados. Isto aumenta a latencia e diminúe o rendemento.
• Hai que empregar transaccións só cando é absolutamente necesario.
• Por defecto unha transacción ten un tempo máximo de 1 minuto tras a primeira escritura.
• Só funcionan nos servidores configurados como «replica set» e non «standalone»

  Exemplo dunha transacción

                        const asesion = db.getMongo().startSession()
                        asesion.startTransaction()
                        const estudantesmedran=
                            asesion.getDatabase('alumnado').getCollection('estudantes')
                        estudantesmedran.updateMany({}, {$inc : {'idade': 1}})
                        asesion.commitTransaction()
                    

Preme AQUÍ e baixa o exemplo do JSON para Atlas

MongoServerError: Transaction numbers are only allowed on a replica set member or mongos. Ollo! Non existen transaccións cando mongodb está en modo «standalone».

  Transaccións

                        const asesion = db.getMongo().startSession()
                        asesion.startTransaction()
                        const ops = 
                            asesion.getDatabase('alumnado').getCollection('estudantes')
                    

Confirmar

                        asesion.commitTransaction()
                    

Rexeitar

                        asesion.abortTransaction()
                    

  Transacción en MongoDB

  Índices

⇓

  Que son os índices?

• Estruturas de datos. Almacenan unha porción dos datos da colección dunha forma fácil e moi rápida de percorrer.

Vantaxes

• Evitan ter que escanear documento a documento (collection scan).
• Engaden velocidade.
• Ordean os datos referidos ascendente o descendentemente.

  Creación dun índice

db.collection.createIndex( { name: -1 } )

• O número indica a ordenación de datos ascendente (1) ou descendente (-1).
• Créase índice por defecto na "columna" _id
• Pódense crear índices compostos (de dúas ou máis claves)

  Nome por defecto do índice

Toman o nome das claves e a dirección separados por _

Exemplo:

{nome : 1, apelidos: -1}

nome_1_apelidos-1

  Creación dun índice cun nome

db.estudantes.createIndex(
                        { apelidos: 1, expediente: -1 } ,
                        { name: "Notas e apelidos" } )
                        

Ver os índices dunha colección

db.estudantes.getIndexes()

  Tipos de índices

• Simples.
• Compostos (máis dunha clave, cada unha ordenada como se queira).
• Multiclave (asociados a un array).
• Xeoespaciais.
• De búsqueda de texto.
• Hashed.
• Clustered.

  Propiedades que poden ter

• Únicos (UNIQUE): Rexeitan valores duplicados.
• Parciais (PARTIAL): So para algúns documentos que cumplan unhas propiedades.
• Selectivos/Dispersos (Sparse): Só para os documentos que teñan a clave de índice.
• TTL: Para borrar documentos co tempo (útil en datos xerados por máquinas).
• Agochados (HIDEN): Existen pero non se empregan. Permiten avaliar o impacto de quitalos.

  Cotexo de datos (Data collation)

• Os índices dependen do idioma para a ordenación.
• Regras de acentuación, maiúsculas, minúsculas etc afectan.
• Exemplos: Idioma fracés, español ou caracteres en cirílico (ou mezcla).

  Creando índice con cotexo de idioma

db.estudantes.createIndex( {apelidos: 1},
                                {collation: {locale: "es"}} )

db.estudantes.find({apelidos: "Sánchez"})
                                .collation({locale: "es"})

db.estudantes.find({apelidos: "Sánchez"})

  Búsqueda

Índice de búsqueda.

• É unha búsqueda por relevancia.
• O índice indica como debería facerse a busca

Índice de BBDD

• Fai as consultas a esta búsqueda máis eficientes

  Índice de búsqueda

Dynamic Mapping

• Por defecto. A máis rápida de configurar.
• Empréganse tódolos campos agás: Booleans, objectIds e timestamps.
• Baseada en: Apache Lucene

  Búsquedas con Apache Lucene

                        {
                            "name": "sample_supplies-sales-dynamic",
                            "searchAnalyzer": "lucene.standard",
                            "analyzer": "lucene.standard",
                            "collectionName": "sales",
                            "database": "sample_supplies",
                            "mappings": {
                                "dynamic": true
                            }
                        }
                        

                        atlas clusters search indexes create \
                            --clusterName myAtlasClusterEDU \
                            -f /app/search_index.json
                        

  Índice Apache Lucene

                        atlas clusters search indexes list \
                            --clusterName myAtlasClusterEDU \
                            --db sample_supplies --collection sales
                        

                        mongosh -u myAtlasDBUser -p myatlas-001 \
                            $MY_ATLAS_CONNECTION_STRING/sample_supplies
                        

  Empregando índice en agregación

                            db.sales.aggregate([
                            {
                                $search: {
                                index: 'sample_supplies-sales-dynamic',
                                text: {
                                    query: 'notepad', path: { 'wildcard': '*' }
                                } } },
                                {
                                    $set: {
                                        score: { $meta: "searchScore" }
                                    }
                                }
                                ])
                        

  Índice de búsqueda

Static Indexing

  Índices de BBDD para busca de texto

Creación cun so campo

db.estudantes.createIndex({titor: "text"})

Buscar empregando o índice de búsqueda

db.estudantes.find({$text:{$search:"Sánchez"}})

  Índices compostos de busca de texto

Crear o índicedb.estudantes.createIndex({titor: "text", apelidos: "text"})

Empregalodb.estudantes.find({$text:{$search:"Sánchez"}})

  Índices ocultos

  Comportamento dos índices ocultos

• Se ten unha restrición UNIQUE, siguea aplicando.
• Se o índice é de tipo TTL, o índice aínda fai expirar os documentos.
• Son visibles en: listIndexes e db.acolleccion.getIndexes().
• Actualízanse coas operacións de escritura (siguen consumindo espacio e memoria)
• Inclúense en: db.collection.stats() e $indexStats.
• Agochar un índice ou amosar un índice agochado resetea as súas estatísticas ($indexStats).
• Agochar un índice oculto ou amosar un índice non oculto, non resetea as estatísticas.

  Restricións

• Para agochar un índice debes ter o axuste: featureCompatibilityVersion establecido a 4.4 ou maior.
• Sen embargo, unha vez agochado o índice, este permanece oculto aínda que poñas featureCompatibilityVersion a 4.2.
• Non podes agochar o índice _id.
• Non podes empregar cursos.hint() nun índice agochado.

  Crear un índice oculto

                        db.estudantes.createIndex(
                           { apelidos: 1 },
                           { hidden: true }
                        );
                        

  Agochar un índice

Consideramos que temos creado o índice así:

db.estudantes.createIndex( { apelidos: 1, nome: 1 } );

Opción 1: Co nome directamente

db.estudantes.hideIndex( "apelidos_1_nome_1" ); 

Opción 2: Especificando o índice completo

db.estudantes.hideIndex( { apelidos: 1, nome: 1 } );

  Amosar un índice oculto

db.estudantes.getIndexes()

db.estudantes.unhideIndex( { apelidos: 1, nome: 1 } );

db.estudantes.unhideIndex( "apelidos_1_nome_1" );

  explain() — Usamos índice?

                            db.coviditalia.explain().find({codice_regione: 15})
                        

• IXSCAN: Empregamos índice. Indica cal.
• COLLSCAN: Non empregamos índice ningún.
• FETCH: Os documentos lense dende a colección
• SORT: Os documentos ordénanse na memoria.

  Exercicio

                        db.coviditalia.createIndex( 
                            "data": 1, "denominazione_regione": 1 );

Exercicio 2

Crea unha colección con documentos produto. Cada produto ten nome, descrición, prezo, categoría e fabricante. Mete alomenos 10 produtos.

Crea un índice de BBDD composto que permita buscar por tódolos campos relevantes para un usuario dunha tenda online. Fai uso do índice e demostra que funciona (pon exemplos e xustifícaos).

  Miscelánea

Tamén pode ser do teu interese...

⇓

  Monitorización na web

Activar o servizo
                            db.enableFreeMonitoring()
                        

Desactivar o servizo
                            db.disableFreeMonitoring()
                        

https://www.mongodb.com/docs/mongodb-shell/free-monitoring/

  Telemetry

Desactivar telemetría
                                disableTelemetry()
                            

Activar telemetría
                                enableTelemetry()
                            

  Estatíscas interesantes

Ver estatísticas da BBDD

database1> db.stats()

Ver estatísticas da coleccion «estudantes»

                            db.estudantes.stats()
                        

  MongoDB Shell

• Variables.
• Funcións.
• Estruturas: Condicionais, iterativas (bucles).
• Outros mecanismos de control de fluxo.

  Javascript en MongoSH

                            const artigosArray =
                                ['auga', 'pan', 'leite', 'ovos'];
                            const mercaBucle=
                                (array) => array.forEach(
                                    artigo => console.log(artigo)
                                );
                            mercaBucle(artigosArray);
                        

  Modelado de datos

Novo paradigma NO-SQL

⇓

  Modelando relaciones

• Embebidas (subdocumentos)
• Por referencia (cun _id)

Máximas

• Estruturar os datos segundo consulta ou modifica a túa aplicación
• Principio: "Os datos aos que accedemos xuntos, deberían gardarse xuntos"

  Datos Embebidos

Problemas/Desvantaxes:

• Podemos crear documentos moi grandes.
• Os documentos grandes deben ser lidos completamente en memoria, o que pode afectar ao rendemento.
• Se engadimos datos e máis datos creamos o que se chama «Unbounded documents» que poden exceder o límite máximo de 16MB dun documento BSON.

  Son antipatróns no esquema:

• Documentos excesivamente grandes.
• Unbounded documents (ilimitados/sen freo).

  Datos por Referencia

• Requiren enlazado e normalización de datos.

Vantaxes:

• Evitan duplicación.
• Diminúen o tamaño dos documentos.

Desvantaxes:

• Lemos datos de varias coleccións ou varias veces [JOIN].
• Ten un impacto no rendemento: recursos extra e impacta na velocidade de lectura.