В чём разница между JSONField в PostgreSQL и хранением данных в MongoDB?

JSONField в PostgreSQL vs MongoDB

PostgreSQL с JSONField

JSONField в PostgreSQL — это специализированный тип данных для хранения JSON внутри реляционной таблицы. PostgreSQL добавил поддержку JSON в версии 9.2, с улучшениями в 9.4 (JSONB).

# Django ORM с JSONField
from django.db import models

class User(models.Model):
    id = models.UUIDField(primary_key=True)
    name = models.CharField(max_length=100)
    # JSONField хранит структурированные данные
    metadata = models.JSONField(default=dict)
    # Может быть много полей
    email = models.EmailField()
    created_at = models.DateTimeField(auto_now_add=True)

# Использование
user = User.objects.create(
    id='123',
    name='Иван',
    email='ivan@example.com',
    metadata={
        'preferences': {'theme': 'dark', 'language': 'ru'},
        'tags': ['python', 'django'],
        'social_links': {'github': 'ivan_dev', 'twitter': None}
    }
)

# Запрос данных
user = User.objects.get(id='123')
print(user.metadata['preferences']['theme'])  # 'dark'

SQL запрос:

-- PostgreSQL с JSONField
CREATE TABLE users (
    id UUID PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100),
    metadata JSONB NOT NULL,  -- JSONB более эффективен чем JSON
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Вставка данных
INSERT INTO users (id, name, email, metadata)
VALUES (
    '123',
    'Иван',
    'ivan@example.com',
    '{"preferences": {"theme": "dark", "language": "ru"}, "tags": ["python", "django"]}'
);

-- Запрос JSON поля
SELECT id, name, metadata->'preferences'->>'theme' as theme
FROM users
WHERE metadata->'preferences'->>'language' = 'ru';

-- Обновление JSON
UPDATE users
SET metadata = jsonb_set(metadata, '{preferences,theme}', '"light"')
WHERE id = '123';

MongoDB

MongoDB — это документоориентированная NoSQL база данных. Каждый документ (запись) — это JSON-подобный объект BSON (Binary JSON).

# MongoDB с PyMongo
from pymongo import MongoClient
from datetime import datetime
from uuid import uuid4

client = MongoClient('mongodb://localhost:27017')
db = client['myapp']
users_collection = db['users']

# В MongoDB нет строгой схемы
# Вставка документа
user_doc = {
    '_id': str(uuid4()),
    'name': 'Иван',
    'email': 'ivan@example.com',
    'metadata': {
        'preferences': {'theme': 'dark', 'language': 'ru'},
        'tags': ['python', 'django'],
        'social_links': {'github': 'ivan_dev', 'twitter': None}
    },
    'created_at': datetime.utcnow()
}

result = users_collection.insert_one(user_doc)
print(f"Inserted ID: {result.inserted_id}")

# Запрос данных
user = users_collection.find_one({'_id': '123'})
print(user['metadata']['preferences']['theme'])  # 'dark'

# Запрос с фильтром по JSON полю
users = users_collection.find(
    {'metadata.preferences.language': 'ru'}
)

# Обновление
users_collection.update_one(
    {'_id': '123'},
    {'$set': {'metadata.preferences.theme': 'light'}}
)

Сравнение архитектур

PostgreSQL с JSONField:

┌──────────────────────────────────┐
│       PostgreSQL (RDBMS)         │
├──────────────────────────────────┤
│  users (таблица)                 │
│  ├─ id (INTEGER)                 │
│  ├─ name (VARCHAR)               │
│  ├─ email (VARCHAR)              │
│  ├─ metadata (JSONB) ← JSON поле │
│  └─ created_at (TIMESTAMP)       │
│                                  │
│  Структура фиксирована           │
│  JSON = одно из полей            │
└──────────────────────────────────┘

MongoDB:

┌──────────────────────────────────┐
│       MongoDB (NoSQL)            │
├──────────────────────────────────┤
│  users (collection)              │
│  ├─ Document 1 (весь объект JSON)│
│  │  ├─ _id: '123'               │
│  │  ├─ name: 'Иван'             │
│  │  ├─ email: 'ivan@email.com'  │
│  │  ├─ metadata: { ... }        │
│  │  └─ created_at: timestamp    │
│  │                               │
│  ├─ Document 2 (может быть иная │
│  │  структура!)                 │
│  │  ├─ name: 'Мария'            │
│  │  └─ phone: '8-800-...'  ← Совсем другие поля!
│  │                               │
│  └─ ...                          │
│                                  │
│  Структура гибкая                │
│  Весь объект = документ          │
└──────────────────────────────────┘

Ключевые различия

Практический пример: E-commerce

PostgreSQL подход:

from django.db import models

