Home esercizi python aggregazioni mongodb

Esercizi Aggregazione MongoDB Python

Esercizi sull’aggregazione di dati in un database MongoDB utilizzando le librerie Python pymongo e motor. Gli esercizi includono approcci sequenziali e orientati agli oggetti (OOP).

Esercizio 1: Aggregazione con pymongo (Sequenziale)

Eseguire un'aggregazione semplice per calcolare la media degli stipendi utilizzando pymongo.

from pymongo import MongoClient

def aggregate_average_salary():
    client = MongoClient('mongodb://localhost:27017/')
    db = client['testdb']
    collection = db['employees']
    pipeline = [
        {"$group": {"_id": None, "average_salary": {"$avg": "$salary"}}}
    ]
    result = collection.aggregate(pipeline)
    for doc in result:
        print("Media degli stipendi:", doc["average_salary"])
    client.close()

aggregate_average_salary()

Esercizio 2: Aggregazione con Condizione con pymongo (OOP)

Eseguire un'aggregazione con condizione per contare il numero di dipendenti in ogni dipartimento utilizzando pymongo e OOP.

from pymongo import MongoClient

class MongoDBConnection:
    def __init__(self, uri, db_name, collection_name):
        self.client = MongoClient(uri)
        self.db = self.client[db_name]
        self.collection = self.db[collection_name]

    def aggregate_count_by_department(self):
        pipeline = [
            {"$group": {"_id": "$department", "count": {"$sum": 1}}}
        ]
        result = self.collection.aggregate(pipeline)
        for doc in result:
            print("Dipartimento:", doc["_id"], "Numero di dipendenti:", doc["count"])

    def close(self):
        self.client.close()

# Uso
db_connection = MongoDBConnection('mongodb://localhost:27017/', 'testdb', 'employees')
db_connection.aggregate_count_by_department()
db_connection.close()

Esercizio 3: Aggregazione con motor (Sequenziale)

Eseguire un'aggregazione semplice per calcolare il totale delle vendite utilizzando motor.

import motor.motor_asyncio
import asyncio

async def aggregate_total_sales():
    client = motor.motor_asyncio.AsyncIOMotorClient('mongodb://localhost:27017/')
    db = client['testdb']
    collection = db['sales']
    pipeline = [
        {"$group": {"_id": None, "total_sales": {"$sum": "$amount"}}}
    ]
    async for doc in collection.aggregate(pipeline):
        print("Totale delle vendite:", doc["total_sales"])
    client.close()

# Uso
asyncio.run(aggregate_total_sales())

Esercizio 4: Aggregazione con Condizione con motor (OOP)

Eseguire un'aggregazione con condizione per contare il numero di ordini per ogni cliente utilizzando motor e OOP.

import motor.motor_asyncio
import asyncio

class MongoDBConnection:
    def __init__(self, uri, db_name, collection_name):
        self.client = motor.motor_asyncio.AsyncIOMotorClient(uri)
        self.db = self.client[db_name]
        self.collection = self.db[collection_name]

    async def aggregate_count_by_customer(self):
        pipeline = [
            {"$group": {"_id": "$customer_id", "count": {"$sum": 1}}}
        ]
        async for doc in self.collection.aggregate(pipeline):
            print("Cliente ID:", doc["_id"], "Numero di ordini:", doc["count"])

    def close(self):
        self.client.close()

# Uso
async def main():
    db_connection = MongoDBConnection('mongodb://localhost:27017/', 'testdb', 'orders')
    await db_connection.aggregate_count_by_customer()
    db_connection.close()

asyncio.run(main())

Esercizio 5: Aggregazione con Proiezione con pymongo (Sequenziale)

Eseguire un'aggregazione con proiezione per mostrare solo i campi necessari utilizzando pymongo.

from pymongo import MongoClient

def aggregate_with_projection():
    client = MongoClient('mongodb://localhost:27017/')
    db = client['testdb']
    collection = db['employees']
    pipeline = [
        {"$group": {"_id": "$department", "average_salary": {"$avg": "$salary"}}},
        {"$project": {"department": "$_id", "average_salary": 1, "_id": 0}}
    ]
    result = collection.aggregate(pipeline)
    for doc in result:
        print(doc)
    client.close()

aggregate_with_projection()

Esercizio 6: Aggregazione con Proiezione con motor (OOP)

Eseguire un'aggregazione con proiezione per mostrare solo i campi necessari utilizzando motor e OOP.

import motor.motor_asyncio
import asyncio

class MongoDBConnection:
    def __init__(self, uri, db_name, collection_name):
        self.client = motor.motor_asyncio.AsyncIOMotorClient(uri)
        self.db = self.client[db_name]
        self.collection = self.db[collection_name]

    async def aggregate_with_projection(self):
        pipeline = [
            {"$group": {"_id": "$department", "average_salary": {"$avg": "$salary"}}},
            {"$project": {"department": "$_id", "average_salary": 1, "_id": 0}}
        ]
        async for doc in self.collection.aggregate(pipeline):
            print(doc)

    def close(self):
        self.client.close()

# Uso
async def main():
    db_connection = MongoDBConnection('mongodb://localhost:27017/', 'testdb', 'employees')
    await db_connection.aggregate_with_projection()
    db_connection.close()

asyncio.run(main())

Esercizio 7: Aggregazione con Ordinamento con pymongo (Sequenziale)

Eseguire un'aggregazione con ordinamento dei risultati utilizzando pymongo.

from pymongo import MongoClient

def aggregate_with_sorting():
    client = MongoClient('mongodb://localhost:27017/')
    db = client['testdb']
    collection = db['employees']
    pipeline = [
        {"$group": {"_id": "$department", "total_salary": {"$sum": "$salary"}}},
        {"$sort": {"total_salary": -1}}
    ]
    result = collection.aggregate(pipeline)
    for doc in result:
        print(doc)
    client.close()

aggregate_with_sorting()

Esercizio 8: Aggregazione con Ordinamento con motor (OOP)

Eseguire un'aggregazione con ordinamento dei risultati utilizzando motor e OOP.

import motor.motor_asyncio
import asyncio

class MongoDBConnection:
    def __init__(self, uri, db_name, collection_name):
        self.client = motor.motor_asyncio.AsyncIOMotorClient(uri)
        self.db = self.client[db_name]
        self.collection = self.db[collection_name]

    async def aggregate_with_sorting(self):
        pipeline = [
            {"$group": {"_id": "$department", "total_salary": {"$sum": "$salary"}}},
            {"$sort": {"total_salary": -1}}
        ]
        async for doc in self.collection.aggregate(pipeline):
            print(doc)

    def close(self):
        self.client.close()

# Uso
async def main():
    db_connection = MongoDBConnection('mongodb://localhost:27017/', 'testdb', 'employees')
    await db_connection.aggregate_with_sorting()
    db_connection.close()

asyncio.run(main())