Convert MySQL CREATE TABLE statements to Java entity classes following framework conventions. Use when converting SQL DDL to Java entity definitions, generat...
---
name: sql-to-java-entity
description: Convert MySQL CREATE TABLE statements to Java entity classes following framework conventions. Use when converting SQL DDL to Java entity definitions, generating ORM models from database schemas, or creating JPA/MyBatis-Plus entity classes from MySQL tables. Supports MySQL to Java type mapping, snake_case to camelCase conversion, and automatic annotation generation with MyBatis-Plus and JPA annotations.
---
# SQL to Java Entity
## Quick Start
Convert a MySQL CREATE TABLE statement to a Java entity class:
1. Parse the CREATE TABLE statement to extract table name, columns, and constraints
2. Map each MySQL column type to corresponding Java type
3. Convert snake_case column names to camelCase field names
4. Generate entity class with `@TableName`, `@TableId`, and JPA annotations
5. Generate getter/setter methods
## Configuration
Before generating the entity class, determine the following:
- **Package name**: Ask the user for the target package (e.g., `com.example.entity`)
- **Base class**: Ask if the entity should extend a base class
- **Annotation style**: Confirm whether to use MyBatis-Plus annotations (default) or JPA annotations
If the user doesn't specify, use sensible defaults based on the project context.
## Type Mapping
For complete MySQL to Java type mappings, see [type_mappings.md](references/type_mappings.md).
### Quick Reference
| MySQL | Java | Notes |
|-------|------|-------------------------|
| `INT` | `Integer` | |
| `BIGINT` | `Long` | |
| `VARCHAR` | `String` | |
| `TEXT` | `String` | |
| `DATETIME` | `LocalDateTime` | java.time.LocalDateTime |
| `TIMESTAMP` | `LocalDateTime` | java.time.LocalDateTime |
| `TINYINT(1)` | `Integer` | |
| `DECIMAL` | `BigDecimal` | java.math.BigDecimal |
## Column Name Conversion
Convert `snake_case` to `camelCase`:
```
user_name → userName
created_at → createdAt
user_id → userId
is_active → isActive
```
Class name conversion (PascalCase):
```
user_info → UserInfo
order_detail → OrderDetail
```
## Annotation Generation
### MyBatis-Plus Annotations
| Constraint | Annotation |
|------------|-----------|
| Table name | `@TableName("table_name")` |
| Primary key | `@TableId(type = IdType.AUTO)` |
| Column name | `@TableField("column_name")` (only if different from field name) |
| Not mapped | `@TableField(exist = false)` |
### JPA Annotations (if needed)
| Constraint | Annotation |
|------------|-----------|
| Primary key | `@Id` |
| Auto increment | `@GeneratedValue(strategy = GenerationType.IDENTITY)` |
| Column name | `@Column(name = "column_name")` |
| Not null | `@Column(nullable = false)` |
| Unique | `@Column(unique = true)` |
| Length | `@Column(length = 50)` |
## Example
### Input
```sql
CREATE TABLE `user_info` (
`id` bigint unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL,
`age` int DEFAULT NULL,
`email` varchar(100) NOT NULL,
`salary` decimal(10,2) DEFAULT NULL,
`description` text,
`created_at` datetime DEFAULT CURRENT_TIMESTAMP,
`is_active` tinyint(1) DEFAULT '1',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='User Table';
```
### Output
```java
package com.example.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@TableName("user_info")
public class UserInfo {
@TableId(type = IdType.AUTO)
private Long id;
private String name;
private Integer age;
private String email;
private BigDecimal salary;
private String description;
private LocalDateTime createdAt;
private Integer isActive;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public BigDecimal getSalary() {
return salary;
}
public void setSalary(BigDecimal salary) {
this.salary = salary;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public LocalDateTime getCreatedAt() {
return createdAt;
}
public void setCreatedAt(LocalDateTime createdAt) {
this.createdAt = createdAt;
}
public Integer getIsActive() {
return isActive;
}
public void setIsActive(Integer isActive) {
this.isActive = isActive;
}
}
```
## Workflow
1. **Extract table info**: Get table name, column definitions, constraints, comment
2. **Apply type mappings**: See [type_mappings.md](references/type_mappings.md) for reference
3. **Generate class name**: Convert snake_case table name to PascalCase
4. **Generate field names**: Convert snake_case columns to camelCase
5. **Add annotations**: Generate @TableName, @TableId, @TableField based on column attributes
6. **Generate getters/setters**: Create standard getter and setter methods
7. **Add imports**: Include necessary imports for types and annotations
## Package Structure
Entity classes should be placed in a package specified by the user. Common conventions:
- **Generic project**: `com.{company}.{module}.entity` or `com.{company}.{module}.model`
## Class Comment
Use table comment as class comment:
```java
/**
* User Table
*/
@TableName("user_info")
public class UserInfo extends EntityBean {
}
```
## Base Class
The entity may extend a framework base class if required:
- **Framework**: May extend `BaseEntity`, `AbstractEntity`, or no base class
## Primary Key Strategy
| MySQL Column Definition | IdType |
|------------------------|--------|
| AUTO_INCREMENT | `IdType.AUTO` |
| Manual assignment | `IdType.INPUT` |
| UUID | `IdType.ASSIGN_UUID` |
| Snowflake algorithm | `IdType.ASSIGN_ID` |
## Nullable Columns
For nullable columns (allows NULL), use wrapper types:
- `Integer` instead of `int`
- `Long` instead of `long`
- `Boolean` instead of `boolean`
## Important Notes
1. Always use wrapper types (`Integer`, `Long`, `Boolean`) for nullable columns
2. Use `BigDecimal` for DECIMAL/NUMERIC types to maintain precision
3. Use `LocalDateTime` for DATETIME/TIMESTAMP types
4. Table name in `@TableName` should match the actual database table name exactly
5. The `id` field should use `IdType.AUTO` for auto-increment columns
6. Generate complete getter/setter methods for all fields
7. Follow framework conventions and package structure
don't have the plugin yet? install it then click "run inline in claude" again.