Column

Explicação

A anotação @Column no JPA é usada para mapear um atributo da entidade para uma coluna específica em uma tabela de banco de dados. Ela permite personalizar a forma como o atributo da entidade é tratado na tabela, seja em termos de nome, tamanho, tipo de dados ou outras restrições.

Abaixo, explico os detalhes da anotação @Column e como ela pode ser aplicada à entidade Cliente fornecida.

Objetivo da anotação @Column

A anotação @Column permite configurar vários aspectos do mapeamento entre atributos da entidade e as colunas da tabela no banco de dados. Entre os principais aspectos que você pode configurar com @Column, temos:

1. Nome da coluna (name)
2. Tamanho da coluna (length)
3. Se a coluna pode ser null (nullable)
4. Se a coluna é única (unique)
5. Se a coluna é indexada (insertable, updatable)
6. Tipo de dado da coluna (columnDefinition, precision, scale)

Exemplo básico

Aqui está a versão da classe Cliente com a anotação @Column aplicada aos atributos, usando as opções mais comuns para personalizar o mapeamento entre os atributos da classe e as colunas da tabela:

@Entity
public class Cliente {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // Definindo uma chave primária gerada automaticamente
    @Column(name = "id_cliente")  // Personalizando o nome da coluna para "id_cliente"
    private Integer id;

    @Column(name = "cpf_cnpj", length = 18, nullable = false, unique = true)  // Define o nome, o tamanho, torna não-nulo e único
    private String cpfCnpj;

    @Column(name = "nome_completo", length = 100, nullable = false)  // Define o nome e o tamanho da coluna
    private String nomeCompleto;

    @Column(name = "email", length = 100, nullable = false, unique = true)  // Define o nome, o tamanho e a unicidade
    private String email;

    @Column(name = "aniversario")  // O nome da coluna será o mesmo que o nome do atributo por padrão
    private LocalDate aniversario;

    @Column(name = "renda_mensal", precision = 10, scale = 2)  // Define a precisão e a escala para um número decimal
    private Double rendaMensal;

    @Column(name = "ativo", nullable = false)  // Torna a coluna 'ativo' não-nula
    private boolean ativo;
    
    // Lombok ou Getters e Setters
}

Atributos Comuns

1. name:

• Descrição: Define o nome da coluna no banco de dados. Caso não seja especificado, o JPA usará o nome do atributo da entidade como o nome da coluna.
• Exemplo:

  @Column(name = "cpf_cnpj")
  private String cpfCnpj;
  

2. length:

• Descrição: Define o tamanho máximo da coluna. Esse parâmetro é relevante principalmente para colunas de tipos como String (ou VARCHAR). Por padrão, o comprimento de uma String é 255 caracteres, mas você pode definir um tamanho menor.
• Exemplo:

  @Column(name = "nome_completo", length = 100)
  private String nomeCompleto;
  

3. nullable:

• Descrição: Define se a coluna pode ou não ser null. O valor padrão é true, ou seja, a coluna pode ser null. Se você definir como false, o banco de dados vai garantir que o campo tenha um valor não-nulo.
• Exemplo:

  @Column(name = "email", nullable = false)
  private String email;
  

4. unique:

• Descrição: Indica que os valores dessa coluna devem ser únicos no banco de dados. Isso cria uma restrição de unicidade para a coluna.
• Exemplo:

  @Column(name = "cpf_cnpj", unique = true)
  private String cpfCnpj;
  

5. insertable e updatable:

• Descrição: Controlam se o valor da coluna pode ser inserido ou atualizado. Se configurados como false, significa que a coluna será ignorada durante as operações de inserção e/ou atualização.
• Exemplo:

  @Column(name = "ativo", insertable = false, updatable = false)
  private boolean ativo;  // Este campo não será inserido ou atualizado diretamente
  

6. precision e scale:

• Descrição: São usados para colunas numéricas (como BigDecimal ou Double), especificando a precisão (número total de dígitos) e a escala (número de dígitos após o ponto decimal).
• Exemplo:

  @Column(name = "renda_mensal", precision = 10, scale = 2)
  private Double rendaMensal;
  

7. columnDefinition:

• Descrição: Permite especificar a definição completa da coluna, como o tipo de dado exato (por exemplo, VARCHAR(255), TEXT, INT).
• Exemplo:

  @Column(name = "aniversario", columnDefinition = "DATE")
  private LocalDate aniversario;
  

8. insertable e updatable:

• Descrição: Controlam se a coluna pode ser inserida ou atualizada diretamente. Por exemplo, se um atributo é calculado ou mantido por outro processo, ele pode ser marcado como não inserível ou não atualizável.
• Exemplo:

  @Column(name = "ativo", insertable = false, updatable = false)
  private boolean ativo;
  

Funcionalidades

• name: Define o nome da coluna no banco de dados.
• length: Define o tamanho da coluna para tipos de dados como String.
• nullable: Define se a coluna pode ser nula.
• unique: Define se os valores da coluna devem ser únicos.
• insertable / updatable: Define se a coluna será inserida ou atualizada.
• precision / scale: Define a precisão e escala para valores numéricos (usado principalmente para BigDecimal).
• columnDefinition: Define a definição completa do tipo da coluna no banco de dados.

Usando @Transient

A anotação @Transient no JPA é utilizada para indicar que um atributo não deve ser persistido na tabela do banco de dados. Ou seja, quando você usa @Transient, o JPA ignora o campo durante o processo de persistência (inserção, atualização, exclusão) e não tentará mapear esse campo para uma coluna na tabela do banco de dados.

Quando usar @Transient ?

Você deve usar @Transient quando quiser que o atributo seja somente leitura, mas não tenha nenhuma relação com o banco de dados (ou seja, você não quer que o campo seja persistido de forma alguma). Isso é útil, por exemplo, para campos calculados dinamicamente, ou para informações que são necessárias para o funcionamento da aplicação, mas não fazem parte do modelo de dados persistido.

@Entity
public class Cliente {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "renda_mensal", precision = 10, scale = 2)
    private Double rendaMensal;

    @Transient  // Este campo não será persistido no banco de dados
    private Double rendaAnual;

    public Double getRendaAnual() {
        this.rendaAnual = this.rendaMensal * 12;
        return this.rendaAnual;
    }

    // Getters e setters
}

Nesse exemplo:

• O atributo rendaMensal é persistido normalmente na tabela.
• O atributo rendaAnual é calculado dinamicamente com base no valor de rendaMensal, mas não é persistido nem no banco de dados nem na tabela. A anotação @Transient indica explicitamente que o atributo não será mapeado para nenhuma coluna.

Conclusão

A anotação @Column oferece um controle detalhado sobre como os atributos de uma entidade serão mapeados para colunas de uma tabela no banco de dados. Ela permite especificar o nome da coluna, restrições de unicidade, tamanho, se a coluna pode ser null, entre outras características. Ao utilizá-la corretamente, você pode garantir que as entidades da sua aplicação sejam mapeadas de maneira eficiente e conforme os requisitos do banco de dados.