Какие знаешь типы баз данных?

Типы баз данных и их применение

В современной разработке используются различные типы БД в зависимости от требований приложения. Расскажу о каждом типе с примерами использования.

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

Реляционные базы данных хранят данные в таблицах с связями между ними:

// PostgreSQL/MySQL example
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    private String name;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
    
    private BigDecimal amount;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
}

Популярные: PostgreSQL, MySQL, Oracle, SQL Server

Преимущества:

• ACID гарантии
• Строгая схема
• Мощные JOIN операции
• Нормализация данных

Недостатки:

• Может быть медленным при большом масштабе
• Сложно масштабировать горизонтально
• Жёсткая структура (миграции)

2. NoSQL - Document Store (MongoDB)

Документ-ориентированные БД хранят данные как JSON документы:

// MongoDB example
@Document(collection = "users")
public class User {
    @Id
    private ObjectId id;
    
    private String email;
    private String name;
    
    // Вложенные данные
    @Field("address")
    private Address address;
    
    private List<Order> orders;  // Вложенный массив
}

public class Order {
    private String id;
    private String productName;
    private BigDecimal amount;
    private LocalDateTime createdAt;
}

@Repository
public interface UserRepository extends MongoRepository<User, ObjectId> {
    Optional<User> findByEmail(String email);
    
    // Query DSL
    @Query("{ 'email': ?0 }")
    User findUserByEmail(String email);
    
    // Aggregation pipeline
    @Aggregation(pipeline = {
        "{ $match: { 'status': 'active' } }",
        "{ $group: { _id: '$category', count: { $sum: 1 } } }"
    })
    List<CategoryCount> countByCategory();
}

Популярные: MongoDB, CouchDB, Firebase

Преимущества:

• Гибкая схема
• Быстрое развитие без миграций
• Хорошо масштабируется горизонтально
• Естественная работа с JSON

Недостатки:

• Нет ACID гарантий (обычно)
• Может привести к дублированию данных
• Требует осторожности с нормализацией

3. NoSQL - Key-Value Store (Redis)

Простые пары ключ-значение, хранящиеся в памяти:

// Redis example
@Configuration
public class RedisConfig {
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        return template;
    }
}

@Service
public class CacheService {
    private final StringRedisTemplate redisTemplate;
    
    public void cacheUser(User user) {
        // Простое кэширование
        redisTemplate.opsForValue().set(
            "user:" + user.getId(),
            objectMapper.writeValueAsString(user),
            Duration.ofHours(1)
        );
    }
    
    public User getCachedUser(Long userId) {
        String data = redisTemplate.opsForValue().get("user:" + userId);
        return objectMapper.readValue(data, User.class);
    }
    
    // Counter
    public void incrementPageViews(String pageId) {
        redisTemplate.opsForValue().increment("views:" + pageId);
    }
    
    // List (очередь)
    public void enqueueJob(String job) {
        redisTemplate.opsForList().leftPush("jobs:queue", job);
    }
    
    // Set (уникальные значения)
    public void addFollower(String userId, String followerId) {
        redisTemplate.opsForSet().add("followers:" + userId, followerId);
    }
    
    // Sorted Set (рейтинги)
    public void updateRanking(String userId, double score) {
        redisTemplate.opsForZSet().add("rankings", userId, score);
    }
}

Популярные: Redis, Memcached, DynamoDB

Преимущества:

• Очень быстро (в памяти)
• Простая структура
• Хорошо для кэширования
• Поддержка различных типов данных (list, set, sorted set)

Недостатки:

• Данные теряются при перезагрузке (без RDB/AOF)
• Ограничено памятью
• Требует аккуратной работы с TTL

4. NoSQL - Search Engine (Elasticsearch)

Для быстрого полнотекстового поиска:

// Elasticsearch example
@Document(indexName = "products")
public class Product {
    @Id
    private String id;
    
    @Field(type = FieldType.Text)
    private String name;
    
    @Field(type = FieldType.Text, analyzer = "standard")
    private String description;
    
    @Field(type = FieldType.Keyword)
    private String category;
    
    @Field(type = FieldType.Double)
    private BigDecimal price;
}

@Repository
public interface ProductRepository extends ElasticsearchRepository<Product, String> {
    List<Product> findByName(String name);
    List<Product> findByCategory(String category);
}

@Service
public class ProductSearchService {
    private final ProductRepository repository;
    private final ElasticsearchOperations elasticsearchOperations;
    
    public List<Product> searchProducts(String query) {
        // Простой поиск
        return repository.findByName(query);
    }
    
    public List<Product> advancedSearch(String query, String category, BigDecimal maxPrice) {
        // Используем Query DSL
        Query searchQuery = new NativeSearchQueryBuilder()
            .withQuery(QueryBuilders.multiMatchQuery(query, "name", "description"))
            .withFilter(QueryBuilders.termQuery("category", category))
            .withFilter(QueryBuilders.rangeQuery("price").lte(maxPrice))
            .build();
        
        return elasticsearchOperations.search(searchQuery, Product.class)
            .getSearchHits()
            .stream()
            .map(SearchHit::getContent)
            .collect(Collectors.toList());
    }
}

Популярные: Elasticsearch, Solr, Meilisearch

Преимущества:

• Мощный полнотекстовый поиск
• Быстро для больших объёмов данных
• Агрегации и аналитика
• Масштабируется хорошо

Недостатки:

• Требует синхронизации с основной БД
• Требует памяти
• Eventual consistency

