MongoDB: Bancos de dados e coleções

Última atualização: 2026-08-26

Um banco de dados é um contêiner para coleções, e uma coleção é um contêiner para documentos — essa é a estrutura hierárquica dos dados no MongoDB.

Este curso oferece uma compreensão aprofundada dos conceitos, das convenções de nomenclatura e dos métodos de criação de bancos de dados e coleções, bem como da “coleção limitada”, que é um tipo especial de coleção.

1. O que você vai aprender

• A diferença fundamental entre bancos de dados e conjuntos (espaços de nomes)
• A filosofia de design sem esquema das coleções do MongoDB
• Convenções de nomenclatura e restrições para bancos de dados e coleções
• A diferença entre criação implícita e explícita Uso de use, show, db.createCollection()
• coleção com limite máximo (fila circular)
• Visualização de metadados da coleção e gerenciamento de banco de dados

2. Uma história real de um administrador de banco de dados

(1) Problema: Convenções de nomenclatura confusas dificultam a manutenção

Diana é administradora de banco de dados MongoDB e é responsável pelo gerenciamento do banco de dados de comércio eletrônico da empresa. Ela descobriu que:

“Temos mais de 50 bancos de dados e mais de 500 coleções, com os mais diversos nomes: shopdb.Products, shop-db.Products, shop-db.product_list… Não sabemos qual usar ao executar consultas, e nossos scripts de backup frequentemente falham.”

A situação atual caótica:

(2) MongoDB + Uma solução que utiliza convenções de nomenclatura

Estabelecer convenções de nomenclatura + validação de esquema.

// === Naming Conventions(Hump-style + Business Prefix)===

// ❌ Counterexample
db.Products              // Uppercase without a prefix
db["shop-db.product"]    // contains . and -
db.$reserved              // $ Leading reserved word

// ✅ Correct Example
db.shop_products         // Business Prefix + Business Name(Lowercase and underlined)
db.shop_orders
db.shop_users

// === Schema Verification(mongoose Centralized Management of Field Types)===
const ProductSchema = new mongoose.Schema({
  sku: { type: String, required: true },        // Clarify String Type
  price: { type: mongoose.Schema.Types.Decimal128, required: true }, // Clarify Decimal128
  createdAt: { type: Date, default: Date.now }  // Clarify Date Type
});

(3) Receita

3. Conceitos de bancos de dados

Explicação do conceito: Um banco de dados é o namespace de nível superior no MongoDB, utilizado para organizar coleções relacionadas. Cada instância do MongoDB pode conter vários bancos de dados, e cada banco de dados possui seu próprio armazenamento de arquivos, controles de permissão e espaço de indexação. Os bancos de dados estão fisicamente isolados uns dos outros, mas as consultas com $lookup não podem ser executadas entre bancos de dados.

Como funciona: O MongoDB aloca um espaço de arquivo separado para cada banco de dados (uma pasta por banco de dados no mecanismo WiredTiger). Os bancos de dados não são criados fisicamente — quando você executa use shopdb, o MongoDB simplesmente alterna de contexto; o banco de dados só é criado de fato quando os dados são gravados nele pela primeira vez. A exclusão de um banco de dados exclui fisicamente o espaço de arquivo correspondente.

graph TB
    A[MongoDB Server Examples] --> B[admin Database<br/>System Administration]
    A --> C[config Database<br/>Sharded Cluster Metadata]
    A --> D[local Database<br/>Dungeon Collection Status]
    A --> E[shopdb Business Database]
    A --> F[analyticsdb Analytical Database]

    E --> E1[users Gathering]
    E --> E2[products Gathering]
    E --> E3[orders Gathering]

    F --> F1[events Gathering]
    F --> F2[user_behavior Gathering]

    style E fill:#d4edda

graph TB
    A[MongoDB Server Examples] --> B[admin Database<br/>System Administration]
    A --> C[config Database<br/>Sharded Cluster Metadata]
    A --> D[local Database<br/>Dungeon Collection Status]
    A --> E[shopdb Business Database]
    A --> F[analyticsdb Analytical Database]

    E --> E1[users Gathering]
    E --> E2[products Gathering]
    E --> E3[orders Gathering]

    F --> F1[events Gathering]
    F --> F2[user_behavior Gathering]

    style E fill:#d4edda

(1) O que é um banco de dados?

