이 포스트는 김영한님의 "자바 ORM 표준 JPA 프로그래밍"을 참조하였음을 알립니다.

 

JPA를 사용하는 데 가장 중요한 일은 Entity와 Table을 정확히 매핑하는 것이다.

아래는 대표 어노테이션에 해당한다.

  • 객체와 테이블 매핑: @Entity, @Table
  • 기본 키 매핑: @Id
  • 필드와 컬럼 매핑: @Column 
  • 연관관계 매핑: @ManyToOne, @JoinColumn

 

📕 목차

1. @Entity
2. @Table
3. 다양한 매핑 사용
4. 데이터베이스 스키마 자동 생성
5. DDL(Data Definition Language) 생성 기능
6. 기본 키 매핑
    • 기본 키 직접 할당 전략
    • IDENTITY 전략
    • SEQUENCE 전략
    • TABLE 전략
    • AUTO 전략
    • 기본 키 매핑 정리
7. 필드와 컬럼 매핑: 레퍼런스
    • @Column
    • @Enumerated
    • @Temporal
    • @Lob
    • @Transient
    • @Access
8. 정리

1. @Entity

 

Table과 매핑할 도메인 클래스는 @Entity 어노테이션을 필수로 붙여야 한다.

해당 클래스는 JPA가 관리한다.

속성  기능 기본값
name • JPA에서 사용할 엔티티 이름을 지정한다.
• 보통 기본값인 클래스 이름을 사용한다.
• 만약 다른 패키지에 이름이 같은 엔티티 클래스가 있다면 충돌이 없도록 한다.		 설정하지 않으면 클래스 이름을 그대로 사용한다.

 

🙅‍♂️ 주의 사항
  • 기본 생성자는 필수 (파라미터가 없는 public 혹은 protected 생성자) → JPA가 사용
  • final 클래스, enum, interface, inner 클래스에는 사용할 수 없다.
  • 저장할 필드에 final을 사용하면 안 된다.

 

2. @Table

 

Entity와 매핑할 테이블을 명시한다.

생략하면 매핑한 엔티티 이름을 테이블 이름으로 사용한다.

 

속성  기능 기본값
name • 매핑할 테이블 이름 엔티티 이름 사용
catalog • catalog 기능이 있는 데이터베이스에서 catalog를 매핑한다.  
schema • schema 기능이 있는 데이터베이스에서 schema를 매핑한다.  
uniqueConstraints(DDL) • DDL 생성 시에 유니크 제약조건을 만든다.
• 2개 이상의 복합 유니크 제약조건도 만들 수 있다.
• 참고로 이 기능은 스키마 자동 생성 기능을 사용해서 DDL을 만들 때만 사용된다.		  

 

3. 다양한 매핑 사용

 

public enum RoleType {
    ADMIN, USER
}
@Entity
@Table(name="MEMBER")
public class Member {
    @Id @Column(name="MEMBER_ID")
    private String id;
    
    @Column(name="NAME")
    private String username;
    
    private Integer age;
    
    @Enumerated(EnumType.STRING)
    private RoleType roleType;
    
    @Temporal(TemporalType.TIMESTAMP)
    private Date createdDate;
    
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastModifiedDate;
    
    @Lob
    private String description;
    
    // getter, setter
}
  • roleType
    • 자바의 열거 타입을 사용해서 회원 타입을 구분한다.
    • 일반 회원은 USER, 관리자는 ADMIN이다.
    • 자바의 enum을 사용하려면 @Enumerated 어노테이션으로 매핑해야 한다.
  • createdDate, lastModifiedDate
    • 자바의 날짜 타입은 @Temporal을 사용하여 매핑한다.
  • description
    • 회원을 설명하는 필드는 길이 제한이 없다.
    • 데이터베이스의 VARCHAR 타입 대신에 CLOB 타입으로 저장해야 한다.
    • @Lob을 사용하면 CLOB, BLOB 타입을 매핑할 수 있다.

 

4. 데이터베이스 스키마 자동 생성

 

JPA는 데이터베이스 스키마를 자동으로 생성하는 기능을 제공한다.

클래스의 매핑 정보를 분석하여, 알아서 스키마를 생성하는데 당연히 설정을 해주어야 한다.

 

