Column mapping with @Column in Spring Boot - Step-by-Step Execution

Concept Flow - Column mapping with @Column

Define Entity Class

↓

Add @Entity Annotation

↓

Add Fields

↓

Annotate Fields with @Column

↓

Set Column Properties (name, length, nullable, etc.)

↓

Spring Boot Maps Fields to DB Columns

↓

Use Repository to Save/Retrieve Data

This flow shows how you define a Java class as an entity, annotate its fields with @Column to map to database columns, and then Spring Boot uses this mapping to interact with the database.

Execution Sample

Spring Boot

import jakarta.persistence.*;

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

  @Column(name = "user_name", length = 50, nullable = false)
  private String username;
}

Defines a User entity with a username field mapped to the 'user_name' column in the database with specific constraints.

Execution Table

Step	Action	Field	@Column Properties	Effect on DB Mapping
1	Read class User	-	-	Prepare entity mapping
2	Read field id	id	@Id, @GeneratedValue	Primary key, auto-generated
3	Read field username	username	name='user_name', length=50, nullable=false	Maps to 'user_name' column, max 50 chars, not null
4	Spring Boot creates DB schema	-	-	Creates table with columns 'id' and 'user_name' with constraints
5	Save User instance	username='alice'	-	Stores 'alice' in 'user_name' column
6	Retrieve User	-	-	Fetches data from 'user_name' column into username field
7	End	-	-	Mapping complete

💡 All fields mapped and database operations use these mappings

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
id	null	null	auto-generated (e.g., 1)	1
username	null	null	'alice'	'alice'

Key Moments - 3 Insights

Why do we use @Column(name = "user_name") instead of just naming the field 'user_name'?

The field name in Java can differ from the database column name. @Column(name = "user_name") tells Spring Boot exactly which DB column to map to, as shown in execution_table step 3.

What happens if we omit @Column on a field?

Spring Boot uses the field name as the column name by default. But you lose control over properties like length or nullability, which @Column lets you specify (see step 3).

How does nullable=false affect the database?

It adds a NOT NULL constraint to the column in the database, preventing null values. This is shown in step 4 where the schema is created with constraints.

Visual Quiz - 3 Questions

Look at the execution_table, what is the effect of @Column on the 'username' field at step 3?

A Makes the field optional and nullable

B Maps to 'username' column with default settings

C Maps to 'user_name' column with max 50 chars and not null

D Generates the primary key

💡 Hint

Check the '@Column Properties' and 'Effect on DB Mapping' columns at step 3

At which step does Spring Boot create the database schema with column constraints?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the step mentioning 'creates table with columns' in the execution_table

If we remove 'nullable=false' from @Column, what changes in the execution?

A The column will allow null values in the database

B The column name changes to 'username'

C The field becomes the primary key

D The length of the column is unlimited

💡 Hint

Refer to key_moments about nullable property and step 4 in execution_table

Concept Snapshot

Use @Column to map Java fields to DB columns.
Specify properties like name, length, nullable.
If omitted, defaults apply (field name as column).
Spring Boot uses these mappings to create schema and handle data.
Example: @Column(name="user_name", length=50, nullable=false)

Full Transcript

This visual execution shows how Spring Boot maps Java entity fields to database columns using the @Column annotation. First, the entity class is defined and annotated with @Entity. Each field can be annotated with @Column to specify the database column name and constraints like length and nullability. Spring Boot reads these annotations to create the database schema with the correct columns and constraints. When saving or retrieving data, Spring Boot uses this mapping to store and fetch values correctly. Key points include that @Column allows customizing the column name and constraints, and if omitted, defaults are used. The execution table traces each step from reading the class and fields, applying @Column properties, creating the schema, and performing data operations. This helps beginners see how the annotation controls database mapping in a clear step-by-step way.

Practice

1. What is the main purpose of the @Column annotation in Spring Boot?

easy

A. To define a primary key for the entity

B. To create a new database table automatically

C. To configure the database connection settings

D. To map a Java field to a specific database column

Solution

1. Step 1: Understand the role of @Column

   The @Column annotation is used to link a Java class field to a database column, specifying details like name and constraints.

2. Step 2: Differentiate from other annotations

   Other annotations like @Id define primary keys, and database connection settings are configured elsewhere, not with @Column.

3. Final Answer:

   To map a Java field to a specific database column -> Option D

4. Quick Check:

   @Column maps field to column [OK]

