В чем разница между реляционной и нереляционной БД?

Разница между реляционной и нереляционной БД

Это два принципиально различных подхода к хранению и организации данных, и выбор между ними критичен для архитектуры приложения.

1. Реляционные БД (SQL)

Определение: Реляционная база данных организует данные в виде таблиц (отношений) с фиксированной схемой, где строки и столбцы связаны между собой.

Основные характеристики:

• Данные организованы в таблицы со строками и столбцами
• Фиксированная схема (нужно определить структуру заранее)
• Отношения между таблицами через внешние ключи (Foreign Keys)
• Использует язык SQL (Structured Query Language)
• ACID свойства (Atomicity, Consistency, Isolation, Durability)
• Нормализация для избежания дублирования
• Лучше всего для структурированных данных

Примеры: PostgreSQL, MySQL, Oracle, SQL Server, MariaDB

Пример структуры:

-- Таблица пользователей
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    age INT CHECK (age >= 0),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Таблица постов
CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INT NOT NULL,
    title VARCHAR(200) NOT NULL,
    content TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Таблица комментариев
CREATE TABLE comments (
    id SERIAL PRIMARY KEY,
    post_id INT NOT NULL,
    user_id INT NOT NULL,
    text TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (post_id) REFERENCES posts(id),
    FOREIGN KEY (user_id) REFERENCES users(id)
);

Запросы в Java с использованием JDBC:

public class UserRepository {
    private Connection connection;
    
    public User findById(int id) throws SQLException {
        String sql = "SELECT id, name, email, age FROM users WHERE id = ?";
        
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setInt(1, id);
            ResultSet rs = stmt.executeQuery();
            
            if (rs.next()) {
                return new User(
                    rs.getInt("id"),
                    rs.getString("name"),
                    rs.getString("email"),
                    rs.getInt("age")
                );
            }
        }
        return null;
    }
    
    public List<Post> getUserPosts(int userId) throws SQLException {
        String sql = "SELECT p.id, p.title, p.content, p.created_at " +
                     "FROM posts p WHERE p.user_id = ? ORDER BY p.created_at DESC";
        
        List<Post> posts = new ArrayList<>();
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setInt(1, userId);
            ResultSet rs = stmt.executeQuery();
            
            while (rs.next()) {
                posts.add(new Post(
                    rs.getInt("id"),
                    rs.getString("title"),
                    rs.getString("content")
                ));
            }
        }
        return posts;
    }
    
    // Транзакция — гарантирует целостность данных
    public void transferMoney(int fromUserId, int toUserId, BigDecimal amount) 
            throws SQLException {
        try {
            connection.setAutoCommit(false);
            
            // Снять со счёта
            String decreaseSQL = "UPDATE accounts SET balance = balance - ? WHERE user_id = ?";
            try (PreparedStatement stmt = connection.prepareStatement(decreaseSQL)) {
                stmt.setBigDecimal(1, amount);
                stmt.setInt(2, fromUserId);
                stmt.executeUpdate();
            }
            
            // Положить на счёт
            String increaseSQL = "UPDATE accounts SET balance = balance + ? WHERE user_id = ?";
            try (PreparedStatement stmt = connection.prepareStatement(increaseSQL)) {
                stmt.setBigDecimal(1, amount);
                stmt.setInt(2, toUserId);
                stmt.executeUpdate();
            }
            
            connection.commit();
        } catch (SQLException e) {
            connection.rollback(); // Откатить все изменения при ошибке
            throw e;
        } finally {
            connection.setAutoCommit(true);
        }
    }
}

2. Нереляционные БД (NoSQL)

Определение: Нереляционная база данных хранит данные в гибких форматах (документы, ключ-значение, графы) без фиксированной схемы.

Основные характеристики:

• Гибкая/динамическая схема (schema-less)
• Нет жёстких отношений
• Горизонтальная масштабируемость (горизонтальное разделение)
• Высокая производительность для больших объёмов данных
• BASE свойства (Basically Available, Soft state, Eventually consistent)
• Лучше всего для неструктурированных данных
• Денормализация (дублирование данных для быстроты)

Типы NoSQL БД:

Document Store (MongoDB)

// MongoDB хранит документы JSON/BSON
public class MongoUserRepository {
    private MongoCollection<Document> collection;
    
    public void saveUser(User user) {
        Document doc = new Document()
            .append("_id", new ObjectId())
            .append("name", user.getName())
            .append("email", user.getEmail())
            .append("age", user.getAge())
            .append("posts", new ArrayList<>())
            .append("createdAt", new Date());
        
        collection.insertOne(doc);
    }
    
    public User findByEmail(String email) {
        Document doc = collection.find(new Document("email", email)).first();
        
        if (doc != null) {
            return new User(
                doc.getObjectId("_id").toString(),
                doc.getString("name"),
                doc.getString("email"),
                doc.getInteger("age")
            );
        }
        return null;
    }
    