application.yml의 속성을 다음과 같이 정해주면된다.

spring:
  jpa:
    show-sql: true     # DDL 출력 
    hibernate:
      ddl-auto: create
  • show-sql : true로 지정하면 테이블 생성 DDL(Data Definition Language)을 콘솔에 출력시킬 수 있다.
  • ddl-auto : create 지정을 하면 애플리케이션 실행 시점에 데이터베이스 테이블을 자동으로 생성한다.

 

스키마 자동 생성 기능을 사용하면 개발자가 테이블을 직접 생성하는 수고를 덜 수는 있다.

하지만 자동 생성 기능이 만든 DDL은 운영 환경에서 사용할 만큼 완벽하지는 않으므로, 개발 환경에서 사용하거나 참고 정도로만 사용하는 것이 좋다.

 

옵션 설명
create 기존 테이블을 삭제하고 새로 생성한다.
DROP + CREATE
create-drop create 속성에 추가로 애플리케이션을 종료할 때 생성한 DDL을 제거한다.
DROP + CREATE + DROP
update 데이터베이스 테이블과 엔티티 매핑정보를 비교해서 변경 사항만 수정한다.
validate 데이터베이스 테이블과 엔티티 매핑정보를 비교해서 차이가 있으면 경고를 남기고, 애플리케이션을 실행하지 않는다. (이 설정은 DDL을 수정하지 않는다.)
none 자동 생성 기능을 사용하지 않는다.

JPA 2.1부터는 update, validate 옵션을 지원하지 않는다.

 

💡DDL 옵션 주의사항

create, create-drop, update는 로컬 환경에서만 사용해라.

  • 개발 초기 단계 : create, update
  • 초기화 상태로 자동화된 테스트 진행하는 개발자 환경과 CI 서버 : create, create-drop
  • 테스트 서버 : update, validate
  • 스테이징과 운영 서버 : validate 또는 none

 

운영 서버에서 create 옵션을 걸면 무슨 일이 벌어지는지 알 수 있다. ㅋㅋㅋㅋㅋㅋㅋㅋ

 

💡 이름 매핑 전략 변경하기
  • 자바 : Camel 표기법을 주로 사용
  • 데이터 베이스 : 구분자로 언더스코어(_)를 주로 사용
@Column(name="role_type") // 언더스코어로 구분
String roleType           // 카멜 표기법으로 구분

 

그런데 요샌 "ROLE_TYPE"으로 지정하면 알아서 고쳐준다.

spring:
  jpa:
      naming:
        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy

위는 따로 설정하지 않아도 기본으로 지정된 naming 전략에 해당한다.

해당 전략으로 인해 자동으로 lowerCamelCase를 lower_snake_case로 변환해준다.

 

 

5. DDL(Data Definition Language) 생성 기능

 

회원 이름은 필수로 입력되어야 하고, 10자를 초과하면 안 된다는 제약조건이 붙은 경우

@Column(name="NAME", nullable=false, length=10)
private String username;

속성을 추가하면 DDL에 제약 조건을 추가할 수 있다.

 

유니크 제약조건을 만들어 주는 @Table의 uniqueConstraints 속성도 다뤄보자.

@Table(name="MEMBER", uniqueConstraints = { @UniqueConstraint(
    name = "NAME_AGE_UNIQUE",
    columnNames = {"NAME", "AGE"})})
public class Member {
    @Id @COLUMN(NAME="id")
    private String id;
    
    @Column(name = "name")
    private String username;
    
    private Integer age;
    ...
}
ALTER TABLE MEMBER
    ADD CONSTRAINT NAME_AGE_UNIQUE UNIQUE (NAME, AGE)

 

💡 이런 기능들은 단지 DDL을 자동 생성할 때만 사용되고 JPA 실행 로직에는 영향을 주지 않는다.
      따라서 스키마 자동 생성 기능을 사용하지 않고 직접 DDL을 만들면 사용할 이유가 없다.

 

6. 기본 키 매핑

 

@Entity
@Table(name="MEMBER")
public class Member {
    @Id @Column(name="MEMBER_ID")
    private String id;
    ...
}

