• Comenzi MongoDB
• Operații DML

• MongoDB: https://www.mongodb.com/try/download/community
• Mongo database tools: https://www.mongodb.com/try/download/database-tools
• MongoDB in Docker:

docker pull mongo
docker run -d -p 27017-27019:27017-27019 --name mongodb mongo:latest

Calea unde se găsesc utilitarele: C:\Program Files\mongodb*\bin, restul comenzilor sunt ca în laborator.

Dacă ați instalat tool-urile de mai sus, utilitarele se găsesc la calea C:\Program Files\MongoDB\Tools\100\bin, puteți să o includeți ca să lucrați mai ușor cu anumite comenzi.

Pentru a porni baza de date MongoDB se va folosi demonul mongod(mongod).

Procesul demon mongod poate porni cu următorii paramterii:

• --config <filename> specifică un fisier de configurare
• --port <port> pentru a specifica portul pe care asculta procesul demon, implicit 27017
• --bind_ip <hostnames|ipaddresses|Unix domain socket paths> pentru a specifica addresa de
• --dbpath <path> calea către directorul unde se vor stoca fișierele de stocare.

Exemplu utilizare mongodb

mongod --port 27018 --bind_ip 192.100.10.10 --dbpath /data

Ex. 1. - LAB Să creeze un director pe discul Student numit mongo_data. Să se pornească baza de date cu folosind ca director de stocare noul director creat. Restul valorilor rămân cele implicite.

Ex. 1. - Docker Intrați în container folosind comanda: docker exec -it mongodb bash.

Pentru a va conecta la un server MongoDB, se folosește interpretorul în linie de comandă mongo (Documentație).

Exemplu de utilizare:

# se conectează implicit la localhost pe portul 27017
mongo
 
# se conectează la hostname folosind portul implicit 217017
mongo --host hostname
 
# se conectează implicit la localhost folosind portul port
mongo --port 27017
 
# se conectează la hostname folosind portul port
mongo --host hostname:27017
 
mongo --host hostname --port 27017

Ex. 2. Conectați-vă la MongoDB.

Pentru a vedea baza de date curentă se folosește comanda db.

Pentru a vedea toate bazele de date existente se folosește comanda show dbs.

Pentru a vă conecta la o baza de date sau a crea o nouă bază de date se folosește comanda use DATABASE_NAME. În cazul în care se folosește comanda use pentru a crea o bază de date, aceasta va deveni persistentă numai dacă se crează o colecție sau se inserează o înregistrare.

Pentru a vedea toate colecțiile se folosește comanda show collections.

Puteți folosi una din următoarele metode pentru a crea o nouă colecție:

• db.createCollection(“COLLECTION_NAME”), unde COLLECTION_NAME este numele noii colecții
• inserați o înregistrare și colecția se va crea automat.

Pentru a șterge o colecție se folosește comanda db.COLLECTION_NAME.drop().

Pentru a șterge o baza de date se folosește comanda db.dropDatabase(). Trebuie să fiți conectați la baza de date (folosing use) pentru a o șterge.

Ex. 3. Creați o bază de date numită faculty care să conțină colecția students.

Pentru a adăuga date în MongoDB puteți sa folosiți una din metodele:

• Insert sau Bulk Insert (Documentație)
• mongoimport (Documentație)

Comanda Insert are următoare sintaxa

db.collection.insert(
   <document or array of documents>,
   {
     writeConcern: <document>,
     ordered: <boolean>
   }
)

Un document dintr-o colecție este în format BSON:

{
    "student": 
        {
            "firstname": "Ion", 
            "lastname": "Popescu"
        },
    "an": 4,
    "grupa": "342C3",
    "materii": 
        [
            {"nume": "BD2",  "an": 4}, 
            {"nume": "Comp", "an": 4}, 
            {"nume": "SO2",  "an": 4}
        ],
    "cunostinte": ["SQL", "Java", "PL/SQL"]
}

Pentru a insera documentul în colecția students:

db.students.insert(
{
    "student": 
        {
            "firstname": "Ion", 
            "lastname": "Popescu"
        },
    "an": 4,
    "grupa": "342C3",
    "materii": 
        [
            {"nume": "Comp", "an": 4}, 
    	    {"nume": "BD2" , "an": 4}, 
            {"nume": "SO2" , "an": 4}
        ],
    "cunostinte": ["SQL", "Java", "PL/SQL"]
}
)

Pentru a va ușura munca puteți sa va creați variabile la nivelul consolei. Dacă se dorește inserarea mai multor înregistrari, se poate declara un vector.

var stud = {"student": { "firstname": "Andrei", "lastname": "Ionescu"}, "an": 4, "grupa": "341C4", "materii": [{"nume": "BD2", "an": 4}, {"nume": "IA", "an": 4},{"nume": "IAUT", "an": 4}], "cunostinte": ["C", "C++", "SQL"] }
 