Um banco de dados é o espaço de nomes de nível superior no MongoDB, utilizado para organizar coleções relacionadas.

graph TB
    A[MongoDB Server Examples] --> B[admin Database<br/>System Administration]
    A --> C[config Database<br/>Sharded Cluster Metadata]
    A --> D[local Database<br/>Dungeon Collection Status]
    A --> E[shopdb Business Database]
    A --> F[analyticsdb Analytical Database]

    E --> E1[users Gathering]
    E --> E2[products Gathering]
    E --> E3[orders Gathering]

    F --> F1[events Gathering]
    F --> F2[user_behavior Gathering]

    style E fill:#d4edda

graph TB
    A[MongoDB Server Examples] --> B[admin Database<br/>System Administration]
    A --> C[config Database<br/>Sharded Cluster Metadata]
    A --> D[local Database<br/>Dungeon Collection Status]
    A --> E[shopdb Business Database]
    A --> F[analyticsdb Analytical Database]

    E --> E1[users Gathering]
    E --> E2[products Gathering]
    E --> E3[orders Gathering]

    F --> F1[events Gathering]
    F --> F2[user_behavior Gathering]

    style E fill:#d4edda

(2) 4 bancos de dados do sistema

Análise dos pontos-chave:

1. admin é um banco de dados muito especial — os usuários criados na seção de administração possuem privilégios globais.
2. config Metadados do cluster de fragmentos de armazenamento (quase vazio em ambientes sem fragmentação)
3. Os dados do local não são replicados para outros nós do conjunto de réplicas — isso é adequado para armazenar dados que precisam estar disponíveis apenas localmente.
4. test é o banco de dados padrão do mongosh; seu uso deve ser evitado em ambientes de produção.

(3) Convenções de nomenclatura de bancos de dados

// === MongoDB Database Naming Conventions ===

// ✅ Valid database names
use shopdb              // Alphanumeric
use shop_db             // Underline
use "shop-db"           // Contains a hyphen(Quotation marks are required)
use "shop.2026"         // Including periods(Quotation marks are required)

// ❌ Invalid database name
use ""                  // Empty string
use "shop/db"           // Contains a slash
use "shop$db"           // $ Introduction(Although it is legal, it is not recommended)
use "admin"             // System-Reserved(Although it is available, it is not recommended)

▶ Exemplo 1: Comandos de gerenciamento de banco de dados

// === List all databases ===
show dbs
// admin       0.000GB
// config      0.000GB
// local       0.000GB
// shopdb      0.005GB
// test        0.000GB

// === Switch Databases ===
use shopdb
// switched to db shopdb

// === Display the current database ===
db
// shopdb

// === Delete the database(Use with caution!)===
db.dropDatabase()
// { "dropped" : "shopdb", "ok" : 1 }

// === View Database Statistics ===
db.stats()
// {
//   db: 'shopdb',
//   collections: 5,
//   views: 0,
//   objects: 1250,
//   avgObjSize: 245,
//   dataSize: 306250,
//   storageSize: 286720,
//   indexes: 8,
//   indexSize: 57344,
//   fileSize: 67108864,
//   nsSizeMB: 16
// }

4. O conceito de coleções

Explicação do conceito: Uma coleção é um contêiner para documentos no MongoDB, semelhante a uma “tabela” em um banco de dados relacional, mas com uma diferença fundamental — as coleções não possuem esquema, o que significa que os documentos dentro da mesma coleção podem ter combinações diferentes de campos. Essa flexibilidade é um dos principais pontos fortes do MongoDB, mas também representa um risco potencial (exigindo que a camada de aplicação ou a validação do esquema garantam a qualidade dos dados).

Como funciona: As coleções são identificadas no namespace do MongoDB como <database>.<collection>. As coleções não armazenam dados por si mesmas — os dados são armazenados como documentos BSON no espaço de arquivos da coleção, enquanto a coleção mantém apenas metadados (informações de índice, regras de validação de esquema, configurações de limite, etc.). Uma coleção é criada implicitamente quando o primeiro documento é inserido, ou pode ser criada explicitamente usando createCollection().

graph TB
    A[shopdb Database] --> B[users Gathering]
    A --> C[products Gathering]
    A --> D[orders Gathering]

    B --> B1[Document 1<br/>name: Alice<br/>age: 28]
    B --> B2[Document 2<br/>name: Bob<br/>age: 32<br/>role: admin]
    B --> B3[Document 3<br/>name: Charlie<br/>email: c@example.com]

    style B2 fill:#f8d7da