Hint: Remember: @Column links fields to columns directly [OK]

Common Mistakes:

• Confusing @Column with @Id for primary keys
• Thinking @Column creates tables
• Mixing @Column with database connection setup

2. Which of the following is the correct way to specify a column name and length using @Column?

easy

A. @Column(name = "user_name", length = 50)

B. @Column(columnName = "user_name", size = 50)

C. @Column(name = user_name, length = 50)

D. @Column(name = "user_name", maxLength = 50)

Solution

1. Step 1: Check correct attribute names

   The correct attributes for @Column are 'name' for column name and 'length' for string length.

2. Step 2: Validate syntax

   Attributes must be strings in quotes for names; length is an integer. @Column(name = "user_name", length = 50) uses correct syntax and attribute names.

3. Final Answer:

   @Column(name = "user_name", length = 50) -> Option A

4. Quick Check:

   Use name and length attributes correctly [OK]

Hint: Use 'name' and 'length' exactly in @Column [OK]

Common Mistakes:

• Using wrong attribute names like columnName or maxLength
• Forgetting quotes around string values
• Using variables without quotes for name

3. Given the entity field:

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

What will happen if you try to save two entities with the same email?

medium

A. The application will throw a null pointer exception

B. The database will throw a unique constraint violation error

C. The second entity will overwrite the first one silently

D. Both entities will be saved without error

Solution

1. Step 1: Understand unique constraint

   The 'unique = true' attribute enforces that no two rows can have the same value in this column.

2. Step 2: Predict behavior on duplicate insert

   Trying to save a duplicate email will cause the database to reject the insert/update with a unique constraint violation error.

3. Final Answer:

   The database will throw a unique constraint violation error -> Option B

4. Quick Check:

   unique = true prevents duplicates [OK]

Hint: unique=true means no duplicate values allowed [OK]

Common Mistakes:

• Assuming duplicates are allowed with unique=true
• Confusing unique with nullable
• Expecting application to handle duplicates silently

4. Consider this code snippet:

@Column(name = "age", nullable = false)
private Integer age;

What is wrong if the application allows saving an entity with age = null without error?

medium

A. The database column is not set to NOT NULL, so nullable=false is ignored

B. The @Column annotation does not enforce nullability at the database level

C. The field type Integer allows null, so nullable=false has no effect

D. The entity is missing @NotNull validation annotation

Solution

1. Step 1: Understand nullable attribute

   The 'nullable = false' in @Column tells JPA to generate a NOT NULL constraint in the database schema.

2. Step 2: Recognize runtime enforcement

   @Column does not validate null values in Java code; it only affects database schema. If schema is not updated, nulls can be saved.

3. Final Answer:

   The database column is not set to NOT NULL, so nullable=false is ignored -> Option A

4. Quick Check:

   nullable=false affects DB schema, not Java validation [OK]

Hint: @Column nullable=false sets DB constraint, not Java checks [OK]

Common Mistakes:

• Thinking nullable=false validates Java field nulls
• Assuming Integer type disables nulls
• Confusing @Column with validation annotations

5. You want to map a Java field private String phoneNumber; to a database column named phone_num that must be unique and cannot be null, with a maximum length of 15 characters. Which is the correct @Column annotation to use?

hard

A. @Column(name = "phone_num", unique = false, nullable = true, length = 15)

B. @Column(name = "phoneNumber", unique = true, nullable = false, length = 15)

C. @Column(name = "phone_num", unique = true, nullable = false, length = 15)

D. @Column(name = "phone_num", unique = true, nullable = false)

Solution

1. Step 1: Match column name and constraints

   The column name must be 'phone_num', unique true, nullable false, and length 15 as per requirements.

2. Step 2: Check each option

   @Column(name = "phone_num", unique = true, nullable = false, length = 15) matches all requirements exactly. @Column(name = "phoneNumber", unique = true, nullable = false, length = 15) uses wrong column name. @Column(name = "phone_num", unique = false, nullable = true, length = 15) allows null and not unique. @Column(name = "phone_num", unique = true, nullable = false) misses length attribute.

3. Final Answer:

   @Column(name = "phone_num", unique = true, nullable = false, length = 15) -> Option C

4. Quick Check:

   Use correct name, unique, nullable, and length [OK]

Hint: Set all attributes explicitly to match requirements [OK]

Common Mistakes:

• Using Java field name instead of column name
• Forgetting unique or nullable constraints
• Missing length attribute for string columns