JPA가 제공하는 데이터베이스 기본 키 생성 전략은 다음과 같다.

  • 직접 할당
  • 자동 생성
    • IDENTITY: 기본 키 생성을 데이터베이스에 위임한다.
    • SEQUENCE: 데이터베이스 시퀀스를 사용해서 기본 키를 할당한다.
    • TABLE: 키 생성 테이블을 사용한다.

자동 생성 전략이 다양한 이유는 데이터베이스 벤더마다 지원 방식이 다르기 때문이다.

오라클은 시퀀스, MySQL은 AUTO_INCREMENT를 사용하므로 전략은 데이터베이스에 의존한다.

자동 생성 전략을 사용하려면  @GeneratedValue를 추가하고 키 생성 전략을 선택하면 된다.

 

📌 기본 키 직접 할당 전략

직접 할당은 @Id 애너테이션만 매핑하면 끝난다.

@Id 적용 가능 자바 타입은 다음과 같다.

  • 자바 기본현
  • 자바 래퍼형
  • String
  • java.util.Date
  • java.sql.Date
  • java.math.BigDecimal
  • java.math.BigInteger

이 방식을 사용하려면 Entity를 영속화하기 전에 애플리케이션에서 기본키를 직접 할당한다.

Member member = new Member();
member.setId("id1");
em.persist(member);

 

📌 IDENTITY 전략
  • 기본 키 생성을 데이터베이스에 위임한다.
  • 주로 MySQL, PostgreSQL, SQL Server, DB2에서 사용한다.
  • 예를 들어, MySQL과 연결되어 있다면 AUTO_INCREMENT 기능으로 기본 키를 자동 생성해준다.
CREATE TABLE MEMBER (
    ID INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    USERNAME VARCHAR(45)
);

INSERT INTO MEMBER(USERNAME) VALUES('유저1'); -- id 1인 유저1 생성
INSERT INTO MEMBER(USERNAME) VALUES('유저2'); -- id 2인 유저2 생성

위의 예제는 MySQL의 AUTO_INCREMENT 기능을 활용한 예시다.

해당 기능을 그대로 사용하려면 기본 키 전략을 다음과 같이 설정해주면 된다.

@Entity
@Table(name="MEMBER")
public class Member {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private String id;
    ...
}
private static void logic(EntityManager em) {
    Member member = new Member();
    em.persist(member);
    System.out.println(member.getId()); // 1
}
  • persist()로 Entity를 저장해 자동 생성된 기본 키 값을 출력
  • 데이터를 DB에 INSERT한 후 기본 키 값을 조회해야 하므로 JPA가 추가로 DB를 조회하는 과정 수반
  • JDBC3의 Statement.getGeneratedKeys()는 데이터 저장과 동시에 생성된 기본키 값을 얻어올 수 있다.

 

✒️ 쓰기 지연과 IDENTITY

이 부분에서 의문이 들 수 있는 점이 있다.
기본 키가 자동 할당되기 위해서는 DB에 반영이 되어야 하는데, 이전에 persist는 객체를 영속화하는 메서드지 transaction.commit()이 호출되는 시점은 아니다.
그렇다면 persist() 직후 getId()를 하면 null값이 나와야 하는 것이 당연한 것 아닌가?

사실 Entity가 영속 상태가 되려면 식별자가 반드시 필요하다.
그런데 IDENTITY 식별자 생성 전략은 Entity를 DB에 저장해야 식별자를 얻을 수 있으므로, persist()를 호출하는 즉시 INSERT SQL이 DB로 전달된다.
따라서, 이 전략은 트랜잭션을 지원하는 쓰기 지연이 동작하지 않는다.

 

📌 SEQUENCE 전략
  • 유일한 값을 순서대로 생성하는 특별한 데이터베이스 오브젝트다.
  • Oracle, PostgreSQL, DB2, H2 데이터베이스에서 사용한다.
CREATE TABLE MEMBER (
    ID BIGINT NOT NULL PRIMARY KEY,
    USERNAME VARCHAR(45)
)

-- Sequence 생성 및 초기화
CREATE SEQUENCE MEMBER_SEQ START WITH 1 INCREMENT BY 1;

그리고 위의 Sequence와 기본 키를 매핑해주면 된다.

@Entity
@Table(name="MEMBER")
@SequenceGenerator(
        name="MEMBER_SEQ_GENERATOR",
        sequenceName = "MEMBER_SEQ",
        initialValue = 1, allocationSize = 1)
