0Pricing
MongoDB Academy · レッスン

コレクションと SQL テーブルの比較

MongoDB のコレクションとリレーショナルテーブルを比較し、柔軟なスキーマがデータ設計をどのように変えるかを理解します。

「コレクションと SQL テーブルの比較」はCoddyKit上の無料MongoDB Academyレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはMongoDB Academy学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 MongoDB Academyコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Tables vs Collections at a Glance

SQL's basic unit is the table, where every row has identical columns. MongoDB's is the collection — a group of documents that can each differ.

Fixed Schema: The SQL Way

SQL needs a fixed schema defined before any data goes in, and changing it later can rebuild the whole table. Rigid, but predictable and storage-efficient.

-- SQL table: schema defined upfront, rigid
CREATE TABLE users (
  id         SERIAL PRIMARY KEY,
  name       VARCHAR(100) NOT NULL,
  email      VARCHAR(200) UNIQUE NOT NULL,
  age        INT,
  created_at TIMESTAMP DEFAULT NOW()
);
-- Every row must have exactly these columns

Flexible Schema: The MongoDB Way

A MongoDB collection appears the moment you insert — no schema needed. This flexible schema is great for prototyping, but your code must handle missing fields.

// No schema definition needed - collection created on first insert
db.users.insertOne({ name: 'Alice', email: 'alice@test.com', age: 30 });

// Next insert can have completely different fields
db.users.insertOne({ name: 'Bob', email: 'bob@test.com', company: 'Acme', role: 'admin' });

// Both documents live in the same 'users' collection

Schema vs Schema-Less: The Trade-Off

Neither wins outright. Fixed schemas guard against bad data; flexible ones let you move fast. MongoDB's JSON Schema validation gives you optional middle ground.

Normalization vs Denormalization

SQL favors normalization — splitting data across tables. MongoDB favors denormalization — embedding related data together, so you read it all in one go without JOINs.

// SQL normalized: address in separate table
// SELECT u.name, a.city FROM users u JOIN addresses a ON a.user_id = u.id

// MongoDB denormalized: address embedded in user document
{
  _id: ObjectId('...'),
  name: 'Alice',
  address: { city: 'London', zip: 'EC1A' }   // no JOIN needed
}

Creating Collections Explicitly

Collections appear automatically, but createCollection lets you set options up front — like a capped collection for logs or a validator. The code shows one.

// Create a capped collection explicitly
db.createCollection('appLogs', {
  capped: true,
  size: 10485760,   // 10 MB maximum size
  max: 50000        // optional: max 50,000 documents
});
// When full, oldest documents are automatically removed

Listing and Dropping Collections

A few handy commands list, count, and drop collections. To empty one without deleting it, use deleteMany — there's no TRUNCATE in MongoDB. The code shows them.

// Useful collection management commands in mongosh
db.getCollectionNames();
// ['users', 'orders', 'products']

db.users.countDocuments({});
// 4823

db.users.stats().storageSize;
// 2097152 (bytes)

// Delete all documents but keep the collection:
db.users.deleteMany({});
// { acknowledged: true, deletedCount: 4823 }

The _id Field and Primary Keys

Every collection has _id as its primary key, with an automatic unique index. You can supply your own _id — like a product SKU — as long as it's unique.

// Custom _id values
db.products.insertOne({
  _id: 'SKU-HEADPHONES-BLK-42',   // string _id
  name: 'Wireless Headphones Black',
  price: 79.99
});

// Lookup by custom _id is O(log n) via the _id index
db.products.findOne({ _id: 'SKU-HEADPHONES-BLK-42' });

Index Structure Differences

Both SQL and MongoDB use B-tree indexes, but MongoDB can index nested fields and array elements too. So flexible schemas don't cost you query speed.

// Index a nested field and an array field
db.users.createIndex({ 'address.city': 1 });
// Now queries on city use an index:
db.users.find({ 'address.city': 'Chicago' });

// Multikey index on array field - indexes each element
db.products.createIndex({ tags: 1 });
db.products.find({ tags: 'electronics' }); // uses multikey index

Transactions: Tables vs Collections

Since v4.0, MongoDB supports multi-document transactions. But by embedding related data in one document, you often get atomic updates without needing them at all.

// Single-document atomicity (always available)
// Updating order status and adding a tracking number
db.orders.updateOne(
  { _id: orderId },
  { $set: { status: 'shipped', trackingNumber: 'UPS123456' } }
);
// These two field updates happen atomically - no transaction needed

When to Choose Tables Over Collections

Sometimes SQL tables are the better pick: stable schemas, heavy JOINs, or strict foreign-key integrity. Choose the right tool, not the trendiest one.

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

You learned collections don't force a schema, MongoDB embeds related data to skip JOINs, and every collection auto-indexes _id. Next: databases and namespaces.

よくある質問

「コレクションと SQL テーブルの比較」レッスンは無料ですか？

はい。「コレクションと SQL テーブルの比較」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、MongoDB Academyコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 MongoDB Academyコースには全4レッスンが含まれています。

「コレクションと SQL テーブルの比較」で何を学びますか？

MongoDB のコレクションとリレーショナルテーブルを比較し、柔軟なスキーマがデータ設計をどのように変えるかを理解します。 ブラウザで直接実行するハンズオンコードでMongoDB Academyを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

MongoDB Academyを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのMongoDB Academyは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。

「コレクションと SQL テーブルの比較」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このMongoDB Academyレッスンでコードを書いて実行できますか？

はい。すべてのMongoDB Academyレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. BSON ドキュメントとは
  2. コレクションと SQL テーブルの比較
  3. データベース、コレクション、名前空間
  4. mongosh シェルの基本
← MongoDB Academyに戻る