Что такое OLTP?

Что такое OLTP

OLTP (Online Transaction Processing) — это тип системы обработки данных, предназначенный для управления транзакционными операциями в реальном времени. OLTP-системы оптимизированы для быстрого выполнения большого количества коротких транзакций с высокой параллельностью.

В контексте Java разработки, понимание OLTP критично при проектировании production-систем, так как это основной тип архитектуры для большинства бизнес-приложений.

Основное определение

OLTP — это системы, которые обрабатывают операции в реальном времени: оформление заказа, перевод денег, бронирование билетов, регистрация пользователя.

Клиент (веб-браузер, мобильное приложение)
       |
       v
Апликационный сервер (Java)
       |
       v
OLTP база данных (PostgreSQL, MySQL, Oracle)
       |
       v
Транзакция выполняется немедленно (ACID)

Характеристики OLTP систем

1. Высокая частота операций

Обработка тысяч операций в секунду

Оператор регистрирует заказ → Выполняется транзакция INSERT
Покупатель оплачивает → Выполняется транзакция UPDATE
Проверка статуса → Выполняется транзакция SELECT

2. Данные нормализованы

Данные разбиты по таблицам для минимизации дублирования

// OLTP схема БД
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    email VARCHAR(100) UNIQUE,
    name VARCHAR(100)
);

CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    user_id BIGINT REFERENCES users(id),
    total_price DECIMAL(10,2),
    created_at TIMESTAMP
);

CREATE TABLE order_items (
    id BIGINT PRIMARY KEY,
    order_id BIGINT REFERENCES orders(id),
    product_id BIGINT REFERENCES products(id),
    quantity INT,
    price DECIMAL(10,2)
);

При нормализации избегаем избыточности данных: информация о пользователе хранится один раз в таблице users.

3. ACID гарантии

Каждая транзакция соответствует ACID принципам

@Transactional(isolation = Isolation.SERIALIZABLE)
public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
    // Atomicity: либо выполнятся обе операции, либо ни одна
    Account fromAccount = accountRepository.findById(fromAccountId).orElseThrow();
    Account toAccount = accountRepository.findById(toAccountId).orElseThrow();
    
    // Consistency: баланс остается логически корректным
    if (fromAccount.getBalance().compareTo(amount) < 0) {
        throw new InsufficientBalanceException();
    }
    
    // Isolation: другие транзакции не видят промежуточное состояние
    fromAccount.setBalance(fromAccount.getBalance().subtract(amount));
    toAccount.setBalance(toAccount.getBalance().add(amount));
    
    accountRepository.save(fromAccount);
    accountRepository.save(toAccount);
    // Durability: после коммита данные гарантированно сохранены
}

4. Короткие транзакции

Транзакции выполняются быстро (миллисекунды)

@Transactional
public Order createOrder(OrderRequest request) {
    // Операция выполняется быстро: несколько сотен миллисекунд
    User user = userRepository.findById(request.getUserId()).orElseThrow();
    
    Order order = new Order();
    order.setUser(user);
    order.setTotalPrice(request.getTotalPrice());
    order.setCreatedAt(LocalDateTime.now(ZoneOffset.UTC));
    
    Order savedOrder = orderRepository.save(order);
    
    // Сохраняем позиции заказа
    for (OrderItemRequest itemRequest : request.getItems()) {
        OrderItem item = new OrderItem();
        item.setOrder(savedOrder);
        item.setProduct(productRepository.findById(itemRequest.getProductId()).orElseThrow());
        item.setQuantity(itemRequest.getQuantity());
        item.setPrice(itemRequest.getPrice());
        orderItemRepository.save(item);
    }
    
    return savedOrder;
}

5. Высокий уровень параллелизма

Много пользователей одновременно работают с системой

// Spring Boot конфигурация для OLTP
@Configuration
public class DatasourceConfiguration {
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost/myapp");
        config.setUsername("user");
        config.setPassword("password");
        
        // Пул соединений для обработки множества одновременных запросов
        config.setMaximumPoolSize(20);  // 20 одновременных соединений
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000);  // 30 сек на получение соединения
        
        return new HikariDataSource(config);
    }
}

Примеры OLTP операций

// 1. Создание заказа (INSERT + UPDATEs)
@PostMapping("/orders")
public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
    Order order = orderService.createOrder(request);
    return ResponseEntity.ok(new OrderResponse(order));
}

// 2. Обновление статуса заказа (UPDATE)
@PutMapping("/orders/{orderId}/status")
public ResponseEntity<Void> updateOrderStatus(
    @PathVariable Long orderId,
    @RequestBody UpdateStatusRequest request) {
    orderService.updateStatus(orderId, request.getStatus());
    return ResponseEntity.noContent().build();
}

// 3. Получение информации о заказе (SELECT)
@GetMapping("/orders/{orderId}")
public ResponseEntity<OrderResponse> getOrder(@PathVariable Long orderId) {
    Order order = orderService.getOrder(orderId);
    return ResponseEntity.ok(new OrderResponse(order));
}