public class Member {
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE,
                        generator = "MEMBER_SEQ_GENERATOR")
    private String id;
    ...
}
  • MEMBER_SEQ_GENERATOR라는 시퀀스 생성기를 등록했다.
  • JPA는 squenceName인 MEMBER_SEQ를 실제 데이터베이스의 MEMBER_SEQ와 매핑한다.
  • generator로 인해 id값은 MEMBER_SEQ_GENERATOR가 할당한다.
private static void logic(EntityManager em) {
    Member member = new Member();
    em.persist(member);
    System.out.println("member.id = " + member.getId()); // 1
}

IDENTITY와 비슷하지만, 내부 동작 방식에서 차이가 발생한다.

Entity를 DB에 저장하고 식별자를 조회하던 IDENTITY 방식과 달리 SEQUENCE 전략은 아래 순서를 따른다.

  1. em.persist() 호출 시, 먼저 데이터베이스를 사용해서 식별자를 조회한다.
  2. 조회한 식별자를 Entity에 할당한 후, Entity를 영속성 컨텍스트에 저장한다.
  3. 이후 트랜잭션 커밋 단계에서 플러시가 발생하면 Entity를 데이터베이스에 저장한다.

 

✒️ @SequenceGenerator

속성 기능 기본값
name 식별자 생성기 이름 필수
sequenceName 데이터베이스에 등록되어 있는 시퀀스 이름 hibernate_sequence
initialValue DDL 생성시에만 사용
시퀀스 DDL을 생성할 때 처음 시작하는 수		 1
allocationSize 시퀀스 한 번 호출에 증가하는 수 (성능 최적화) 50
catalog, schema 데이터베이스 catalog, schema 이름  
위의 속성은 아래 SQL에 매핑된다.
CREATE SEQUENCE [sequenceName]
START WITH [initialValue] INCREMENT BY [allocationSize]
더보기

✨ SEQUENCE 전략과 최적화

 

SEQUENCE 전략은 데이터베이스와 2번 통신한다.

  • 식별자를 구하기 위해 데이터베이스 조회
  • 조회한 시퀀스를 기본 키 값으로 데이터베이스에 저장

JPA에서 해당 시퀀스 접근 횟수를 줄이기 위해 @SequenceGenerator.allocationSize를 사용한다.

  1. allocationSize(기본값 50)만큼 한 번에 시퀀스 값을 증가시킨다.
  2. 1~50까지는 메모리에서 식별자를 할당한다.
  3. 51이 되면 시퀀스 값을 100으로 증가시켜 51~100까지 메모리에서 식별자를 할당한다.

이 방법은 JVM이 동시에 동작해도 기본 키 값이 충돌하지 않는다는 장점이 있지만,

데이터베이스에 직접 접근해서 데이터를 등록할 때 시퀀스 값이 한 번에 많이 증가한다는 점을 염두해야 한다.

INSERT 성능이 중요하지 않다면, allocationSize를 1로 설정하자.

 

📌 TABLE 전략
  • 키 생성 전용 테이블을 하나 만들어, 데이터베이스 시퀀스를 흉내내는 전략이다.
  • 모든 데이터베이스에서 사용가능하다.
CREATE TABLE MY_SEQUENCES(
    sequence_name VARCHAR(255) NOT NULL,
    next_val BIGINT,
    PRIMARY KEY (sequence_name)
)

자바에서 다음과 같이 매핑하면 된다.

@Entity
@Table(name="MEMBER")
@TableGenerator(
        name = "MEMBER_SEQ_GENERATOR",
        table = "MY_SEQUENCES",
        pkColumnValue = "MEMBER_SEQ", allocationSize = 1)
public class Member {
    @Id @GeneratedValue(strategy = GenerationType.TABLE,
                        generator = "MEMBER_SEQ_GENERATOR")
    private String id;
    ...
}
private static void logic(EntityManager em) {
    Member member = new Member();
    em.persist(member);
    System.out.println("member.id = " + member.getId()); // 1
}
  • SEQUENCE 전략과 내부 동작 방식이 같다.
  • 키 생성기를 사용할 때마다 next_val 컬럼 값이 증가한다.
  • MY_SEQUENCES 테이블에 값이 없으면 JPA가 값을 INSERT하면서 초기화하므로 미리 넣어둘 필요도 없다.

 