    // Гибкая структура — каждый документ может быть разным
    public void saveFlexibleUser(String name, String email, String phone, String address) {
        Document doc = new Document()
            .append("name", name)
            .append("email", email);
        
        if (phone != null) {
            doc.append("phone", phone);
        }
        if (address != null) {
            doc.append("address", address);
        }
        
        collection.insertOne(doc);
    }
}

Key-Value Store (Redis)

// Redis хранит простые пары ключ-значение
public class RedisSessionRepository {
    private RedisClient redis;
    
    public void saveSession(String sessionId, String userId, long expirySeconds) {
        redis.setex("session:" + sessionId, expirySeconds, userId);
    }
    
    public String getSession(String sessionId) {
        return redis.get("session:" + sessionId);
    }
    
    // Кэширование
    public void cacheUserData(String userId, String jsonData, long ttl) {
        redis.setex("user:" + userId, ttl, jsonData);
    }
}

Graph Database (Neo4j)

// Neo4j хранит данные как графы узлов и рёбер
public class Neo4jFollowerRepository {
    private Driver driver;
    
    public void createFollowRelationship(String followerId, String followeeId) {
        try (Session session = driver.session()) {
            session.executeWrite(tx -> {
                Result result = tx.run(
                    "MATCH (a:User {id: $followerId}), (b:User {id: $followeeId}) " +
                    "CREATE (a)-[:FOLLOWS]->(b)",
                    Map.of("followerId", followerId, "followeeId", followeeId)
                );
                return result.consume();
            });
        }
    }
    
    // Рекомендации через графы — просто и быстро
    public List<String> getFollowerRecommendations(String userId) {
        try (Session session = driver.session()) {
            List<String> recommendations = session.executeRead(tx -> {
                List<String> result = new ArrayList<>();
                Result queryResult = tx.run(
                    "MATCH (user:User {id: $userId})-[:FOLLOWS]->(followed)-[:FOLLOWS]->(recommended) " +
                    "WHERE NOT (user)-[:FOLLOWS]->(recommended) " +
                    "RETURN recommended.id LIMIT 10",
                    Map.of("userId", userId)
                );
                
                while (queryResult.hasNext()) {
                    result.add(queryResult.next().get("recommended.id").asString());
                }
                return result;
            });
            return recommendations;
        }
    }
}

Сравнительная таблица

Когда использовать каждую

Реляционная БД (SQL):

✓ Финансовые системы (нужны транзакции)
✓ E-commerce (заказы, платежи)
✓ ERP/CRM системы
✓ Любые системы с ACID требованиями
✓ Много отношений между сущностями
✓ Сложные JOIN запросы

Нереляционная БД (NoSQL):

✓ Big Data, аналитика
✓ Real-time приложения
✓ Социальные сети
✓ Кэширование сессий
✓ Логирование
✓ Неструктурированные данные
✓ Высокая масштабируемость требуется

Практический пример: выбор БД для проекта

Сценарий: Платформа блога с рекомендациями

public class BlogPlatform {
    private PostgreSQL userDB;        // Реляционная для пользователей и постов
    private MongoDB commentDB;        // Нереляционная для гибких комментариев
    private Redis cache;              // Кэширование
    private Neo4j relationshipDB;     // Графы для рекомендаций
    
    public void createPost(Post post) {
        // Сохраняем структурированные данные
        userDB.save(post);
        cache.invalidate("user:" + post.getAuthorId() + ":posts");
    }
    
    public void addComment(Comment comment) {
        // Комментарии могут быть более гибкими
        commentDB.save(comment);
    }
    
    public List<Post> getRecommendedPosts(String userId) {
        // Используем граф для находит похожих пользователей
        List<String> similarUsers = relationshipDB.getSimilarUsers(userId);
        // Получаем их посты из основной БД
        return userDB.getPostsByUsers(similarUsers);
    }
    
    public List<Post> getCachedUserPosts(String userId) {
        // Сначала проверяем кэш
        List<Post> cached = cache.get("user:" + userId + ":posts");
        if (cached != null) {
            return cached;
        }
        
        // Если нет в кэше, получаем из БД
        List<Post> posts = userDB.getPostsByUser(userId);
        cache.set("user:" + userId + ":posts", posts, 3600);
        return posts;
    }
}

Выводы

1. Реляционные БД идеальны для структурированных данных, транзакций и целостности данных
2. Нереляционные БД лучше для масштабируемости, гибкости и высокопроизводительных систем
3. В реальных системах часто используют оба типа (polyglot persistence)
4. Выбор зависит от требований проекта, объёма данных и типа операций

Лучшие архитекторы выбирают подходящий инструмент для каждой задачи, а не пытаются использовать одну БД для всего.