graph TB
    A[shopdb Database] --> B[users Gathering]
    A --> C[products Gathering]
    A --> D[orders Gathering]

    B --> B1[Document 1<br/>name: Alice<br/>age: 28]
    B --> B2[Document 2<br/>name: Bob<br/>age: 32<br/>role: admin]
    B --> B3[Document 3<br/>name: Charlie<br/>email: c@example.com]

    style B2 fill:#f8d7da

Pontos-chave: Uma única coleção pode ter campos diferentes (sem esquema); o Documento 1 possui um campo age, enquanto o Documento 3 possui um campo email, mas não possui o campo age. Isso demonstra a flexibilidade do MongoDB — mas também significa que é necessário usar o Mongoose Schema ou a validação de esquema para restringir os campos.

(1) O que é um conjunto?

Uma coleção é um recipiente para documentos no MongoDB, semelhante a uma “tabela” em um banco de dados relacional, mas sem restrições de esquema.

graph TB
    A[shopdb Database] --> B[users Gathering]
    A --> C[products Gathering]
    A --> D[orders Gathering]

    B --> B1[Document 1<br/>name: Alice<br/>age: 28]
    B --> B2[Document 2<br/>name: Bob<br/>age: 32<br/>role: admin]
    B --> B3[Document 3<br/>name: Charlie<br/>email: c@example.com]

    style B2 fill:#f8d7da

graph TB
    A[shopdb Database] --> B[users Gathering]
    A --> C[products Gathering]
    A --> D[orders Gathering]

    B --> B1[Document 1<br/>name: Alice<br/>age: 28]
    B --> B2[Document 2<br/>name: Bob<br/>age: 32<br/>role: admin]
    B --> B3[Document 3<br/>name: Charlie<br/>email: c@example.com]

    style B2 fill:#f8d7da

Observação: Uma única coleção pode ter campos diferentes (sem esquema); o Documento 1 possui um campo “idade”, enquanto o Documento 3 possui um campo “e-mail”, mas não possui o campo “idade”.

(2) Conjuntos x Tabelas relacionais

(3) Regras para a nomenclatura de conjuntos

// ✅ Valid collection names
db.shop_products          // Alphanumeric and underscores
db["shop-products"]       // Contains a hyphen(Quotation marks are required)
db.shop2026               // Contains numbers
db["shop.products"]       // Including periods(Quotation marks are required)

// ❌ Invalid set names
db[""]                    // Empty string
db.$reserved              // $ Introduction(Retain)
db["system.users"]        // system. Introduction(System-Reserved)
db["shop\\products"]      // Contains a backslash

▶ Exemplo 2: Comandos de gerenciamento de coleções

// === List all collections in the current database ===
show collections
// users
// products
// orders
// reviews

// === Explicitly Creating Sets ===
db.createCollection("users");
// { ok: 1 }

// === Implicit Collection Creation(Created automatically when inserted into a document)===
db.users.insertOne({ name: "Alice" });
// Automatically create the collection if it does not exist

// === Create a Fixed-Size Set(capped collection)===
db.createCollection("logs", {
  capped: true,
  size: 10485760,      // 10 MB
  max: 10000           // At most 10000 Documents
});
// { ok: 1 }

// === Delete Set ===
db.users.drop();
// true

// === View Collection Statistics ===
db.users.stats();
// {
//   ns: 'shopdb.users',
//   size: 1024,
//   count: 50,
//   avgObjSize: 20,
//   storageSize: 8192,
//   capped: false,
//   max: null,
//   ...
// }

5. Criação implícita x Criação explícita

Explicação do conceito: O MongoDB oferece dois métodos para a criação de coleções — a criação implícita (criadas automaticamente ao inserir documentos) e a criação explícita (criadas manualmente usando createCollection()). Esses dois métodos diferem significativamente em termos de experiência de desenvolvimento e segurança dos dados. A criação implícita é recomendada durante a fase de desenvolvimento (para iteração rápida), enquanto a criação explícita, combinada com a validação de esquema, é recomendada para ambientes de produção (para evitar dados incorretos).