5. NoSQL - Time Series (InfluxDB, TimescaleDB)

Для хранения временных рядов (метрики, логи):

// TimescaleDB (PostgreSQL extension)
@Entity
@Table(name = "metrics")
public class Metric {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(nullable = false)
    private LocalDateTime timestamp;
    
    private Double value;
    
    private Map<String, String> tags;  // JSON
}

// InfluxDB
@Configuration
public class InfluxDBConfig {
    @Bean
    public InfluxDBClient influxDBClient() {
        return InfluxDBClientFactory.create(
            "http://localhost:8086",
            "token".toCharArray()
        );
    }
}

@Service
public class MetricsService {
    private final InfluxDBClient client;
    
    public void recordMetric(String measurementName, Map<String, String> tags, 
                             Map<String, Object> fields, LocalDateTime timestamp) {
        Point point = Point
            .measurement(measurementName)
            .time(timestamp.toInstant(ZoneOffset.UTC).toEpochMilli(), WritePrecision.MS)
            .addTags(tags)
            .addFields(fields)
            .build();
        
        client.getWriteApiBlocking().writePoint("my-bucket", "my-org", point);
    }
    
    public void queryMetrics(String query) {
        List<FluxRecord> records = client.getQueryApi()
            .query(query, "my-org");
        
        records.forEach(record -> 
            System.out.println(record.getValueByKey("_value"))
        );
    }
}

Популярные: InfluxDB, TimescaleDB (PostgreSQL extension), Prometheus

Преимущества:

• Оптимизировано для временных рядов
• Высокая пропускная способность для writes
• Встроенная опция сжатия данных
• Хорошо масштабируется

6. NoSQL - Graph Database (Neo4j)

Для хранения графов и отношений:

// Neo4j example
@Node("User")
public class User {
    @Id
    @GeneratedValue
    private Long id;
    
    private String email;
    
    @Relationship(type = "FOLLOWS", direction = Relationship.Direction.OUTGOING)
    private List<User> followers;
    
    @Relationship(type = "CREATED", direction = Relationship.Direction.OUTGOING)
    private List<Post> posts;
}

@Node("Post")
public class Post {
    @Id
    @GeneratedValue
    private Long id;
    
    private String title;
    
    @Relationship(type = "CREATED_BY", direction = Relationship.Direction.INCOMING)
    private User author;
}

@Repository
public interface UserRepository extends Neo4jRepository<User, Long> {
    // Поиск друзей друга (2-step relationship)
    @Query("""
        MATCH (u:User {email: $email})-[:FOLLOWS]->(friend)-[:FOLLOWS]->(friendOfFriend)
        RETURN DISTINCT friendOfFriend
    """)
    List<User> findFriendsOfFriends(@Param("email") String email);
    
    // Рекомендации на основе графа
    @Query("""
        MATCH (u:User {email: $email})-[:CREATED]->(:Post)<-[:CREATED]-(similarUser)
        RETURN similarUser, COUNT(*) as commonPosts
        ORDER BY commonPosts DESC
        LIMIT 5
    """)
    List<User> findSimilarUsers(@Param("email") String email);
}

Популярные: Neo4j, ArangoDB, JanusGraph

Преимущества:

• Естественное представление отношений
• Быстрые запросы на relationships
• Отлично для социальных сетей, рекомендаций

Недостатки:

• Требует переосмысления модели данных
• Медленнее при плоских данных

7. OLAP БД (Data Warehouse)

Для аналитики и больших объёмов данных:

// ClickHouse example - OLAP база
@Configuration
public class ClickHouseConfig {
    @Bean
    public ClickHouseClient clickHouseClient() throws ClickHouseException {
        ClickHouseNode server = ClickHouseNode.of("http://localhost:8123");
        return ClickHouseClient.newInstance(server);
    }
}

@Service
public class AnalyticsService {
    private final ClickHouseClient client;
    
    public void insertAnalytics(List<AnalyticsEvent> events) {
        // OLAP БД для вставки много строк сразу
        client.insert("analytics_events", events);
    }
    
    public List<Map<String, Object>> getAggregations() {
        // Быстрые агрегации
        return client.query("""
            SELECT 
                date,
                COUNT(*) as event_count,
                SUM(amount) as total_amount,
                AVG(duration) as avg_duration
            FROM analytics_events
            GROUP BY date
            ORDER BY date DESC
        """).getResult();
    }
}

Популярные: ClickHouse, Snowflake, BigQuery, Redshift

Преимущества:

• Отличная компрессия
• Быстро для агрегаций
• Хорошо масштабируется
• Оптимизирована для reads

8. Гибридные решения (HTAP)

Комбинация OLTP и OLAP:

• PostgreSQL с extensions (TimescaleDB, Citus)
• Supabase (PostgreSQL + реал-тайм)
• Cockroach DB (распределённый SQL)

Выбор БД: матрица решений

Best Practices

• Используй правильную БД для задачи — не упаковывай граф в реляционную БД
• Комбинируй БД — PostgreSQL + Redis + Elasticsearch часто оптимально
• Резервируй данные — особенно critical данные
• Мониторь производительность — профилируй запросы
• Кэшируй часто запрашиваемые данные — Redis перед основной БД
• Нормализуй в OLTP, денормализуй в OLAP — разные подходы для разных целей

В целом: выбор типа БД зависит от требований приложения. Часто используется комбинация нескольких типов для оптимального решения.