Какие задачи выполнял в БД

Типичные задачи с базами данных в Java разработке

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

1. Проектирование и оптимизация схемы БД

Одна из критически важных задач - правильное проектирование структуры данных:

// Пример: проектирование таблицы пользователей
// CREATE TABLE users (
//   id UUID PRIMARY KEY,
//   email VARCHAR(255) NOT NULL UNIQUE,
//   created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
//   updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
//   is_active BOOLEAN DEFAULT true
// );

public class User {
    @Id
    private UUID id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
    
    private Boolean isActive;
}

Обычно включает:

• Определение таблиц и их взаимосвязей (relationships)
• Выбор правильных индексов для быстрого поиска
• Нормализацию данных (1NF, 2NF, 3NF)
• Планирование growth и scalability

2. Написание SQL запросов и работа с ORM

Я регулярно пишу как raw SQL, так и используюю ORM (Hibernate):

// Spring Data JPA Repository
@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    Optional<User> findByEmail(String email);
    
    @Query("SELECT u FROM User u WHERE u.isActive = true AND u.createdAt > :date")
    List<User> findActiveUsersAfter(@Param("date") LocalDateTime date);
}

// Использование в сервисе
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public List<User> getNewActiveUsers() {
        LocalDateTime oneMonthAgo = LocalDateTime.now().minusMonths(1);
        return userRepository.findActiveUsersAfter(oneMonthAgo);
    }
}

Сложные запросы часто требуют:

• JOINs с другими таблицами
• GROUP BY и агрегирующие функции
• Подзапросы (subqueries)
• Сортировку и пагинацию

3. Работа с миграциями

Управление версионированием БД - критически важно:

-- migration V1__create_users_table.sql
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL UNIQUE,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_users_email ON users(email);

-- migration V2__add_phone_column.sql
ALTER TABLE users ADD COLUMN phone VARCHAR(20);

Использую Flyway или Liquibase:

// Spring Boot автоматически запускает миграции
// application.yml
spring:
  flyway:
    enabled: true
    locations: classpath:db/migration

4. Оптимизация производительности запросов

Очень частая задача - улучшение performance приложения:

// Проблема: N+1 query problem
@Entity
public class Post {
    @Id
    private UUID id;
    
    @ManyToOne
    private User author;  // Каждый запрос будет дополнительный SELECT
}

// Решение: использовать JOIN FETCH или Eager Loading
@Repository
public interface PostRepository extends JpaRepository<Post, UUID> {
    @Query("SELECT p FROM Post p JOIN FETCH p.author WHERE p.published = true")
    List<Post> findPublishedWithAuthor();
}

// Альтернатива: использовать LAZY loading с Hibernate.initialize
public List<Post> getPostsOptimized() {
    List<Post> posts = postRepository.findAll();
    Hibernate.initialize(posts.get(0).getAuthor());
    return posts;
}

Обычные оптимизации:

• Добавление индексов на часто используемые колонки
• Использование EXPLAIN PLAN для анализа запросов
• Query result caching (Redis, Memcached)
• Batch processing для массовых операций

5. Работа с транзакциями

Обеспечение консистентности данных - ключевая ответственность:

@Service
public class PaymentService {
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void transferMoney(UUID fromUserId, UUID toUserId, BigDecimal amount) {
        // Оба запроса либо выполнятся, либо откатятся
        User fromUser = userRepository.findById(fromUserId).orElseThrow();
        User toUser = userRepository.findById(toUserId).orElseThrow();
        
        if (fromUser.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        
        fromUser.setBalance(fromUser.getBalance().subtract(amount));
        toUser.setBalance(toUser.getBalance().add(amount));
        
        userRepository.save(fromUser);
        userRepository.save(toUser);
    }
}

Уровни изоляции:

• READ_UNCOMMITTED: самый быстрый, но небезопасный
• READ_COMMITTED: стандартный уровень
• REPEATABLE_READ: лучше для параллельности
• SERIALIZABLE: максимальная безопасность, но медленнее

6. Работа с связанными данными (Relationships)

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

// One-to-Many
@Entity
public class User {
    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
    private List<Post> posts = new ArrayList<>();
}

@Entity
public class Post {
    @ManyToOne
    private User author;
}

// Many-to-Many
@Entity
public class Course {
    @ManyToMany
    @JoinTable(
        name = "course_student",
        joinColumns = @JoinColumn(name = "course_id"),
        inverseJoinColumns = @JoinColumn(name = "student_id")
    )
    private Set<Student> students = new HashSet<>();
}

// Many-to-One с Foreign Key
@Entity
public class Comment {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id", nullable = false)
    private Post post;
}

7. Обработка исключений и ошибок БД

Правильная обработка ошибок подключения и запросов:

@Service
public class UserService {
    @Transactional(rollbackFor = Exception.class)
    public User createUser(CreateUserRequest request) {
        try {
            User user = new User();
            user.setEmail(request.getEmail());
            return userRepository.save(user);
        } catch (DataIntegrityViolationException e) {
            throw new UserAlreadyExistsException("User with email already exists");
        } catch (Exception e) {
            logger.error("Unexpected error while creating user", e);
            throw new InternalServerException();
        }
    }
}

8. Тестирование слоя данных

Написание тестов для репозиториев и сервисов:

@DataJpaTest
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void testFindByEmail_ShouldReturnUser() {
        // Arrange
        User user = new User();
        user.setEmail("test@example.com");
        userRepository.save(user);
        
        // Act
        Optional<User> found = userRepository.findByEmail("test@example.com");
        
        // Assert
        assertTrue(found.isPresent());
        assertEquals("test@example.com", found.get().getEmail());
    }
}

9. Bulk операции и batch processing

Обработка больших объемов данных эффективно:

@Service
public class BulkUserService {
    @Transactional
    public void importUsers(List<UserImportDto> users) {
        List<User> userEntities = users.stream()
            .map(dto -> new User(dto.getEmail(), dto.getName()))
            .collect(Collectors.toList());
        
        // Batch insert вместо одного за другим
        int batchSize = 1000;
        for (int i = 0; i < userEntities.size(); i += batchSize) {
            int end = Math.min(i + batchSize, userEntities.size());
            userRepository.saveAll(userEntities.subList(i, end));
            entityManager.flush();
            entityManager.clear();
        }
    }
}

10. Мониторинг и отладка БД

Отслеживание проблем с БД:

// Логирование SQL запросов
// application.yml
spring:
  jpa:
    show-sql: false
    properties:
      hibernate:
        format_sql: true
        use_sql_comments: true
        jdbc:
          batch_size: 20
          fetch_size: 50

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE

Ключевые навыки в работе с БД

✓ Проектирование нормализованных схем
✓ Написание оптимизированных SQL запросов
✓ Управление миграциями и версионированием БД
✓ Работа с ORM фреймворками (Hibernate, JPA)
✓ Оптимизация производительности запросов
✓ Управление транзакциями и консистентностью
✓ Обработка исключений и edge cases
✓ Написание модульных тестов для данных
✓ Понимание index strategy и query plans
✓ Monitoring и отладка проблем с БД

Эти навыки - основа успешной Java разработки, особенно в backend приложениях, где правильная работа с данными определяет стабильность и производительность всей системы.