Como funciona: Na criação implícita, o MongoDB cria automaticamente o banco de dados e a coleção durante a primeira operação de gravação, utilizando configurações padrão (sem coleção com limite de registros, sem regras de validação). Na criação explícita, é possível especificar antecipadamente regras de validação de esquema, configurações de coleção com limite de registros, regras de ordenação e muito mais, para garantir que as gravações subsequentes estejam em conformidade com as restrições de negócios.

(1) Criação implícita (recomendada para desenvolvimento)

// 1. Switch Databases(If it doesn't exist, create it later)
use shopdb;

// 2. Insert directly into the document
db.users.insertOne({ name: "Alice" });
// Automatically Create users Gathering

// 3. View Automatically Created Collections
show collections;
// users

Vantagens: Simples e rápido; não requer gerenciamento manual Desvantagens: Pode criar acidentalmente conjuntos com erros ortográficos (por exemplo, user vs. users)

(2) Criação explícita (recomendada para uso em produção)

// 1. Create an empty set(For predefined structures)
db.createCollection("users");
db.createCollection("products");
db.createCollection("orders");

// 2. Create a collection with validation(Schema Validation)
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["email", "username"],
      properties: {
        email: {
          bsonType: "string",
          pattern: "^.+@.+$"
        },
        username: {
          bsonType: "string",
          minLength: 3,
          maxLength: 30
        },
        age: {
          bsonType: "int",
          minimum: 0,
          maximum: 150
        }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
});

(3) Comparação dos dois métodos

▶ Exemplo 3: Coleção com limite máximo

// === Create capped collection(Circular Queue)===
db.createCollection("activity_logs", {
  capped: true,
  size: 10485760,        // 10 MB Upper Limit
  max: 100000            // At most 100,000 Documents
});

// === Insert Document(Once it's full, it will automatically overwrite the oldest entries.)===
for (let i = 0; i < 5; i++) {
  db.activity_logs.insertOne({
    userId: `user_${i}`,
    action: "login",
    timestamp: new Date()
  });
}

// === Search ===
db.activity_logs.find().sort({ timestamp: -1 }).limit(5);

// === Edit capped collection size ===
db.runCommand({
  collMod: "activity_logs",
  cappedSize: 20971520   // Expand to 20 MB
});

// === Convert to a regular collection(Irreversible!)===
db.runCommand({
  collMod: "activity_logs",
  cappedSize: -1
});

Casos de uso da coleção com limite:

• Sistema de registros (limpa automaticamente os registros antigos)
• Fila de mensagens (armazena as N mensagens mais recentes)
• Fluxos de dados em tempo real (cotações de ações, dados de sensores)

Situações em que isso não é apropriado:

• A documentação precisa ser atualizada (o Capped não suporta atualizações no próprio arquivo que excedam o tamanho original)
• É necessário excluir documentos específicos (o Capped não permite a exclusão seletiva)

6. Espaços de nomes de coleções

Explicação do conceito: Um namespace é o método interno do MongoDB para identificar coleções de forma exclusiva e segue o formato <database>.<collection>. Por exemplo, shopdb.users refere-se à coleção users no banco de dados shopdb. Os namespaces são utilizados pelo mecanismo de armazenamento do MongoDB para localizar dados e arquivos de índice; compreender os namespaces ajuda a entender a estrutura interna de armazenamento do MongoDB.

Como funciona: O mecanismo de armazenamento WiredTiger cria arquivos separados de dados e de índice para cada coleção, com nomes de arquivo que incluem um hash do namespace. O arquivo de namespace (arquivo .ns) armazena metadados de todas as coleções (informações de índice, regras de validação, configurações de limite, etc.). O arquivo de namespace tem 16 MB por padrão, o que limita o número de coleções que podem ser criadas em cada banco de dados.

graph TB
    A[MongoDB Namespace] --> B[Database Name.Set Name]
    B --> C[shopdb.users]
    B --> D[shopdb.products]
    B --> E[shopdb.orders]
    B --> F[analytics.events]

    style A fill:#cce5ff

graph TB
    A[MongoDB Namespace] --> B[Database Name.Set Name]
    B --> C[shopdb.users]
    B --> D[shopdb.products]
    B --> E[shopdb.orders]
    B --> F[analytics.events]

    style A fill:#cce5ff

(1) Estrutura do namespace

graph TB
    A[MongoDB Namespace] --> B[Database Name.Set Name]
    B --> C[shopdb.users]
    B --> D[shopdb.products]
    B --> E[shopdb.orders]
    B --> F[analytics.events]

    style A fill:#cce5ff