class Product(models.Model):
    id = models.UUIDField(primary_key=True)
    name = models.CharField(max_length=255)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    
class Order(models.Model):
    id = models.UUIDField(primary_key=True)
    user_id = models.UUIDField()  # FK to User
    status = models.CharField(max_length=20)  # Строгая схема
    # Items хранятся как JSON
    items = models.JSONField()
    # {
    #     "items": [
    #         {"product_id": "...", "quantity": 2, "price": 1000},
    #         {"product_id": "...", "quantity": 1, "price": 500}
    #     ]
    # }
    total = models.DecimalField(max_digits=12, decimal_places=2)
    created_at = models.DateTimeField(auto_now_add=True)

# SQL запрос
SELECT 
    o.id,
    jsonb_array_elements(o.items)->>'product_id' as product_id,
    jsonb_array_elements(o.items)->>'quantity' as quantity
FROM orders o
WHERE o.user_id = '123';

MongoDB подход:

from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017')
db = client['shop']

# Вставка заказа
order_doc = {
    '_id': uuid4(),
    'user_id': '123',
    'status': 'pending',
    'items': [
        {'product_id': '...', 'quantity': 2, 'price': 1000},
        {'product_id': '...', 'quantity': 1, 'price': 500}
    ],
    'total': 2500,
    'created_at': datetime.utcnow(),
    'shipping': {  # Легко добавить новое поле
        'address': 'Москва',
        'phone': '+7-900-...',
        'tracking': '...'  # Может быть или нет
    }
}

db['orders'].insert_one(order_doc)

# Запрос с $lookup (аналог JOIN)
result = list(db['orders'].aggregate([
    {'$match': {'user_id': '123'}},
    {'$lookup': {
        'from': 'users',
        'localField': 'user_id',
        'foreignField': '_id',
        'as': 'user'
    }}
]))

Когда использовать каждый подход

PostgreSQL JSONField хорош для:

# 1. Частично неструктурированные данные
class UserSettings(models.Model):
    user = models.ForeignKey(User)
    # Основные поля структурированы
    email_verified = models.BooleanField()
    # Дополнительные опции в JSON
    preferences = models.JSONField(
        default=dict  # Может быть разным для разных пользователей
    )

# 2. Нужны транзакции
with transaction.atomic():
    user.balance -= 100
    order_item = OrderItem.objects.create(
        order=order,
        metadata={'tracking': uuid4()}  # JSON
    )
    user.save()

# 3. Нужны JOIN'ы
Query:
SELECT u.name, o.total, 
       jsonb_array_elements(o.items)->>'product_id' as product_id
FROM users u
JOIN orders o ON u.id = o.user_id
JOIN products p ON jsonb_array_elements(o.items)->>'product_id' = p.id

MongoDB хорош для:

# 1. Полностью неструктурированные данные
db['events'].insert_one({
    '_id': uuid4(),
    'type': 'user_login',
    'timestamp': datetime.utcnow(),
    'data': {... любой JSON ...}  # Структура может быть любой
})

# 2. Горизонтальное масштабирование (sharding)
db.command('shardCollection', 'shop.orders', key={'user_id': 1})

# 3. Быстрое прототипирование
# Нет нужды в миграциях — просто добавляешь поля
db['users'].update_one(
    {'_id': '123'},
    {'$set': {'new_field': 'value'}}  # Автоматически появится
)

# 4. Real-time данные (логи, события, аналитика)
db['analytics'].insert_many([
    {'event': 'click', 'user_id': '...', 'timestamp': ..., 'extra': {...}},
    {'event': 'scroll', 'user_id': '...', 'timestamp': ..., 'distance': 100},
])

Гибридный подход

# PostgreSQL с JSONField в основных системах
# MongoDB для логов и событий

# Users, Orders, Products — PostgreSQL (ACID, JOIN'ы, constraints)
class Order(models.Model):
    user = models.ForeignKey(User)  # ACID constraint
    items_json = models.JSONField()  # Flexible

# Event logs, Analytics — MongoDB (гибкость, масштабируемость)
db['event_logs'].insert_one({
    'user_id': '123',
    'event': 'purchase',
    'timestamp': datetime.utcnow(),
    'metadata': {... любой JSON ...}
})

Вывод

• PostgreSQL JSONField — JSON как один из типов полей в таблице

  • Сохраняет структуру RDBMS (schema, FK, транзакции, JOIN'ы)
  • Для частично неструктурированных данных

• MongoDB — документоориентированная, весь документ это JSON

  • Полная гибкость структуры
  • Горизонтальное масштабирование
  • Для полностью неструктурированных данных

• Выбирай PostgreSQL если нужны ACID транзакции и JOIN'ы

• Выбирай MongoDB если нужна гибкость и горизонтальное масштабирование

• Часто используют оба вместе в одном приложении