JPA/Hibernate ID 생성 전략

// 예제 1: 시퀀스 전략
@Id
@GeneratedValue(strategy=SEQUENCE, generator="CUST_SEQ")
@Column(name="CUST_ID")
public Long getId() { return id; }
// → "CUST_SEQ"라는 시퀀스로 ID 생성

// 예제 2: 테이블 전략
@Id
@GeneratedValue(strategy=TABLE, generator="CUST_GEN")
@Column(name="CUST_ID")
Long id;
// → "CUST_GEN"이라는 키 생성 테이블로 ID 생성

// 매핑된 슈퍼클래스 (테이블로 생성되지 않음)
@MappedSuperclass
public abstract class BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // ← 여기에 @GeneratedValue 적용

    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;

    // getter, setter...
}

// 자식 엔티티 1
@Entity
@Table(name = "users")
public class User extends BaseEntity {
// id, createdAt, updatedAt 필드를 상속받음

    private String username;
    private String email;
}

// 자식 엔티티 2
@Entity
@Table(name = "products")
public class Product extends BaseEntity {
// id, createdAt, updatedAt 필드를 상속받음

    private String name;
    private int price;
}

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // PK 자동 생성

    private String username;

    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private UserProfile profile;
}

@Entity
public class UserProfile {
@Id
private Long id;  // User의 id를 그대로 사용 (자동 생성 X)

    @OneToOne
    @MapsId  // ← User의 PK를 이 엔티티의 PK로 매핑
    @JoinColumn(name = "id")
    private User user;

    private String bio;
    private String profileImageUrl;
}

// 이렇게 하면 안 됨
@Entity
public class UserProfile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // 충돌!
    private Long id;

    @OneToOne
    @MapsId
    private User user;
}

@Entity
public class UserProfile {
    @Id  // @GeneratedValue 없이 @Id만!
    private Long id;

    @OneToOne
    @MapsId  // User.id 값이 자동으로 이 엔티티의 id가 됨
    @JoinColumn(name = "id")
    private User user;

}

// 사용 예시
User user = new User();
user.setUsername("kim");
// user를 저장하면 id = 1 자동 생성

UserProfile profile = new UserProfile();
profile.setUser(user);  // 이 순간 profile.id도 1이 됨
profile.setBio("안녕하세요");

// org.hibernate.id.IdentityGenerator (간략화)
public class IdentityGenerator implements IdentifierGenerator {

    @Override
    public Object generate(SharedSessionContractImplementor session, Object object) {
        // IDENTITY 전략은 DB가 값을 생성하므로
        // INSERT 후 생성된 값을 가져옴
        return IdentifierGeneratorHelper.POST_INSERT_INDICATOR;
    }
}

// org.springframework.data.jpa.repository.support.SimpleJpaRepository
@Transactional
@Override
public <S extends T> S save(S entity) {

    Assert.notNull(entity, "Entity must not be null");

    if (entityInformation.isNew(entity)) {
        // 새 엔티티면 persist
        entityManager.persist(entity);
        return entity;
    } else {
        // 기존 엔티티면 merge
        return entityManager.merge(entity);
    }
}

// org.hibernate.internal.SessionImpl
@Override
public void persist(Object object) {
    checkOpen();
    firePersist(new PersistEvent(null, object, this));
}

private void firePersist(PersistEvent event) {
    // 이벤트 리스너에게 위임
    fastSessionServices.eventListenerGroup_PERSIST.fireEventOnEachListener(event, PersistEventListener::onPersist);
}

// org.hibernate.event.internal.DefaultPersistEventListener
@Override
public void onPersist(PersistEvent event) throws HibernateException {
    onPersist(event, IdentityHashMap.newInstance(10));
}

@Override
public void onPersist(PersistEvent event, PersistContext createdAlready) {
final Object object = event.getObject();

    // 엔티티 상태 확인
    final EntityEntry entityEntry = event.getSession()
        .getPersistenceContextInternal()
        .getEntry(object);

    EntityState entityState = EntityState.getEntityState(object, ...);

    switch (entityState) {
        case TRANSIENT:
            // 새 엔티티 → 저장 처리
            entityIsTransient(event, createdAlready);
            break;
        // ... 다른 상태들
    }
}

protected void entityIsTransient(PersistEvent event, PersistContext createdAlready) {
    // AbstractSaveEventListener의 메서드 호출
    saveWithGeneratedId(...);
}