db.students.insert(stud)
 
var studs = [
    {"student": { "firstname": "George", "lastname": "Popescu"}, "an": 4, "grupa": "341C2", "materii": [{"nume": "BD2", "an": 4}, {"nume": "IOCLA", "an": 2}], "cunostinte": ["Python", "SQL"]  },
    {"student": { "firstname": "Georgiana", "lastname": "Petrescu"}, "an": 4, "grupa": "341C2", "materii": [{"nume": "BD2", "an": 4}, {"nume": "SCAD", "an": 4}], "cunostinte": ["Python", "SQL"]  },
    {"student": { "firstname": "Valentina", "lastname": "Vasilescu"}, "an": 3, "grupa": "331CA", "materii": [{"nume": "BD", "an": 3}, {"nume": "RL", "an": 3}, {"nume": "APD", "an": 2}], "cunostinte": ["Java", "C++", "SQL"] },
    {"student": { "firstname": "Grigore", "lastname": "Ionescu"}, "an": 4, "grupa": "342C2", "materii": [{"nume": "BD2", "an": 4}, {"nume": "VLSI", "an": 4}, {"nume": "SRIC", "an": 4}, {"nume": "SO", "an": 3}], "cunostinte": ["C", "Python", "SQL", "Ruby"] },
    {"student": { "firstname": "Andrei", "lastname": "Popescu"}, "an": 3, "grupa": "332CA", "materii": [{"nume": "CN1", "an": 2}, {"nume": "CN2", "an": 2}, {"nume": "RL", "an": 3}], "cunostinte": ["C", "Python", "SQL", "Ruby"] },
    {"student": { "firstname": "Ana", "lastname": "Georgescu"}, "an": 4, "grupa": "342C5", "materii": [{"nume": "BD2", "an": 4}, {"nume": "UBD", "an": 4}, {"nume": "SRIC", "an": 4}, {"nume": "SO", "an": 3}], "cunostinte": ["C", "Python", "SQL", "Ruby"], "sef": true },
]
 
db.students.insert(studs)

Ex. 4. Inserați în baza de date faculty în colecția students folosind structura JSON de mai sus doi colegi și pe dumneavoastră.

Pentru a insera un fișier în format CSV sau JSON se folosește comanda mongoimport. Parametrii comenzii sunt:

• --host=<hostname><:port> - specifică numele host-ului și portul. Dacă nu se specifică se vor lua valorile implicite
• --port=<port> - specifică portul. Dacă nu se specifică se va lua valoarea implicită
• --db=<databasename> - specifică numele bazei de date unde se vor insera datele
• --collection=<collection> - specifică numele colecției care va stoca datele
• --fields=<field1[,field2]> - specifică câmpurile din fișier care for fi inserate în colecție
• --columnsHaveTypes - se utilizează dacă se dorește specificarea tipurilor de date pentru coloanele din lista de coloane specificată cu opțiunea --fields
• --type=<json|csv|tsv> - specifică formatul fișierului cu date
• --file=<filename> - specifică numele fișierului cu date

mongoimport --host=192.100.10.2 --port=28018 --db=BD --collection=students --type=json --file=data_dump.json
 
mongoimport --host=192.100.10.2 --port=28018 --db=BD --collection=students --columnsHaveTypes --fields="name.string(),birthdate.date(2006-01-02),contacted.boolean(),followerCount.int32(),thumbnail.binary(base64)" --type=csv --file=data_dump.csv

Ex. 5. Să se insereze fișierul bd2_mongo care conține baza de date în format JSON. Noua bază de date se va numi BD2 și colecția se va numi documents.

În MongoDB operația de selecție a datelor este find() (Documentație).

Sintaxa comenzii este:

db.collection.find(query, projection)​

Unde

• query reprezintă lista de filtre
• projection reprezintă câmpurile care vor fi afișate

Dacă parametrul query lipsește, atunci se selectează toate documentele. Dacă parametrul projection lipsește atunci se afișează toate câmpurile documentului.

Comanda find() face paginație, arătând în consolă 10 înregistrări.

Să se selecteze toți studenții din colecția students, baza de date faculty

db.students.find()

db.students.findOne()

db.students.find().limit(3)

db.students.find().sort({"grupa": 1})

db.students.find().pretty()

db.students.find().sort({"student.firstname": 1}).limit(3).pretty()

Ex. 6. Să se selecteze primele 4 rezultate ale unei cereri care întoarce toți studenți ordonați descrescător după nume.

Pentru a filtra rezultatele se folosește parametru query.

Pentru comparație avem:

• : - egalitate
• $ne - diferit de (not equal)
• $gt - mai mare
• $gte - mai mare sau egal
• $lt - mai mic
• $lte - mai mic sau egal
• $in - căutare într-o listă
• $all - căutare cu egalitate pe toate elementele dintr-o listă

