Introdução a Bases de Dados

public List<User> getInactiveUsers() throws SQLException {
    String sql = "SELECT * FROM tb_users WHERE active = false";
    PreparedStatement statement = connection.prepareStatement(sql);
    ResultSet resultSet = statement.executeQuery();
    List<User> inactiveUsers = new ArrayList<>();
    while (resultSet.next()) {
        User user = new User();
        user.setId(resultSet.getLong("id"));
        user.setUsername(resultSet.getString("username"));
        user.setEmail(resultSet.getString("email"));
        user.setActive(resultSet.getBoolean("active"));
        inactiveUsers.add(user);
    }
    return inactiveUsers;
}

public List<User> getInactiveUsers() {
    String jpql = "SELECT u FROM User u WHERE u.active = false";
    TypedQuery<User> query = entityManager.createQuery(jpql, User.class);
    return query.getResultList();
}

@Entity // [1] Define que a classe é uma entidade JPA
@Table(name = "tb_users") // [2] Especifica o nome da tabela no banco de dados
public class User {

    @Id // [3] Indica que o campo é a chave primária da entidade
    @GeneratedValue(strategy = GenerationType.IDENTITY) // [4] Especifica que o valor da chave primária deve ser gerado automaticamente pelo banco de dados
    private Long id;

    @Column(nullable = false, unique = true) // [5] Especifica que a coluna "username" não pode ser nula e deve ser única
    private String username;

    @Column(nullable = false, unique = true) // [6] Especifica que a coluna "email" não pode ser nula e deve ser única
    private String email;

    @Column(name = "last_login") // [7] Especifica o nome da coluna no banco de dados para o campo "lastLogin"
    private LocalDateTime lastLogin;

    // getters e setters
}