graph TB
    A[MongoDB Namespace] --> B[Database Name.Set Name]
    B --> C[shopdb.users]
    B --> D[shopdb.products]
    B --> E[shopdb.orders]
    B --> F[analytics.events]

    style A fill:#cce5ff

Espaço de nomes = <database>.<collection>; O MongoDB usa o arquivo .ns para armazenar metadados internamente.

(2) Limite de tamanho do namespace

(3) Exibir todos os namespaces

// === View the namespaces for all collections ===
db.getCollectionNames();
// [ 'users', 'products', 'orders', 'reviews', 'activity_logs' ]

// === Namespaces with prefixes ===
db.getCollectionInfos();
// [
//   { name: 'users', type: 'collection' },
//   { name: 'products', type: 'collection' },
//   ...
// ]

// === View the namespace of the collection(ns) ===
db.users.stats().ns;
// 'shopdb.users'

// === Switch Sets(For long set names)===
const productsCollection = db.getCollection("products");
productsCollection.findOne();
// equivalent to db.products.findOne();

7. Gestão de metadados de coleções

(1) Estatísticas do conjunto

// === Statistics for a Single Set ===
db.users.stats();
// {
//   ns: 'shopdb.users',        // Namespace
//   size: 10240,               // Data Size(Byte)
//   count: 250,                // Number of documents
//   avgObjSize: 40,            // Average Document Size
//   storageSize: 12288,        // Disk Usage
//   capped: false,             // Is it a fixed set?
//   max: null,                 // Maximum number of documents(capped)
//   maxSize: null,             // Maximum size(capped)
//   totalIndexSize: 16384,     // Total Index Size
//   indexSizes: {              // Index Sizes
//     _id_: 8192,
//     email_1: 4096
//   }
// }

// === Index Information for Sets ===
db.users.getIndexes();
// [
//   { v: 2, key: { _id: 1 }, name: '_id_' },
//   { v: 2, key: { email: 1 }, name: 'email_1', unique: true }
// ]

// === Aggregate Data Size(Does not include indexes)===
db.users.dataSize();
// 10240

(2) Armazenamento de informações em conjuntos

// === View the collection's WiredTiger Store Information ===
db.users.storageSize();
// 12288

// === View all namespace information for the collection ===
db.users.totalSize();
// 24576

// === Index size within the set ===
db.users.totalIndexSize();
// 16384

▶ Exemplo 4: Script de verificação do estado da coleção

// === Group Physical Exams ===
function checkCollectionHealth(collName) {
  const stats = db[collName].stats();
  const indexes = db[collName].getIndexes();

  print(`\n=== ${collName} Health Report ===`);
  print(`Number of documents: ${stats.count}`);
  print(`Data Size: ${(stats.size / 1024).toFixed(2)} KB`);
  print(`Average Document Size: ${stats.avgObjSize} bytes`);
  print(`Disk Usage: ${(stats.storageSize / 1024).toFixed(2)} KB`);
  print(`Number of Indexes: ${indexes.length}`);
  print(`Index Size: ${(stats.totalIndexSize / 1024).toFixed(2)} KB`);
  print(`Data/Disk Ratio: ${((stats.size / stats.storageSize) * 100).toFixed(1)}%`);
  print(`Is it capped: ${stats.capped ? 'Yes' : 'No'}`);

  if (stats.capped) {
    print(`capped size: ${(stats.maxSize / 1024 / 1024).toFixed(2)} MB`);
    print(`capped max docs: ${stats.max}`);
  }
}

// Check all sets
db.getCollectionNames().forEach(checkCollectionHealth);

8. Melhores práticas para bancos de dados e coleções

(1) Princípios de projeto de bancos de dados

graph TB
    A[Database Partitioning] --> B[By Business Domain<br/>shopdb / analyticsdb / logdb]
    A --> C[By Environment<br/>shopdb_dev / shopdb_staging / shopdb_prod]
    A --> D[By Tenant<br/>shopdb_tenant1 / shopdb_tenant2]

    B --> B1[✅ Recommendations]
    C --> C2[⚠️ Small and Medium-Sized Projects]
    D --> D3[⚠️ SaaS Multi-tenant]