// 4. Удаление заказа (DELETE)
@DeleteMapping("/orders/{orderId}")
public ResponseEntity<Void> deleteOrder(@PathVariable Long orderId) {
    orderService.deleteOrder(orderId);
    return ResponseEntity.noContent().build();
}

OLTP vs OLAP

Оптимизация OLTP систем

1. Индексы для быстрого поиска

@Entity
@Table(name = "users", indexes = {
    @Index(name = "idx_email", columnList = "email", unique = true),
    @Index(name = "idx_created_at", columnList = "created_at")
})
public class User {
    @Id
    private Long id;
    
    @Column(unique = true)
    private String email;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
}

2. Connection Pooling

// HikariCP автоматически переиспользует соединения
@Bean
public DataSource dataSource() {
    return DataSourceBuilder.create()
        .url("jdbc:postgresql://localhost/myapp")
        .driverClassName("org.postgresql.Driver")
        .username("user")
        .password("password")
        .type(com.zaxxer.hikari.HikariDataSource.class)
        .build();
}

3. Batch операции для улучшения производительности

@Service
public class UserService {
    @Transactional
    public void createUsersInBatch(List<User> users) {
        // Вместо 1000 операций INSERT, выполняем один batch
        userRepository.saveAllAndFlush(users);
    }
}

4. Кэширование часто используемых данных

@Service
@CacheConfig(cacheNames = "users")
public class UserService {
    @Cacheable(key = "#id")
    public User getUserById(Long id) {
        // Результат кэшируется на 1 час
        return userRepository.findById(id).orElseThrow();
    }
}

5. Правильная изоляция транзакций

@Transactional(isolation = Isolation.READ_COMMITTED)
public void updateUserEmail(Long userId, String newEmail) {
    // READ_COMMITTED: быстрее, но допускает non-repeatable read
    User user = userRepository.findById(userId).orElseThrow();
    user.setEmail(newEmail);
    userRepository.save(user);
}

@Transactional(isolation = Isolation.SERIALIZABLE)
public void transferMoney(Long from, Long to, BigDecimal amount) {
    // SERIALIZABLE: медленнее, но гарантирует полную изоляцию
    // Используется для критичных операций
}

Реальный пример: Электронный магазин

@Service
public class OrderService {
    
    @Transactional
    public Order placeOrder(Long userId, List<CartItem> items) {
        // 1. Проверяем пользователя
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException());
        
        // 2. Проверяем доступность товаров
        BigDecimal totalPrice = BigDecimal.ZERO;
        for (CartItem item : items) {
            Product product = productRepository.findById(item.getProductId())
                .orElseThrow(() -> new ProductNotFoundException());
            
            if (product.getStock() < item.getQuantity()) {
                throw new OutOfStockException();
            }
            
            totalPrice = totalPrice.add(
                product.getPrice().multiply(new BigDecimal(item.getQuantity()))
            );
        }
        
        // 3. Создаем заказ
        Order order = new Order();
        order.setUser(user);
        order.setTotalPrice(totalPrice);
        order.setStatus("PENDING");
        order.setCreatedAt(LocalDateTime.now(ZoneOffset.UTC));
        
        Order savedOrder = orderRepository.save(order);
        
        // 4. Добавляем позиции заказа и уменьшаем stock
        for (CartItem item : items) {
            OrderItem orderItem = new OrderItem();
            orderItem.setOrder(savedOrder);
            Product product = productRepository.findById(item.getProductId()).orElseThrow();
            orderItem.setProduct(product);
            orderItem.setQuantity(item.getQuantity());
            
            // Уменьшаем stock (сложно в конкурентной среде!)
            product.setStock(product.getStock() - item.getQuantity());
            productRepository.save(product);
            
            orderItemRepository.save(orderItem);
        }
        
        return savedOrder;
    }
}

Проблемы и решения в OLTP

Проблема: Race Conditions при обновлении stock

// ПЛОХО: Два потока одновременно обновляют stock
Product p = productRepository.findById(1L);
p.setStock(p.getStock() - 1);  // Потеря обновления!
productRepository.save(p);

// ХОРОШО: Используем SELECT FOR UPDATE
@Query("SELECT p FROM Product p WHERE p.id = :id")
@Lock(LockModeType.PESSIMISTIC_WRITE)
Product findByIdForUpdate(@Param("id") Long id);

Проблема: Deadlocks

// Правильный порядок для избежания deadlock:
// Всегда обновляй ресурсы в одинаковом порядке

@Transactional
public void transfer(Long accountA, Long accountB) {
    // Сортируем по ID для избежания циклических зависимостей
    Long firstId = Math.min(accountA, accountB);
    Long secondId = Math.max(accountA, accountB);
    
    Account first = accountRepository.findByIdForUpdate(firstId);
    Account second = accountRepository.findByIdForUpdate(secondId);
    
    // Операция
}

Заключение

OLTP-системы — это основа современных бизнес-приложений. Они оптимизированы для:

• Быстрого выполнения большого количества коротких операций
• Высокой параллельности с множеством одновременных пользователей
• Надежности данных через ACID гарантии
• Нормализованной структуры данных для избежания аномалий

Для Java разработчика понимание OLTP критично при работе с production-системами, базами данных и управлением транзакциями.