db.students.find({"student.firstname": "Ion"})
db.students.find({an: {$gte: 4}})
db.students.find({"materii.nume": {$in: ['SCAD', 'IA']} })
db.students.find({"grupa": /^341/ })
db.students.find({"cunostinte": {$all: [/^J/, /^C/ ]}})

Operatori logici

• $or - sau logic
• $and - și logic
• $not - negare logic

db.students.find({$or:  [{"student.lastname": "Ionescu"}, {"cunostinte": /^C/}]})
db.students.find({$and: [{"student.lastname": "Ionescu"}, {"cunostinte": /^C/}]})

Operatori utili pentru vectori

• $size pentru a verifica dimensiune
• 0, 1, 2,… pentru poziționare (indexare vectorilor începe de la 0)

db.students.find({"cunostinte": {$size: 2}})
db.students.find({"cunostinte.2": "SQL"})
db.students.find({"materii.0.nume": "BD2"})

Pentru a verifica existența unui câmp se folosește $exists

db.students.find({"sef": true})
db.students.find({"sef": {$exists: true}})
db.students.find({"sef": false})
db.students.find({"sef": {$exists: false}})

Ex. 7. Explicați ce fac cererile din acest subcapitol.

Ex. 8. Să se selecteze toți studenții din anul 4 care au restanțe și știu limbajele de programare C și SQL.

Pentru a proiecta doar anumite câmpuri se se folosește parametrul projection. În cazul în care nu se folosește filtrare se pun acolade fără goale pentru query.

db.students.find({}, {"student.firstname": 1})

O cerere cu projection va întoarce doar câmpurile specificate și _id. Dacă se dorește să se elimine câmpul _id atunci proiecția trebuie să conțină și “_id”: 0

db.students.find({}, {"_id": 0, "student.firstname": 1})

Ex. 9. Să se selecteze studenții care nu sunt șefi și au cunoștințe de “Python” pe a doua poziție din vectorul de cunoștințe. Afișați doar numele, prenumele și vectorul de cunoștințe.

Pentru a modifica datele se poate folosi una din comenzile:

• db.collection.update(<query>, <update>, <options>)​ (Documentație)

Unde:

• query - filtrează datele
• update - setează date care trebuie modificate
• options - diferite opțiuni, e.g.:
  • upsert: <boolean> - crează un nou document în cazul în care nu se găsește nici un document cu filtrul
  • multi: <boolean> - modifică mai multe documente

Pentru a seta o valoare se folosește $set:

db.students.update({"student.firstname": "George"}, {$set: {"grupa": "342C1"}})
db.students.update({an: 4, "student.firstname": "Grigore"}, {$set: {cunostinte: ["C++"]}})

Folosind $set se suprascrie valoarea pentru câmp. În cazul în care dorim sa modificăm o structură de tip vector folosiți $push. Dacă se dorește să se adauge mai multe valori, se poate folosi $push împreună cu $each.

db.students.update({an: 4, "student.firstname": "Grigore"}, {$push: {"cunostinte": "C"}})
db.students.update({an: 4, "student.firstname": "Grigore"}, {$push: {"cunostinte":{$each: ["Python", "SQL", "Ruby"]}}})

Dacă se dorește să se modifice valoare unui element dintr-o listă sau a unui câmp dintr-un document imbricat care se găsește în listă se poate folosi $. Trebuie să selectați și valoare/câmpul care se dorește să fie modificat în query:

db.students.update({"student.firstname": "Grigore", "cunostinte": "C"}, {$set: {"cunostinte.$": "Java"}})
db.students.update({"student.firstname": "Grigore", "materii.nume": "SRIC"}, {$set: {"materii.$.nume": "SPG"}})
db.students.update({"student.firstname": "Grigore", "materii.nume": "SPG"}, {$set: {"materii.$.nume": "SRIC", "materii.$.an":4}})

Ex. 10. Să se adauge la toți studenți de anul 3 materiile EGC și LFA (nume si an) folosind o singură comandă.

Alte funcții care modifică datele sunt:

• db.collection.updateOne(<query>, <update>, <options>)​
• db.collection.updateMany(<query>, <update>, <options>)​

Pentru a șterge un document dintr-o colecție se folosește comanda:

• db.collection.remove(<query>, <justOne>)​ Documentație

Unde

• query - filtrează datele
• justOne - boolean pentru a șterge unul (true) sau mai multe (false – implicit) documente

 db.students.remove({"an": {$lt: 4}})

db.students.remove({})

Alte comenzi care pot fi utilizare pentru a șterge documente dintr-o colecție sunt:

• db.collection.deleteOne(<filter>)​
• db.collection.deleteMany(<filter>)​

Ex. 11. Să se șteargă doar un student care are materia BD2.