graph TB
    A[Database Partitioning] --> B[By Business Domain<br/>shopdb / analyticsdb / logdb]
    A --> C[By Environment<br/>shopdb_dev / shopdb_staging / shopdb_prod]
    A --> D[By Tenant<br/>shopdb_tenant1 / shopdb_tenant2]

    B --> B1[✅ Recommendations]
    C --> C2[⚠️ Small and Medium-Sized Projects]
    D --> D3[⚠️ SaaS Multi-tenant]

(2) Princípios do design de cenários

(3) Controle do número de séries

▶ Exemplo 5: Estrutura do banco de dados para um projeto de comércio eletrônico

// === shopdb Database Structure ===
shopdb/
├── users              // User Information
├── user_addresses     // Shipping Address(If you need to be independent)
├── products           // Products
├── product_variants   // Product Variants(Color/Dimensions)
├── categories         // Product Categories
├── orders             // Order
├── order_items        // Order Items(If the data volume is large)
├── reviews            // Product Reviews
├── carts              // Shopping Cart
├── coupons            // Coupon
├── sessions           // User Session
└── activity_logs      // User Behavior Logs(capped collection)

// === analyticsdb Database Structure(Data Analysis)===
analyticsdb/
├── user_events        // User Events
├── page_views         // Page Views
├── conversion_data    // Conversion Funnel
└── aggregated_stats   // Aggregate Statistics

// === logdb Database Structure(Operations Logs)===
logdb/
├── app_logs           // App Logs(capped)
├── error_logs         // Error Log
└── audit_logs         // Audit Log

9. Exercício prático abrangente: inicialização do banco de dados de uma plataforma de comércio eletrônico

(1) Requisitos do cenário

Configurar um banco de dados MongoDB para uma plataforma de comércio eletrônico, incluindo:

• Entidades centrais do negócio (usuários/produtos/pedidos/avaliações)
• Coleta de logs (coleta limitada)
• Script de inicialização do banco de dados

(2) Script de inicialização

// === init-shopdb.js ===

// 1. Create a Database(Implicit)
const dbName = 'shopdb';
use(dbName);

// 2. Explicitly Creating a Core Collection(with Schema Validation)
db.createCollection('users', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['email', 'username'],
      properties: {
        email: {
          bsonType: 'string',
          pattern: '^.+@.+$'
        },
        username: {
          bsonType: 'string',
          minLength: 3,
          maxLength: 30
        },
        role: {
          enum: ['customer', 'admin', 'moderator']
        }
      }
    }
  }
});

db.createCollection('products', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['sku', 'title', 'price'],
      properties: {
        sku: {
          bsonType: 'string',
          pattern: '^[A-Z0-9-]+$'
        },
        price: {
          bsonType: 'decimal'
        }
      }
    }
  }
});

// 3. Create a Regular Set
db.createCollection('orders');
db.createCollection('reviews');
db.createCollection('carts');

// 4. Create capped collection(Log)
db.createCollection('activity_logs', {
  capped: true,
  size: 10485760,    // 10 MB
  max: 100000        // At most 10 10,000 entries
});

// 5. Create an Index
db.users.createIndex({ email: 1 }, { unique: true });
db.users.createIndex({ username: 1 }, { unique: true });
db.users.createIndex({ createdAt: -1 });

db.products.createIndex({ sku: 1 }, { unique: true });
db.products.createIndex({ category: 1, price: 1 });
db.products.createIndex({ title: 'text', description: 'text' });

db.orders.createIndex({ userId: 1, createdAt: -1 });
db.orders.createIndex({ status: 1 });

db.reviews.createIndex({ productId: 1, createdAt: -1 });
db.reviews.createIndex({ userId: 1 });

// 6. Verification Initialization
print('=== shopdb Initialization Complete ===');
print(`Number of sets: ${db.getCollectionNames().length}`);
db.getCollectionNames().forEach(name => {
  print(`  - ${name}`);
});

// 7. Perform Initialization
mongosh "mongodb://localhost:27017" init-shopdb.js

(3) Verificar a estrutura do banco de dados

// === View the database structure ===
db.adminCommand('listCollections', { db: 'shopdb' });
// {
//   cursor: {
//     firstBatch: [
//       { name: 'users', type: 'collection', info: { ... } },
//       { name: 'products', type: 'collection', info: { ... } },
//       ...
//     ]
//   }
// }

// === View Collection Statistics ===
db.getCollectionNames().forEach(name => {
  const stats = db[name].stats();
  print(`${name}: ${stats.count} docs, ${(stats.size / 1024).toFixed(2)} KB`);
});

