Databases SQL

SQL vs NoSQL: яку базу даних обрати для проекту?

15 лютого 2026 | 25 хв читання

У 1970 році Едгар Кодд опублікував статтю "A Relational Model of Data for Large Shared Data Banks", яка започаткувала еру реляційних баз даних. 50 років потому з'явились NoSQL бази, які кинули виклик SQL-гегемонії. Але хто переможе у 2026? Спойлер: ніхто. Кожен інструмент має своє місце.

Фундаментальні відмінності

SQL бази даних: класика не вмирає

PostgreSQL — найпотужніша open-source RDBMS

-- Створення таблиць з зв'язками
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
    title VARCHAR(200) NOT NULL,
    content TEXT,
    published BOOLEAN DEFAULT false,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE comments (
    id SERIAL PRIMARY KEY,
    post_id INTEGER REFERENCES posts(id) ON DELETE CASCADE,
    user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Індекси для оптимізації
CREATE INDEX idx_posts_user_id ON posts(user_id);
CREATE INDEX idx_posts_published ON posts(published) WHERE published = true;

-- Складний запит з JOIN
SELECT
    u.username,
    p.title,
    COUNT(c.id) as comment_count,
    p.created_at
FROM users u
JOIN posts p ON u.id = p.user_id
LEFT JOIN comments c ON p.id = c.post_id
WHERE p.published = true
GROUP BY u.username, p.id
ORDER BY p.created_at DESC
LIMIT 10;

NoSQL: різноманітність підходів

1. Document Stores (MongoDB)

Зберігають дані як JSON-подібні документи. Ідеальні для гнучких схем.

// MongoDB — робота з документами
const mongoose = require('mongoose');

// Схема (опціональна, але рекомендована)
const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  email: { type: String, required: true, unique: true },
  profile: {
    firstName: String,
    lastName: String,
    avatar: String,
    bio: String
  },
  posts: [{
    title: String,
    content: String,
    tags: [String],
    comments: [{
      userId: mongoose.Types.ObjectId,
      content: String,
      createdAt: { type: Date, default: Date.now }
    }],
    createdAt: { type: Date, default: Date.now }
  }],
  settings: {
    theme: { type: String, default: 'light' },
    notifications: { type: Boolean, default: true }
  },
  createdAt: { type: Date, default: Date.now }
});

const User = mongoose.model('User', userSchema);

// Створення документа
const newUser = await User.create({
  username: 'john_doe',
  email: 'john@example.com',
  profile: {
    firstName: 'John',
    lastName: 'Doe'
  },
  posts: [{
    title: 'My First Post',
    content: 'Hello World!',
    tags: ['intro', 'welcome']
  }]
});

// Aggregation pipeline
const stats = await User.aggregate([
  { $unwind: '$posts' },
  { $group: {
      _id: '$username',
      totalPosts: { $sum: 1 },
      avgComments: { $avg: { $size: '$posts.comments' } }
  }},
  { $sort: { totalPosts: -1 } },
  { $limit: 10 }
]);

2. Key-Value Stores (Redis)

Надшвидкі операції з простими даними. Ідеальні для кешування та сесій.

import redis

# Підключення
r = redis.Redis(host='localhost', port=6379, db=0)

# Прості операції
r.set('user:1:name', 'John Doe')
r.get('user:1:name')  # b'John Doe'

# TTL (Time To Live) — автоматичне видалення
r.setex('session:abc123', 3600, 'user_data')  # 1 година

# Лічильники
r.incr('page:views:homepage')
r.incrby('user:1:points', 100)

# Списки (для черг)
r.lpush('queue:emails', 'email1@example.com')
r.lpush('queue:emails', 'email2@example.com')
r.rpop('queue:emails')  # FIFO

# Хеші (для об'єктів)
r.hset('user:1', mapping={
    'name': 'John',
    'email': 'john@example.com',
    'age': '30'
})
r.hget('user:1', 'name')
r.hgetall('user:1')

# Sorted Sets (для лідербордів)
r.zadd('leaderboard', {'player1': 1000, 'player2': 850, 'player3': 920})
r.zrevrange('leaderboard', 0, 9, withscores=True)  # Top 10

# Pub/Sub (для real-time)
pubsub = r.pubsub()
pubsub.subscribe('notifications')
r.publish('notifications', 'New message!')

3. Graph Databases (Neo4j)

Оптимізовані для зв'язків. Ідеальні для соціальних мереж, рекомендацій.

// Cypher Query Language (Neo4j)

// Створення вузлів та зв'язків
CREATE (john:Person {name: 'John', age: 30})
CREATE (jane:Person {name: 'Jane', age: 28})
CREATE (bob:Person {name: 'Bob', age: 32})
CREATE (john)-[:FRIENDS_WITH]->(jane)
CREATE (jane)-[:FRIENDS_WITH]->(bob)
CREATE (john)-[:WORKS_AT]->(company:Company {name: 'TechCorp'})

// Знайти друзів друзів
MATCH (person:Person {name: 'John'})-[:FRIENDS_WITH*2]->(fof)
WHERE fof <> person
RETURN DISTINCT fof.name

// Найкоротший шлях між людьми
MATCH path = shortestPath(
  (a:Person {name: 'John'})-[:FRIENDS_WITH*]-(b:Person {name: 'Bob'})
)
RETURN path

// Рекомендації "люди, яких ви можете знати"
MATCH (user:Person {name: 'John'})-[:FRIENDS_WITH]->(friend)-[:FRIENDS_WITH]->(recommendation)
WHERE NOT (user)-[:FRIENDS_WITH]->(recommendation) AND user <> recommendation
RETURN recommendation.name, COUNT(*) AS mutualFriends
ORDER BY mutualFriends DESC
LIMIT 5

Практичний вибір: дерево рішень

Polyglot Persistence: найкращий підхід 2026

Сучасні додатки часто використовують кілька баз даних одночасно:

ORM: абстракція над базою даних

# SQLAlchemy (Python) — SQL ORM
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship, sessionmaker, declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True, nullable=False)
    posts = relationship('Post', back_populates='author', cascade='all, delete-orphan')

class Post(Base):
    __tablename__ = 'posts'

    id = Column(Integer, primary_key=True)
    title = Column(String(200), nullable=False)
    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    author = relationship('User', back_populates='posts')

# Використання
engine = create_engine('postgresql://user:pass@localhost/db')
Session = sessionmaker(bind=engine)
session = Session()

# Створення
user = User(username='john')
user.posts.append(Post(title='Hello World'))
session.add(user)
session.commit()

# Запит
users_with_posts = session.query(User).join(Post).filter(Post.title.like('%Hello%')).all()