// org.hibernate.event.internal.AbstractSaveEventListener
protected Object saveWithGeneratedId(Object entity, String entityName, Object anything,
EventSource source, boolean requiresImmediateIdAccess) {

    // 엔티티 메타데이터 가져오기
    EntityPersister persister = source.getEntityPersister(entityName, entity);

    // ★ ID 생성기 가져와서 ID 생성
    Object generatedId = persister.getIdentifierGenerator()
        .generate((SharedSessionContractImplementor) source, entity);

    // IDENTITY 전략인 경우 (POST_INSERT_INDICATOR 반환됨)
    if (generatedId == IdentifierGeneratorHelper.POST_INSERT_INDICATOR) {
        // INSERT 후 ID를 가져와야 함
        return performSaveWithId(entity, null, persister, ...);
    }

    // SEQUENCE, TABLE 전략인 경우 (이미 ID가 생성됨)
    return performSaveWithId(entity, generatedId, persister, ...);
}

// org.hibernate.id.IdentityGenerator
public class IdentityGenerator implements IdentifierGenerator {

    @Override
    public Object generate(SharedSessionContractImplementor session, Object object) {
        // DB가 ID를 생성하므로 "나중에 가져올게" 표시만 반환
        return IdentifierGeneratorHelper.POST_INSERT_INDICATOR;
    }
}

// org.hibernate.id.enhanced.SequenceStyleGenerator
public class SequenceStyleGenerator implements IdentifierGenerator {

    @Override
    public Object generate(SharedSessionContractImplementor session, Object object) {
        // DB 시퀀스에서 다음 값 조회
        // SELECT nextval('hibernate_sequence')
        return optimizer.generate(
            accessCallback  // 실제 시퀀스 호출
        );
    }
}

// org.hibernate.id.enhanced.TableGenerator
public class TableGenerator implements IdentifierGenerator {

    @Override
    public Object generate(SharedSessionContractImplementor session, Object object) {
        // 키 생성 테이블에서 값 조회 및 업데이트
        // SELECT, UPDATE 실행
        return optimizer.generate(accessCallback);
    }
}

// org.hibernate.id.insert.AbstractReturningDelegate
public Object performInsert(PreparedStatementDetails insertStatementDetails,
JdbcValueBindings jdbcValueBindings, Object entity, SharedSessionContractImplementor session) {

    // INSERT 실행
    session.getJdbcCoordinator()
        .getResultSetReturn()
        .executeUpdate(insertStatement);

    // DB에서 생성된 ID 조회
    // MySQL: SELECT LAST_INSERT_ID()
    // PostgreSQL: RETURNING id
    ResultSet rs = getInsertGeneratedIdentifierDelegate()
        .executeAndExtract(insertStatement, session);

    return rs.getLong(1);  // 생성된 ID 반환
}

// org.hibernate.event.internal.AbstractSaveEventListener
protected Object performSaveOrReplicate(Object entity, Object id, EntityPersister persister, ...) {

    // 생성된 ID를 엔티티에 설정
    persister.setIdentifier(entity, id, session);

    // 영속성 컨텍스트에 등록
    source.getPersistenceContextInternal()
        .addEntity(entity, Status.MANAGED, ...);
}

// org.hibernate.engine.spi.ActionQueue
public void addAction(EntityInsertAction action) {

    // ★ 핵심: ID 생성 방식 확인
    if (action.isEarlyInsert()) {
        // IDENTITY 전략 → 즉시 INSERT 실행해야 함
        executeInsertNow(action);
    } else {
        // SEQUENCE, TABLE → 나중에 batch로 모아서 실행 가능
        addToInsertQueue(action);
    }
}

// org.hibernate.action.internal.EntityInsertAction
public boolean isEarlyInsert() {
  // ID 생성기가 POST_INSERT 타입인지 확인
  return persister.getIdentifierGenerator() instanceof PostInsertIdentifierGenerator;
}

// org.hibernate.id.IdentityGenerator
public class IdentityGenerator implements PostInsertIdentifierGenerator {  // ← 이 인터페이스!

    // IDENTITY는 PostInsertIdentifierGenerator를 구현
    // = INSERT 후에야 ID를 알 수 있다는 의미
}