✒️ @TableGenerator

속성 기능 기본값
name 식별자 생성기 이름 필수
table 키 생성 테이블 명 hibernate_sequences
pkColumnName 시퀀스 컬럼명 sequence_name
valueColumnName 시퀀스 값 컬럼명 next_val
pkColumnValue 키로 사용할 값 이름 엔티티 이름
initialValue 초기 값, 마지막으로 생성된 값 기준 0
allocationSize 시퀀스 한 번 호출에 증가하는 수(성능 최적화) 50
catalog, schema 데이터베이스 catalog, schema 이름  
uniqueConstraints(DDL) 유니크 제약 조건 지정 가능  

 

📌 AUTO 전략
  • 선택한 데이터베이스 방언에 따라 IDENTITY, SEQUENCE, TABLE 전략 중 하나를 자동으로 선택한다.
  • @GeneratedValue 애너테이션 기본 값에 해당한다.
  • 데이터베이스를 변경해도 코드를 수정할 필요 없으므로, 개발 초기 단계나 프로토타입 개발 시 편리하다.

 

📌 기본 키 매핑 정리

데이터 베이스 기본 키 3가지 조건

  • null 값을 허용하지 않는다.
  • 유일하다.
  • 불변하다.

 

테이블 기본 키 선택 2가지 전략

  • 자연키(natural key)
    • 비지니스에 의미가 있는 키
    • 주민번호, 이메일, 전화번호 등
  • 대리키(surrogate key)
    • 비지니스와 관련 없는 임의의 키
    • 오라클 시퀀스, AUTO_INCREMENT, 키 생성 테이블

 

주의 사항

  • 자연 키보다는 대리키를 권장
    • 전화번호가 기본키 값으로 적합한가?
  • 비지니스 환경은 언젠가 변한다
    • 주민등록번호로 기본 키 값을 관리했는데, 법적으로 주민등록번호 저장이 금지됐다면?
  • JPA는 모든 Entity에 일관된 방식으로 대리 키 사용을 권장한다.

 

7. 필드와 컬럼 매핑: 레퍼런스

 

분류 매핑 어노테이션 설명
필드와 컬럼 매핑 @Column 컬럼 매핑
@Enumerated 자바의 enum 타입 매핑
@Temporal 날짜 타입 매핑
@Lob BLOB, CLOB 타입 매핑
@Transient 특정 필드를 데이터베이스에 매핑 안 함
기타 @Access JPA가 Entity에 접근하는 방식 지정

 

📌 @Column
속성 기능 기본값
name • 필드와 매핑할 테이블 컬럼 이름 객체의 필드 이름
insertable (거의 사용 안 함) • Entity 저장 시 해당 필드도 같이 저장
• false로 설정하면 이 필드는 DB에 저장 안 한다.
• false : 읽기 전용		 true
updatable (거의 사용 안 함) • Entity 수정 시 해당 필드도 같이 수정
• false면 DB 수정 안 함(읽기 전용)		 true
table (거의 사용 안 함) • 하나의 Entity를 두 개 이상의 테이블에 매핑할 때 사용
• 지정 필드를 다른 테이블에 매핑 가능		 현재 클래스가 매핑된 테이블
nullable(DDL) • null 값 허용 여부 설정
• false로 하면 DDL 생성 시 not null 제약 조건 붙음		 true
unique(DDL) • @Table의 uniqueConstraints와 같음
• 한 컬럼에만 간단히 제약조건 추가 시 사용
• 두 컬럼 이상 유니크 제약조건 추가 시 클래스 레벨에서 수행		  
columnDefinition(DDL) • 데이터베이스 컬럼 정보 직접 제공 가능 필드의 자바 타입과 방언 정보를 사용해서 적절한 컬럼 타입 생성
length(DDL) • 문자 길이 제약 조건, String 타입에만 사용 255
precision, scale(DDL) • BigDecimal 타입에서 사용 (BigInteger도 가능)
• 전체 자릿수(precision), 소수 자릿수(scale)
• double, float 타입에 적용되지 않는다.
• 아주 큰 수나 정밀한 소수를 다룰 때 사용 		 precision=19,
scale=2

 

✒️ Column 생략

