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

// === Switch Databases ===
use shopdb

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

// === Delete the database(Use with caution!)===
db.dropDatabase()

// === View Database Statistics ===
db.stats()

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