// org.hibernate.engine.jdbc.batch.internal.BatchBuilderImpl
public Batch buildBatch(BatchKey key, JdbcCoordinator jdbcCoordinator) {

    // IDENTITY 전략이면 batch size를 1로 강제
    if (isIdentityInsert(key)) {
        return new NonBatchingBatch(key, jdbcCoordinator);
    }

    // 다른 전략은 설정된 batch size 사용
    return new BatchingBatch(key, jdbcCoordinator, batchSize);
}

// org.hibernate.id.insert.AbstractReturningDelegate
public Object performInsert(...) {

    // IDENTITY: 각 INSERT마다 즉시 실행하고 ID 조회
    jdbcCoordinator.getResultSetReturn().executeUpdate(insertStatement);

    // 생성된 ID 즉시 조회 (이게 batch를 막는 원인)
    ResultSet rs = statement.getGeneratedKeys();
    return rs.getLong(1);
}

// org.hibernate.engine.internal.StatefulPersistenceContext
public void addEntity(EntityKey key, Object entity) {
    // ★ EntityKey 생성에 ID가 필수!
    // ID가 없으면 1차 캐시에 등록 자체가 불가능
    entitiesByKey.put(key, entity);
}

// org.hibernate.engine.spi.EntityKey
public EntityKey(Object id, EntityPersister persister) {
    this.identifier = id;  // ← ID가 반드시 있어야 함
    this.persister = persister;
}

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

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> items;
}

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

    @ManyToOne
    @JoinColumn(name = "order_id")
    private Order order;  // ← FK로 Order.id 필요!
}

// 저장 시
Order order = new Order();
OrderItem item1 = new OrderItem();
OrderItem item2 = new OrderItem();
order.addItem(item1);
order.addItem(item2);

entityManager.persist(order);

public class IdentityGenerator
implements PostInsertIdentifierGenerator,
BulkInsertionCapableIdentifierGenerator,  // ← 이게 있어서 bulk 가능?
StandardGenerator {

    public boolean referenceColumnsInSql(Dialect dialect) {
        return dialect.getIdentityColumnSupport().hasIdentityInsertKeyword();
    }

    public String[] getReferencedColumnValues(Dialect dialect) {
        return new String[]{dialect.getIdentityColumnSupport().getIdentityInsertString()};
    }

    // ... 나머지 코드
}

// org.hibernate.id.BulkInsertionCapableIdentifierGenerator
public interface BulkInsertionCapableIdentifierGenerator extends IdentifierGenerator {

    /**
     * SQL 구문에서 ID 컬럼을 참조해야 하는지?
     * (INSERT 구문에 ID 컬럼을 명시적으로 포함할지 여부)
     */
    boolean referenceColumnsInSql(Dialect dialect);

    /**
     * ID 컬럼에 들어갈 값 (키워드 등)
     * 예: Oracle의 "DEFAULT", SQL Server의 "DEFAULT" 등
     */
    String[] getReferencedColumnValues(Dialect dialect);
}

String hql = "INSERT INTO UserArchive (id, name, email) " +
"SELECT u.id, u.name, u.email FROM User u WHERE u.status = 'INACTIVE'";

entityManager.createQuery(hql).executeUpdate();

// IdentityGenerator
public boolean referenceColumnsInSql(Dialect dialect) {
    return dialect.getIdentityColumnSupport().hasIdentityInsertKeyword();
}

// 예: SQL Server의 IdentityColumnSupport
public class SQLServerIdentityColumnSupport extends IdentityColumnSupportImpl {

    @Override
    public boolean hasIdentityInsertKeyword() {
        return true;  // SQL Server는 IDENTITY_INSERT 키워드 있음
    }

    @Override
    public String getIdentityInsertString() {
        return "default";  // INSERT 시 'DEFAULT' 키워드 사용
    }
}

// MySQL의 경우
public class MySQLIdentityColumnSupport extends IdentityColumnSupportImpl {

    @Override
    public boolean hasIdentityInsertKeyword() {
        return false;  // MySQL은 없음
    }
}

// JDBC Batch - IDENTITY에서 불가
for (User u : users) {
em.persist(u);  // 개별 INSERT
}

// HQL Bulk - IDENTITY에서 가능 (BulkInsertionCapableIdentifierGenerator 덕분)
em.createQuery("INSERT INTO Archive SELECT u FROM User u").executeUpdate();