@Entity
@Table(name = "tb_users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false, unique = true)
    private String email;

    @OneToOne // [1] Define um relacionamento um-para-um com a entidade Profile
    @JoinColumn(name = "profile_id") // [2] Especifica a coluna de junção para o relacionamento um-para-um
    private Profile profile;

    @OneToMany(mappedBy = "user") // [3] Define um relacionamento um-para-muitos com a entidade Post
    private List<Post> posts;

    @ManyToMany // [4] Define um relacionamento muitos-para-muitos com a entidade Role
    @JoinTable(
        name = "tb_user_roles",  // [5] Especifica a tabela de junção e as colunas de junção para o relacionamento muitos-para-muitos
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private List<Role> roles;

    // getters e setters
}

@Entity
@Table(name = "tb_users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true) // [1] Especifica que a coluna "username" não pode ser nula e deve ser única
    private String username;

    @Column(nullable = false, unique = true) // [2] Especifica que a coluna "email" não pode ser nula e deve ser única
    private String email;

    @Column(length = 255) // [3] Especifica o comprimento máximo da coluna "password"
    private String password;

    // getters e setters
}

@ApplicationScoped // [1] Define que a classe é um bean CDI de escopo de aplicação
public class UserRepository {

    private final EntityManager entityManager;

    @Inject // [2] Injeta o EntityManager usando CDI
    public UserRepository(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public List<User> getInactiveUsers() {
        return entityManager.createQuery("FROM User u WHERE u.active = false", User.class) // [3] Cria uma consulta JPQL para recuperar todos os usuários inativos
                            .getResultList(); // [4] Executa a consulta e retorna os resultados como uma lista de objetos User
    }
}

public User getUserWithProfile(Long userId) {
    return entityManager.createQuery("FROM User u WHERE u.profile.enable = true", User.class) // [1] Cria uma consulta JPQL para recuperar um usuário com seu perfil ativo
                        .getSingleResult(); // [2] Executa a consulta e retorna o resultado como um objeto User
}

@Entity
@Table(name = "tb_users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false, unique = true)
    private String email;

    @OneToOne(fetch = FetchType.EAGER) // [1] Define um relacionamento um-para-um com a entidade Profile e especifica que o carregamento deve ser Eager
    @JoinColumn(name = "profile_id")
    private Profile profile;

    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY) // [2] Define um relacionamento um-para-muitos com a entidade Post e especifica que o carregamento deve ser Lazy
    private List<Post> posts;

    @ManyToMany // [3] Define um relacionamento muitos-para-muitos com a entidade Role e usa o modo de carregamento padrão (Lazy)
    @JoinTable(
        name = "tb_user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private List<Role> roles;

    // getters e setters
}

public User getUserWithProfile(Long userId) {
    return entityManager.createQuery("SELECT u FROM User u JOIN FETCH u.profile WHERE u.id = :userId", User.class) // [1] Cria uma consulta JPQL que usa JOIN FETCH para carregar o perfil do usuário imediatamente
                        .setParameter("userId", userId) // [2] Define o parâmetro da consulta
                        .getSingleResult(); // [3] Executa a consulta e retorna o resultado como um objeto User
}

public List<User> search(UserSearchCriteria criteria) {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); // [1] Cria um CriteriaBuilder a partir do EntityManager
    CriteriaQuery<User> criteriaQuery = criteriaBuilder.createQuery(User.class); // [2] Cria um CriteriaQuery para a entidade User
    Root<User> userRoot = criteriaQuery.from(User.class); // [3] Define a raiz da consulta como a entidade User

    List<Predicate> predicates = new ArrayList<>();
    if (Objects.nonNull(criteria.disabled)) {
        if (criteria.disabled) {
            predicates.add(criteriaBuilder.isTrue(userRoot.get("disabled"))); // [4] Adiciona um predicado para filtrar usuários desativados
        } else {
            predicates.add(criteriaBuilder.isFalse(userRoot.get("disabled"))); // [5] Adiciona um predicado para filtrar usuários ativados
        }
    }

    if (Objects.nonNull(criteria.name) && !criteria.name.isBlank()) {
        predicates.add(criteriaBuilder.like(criteriaBuilder.lower(userRoot.get("name")),
                                            "%%%s%%".formatted(criteria.name.toLowerCase()))); // [6] Adiciona um predicado para filtrar usuários pelo nome, usando uma comparação case-insensitive e permitindo correspondências parciais
    }

    if (Objects.nonNull(criteria.email) && !criteria.email.isBlank()) {
        predicates.add(criteriaBuilder.like(criteriaBuilder.lower(userRoot.get("email")),
                                            "%%%s%%".formatted(criteria.email.toLowerCase()))); // [7] Adiciona um predicado para filtrar usuários pelo email, usando uma comparação case-insensitive e permitindo correspondências parciais
    }

    if (!predicates.isEmpty()) {
        criteriaQuery.where(criteriaBuilder.and(predicates.toArray(new Predicate[0]))); // [8] Adiciona os predicados à consulta usando a cláusula WHERE, combinando-os com o operador AND
    }

    criteriaQuery.orderBy(criteriaBuilder.asc(userRoot.get("name"))); // [9] Adiciona uma cláusula ORDER BY para ordenar os resultados pelo nome do usuário em ordem crescente
    return entityManager.createQuery(criteriaQuery).getResultList();  // [10] Executa a consulta e retorna os resultados como uma lista de objetos User
}

var user = new User("john.doe", "John", "Doe", "john.doe@example.com"); // [1] A entidade user é criada pelo operador new, e não possui um identificador
System.out.println(user.getId()); // [2] O identificador da entidade user ainda é null, pois ela ainda não foi associada a um contexto de persistência
entityManager.persist(user); // [3] A entidade user é persistida e deixa o estado transitório, passando a ser gerenciada
System.out.println(user.getId()); // [4] O identificador da entidade user é atribuído pelo JPA, e agora a entidade está em estado gerenciado

var user = entityMananger.find(User.class, 1L); // [1] A entidade user é recuperada do banco de dados e passa a ser gerenciada
System.out.println(user.getName()); // [2] O nome do usuário é acessado,
user.setName("John Doe"); // [3] O nome do usuário é alterado, e a entidade user permanece em estado gerenciado
var updatedUser = entityManager.find(User.class, 1L); // [4] A entidade user não é recuperada novamente do banco de dados, pois como ela já está em estado gerenciado, o JPA retorna a mesma instância em cache, refletindo a mudança feita no nome do usuário
System.out.println(updatedUser.getName()); // [5] O nome do usuário é acessado novamente, e a mudança feita anteriormente é refletida, mesmo sem a necessidade de sincronizar explicitamente as mudanças com o banco de dados