대부분 기본 값이 적용되긴 하나, 기본 타입과 래퍼 타입에서 nullable 속성에 예외가 있다.
기본 타입 변수에 null을 할당할 수 없으므로 JPA는 @Column이 생략된 기본 타입 속성에는 not null 제약조건을 설정한다.
만약 기본 타입 변수에 @Column을 붙인다면 nullable=false로 지정하는 것이 안전하다.

 

📌 @Enumerated
속성 기능 기본값
value • EnumType.ORDINAL : 순서를 DB에 저장 
• EnumType.String : 이름을 DB에 저장		 EnumType.ORDINAL

 

예를 들어, 다음과 같다.

enum RoleType {
    ADMIN, USER
}
  • EnumType.ORDINAL → 자바 프로그래밍 원칙 상, 별로 좋지 않은 방법
    • enum에 정의된 순서대로 0(ADMIN), 1(USER)로 저장. enum의 ordinal() 메서드 사용.
    • pros: 데이터베이스에 저장되는 데이터 크기가 같다
    • cons: 이미 저장된 enum 순서를 더 이상 변경 불가능하다.
  • EnumType.STRING
    • 이름 그대로 ADMIN, USER라고 저장
    • pros: 저장된 enum 순서가 변경되거나, 추가되어도 안전하다
    • cons: DB에 저장되는 데이터 크기가 ORDINAL에 비해서 크다

 

📌 @Temporal

날짜 타입(java.util.Date, java.util.Calender)을 매핑할 때 사용

속성 기능 기본값
value • TemporalType.DATE: 날짜, 데이터베이스 date 타입과 매핑
• TemporalType.TIME: 시간, 데이터베이스 time 타입과 매핑
• TemporalType.TIMESTAMP: 날짜와 시간, 데이터베이스 timestamp 타입과 매핑		 TemporalType은 필수로 지정해야 함
  • @Temporal을 생략하면 자바의 Date와 가장 유사한 timestamp로 정의
  • datetime을 예약어로 사용하는 데이터베이스도 있으나, 데이터베이스 방언 덕분에 애플리케이션 코드 수정을 불필요
  • MySQL이 datetime을 예약어로 사용한다.

 

📌 @Lob
  • DB의 BLOB, CLOB 타입과 매핑
  • 지정할 수 있는 속성이 없다.
  • 매핑하는 필드 타입이 문자면 CLOB로 매핑, 나머지는 BLOB로 매핑한다.
    • CLOB: String, char[], java.sql.CLOB
    • BLOB: byte[], java.sql.BLOB

 

📌 @Transient
  • 해당 필드는 매핑하지 않는다.
  • 데이터베이스에 저장하지도, 조회하지도 않는다.
  • 객체에 임시로 어떤 값을 보관하고 싶을 때 사용한다.

 

📌 @Access

Access를 설정하지 않으면 @Id 위치를 기준으로 접근 방식이 결정된다.

@Entity
@Access(AccessType.FIELD)
public class Member {
    @Id
    private String id;
    
    private String data1;
    private String data2
    ...
}
  • 필드 접근
    • AccessType.FIELD
    • 필드에 직접 접근하며, private여도 접근 가능하다.
    • @Id가 필드에 있으므로 AccessType.FIELD와 동일하다. (생략 가능)
@Entity
@Access(AccessType.PROPERTY)
public class Member {
    private String id;
    
    private String data1;
    private String data2
    
    @Id public String getId() { return id; }
    @Column public String getDeta1() { return data1 }
    public String getDeta2() { return data2 }
}
  • 프로퍼티 접근
    • AccessType.PROPERTY
    • Getter를 사용하여 접근한다.
    • @Id가 프로퍼티에 있으므로 AccessType.PROPERTY와 동일 (생략 가능)

 

✒️ 필드, 프로퍼티 접근 함께 사용

@Entity
public class Member {
    @Id
    private String id;
    
    @Transient
    private String firstName;
    @Transient
    private String lastName;
    
    @Access(AccessType.PROPERTY)
    public String getFullName() {
        return firstName + lastName;
    }
    ...
}
  • 회원 Entity 저장하면 테이블에 FULLNAME(firstName + lastName) 결과가 저장된다.

 

저작자표시 비영리

티스토리툴바