Databases and Collections: Namespace Management in MongoDB

// === 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
});

// === 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）

// === 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
// }

// ✅ 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

// === 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,
//   ...
// }

// 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

// 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"
});

// === 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
});

// === 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();

// === 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

// === 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

// === 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);

// === 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

// === 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

// === 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`);
});