W3docs
it
Accedi

MongoDB Crea Database

Scopri come creare un database MongoDB in Python con PyMongo: connessione, creazione lazy, elenco dei database e problemi comuni.

MongoDB non crea un database finché non vengono effettivamente scritti dati al suo interno. Questo comportamento di "creazione lazy" è intenzionale ed è una delle prime cose su cui inciampano i nuovi utenti. Questo capitolo ti guida attraverso la connessione a un server MongoDB con il driver pymongo di Python, la comprensione di quando un database viene effettivamente creato, la verifica della sua esistenza e la rimozione dei database di test.

Prerequisiti

  • Python 3.8 o versione successiva installato
  • Un server MongoDB in esecuzione (locale o remoto). Se non hai ancora installato MongoDB, segui prima il capitolo MongoDB Get Started.
  • Il driver pymongo installato:
pip install pymongo

Come funziona la creazione di un database MongoDB

A differenza dei database relazionali, in MongoDB non si esegue mai un'istruzione CREATE DATABASE. Invece:

  1. Si fa riferimento a un database tramite il suo nome attraverso l'oggetto client.
  2. MongoDB mantiene quel riferimento in memoria, ma non crea nulla su disco ancora.
  3. Il database viene creato fisicamente la prima volta che si inserisce un documento o si crea esplicitamente una collezione.

Ciò significa che client["mydb"] ha sempre "successo" — restituisce un oggetto Database che mydb esista o meno.

Connessione a MongoDB

Importa MongoClient e apri una connessione. Quando MongoDB è in esecuzione sulla stessa macchina con le impostazioni predefinite (host localhost, porta 27017), puoi chiamare MongoClient() senza argomenti:

from pymongo import MongoClient

# Connect to the local MongoDB server (localhost:27017)
client = MongoClient()

Per connettersi a un server remoto o a una porta non predefinita, passa un URI di connessione:

# Generic URI form
client = MongoClient("mongodb://hostname:port")

# Example: remote host on port 27017
client = MongoClient("mongodb://db.example.com:27017")

# Example: with authentication
client = MongoClient("mongodb://username:[email protected]:27017")

MongoClient utilizza internamente un pool di connessioni — si crea un solo client per applicazione e lo si riutilizza in tutte le operazioni sul database.

Ottenere un riferimento al database

Accedi a un database tramite il nome come attributo o con la notazione a chiave dizionario:

# Both lines do exactly the same thing
db = client.my_database
db = client["my_database"]

Usa lo stile dizionario (client["name"]) quando il nome del database contiene caratteri che non sono identificatori Python validi, come i trattini.

A questo punto il database non esiste ancora sul server. Stampa l'elenco dei database del client per confermare:

print(client.list_database_names())
# Typical output: ['admin', 'config', 'local']
# 'my_database' is NOT listed yet

Creare il database inserendo un documento

Il modo più semplice per materializzare il database è inserire un documento. L'esempio seguente crea un database chiamato bookstore e una collezione chiamata books:

from pymongo import MongoClient

client = MongoClient()

db = client["bookstore"]
books = db["books"]

# Inserting the first document triggers physical database creation
result = books.insert_one({
    "title": "The Pragmatic Programmer",
    "author": "David Thomas",
    "year": 1999
})

print("Inserted document id:", result.inserted_id)
print("Databases now:", client.list_database_names())

Dopo aver eseguito questo script dovresti vedere un output simile a:

Inserted document id: 64a1e3b2c9f1234567890abc
Databases now: ['admin', 'bookstore', 'config', 'local']

bookstore compare ora nell'elenco perché al suo interno esiste almeno un documento.

Verificare se un database esiste

Poiché un database referenziato potrebbe esistere o meno, la verifica richiede di ispezionare l'elenco restituito da list_database_names():

from pymongo import MongoClient

client = MongoClient()

def database_exists(client, name):
    return name in client.list_database_names()

print(database_exists(client, "bookstore"))   # True (if created above)
print(database_exists(client, "no_such_db"))  # False

Eliminare un database di test

Quando si vuole rimuovere un database (ad esempio dopo i test), chiama drop_database() sul client:

from pymongo import MongoClient

client = MongoClient()
client.drop_database("bookstore")

print("bookstore" in client.list_database_names())  # False

Questo elimina definitivamente il database e tutte le sue collezioni e documenti. Non viene richiesta alcuna conferma.

Problemi comuni

I refusi sono silenziosi

Poiché MongoDB crea i database su richiesta, un refuso nel nome del database crea silenziosamente un secondo database invece di generare un errore:

# Intended: 'bookstore'
# Actual:   'bookstoree'  — a new empty database that never gets data
db = client["bookstoree"]

Definisci sempre i nomi dei database come costanti in cima al modulo per evitare questo problema:

DB_NAME = "bookstore"
db = client[DB_NAME]

I database vuoti sono invisibili

Se fai riferimento a un database ma non inserisci mai dati, list_database_names() non lo includerà. Questo può rendere il debug confuso — il database "esiste" come oggetto Python ma non su disco.

Gli errori di connessione emergono tardi

MongoClient() ha successo anche quando MongoDB non è in esecuzione. L'errore di connessione emerge solo quando si effettua una richiesta reale (insert, find, ecc.). Racchiudi le operazioni reali in un blocco try/except:

from pymongo import MongoClient
from pymongo.errors import ConnectionFailure

client = MongoClient(serverSelectionTimeoutMS=3000)

try:
    # This forces a real network round-trip
    client.admin.command("ping")
    print("Connected to MongoDB")
except ConnectionFailure as e:
    print("Could not connect:", e)

Esempio completo funzionante

Il seguente script autonomo dimostra tutti i passaggi trattati in questo capitolo:

from pymongo import MongoClient
from pymongo.errors import ConnectionFailure

DB_NAME = "demo_bookstore"

def main():
    client = MongoClient(serverSelectionTimeoutMS=3000)

    # Verify the connection
    try:
        client.admin.command("ping")
    except ConnectionFailure as e:
        print("MongoDB is not reachable:", e)
        return

    # Before any insert, the database does not appear in the list
    print("Before insert:", DB_NAME in client.list_database_names())

    db = client[DB_NAME]
    books = db["books"]

    # Insert a document — this creates the database
    books.insert_one({"title": "Clean Code", "author": "Robert C. Martin"})

    # Now the database is visible
    print("After insert: ", DB_NAME in client.list_database_names())
    print("Databases:    ", client.list_database_names())

    # Clean up
    client.drop_database(DB_NAME)
    print("After drop:   ", DB_NAME in client.list_database_names())

if __name__ == "__main__":
    main()

Output atteso (l'id del documento sarà diverso):

Before insert: False
After insert:  True
Databases:     ['admin', 'config', 'demo_bookstore', 'local']
After drop:    False

Prossimi passi

Was this page helpful?