❓ Perguntas Frequentes

P: Qual é a diferença fundamental entre uma coleção e uma tabela? R: Uma tabela está fortemente vinculada a um esquema (os tipos de campo são definidos por DDL), enquanto uma coleção não possui esquema (a mesma coleção pode ter campos diferentes). O MongoDB não valida os campos na camada do banco de dados; isso é controlado pela camada de aplicação (Mongoose) ou pela Validação de Esquema.

P: Quais são os riscos da criação implícita de coleções? R: O risco de erros de digitação (por exemplo, user versus users criaria duas coleções). Em ambientes de produção, recomendamos a criação explícita combinada com a validação do esquema para evitar dados incorretos.

P: Quais são as limitações de uma coleção com limite de tamanho? R: (1) Não é possível atualizar documentos no local para além do tamanho original do documento; (2) Não é possível excluir documentos seletivamente; (3) Não é possível fragmentar a coleção. Ela é adequada para cenários como logs e filas de mensagens.

P: Posso usar caracteres chineses nos nomes dos bancos de dados? R: É tecnicamente possível (UTF-8), mas é fortemente desaconselhado. Ferramentas de linha de comando, scripts de backup e ferramentas de terceiros oferecem suporte insuficiente a caracteres chineses, o que pode levar a desastres operacionais. Recomendamos usar exclusivamente caracteres em inglês e sublinhados.

P: Posso realizar JOINs entre bancos de dados? R: Não. O $lookup está limitado a conjuntos dentro do mesmo banco de dados. JOINs entre bancos de dados exigem várias consultas na camada de aplicação ou o uso do Atlas Data Lake.

P: É possível restaurar uma coleção depois que ela for excluída? R: Não é possível restaurá-la diretamente, a menos que você tenha um backup (mongodump) ou que a replicação do oplog esteja habilitada. Certifique-se de db.collection.findOne() verificar antes de excluir em um ambiente de produção.

P: Existe um limite para o número de bancos de dados? R: Não há limites técnicos rígidos; o número é determinado pelo tamanho do arquivo de namespace (16 MB por padrão). Em um ambiente de produção, recomendamos entre 5 e 20 bancos de dados; ter um número excessivo aumentará a complexidade do gerenciamento.

📖 Resumo

• Um banco de dados é um espaço de nomes para coleções, e uma coleção é um contêiner para documentos
• O MongoDB possui quatro bancos de dados do sistema padrão: admin, config, local e test
• Os conjuntos não seguem um esquema definido; um único conjunto pode ter campos diferentes.
• Convenção de nomenclatura: letras minúsculas + sublinhado + prefixo da empresa; evite caracteres especiais
• A criação implícita é simples, mas está sujeita a erros de digitação; a criação explícita é segura, mas é trabalhosa.
• Uma coleção com limite máximo é uma fila circular de tamanho fixo, adequada para registros e filas de mensagens.
• Estatísticas agregadas: db.collection.stats(), getIndexes(), dataSize()

📝 Exercícios

1. Questão básica (⭐): Crie um banco de dados chamado shopdb no Mongosh que contenha três coleções: users, products e orders. Liste todos os bancos de dados e coleções.

2. Questão básica (⭐): Use db.users.insertOne({...}) para criar implicitamente uma nova coleção (como “sessions”) e compreender o mecanismo de criação implícita do MongoDB.

3. Exercício avançado (⭐⭐): Crie uma coleção com limite de tamanho activity_logs (tamanho de 5 MB, máximo de 1.000), insira 100 documentos e verifique se os documentos mais antigos são sobrescritos automaticamente.

4. Exercício avançado (⭐⭐): Escreva um script de inicialização init-shopdb.js para criar a coleção users/products/orders (com validação de esquema), criar pelo menos 5 índices e criar uma coleção com limite de tamanho para logs.

5. Exercício avançado (⭐⭐): Use db.collection.stats() para inspecionar todas as coleções e escreva um script que gere um relatório em forma de tabela contendo “nome da coleção, número de documentos, tamanho dos dados, tamanho médio dos documentos e número de índices”.

6. Desafio (⭐⭐⭐): Projete um esquema de banco de dados multilocatário para SaaS (dividido em 5 bancos de dados por domínio de negócios), escreva um script de inicialização completo para criar todas as coleções, índices e validação do esquema, e gere um relatório de inicialização.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós